data/qcsrc/server/race.qc

   1 #define MAX_CHECKPOINTS 255
   2
   3 void spawnfunc_target_checkpoint();
   4
   5 .float race_penalty;
   6 .float race_penalty_accumulator;
   7 .string race_penalty_reason;
   8 .float race_checkpoint; // player: next checkpoint that has to be reached
   9 .float race_laptime;
  10 .entity race_lastpenalty;
  11
  12 .entity sprite;
  13
  14 float race_checkpoint_records[MAX_CHECKPOINTS];
  15 string race_checkpoint_recordholders[MAX_CHECKPOINTS];
  16 float race_checkpoint_lasttimes[MAX_CHECKPOINTS];
  17 float race_checkpoint_lastlaps[MAX_CHECKPOINTS];
  18 entity race_checkpoint_lastplayers[MAX_CHECKPOINTS];
  19
  20 float race_highest_checkpoint;
  21 float race_timed_checkpoint;
  22
  23 float defrag_ents;
  24 float defragcpexists;
  25
  26 float race_NextCheckpoint(float f)
  27 {
  28         if(f >= race_highest_checkpoint)
  29                 return 0;
  30         else
  31                 return f + 1;
  32 }
  33
  34 float race_PreviousCheckpoint(float f)
  35 {
  36         if(f == -1)
  37                 return 0;
  38         else if(f == 0)
  39                 return race_highest_checkpoint;
  40         else
  41                 return f - 1;
  42 }
  43
  44 // encode as:
  45 //   0 = common start/finish
  46 // 254 = start
  47 // 255 = finish
  48 float race_CheckpointNetworkID(float f)
  49 {
  50         if(race_timed_checkpoint)
  51         {
  52                 if(f == 0)
  53                         return 254; // start
  54                 else if(f == race_timed_checkpoint)
  55                         return 255; // finish
  56         }
  57         return f;
  58 }
  59
  60 void race_SendNextCheckpoint(entity e, float spec) // qualifying only
  61 {
  62         float recordtime;
  63         string recordholder;
  64         float cp;
  65
  66         if(!e.race_laptime)
  67                 return;
  68
  69         cp = e.race_checkpoint;
  70         recordtime = race_checkpoint_records[cp];
  71         recordholder = race_checkpoint_recordholders[cp];
  72         if(recordholder == e.netname)
  73                 recordholder = "";
  74
  75         if(!spec)
  76                 msg_entity = e;
  77         WRITESPECTATABLE_MSG_ONE({
  78                 WriteByte(MSG_ONE, SVC_TEMPENTITY);
  79                 WriteByte(MSG_ONE, TE_CSQC_RACE);
  80                 if(spec)
  81                 {
  82                         WriteByte(MSG_ONE, RACE_NET_CHECKPOINT_NEXT_SPEC_QUALIFYING);
  83                         //WriteCoord(MSG_ONE, e.race_laptime - e.race_penalty_accumulator);
  84                         WriteCoord(MSG_ONE, time - e.race_movetime - e.race_penalty_accumulator);
  85                 }
  86                 else
  87                         WriteByte(MSG_ONE, RACE_NET_CHECKPOINT_NEXT_QUALIFYING);
  88                 WriteByte(MSG_ONE, race_CheckpointNetworkID(cp)); // checkpoint the player will be at next
  89                 WriteInt24_t(MSG_ONE, recordtime);
  90                 WriteString(MSG_ONE, recordholder);
  91         });
  92 }
  93
  94 void race_InitSpectator()
  95 {
  96         if(g_race_qualifying)
  97                 if(msg_entity.enemy.race_laptime)
  98                         race_SendNextCheckpoint(msg_entity.enemy, 1);
  99 }
 100
 101 string rr;
 102 float grecordtime[RANKINGS_CNT];
 103 string grecordholder[RANKINGS_CNT];
 104 #ifdef UID
 105 string grecorduid[RANKINGS_CNT];
 106 #endif
 107 float worst_time; // last ranked time
 108 float have_recs; // have we already read the records from the database before?
 109 float race_GetTime(float pos) {
 110         if(g_cts)
 111                 rr = CTS_RECORD;
 112         else
 113                 rr = RACE_RECORD;
 114
 115         if (!have_recs) { // I guess this is better than checking if the first array item is empty, rumor has it that arrays are slow
 116                 float i;
 117                 for(i=0;i<RANKINGS_CNT;++i) {
 118                         grecordtime[i] = stof(db_get(ServerProgsDB, strcat(GetMapname(), rr, "time", ftos(i))));
 119                         grecordholder[i] = strzone(db_get(ServerProgsDB, strcat(GetMapname(), rr, "netname", ftos(i))));
 120 #ifdef UID
 121                         grecorduid[i] = strzone(db_get(ServerProgsDB, strcat(GetMapname(), rr, "uid", ftos(i))));
 122 #endif
 123                 }
 124                 grecordtime[0] = stof(db_get(ServerProgsDB, strcat(GetMapname(), rr, "time")));
 125                 grecordholder[0] = strzone(db_get(ServerProgsDB, strcat(GetMapname(), rr, "netname")));
 126 #ifdef UID
 127                 grecorduid[0] = strzone(db_get(ServerProgsDB, strcat(GetMapname(), rr, "uid")));
 128 #endif
 129                 worst_time = stof(db_get(ServerProgsDB, strcat(GetMapname(), rr, strcat("time", ftos(RANKINGS_CNT-1)))));
 130                 have_recs = 1;
 131         }
 132
 133         return grecordtime[pos-1];
 134 }
 135
 136 string race_GetName(float pos) { // these other functions assume that race_GetTime has been called >= once before
 137         return grecordholder[pos-1];
 138 }
 139
 140 #ifdef UID
 141 float race_CheckUID(string myuid, string net_name) { // return existing UID or player name ranking pos, else 0
 142         float i;
 143         for (i=RANKINGS_CNT-1;i>=0;--i)
 144                 if(grecorduid[i] == myuid)
 145                         return i+1;
 146         for (i=RANKINGS_CNT-1;i>=0;--i)
 147                 if(grecordholder[i] == net_name)
 148                         return i+1;
 149         return 0;
 150 }
 151 #endif
 152
 153 float race_CheckName(string net_name) { // Does the name already exist in rankings? In that case, where? (otherwise 0)
 154         float i;
 155         for (i=RANKINGS_CNT-1;i>=0;--i)
 156                 if(grecordholder[i] == net_name)
 157                         return i+1;
 158         return 0;
 159 }
 160
 161 float race_GetPos(float t) {
 162         float i;
 163
 164         if(worst_time == 0)
 165         for (i=0;i<RANKINGS_CNT;++i)
 166                 if (grecordtime[i] == 0 || grecordtime[i] > t)
 167                         return i+1;
 168
 169         for (i=0;i<RANKINGS_CNT;++i)
 170                 if (grecordtime[i] > t)
 171                         return i+1;
 172         return 0;
 173 }
 174
 175 void race_send_recordtime(float msg)
 176 {
 177         // send the server best time
 178         WriteByte(msg, SVC_TEMPENTITY);
 179         WriteByte(msg, TE_CSQC_RACE);
 180         WriteByte(msg, RACE_NET_SERVER_RECORD);
 181         WriteInt24_t(msg, race_GetTime(1));
 182 }
 183
 184 void race_SendRankings(float pos, float prevpos, float del, float msg)
 185 {
 186         WriteByte(msg, SVC_TEMPENTITY);
 187         WriteByte(msg, TE_CSQC_RACE);
 188         WriteByte(msg, RACE_NET_SERVER_RANKINGS);
 189         WriteShort(msg, pos);
 190         WriteShort(msg, prevpos);
 191         WriteShort(msg, del);
 192         WriteString(msg, race_GetName(pos));
 193         WriteInt24_t(msg, race_GetTime(pos));
 194 }
 195
 196 void race_SendStatus(float id, entity e)
 197 {
 198         float msg = MSG_ONE;
 199         msg_entity = e;
 200         WRITESPECTATABLE_MSG_ONE_VARNAME(dummy3, {
 201                 WriteByte(msg, SVC_TEMPENTITY);
 202                 WriteByte(msg, TE_CSQC_RACE);
 203                 WriteByte(msg, RACE_NET_SERVER_STATUS);
 204                 WriteShort(msg, id);
 205         });
 206 }
 207
 208 string race_PlaceName(float pos) {
 209         if(pos == 1)
 210                 return "1st";
 211         else if(pos == 2)
 212                 return "2nd";
 213         else if(pos == 3)
 214                 return "3rd";
 215         else
 216                 return strcat(ftos(pos), "th");
 217 }
 218
 219 void race_SetTime(entity e, float t) {
 220         if (worst_time && t > worst_time)
 221                 return;
 222
 223         float oldrec;
 224         string recorddifference;
 225         float pos;
 226         pos = race_GetPos(t);
 227         float prevpos;
 228
 229         prevpos = race_CheckName(e.netname);
 230 #ifdef UID
 231         prevpos = race_CheckUID(e.uid, e.netname);
 232 #endif
 233         if (prevpos && (prevpos < pos || !pos))
 234         {
 235                 oldrec = race_GetTime(prevpos);
 236                 recorddifference = strcat(" ^1[+", TIME_ENCODED_TOSTRING(t - oldrec), "]");
 237                 bprint(e.netname, "^7 couldn't break their ", race_PlaceName(prevpos), " place record of ", TIME_ENCODED_TOSTRING(oldrec), recorddifference, "\n");
 238
 239                 return;
 240         } else if (!pos) { // no ranking, time worse than the worst ranked
 241                 recorddifference = strcat(" ^1[+", TIME_ENCODED_TOSTRING(t - grecordtime[RANKINGS_CNT-1]), "]");
 242                 bprint(e.netname, "^7 couldn't break the ", race_PlaceName(RANKINGS_CNT), " place record of ", TIME_ENCODED_TOSTRING(grecordtime[RANKINGS_CNT-1]), recorddifference, "\n");
 243                 return;
 244         }
 245
 246         // move other rankings out of the way
 247         float i;
 248         if (prevpos) { // player improved his existing record
 249                 if(prevpos == pos)
 250                         oldrec = grecordtime[pos-1];
 251                 else
 252                         oldrec = grecordtime[pos-1];
 253                 for (i=prevpos-1;i>pos-1;--i) {
 254                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "time", ftos(i)), ftos(grecordtime[i-1]));
 255                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "netname", ftos(i)), grecordholder[i-1]);
 256 #ifdef UID
 257                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "uid", ftos(i)), grecorduid[i-1]);
 258 #endif
 259                         grecordtime[i] = grecordtime[i-1];
 260
 261                         if (grecordholder[i])
 262                                 strunzone(grecordholder[i]);
 263                         grecordholder[i] = strzone(grecordholder[i-1]);
 264 #ifdef UID
 265                         if (grecorduid[i])
 266                                 strunzone(grecorduid[i]);
 267                         grecorduid[i] = strzone(grecorduid[i-1]);
 268 #endif
 269                 }
 270         } else { // player has no ranked record yet
 271                 oldrec = grecordtime[pos-1];
 272                 for (i=RANKINGS_CNT-1;i>pos-1;--i) {
 273                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "time", ftos(i)), ftos(grecordtime[i-1]));
 274                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "netname", ftos(i)), grecordholder[i-1]);
 275 #ifdef UID
 276                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "uid", ftos(i)), grecorduid[i-1]);
 277 #endif
 278                         grecordtime[i] = grecordtime[i-1];
 279
 280                         if (grecordholder[i])
 281                                 strunzone(grecordholder[i]);
 282                         grecordholder[i] = strzone(grecordholder[i-1]);
 283 #ifdef UID
 284                         if (grecorduid[i])
 285                                 strunzone(grecorduid[i]);
 286                         grecorduid[i] = strzone(grecorduid[i-1]);
 287 #endif
 288                 }
 289         }
 290
 291         // store new ranking
 292         if (pos == 1) {
 293                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "time"), ftos(t));
 294                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "netname"), e.netname);
 295 #ifdef UID
 296                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "uid"), e.uid);
 297 #endif
 298
 299                 grecordtime[0] = t;
 300
 301                 if (grecordholder[0])
 302                         strunzone(grecordholder[0]);
 303                 grecordholder[0] = strzone(e.netname);
 304 #ifdef UID
 305                 if (grecorduid[0])
 306                         strunzone(grecorduid[0]);
 307                 grecorduid[0] = strzone(e.uid);
 308 #endif
 309                 write_recordmarker(e, time - TIME_DECODE(t), TIME_DECODE(t));
 310                 race_send_recordtime(MSG_ALL);
 311         } else {
 312                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "time", ftos(pos-1)), ftos(t));
 313                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "netname", ftos(pos-1)), e.netname);
 314 #ifdef UID
 315                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "uid", ftos(pos-1)), e.uid);
 316 #endif
 317
 318                 grecordtime[pos-1] = t;
 319
 320                 if (grecordholder[pos-1])
 321                         strunzone(grecordholder[pos-1]);
 322                 grecordholder[pos-1] = strzone(e.netname);
 323 #ifdef UID
 324                 if (grecorduid[pos-1])
 325                         strunzone(grecorduid[pos-1]);
 326                 grecorduid[pos-1] = strzone(e.uid);
 327 #endif
 328         }
 329
 330         if (pos == RANKINGS_CNT)
 331                 worst_time = t;
 332
 333         race_SendRankings(pos, prevpos, 0, MSG_ALL);
 334         if(rankings_reply)
 335                 strunzone(rankings_reply);
 336         rankings_reply = strzone(getrankings());
 337         if(pos == 1) {
 338                 if(pos == prevpos) {
 339                         recorddifference = strcat(" ^2[-", TIME_ENCODED_TOSTRING(oldrec - t), "]");
 340                         bprint(e.netname, "^1 improved their 1st place record with ", TIME_ENCODED_TOSTRING(t), recorddifference, "\n");
 341                         race_SendStatus(2, e); // "new record"
 342                 } else {
 343                         recorddifference = strcat(" ^2[-", TIME_ENCODED_TOSTRING(oldrec - t), "]");
 344                         bprint(e.netname, "^1 broke ", grecordholder[pos], "^1's 1st place record with ", strcat(TIME_ENCODED_TOSTRING(t), recorddifference, "\n"));
 345                         race_SendStatus(2, e); // "new record"
 346                 }
 347         } else {
 348                 if(pos == prevpos) {
 349                         recorddifference = strcat(" ^2[-", TIME_ENCODED_TOSTRING(oldrec - t), "]");
 350                         bprint(e.netname, "^3 improved their ", race_PlaceName(pos), " ^3place record with ", TIME_ENCODED_TOSTRING(t), recorddifference, "\n");
 351                         race_SendStatus(0, e); // "new time"
 352                 } else if (oldrec == 0) {
 353                         bprint(e.netname, "^2 set the ", race_PlaceName(pos), " ^2place record with ", TIME_ENCODED_TOSTRING(t), "\n");
 354                         race_SendStatus(1, e); // "new rank"
 355                 } else {
 356                         recorddifference = strcat(" ^2[-", TIME_ENCODED_TOSTRING(oldrec - t), "]");
 357                         bprint(e.netname, "^2 broke ", grecordholder[pos], "^2's ", race_PlaceName(pos), " ^2place record with ", strcat(TIME_ENCODED_TOSTRING(t), recorddifference, "\n"));
 358                         race_SendStatus(1, e); // "new rank"
 359                 }
 360         }
 361 }
 362
 363 void race_DeleteTime(float pos) {
 364         float i;
 365
 366         for (i = pos-1; i <= RANKINGS_CNT-1; ++i) {
 367                 if (i == 0) {
 368                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "time"), ftos(grecordtime[1]));
 369                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "netname"), grecordholder[1]);
 370 #ifdef UID
 371                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "uid"), grecorduid[1]);
 372 #endif
 373                         grecordtime[0] = grecordtime[1];
 374                         if (grecordholder[i])
 375                                 strunzone(grecordholder[0]);
 376                         grecordholder[0] = strzone(grecordholder[1]);
 377
 378 #ifdef UID
 379                         if (grecorduid[i])
 380                                 strunzone(grecorduid[0]);
 381                         grecorduid[0] = strzone(grecorduid[1]);
 382 #endif
 383                 }
 384                 else if (i == RANKINGS_CNT-1) {
 385                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "time", ftos(i)), string_null);
 386                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "netname", ftos(i)), string_null);
 387 #ifdef UID
 388                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "uid", ftos(i)), string_null);
 389 #endif
 390                         grecordtime[i] = 0;
 391                         if (grecordholder[i])
 392                                 strunzone(grecordholder[i]);
 393                         grecordholder[i] = string_null;
 394
 395 #ifdef UID
 396                         if (grecorduid[i])
 397                                 strunzone(grecorduid[i]);
 398                         grecorduid[i] = string_null;
 399 #endif
 400                 }
 401                 else {
 402                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "time", ftos(i)), ftos(grecordtime[i+1]));
 403                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "netname", ftos(i)), grecordholder[i+1]);
 404 #ifdef UID
 405                         db_put(ServerProgsDB, strcat(GetMapname(), rr, "uid", ftos(i)), grecorduid[i+1]);
 406 #endif
 407                         grecordtime[i] = grecordtime[i+1];
 408                         if (grecordholder[i])
 409                                 strunzone(grecordholder[i]);
 410                         grecordholder[i] = strzone(grecordholder[i+1]);
 411
 412 #ifdef UID
 413                         if (grecorduid[i])
 414                                 strunzone(grecorduid[i]);
 415                         grecorduid[i] = strzone(grecorduid[i+1]);
 416 #endif
 417                 }
 418         }
 419
 420         race_SendRankings(pos, 0, 1, MSG_ALL);
 421         if(pos == 1)
 422                 race_send_recordtime(MSG_ALL);
 423
 424         if(rankings_reply)
 425                 strunzone(rankings_reply);
 426         rankings_reply = strzone(getrankings());
 427
 428         worst_time = 0;
 429 }
 430
 431 void race_SendTime(entity e, float cp, float t, float tvalid)
 432 {
 433         float snew, l;
 434         entity p;
 435
 436         if(g_race_qualifying)
 437                 t += e.race_penalty_accumulator;
 438
 439         t = TIME_ENCODE(t); // make integer
 440         // adding just 0.4 so it rounds down in the .5 case (matching the timer display)
 441
 442         if(tvalid)
 443         if(cp == race_timed_checkpoint) // finish line
 444         if not(e.race_completed)
 445         {
 446                 float s;
 447                 if(g_race_qualifying)
 448                 {
 449                         s = PlayerScore_Add(e, SP_RACE_FASTEST, 0);
 450                         if(!s || t < s)
 451                                 PlayerScore_Add(e, SP_RACE_FASTEST, t - s);
 452                 }
 453                 else
 454                 {
 455                         s = PlayerScore_Add(e, SP_RACE_TIME, 0);
 456                         snew = TIME_ENCODE(time - game_starttime);
 457                         PlayerScore_Add(e, SP_RACE_TIME, snew - s);
 458                         l = PlayerTeamScore_Add(e, SP_RACE_LAPS, ST_RACE_LAPS, 1);
 459
 460                         if(cvar("fraglimit"))
 461                                 if(l >= cvar("fraglimit"))
 462                                         race_StartCompleting();
 463
 464                         if(race_completing)
 465                         {
 466                                 e.race_completed = 1;
 467                                 MAKE_INDEPENDENT_PLAYER(e);
 468                                 bprint(e.netname, "^7 has finished the race.\n");
 469                                 ClientData_Touch(e);
 470                         }
 471                 }
 472         }
 473
 474         float recordtime;
 475         string recordholder;
 476         if(g_race_qualifying)
 477         {
 478                 if(tvalid)
 479                 {
 480                         recordtime = race_checkpoint_records[cp];
 481                         recordholder = strcat1(race_checkpoint_recordholders[cp]); // make a tempstring copy, as we'll possibly strunzone it!
 482                         if(recordholder == e.netname)
 483                                 recordholder = "";
 484
 485                         if(t != 0)
 486                         if(t < worst_time || worst_time == 0)
 487                         {
 488                                 if(cp == race_timed_checkpoint)
 489                                 {
 490                                         race_SetTime(e, t);
 491                                 }
 492
 493                                 if(t < recordtime || recordtime == 0)
 494                                 {
 495                                         race_checkpoint_records[cp] = t;
 496                                         if(race_checkpoint_recordholders[cp])
 497                                                 strunzone(race_checkpoint_recordholders[cp]);
 498                                         race_checkpoint_recordholders[cp] = strzone(e.netname);
 499                                         if(g_race_qualifying)
 500                                         {
 501                                                 FOR_EACH_REALPLAYER(p)
 502                                                         if(p.race_checkpoint == cp)
 503                                                                 race_SendNextCheckpoint(p, 0);
 504                                         }
 505                                 }
 506                         }
 507                 }
 508                 else
 509                 {
 510                         // dummies
 511                         t = 0;
 512                         recordtime = 0;
 513                         recordholder = "";
 514                 }
 515
 516                 msg_entity = e;
 517                 if(g_race_qualifying)
 518                 {
 519                         WRITESPECTATABLE_MSG_ONE_VARNAME(dummy1, {
 520                                 WriteByte(MSG_ONE, SVC_TEMPENTITY);
 521                                 WriteByte(MSG_ONE, TE_CSQC_RACE);
 522                                 WriteByte(MSG_ONE, RACE_NET_CHECKPOINT_HIT_QUALIFYING);
 523                                 WriteByte(MSG_ONE, race_CheckpointNetworkID(cp)); // checkpoint the player now is at
 524                                 WriteInt24_t(MSG_ONE, t); // time to that intermediate
 525                                 WriteInt24_t(MSG_ONE, recordtime); // previously best time
 526                                 WriteString(MSG_ONE, recordholder); // record holder
 527                         });
 528                 }
 529         }
 530         else // RACE! Not Qualifying
 531         {
 532                 float lself, lother, othtime;
 533                 entity oth;
 534                 oth = race_checkpoint_lastplayers[cp];
 535                 if(oth)
 536                 {
 537                         lself = PlayerScore_Add(e, SP_RACE_LAPS, 0);
 538                         lother = race_checkpoint_lastlaps[cp];
 539                         othtime = race_checkpoint_lasttimes[cp];
 540                 }
 541                 else
 542                         lself = lother = othtime = 0;
 543
 544                 msg_entity = e;
 545                 WRITESPECTATABLE_MSG_ONE_VARNAME(dummy2, {
 546                         WriteByte(MSG_ONE, SVC_TEMPENTITY);
 547                         WriteByte(MSG_ONE, TE_CSQC_RACE);
 548                         WriteByte(MSG_ONE, RACE_NET_CHECKPOINT_HIT_RACE);
 549                         WriteByte(MSG_ONE, race_CheckpointNetworkID(cp)); // checkpoint the player now is at
 550                         if(e == oth)
 551                         {
 552                                 WriteInt24_t(MSG_ONE, 0);
 553                                 WriteByte(MSG_ONE, 0);
 554                                 WriteString(MSG_ONE, "");
 555                         }
 556                         else
 557                         {
 558                                 WriteInt24_t(MSG_ONE, TIME_ENCODE(time - race_checkpoint_lasttimes[cp]));
 559                                 WriteByte(MSG_ONE, lself - lother);
 560                                 WriteString(MSG_ONE, oth.netname); // record holder
 561                         }
 562                 });
 563
 564                 race_checkpoint_lastplayers[cp] = e;
 565                 race_checkpoint_lasttimes[cp] = time;
 566                 race_checkpoint_lastlaps[cp] = lself;
 567
 568                 msg_entity = oth;
 569                 WRITESPECTATABLE_MSG_ONE_VARNAME(dummy3, {
 570                         WriteByte(MSG_ONE, SVC_TEMPENTITY);
 571                         WriteByte(MSG_ONE, TE_CSQC_RACE);
 572                         WriteByte(MSG_ONE, RACE_NET_CHECKPOINT_HIT_RACE_BY_OPPONENT);
 573                         WriteByte(MSG_ONE, race_CheckpointNetworkID(cp)); // checkpoint the player now is at
 574                         if(e == oth)
 575                         {
 576                                 WriteInt24_t(MSG_ONE, 0);
 577                                 WriteByte(MSG_ONE, 0);
 578                                 WriteString(MSG_ONE, "");
 579                         }
 580                         else
 581                         {
 582                                 WriteInt24_t(MSG_ONE, TIME_ENCODE(time - othtime));
 583                                 WriteByte(MSG_ONE, lother - lself);
 584                                 WriteString(MSG_ONE, e.netname); // record holder
 585                         }
 586                 });
 587         }
 588 }
 589
 590 void race_ClearTime(entity e)
 591 {
 592         e.race_checkpoint = 0;
 593         e.race_laptime = 0;
 594         e.race_movetime = e.race_movetime_frac = e.race_movetime_count = 0;
 595         e.race_penalty_accumulator = 0;
 596         e.race_lastpenalty = world;
 597
 598         msg_entity = e;
 599         WRITESPECTATABLE_MSG_ONE({
 600                 WriteByte(MSG_ONE, SVC_TEMPENTITY);
 601                 WriteByte(MSG_ONE, TE_CSQC_RACE);
 602                 WriteByte(MSG_ONE, RACE_NET_CHECKPOINT_CLEAR); // next
 603         });
 604 }
 605
 606 void dumpsurface(entity e)
 607 {
 608         float n, si, ni;
 609         vector norm, vec;
 610         print("Surfaces of ", etos(e), ":\n");
 611
 612         print("TEST = ", ftos(getsurfacenearpoint(e, '0 0 0')), "\n");
 613
 614         for(si = 0; ; ++si)
 615         {
 616                 n = getsurfacenumpoints(e, si);
 617                 if(n <= 0)
 618                         break;
 619                 print("  Surface ", ftos(si), ":\n");
 620                 norm = getsurfacenormal(e, si);
 621                 print("    Normal = ", vtos(norm), "\n");
 622                 for(ni = 0; ni < n; ++ni)
 623                 {
 624                         vec = getsurfacepoint(e, si, ni);
 625                         print("    Point ", ftos(ni), " = ", vtos(vec), " (", ftos(norm * vec), ")\n");
 626                 }
 627         }
 628 }
 629
 630 void checkpoint_passed()
 631 {
 632         string oldmsg;
 633         entity cp;
 634
 635         if(other.classname == "porto")
 636         {
 637                 // do not allow portalling through checkpoints
 638                 trace_plane_normal = normalize(-1 * other.velocity);
 639                 self = other;
 640                 W_Porto_Fail(0);
 641                 return;
 642         }
 643
 644         /*
 645          * Trigger targets
 646          */
 647         if not((self.spawnflags & 2) && (other.classname == "player"))
 648         {
 649                 activator = other;
 650                 oldmsg = self.message;
 651                 self.message = "";
 652                 SUB_UseTargets();
 653                 self.message = oldmsg;
 654         }
 655
 656         if(other.classname != "player")
 657                 return;
 658
 659         /*
 660          * Remove unauthorized equipment
 661          */
 662         Portal_ClearAll(other);
 663
 664         other.porto_forbidden = 2; // decreased by 1 each StartFrame
 665
 666         if(defrag_ents) {
 667                 if(self.race_checkpoint == -2)
 668                 {
 669                         self.race_checkpoint = other.race_checkpoint;
 670                 }
 671
 672                 float largest_cp_id;
 673                 float cp_amount;
 674                 for(cp = world; (cp = find(cp, classname, "target_checkpoint"));) {
 675                         cp_amount += 1;
 676                         if(cp.race_checkpoint > largest_cp_id) // update the finish id if someone hit a new checkpoint
 677                         {
 678                                 largest_cp_id = cp.race_checkpoint;
 679                                 for(cp = world; (cp = find(cp, classname, "target_stopTimer"));)
 680                                         cp.race_checkpoint = largest_cp_id + 1; // finish line
 681                                 race_highest_checkpoint = largest_cp_id + 1;
 682                                 race_timed_checkpoint = largest_cp_id + 1;
 683
 684                                 for(cp = world; (cp = find(cp, classname, "target_checkpoint"));) {
 685                                         if(cp.race_checkpoint == -2) // set defragcpexists to -1 so that the cp id file will be rewritten when someone finishes
 686                                                 defragcpexists = -1;
 687                                 }
 688                         }
 689                 }
 690                 if(cp_amount == 0) {
 691                         for(cp = world; (cp = find(cp, classname, "target_stopTimer"));)
 692                                 cp.race_checkpoint = 1;
 693                         race_highest_checkpoint = 1;
 694                         race_timed_checkpoint = 1;
 695                 }
 696         }
 697
 698         if((other.race_checkpoint == -1 && self.race_checkpoint == 0) || (other.race_checkpoint == self.race_checkpoint))
 699         {
 700                 if(self.race_penalty)
 701                 {
 702                         if(other.race_lastpenalty != self)
 703                         {
 704                                 other.race_lastpenalty = self;
 705                                 race_ImposePenaltyTime(other, self.race_penalty, self.race_penalty_reason);
 706                         }
 707                 }
 708
 709                 if(other.race_penalty)
 710                         return;
 711
 712                 /*
 713                  * Trigger targets
 714                  */
 715                 if(self.spawnflags & 2)
 716                 {
 717                         activator = other;
 718                         oldmsg = self.message;
 719                         self.message = "";
 720                         SUB_UseTargets();
 721                         self.message = oldmsg;
 722                 }
 723
 724                 if(other.race_respawn_checkpoint != self.race_checkpoint || !other.race_started)
 725                         other.race_respawn_spotref = self; // this is not a spot but a CP, but spawnpoint selection will deal with that
 726                 other.race_respawn_checkpoint = self.race_checkpoint;
 727                 other.race_checkpoint = race_NextCheckpoint(self.race_checkpoint);
 728                 other.race_started = 1;
 729
 730                 race_SendTime(other, self.race_checkpoint, other.race_movetime, !!other.race_laptime);
 731
 732                 if(!self.race_checkpoint) // start line
 733                 {
 734                         other.race_laptime = time;
 735                         other.race_movetime = other.race_movetime_frac = other.race_movetime_count = 0;
 736                         other.race_penalty_accumulator = 0;
 737                         other.race_lastpenalty = world;
 738                 }
 739
 740                 if(g_race_qualifying)
 741                         race_SendNextCheckpoint(other, 0);
 742
 743                 if(defrag_ents && defragcpexists < 0 && self.classname == "target_stopTimer")
 744                 {
 745                         float fh;
 746                         defragcpexists = fh = fopen(strcat("maps/", GetMapname(), ".defragcp"), FILE_WRITE);
 747                         if(fh >= 0)
 748                         {
 749                                 for(cp = world; (cp = find(cp, classname, "target_checkpoint"));)
 750                                 fputs(fh, strcat(cp.targetname, " ", ftos(cp.race_checkpoint), "\n"));
 751                         }
 752                         fclose(fh);
 753                 }
 754         }
 755         else if(other.race_checkpoint == race_NextCheckpoint(self.race_checkpoint))
 756         {
 757                 // ignored
 758         }
 759         else
 760         {
 761                 if(self.spawnflags & 4)
 762                         Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 763         }
 764 }
 765
 766 void checkpoint_touch()
 767 {
 768         EXACTTRIGGER_TOUCH;
 769         checkpoint_passed();
 770 }
 771
 772 void checkpoint_use()
 773 {
 774         if(other.classname == "info_player_deathmatch") // a spawn, a spawn
 775                 return;
 776
 777         other = activator;
 778         checkpoint_passed();
 779 }
 780
 781 float race_waypointsprite_visible_for_player(entity e)
 782 {
 783         if(e.race_checkpoint == -1 || self.owner.race_checkpoint == -2)
 784                 return TRUE;
 785         else if(e.race_checkpoint == self.owner.race_checkpoint)
 786                 return TRUE;
 787         else
 788                 return FALSE;
 789 }
 790
 791 float have_verified;
 792 void trigger_race_checkpoint_verify()
 793 {
 794         entity oldself, cp;
 795         float i, p;
 796         float qual;
 797
 798         if(have_verified)
 799                 return;
 800         have_verified = 1;
 801
 802         qual = g_race_qualifying;
 803
 804         oldself = self;
 805         self = spawn();
 806         self.classname = "player";
 807
 808         if(g_race)
 809         {
 810                 for(i = 0; i <= race_highest_checkpoint; ++i)
 811                 {
 812                         self.race_checkpoint = race_NextCheckpoint(i);
 813
 814                         // race only (middle of the race)
 815                         g_race_qualifying = 0;
 816                         self.race_place = 0;
 817                         if(!Spawn_FilterOutBadSpots(findchain(classname, "info_player_deathmatch"), world, 0, FALSE, FALSE))
 818                                 error(strcat("Checkpoint ", ftos(i), " misses a spawnpoint with race_place==", ftos(self.race_place), " (used for respawning in race) - bailing out"));
 819
 820                         if(i == 0)
 821                         {
 822                                 // qualifying only
 823                                 g_race_qualifying = 1;
 824                                 self.race_place = race_lowest_place_spawn;
 825                                 if(!Spawn_FilterOutBadSpots(findchain(classname, "info_player_deathmatch"), world, 0, FALSE, FALSE))
 826                                         error(strcat("Checkpoint ", ftos(i), " misses a spawnpoint with race_place==", ftos(self.race_place), " (used for qualifying) - bailing out"));
 827
 828                                 // race only (initial spawn)
 829                                 g_race_qualifying = 0;
 830                                 for(p = 1; p <= race_highest_place_spawn; ++p)
 831                                 {
 832                                         self.race_place = p;
 833                                         if(!Spawn_FilterOutBadSpots(findchain(classname, "info_player_deathmatch"), world, 0, FALSE, FALSE))
 834                                                 error(strcat("Checkpoint ", ftos(i), " misses a spawnpoint with race_place==", ftos(self.race_place), " (used for initially spawning in race) - bailing out"));
 835                                 }
 836                         }
 837                 }
 838         }
 839         else if(!defrag_ents)
 840         {
 841                 // qualifying only
 842                 self.race_checkpoint = race_NextCheckpoint(0);
 843                 g_race_qualifying = 1;
 844                 self.race_place = race_lowest_place_spawn;
 845                 if(!Spawn_FilterOutBadSpots(findchain(classname, "info_player_deathmatch"), world, 0, FALSE, FALSE))
 846                         error(strcat("Checkpoint ", ftos(i), " misses a spawnpoint with race_place==", ftos(self.race_place), " (used for qualifying) - bailing out"));
 847         }
 848         else
 849         {
 850                 self.race_checkpoint = race_NextCheckpoint(0);
 851                 g_race_qualifying = 1;
 852                 self.race_place = 0; // there's only one spawn on defrag maps
 853
 854                 // check if a defragcp file already exists, then read it and apply the checkpoint order
 855                 float fh;
 856                 float len;
 857                 string l;
 858
 859                 defragcpexists = fh = fopen(strcat("maps/", GetMapname(), ".defragcp"), FILE_READ);
 860                 if(fh >= 0)
 861                 {
 862                         while((l = fgets(fh)))
 863                         {
 864                                 len = tokenize_console(l);
 865                                 if(len != 2) {
 866                                         defragcpexists = -1; // something's wrong in the defrag cp file, set defragcpexists to -1 so that it will be rewritten when someone finishes
 867                                         continue;
 868                                 }
 869                                 for(cp = world; (cp = find(cp, classname, "target_checkpoint"));)
 870                                         if(argv(0) == cp.targetname)
 871                                                 cp.race_checkpoint = stof(argv(1));
 872                         }
 873                         fclose(fh);
 874                 }
 875         }
 876
 877         g_race_qualifying = qual;
 878
 879         if(race_timed_checkpoint) {
 880                 if(defrag_ents) {
 881                         for(cp = world; (cp = find(cp, classname, "target_startTimer"));)
 882                                 WaypointSprite_UpdateSprites(cp.sprite, "race-start", "", "");
 883                         for(cp = world; (cp = find(cp, classname, "target_stopTimer"));)
 884                                 WaypointSprite_UpdateSprites(cp.sprite, "race-finish", "", "");
 885
 886                         for(cp = world; (cp = find(cp, classname, "target_checkpoint"));) {
 887                                 if(cp.race_checkpoint == -2) // something's wrong with the defrag cp file or it has not been written yet, set defragcpexists to -1 so that it will be rewritten when someone finishes
 888                                         defragcpexists = -1;
 889                         }
 890
 891                         if(defragcpexists != -1){
 892                                 float largest_cp_id;
 893                                 for(cp = world; (cp = find(cp, classname, "target_checkpoint"));)
 894                                         if(cp.race_checkpoint > largest_cp_id)
 895                                                 largest_cp_id = cp.race_checkpoint;
 896                                 for(cp = world; (cp = find(cp, classname, "target_stopTimer"));)
 897                                         cp.race_checkpoint = largest_cp_id + 1; // finish line
 898                                 race_highest_checkpoint = largest_cp_id + 1;
 899                                 race_timed_checkpoint = largest_cp_id + 1;
 900                         } else {
 901                                 for(cp = world; (cp = find(cp, classname, "target_stopTimer"));)
 902                                         cp.race_checkpoint = 255; // finish line
 903                                 race_highest_checkpoint = 255;
 904                                 race_timed_checkpoint = 255;
 905                         }
 906                 }
 907                 else {
 908                         for(cp = world; (cp = find(cp, classname, "trigger_race_checkpoint")); )
 909                                 if(cp.sprite)
 910                                 {
 911                                         if(cp.race_checkpoint == 0)
 912                                                 WaypointSprite_UpdateSprites(cp.sprite, "race-start", "", "");
 913                                         else if(cp.race_checkpoint == race_timed_checkpoint)
 914                                                 WaypointSprite_UpdateSprites(cp.sprite, "race-finish", "", "");
 915                                 }
 916                 }
 917         }
 918
 919         if(defrag_ents) {
 920                 entity trigger, targ;
 921                 for(trigger = world; (trigger = find(trigger, classname, "trigger_multiple")); )
 922                         for(targ = world; (targ = find(targ, targetname, trigger.target)); )
 923                                 if (targ.classname == "target_checkpoint" || targ.classname == "target_startTimer" || targ.classname == "target_stopTimer") {
 924                                         targ.wait = -2;
 925                                         targ.delay = 0;
 926
 927                                         setsize(targ, trigger.mins, trigger.maxs);
 928                                         setorigin(targ, trigger.origin);
 929                                         remove(trigger);
 930                                 }
 931         }
 932         remove(self);
 933         self = oldself;
 934 }
 935
 936 void spawnfunc_trigger_race_checkpoint()
 937 {
 938         vector o;
 939         if(!g_race && !g_cts)
 940         {
 941                 remove(self);
 942                 return;
 943         }
 944
 945         EXACTTRIGGER_INIT;
 946
 947         self.use = checkpoint_use;
 948         if not(self.spawnflags & 1)
 949                 self.touch = checkpoint_touch;
 950
 951         o = (self.absmin + self.absmax) * 0.5;
 952         tracebox(o, PL_MIN, PL_MAX, o - '0 0 1' * (o_z - self.absmin_z), MOVE_NORMAL, self);
 953         waypoint_spawnforitem_force(self, trace_endpos);
 954         self.nearestwaypointtimeout = time + 1000000000;
 955
 956         if(!self.message)
 957                 self.message = "went backwards";
 958         if (!self.message2)
 959                 self.message2 = "was pushed backwards by";
 960         if (!self.race_penalty_reason)
 961                 self.race_penalty_reason = "missing a checkpoint";
 962
 963         self.race_checkpoint = self.cnt;
 964
 965         if(self.race_checkpoint > race_highest_checkpoint)
 966         {
 967                 race_highest_checkpoint = self.race_checkpoint;
 968                 if(self.spawnflags & 8)
 969                         race_timed_checkpoint = self.race_checkpoint;
 970                 else
 971                         race_timed_checkpoint = 0;
 972         }
 973
 974         if(!self.race_penalty)
 975         {
 976                 if(self.race_checkpoint)
 977                         WaypointSprite_SpawnFixed("race-checkpoint", o, self, sprite);
 978                 else
 979                         WaypointSprite_SpawnFixed("race-finish", o, self, sprite);
 980         }
 981
 982         self.sprite.waypointsprite_visible_for_player = race_waypointsprite_visible_for_player;
 983
 984         InitializeEntity(self, trigger_race_checkpoint_verify, INITPRIO_FINDTARGET);
 985 }
 986
 987 void spawnfunc_target_checkpoint() // defrag entity
 988 {
 989         vector o;
 990         if(!g_race && !g_cts)
 991         {
 992                 remove(self);
 993                 return;
 994         }
 995         defrag_ents = 1;
 996
 997         EXACTTRIGGER_INIT;
 998
 999         self.use = checkpoint_use;
1000         if not(self.spawnflags & 1)
1001                 self.touch = checkpoint_touch;
1002
1003         o = (self.absmin + self.absmax) * 0.5;
1004         tracebox(o, PL_MIN, PL_MAX, o - '0 0 1' * (o_z - self.absmin_z), MOVE_NORMAL, self);
1005         waypoint_spawnforitem_force(self, trace_endpos);
1006         self.nearestwaypointtimeout = time + 1000000000;
1007
1008         if(!self.message)
1009                 self.message = "went backwards";
1010         if (!self.message2)
1011                 self.message2 = "was pushed backwards by";
1012         if (!self.race_penalty_reason)
1013                 self.race_penalty_reason = "missing a checkpoint";
1014
1015         if(self.classname == "target_startTimer")
1016                 self.race_checkpoint = 0;
1017         else
1018                 self.race_checkpoint = -2;
1019
1020         race_timed_checkpoint = 1;
1021
1022         if(self.race_checkpoint == 0)
1023                 WaypointSprite_SpawnFixed("race-start", o, self, sprite);
1024         else
1025                 WaypointSprite_SpawnFixed("race-checkpoint", o, self, sprite);
1026
1027         self.sprite.waypointsprite_visible_for_player = race_waypointsprite_visible_for_player;
1028
1029         InitializeEntity(self, trigger_race_checkpoint_verify, INITPRIO_FINDTARGET);
1030 }
1031
1032 void spawnfunc_target_startTimer() { spawnfunc_target_checkpoint(); }
1033 void spawnfunc_target_stopTimer() { spawnfunc_target_checkpoint(); }
1034
1035 void race_AbandonRaceCheck(entity p)
1036 {
1037         if(race_completing && !p.race_completed)
1038         {
1039                 p.race_completed = 1;
1040                 MAKE_INDEPENDENT_PLAYER(p);
1041                 bprint(p.netname, "^7 has abandoned the race.\n");
1042                 ClientData_Touch(p);
1043         }
1044 }
1045
1046 void race_StartCompleting()
1047 {
1048         entity p;
1049         race_completing = 1;
1050         FOR_EACH_PLAYER(p)
1051                 if(p.deadflag != DEAD_NO)
1052                         race_AbandonRaceCheck(p);
1053 }
1054
1055 void race_PreparePlayer()
1056 {
1057         race_ClearTime(self);
1058         self.race_place = 0;
1059         self.race_started = 0;
1060         self.race_respawn_checkpoint = 0;
1061         self.race_respawn_spotref = world;
1062 }
1063
1064 void race_RetractPlayer()
1065 {
1066         if(!g_race && !g_cts)
1067                 return;
1068         if(self.race_respawn_checkpoint == 0 || self.race_respawn_checkpoint == race_timed_checkpoint)
1069                 race_ClearTime(self);
1070         self.race_checkpoint = self.race_respawn_checkpoint;
1071 }
1072
1073 void race_PreDie()
1074 {
1075         if(!g_race && !g_cts)
1076                 return;
1077
1078         race_AbandonRaceCheck(self);
1079 }
1080
1081 void race_PreSpawn()
1082 {
1083         if(!g_race && !g_cts)
1084                 return;
1085         if(self.killcount == -666 /* initial spawn */ || g_race_qualifying) // spawn
1086                 race_PreparePlayer();
1087         else // respawn
1088                 race_RetractPlayer();
1089
1090         race_AbandonRaceCheck(self);
1091 }
1092
1093 void race_PostSpawn(entity spot)
1094 {
1095         if(!g_race && !g_cts)
1096                 return;
1097
1098         if(spot.target == "")
1099                 // Emergency: this wasn't a real spawnpoint. Can this ever happen?
1100                 race_PreparePlayer();
1101
1102         // if we need to respawn, do it right
1103         self.race_respawn_checkpoint = self.race_checkpoint;
1104         self.race_respawn_spotref = spot;
1105
1106         self.race_place = 0;
1107 }
1108
1109 void race_PreSpawnObserver()
1110 {
1111         if(!g_race && !g_cts)
1112                 return;
1113         race_PreparePlayer();
1114         self.race_checkpoint = -1;
1115 }
1116
1117 void spawnfunc_info_player_race (void)
1118 {
1119         if(!g_race && !g_cts)
1120         {
1121                 remove(self);
1122                 return;
1123         }
1124         ++race_spawns;
1125         spawnfunc_info_player_deathmatch();
1126
1127         if(self.race_place > race_highest_place_spawn)
1128                 race_highest_place_spawn = self.race_place;
1129         if(self.race_place < race_lowest_place_spawn)
1130                 race_lowest_place_spawn = self.race_place;
1131 }
1132
1133 void race_ClearRecords()
1134 {
1135         float i;
1136         entity e;
1137
1138         for(i = 0; i < MAX_CHECKPOINTS; ++i)
1139         {
1140                 race_checkpoint_records[i] = 0;
1141                 if(race_checkpoint_recordholders[i])
1142                         strunzone(race_checkpoint_recordholders[i]);
1143                 race_checkpoint_recordholders[i] = string_null;
1144         }
1145
1146         e = self;
1147         FOR_EACH_CLIENT(self)
1148         {
1149                 float p;
1150                 p = self.race_place;
1151                 race_PreparePlayer();
1152                 self.race_place = p;
1153         }
1154         self = e;
1155 }
1156
1157 void race_ReadyRestart()
1158 {
1159         float s;
1160
1161         Score_NicePrint(world);
1162
1163         race_ClearRecords();
1164         PlayerScore_Sort(race_place);
1165
1166         entity e;
1167         FOR_EACH_CLIENT(e)
1168         {
1169                 if(e.race_place)
1170                 {
1171                         s = PlayerScore_Add(e, SP_RACE_FASTEST, 0);
1172                         if(!s)
1173                                 e.race_place = 0;
1174                 }
1175                 print(e.netname, " = ", ftos(e.race_place), "\n");
1176         }
1177
1178         if(g_race_qualifying == 2)
1179         {
1180                 g_race_qualifying = 0;
1181                 independent_players = 0;
1182                 cvar_set("fraglimit", ftos(race_fraglimit));
1183                 cvar_set("leadlimit", ftos(race_leadlimit));
1184                 cvar_set("timelimit", ftos(race_timelimit));
1185                 ScoreRules_race();
1186         }
1187 }
1188
1189 void race_ImposePenaltyTime(entity pl, float penalty, string reason)
1190 {
1191         if(g_race_qualifying)
1192         {
1193                 pl.race_penalty_accumulator += penalty;
1194                 msg_entity = pl;
1195                 WRITESPECTATABLE_MSG_ONE({
1196                         WriteByte(MSG_ONE, SVC_TEMPENTITY);
1197                         WriteByte(MSG_ONE, TE_CSQC_RACE);
1198                         WriteByte(MSG_ONE, RACE_NET_PENALTY_QUALIFYING);
1199                         WriteShort(MSG_ONE, TIME_ENCODE(penalty));
1200                         WriteString(MSG_ONE, reason);
1201                 });
1202         }
1203         else
1204         {
1205                 pl.race_penalty = time + penalty;
1206                 msg_entity = pl;
1207                 WRITESPECTATABLE_MSG_ONE_VARNAME(dummy, {
1208                         WriteByte(MSG_ONE, SVC_TEMPENTITY);
1209                         WriteByte(MSG_ONE, TE_CSQC_RACE);
1210                         WriteByte(MSG_ONE, RACE_NET_PENALTY_RACE);
1211                         WriteShort(MSG_ONE, TIME_ENCODE(penalty));
1212                         WriteString(MSG_ONE, reason);
1213                 });
1214         }
1215 }
1216
1217 void penalty_touch()
1218 {
1219         EXACTTRIGGER_TOUCH;
1220         if(other.race_lastpenalty != self)
1221         {
1222                 other.race_lastpenalty = self;
1223                 race_ImposePenaltyTime(other, self.race_penalty, self.race_penalty_reason);
1224         }
1225 }
1226
1227 void penalty_use()
1228 {
1229         race_ImposePenaltyTime(activator, self.race_penalty, self.race_penalty_reason);
1230 }
1231
1232 void spawnfunc_trigger_race_penalty()
1233 {
1234         EXACTTRIGGER_INIT;
1235
1236         self.use = penalty_use;
1237         if not(self.spawnflags & 1)
1238                 self.touch = penalty_touch;
1239
1240         if (!self.race_penalty_reason)
1241                 self.race_penalty_reason = "missing a checkpoint";
1242         if (!self.race_penalty)
1243                 self.race_penalty = 5;
1244 }