ef81fd92bad7db138edb2fa1e1067d252bae875b
[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, runes, 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                                                 if(g_lms)
112                                                         PlayerScore_Add(self, SP_LMS_LIVES, LMS_NewPlayerLives());
113                                                 self.killcount = 0;
114                                                 //stop the player from moving so that he stands still once he gets respawned
115                                                 self.velocity = '0 0 0';
116                                                 self.avelocity = '0 0 0';
117                                                 self.movement = '0 0 0';
118                                                 PutClientInServer();
119                                         }
120                                 }
121                         }
122                 }
123         }
124
125         if(g_keyhunt)
126                 kh_Controller_SetThink_NoMsg(autocvar_g_balance_keyhunt_delay_round+(game_starttime - time), kh_StartRound);
127
128         if(g_arena)
129         if(champion && champion.classname == "player" && player_count > 1)
130                 UpdateFrags(champion, +1);
131
132         self = oldself;
133 }
134
135 void Spawnqueue_Insert(entity e)
136 {
137         if(e.spawnqueue_in)
138                 return;
139         dprint(strcat("Into queue: ", e.netname, "\n"));
140         e.spawnqueue_in = TRUE;
141         e.spawnqueue_prev = spawnqueue_last;
142         e.spawnqueue_next = world;
143         if(spawnqueue_last)
144                 spawnqueue_last.spawnqueue_next = e;
145         spawnqueue_last = e;
146         if(!spawnqueue_first)
147                 spawnqueue_first = e;
148 }
149
150 void Spawnqueue_Remove(entity e)
151 {
152         if(!e.spawnqueue_in)
153                 return;
154         dprint(strcat("Out of queue: ", e.netname, "\n"));
155         e.spawnqueue_in = FALSE;
156         if(e == spawnqueue_first)
157                 spawnqueue_first = e.spawnqueue_next;
158         if(e == spawnqueue_last)
159                 spawnqueue_last = e.spawnqueue_prev;
160         if(e.spawnqueue_prev)
161                 e.spawnqueue_prev.spawnqueue_next = e.spawnqueue_next;
162         if(e.spawnqueue_next)
163                 e.spawnqueue_next.spawnqueue_prev = e.spawnqueue_prev;
164         e.spawnqueue_next = world;
165         e.spawnqueue_prev = world;
166 }
167
168 void Spawnqueue_Unmark(entity e)
169 {
170         if(!e.spawned)
171                 return;
172         e.spawned = FALSE;
173         numspawned = numspawned - 1;
174 }
175
176 void Spawnqueue_Mark(entity e)
177 {
178         if(e.spawned)
179                 return;
180         e.spawned = TRUE;
181         numspawned = numspawned + 1;
182 }
183
184 /**
185  * If roundbased arena game mode is active, it centerprints the texts for the
186  * player when player is waiting for the countdown to finish.
187  * Blocks the players movement while countdown is active.
188  * Unblocks the player once the countdown is over.
189  *
190  * Called in StartFrame()
191  */
192 float roundStartTime_prev; // prevent networkspam
193 void Arena_Warmup()
194 {
195         float f;
196         entity e;
197
198         if(gameover)
199         {
200                 if(warmup && time < warmup)
201                 {
202                         FOR_EACH_REALCLIENT(e)
203                                 Send_CSQC_Centerprint_Generic_Expire(e, CPID_ROUND_STARTING);
204                         warmup = 0;
205                 }
206                 if(champion && g_arena)
207                 {
208                         FOR_EACH_REALCLIENT(e)
209                                 centerprint(e, strcat("The Champion is ", champion.netname));
210                         champion = world;
211                 }
212                 return;
213         }
214         if((!g_arena && !g_ca && !g_freezetag) || (g_arena && !arena_roundbased) || (time < game_starttime))
215                 return;
216
217         f = ceil(warmup - time);
218
219         if(inWarmupStage)
220                 allowed_to_spawn = 1;
221         else if(!g_ca)
222                 allowed_to_spawn = 0;
223
224         if(time < warmup && !inWarmupStage)
225         {
226                 if (g_ca)
227                         allowed_to_spawn = 1;
228                 if(champion && g_arena)
229                 {
230                         FOR_EACH_REALCLIENT(e)
231                                 centerprint(e, strcat("The Champion is ", champion.netname));
232                 }
233
234                 if(f != roundStartTime_prev) {
235                         roundStartTime_prev = f;
236                         if(g_ca && !(red_players && blue_players)) {
237                                 FOR_EACH_REALCLIENT(self)
238                                         Send_CSQC_Centerprint_Generic(self, CPID_ROUND_STARTING, "^1Need at least 1 player in each team to play CA", 2, 0);
239                                 warmup = time + autocvar_g_ca_warmup;
240                         } else {
241                                 if(f == 5)
242                                         Announce("prepareforbattle");
243                                 else if(f == 3)
244                                         Announce("3");
245                                 else if(f == 2)
246                                         Announce("2");
247                                 else if(f == 1)
248                                         Announce("1");
249
250                                 FOR_EACH_REALCLIENT(e)
251                                         Send_CSQC_Centerprint_Generic(e, CPID_ROUND_STARTING, "Round will start in %d", 1, f);
252                         }
253                 }
254
255                 if (g_arena) {
256                         FOR_EACH_CLIENT(e)
257                         {
258                                 if(e.spawned && e.classname == "player")
259                                         e.player_blocked = 1;
260                         }
261                 }
262         }
263         else if(f > -1 && f != roundStartTime_prev)
264         {
265                 roundStartTime_prev = f;
266                 if(g_ca) {
267                         if(red_players && blue_players)
268                                 allowed_to_spawn = 0;
269                         else
270                                 reset_map(TRUE);
271                 } else {
272                         Announce("begin");
273                         FOR_EACH_REALCLIENT(e)
274                                 Send_CSQC_Centerprint_Generic(e, CPID_ROUND_STARTING, "^1Begin!", 1, 0);
275                 }
276
277                 if(g_arena) {
278                         FOR_EACH_CLIENT(e)
279                         {
280                                 if(e.player_blocked)
281                                         e.player_blocked = 0;
282                         }
283                 }
284         }
285
286         // clear champion to avoid centerprinting again the champion msg
287         if (champion)
288                 champion = world;
289 }
290
291 void count_players()
292 {
293         // count amount of players in each team
294         total_players = red_players = blue_players = yellow_players = pink_players = 0;
295         FOR_EACH_PLAYER(self) {
296                 if (self.team == COLOR_TEAM1)
297                 {
298                         red_players += 1;
299                         total_players += 1;
300                 }
301                 else if (self.team == COLOR_TEAM2)
302                 {
303                         blue_players += 1;
304                         total_players += 1;
305                 }
306                 else if (self.team == COLOR_TEAM3)
307                 {
308                         yellow_players += 1;
309                         total_players += 1;
310                 }
311                 else if (self.team == COLOR_TEAM4)
312                 {
313                         pink_players += 1;
314                         total_players += 1;
315                 }
316         }
317 }
318
319 void count_alive_players()
320 {
321         totalalive = redalive = bluealive = yellowalive = pinkalive = 0;
322         if(g_ca)
323         {
324                 FOR_EACH_PLAYER(self) {
325                         if (self.team == COLOR_TEAM1 && self.health >= 1)
326                         {
327                                 redalive += 1;
328                                 totalalive += 1;
329                         }
330                         else if (self.team == COLOR_TEAM2 && self.health >= 1)
331                         {
332                                 bluealive += 1;
333                                 totalalive += 1;
334                         }
335                 }
336                 FOR_EACH_REALCLIENT(self) {
337                         self.redalive_stat = redalive;
338                         self.bluealive_stat = bluealive;
339                 }
340         }
341         else if(g_freezetag)
342         {
343                 // count amount of alive players in each team
344                 FOR_EACH_PLAYER(self) {
345                         if (self.team == COLOR_TEAM1 && self.freezetag_frozen == 0 && self.health >= 1)
346                         {
347                                 redalive += 1;
348                                 totalalive += 1;
349                         }
350                         else if (self.team == COLOR_TEAM2 && self.freezetag_frozen == 0 && self.health >= 1)
351                         {
352                                 bluealive += 1;
353                                 totalalive += 1;
354                         }
355                         else if (self.team == COLOR_TEAM3 && self.freezetag_frozen == 0 && self.health >= 1)
356                         {
357                                 yellowalive += 1;
358                                 totalalive += 1;
359                         }
360                         else if (self.team == COLOR_TEAM4 && self.freezetag_frozen == 0 && self.health >= 1)
361                         {
362                                 pinkalive += 1;
363                                 totalalive += 1;
364                         }
365                 }
366                 FOR_EACH_REALCLIENT(self) {
367                         self.redalive_stat = redalive;
368                         self.bluealive_stat = bluealive;
369                         self.yellowalive_stat = yellowalive;
370                         self.pinkalive_stat = pinkalive;
371                 }
372         }
373
374 }
375
376 /**
377  * This function finds out whether an arena round is over 1 player is left.
378  * It determines the last player who's still alive and saves it's entity reference
379  * in the global variable 'champion'. Then the new enemy/enemies are put into the server.
380  *
381  * Gets called in StartFrame()
382  */
383 void Spawnqueue_Check()
384 {
385         if(warmup == 0 && g_ca && !inWarmupStage)
386         {
387                 if(red_players || blue_players)
388                         reset_map(TRUE);
389                 return;
390         }
391         if(time < warmup + 1 || inWarmupStage || intermission_running)
392                 return;
393
394         if(g_ca) {
395                 if(allowed_to_spawn) // round is not started yet
396                         return;
397                 if(!next_round) {
398                         if(!(redalive && bluealive)) {
399                                 // every player of (at least) one team is dead, round ends here
400                                 if(redalive) {
401                                         play2all("ctf/red_capture.wav");
402                                         FOR_EACH_CLIENT(self) centerprint(self, "^1RED ^7team wins the round");
403                                         TeamScore_AddToTeam(COLOR_TEAM1, ST_SCORE, +1);
404                                 }
405                                 else if(bluealive) {
406                                         play2all("ctf/blue_capture.wav");
407                                         FOR_EACH_CLIENT(self) centerprint(self, "^4BLUE ^7team wins the round");
408                                         TeamScore_AddToTeam(COLOR_TEAM2, ST_SCORE, +1);
409                                 }
410                                 else
411                                         FOR_EACH_CLIENT(self) centerprint(self, "^7Round tied");
412                                 next_round = -1;
413                         }
414                         else if(time - warmup > autocvar_g_ca_round_timelimit) {
415                                 FOR_EACH_CLIENT(self) centerprint(self, "^7Round tied");
416                                 next_round = time + 5;
417                         }
418                 }
419                 else if(next_round == -1) {
420                         // wait for killed players to be put as spectators
421                         if(!(red_players && blue_players))
422                                 next_round = time + 5;
423                 }
424                 else if((next_round > 0 && next_round < time))
425                 {
426                         next_round = 0;
427                         reset_map(TRUE);
428                 }
429         } else if(g_freezetag) {
430                 if((next_round && next_round < time))
431                 {
432                         next_round = 0;
433                         reset_map(TRUE);
434                 }
435         } else { // arena
436                 //extend next_round if it isn't set yet and only 1 player is spawned
437                 if(!next_round)
438                 if(numspawned < 2)
439                         next_round = time + 3;
440
441                 if(!arena_roundbased || (next_round && next_round < time && player_count > 1))
442                 {
443                         next_round = 0;
444
445                         if(arena_roundbased)
446                         {
447                                 champion = find(world, classname, "player");
448                                 while(champion && champion.deadflag)
449                                         champion = find(champion, classname, "player");
450                                 reset_map(TRUE);
451                         }
452
453                         while(numspawned < maxspawned && spawnqueue_first)
454                         {
455                                 self = spawnqueue_first;
456
457                                 bprint ("^4", self.netname, "^4 is the next challenger\n");
458
459                                 Spawnqueue_Remove(self);
460                                 Spawnqueue_Mark(self);
461
462                                 self.classname = "player";
463                                 PutClientInServer();
464                         }
465                 }
466         }
467 }