~mulder-nebulon/openracing/cleaned

« back to all changes in this revision

Viewing changes to src/libsimulator/simuv2/simu.cpp

  • Committer: Nagy Imre
  • Date: 2009-04-04 06:54:16 UTC
  • Revision ID: mulder@codenode-20090404065416-ybb5akhb6im7b0x6
Almost ok, but in Z-180, it rotates backwards

Show diffs side-by-side

added added

removed removed

Lines of Context:
144
144
    fprintf(stderr, "C++ laps 4156 ?= %d\n", carElt->race.laps);
145
145
    fprintf(stderr, "C++ -4 ?= %d\n", (long)&carElt->pub.corner[3].az - (long)&carElt->race.bestLapTime);
146
146
#endif
147
 
printf("SC-1\n");
148
147
    SimCarConfig(car);
149
 
printf("SC-2\n");
150
 
 
151
148
    SimCarCollideConfig(car, track);
152
 
printf("SC-3\n");
153
149
    sgMakeCoordMat4(carElt->pub.posMat, carElt->_pos_X, carElt->_pos_Y, carElt->_pos_Z - carElt->_statGC_z, RAD2DEG(carElt->_yaw), RAD2DEG(carElt->_roll), RAD2DEG(carElt->_pitch));
154
 
printf("SC-4\n");
155
150
}
156
151
 
