qcsrc/server/mutators/mutator/gamemode_race.qc

   1 #include "gamemode_race.qh"
   2
   3 #include <server/race.qh>
   4
   5 #define autocvar_g_race_laps_limit cvar("g_race_laps_limit")
   6 float autocvar_g_race_qualifying_timelimit;
   7 float autocvar_g_race_qualifying_timelimit_override;
   8 int autocvar_g_race_teams;
   9
  10 // legacy bot roles
  11 .float race_checkpoint;
  12 void havocbot_role_race(entity this)
  13 {
  14         if(IS_DEAD(this))
  15                 return;
  16
  17         if (this.bot_strategytime < time)
  18         {
  19                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
  20                 navigation_goalrating_start(this);
  21
  22                 IL_EACH(g_racecheckpoints, true,
  23                 {
  24                         if(it.cnt == this.race_checkpoint)
  25                         {
  26                                 navigation_routerating(this, it, 1000000, 5000);
  27                         }
  28                         else if(this.race_checkpoint == -1)
  29                         {
  30                                 navigation_routerating(this, it, 1000000, 5000);
  31                         }
  32                 });
  33
  34                 navigation_goalrating_end(this);
  35         }
  36 }
  37
  38 void race_ScoreRules()
  39 {
  40         ScoreRules_basics(race_teams, 0, 0, false);
  41         if(race_teams)
  42         {
  43                 ScoreInfo_SetLabel_TeamScore(  ST_RACE_LAPS,    "laps",       SFL_SORT_PRIO_PRIMARY);
  44                 ScoreInfo_SetLabel_PlayerScore(SP_RACE_LAPS,    "laps",      SFL_SORT_PRIO_PRIMARY);
  45                 ScoreInfo_SetLabel_PlayerScore(SP_RACE_TIME,    "time",      SFL_SORT_PRIO_SECONDARY | SFL_LOWER_IS_BETTER | SFL_TIME);
  46                 ScoreInfo_SetLabel_PlayerScore(SP_RACE_FASTEST, "fastest",   SFL_LOWER_IS_BETTER | SFL_TIME);
  47         }
  48         else if(g_race_qualifying)
  49         {
  50                 ScoreInfo_SetLabel_PlayerScore(SP_RACE_FASTEST, "fastest",   SFL_SORT_PRIO_PRIMARY | SFL_LOWER_IS_BETTER | SFL_TIME);
  51         }
  52         else
  53         {
  54                 ScoreInfo_SetLabel_PlayerScore(SP_RACE_LAPS,    "laps",      SFL_SORT_PRIO_PRIMARY);
  55                 ScoreInfo_SetLabel_PlayerScore(SP_RACE_TIME,    "time",      SFL_SORT_PRIO_SECONDARY | SFL_LOWER_IS_BETTER | SFL_TIME);
  56                 ScoreInfo_SetLabel_PlayerScore(SP_RACE_FASTEST, "fastest",   SFL_LOWER_IS_BETTER | SFL_TIME);
  57         }
  58         ScoreRules_basics_end();
  59 }
  60
  61 void race_EventLog(string mode, entity actor) // use an alias for easy changing and quick editing later
  62 {
  63         if(autocvar_sv_eventlog)
  64                 GameLogEcho(strcat(":race:", mode, ":", ((actor != NULL) ? (strcat(":", ftos(actor.playerid))) : "")));
  65 }
  66
  67 float WinningCondition_Race(float fraglimit)
  68 {
  69         float wc;
  70         float n, c;
  71
  72         n = 0;
  73         c = 0;
  74         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
  75                 ++n;
  76                 if(it.race_completed)
  77                         ++c;
  78         ));
  79         if(n && (n == c))
  80                 return WINNING_YES;
  81         wc = WinningCondition_Scores(fraglimit, 0);
  82
  83         // ALWAYS initiate overtime, unless EVERYONE has finished the race!
  84         if(wc == WINNING_YES || wc == WINNING_STARTSUDDENDEATHOVERTIME)
  85         // do NOT support equality when the laps are all raced!
  86                 return WINNING_STARTSUDDENDEATHOVERTIME;
  87         else
  88                 return WINNING_NEVER;
  89 }
  90
  91 float WinningCondition_QualifyingThenRace(float limit)
  92 {
  93         float wc;
  94         wc = WinningCondition_Scores(limit, 0);
  95
  96         // NEVER initiate overtime
  97         if(wc == WINNING_YES || wc == WINNING_STARTSUDDENDEATHOVERTIME)
  98         {
  99                 return WINNING_YES;
 100         }
 101
 102         return wc;
 103 }
 104
 105 MUTATOR_HOOKFUNCTION(rc, AbortSpeedrun)
 106 {
 107         entity player = M_ARGV(0, entity);
 108
 109         if(autocvar_g_allow_checkpoints)
 110                 race_PreparePlayer(player); // nice try
 111 }
 112
 113 MUTATOR_HOOKFUNCTION(rc, PlayerPhysics)
 114 {
 115         entity player = M_ARGV(0, entity);
 116         float dt = M_ARGV(1, float);
 117
 118         player.race_movetime_frac += dt;
 119         float f = floor(player.race_movetime_frac);
 120         player.race_movetime_frac -= f;
 121         player.race_movetime_count += f;
 122         player.race_movetime = player.race_movetime_frac + player.race_movetime_count;
 123
 124 #ifdef SVQC
 125         if(IS_PLAYER(player))
 126         {
 127                 if (player.race_penalty)
 128                         if (time > player.race_penalty)
 129                                 player.race_penalty = 0;
 130                 if(player.race_penalty)
 131                 {
 132                         player.velocity = '0 0 0';
 133                         set_movetype(player, MOVETYPE_NONE);
 134                         player.disableclientprediction = 2;
 135                 }
 136         }
 137 #endif
 138
 139         // force kbd movement for fairness
 140         float wishspeed;
 141         vector wishvel;
 142
 143         // if record times matter
 144         // ensure nothing EVIL is being done (i.e. div0_evade)
 145         // this hinders joystick users though
 146         // but it still gives SOME analog control
 147         wishvel.x = fabs(player.movement.x);
 148         wishvel.y = fabs(player.movement.y);
 149         if(wishvel.x != 0 && wishvel.y != 0 && wishvel.x != wishvel.y)
 150         {
 151                 wishvel.z = 0;
 152                 wishspeed = vlen(wishvel);
 153                 if(wishvel.x >= 2 * wishvel.y)
 154                 {
 155                         // pure X motion
 156                         if(player.movement.x > 0)
 157                                 player.movement_x = wishspeed;
 158                         else
 159                                 player.movement_x = -wishspeed;
 160                         player.movement_y = 0;
 161                 }
 162                 else if(wishvel.y >= 2 * wishvel.x)
 163                 {
 164                         // pure Y motion
 165                         player.movement_x = 0;
 166                         if(player.movement.y > 0)
 167                                 player.movement_y = wishspeed;
 168                         else
 169                                 player.movement_y = -wishspeed;
 170                 }
 171                 else
 172                 {
 173                         // diagonal
 174                         if(player.movement.x > 0)
 175                                 player.movement_x = M_SQRT1_2 * wishspeed;
 176                         else
 177                                 player.movement_x = -M_SQRT1_2 * wishspeed;
 178                         if(player.movement.y > 0)
 179                                 player.movement_y = M_SQRT1_2 * wishspeed;
 180                         else
 181                                 player.movement_y = -M_SQRT1_2 * wishspeed;
 182                 }
 183         }
 184 }
 185
 186 MUTATOR_HOOKFUNCTION(rc, reset_map_global)
 187 {
 188         float s;
 189
 190         Score_NicePrint(NULL);
 191
 192         race_ClearRecords();
 193         PlayerScore_Sort(race_place, 0, 1, 0);
 194
 195         FOREACH_CLIENT(true, LAMBDA(
 196                 if(it.race_place)
 197                 {
 198                         s = PlayerScore_Add(it, SP_RACE_FASTEST, 0);
 199                         if(!s)
 200                                 it.race_place = 0;
 201                 }
 202                 race_EventLog(ftos(it.race_place), it);
 203         ));
 204
 205         if(g_race_qualifying == 2)
 206         {
 207                 g_race_qualifying = 0;
 208                 independent_players = 0;
 209                 cvar_set("fraglimit", ftos(race_fraglimit));
 210                 cvar_set("leadlimit", ftos(race_leadlimit));
 211                 cvar_set("timelimit", ftos(race_timelimit));
 212                 race_ScoreRules();
 213         }
 214 }
 215
 216 MUTATOR_HOOKFUNCTION(rc, ClientConnect)
 217 {
 218         entity player = M_ARGV(0, entity);
 219
 220         race_PreparePlayer(player);
 221         player.race_checkpoint = -1;
 222
 223         string rr = RACE_RECORD;
 224
 225         if(IS_REAL_CLIENT(player))
 226         {
 227                 msg_entity = player;
 228                 race_send_recordtime(MSG_ONE);
 229                 race_send_speedaward(MSG_ONE);
 230
 231                 speedaward_alltimebest = stof(db_get(ServerProgsDB, strcat(GetMapname(), rr, "speed/speed")));
 232                 speedaward_alltimebest_holder = uid2name(db_get(ServerProgsDB, strcat(GetMapname(), rr, "speed/crypto_idfp")));
 233                 race_send_speedaward_alltimebest(MSG_ONE);
 234
 235                 float i;
 236                 for (i = 1; i <= RANKINGS_CNT; ++i)
 237                 {
 238                         race_SendRankings(i, 0, 0, MSG_ONE);
 239                 }
 240         }
 241 }
 242
 243 MUTATOR_HOOKFUNCTION(rc, MakePlayerObserver)
 244 {
 245         entity player = M_ARGV(0, entity);
 246
 247         if(g_race_qualifying)
 248         if(PlayerScore_Add(player, SP_RACE_FASTEST, 0))
 249                 player.frags = FRAGS_LMS_LOSER;
 250         else
 251                 player.frags = FRAGS_SPECTATOR;
 252
 253         race_PreparePlayer(player);
 254         player.race_checkpoint = -1;
 255 }
 256
 257 MUTATOR_HOOKFUNCTION(rc, PlayerSpawn)
 258 {
 259         entity player = M_ARGV(0, entity);
 260         entity spawn_spot = M_ARGV(1, entity);
 261
 262         if(spawn_spot.target == "")
 263                 // Emergency: this wasn't a real spawnpoint. Can this ever happen?
 264                 race_PreparePlayer(player);
 265
 266         // if we need to respawn, do it right
 267         player.race_respawn_checkpoint = player.race_checkpoint;
 268         player.race_respawn_spotref = spawn_spot;
 269
 270         player.race_place = 0;
 271 }
 272
 273 MUTATOR_HOOKFUNCTION(rc, PutClientInServer)
 274 {
 275         entity player = M_ARGV(0, entity);
 276
 277         if(IS_PLAYER(player))
 278         if(!game_stopped)
 279         {
 280                 if(player.killcount == FRAGS_SPECTATOR /* initial spawn */ || g_race_qualifying) // spawn
 281                         race_PreparePlayer(player);
 282                 else // respawn
 283                         race_RetractPlayer(player);
 284
 285                 race_AbandonRaceCheck(player);
 286         }
 287 }
 288
 289 MUTATOR_HOOKFUNCTION(rc, PlayerDies)
 290 {
 291         entity frag_target = M_ARGV(2, entity);
 292
 293         frag_target.respawn_flags |= RESPAWN_FORCE;
 294         race_AbandonRaceCheck(frag_target);
 295 }
 296
 297 MUTATOR_HOOKFUNCTION(rc, HavocBot_ChooseRole)
 298 {
 299         entity bot = M_ARGV(0, entity);
 300
 301         bot.havocbot_role = havocbot_role_race;
 302         return true;
 303 }
 304
 305 MUTATOR_HOOKFUNCTION(rc, GetPressedKeys)
 306 {
 307         entity player = M_ARGV(0, entity);
 308
 309         if(player.cvar_cl_allow_uidtracking == 1 && player.cvar_cl_allow_uid2name == 1)
 310         {
 311                 if (!player.stored_netname)
 312                         player.stored_netname = strzone(uid2name(player.crypto_idfp));
 313                 if(player.stored_netname != player.netname)
 314                 {
 315                         db_put(ServerProgsDB, strcat("/uid2name/", player.crypto_idfp), player.netname);
 316                         strunzone(player.stored_netname);
 317                         player.stored_netname = strzone(player.netname);
 318                 }
 319         }
 320
 321         if (!IS_OBSERVER(player))
 322         {
 323                 if(vdist(player.velocity - player.velocity_z * '0 0 1', >, speedaward_speed))
 324                 {
 325                         speedaward_speed = vlen(player.velocity - player.velocity_z * '0 0 1');
 326                         speedaward_holder = player.netname;
 327                         speedaward_uid = player.crypto_idfp;
 328                         speedaward_lastupdate = time;
 329                 }
 330                 if (speedaward_speed > speedaward_lastsent && time - speedaward_lastupdate > 1)
 331                 {
 332                         string rr = RACE_RECORD;
 333                         race_send_speedaward(MSG_ALL);
 334                         speedaward_lastsent = speedaward_speed;
 335                         if (speedaward_speed > speedaward_alltimebest && speedaward_uid != "")
 336                         {
 337                                 speedaward_alltimebest = speedaward_speed;
 338                                 speedaward_alltimebest_holder = speedaward_holder;
 339                                 speedaward_alltimebest_uid = speedaward_uid;
 340                                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "speed/speed"), ftos(speedaward_alltimebest));
 341                                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "speed/crypto_idfp"), speedaward_alltimebest_uid);
 342                                 race_send_speedaward_alltimebest(MSG_ALL);
 343                         }
 344                 }
 345         }
 346 }
 347
 348 MUTATOR_HOOKFUNCTION(rc, ForbidPlayerScore_Clear)
 349 {
 350         if(g_race_qualifying)
 351                 return true; // in qualifying, you don't lose score by observing
 352 }
 353
 354 MUTATOR_HOOKFUNCTION(rc, CheckAllowedTeams, CBC_ORDER_EXCLUSIVE)
 355 {
 356         M_ARGV(0, float) = race_teams;
 357 }
 358
 359 MUTATOR_HOOKFUNCTION(rc, Scores_CountFragsRemaining)
 360 {
 361         // announce remaining frags if not in qualifying mode
 362         if(!g_race_qualifying)
 363                 return true;
 364 }
 365
 366 MUTATOR_HOOKFUNCTION(rc, GetRecords)
 367 {
 368         int record_page = M_ARGV(0, int);
 369         string ret_string = M_ARGV(1, string);
 370
 371         for(int i = record_page * 200; i < MapInfo_count && i < record_page * 200 + 200; ++i)
 372         {
 373                 if(MapInfo_Get_ByID(i))
 374                 {
 375                         float r = race_readTime(MapInfo_Map_bspname, 1);
 376
 377                         if(!r)
 378                                 continue;
 379
 380                         string h = race_readName(MapInfo_Map_bspname, 1);
 381                         ret_string = strcat(ret_string, strpad(32, MapInfo_Map_bspname), " ", strpad(-8, TIME_ENCODED_TOSTRING(r)), " ", h, "\n");
 382                 }
 383         }
 384
 385         M_ARGV(1, string) = ret_string;
 386 }
 387
 388 MUTATOR_HOOKFUNCTION(rc, HideTeamNagger)
 389 {
 390         return true; // doesn't work so well
 391 }
 392
 393 MUTATOR_HOOKFUNCTION(rc, FixClientCvars)
 394 {
 395         entity player = M_ARGV(0, entity);
 396
 397         stuffcmd(player, "cl_cmd settemp cl_movecliptokeyboard 2\n");
 398 }
 399
 400 MUTATOR_HOOKFUNCTION(rc, CheckRules_World)
 401 {
 402         float checkrules_timelimit = M_ARGV(1, float);
 403         float checkrules_fraglimit = M_ARGV(2, float);
 404
 405         if(checkrules_timelimit >= 0)
 406         {
 407                 if(!g_race_qualifying)
 408                 {
 409                         M_ARGV(0, float) = WinningCondition_Race(checkrules_fraglimit);
 410                         return true;
 411                 }
 412                 else if(g_race_qualifying == 2)
 413                 {
 414                         M_ARGV(0, float) = WinningCondition_QualifyingThenRace(checkrules_fraglimit);
 415                         return true;
 416                 }
 417         }
 418 }
 419
 420 MUTATOR_HOOKFUNCTION(rc, ReadLevelCvars)
 421 {
 422         if(g_race_qualifying == 2)
 423                 warmup_stage = 0;
 424 }
 425
 426 void race_Initialize()
 427 {
 428         race_ScoreRules();
 429         if(g_race_qualifying == 2)
 430                 warmup_stage = 0;
 431 }
 432
 433 void rc_SetLimits()
 434 {
 435         int fraglimit_override, leadlimit_override;
 436         float timelimit_override, qualifying_override;
 437
 438         if(autocvar_g_race_teams)
 439         {
 440                 ActivateTeamplay();
 441                 race_teams = bound(2, autocvar_g_race_teams, 4);
 442                 int teams = 0;
 443                 if(race_teams >= 1) teams |= BIT(0);
 444                 if(race_teams >= 2) teams |= BIT(1);
 445                 if(race_teams >= 3) teams |= BIT(2);
 446                 if(race_teams >= 4) teams |= BIT(3);
 447
 448                 race_teams = teams; // now set it?
 449
 450                 have_team_spawns = -1; // request team spawns
 451         }
 452         else
 453                 race_teams = 0;
 454
 455         qualifying_override = autocvar_g_race_qualifying_timelimit_override;
 456         fraglimit_override = autocvar_g_race_laps_limit;
 457         leadlimit_override = 0; // currently not supported by race
 458         timelimit_override = autocvar_timelimit_override;
 459
 460         float want_qualifying = ((qualifying_override >= 0) ? qualifying_override : autocvar_g_race_qualifying_timelimit) > 0;
 461
 462         if(autocvar_g_campaign)
 463         {
 464                 g_race_qualifying = 1;
 465                 independent_players = 1;
 466         }
 467         else if(want_qualifying)
 468         {
 469                 g_race_qualifying = 2;
 470                 independent_players = 1;
 471                 race_fraglimit = (fraglimit_override >= 0) ? fraglimit_override : autocvar_fraglimit;
 472                 race_leadlimit = (leadlimit_override >= 0) ? leadlimit_override : autocvar_leadlimit;
 473                 race_timelimit = (timelimit_override >= 0) ? timelimit_override : autocvar_timelimit;
 474                 qualifying_override = (qualifying_override >= 0) ? qualifying_override : autocvar_g_race_qualifying_timelimit;
 475                 fraglimit_override = 0;
 476                 leadlimit_override = 0;
 477                 timelimit_override = qualifying_override;
 478         }
 479         else
 480                 g_race_qualifying = 0;
 481         SetLimits(fraglimit_override, leadlimit_override, timelimit_override, qualifying_override);
 482 }