/** Returns the absolute height in meters of the road
at the Local position p.
If the point lies outside the track (and sides)
the height is computed using the tangent to the banking
of the segment (or side).
@verbatim
| + Point given
| .^
| . |
| . |
| . |
| / | heigth
| / |
| ______/ v
| ^ ^^ ^
| | || |
| track side
@endverbatim
@ingroup tracktools
@param p Local position
@return Height in meters
*/
tdble
RtTrackHeightL(tTrkLocPos *p)
{
tdble lg;
tdble tr = p->toRight;
tTrackSeg *seg = p->seg;
//bool left_side = true; // Never used.
if ((tr < 0) && (seg->rside != NULL)) {
// left_side = false; // Never used.
seg = seg->rside;
tr += seg->width;
if ((tr < 0) && (seg->rside != NULL)) {
seg = seg->rside;
tr += RtTrackGetWidth(seg, p->toStart);
}
} else if ((tr > seg->width) && (seg->lside != NULL)) {
tr -= seg->width;
seg = seg->lside;
if ((tr > seg->width) && (seg->lside != NULL)) {
tr -= RtTrackGetWidth(seg, p->toStart);
seg = seg->lside;
}
}
switch (seg->type) {
case TR_STR:
lg = p->toStart;
break;
default:
lg = p->toStart * seg->radius;
break;
}
if (seg->style == TR_CURB) {
// The final height = starting height + height difference due
// to track angle + height difference due to curb (this seems
// to be the way it is implemented in the graphics too: the
// curb does not adding an angle to the main track, but a
// height in global coords).
if (seg->type2 == TR_RBORDER) {
// alpha shows how far we've moved into this segment.
tdble alpha = seg->width - tr;
tdble angle = seg->angle[TR_XS] + p->toStart * seg->Kzw;
tdble noise = seg->surface->kRoughness * sin(seg->surface->kRoughWaveLen * lg) * alpha / seg->width;
tdble start_height = seg->vertex[TR_SR].z + p->toStart * seg->Kzl;
return start_height + tr * tan(angle) + alpha * atan2(seg->height, seg->width) + noise;
}
return seg->vertex[TR_SR].z + p->toStart * seg->Kzl +
tr * (tan(seg->angle[TR_XS] + p->toStart * seg->Kzw)
+ atan2(seg->height, seg->width)) +
seg->surface->kRoughness * sin(seg->surface->kRoughWaveLen * lg) * tr / seg->width;
}
return seg->vertex[TR_SR].z + p->toStart * seg->Kzl + tr * tan(seg->angle[TR_XS] + p->toStart * seg->Kzw) +
seg->surface->kRoughness * sin(seg->surface->kRoughWaveLen * tr) * sin(seg->surface->kRoughWaveLen * lg);
}
/* get the real segment */
tTrackSeg *
RtTrackGetSeg(tTrkLocPos *p)
{
tdble tr = p->toRight;
tTrackSeg *seg = p->seg;
if ((tr < 0) && (seg->rside != NULL)) {
seg = seg->rside;
tr += seg->width;
if ((tr < 0) && (seg->rside != NULL)) {
seg = seg->rside;
tr += RtTrackGetWidth(seg, p->toStart);
}
} else if ((tr > seg->width) && (seg->lside != NULL)) {
tr -= seg->width;
seg = seg->lside;
if ((tr > seg->width) && (seg->lside != NULL)) {
tr -= RtTrackGetWidth(seg, p->toStart);
seg = seg->lside;
}
}
return seg;
}
void
ReCarsManageCar(tCarElt *car, bool& bestLapChanged)
{
char msg[64];
int i;
int xx;
tTrackSeg *sseg;
tdble wseg;
static const float ctrlMsgColor[] = {0.0, 0.0, 1.0, 1.0};
tSituation *s = ReInfo->s;
tReCarInfo *info = &(ReInfo->_reCarInfo[car->index]);
// Update top speeds.
if (car->_speed_x > car->_topSpeed)
car->_topSpeed = car->_speed_x;
// (practice and qualification only).
if (car->_speed_x > info->topSpd)
info->topSpd = car->_speed_x;
if (car->_speed_x < info->botSpd)
info->botSpd = car->_speed_x;
// Pitstop management.
if (car->_pit) {
// If the driver can ask for a pit, update control messages whether slot occupied or not.
if (car->ctrl.raceCmd & RM_CMD_PIT_ASKED) {
// Pit already occupied?
if (car->_pit->pitCarIndex == TR_PIT_STATE_FREE)
snprintf(car->ctrl.msg[2], RM_CMD_MAX_MSG_SIZE, "Can Pit");
else
snprintf(car->ctrl.msg[2], RM_CMD_MAX_MSG_SIZE, "Pit Occupied");
car->ctrl.msg[2][RM_CMD_MAX_MSG_SIZE-1] = 0; // Some snprintf implementations fail to do so.
memcpy(car->ctrl.msgColor, ctrlMsgColor, sizeof(car->ctrl.msgColor));
}
// If pitting, check if pitting delay over, and end up with pitting process if so.
if (car->_state & RM_CAR_STATE_PIT) {
car->ctrl.raceCmd &= ~RM_CMD_PIT_ASKED; // clear the flag.
// Note: Due to asynchronous behaviour of the main updater and the situation updater,
// we have to wait for car->_scheduledEventTime being set to smthg > 0.
if (car->_scheduledEventTime > 0.0) {
if (car->_scheduledEventTime < s->currentTime) {
car->_state &= ~RM_CAR_STATE_PIT;
car->_pit->pitCarIndex = TR_PIT_STATE_FREE;
snprintf(msg, sizeof(msg), "%s pit stop %.1f s", car->_name, info->totalPitTime);
msg[sizeof(msg)-1] = 0; // Some snprintf implementations fail to do so.
ReSituation::self().setRaceMessage(msg, 5);
GfLogInfo("%s exiting pit (%.1f s elapsed).\n", car->_name, info->totalPitTime);
} else {
snprintf(car->ctrl.msg[2], RM_CMD_MAX_MSG_SIZE, "In pits %.1f s",
s->currentTime - info->startPitTime);
car->ctrl.msg[2][RM_CMD_MAX_MSG_SIZE-1] = 0; // Some snprintf implementations fail to do so.
}
}
// If the driver asks for a pit, check if the car is in the right conditions
// (position, speed, ...) and start up pitting process if so.
} else if ((car->ctrl.raceCmd & RM_CMD_PIT_ASKED) &&
car->_pit->pitCarIndex == TR_PIT_STATE_FREE &&
(s->_maxDammage == 0 || car->_dammage <= s->_maxDammage)) {
snprintf(car->ctrl.msg[2], RM_CMD_MAX_MSG_SIZE, "Pit request");
car->ctrl.msg[2][RM_CMD_MAX_MSG_SIZE-1] = 0; // Some snprintf implementations fail to do so.
tdble lgFromStart = car->_trkPos.seg->lgfromstart;
switch (car->_trkPos.seg->type) {
case TR_STR:
lgFromStart += car->_trkPos.toStart;
break;
default:
lgFromStart += car->_trkPos.toStart * car->_trkPos.seg->radius;
break;
}
if ((lgFromStart > car->_pit->lmin) && (lgFromStart < car->_pit->lmax)) {
int side;
tdble toBorder;
if (ReInfo->track->pits.side == TR_RGT) {
side = TR_SIDE_RGT;
toBorder = car->_trkPos.toRight;
} else {
side = TR_SIDE_LFT;
toBorder = car->_trkPos.toLeft;
}
sseg = car->_trkPos.seg->side[side];
wseg = RtTrackGetWidth(sseg, car->_trkPos.toStart);
if (sseg->side[side]) {
sseg = sseg->side[side];
wseg += RtTrackGetWidth(sseg, car->_trkPos.toStart);
}
if (((toBorder + wseg) < (ReInfo->track->pits.width - car->_dimension_y / 2.0)) &&
(fabs(car->_speed_x) < 1.0) && (fabs(car->_speed_y) < 1.0))
{
// All conditions fullfilled => enter pitting process
car->_state |= RM_CAR_STATE_PIT;
car->_scheduledEventTime = 0.0; // Pit will really start when set to smthg > 0.
car->_nbPitStops++;
for (i = 0; i < car->_pit->freeCarIndex; i++) {
if (car->_pit->car[i] == car) {
car->_pit->pitCarIndex = i;
break;
}
}
info->startPitTime = s->currentTime;
snprintf(msg, sizeof(msg), "%s in pits", car->_name);
msg[sizeof(msg)-1] = 0; // Some snprintf implementations fail to do so.
ReSituation::self().setRaceMessage(msg, 5);
GfLogInfo("%s entering in pit slot.\n", car->_name);
if (car->robot->rbPitCmd(car->robot->index, car, s) == ROB_PIT_MENU) {
// the pit cmd is modified by menu.
reCarsSchedulePitMenu(car);
} else {
ReCarsUpdateCarPitTime(car);
}
}
else
{ // The cars speed or offset is out of accepted range
// Show the user/developer/robot the reason of the issue
tTeamDriver* TeamDriver = RtTeamDriverByCar(car);
if (TeamDriver)
{
TeamDriver->StillToGo = 0.0;
TeamDriver->MoreOffset = 0.0;
TeamDriver->TooFastBy = 0.0;
}
float Offset = (float) ((toBorder + wseg) - (ReInfo->track->pits.width - car->_dimension_y / 2.0));
if (Offset >= 0.0)
{
// The car's position across the track is out of accepted range
snprintf(car->ctrl.msg[2], RM_CMD_MAX_MSG_SIZE, "Offset: %.02f",Offset);
car->ctrl.msg[2][RM_CMD_MAX_MSG_SIZE-1] = 0; // Some snprintf implementations fail to do so.
if (TeamDriver)
TeamDriver->MoreOffset = Offset;
}
float TooFastBy = MAX(fabs(car->_speed_x),fabs(car->_speed_y));
if (TooFastBy >= 1.0)
{
// The car's speed is out of accepted range
snprintf(car->ctrl.msg[2], RM_CMD_MAX_MSG_SIZE, "Speed: %.02f",TooFastBy);
car->ctrl.msg[2][RM_CMD_MAX_MSG_SIZE-1] = 0; // Some snprintf implementations fail to do so.
if (TeamDriver)
TeamDriver->TooFastBy = TooFastBy;
}
}
}
else
{ // The car's position along the track is out of accepted range
// Show the user/developer/robot the reason of the issue
tTeamDriver* TeamDriver = RtTeamDriverByCar(car);
if (TeamDriver)
{
TeamDriver->StillToGo = 0.0;
TeamDriver->MoreOffset = 0.0;
TeamDriver->TooFastBy = 0.0;
}
if (car->_pit->lmin > lgFromStart)
{
float StillToGo = car->_pit->lmin - lgFromStart;
snprintf(car->ctrl.msg[2], RM_CMD_MAX_MSG_SIZE, "Still to go: %0.2f m" ,StillToGo);
car->ctrl.msg[2][RM_CMD_MAX_MSG_SIZE-1] = 0; // Some snprintf implementations fail to do so.
if (TeamDriver)
TeamDriver->StillToGo = StillToGo;
}
else if (car->_pit->lmax < lgFromStart)
{
float StillToGo = lgFromStart - car->_pit->lmax;
snprintf(car->ctrl.msg[2], RM_CMD_MAX_MSG_SIZE, "Overrun: %0.2f m" ,StillToGo);
car->ctrl.msg[2][RM_CMD_MAX_MSG_SIZE-1] = 0; // Some snprintf implementations fail to do so.
if (TeamDriver)
TeamDriver->StillToGo = -StillToGo;
}
}
}
}
/* Check if it is in a new sector */
while (true)
{
if (car->_currentSector < ReInfo->track->numberOfSectors - 1 && car->_laps > 0 && info->lapFlag == 0)
{
/* Must pass at least one sector before the finish */
if (RtGetDistFromStart(car) > ReInfo->track->sectors[car->_currentSector])
{
/* It is in a new sector : update split time */
car->_curSplitTime[car->_currentSector] = car->_curLapTime;
++car->_currentSector;
continue;
}
}
break;
}
/* Start Line Crossing */
if (info->prevTrkPos.seg != car->_trkPos.seg) {
if ((info->prevTrkPos.seg->raceInfo & TR_LAST)
&& (car->_trkPos.seg->raceInfo & TR_START)) {
if (info->lapFlag == 0) {
// If the car has not yet finished the race :
if (!(car->_state & RM_CAR_STATE_FINISH)) {
// 1 more lap completed
// (Note: lap with index 0 finishes when the car crosses the start line the 1st time,
// and is thus considered a real lap, whereas it is not).
car->_laps++;
/*if (NetGetNetwork())
NetGetNetwork()->SendLapStatusPacket(car);*/
car->_remainingLaps--;
if (car->_pos == 1 && s->currentTime < s->_totTime
&& s->_raceType == RM_TYPE_RACE)
{
/* First car passed finish time before the time ends: increase the number of laps for everyone */
for (xx = 0; xx < s->_ncars; ++xx)
++ReInfo->s->cars[xx]->_remainingLaps;
++s->_totLaps;
}
car->_currentSector = 0;
if (car->_laps > 1) {
car->_lastLapTime = s->currentTime - info->sTime;
if (car->_bestLapTime != 0) {
car->_deltaBestLapTime = car->_lastLapTime - car->_bestLapTime;
}
if ((car->_lastLapTime < car->_bestLapTime) || (car->_bestLapTime == 0)) {
car->_bestLapTime = car->_lastLapTime;
memcpy(car->_bestSplitTime, car->_curSplitTime, sizeof(double)*(ReInfo->track->numberOfSectors - 1) );
if (s->_raceType != RM_TYPE_RACE && s->_ncars > 1)
{
/* Best lap time is made better : update times behind leader */
bestLapChanged = true;
car->_timeBehindLeader = car->_bestLapTime - s->cars[0]->_bestLapTime;
if (car->_pos > 1)
{
car->_timeBehindPrev = car->_bestLapTime - s->cars[car->_pos - 1]->_bestLapTime;
}
else
{
/* New best time for the leader : update the differences */
for (xx = 1; xx < s->_ncars; ++xx)
{
if (s->cars[xx]->_bestLapTime > 0.0f)
s->cars[xx]->_timeBehindLeader = s->cars[xx]->_bestLapTime - car->_bestLapTime;
}
}
if (car->_pos + 1 < s->_ncars && s->cars[car->_pos+1]->_bestLapTime > 0.0f)
car->_timeBeforeNext = s->cars[car->_pos + 1]->_bestLapTime - car->_bestLapTime;
else
car->_timeBeforeNext = 0;
}
}
}
if (car->_laps > 0) {
car->_curTime += s->currentTime - info->sTime;
if (car->_pos != 1 && s->_raceType == RM_TYPE_RACE) {
car->_timeBehindLeader = car->_curTime - s->cars[0]->_curTime;
car->_lapsBehindLeader = s->cars[0]->_laps - car->_laps;
car->_timeBehindPrev = car->_curTime - s->cars[car->_pos - 2]->_curTime;
s->cars[car->_pos - 2]->_timeBeforeNext = car->_timeBehindPrev;
} else if (s->_raceType == RM_TYPE_RACE) {
car->_timeBehindLeader = 0;
car->_lapsBehindLeader = 0;
car->_timeBehindPrev = 0;
}
info->sTime = (tdble)s->currentTime;
if (ReInfo->s->_raceType == RM_TYPE_PRACTICE &&
(car->_laps > 1 || s->_totLaps == 0))
ReSavePracticeLap(car);
}
if (ReInfo->_displayMode == RM_DISP_MODE_NONE)
{
switch(s->_raceType)
{
case RM_TYPE_PRACTICE:
ReUpdatePracticeCurRes(car);
break;
case RM_TYPE_QUALIF:
ReUpdateQualifCurRes(car);
break;
case RM_TYPE_RACE:
ReUpdateRaceCurRes();
break;
default:
break;
}
}
info->topSpd = car->_speed_x;
info->botSpd = car->_speed_x;
if ((car->_remainingLaps < 0 && s->currentTime > s->_totTime) || (s->_raceState == RM_RACE_FINISHING)) {
car->_state |= RM_CAR_STATE_FINISH;
s->_raceState = RM_RACE_FINISHING;
if (ReInfo->s->_raceType == RM_TYPE_RACE) {
if (car->_pos == 1) {
snprintf(msg, sizeof(msg), "Winner %s", car->_name);
msg[sizeof(msg)-1] = 0; // Some snprintf implementations fail to do so.
ReSituation::self().setRaceMessage(msg, 10, /*big=*/true);
if (NetGetServer())
{
NetGetServer()->SetFinishTime(s->currentTime+FINISHDELAY);
}
} else {
const char *numSuffix = "th";
if (abs(12 - car->_pos) > 1) { /* leave suffix as 'th' for 11 to 13 */
switch (car->_pos % 10) {
case 1:
numSuffix = "st";
break;
case 2:
numSuffix = "nd";
break;
case 3:
numSuffix = "rd";
break;
default:
break;
}
}
snprintf(msg, sizeof(msg), "%s finished %d%s", car->_name, car->_pos, numSuffix);
msg[sizeof(msg)-1] = 0; // Some snprintf implementations fail to do so.
ReSituation::self().setRaceMessage(msg, 5);
}
}
}
// Notify the UI when a lap is completed (by the leader)
// and race results have been updated.
if (car->_pos == 1)
ReUI().onLapCompleted(car->_laps - 1);
} else {
// Prevent infinite looping of cars around track,
// allowing one lap after finish for the first car, but no more
for (i = 0; i < s->_ncars; i++) {
s->cars[i]->_state |= RM_CAR_STATE_FINISH;
}
return;
}
} else {
info->lapFlag--;
}
}
if ((info->prevTrkPos.seg->raceInfo & TR_START)
&& (car->_trkPos.seg->raceInfo & TR_LAST)) {
/* going backward through the start line */
info->lapFlag++;
}
} // Start Line Crossing
// Apply race rules (penalties if enabled).
reCarsApplyRaceRules(car);
// Update misc car info.
info->prevTrkPos = car->_trkPos;
car->_curLapTime = s->currentTime - info->sTime;
car->_distFromStartLine = car->_trkPos.seg->lgfromstart +
(car->_trkPos.seg->type == TR_STR ? car->_trkPos.toStart : car->_trkPos.toStart * car->_trkPos.seg->radius);
car->_distRaced = (car->_laps - 1) * ReInfo->track->length + car->_distFromStartLine;
}
void
RtTrackGlobal2Local(tTrackSeg *segment, tdble X, tdble Y, tTrkLocPos *p, int type)
{
int segnotfound = 1;
tdble x, y;
tTrackSeg *seg = segment;
tTrackSeg *sseg;
tdble theta, a2;
int depl = 0;
tdble curWidth;
p->type = type;
while (segnotfound) {
switch(seg->type) {
case TR_STR:
/* rotation */
tdble ts;
x = X - seg->vertex[TR_SR].x;
y = Y - seg->vertex[TR_SR].y;
ts = x * seg->cos + y * seg->sin;
p->seg = seg;
p->toStart = ts;
p->toRight = y * seg->cos - x * seg->sin;
if ((ts < 0) && (depl < 1)) {
/* get back */
seg = seg->prev;
depl = -1;
} else if ((ts > seg->length) && (depl > -1)) {
seg = seg->next;
depl = 1;
} else {
segnotfound = 0;
}
break;
case TR_LFT:
/* rectangular to polar */
x = X - seg->center.x;
y = Y - seg->center.y;
a2 = seg->arc / 2.0f;
theta = atan2(y, x) - (seg->angle[TR_CS] + a2);
FLOAT_NORM_PI_PI(theta);
p->seg = seg;
p->toStart = theta + a2;
p->toRight = seg->radiusr - sqrt(x*x + y*y);
if ((theta < -a2) && (depl < 1)) {
seg = seg->prev;
depl = -1;
} else if ((theta > a2) && (depl > -1)) {
seg = seg->next;
depl = 1;
} else {
segnotfound = 0;
}
break;
case TR_RGT:
/* rectangular to polar */
x = X - seg->center.x;
y = Y - seg->center.y;
a2 = seg->arc / 2.0f;
theta = seg->angle[TR_CS] - a2 - atan2(y, x);
FLOAT_NORM_PI_PI(theta);
p->seg = seg;
p->toStart = theta + a2;
p->toRight = sqrt(x*x + y*y) - seg->radiusr;
if ((theta < -a2) && (depl < 1)) {
seg = seg->prev;
depl = -1;
} else if ((theta > a2) && (depl > -1)) {
seg = seg->next;
depl = 1;
} else {
segnotfound = 0;
}
break;
}
}
/* The track is of constant width */
/* This is subject to change */
p->toMiddle = p->toRight - seg->width / 2.0f;
p->toLeft = seg->width - p->toRight;
/* Consider all the track with the sides */
/* Stay on main segment */
if (type == TR_LPOS_TRACK) {
if (seg->rside != NULL) {
sseg = seg->rside;
p->toRight += RtTrackGetWidth(sseg, p->toStart);
sseg = sseg->rside;
if (sseg) {
p->toRight += RtTrackGetWidth(sseg, p->toStart);
}
}
if (seg->lside != NULL) {
sseg = seg->lside;
p->toLeft += RtTrackGetWidth(sseg, p->toStart);
sseg = sseg->lside;
if (sseg) {
p->toLeft += RtTrackGetWidth(sseg, p->toStart);
}
}
}
/* Relative to a segment, change to the side segment if necessary */
if (type == TR_LPOS_SEGMENT) {
if ((p->toRight < 0) && (seg->rside != NULL)) {
sseg = seg->rside;
p->seg = sseg;
curWidth = RtTrackGetWidth(sseg, p->toStart);
p->toRight += curWidth;
p->toLeft -= seg->width;
p->toMiddle += (seg->width + curWidth) / 2.0f;
if ((p->toRight < 0) && (sseg->rside != NULL)) {
p->toLeft -= curWidth;
p->toMiddle += curWidth / 2.0f;
seg = sseg;
sseg = seg->rside;
curWidth = RtTrackGetWidth(sseg, p->toStart);
p->seg = sseg;
p->toRight += curWidth;
p->toMiddle += curWidth / 2.0f;
}
} else if ((p->toLeft < 0) && (seg->lside != NULL)) {
sseg = seg->lside;
p->seg = sseg;
curWidth = RtTrackGetWidth(sseg, p->toStart);
p->toRight += -seg->width;
p->toMiddle -= (seg->width + curWidth) / 2.0f;
p->toLeft += curWidth;
if ((p->toLeft < 0) && (sseg->lside != NULL)) {
p->toRight -= curWidth;
p->toMiddle -= curWidth / 2.0f;
seg = sseg;
sseg = seg->lside;
curWidth = RtTrackGetWidth(sseg, p->toStart);
p->seg = sseg;
p->toMiddle -= curWidth / 2.0f;
p->toLeft += curWidth;
}
}
}
}
static void
ReManage(tCarElt *car)
{
int i, pitok;
tTrackSeg *sseg;
tdble wseg;
static float color[] = {0.0, 0.0, 1.0, 1.0};
tSituation *s = ReInfo->s;
tReCarInfo *info = &(ReInfo->_reCarInfo[car->index]);
if (car->_speed_x > car->_topSpeed) {
car->_topSpeed = car->_speed_x;
}
// For practice and qualif.
if (car->_speed_x > info->topSpd) {
info->topSpd = car->_speed_x;
}
if (car->_speed_x < info->botSpd) {
info->botSpd = car->_speed_x;
}
// Pitstop.
if (car->_pit) {
if (car->ctrl.raceCmd & RM_CMD_PIT_ASKED) {
// Pit already occupied?
if (car->_pit->pitCarIndex == TR_PIT_STATE_FREE) {
sprintf(car->ctrl.msg[2], "Can Pit");
} else {
sprintf(car->ctrl.msg[2], "Pit Occupied");
}
memcpy(car->ctrl.msgColor, color, sizeof(car->ctrl.msgColor));
}
if (car->_state & RM_CAR_STATE_PIT) {
car->ctrl.raceCmd &= ~RM_CMD_PIT_ASKED; // clear the flag.
if (car->_scheduledEventTime < s->currentTime) {
car->_state &= ~RM_CAR_STATE_PIT;
car->_pit->pitCarIndex = TR_PIT_STATE_FREE;
sprintf(buf, "%s pit stop %.1fs", car->_name, info->totalPitTime);
ReRaceMsgSet(buf, 5);
} else {
sprintf(car->ctrl.msg[2], "in pits %.1fs", s->currentTime - info->startPitTime);
}
} else if ((car->ctrl.raceCmd & RM_CMD_PIT_ASKED) &&
car->_pit->pitCarIndex == TR_PIT_STATE_FREE &&
(s->_maxDammage == 0 || car->_dammage <= s->_maxDammage))
{
tdble lgFromStart = car->_trkPos.seg->lgfromstart;
switch (car->_trkPos.seg->type) {
case TR_STR:
lgFromStart += car->_trkPos.toStart;
break;
default:
lgFromStart += car->_trkPos.toStart * car->_trkPos.seg->radius;
break;
}
if ((lgFromStart > car->_pit->lmin) && (lgFromStart < car->_pit->lmax)) {
pitok = 0;
int side;
tdble toBorder;
if (ReInfo->track->pits.side == TR_RGT) {
side = TR_SIDE_RGT;
toBorder = car->_trkPos.toRight;
} else {
side = TR_SIDE_LFT;
toBorder = car->_trkPos.toLeft;
}
sseg = car->_trkPos.seg->side[side];
wseg = RtTrackGetWidth(sseg, car->_trkPos.toStart);
if (sseg->side[side]) {
sseg = sseg->side[side];
wseg += RtTrackGetWidth(sseg, car->_trkPos.toStart);
}
if (((toBorder + wseg) < (ReInfo->track->pits.width - car->_dimension_y / 2.0)) &&
(fabs(car->_speed_x) < 1.0) &&
(fabs(car->_speed_y) < 1.0))
{
pitok = 1;
}
if (pitok) {
car->_state |= RM_CAR_STATE_PIT;
car->_nbPitStops++;
for (i = 0; i < car->_pit->freeCarIndex; i++) {
if (car->_pit->car[i] == car) {
car->_pit->pitCarIndex = i;
break;
}
}
info->startPitTime = s->currentTime;
sprintf(buf, "%s in pits", car->_name);
ReRaceMsgSet(buf, 5);
if (car->robot->rbPitCmd(car->robot->index, car, s) == ROB_PIT_MENU) {
// the pit cmd is modified by menu.
ReStop();
RmPitMenuStart(car, (void*)car, ReUpdtPitCmd);
} else {
ReUpdtPitTime(car);
}
}
}
}
}
/* Start Line Crossing */
if (info->prevTrkPos.seg != car->_trkPos.seg) {
if ((info->prevTrkPos.seg->raceInfo & TR_LAST) && (car->_trkPos.seg->raceInfo & TR_START)) {
if (info->lapFlag == 0) {
if ((car->_state & RM_CAR_STATE_FINISH) == 0) {
car->_laps++;
car->_remainingLaps--;
if (car->_laps > 1) {
car->_lastLapTime = s->currentTime - info->sTime;
car->_curTime += car->_lastLapTime;
if (car->_bestLapTime != 0) {
car->_deltaBestLapTime = car->_lastLapTime - car->_bestLapTime;
}
if ((car->_lastLapTime < car->_bestLapTime) || (car->_bestLapTime == 0)) {
car->_bestLapTime = car->_lastLapTime;
}
if (car->_pos != 1) {
car->_timeBehindLeader = car->_curTime - s->cars[0]->_curTime;
car->_lapsBehindLeader = s->cars[0]->_laps - car->_laps;
car->_timeBehindPrev = car->_curTime - s->cars[car->_pos - 2]->_curTime;
s->cars[car->_pos - 2]->_timeBeforeNext = car->_timeBehindPrev;
} else {
car->_timeBehindLeader = 0;
car->_lapsBehindLeader = 0;
car->_timeBehindPrev = 0;
}
info->sTime = s->currentTime;
switch (ReInfo->s->_raceType) {
case RM_TYPE_PRACTICE:
if (ReInfo->_displayMode == RM_DISP_MODE_NONE) {
ReInfo->_refreshDisplay = 1;
char *t1, *t2;
t1 = GfTime2Str(car->_lastLapTime, 0);
t2 = GfTime2Str(car->_bestLapTime, 0);
sprintf(buf,"lap: %02d time: %s best: %s top spd: %.2f min spd: %.2f damage: %d",
car->_laps - 1, t1, t2,
info->topSpd * 3.6, info->botSpd * 3.6, car->_dammage);
ReResScreenAddText(buf);
free(t1);
free(t2);
}
/* save the lap result */
ReSavePracticeLap(car);
break;
case RM_TYPE_QUALIF:
if (ReInfo->_displayMode == RM_DISP_MODE_NONE) {
ReUpdateQualifCurRes(car);
}
break;
}
} else {
if ((ReInfo->_displayMode == RM_DISP_MODE_NONE) && (ReInfo->s->_raceType == RM_TYPE_QUALIF)) {
ReUpdateQualifCurRes(car);
}
}
info->topSpd = car->_speed_x;
info->botSpd = car->_speed_x;
if ((car->_remainingLaps < 0) || (s->_raceState == RM_RACE_FINISHING)) {
car->_state |= RM_CAR_STATE_FINISH;
s->_raceState = RM_RACE_FINISHING;
if (ReInfo->s->_raceType == RM_TYPE_RACE) {
if (car->_pos == 1) {
sprintf(buf, "Winner %s", car->_name);
ReRaceBigMsgSet(buf, 10);
} else {
const char *numSuffix = "th";
if (abs(12 - car->_pos) > 1) { /* leave suffix as 'th' for 11 to 13 */
switch (car->_pos % 10) {
case 1:
numSuffix = "st";
break;
case 2:
numSuffix = "nd";
break;
case 3:
numSuffix = "rd";
break;
default:
break;
}
}
sprintf(buf, "%s Finished %d%s", car->_name, car->_pos, numSuffix);
ReRaceMsgSet(buf, 5);
}
}
}
} else {
/* prevent infinite looping of cars around track, allow one lap after finish for the first car */
for (i = 0; i < s->_ncars; i++) {
s->cars[i]->_state |= RM_CAR_STATE_FINISH;
}
return;
}
} else {
info->lapFlag--;
}
}
if ((info->prevTrkPos.seg->raceInfo & TR_START) && (car->_trkPos.seg->raceInfo & TR_LAST)) {
/* going backward through the start line */
info->lapFlag++;
}
}
ReRaceRules(car);
info->prevTrkPos = car->_trkPos;
car->_curLapTime = s->currentTime - info->sTime;
car->_distFromStartLine = car->_trkPos.seg->lgfromstart +
(car->_trkPos.seg->type == TR_STR ? car->_trkPos.toStart : car->_trkPos.toStart * car->_trkPos.seg->radius);
car->_distRaced = (car->_laps - 1) * ReInfo->track->length + car->_distFromStartLine;
}