157
152
/* After pit stop */
173
168
static void
174
169
RemoveCar(tCar *car, tSituation *s)
175
170
{
176
 
    return; // JEKO: We do not need this! (it just handle removing cars from race)
177
 
        int i;
178
 
        tCarElt *carElt;
179
 
        tTrkLocPos trkPos;
180
 
        int trkFlag;
181
 
        tdble travelTime;
182
 
        tdble dang;
183
 
 
184
 
        static tdble PULL_Z_OFFSET = 3.0;
185
 
        static tdble PULL_SPD = 0.5;
186
 
 
187
 
        carElt = car->carElt;
188
 
 
189
 
        if (carElt->_state & RM_CAR_STATE_PULLUP) {
190
 
                carElt->_pos_Z += car->restPos.vel.z * SimDeltaTime;
191
 
                carElt->_yaw += car->restPos.vel.az * SimDeltaTime;
192
 
                carElt->_roll += car->restPos.vel.ax * SimDeltaTime;
193
 
                carElt->_pitch += car->restPos.vel.ay * SimDeltaTime;
194
 
                sgMakeCoordMat4(carElt->pub.posMat, carElt->_pos_X, carElt->_pos_Y, carElt->_pos_Z - carElt->_statGC_z,
195
 
                        RAD2DEG(carElt->_yaw), RAD2DEG(carElt->_roll), RAD2DEG(carElt->_pitch));
196
 
 
197
 
                if (carElt->_pos_Z > (car->restPos.pos.z + PULL_Z_OFFSET)) {
198
 
                        carElt->_state &= ~RM_CAR_STATE_PULLUP;
199
 
                        carElt->_state |= RM_CAR_STATE_PULLSIDE;
200
 
 
201
 
                        // Moved pullside velocity computation down due to floating point error accumulation.
202
 
                }
203
 
                return;
204
 
        }
205
 
 
206
 
 
207
 
        if (carElt->_state & RM_CAR_STATE_PULLSIDE) {
208
 
                // Recompute speed to avoid missing the parking point due to error accumulation (the pos might be
209
 
                // in the 0-10000 range, depending on the track and vel*dt is around 0-0.001, so basically all
210
 
                // but the most significant digits are lost under bad conditions, happens e.g on e-track-4).
211
 
                // Should not lead to a division by zero because the pullside process stops if the car is within
212
 
                // [0.5, 0.5]. Do not move it back.
213
 
                travelTime = DIST(car->restPos.pos.x, car->restPos.pos.y, carElt->_pos_X, carElt->_pos_Y) / PULL_SPD;
214
 
                car->restPos.vel.x = (car->restPos.pos.x - carElt->_pos_X) / travelTime;
215
 
                car->restPos.vel.y = (car->restPos.pos.y - carElt->_pos_Y) / travelTime;
216
 
 
217
 
                carElt->_pos_X += car->restPos.vel.x * SimDeltaTime;
218
 
                carElt->_pos_Y += car->restPos.vel.y * SimDeltaTime;
219
 
                sgMakeCoordMat4(carElt->pub.posMat, carElt->_pos_X, carElt->_pos_Y, carElt->_pos_Z - carElt->_statGC_z,
220
 
                        RAD2DEG(carElt->_yaw), RAD2DEG(carElt->_roll), RAD2DEG(carElt->_pitch));
221
 
 
222
 
                if ((fabs(car->restPos.pos.x - carElt->_pos_X) < 0.5) && (fabs(car->restPos.pos.y - carElt->_pos_Y) < 0.5)) {
223
 
                        carElt->_state &= ~RM_CAR_STATE_PULLSIDE;
224
 
                        carElt->_state |= RM_CAR_STATE_PULLDN;
225
 
                }
226
 
                return;
227
 
        }
228
 
 
229
 
 
230
 
        if (carElt->_state & RM_CAR_STATE_PULLDN) {
231
 
                carElt->_pos_Z -= car->restPos.vel.z * SimDeltaTime;
232
 
                sgMakeCoordMat4(carElt->pub.posMat, carElt->_pos_X, carElt->_pos_Y, carElt->_pos_Z - carElt->_statGC_z,
233
 
                        RAD2DEG(carElt->_yaw), RAD2DEG(carElt->_roll), RAD2DEG(carElt->_pitch));
234
 
 
235
 
                if (carElt->_pos_Z < car->restPos.pos.z) {
236
 
                        carElt->_state &= ~RM_CAR_STATE_PULLDN;
237
 
                        carElt->_state |= RM_CAR_STATE_OUT;
238
 
                }
239
 
                return;
240
 
        }
241
 
 
242
 
 
243
 
        if (carElt->_state & (RM_CAR_STATE_NO_SIMU & ~RM_CAR_STATE_PIT)) {
244
 
                return;
245
 
        }
246
 
 
247
 
        if (carElt->_state & RM_CAR_STATE_PIT) {
248
 
                if ((s->_maxDammage) && (car->dammage > s->_maxDammage)) {
249
 
                        // Broken during pit stop.
250
 
                        carElt->_state &= ~RM_CAR_STATE_PIT;
251
 
                        carElt->_pit->pitCarIndex = TR_PIT_STATE_FREE;
252
 
                } else {
253
 
                        return;
254
 
                }
255
 
        }
256
 
 
257
 
        if ((s->_maxDammage) && (car->dammage > s->_maxDammage)) {
258
 
                carElt->_state |= RM_CAR_STATE_BROKEN;
259
 
        } else {
260
 
                carElt->_state |= RM_CAR_STATE_OUTOFGAS;
261
 
        }
262
 
 
263
 
        carElt->_gear = car->transmission.gearbox.gear = 0;
264
 
        carElt->_enginerpm = car->engine.rads = 0;
265
 
 
266
 
        if (!(carElt->_state & RM_CAR_STATE_DNF)) {
267
 
                if (fabs(carElt->_speed_x) > 1.0) {
268
 
                        return;
269
 
                }
270
 
        }
271
 
 
272
 
        carElt->_state |= RM_CAR_STATE_PULLUP;
273
 
        // RM_CAR_STATE_NO_SIMU evaluates to > 0 from here, so we remove the car from the
274
 
        // collision detection.
275
 
        SimCollideRemoveCar(car, s->_ncars);
276
 
 
277
 
        carElt->priv.collision = car->collision = 0;
278
 
        for(i = 0; i < 4; i++) {
279
 
                carElt->_skid[i] = 0;
280
 
                carElt->_wheelSpinVel(i) = 0;
281
 
                carElt->_brakeTemp(i) = 0;
282
 
        }
283
 
 
284
 
        carElt->pub.DynGC = car->DynGC;
285
 
        carElt->_speed_x = 0;
286
 
 
287
 
        // Compute the target zone for the wrecked car.
288
 
        trkPos = car->trkPos;
289
 
        if (trkPos.toRight >  trkPos.seg->width / 2.0) {
290
 
                while (trkPos.seg->_lside != 0) {
291
 
                        trkPos.seg = trkPos.seg->_lside;
292
 
                }
293
 
                trkPos.toLeft = -3.0;
294
 
                trkFlag = TR_TOLEFT;
295
 
        } else {
296
 
                while (trkPos.seg->_rside != 0) {
297
 
                        trkPos.seg = trkPos.seg->_rside;
298
 
                }
299
 
                trkPos.toRight = -3.0;
300
 
                trkFlag = TR_TORIGHT;
301
 
        }
302
 
 
303
 
        trkPos.type = TR_LPOS_SEGMENT;
304
 
// IMRE
305
 
// I do not know how to handle the next 2 lines 
306
 
        RtTrackLocal2Global(&trkPos, &(car->restPos.pos.x), &(car->restPos.pos.y), trkFlag);
307
 
// so, the chassis position is in restPos.x, restPos.y  
308
 
// but when should it be updated?
309
 
        car->restPos.pos.z = RtTrackHeightL(&trkPos) + carElt->_statGC_z;
310
 
        car->restPos.pos.az = RtTrackSideTgAngleL(&trkPos);
311
 
        car->restPos.pos.ax = 0;
312
 
        car->restPos.pos.ay = 0;
313
 
 
314
 
        car->restPos.vel.z = PULL_SPD;
315
 
        travelTime = (car->restPos.pos.z + PULL_Z_OFFSET - carElt->_pos_Z) / car->restPos.vel.z;
316
 
        dang = car->restPos.pos.az - carElt->_yaw;
317
 
        NORM_PI_PI(dang);
318
 
        car->restPos.vel.az = dang / travelTime;
319
 
        dang = car->restPos.pos.ax - carElt->_roll;
320
 
        NORM_PI_PI(dang);
321
 
        car->restPos.vel.ax = dang / travelTime;
322
 
        dang = car->restPos.pos.ay - carElt->_pitch;
323
 
        NORM_PI_PI(dang);
324
 
        car->restPos.vel.ay = dang / travelTime;
325
171
}
326
172
 
327
 
 
328
 
 
329
173
void
330
174
SimUpdate(tSituation *s, double deltaTime, int telemetry)
331
175
{