]> de.git.xonotic.org Git - xonotic/xonotic-data.pk3dir.git/blob - qcsrc/server/mutators/gamemode_arena.qc
Merge branch 'master' into terencehill/ca_arena_mutators
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / mutators / gamemode_arena.qc
1 .float spawned;
2 float maxspawned;
3 float numspawned;
4 .entity spawnqueue_next;
5 .entity spawnqueue_prev;
6 .float spawnqueue_in;
7 entity spawnqueue_first;
8 entity spawnqueue_last;
9
10 void Spawnqueue_Insert(entity e)
11 {
12         if(e.spawnqueue_in)
13                 return;
14         dprint(strcat("Into queue: ", e.netname, "\n"));
15         e.spawnqueue_in = TRUE;
16         e.spawnqueue_prev = spawnqueue_last;
17         e.spawnqueue_next = world;
18         if(spawnqueue_last)
19                 spawnqueue_last.spawnqueue_next = e;
20         spawnqueue_last = e;
21         if(!spawnqueue_first)
22                 spawnqueue_first = e;
23 }
24
25 void Spawnqueue_Remove(entity e)
26 {
27         if(!e.spawnqueue_in)
28                 return;
29         dprint(strcat("Out of queue: ", e.netname, "\n"));
30         e.spawnqueue_in = FALSE;
31         if(e == spawnqueue_first)
32                 spawnqueue_first = e.spawnqueue_next;
33         if(e == spawnqueue_last)
34                 spawnqueue_last = e.spawnqueue_prev;
35         if(e.spawnqueue_prev)
36                 e.spawnqueue_prev.spawnqueue_next = e.spawnqueue_next;
37         if(e.spawnqueue_next)
38                 e.spawnqueue_next.spawnqueue_prev = e.spawnqueue_prev;
39         e.spawnqueue_next = world;
40         e.spawnqueue_prev = world;
41 }
42
43 void Spawnqueue_Unmark(entity e)
44 {
45         if(!e.spawned)
46                 return;
47         e.spawned = FALSE;
48         numspawned = numspawned - 1;
49 }
50
51 void Spawnqueue_Mark(entity e)
52 {
53         if(e.spawned)
54                 return;
55         e.spawned = TRUE;
56         numspawned = numspawned + 1;
57 }
58
59 float Arena_CheckWinner()
60 {
61         entity e;
62
63         if(round_handler_GetTimeLeft() <= 0)
64         {
65                 FOR_EACH_REALCLIENT(e)
66                         centerprint(e, "Round over, there's no winner");
67                 bprint("Round over, there's no winner\n");
68                 return 1;
69         }
70
71         if(numspawned > 1)
72                 return 0;
73
74         entity champion;
75         champion = world;
76         FOR_EACH_CLIENT(e)
77         {
78                 if(e.spawned && e.classname == "player")
79                         champion = e;
80         }
81
82         if(champion)
83         {
84                 FOR_EACH_REALCLIENT(e)
85                         centerprint(e, strcat("The Champion is ", champion.netname));
86                 bprint("The Champion is ", champion.netname, "\n");
87                 UpdateFrags(champion, +1);
88         }
89         else
90         {
91                 FOR_EACH_REALCLIENT(e)
92                         centerprint(e, "Round tied");
93                 bprint("Round tied\n");
94         }
95         return 1;
96 }
97
98 void Arena_AddChallengers()
99 {
100         entity e;
101         e = self;
102         while(numspawned < maxspawned && spawnqueue_first)
103         {
104                 self = spawnqueue_first;
105
106                 bprint ("^4", self.netname, "^4 is the next challenger\n");
107
108                 Spawnqueue_Remove(self);
109                 Spawnqueue_Mark(self);
110
111                 self.classname = "player";
112                 PutClientInServer();
113         }
114         self = e;
115 }
116
117 float prev_numspawned;
118 float Arena_CheckPlayers()
119 {
120         entity e;
121
122         Arena_AddChallengers();
123
124         if(numspawned >= 2)
125         {
126                 if(prev_numspawned != -1)
127                 {
128                         FOR_EACH_REALCLIENT(e)
129                                 Send_CSQC_Centerprint_Generic_Expire(e, CPID_WAITING_PLAYERS);
130                 }
131                 prev_numspawned = -1;
132                 return 1;
133         }
134
135         if(prev_numspawned != numspawned && numspawned == 1)
136         {
137                 FOR_EACH_REALCLIENT(e)
138                         Send_CSQC_Centerprint_Generic(e, CPID_WAITING_PLAYERS, "Waiting for players to join...", -1, 0);
139                 prev_numspawned = numspawned;
140         }
141
142         return 0;
143 }
144
145 void Arena_RoundStart()
146 {
147         entity e;
148         FOR_EACH_PLAYER(e)
149                 e.player_blocked = 0;
150 }
151
152 MUTATOR_HOOKFUNCTION(arena_ClientDisconnect)
153 {
154         Spawnqueue_Unmark(self);
155         Spawnqueue_Remove(self);
156         return 1;
157 }
158
159 MUTATOR_HOOKFUNCTION(arena_reset_map_players)
160 {
161         FOR_EACH_CLIENT(self)
162         {
163                 if(self.spawned)
164                 {
165                         PutClientInServer();
166                         self.player_blocked = 1;
167                 }
168                 else
169                         PutObserverInServer();
170         }
171         return 1;
172 }
173
174 MUTATOR_HOOKFUNCTION(arena_MakePlayerObserver)
175 {
176         if(self.version_mismatch)
177         {
178                 self.frags = FRAGS_SPECTATOR;
179                 Spawnqueue_Unmark(self);
180                 Spawnqueue_Remove(self);
181         }
182         else
183         {
184                 self.frags = FRAGS_LMS_LOSER;
185                 Spawnqueue_Insert(self);
186         }
187         return 1;
188 }
189
190 MUTATOR_HOOKFUNCTION(arena_PutClientInServer)
191 {
192         if(!self.spawned)
193                 self.classname = "observer";
194         return 1;
195 }
196
197 MUTATOR_HOOKFUNCTION(arena_ClientConnect)
198 {
199         self.classname = "observer";
200         Spawnqueue_Insert(self);
201         return 1;
202 }
203
204 MUTATOR_HOOKFUNCTION(arena_PlayerSpawn)
205 {
206         Spawnqueue_Remove(self);
207         Spawnqueue_Mark(self);
208         if(arena_roundbased)
209                 self.player_blocked = 1;
210         return 1;
211 }
212
213 MUTATOR_HOOKFUNCTION(arena_PlayerPreThink)
214 {
215         self.stat_respawn_time = 0;
216
217         // put dead players in the spawn queue
218         if(arena_roundbased)
219         if(self.deadflag && time - self.death_time >= 1.5)
220                 PutClientInServer();
221
222         return 1;
223 }
224
225 MUTATOR_HOOKFUNCTION(arena_ForbidPlayerScore_Clear)
226 {
227         return 1;
228 }
229
230 MUTATOR_HOOKFUNCTION(arena_GiveFragsForKill)
231 {
232         if(arena_roundbased)
233                 frag_score = 0; // score will be given to the champion when the round ends
234         return 1;
235 }
236
237 MUTATOR_HOOKFUNCTION(arena_PlayerDies)
238 {
239         Spawnqueue_Unmark(self);
240         return 1;
241 }
242
243 MUTATOR_HOOKFUNCTION(arena_SV_StartFrame)
244 {
245         if(arena_roundbased) return 1;
246         if(time <= game_starttime) return 1;
247         if(gameover) return 1;
248
249         Arena_AddChallengers();
250         return 1;
251 }
252
253 void arena_Initialize()
254 {
255         maxspawned = max(2, autocvar_g_arena_maxspawned);
256         arena_roundbased = autocvar_g_arena_roundbased;
257         if(arena_roundbased)
258                 round_handler_Spawn(Arena_CheckPlayers, Arena_CheckWinner, Arena_RoundStart, 5, autocvar_g_arena_warmup, autocvar_g_arena_round_timelimit);
259 }
260
261 MUTATOR_DEFINITION(gamemode_arena)
262 {
263         MUTATOR_HOOK(ClientDisconnect, arena_ClientDisconnect, CBC_ORDER_ANY);
264         MUTATOR_HOOK(reset_map_players, arena_reset_map_players, CBC_ORDER_ANY);
265         MUTATOR_HOOK(MakePlayerObserver, arena_MakePlayerObserver, CBC_ORDER_ANY);
266         MUTATOR_HOOK(PutClientInServer, arena_PutClientInServer, CBC_ORDER_ANY);
267         MUTATOR_HOOK(ClientConnect, arena_ClientConnect, CBC_ORDER_ANY);
268         MUTATOR_HOOK(PlayerSpawn, arena_PlayerSpawn, CBC_ORDER_ANY);
269         MUTATOR_HOOK(PlayerPreThink, arena_PlayerPreThink, CBC_ORDER_ANY);
270         MUTATOR_HOOK(ForbidPlayerScore_Clear, arena_ForbidPlayerScore_Clear, CBC_ORDER_ANY);
271         MUTATOR_HOOK(GiveFragsForKill, arena_GiveFragsForKill, CBC_ORDER_ANY);
272         MUTATOR_HOOK(PlayerDies, arena_PlayerDies, CBC_ORDER_ANY);
273         MUTATOR_HOOK(SV_StartFrame, arena_SV_StartFrame, CBC_ORDER_ANY);
274
275         MUTATOR_ONADD
276         {
277                 if(time > 1) // game loads at time 1
278                         error("This is a game type and it cannot be added at runtime.");
279                 arena_Initialize();
280         }
281
282         MUTATOR_ONREMOVE
283         {
284                 print("This is a game type and it cannot be removed at runtime.");
285                 return -1;
286         }
287
288         return 0;
289 }