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, PlayerPhysics)
 106 {
 107         entity player = M_ARGV(0, entity);
 108         float dt = M_ARGV(1, float);
 109
 110         player.race_movetime_frac += dt;
 111         float f = floor(player.race_movetime_frac);
 112         player.race_movetime_frac -= f;
 113         player.race_movetime_count += f;
 114         player.race_movetime = player.race_movetime_frac + player.race_movetime_count;
 115
 116 #ifdef SVQC
 117         if(IS_PLAYER(player))
 118         {
 119                 if (player.race_penalty)
 120                         if (time > player.race_penalty)
 121                                 player.race_penalty = 0;
 122                 if(player.race_penalty)
 123                 {
 124                         player.velocity = '0 0 0';
 125                         set_movetype(player, MOVETYPE_NONE);
 126                         player.disableclientprediction = 2;
 127                 }
 128         }
 129 #endif
 130
 131         // force kbd movement for fairness
 132         float wishspeed;
 133         vector wishvel;
 134
 135         // if record times matter
 136         // ensure nothing EVIL is being done (i.e. div0_evade)
 137         // this hinders joystick users though
 138         // but it still gives SOME analog control
 139         wishvel.x = fabs(player.movement.x);
 140         wishvel.y = fabs(player.movement.y);
 141         if(wishvel.x != 0 && wishvel.y != 0 && wishvel.x != wishvel.y)
 142         {
 143                 wishvel.z = 0;
 144                 wishspeed = vlen(wishvel);
 145                 if(wishvel.x >= 2 * wishvel.y)
 146                 {
 147                         // pure X motion
 148                         if(player.movement.x > 0)
 149                                 player.movement_x = wishspeed;
 150                         else
 151                                 player.movement_x = -wishspeed;
 152                         player.movement_y = 0;
 153                 }
 154                 else if(wishvel.y >= 2 * wishvel.x)
 155                 {
 156                         // pure Y motion
 157                         player.movement_x = 0;
 158                         if(player.movement.y > 0)
 159                                 player.movement_y = wishspeed;
 160                         else
 161                                 player.movement_y = -wishspeed;
 162                 }
 163                 else
 164                 {
 165                         // diagonal
 166                         if(player.movement.x > 0)
 167                                 player.movement_x = M_SQRT1_2 * wishspeed;
 168                         else
 169                                 player.movement_x = -M_SQRT1_2 * wishspeed;
 170                         if(player.movement.y > 0)
 171                                 player.movement_y = M_SQRT1_2 * wishspeed;
 172                         else
 173                                 player.movement_y = -M_SQRT1_2 * wishspeed;
 174                 }
 175         }
 176 }
 177
 178 MUTATOR_HOOKFUNCTION(rc, reset_map_global)
 179 {
 180         float s;
 181
 182         Score_NicePrint(NULL);
 183
 184         race_ClearRecords();
 185         PlayerScore_Sort(race_place, 0, 1, 0);
 186
 187         FOREACH_CLIENT(true, LAMBDA(
 188                 if(it.race_place)
 189                 {
 190                         s = PlayerScore_Add(it, SP_RACE_FASTEST, 0);
 191                         if(!s)
 192                                 it.race_place = 0;
 193                 }
 194                 race_EventLog(ftos(it.race_place), it);
 195         ));
 196
 197         if(g_race_qualifying == 2)
 198         {
 199                 g_race_qualifying = 0;
 200                 independent_players = 0;
 201                 cvar_set("fraglimit", ftos(race_fraglimit));
 202                 cvar_set("leadlimit", ftos(race_leadlimit));
 203                 cvar_set("timelimit", ftos(race_timelimit));
 204                 race_ScoreRules();
 205         }
 206 }
 207
 208 MUTATOR_HOOKFUNCTION(rc, ClientConnect)
 209 {
 210         entity player = M_ARGV(0, entity);
 211
 212         race_PreparePlayer(player);
 213         player.race_checkpoint = -1;
 214
 215         string rr = RACE_RECORD;
 216
 217         if(IS_REAL_CLIENT(player))
 218         {
 219                 msg_entity = player;
 220                 race_send_recordtime(MSG_ONE);
 221                 race_send_speedaward(MSG_ONE);
 222
 223                 speedaward_alltimebest = stof(db_get(ServerProgsDB, strcat(GetMapname(), rr, "speed/speed")));
 224                 speedaward_alltimebest_holder = uid2name(db_get(ServerProgsDB, strcat(GetMapname(), rr, "speed/crypto_idfp")));
 225                 race_send_speedaward_alltimebest(MSG_ONE);
 226
 227                 float i;
 228                 for (i = 1; i <= RANKINGS_CNT; ++i)
 229                 {
 230                         race_SendRankings(i, 0, 0, MSG_ONE);
 231                 }
 232         }
 233 }
 234
 235 MUTATOR_HOOKFUNCTION(rc, MakePlayerObserver)
 236 {
 237         entity player = M_ARGV(0, entity);
 238
 239         if(g_race_qualifying)
 240         if(PlayerScore_Add(player, SP_RACE_FASTEST, 0))
 241                 player.frags = FRAGS_LMS_LOSER;
 242         else
 243                 player.frags = FRAGS_SPECTATOR;
 244
 245         race_PreparePlayer(player);
 246         player.race_checkpoint = -1;
 247 }
 248
 249 MUTATOR_HOOKFUNCTION(rc, PlayerSpawn)
 250 {
 251         entity player = M_ARGV(0, entity);
 252         entity spawn_spot = M_ARGV(1, entity);
 253
 254         if(spawn_spot.target == "")
 255                 // Emergency: this wasn't a real spawnpoint. Can this ever happen?
 256                 race_PreparePlayer(player);
 257
 258         // if we need to respawn, do it right
 259         player.race_respawn_checkpoint = player.race_checkpoint;
 260         player.race_respawn_spotref = spawn_spot;
 261
 262         player.race_place = 0;
 263 }
 264
 265 MUTATOR_HOOKFUNCTION(rc, PutClientInServer)
 266 {
 267         entity player = M_ARGV(0, entity);
 268
 269         if(IS_PLAYER(player))
 270         if(!gameover)
 271         {
 272                 if(player.killcount == FRAGS_SPECTATOR /* initial spawn */ || g_race_qualifying) // spawn
 273                         race_PreparePlayer(player);
 274                 else // respawn
 275                         race_RetractPlayer(player);
 276
 277                 race_AbandonRaceCheck(player);
 278         }
 279 }
 280
 281 MUTATOR_HOOKFUNCTION(rc, PlayerDies)
 282 {
 283         entity frag_target = M_ARGV(2, entity);
 284
 285         frag_target.respawn_flags |= RESPAWN_FORCE;
 286         race_AbandonRaceCheck(frag_target);
 287 }
 288
 289 MUTATOR_HOOKFUNCTION(rc, HavocBot_ChooseRole)
 290 {
 291         entity bot = M_ARGV(0, entity);
 292
 293         bot.havocbot_role = havocbot_role_race;
 294         return true;
 295 }
 296
 297 MUTATOR_HOOKFUNCTION(rc, GetPressedKeys)
 298 {
 299         entity player = M_ARGV(0, entity);
 300
 301         if(player.cvar_cl_allow_uidtracking == 1 && player.cvar_cl_allow_uid2name == 1)
 302         {
 303                 if (!player.stored_netname)
 304                         player.stored_netname = strzone(uid2name(player.crypto_idfp));
 305                 if(player.stored_netname != player.netname)
 306                 {
 307                         db_put(ServerProgsDB, strcat("/uid2name/", player.crypto_idfp), player.netname);
 308                         strunzone(player.stored_netname);
 309                         player.stored_netname = strzone(player.netname);
 310                 }
 311         }
 312
 313         if (!IS_OBSERVER(player))
 314         {
 315                 if(vdist(player.velocity - player.velocity_z * '0 0 1', >, speedaward_speed))
 316                 {
 317                         speedaward_speed = vlen(player.velocity - player.velocity_z * '0 0 1');
 318                         speedaward_holder = player.netname;
 319                         speedaward_uid = player.crypto_idfp;
 320                         speedaward_lastupdate = time;
 321                 }
 322                 if (speedaward_speed > speedaward_lastsent && time - speedaward_lastupdate > 1)
 323                 {
 324                         string rr = RACE_RECORD;
 325                         race_send_speedaward(MSG_ALL);
 326                         speedaward_lastsent = speedaward_speed;
 327                         if (speedaward_speed > speedaward_alltimebest && speedaward_uid != "")
 328                         {
 329                                 speedaward_alltimebest = speedaward_speed;
 330                                 speedaward_alltimebest_holder = speedaward_holder;
 331                                 speedaward_alltimebest_uid = speedaward_uid;
 332                                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "speed/speed"), ftos(speedaward_alltimebest));
 333                                 db_put(ServerProgsDB, strcat(GetMapname(), rr, "speed/crypto_idfp"), speedaward_alltimebest_uid);
 334                                 race_send_speedaward_alltimebest(MSG_ALL);
 335                         }
 336                 }
 337         }
 338 }
 339
 340 MUTATOR_HOOKFUNCTION(rc, ForbidPlayerScore_Clear)
 341 {
 342         if(g_race_qualifying)
 343                 return true; // in qualifying, you don't lose score by observing
 344 }
 345
 346 MUTATOR_HOOKFUNCTION(rc, CheckAllowedTeams, CBC_ORDER_EXCLUSIVE)
 347 {
 348         M_ARGV(0, float) = race_teams;
 349 }
 350
 351 MUTATOR_HOOKFUNCTION(rc, Scores_CountFragsRemaining)
 352 {
 353         // announce remaining frags if not in qualifying mode
 354         if(!g_race_qualifying)
 355                 return true;
 356 }
 357
 358 MUTATOR_HOOKFUNCTION(rc, GetRecords)
 359 {
 360         int record_page = M_ARGV(0, int);
 361         string ret_string = M_ARGV(1, string);
 362
 363         for(int i = record_page * 200; i < MapInfo_count && i < record_page * 200 + 200; ++i)
 364         {
 365                 if(MapInfo_Get_ByID(i))
 366                 {
 367                         float r = race_readTime(MapInfo_Map_bspname, 1);
 368
 369                         if(!r)
 370                                 continue;
 371
 372                         string h = race_readName(MapInfo_Map_bspname, 1);
 373                         ret_string = strcat(ret_string, strpad(32, MapInfo_Map_bspname), " ", strpad(-8, TIME_ENCODED_TOSTRING(r)), " ", h, "\n");
 374                 }
 375         }
 376
 377         M_ARGV(1, string) = ret_string;
 378 }
 379
 380 MUTATOR_HOOKFUNCTION(rc, FixClientCvars)
 381 {
 382         entity player = M_ARGV(0, entity);
 383
 384         stuffcmd(player, "cl_cmd settemp cl_movecliptokeyboard 2\n");
 385 }
 386
 387 MUTATOR_HOOKFUNCTION(rc, CheckRules_World)
 388 {
 389         float checkrules_timelimit = M_ARGV(1, float);
 390         float checkrules_fraglimit = M_ARGV(2, float);
 391
 392         if(checkrules_timelimit >= 0)
 393         {
 394                 if(!g_race_qualifying)
 395                 {
 396                         M_ARGV(0, float) = WinningCondition_Race(checkrules_fraglimit);
 397                         return true;
 398                 }
 399                 else if(g_race_qualifying == 2)
 400                 {
 401                         M_ARGV(0, float) = WinningCondition_QualifyingThenRace(checkrules_fraglimit);
 402                         return true;
 403                 }
 404         }
 405 }
 406
 407 MUTATOR_HOOKFUNCTION(rc, ReadLevelCvars)
 408 {
 409         if(g_race_qualifying == 2)
 410                 warmup_stage = 0;
 411 }
 412
 413 void race_Initialize()
 414 {
 415         race_ScoreRules();
 416         if(g_race_qualifying == 2)
 417                 warmup_stage = 0;
 418 }
 419
 420 void rc_SetLimits()
 421 {
 422         int fraglimit_override, leadlimit_override;
 423         float timelimit_override, qualifying_override;
 424
 425         if(autocvar_g_race_teams)
 426         {
 427                 ActivateTeamplay();
 428                 race_teams = bound(2, autocvar_g_race_teams, 4);
 429                 int teams = 0;
 430                 if(race_teams >= 1) teams |= BIT(0);
 431                 if(race_teams >= 2) teams |= BIT(1);
 432                 if(race_teams >= 3) teams |= BIT(2);
 433                 if(race_teams >= 4) teams |= BIT(3);
 434
 435                 race_teams = teams; // now set it?
 436
 437                 have_team_spawns = -1; // request team spawns
 438         }
 439         else
 440                 race_teams = 0;
 441
 442         qualifying_override = autocvar_g_race_qualifying_timelimit_override;
 443         fraglimit_override = autocvar_g_race_laps_limit;
 444         leadlimit_override = 0; // currently not supported by race
 445         timelimit_override = autocvar_timelimit_override;
 446
 447         float want_qualifying = ((qualifying_override >= 0) ? qualifying_override : autocvar_g_race_qualifying_timelimit) > 0;
 448
 449         if(autocvar_g_campaign)
 450         {
 451                 g_race_qualifying = 1;
 452                 independent_players = 1;
 453         }
 454         else if(want_qualifying)
 455         {
 456                 g_race_qualifying = 2;
 457                 independent_players = 1;
 458                 race_fraglimit = (fraglimit_override >= 0) ? fraglimit_override : autocvar_fraglimit;
 459                 race_leadlimit = (leadlimit_override >= 0) ? leadlimit_override : autocvar_leadlimit;
 460                 race_timelimit = (timelimit_override >= 0) ? timelimit_override : autocvar_timelimit;
 461                 qualifying_override = (qualifying_override >= 0) ? qualifying_override : autocvar_g_race_qualifying_timelimit;
 462                 fraglimit_override = 0;
 463                 leadlimit_override = 0;
 464                 timelimit_override = qualifying_override;
 465         }
 466         else
 467                 g_race_qualifying = 0;
 468         SetLimits(fraglimit_override, leadlimit_override, timelimit_override, qualifying_override);
 469 }