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