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