change car.cpp collide.cpp differential.cpp sim.h simu.cpp of simuv3
git-svn-id: https://svn.code.sf.net/p/speed-dreams/code/trunk@586 30fe4595-0a0c-4342-8851-515496e4dcbd Former-commit-id: f52aece8ca4165c8d9c60cd3dda0c013ccc1fe01 Former-commit-id: 46a11bb67998e4399062bfcc4bc333ffc4dd9459
This commit is contained in:
torcs-ng
parent
c39f6e9030
commit
22aa5a78e7
5 changed files with 168 additions and 80 deletions
|
|
@ -4,7 +4,7 @@
|
|||
created : Sun Mar 19 00:05:43 CET 2000
|
||||
copyright : (C) 2000 by Eric Espie
|
||||
email : torcs@free.fr
|
||||
version : $Id: car.cpp,v 1.31 2007/12/14 12:45:43 olethros Exp $
|
||||
version : $Id: car.cpp,v 1.28 2007/12/01 11:52:15 olethros Exp $
|
||||
|
||||
***************************************************************************/
|
||||
|
||||
|
|
@ -19,11 +19,15 @@
|
|||
|
||||
|
||||
|
||||
#include <cstring>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "sim.h"
|
||||
|
||||
#undef TEST_ROTATION
|
||||
|
||||
const tdble aMax = 0.35; /* */
|
||||
|
||||
void
|
||||
SimCarConfig(tCar *car)
|
||||
{
|
||||
|
|
@ -51,17 +55,17 @@ SimCarConfig(tCar *car)
|
|||
car->carElt->priv.collision_state.force[0] = 0.0;
|
||||
}
|
||||
|
||||
car->dimension.x = GfParmGetNum(hdle, SECT_CAR, PRM_LEN, (char*)NULL, 4.7f);
|
||||
car->dimension.y = GfParmGetNum(hdle, SECT_CAR, PRM_WIDTH, (char*)NULL, 1.9f);
|
||||
car->dimension.x = GfParmGetNum(hdle, SECT_CAR, PRM_LEN, (char*)NULL, 4.7);
|
||||
car->dimension.y = GfParmGetNum(hdle, SECT_CAR, PRM_WIDTH, (char*)NULL, 1.9);
|
||||
overallwidth = GfParmGetNum(hdle, SECT_CAR, PRM_OVERALLWIDTH, (char*)NULL, car->dimension.y);
|
||||
car->dimension.z = GfParmGetNum(hdle, SECT_CAR, PRM_HEIGHT, (char*)NULL, 1.2f);
|
||||
car->dimension.z = GfParmGetNum(hdle, SECT_CAR, PRM_HEIGHT, (char*)NULL, 1.2);
|
||||
car->mass = GfParmGetNum(hdle, SECT_CAR, PRM_MASS, (char*)NULL, 1500);
|
||||
car->Minv = 1.0 / car->mass;
|
||||
gcfr = GfParmGetNum(hdle, SECT_CAR, PRM_FRWEIGHTREP, (char*)NULL, .5f);
|
||||
gcfrl = GfParmGetNum(hdle, SECT_CAR, PRM_FRLWEIGHTREP, (char*)NULL, .5f);
|
||||
gcrrl = GfParmGetNum(hdle, SECT_CAR, PRM_RRLWEIGHTREP, (char*)NULL, .5f);
|
||||
gcfr = GfParmGetNum(hdle, SECT_CAR, PRM_FRWEIGHTREP, (char*)NULL, .5);
|
||||
gcfrl = GfParmGetNum(hdle, SECT_CAR, PRM_FRLWEIGHTREP, (char*)NULL, .5);
|
||||
gcrrl = GfParmGetNum(hdle, SECT_CAR, PRM_RRLWEIGHTREP, (char*)NULL, .5);
|
||||
car->statGC.y = - (gcfr * gcfrl + (1 - gcfr) * gcrrl) * car->dimension.y + car->dimension.y / 2.0;
|
||||
car->statGC.z = GfParmGetNum(hdle, SECT_CAR, PRM_GCHEIGHT, (char*)NULL, .5f);
|
||||
car->statGC.z = GfParmGetNum(hdle, SECT_CAR, PRM_GCHEIGHT, (char*)NULL, .5);
|
||||
|
||||
car->tank = GfParmGetNum(hdle, SECT_CAR, PRM_TANK, (char*)NULL, 80);
|
||||
car->fuel = GfParmGetNum(hdle, SECT_CAR, PRM_FUEL, (char*)NULL, 80);
|
||||
|
|
@ -77,9 +81,9 @@ SimCarConfig(tCar *car)
|
|||
car->fuel = car->tank;
|
||||
}
|
||||
car->fuel_prev = car->fuel;
|
||||
k = k * k;
|
||||
car->Iinv.x = 12.0 / (car->mass * (car->dimension.y * car->dimension.y + k *car->dimension.z * car->dimension.z));
|
||||
car->Iinv.y = 12.0 / (car->mass * (car->dimension.x * car->dimension.x + k * car->dimension.z * car->dimension.z));
|
||||
k = k * k;
|
||||
car->Iinv.x = 12.0 / (car->mass * (car->dimension.y * car->dimension.y + car->dimension.z * car->dimension.z));
|
||||
car->Iinv.y = 12.0 / (car->mass * (car->dimension.x * car->dimension.x + car->dimension.z * car->dimension.z));
|
||||
car->Iinv.z = 12.0 / (car->mass * (car->dimension.y * car->dimension.y + k * car->dimension.x * car->dimension.x));
|
||||
|
||||
// initialise rotational momentum
|
||||
|
|
@ -87,7 +91,6 @@ SimCarConfig(tCar *car)
|
|||
car->rot_mom[i] = 0.0;
|
||||
}
|
||||
car->rot_mom[SG_W] = 1.0;
|
||||
|
||||
/* configure components */
|
||||
w = car->mass * G;
|
||||
|
||||
|
|
@ -173,12 +176,28 @@ SimCarUpdateForces(tCar *car)
|
|||
minv = 1.0 / m;
|
||||
w = -m * G;
|
||||
|
||||
/* Weight - Bring weight vector to the car's frame of reference */
|
||||
sgVec3 pos = {0.0f, 0.0f, w};
|
||||
sgRotateVecQuat (pos, car->posQuat);
|
||||
F.F.x = pos[SG_X];
|
||||
F.F.y = pos[SG_Y];
|
||||
F.F.z = pos[SG_Z];
|
||||
/* Weight - Bring weight vector to the car's frame of reference*/
|
||||
if (0) {
|
||||
t3Dd original;
|
||||
t3Dd updated;
|
||||
t3Dd angles;
|
||||
original.x = 0.0;
|
||||
original.y = 0.0;
|
||||
original.z = w;
|
||||
angles.x = car->DynGCg.pos.ax;
|
||||
angles.y = car->DynGCg.pos.ay;
|
||||
angles.z = car->DynGCg.pos.az;
|
||||
NaiveRotate (original, angles, &updated);
|
||||
F.F.x = updated.x;
|
||||
F.F.y = updated.y;
|
||||
F.F.z = updated.z;
|
||||
} else {
|
||||
sgVec3 pos = {0.0f, 0.0f, w};
|
||||
sgRotateVecQuat (pos, car->posQuat);
|
||||
F.F.x = pos[SG_X];
|
||||
F.F.y = pos[SG_Y];
|
||||
F.F.z = pos[SG_Z];
|
||||
}
|
||||
|
||||
// initial torque 0.
|
||||
F.M.x = F.M.y = F.M.z = 0;
|
||||
|
|
@ -300,12 +319,13 @@ SimCarUpdateSpeed(tCar *car)
|
|||
t3Dd original;
|
||||
t3Dd updated;
|
||||
t3Dd angles;
|
||||
int i;
|
||||
tdble mass;
|
||||
tdble vel, Rr, Rm; /* Rolling Resistance */
|
||||
|
||||
mass = car->mass + car->fuel;
|
||||
|
||||
|
||||
{
|
||||
// fuel consumption
|
||||
tdble delta_fuel = car->fuel_prev - car->fuel;
|
||||
car->fuel_prev = car->fuel;
|
||||
if (delta_fuel > 0) {
|
||||
|
|
@ -314,28 +334,51 @@ SimCarUpdateSpeed(tCar *car)
|
|||
tdble fi;
|
||||
tdble as = sqrt(car->airSpeed2);
|
||||
if (as<0.1) {
|
||||
fi = 99.9f;
|
||||
fi = 99.9;
|
||||
} else {
|
||||
fi = 100000 * delta_fuel / (as*SimDeltaTime);
|
||||
}
|
||||
tdble alpha = 0.1f;
|
||||
tdble alpha = 0.1;
|
||||
car->carElt->_fuelInstant = (1.0-alpha)*car->carElt->_fuelInstant + alpha*fi;
|
||||
}
|
||||
|
||||
// update angles
|
||||
angles.x = car->DynGCg.pos.ax;
|
||||
angles.y = car->DynGCg.pos.ay;
|
||||
angles.z = car->DynGCg.pos.az;
|
||||
|
||||
// update linear velocity
|
||||
|
||||
|
||||
car->DynGCg.vel.x += car->DynGCg.acc.x * SimDeltaTime;
|
||||
car->DynGCg.vel.y += car->DynGCg.acc.y * SimDeltaTime;
|
||||
car->DynGCg.vel.z += car->DynGCg.acc.z * SimDeltaTime;
|
||||
|
||||
if (0) {
|
||||
Rr = 0;
|
||||
for (i = 0; i < 4; i++) {
|
||||
Rr += car->wheel[i].rollRes;
|
||||
}
|
||||
|
||||
Rm = Rr * car->wheelbase /* / 2.0 */ * car->Iinv.z * SimDeltaTime;
|
||||
Rr = 2.0 * Rr / mass * SimDeltaTime;
|
||||
vel = sqrt(car->DynGCg.vel.x * car->DynGCg.vel.x + car->DynGCg.vel.y * car->DynGCg.vel.y + car->DynGCg.vel.z * car->DynGCg.vel.z);
|
||||
|
||||
if (Rr > vel) {
|
||||
Rr = vel;
|
||||
}
|
||||
if (vel > 0.00001) {
|
||||
car->DynGCg.vel.x -= (car->DynGCg.vel.x) * Rr / vel;
|
||||
car->DynGCg.vel.y -= (car->DynGCg.vel.y) * Rr / vel;
|
||||
car->DynGCg.vel.z -= (car->DynGCg.vel.z) * Rr / vel;
|
||||
} else {
|
||||
car->DynGCg.vel.x -= (car->DynGCg.vel.x) * Rr; // vel;
|
||||
car->DynGCg.vel.y -= (car->DynGCg.vel.y) * Rr; // vel;
|
||||
car->DynGCg.vel.z -= (car->DynGCg.vel.z) * Rr; // vel;
|
||||
}
|
||||
}
|
||||
|
||||
/* We need to get the speed on the actual frame of reference
|
||||
for the car. Now we don't need to worry about the world's
|
||||
coordinates anymore when we calculate stuff. I.E check
|
||||
aero.cpp*/
|
||||
|
||||
original.x = car->DynGCg.vel.x;
|
||||
original.y = car->DynGCg.vel.y;
|
||||
original.z = car->DynGCg.vel.z;
|
||||
|
|
@ -345,25 +388,25 @@ SimCarUpdateSpeed(tCar *car)
|
|||
car->DynGC.vel.z = updated.z;
|
||||
|
||||
|
||||
// Update angular momentum
|
||||
|
||||
// ANGULAR VELOCITIES
|
||||
|
||||
car->rot_mom[SG_X] -= car->rot_acc[0] * SimDeltaTime;
|
||||
car->rot_mom[SG_Y] -= car->rot_acc[1] * SimDeltaTime;
|
||||
car->rot_mom[SG_Z] -= car->rot_acc[2] * SimDeltaTime;
|
||||
|
||||
#if 0
|
||||
// spin limitation
|
||||
if (Rm > fabs(car->rot_mom[SG_Z])) {
|
||||
Rm = fabs(car->rot_mom[SG_Z]);
|
||||
}
|
||||
car->rot_mom[SG_Z] -= Rm * SIGN(car->rot_mom[SG_Z]);
|
||||
#endif
|
||||
|
||||
// Translate angular momentum to angular velocity
|
||||
// NOTE: This translation is done again in SimCarAddAngularVelocity()
|
||||
car->DynGCg.vel.ax = car->DynGC.vel.ax = -2.0f*car->rot_mom[SG_X] * car->Iinv.x;
|
||||
car->DynGCg.vel.ay = car->DynGC.vel.ay = -2.0f*car->rot_mom[SG_Y] * car->Iinv.y;
|
||||
car->DynGCg.vel.az = car->DynGC.vel.az = -2.0f*car->rot_mom[SG_Z] * car->Iinv.z;
|
||||
|
||||
//printf ("%f %f\n", car->DynGC.vel.az, -2.0f * car->rot_mom[SG_Z] * car->Iinv.z);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -372,6 +415,7 @@ SimCarUpdateWheelPos(tCar *car)
|
|||
tdble vx = car->DynGC.vel.x;
|
||||
tdble vy = car->DynGC.vel.y;
|
||||
tdble vz = car->DynGC.vel.z;
|
||||
//sgQuat* Q = &car->posQuat;
|
||||
|
||||
/* Wheels data */
|
||||
for (int i = 0; i < 4; i++) {
|
||||
|
|
@ -388,13 +432,24 @@ SimCarUpdateWheelPos(tCar *car)
|
|||
pos3[SG_Y] = wheel->staticPos.y;
|
||||
pos3[SG_Z] = -car->statGC.z;
|
||||
|
||||
|
||||
|
||||
#if 0
|
||||
angles.x = car->DynGCg.pos.ax;
|
||||
angles.y = car->DynGCg.pos.ay;
|
||||
angles.z = car->DynGCg.pos.az;
|
||||
NaiveInverseRotate (pos, angles, &wheel->pos);
|
||||
wheel->pos.x += car->DynGC.pos.x;
|
||||
wheel->pos.y += car->DynGC.pos.y;
|
||||
wheel->pos.z += car->DynGC.pos.z;
|
||||
#else
|
||||
sgRotateCoordQuat (pos3, car->posQuat);
|
||||
wheel->pos.x = pos3[SG_X] + car->DynGC.pos.x;
|
||||
wheel->pos.y = pos3[SG_Y] + car->DynGC.pos.y;
|
||||
wheel->pos.z = pos3[SG_Z] + car->DynGC.pos.z;
|
||||
#endif
|
||||
|
||||
|
||||
// these two will be taken into account in wheel.cpp
|
||||
// these will be taken into account in wheel.cpp
|
||||
// angles.x += wheel->relPos.ax;
|
||||
// angles.z += wheel->steer + wheel->staticPos.az;
|
||||
|
||||
|
|
@ -415,26 +470,33 @@ SimCarUpdateWheelPos(tCar *car)
|
|||
static void
|
||||
SimCarUpdatePos(tCar *car)
|
||||
{
|
||||
tdble vx, vy, vz;
|
||||
tdble vx, vy;
|
||||
tdble accx, accy;
|
||||
|
||||
vx = car->DynGCg.vel.x;
|
||||
vy = car->DynGCg.vel.y;
|
||||
vz = car->DynGCg.vel.z;
|
||||
|
||||
accx = car->DynGCg.acc.x;
|
||||
accy = car->DynGCg.acc.y;
|
||||
|
||||
car->DynGCg.pos.x = car->DynGC.pos.x;
|
||||
car->DynGCg.pos.y = car->DynGC.pos.y;
|
||||
car->DynGCg.pos.z = car->DynGC.pos.z;
|
||||
|
||||
car->DynGCg.pos.x += vx * SimDeltaTime;
|
||||
car->DynGCg.pos.y += vy * SimDeltaTime;
|
||||
car->DynGCg.pos.z += vz * SimDeltaTime;
|
||||
car->DynGCg.pos.z += car->DynGCg.vel.z * SimDeltaTime;
|
||||
|
||||
car->DynGC.pos.x = car->DynGCg.pos.x;
|
||||
car->DynGC.pos.y = car->DynGCg.pos.y;
|
||||
car->DynGC.pos.z = car->DynGCg.pos.z;
|
||||
|
||||
|
||||
//zyx works ok for x rotation
|
||||
|
||||
SimCarAddAngularVelocity(car);
|
||||
|
||||
|
||||
NORM_PI_PI(car->DynGC.pos.ax);
|
||||
NORM_PI_PI(car->DynGC.pos.ay);
|
||||
NORM_PI_PI(car->DynGC.pos.az);
|
||||
|
|
@ -454,16 +516,31 @@ SimCarUpdateCornerPos(tCar *car)
|
|||
tdble vz = car->DynGC.vel.z;
|
||||
int i;
|
||||
|
||||
#if 0
|
||||
t3Dd angles;
|
||||
angles.x = car->DynGCg.pos.ax;
|
||||
angles.y = car->DynGCg.pos.ay;
|
||||
angles.z = car->DynGCg.pos.az;
|
||||
#endif
|
||||
for (i = 0; i < 4; i++) {
|
||||
|
||||
tDynPt *corner = &(car->corner[i]);
|
||||
#if 0
|
||||
pos.x = corner->pos.x;
|
||||
pos.y = corner->pos.y;
|
||||
pos.z = -car->statGC.z;
|
||||
|
||||
NaiveInverseRotate (pos, angles, &pos);
|
||||
corner->pos.ax = car->DynGCg.pos.x + pos.x;
|
||||
corner->pos.ay = car->DynGCg.pos.y + pos.y;
|
||||
corner->pos.az = car->DynGCg.pos.z + pos.z;
|
||||
#else
|
||||
sgVec3 v = {corner->pos.x, corner->pos.y, -car->statGC.z};
|
||||
sgRotateCoordQuat (v, car->posQuat);
|
||||
corner->pos.ax = car->DynGCg.pos.x + v[SG_X];
|
||||
corner->pos.ay = car->DynGCg.pos.y + v[SG_Y];
|
||||
corner->pos.az = car->DynGCg.pos.z + v[SG_Z];
|
||||
|
||||
#endif
|
||||
// the following is local - confusing a bit.. vel local is
|
||||
// .ax, global is .x contrary to pos [was like that in previous code,
|
||||
// might redo it when I have time to look through all
|
||||
|
|
@ -475,11 +552,22 @@ SimCarUpdateCornerPos(tCar *car)
|
|||
|
||||
|
||||
// calculate global frame velocity.
|
||||
#if 0
|
||||
t3Dd vel;
|
||||
vel.x = corner->vel.ax;
|
||||
vel.y = corner->vel.ay;
|
||||
vel.z = corner->vel.az;
|
||||
NaiveInverseRotate (vel, angles, &vel);
|
||||
corner->vel.x = car->DynGCg.vel.x + vel.x;
|
||||
corner->vel.y = car->DynGCg.vel.y + vel.y;
|
||||
corner->vel.z = car->DynGCg.vel.z + vel.z;
|
||||
#else
|
||||
sgVec3 vel = {corner->vel.ax, corner->vel.ay, corner->vel.az};
|
||||
sgRotateCoordQuat (vel, car->posQuat);
|
||||
corner->vel.x = car->DynGCg.vel.x + vel[SG_X];
|
||||
corner->vel.y = car->DynGCg.vel.y + vel[SG_Y];
|
||||
corner->vel.z = car->DynGCg.vel.z + vel[SG_Z];
|
||||
#endif
|
||||
|
||||
// don't forget to add local frame velocity.
|
||||
corner->vel.ax += vx;
|
||||
|
|
@ -492,8 +580,9 @@ SimCarUpdateCornerPos(tCar *car)
|
|||
void
|
||||
SimTelemetryOut(tCar *car)
|
||||
{
|
||||
tdble Fzf, Fzr;
|
||||
int i;
|
||||
tdble Fzf, Fzr;
|
||||
#if 0
|
||||
printf("-----------------------------\nCar: %d %s ---\n", car->carElt->index, car->carElt->_name);
|
||||
printf("Seg: %d (%s) Ts:%f Tr:%f\n",
|
||||
car->trkPos.seg->id, car->trkPos.seg->name, car->trkPos.toStart, car->trkPos.toRight);
|
||||
|
|
@ -515,6 +604,7 @@ SimTelemetryOut(tCar *car)
|
|||
Fzr = (car->aero.lift[1] + car->wing[1].forces.z) / 9.81;
|
||||
printf("%f %f %f %f %f\n", car->aero.drag / 9.81, Fzf + Fzr,
|
||||
Fzf, Fzr, (Fzf + Fzr) / (car->aero.drag + 0.1) * 9.81);
|
||||
#endif
|
||||
// for (i=0; i<4; i++) {
|
||||
// printf ("%f ", car->wheel[i].spinVel);
|
||||
//}
|
||||
|
|
@ -542,11 +632,9 @@ SimCarUpdate(tCar *car, tSituation * /* s */)
|
|||
void
|
||||
SimCarUpdate2(tCar *car, tSituation * /* s */)
|
||||
{
|
||||
#if 0
|
||||
if (SimTelemetry == car->carElt->index) SimTelemetryOut(car);
|
||||
|
||||
static int cnt = 10;
|
||||
|
||||
if (SimTelemetry == car->carElt->index) SimTelemetryOut(car);
|
||||
#if 0
|
||||
cnt--;
|
||||
if (cnt<=0) {
|
||||
|
||||
|
|
|
|||
|
|
@ -224,9 +224,9 @@ SimCarCollideZ(tCar *car)
|
|||
car->rot_mom[i] = 2.0*car->mass * SIGN(car->rot_mom[i]);
|
||||
}
|
||||
}
|
||||
car->rot_mom[SG_X]*=.999f;
|
||||
car->rot_mom[SG_Y]*=.999f;
|
||||
car->rot_mom[SG_Z]*=.999f;
|
||||
car->rot_mom[SG_X]*=.999;
|
||||
car->rot_mom[SG_Y]*=.999;
|
||||
car->rot_mom[SG_Z]*=.999;
|
||||
car->DynGC.vel.ax = car->DynGCg.vel.ax = -2.0f*car->rot_mom[SG_X] * car->Iinv.x;
|
||||
car->DynGC.vel.ay = car->DynGCg.vel.ay = -2.0f*car->rot_mom[SG_Y] * car->Iinv.y;
|
||||
car->DynGC.vel.az = car->DynGCg.vel.az = -2.0f*car->rot_mom[SG_Z] * car->Iinv.z;
|
||||
|
|
|
|||
|
|
@ -20,19 +20,19 @@
|
|||
#include "sim.h"
|
||||
|
||||
void
|
||||
SimDifferentialConfig(void *hdle, const char *section, tDifferential *differential)
|
||||
SimDifferentialConfig(void *hdle, char *section, tDifferential *differential)
|
||||
{
|
||||
const char *type;
|
||||
char *type;
|
||||
|
||||
differential->I = GfParmGetNum(hdle, section, PRM_INERTIA, (char*)NULL, 0.1f);
|
||||
differential->efficiency = GfParmGetNum(hdle, section, PRM_EFFICIENCY, (char*)NULL, 1.0f);
|
||||
differential->ratio = GfParmGetNum(hdle, section, PRM_RATIO, (char*)NULL, 1.0f);
|
||||
differential->bias = GfParmGetNum(hdle, section, PRM_BIAS, (char*)NULL, 0.1f);
|
||||
differential->dTqMin = GfParmGetNum(hdle, section, PRM_MIN_TQ_BIAS, (char*)NULL, 0.05f);
|
||||
differential->dTqMax = GfParmGetNum(hdle, section, PRM_MAX_TQ_BIAS, (char*)NULL, 0.80f) - differential->dTqMin;
|
||||
differential->dSlipMax = GfParmGetNum(hdle, section, PRM_MAX_SLIP_BIAS, (char*)NULL, 0.75f);
|
||||
differential->lockInputTq = GfParmGetNum(hdle, section, PRM_LOCKING_TQ, (char*)NULL, 300.0f);
|
||||
differential->viscosity = GfParmGetNum(hdle, section, PRM_VISCOSITY_FACTOR, (char*)NULL, 2.0f);
|
||||
differential->I = GfParmGetNum(hdle, section, PRM_INERTIA, (char*)NULL, 0.1);
|
||||
differential->efficiency = GfParmGetNum(hdle, section, PRM_EFFICIENCY, (char*)NULL, 1.0);
|
||||
differential->ratio = GfParmGetNum(hdle, section, PRM_RATIO, (char*)NULL, 1.0);
|
||||
differential->bias = GfParmGetNum(hdle, section, PRM_BIAS, (char*)NULL, 0.1);
|
||||
differential->dTqMin = GfParmGetNum(hdle, section, PRM_MIN_TQ_BIAS, (char*)NULL, 0.05);
|
||||
differential->dTqMax = GfParmGetNum(hdle, section, PRM_MAX_TQ_BIAS, (char*)NULL, 0.80) - differential->dTqMin;
|
||||
differential->dSlipMax = GfParmGetNum(hdle, section, PRM_MAX_SLIP_BIAS, (char*)NULL, 0.75);
|
||||
differential->lockInputTq = GfParmGetNum(hdle, section, PRM_LOCKING_TQ, (char*)NULL, 300.0);
|
||||
differential->viscosity = GfParmGetNum(hdle, section, PRM_VISCOSITY_FACTOR, (char*)NULL, 2.0);
|
||||
differential->viscomax = 1 - exp(-differential->viscosity);
|
||||
|
||||
type = GfParmGetStr(hdle, section, PRM_TYPE, VAL_DIFF_NONE);
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#ifdef WIN32
|
||||
#include <float.h>
|
||||
#define isnan _isnan
|
||||
|
|
|
|||
|
|
@ -84,22 +84,22 @@ ctrlCheck(tCar *car)
|
|||
|
||||
/* When the car is broken try to send it on the track side */
|
||||
if (car->carElt->_state & RM_CAR_STATE_BROKEN) {
|
||||
car->ctrl->accelCmd = 0.0f;
|
||||
car->ctrl->brakeCmd = 0.1f;
|
||||
car->ctrl->accelCmd = 0.0;
|
||||
car->ctrl->brakeCmd = 0.1;
|
||||
car->ctrl->gear = 0;
|
||||
if (car->trkPos.toRight > car->trkPos.seg->width / 2.0) {
|
||||
car->ctrl->steer = 0.1f;
|
||||
car->ctrl->steer = 0.1;
|
||||
} else {
|
||||
car->ctrl->steer = -0.1f;
|
||||
car->ctrl->steer = -0.1;
|
||||
}
|
||||
} else if (car->carElt->_state & RM_CAR_STATE_ELIMINATED) {
|
||||
car->ctrl->accelCmd = 0.0f;
|
||||
car->ctrl->brakeCmd = 0.1f;
|
||||
car->ctrl->accelCmd = 0.0;
|
||||
car->ctrl->brakeCmd = 0.1;
|
||||
car->ctrl->gear = 0;
|
||||
if (car->trkPos.toRight > car->trkPos.seg->width / 2.0) {
|
||||
car->ctrl->steer = 0.1f;
|
||||
car->ctrl->steer = 0.1;
|
||||
} else {
|
||||
car->ctrl->steer = -0.1f;
|
||||
car->ctrl->steer = -0.1;
|
||||
}
|
||||
} else if (car->carElt->_state & RM_CAR_STATE_FINISH) {
|
||||
/* when the finish line is passed, continue at "slow" pace */
|
||||
|
|
@ -111,24 +111,24 @@ ctrlCheck(tCar *car)
|
|||
|
||||
/* check boundaries */
|
||||
if (car->ctrl->accelCmd > 1.0) {
|
||||
car->ctrl->accelCmd = 1.0f;
|
||||
car->ctrl->accelCmd = 1.0;
|
||||
} else if (car->ctrl->accelCmd < 0.0) {
|
||||
car->ctrl->accelCmd = 0.0f;
|
||||
car->ctrl->accelCmd = 0.0;
|
||||
}
|
||||
if (car->ctrl->brakeCmd > 1.0) {
|
||||
car->ctrl->brakeCmd = 1.0f;
|
||||
car->ctrl->brakeCmd = 1.0;
|
||||
} else if (car->ctrl->brakeCmd < 0.0) {
|
||||
car->ctrl->brakeCmd = 0.0;
|
||||
}
|
||||
if (car->ctrl->clutchCmd > 1.0) {
|
||||
car->ctrl->clutchCmd = 1.0f;
|
||||
car->ctrl->clutchCmd = 1.0;
|
||||
} else if (car->ctrl->clutchCmd < 0.0) {
|
||||
car->ctrl->clutchCmd = 0.0f;
|
||||
car->ctrl->clutchCmd = 0.0;
|
||||
}
|
||||
if (car->ctrl->steer > 1.0) {
|
||||
car->ctrl->steer = 1.0f;
|
||||
car->ctrl->steer = 1.0;
|
||||
} else if (car->ctrl->steer < -1.0) {
|
||||
car->ctrl->steer = -1.0f;
|
||||
car->ctrl->steer = -1.0;
|
||||
}
|
||||
|
||||
clutch->transferValue = 1.0 - car->ctrl->clutchCmd;
|
||||
|
|
@ -175,15 +175,15 @@ SimReConfig(tCarElt *carElt)
|
|||
}
|
||||
if (carElt->pitcmd.repair > 0) {
|
||||
for (int i=0; i<4; i++) {
|
||||
carElt->_tyreCondition(i) = 1.01f;
|
||||
carElt->_tyreT_in(i) = 50.0f;
|
||||
carElt->_tyreT_mid(i) = 50.0f;
|
||||
carElt->_tyreT_out(i) = 50.0f;
|
||||
carElt->_tyreCondition(i) = 1.01;
|
||||
carElt->_tyreT_in(i) = 50.0;
|
||||
carElt->_tyreT_mid(i) = 50.0;
|
||||
carElt->_tyreT_out(i) = 50.0;
|
||||
car->wheel[i].bent_damage_x = urandom();
|
||||
car->wheel[i].bent_damage_z = urandom();
|
||||
car->wheel[i].rotational_damage_x = 0.0f;
|
||||
car->wheel[i].rotational_damage_z = 0.0f;
|
||||
car->wheel[i].susp.damper.efficiency = 1.0f;
|
||||
car->wheel[i].rotational_damage_x = 0.0;
|
||||
car->wheel[i].rotational_damage_z = 0.0;
|
||||
car->wheel[i].susp.damper.efficiency = 1.0;
|
||||
}
|
||||
|
||||
// (no need to repair wings because effect depends on damage).
|
||||
|
|
@ -479,8 +479,8 @@ SimShutdown(void)
|
|||
{
|
||||
tCar *car;
|
||||
int ncar;
|
||||
#if 0
|
||||
double elapsed_time = GfTimeClock() - simu_init_time;
|
||||
#if 0
|
||||
printf ("delta_time: %f\n", SimDeltaTime);
|
||||
printf ("simu time: %fs (%f%% of %fs)\n", simu_total_time,
|
||||
100.0f * simu_total_time/elapsed_time, elapsed_time);
|
||||
|
|
|
|||
Loading…
Reference in a new issue