Remove some more g_lms checks & add a use for mega health (disabled by default)
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / arena.qc
1 float maxspawned;
2 float numspawned;
3 float arena_roundbased;
4 .float spawned;
5 .entity spawnqueue_next;
6 .entity spawnqueue_prev;
7 .float spawnqueue_in;
8 entity spawnqueue_first;
9 entity spawnqueue_last;
10 entity champion;
11 float warmup;
12 .float caplayer;
13
14 void PutObserverInServer();
15 void PutClientInServer();
16
17 float next_round;
18 float redalive, bluealive, yellowalive, pinkalive;
19 float totalalive;
20 .float redalive_stat, bluealive_stat, yellowalive_stat, pinkalive_stat;
21 float red_players, blue_players, yellow_players, pink_players;
22 float total_players;
23
24 /**
25  * Resets the state of all clients, items, flags, keys, weapons, waypoints, ... of the map.
26  * Sets the 'warmup' global variable.
27  */
28 void reset_map(float dorespawn)
29 {
30         entity oldself;
31         oldself = self;
32
33         if(g_arena && autocvar_g_arena_warmup)
34                 warmup = time + autocvar_g_arena_warmup;
35         else if(g_ca) {
36                 warmup = time + autocvar_g_ca_warmup;
37                 allowed_to_spawn = 1;
38         }
39         else if(g_freezetag)
40         {
41                 warmup = time + autocvar_g_freezetag_warmup;
42         }
43
44         lms_lowest_lives = 999;
45         lms_next_place = player_count;
46
47         race_ReadyRestart();
48
49         for(self = world; (self = nextent(self)); )
50         if(clienttype(self) == CLIENTTYPE_NOTACLIENT)
51         {
52                 if(self.reset)
53                 {
54                         self.reset();
55                         continue;
56                 }
57
58                 if(self.team_saved)
59                         self.team = self.team_saved;
60
61                 if(self.flags & FL_PROJECTILE) // remove any projectiles left
62                         remove(self);
63         }
64
65         // Waypoints and assault start come LAST
66         for(self = world; (self = nextent(self)); )
67         if(clienttype(self) == CLIENTTYPE_NOTACLIENT)
68         {
69                 if(self.reset2)
70                 {
71                         self.reset2();
72                         continue;
73                 }
74         }
75
76         // Moving the player reset code here since the player-reset depends
77         // on spawnpoint entities which have to be reset first --blub
78         if(dorespawn)
79         FOR_EACH_CLIENT(self) {
80                 if(self.flags & FL_CLIENT)                              // reset all players
81                 {
82                         if(g_arena)
83                         {
84                                 if(self.spawned)
85                                         PutClientInServer();
86                                 else
87                                         PutObserverInServer();
88                         }
89                         else if(g_ca && self.caplayer) {
90                                 self.classname = "player";
91                                 PutClientInServer();
92                         }
93                         else if(g_freezetag)
94                         {
95                                 if(self.classname == "player")
96                                         PutClientInServer();
97                         }
98                         else
99                         {
100                                 /*
101                                 only reset players if a restart countdown is active
102                                 this can either be due to cvar sv_ready_restart_after_countdown having set
103                                 restart_mapalreadyrestarted to 1 after the countdown ended or when
104                                 sv_ready_restart_after_countdown is not used and countdown is still running
105                                 */
106                                 if (restart_mapalreadyrestarted || (time < game_starttime))
107                                 {
108                                         //NEW: changed behaviour so that it prevents that previous spectators/observers suddenly spawn as players
109                                         if (self.classname == "player") {
110                                                 //PlayerScore_Clear(self);
111                                                 self.killcount = 0;
112                                                 //stop the player from moving so that he stands still once he gets respawned
113                                                 self.velocity = '0 0 0';
114                                                 self.avelocity = '0 0 0';
115                                                 self.movement = '0 0 0';
116                                                 PutClientInServer();
117                                         }
118                                 }
119                         }
120                 }
121         }
122
123         if(g_keyhunt)
124                 kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round+(game_starttime - time), kh_StartRound);
125
126         if(g_arena)
127         if(champion && champion.classname == "player" && player_count > 1)
128                 UpdateFrags(champion, +1);
129
130         self = oldself;
131 }
132
133 void Spawnqueue_Insert(entity e)
134 {
135         if(e.spawnqueue_in)
136                 return;
137         dprint(strcat("Into queue: ", e.netname, "\n"));
138         e.spawnqueue_in = TRUE;
139         e.spawnqueue_prev = spawnqueue_last;
140         e.spawnqueue_next = world;
141         if(spawnqueue_last)
142                 spawnqueue_last.spawnqueue_next = e;
143         spawnqueue_last = e;
144         if(!spawnqueue_first)
145                 spawnqueue_first = e;
146 }
147
148 void Spawnqueue_Remove(entity e)
149 {
150         if(!e.spawnqueue_in)
151                 return;
152         dprint(strcat("Out of queue: ", e.netname, "\n"));
153         e.spawnqueue_in = FALSE;
154         if(e == spawnqueue_first)
155                 spawnqueue_first = e.spawnqueue_next;
156         if(e == spawnqueue_last)
157                 spawnqueue_last = e.spawnqueue_prev;
158         if(e.spawnqueue_prev)
159                 e.spawnqueue_prev.spawnqueue_next = e.spawnqueue_next;
160         if(e.spawnqueue_next)
161                 e.spawnqueue_next.spawnqueue_prev = e.spawnqueue_prev;
162         e.spawnqueue_next = world;
163         e.spawnqueue_prev = world;
164 }
165
166 void Spawnqueue_Unmark(entity e)
167 {
168         if(!e.spawned)
169                 return;
170         e.spawned = FALSE;
171         numspawned = numspawned - 1;
172 }
173
174 void Spawnqueue_Mark(entity e)
175 {
176         if(e.spawned)
177                 return;
178         e.spawned = TRUE;
179         numspawned = numspawned + 1;
180 }
181
182 /**
183  * If roundbased arena game mode is active, it centerprints the texts for the
184  * player when player is waiting for the countdown to finish.
185  * Blocks the players movement while countdown is active.
186  * Unblocks the player once the countdown is over.
187  *
188  * Called in StartFrame()
189  */
190 float roundStartTime_prev; // prevent networkspam
191 void Arena_Warmup()
192 {
193         float f;
194         entity e;
195
196         if(gameover)
197         {
198                 if(warmup && time < warmup)
199                 {
200                         Kill_Notification(NOTIF_ALL, world, MSG_CENTER_CPID, CPID_ARENA);
201                         warmup = 0;
202                 }
203                 if(champion && g_arena)
204                 {
205                         FOR_EACH_REALCLIENT(e)
206                                 centerprint(e, strcat("The Champion is ", champion.netname));
207                         champion = world;
208                 }
209                 return;
210         }
211         if((!g_arena && !g_ca && !g_freezetag) || (g_arena && !arena_roundbased) || (time < game_starttime))
212                 return;
213
214         f = ceil(warmup - time);
215
216         if(inWarmupStage)
217                 allowed_to_spawn = 1;
218         else if(!g_ca)
219                 allowed_to_spawn = 0;
220
221         if(time < warmup && !inWarmupStage)
222         {
223                 if (g_ca)
224                         allowed_to_spawn = 1;
225                 if(champion && g_arena)
226                 {
227                         FOR_EACH_REALCLIENT(e)
228                                 centerprint(e, strcat("The Champion is ", champion.netname));
229                 }
230
231                 if(f != roundStartTime_prev) {
232                         roundStartTime_prev = f;
233                         if(g_ca && !(red_players && blue_players)) {
234                                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ARENA_NEEDPLAYER);
235                                 warmup = time + autocvar_g_ca_warmup;
236                         } else {
237                                 if(f == 5)
238                                         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_PREPARE);
239                                 else if(f == 3)
240                                         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_NUM_3);
241                                 else if(f == 2)
242                                         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_NUM_2);
243                                 else if(f == 1)
244                                         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_NUM_1);
245
246                                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_ARENA_ROUNDSTART, f);
247                         }
248                 }
249
250                 if (g_arena) {
251                         FOR_EACH_CLIENT(e)
252                         {
253                                 if(e.spawned && e.classname == "player")
254                                         e.player_blocked = 1;
255                         }
256                 }
257         }
258         else if(f > -1 && f != roundStartTime_prev)
259         {
260                 roundStartTime_prev = f;
261                 if(g_ca) {
262                         if(red_players && blue_players)
263                                 allowed_to_spawn = 0;
264                         else
265                                 reset_map(TRUE);
266                 } else {
267                         Send_Notification(NOTIF_ALL, world, MSG_MULTI, MULTI_ARENA_BEGIN);
268                 }
269
270                 if(g_arena) {
271                         FOR_EACH_CLIENT(e)
272                         {
273                                 if(e.player_blocked)
274                                         e.player_blocked = 0;
275                         }
276                 }
277         }
278
279         // clear champion to avoid centerprinting again the champion msg
280         if (champion)
281                 champion = world;
282 }
283
284 void count_players()
285 {
286         // count amount of players in each team
287         total_players = red_players = blue_players = yellow_players = pink_players = 0;
288         FOR_EACH_PLAYER(self) {
289                 if (self.team == NUM_TEAM_1)
290                 {
291                         red_players += 1;
292                         total_players += 1;
293                 }
294                 else if (self.team == NUM_TEAM_2)
295                 {
296                         blue_players += 1;
297                         total_players += 1;
298                 }
299                 else if (self.team == NUM_TEAM_3)
300                 {
301                         yellow_players += 1;
302                         total_players += 1;
303                 }
304                 else if (self.team == NUM_TEAM_4)
305                 {
306                         pink_players += 1;
307                         total_players += 1;
308                 }
309         }
310 }
311
312 void count_alive_players()
313 {
314         totalalive = redalive = bluealive = yellowalive = pinkalive = 0;
315         if(g_ca)
316         {
317                 FOR_EACH_PLAYER(self) {
318                         if (self.team == NUM_TEAM_1 && self.health >= 1)
319                         {
320                                 redalive += 1;
321                                 totalalive += 1;
322                         }
323                         else if (self.team == NUM_TEAM_2 && self.health >= 1)
324                         {
325                                 bluealive += 1;
326                                 totalalive += 1;
327                         }
328                 }
329                 FOR_EACH_REALCLIENT(self) {
330                         self.redalive_stat = redalive;
331                         self.bluealive_stat = bluealive;
332                 }
333         }
334         else if(g_freezetag)
335         {
336                 // count amount of alive players in each team
337                 FOR_EACH_PLAYER(self) {
338                         if (self.team == NUM_TEAM_1 && self.freezetag_frozen == 0 && self.health >= 1)
339                         {
340                                 redalive += 1;
341                                 totalalive += 1;
342                         }
343                         else if (self.team == NUM_TEAM_2 && self.freezetag_frozen == 0 && self.health >= 1)
344                         {
345                                 bluealive += 1;
346                                 totalalive += 1;
347                         }
348                         else if (self.team == NUM_TEAM_3 && self.freezetag_frozen == 0 && self.health >= 1)
349                         {
350                                 yellowalive += 1;
351                                 totalalive += 1;
352                         }
353                         else if (self.team == NUM_TEAM_4 && self.freezetag_frozen == 0 && self.health >= 1)
354                         {
355                                 pinkalive += 1;
356                                 totalalive += 1;
357                         }
358                 }
359                 FOR_EACH_REALCLIENT(self) {
360                         self.redalive_stat = redalive;
361                         self.bluealive_stat = bluealive;
362                         self.yellowalive_stat = yellowalive;
363                         self.pinkalive_stat = pinkalive;
364                 }
365         }
366
367 }
368
369 /**
370  * This function finds out whether an arena round is over 1 player is left.
371  * It determines the last player who's still alive and saves it's entity reference
372  * in the global variable 'champion'. Then the new enemy/enemies are put into the server.
373  *
374  * Gets called in StartFrame()
375  */
376 void Spawnqueue_Check()
377 {
378         if(warmup == 0 && g_ca && !inWarmupStage)
379         {
380                 if(red_players || blue_players)
381                         reset_map(TRUE);
382                 return;
383         }
384         if(time < warmup + 1 || inWarmupStage || intermission_running)
385                 return;
386
387         if(g_ca) {
388                 if(allowed_to_spawn) // round is not started yet
389                         return;
390                 if(!next_round) {
391                         if(!(redalive && bluealive)) {
392                                 // every player of (at least) one team is dead, round ends here
393                                 if(redalive) {
394                                         play2all("ctf/red_capture.wav");
395                                         FOR_EACH_CLIENT(self) centerprint(self, "^1RED ^7team wins the round");
396                                         TeamScore_AddToTeam(NUM_TEAM_1, ST_SCORE, +1);
397                                 }
398                                 else if(bluealive) {
399                                         play2all("ctf/blue_capture.wav");
400                                         FOR_EACH_CLIENT(self) centerprint(self, "^4BLUE ^7team wins the round");
401                                         TeamScore_AddToTeam(NUM_TEAM_2, ST_SCORE, +1);
402                                 }
403                                 else
404                                         FOR_EACH_CLIENT(self) centerprint(self, "^7Round tied");
405                                 next_round = -1;
406                         }
407                         else if(time - warmup > autocvar_g_ca_round_timelimit) {
408                                 FOR_EACH_CLIENT(self) centerprint(self, "^7Round tied");
409                                 next_round = time + 5;
410                         }
411                 }
412                 else if(next_round == -1) {
413                         // wait for killed players to be put as spectators
414                         if(!(red_players && blue_players))
415                                 next_round = time + 5;
416                 }
417                 else if((next_round > 0 && next_round < time))
418                 {
419                         next_round = 0;
420                         reset_map(TRUE);
421                 }
422         } else if(g_freezetag) {
423                 if((next_round && next_round < time))
424                 {
425                         next_round = 0;
426                         reset_map(TRUE);
427                 }
428         } else { // arena
429                 //extend next_round if it isn't set yet and only 1 player is spawned
430                 if(!next_round)
431                 if(numspawned < 2)
432                         next_round = time + 3;
433
434                 if(!arena_roundbased || (next_round && next_round < time && player_count > 1))
435                 {
436                         next_round = 0;
437
438                         if(arena_roundbased)
439                         {
440                                 champion = find(world, classname, "player");
441                                 while(champion && champion.deadflag)
442                                         champion = find(champion, classname, "player");
443                                 reset_map(TRUE);
444                         }
445
446                         while(numspawned < maxspawned && spawnqueue_first)
447                         {
448                                 self = spawnqueue_first;
449
450                                 bprint ("^4", self.netname, "^4 is the next challenger\n");
451
452                                 Spawnqueue_Remove(self);
453                                 Spawnqueue_Mark(self);
454
455                                 self.classname = "player";
456                                 PutClientInServer();
457                         }
458                 }
459         }
460 }