]> git.xonotic.org Git - xonotic/xonotic-data.pk3dir.git/blob - qcsrc/server/mutators/mutator/gamemode_domination.qc
Merge branch 'master' into TimePath/scoreboard_elo
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / mutators / mutator / gamemode_domination.qc
1 #include "gamemode_domination.qh"
2 #ifndef GAMEMODE_DOMINATION_H
3 #define GAMEMODE_DOMINATION_H
4
5 #define autocvar_g_domination_point_limit cvar("g_domination_point_limit")
6 bool autocvar_g_domination_roundbased;
7 int autocvar_g_domination_roundbased_point_limit;
8 int autocvar_g_domination_point_leadlimit;
9
10 void dom_Initialize();
11
12 REGISTER_MUTATOR(dom, false)
13 {
14         MUTATOR_ONADD
15         {
16                 if (time > 1) // game loads at time 1
17                         error("This is a game type and it cannot be added at runtime.");
18                 dom_Initialize();
19
20                 int fraglimit_override = autocvar_g_domination_point_limit;
21                 if (autocvar_g_domination_roundbased && autocvar_g_domination_roundbased_point_limit)
22                         fraglimit_override = autocvar_g_domination_roundbased_point_limit;
23
24                 ActivateTeamplay();
25                 SetLimits(fraglimit_override, autocvar_g_domination_point_leadlimit, autocvar_timelimit_override, -1);
26                 have_team_spawns = -1; // request team spawns
27         }
28
29         MUTATOR_ONREMOVE
30         {
31                 LOG_INFO("This is a game type and it cannot be removed at runtime.");
32                 return -1;
33         }
34
35         return 0;
36 }
37
38 // score rule declarations
39 const float ST_DOM_TICKS = 1;
40 const float ST_DOM_CAPS = 1;
41
42 // pps: points per second
43 .float dom_total_pps = _STAT(DOM_TOTAL_PPS);
44 .float dom_pps_red = _STAT(DOM_PPS_RED);
45 .float dom_pps_blue = _STAT(DOM_PPS_BLUE);
46 .float dom_pps_yellow = _STAT(DOM_PPS_YELLOW);
47 .float dom_pps_pink = _STAT(DOM_PPS_PINK);
48 float total_pps;
49 float pps_red;
50 float pps_blue;
51 float pps_yellow;
52 float pps_pink;
53
54 // capture declarations
55 .float enemy_playerid;
56 .entity sprite;
57 .float captime;
58
59 // misc globals
60 float domination_roundbased;
61 float domination_teams;
62 #endif
63
64 #ifdef IMPLEMENTATION
65
66 #include <server/teamplay.qh>
67
68 bool g_domination;
69
70 int autocvar_g_domination_default_teams;
71 bool autocvar_g_domination_disable_frags;
72 int autocvar_g_domination_point_amt;
73 bool autocvar_g_domination_point_fullbright;
74 float autocvar_g_domination_round_timelimit;
75 float autocvar_g_domination_warmup;
76 float autocvar_g_domination_point_rate;
77 int autocvar_g_domination_teams_override;
78
79 void dom_EventLog(string mode, float team_before, entity actor) // use an alias for easy changing and quick editing later
80 {
81         if(autocvar_sv_eventlog)
82                 GameLogEcho(strcat(":dom:", mode, ":", ftos(team_before), ((actor != NULL) ? (strcat(":", ftos(actor.playerid))) : "")));
83 }
84
85 void set_dom_state(entity e)
86 {
87         e.dom_total_pps = total_pps;
88         e.dom_pps_red = pps_red;
89         e.dom_pps_blue = pps_blue;
90         if(domination_teams >= 3)
91                 e.dom_pps_yellow = pps_yellow;
92         if(domination_teams >= 4)
93                 e.dom_pps_pink = pps_pink;
94 }
95
96 void dompoint_captured(entity this)
97 {
98         float old_delay, old_team, real_team;
99
100         // now that the delay has expired, switch to the latest team to lay claim to this point
101         entity head = this.owner;
102
103         real_team = this.cnt;
104         this.cnt = -1;
105
106         dom_EventLog("taken", this.team, this.dmg_inflictor);
107         this.dmg_inflictor = NULL;
108
109         this.goalentity = head;
110         this.model = head.mdl;
111         this.modelindex = head.dmg;
112         this.skin = head.skin;
113
114         float points, wait_time;
115         if (autocvar_g_domination_point_amt)
116                 points = autocvar_g_domination_point_amt;
117         else
118                 points = this.frags;
119         if (autocvar_g_domination_point_rate)
120                 wait_time = autocvar_g_domination_point_rate;
121         else
122                 wait_time = this.wait;
123
124         if(domination_roundbased)
125                 bprint(sprintf("^3%s^3%s\n", head.netname, this.message));
126         else
127                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_DOMINATION_CAPTURE_TIME, head.netname, this.message, points, wait_time);
128
129         if(this.enemy.playerid == this.enemy_playerid)
130                 PlayerScore_Add(this.enemy, SP_DOM_TAKES, 1);
131         else
132                 this.enemy = NULL;
133
134         if (head.noise != "")
135                 if(this.enemy)
136                         _sound(this.enemy, CH_TRIGGER, head.noise, VOL_BASE, ATTEN_NORM);
137                 else
138                         _sound(this, CH_TRIGGER, head.noise, VOL_BASE, ATTEN_NORM);
139         if (head.noise1 != "")
140                 play2all(head.noise1);
141
142         this.delay = time + wait_time;
143
144         // do trigger work
145         old_delay = this.delay;
146         old_team = this.team;
147         this.team = real_team;
148         this.delay = 0;
149         SUB_UseTargets (this, this, NULL);
150         this.delay = old_delay;
151         this.team = old_team;
152
153         entity msg = WP_DomNeut;
154         switch(this.team)
155         {
156                 case NUM_TEAM_1: msg = WP_DomRed; break;
157                 case NUM_TEAM_2: msg = WP_DomBlue; break;
158                 case NUM_TEAM_3: msg = WP_DomYellow; break;
159                 case NUM_TEAM_4: msg = WP_DomPink; break;
160         }
161
162         WaypointSprite_UpdateSprites(this.sprite, msg, WP_Null, WP_Null);
163
164         total_pps = 0, pps_red = 0, pps_blue = 0, pps_yellow = 0, pps_pink = 0;
165         FOREACH_ENTITY_CLASS("dom_controlpoint", true, LAMBDA(
166                 if (autocvar_g_domination_point_amt)
167                         points = autocvar_g_domination_point_amt;
168                 else
169                         points = it.frags;
170                 if (autocvar_g_domination_point_rate)
171                         wait_time = autocvar_g_domination_point_rate;
172                 else
173                         wait_time = it.wait;
174                 switch(it.goalentity.team)
175                 {
176                         case NUM_TEAM_1: pps_red += points/wait_time; break;
177                         case NUM_TEAM_2: pps_blue += points/wait_time; break;
178                         case NUM_TEAM_3: pps_yellow += points/wait_time; break;
179                         case NUM_TEAM_4: pps_pink += points/wait_time; break;
180                 }
181                 total_pps += points/wait_time;
182         ));
183
184         WaypointSprite_UpdateTeamRadar(this.sprite, RADARICON_DOMPOINT, colormapPaletteColor(this.goalentity.team - 1, 0));
185         WaypointSprite_Ping(this.sprite);
186
187         this.captime = time;
188
189         FOREACH_CLIENT(IS_REAL_CLIENT(it), LAMBDA(set_dom_state(it)));
190 }
191
192 void AnimateDomPoint(entity this)
193 {
194         if(this.pain_finished > time)
195                 return;
196         this.pain_finished = time + this.t_width;
197         if(this.nextthink > this.pain_finished)
198                 this.nextthink = this.pain_finished;
199
200         this.frame = this.frame + 1;
201         if(this.frame > this.t_length)
202                 this.frame = 0;
203 }
204
205 void dompointthink(entity this)
206 {
207         float fragamt;
208
209         this.nextthink = time + 0.1;
210
211         //this.frame = this.frame + 1;
212         //if(this.frame > 119)
213         //      this.frame = 0;
214         AnimateDomPoint(this);
215
216         // give points
217
218         if (gameover || this.delay > time || time < game_starttime)     // game has ended, don't keep giving points
219                 return;
220
221         if(autocvar_g_domination_point_rate)
222                 this.delay = time + autocvar_g_domination_point_rate;
223         else
224                 this.delay = time + this.wait;
225
226         // give credit to the team
227         // NOTE: this defaults to 0
228         if (!domination_roundbased)
229         if (this.goalentity.netname != "")
230         {
231                 if(autocvar_g_domination_point_amt)
232                         fragamt = autocvar_g_domination_point_amt;
233                 else
234                         fragamt = this.frags;
235                 TeamScore_AddToTeam(this.goalentity.team, ST_SCORE, fragamt);
236                 TeamScore_AddToTeam(this.goalentity.team, ST_DOM_TICKS, fragamt);
237
238                 // give credit to the individual player, if he is still there
239                 if (this.enemy.playerid == this.enemy_playerid)
240                 {
241                         PlayerScore_Add(this.enemy, SP_SCORE, fragamt);
242                         PlayerScore_Add(this.enemy, SP_DOM_TICKS, fragamt);
243                 }
244                 else
245                         this.enemy = NULL;
246         }
247 }
248
249 void dompointtouch(entity this, entity toucher)
250 {
251         if (!IS_PLAYER(toucher))
252                 return;
253         if (toucher.health < 1)
254                 return;
255
256         if(round_handler_IsActive() && !round_handler_IsRoundStarted())
257                 return;
258
259         if(time < this.captime + 0.3)
260                 return;
261
262         // only valid teams can claim it
263         entity head = find(NULL, classname, "dom_team");
264         while (head && head.team != toucher.team)
265                 head = find(head, classname, "dom_team");
266         if (!head || head.netname == "" || head == this.goalentity)
267                 return;
268
269         // delay capture
270
271         this.team = this.goalentity.team; // this stores the PREVIOUS team!
272
273         this.cnt = toucher.team;
274         this.owner = head; // team to switch to after the delay
275         this.dmg_inflictor = toucher;
276
277         // this.state = 1;
278         // this.delay = time + cvar("g_domination_point_capturetime");
279         //this.nextthink = time + cvar("g_domination_point_capturetime");
280         //this.think = dompoint_captured;
281
282         // go to neutral team in the mean time
283         head = find(NULL, classname, "dom_team");
284         while (head && head.netname != "")
285                 head = find(head, classname, "dom_team");
286         if(head == NULL)
287                 return;
288
289         WaypointSprite_UpdateSprites(this.sprite, WP_DomNeut, WP_Null, WP_Null);
290         WaypointSprite_UpdateTeamRadar(this.sprite, RADARICON_DOMPOINT, '0 1 1');
291         WaypointSprite_Ping(this.sprite);
292
293         this.goalentity = head;
294         this.model = head.mdl;
295         this.modelindex = head.dmg;
296         this.skin = head.skin;
297
298         this.enemy = toucher; // individual player scoring
299         this.enemy_playerid = toucher.playerid;
300         dompoint_captured(this);
301 }
302
303 void dom_controlpoint_setup(entity this)
304 {
305         entity head;
306         // find the spawnfunc_dom_team representing unclaimed points
307         head = find(NULL, classname, "dom_team");
308         while(head && head.netname != "")
309                 head = find(head, classname, "dom_team");
310         if (!head)
311                 objerror(this, "no spawnfunc_dom_team with netname \"\" found\n");
312
313         // copy important properties from spawnfunc_dom_team entity
314         this.goalentity = head;
315         _setmodel(this, head.mdl); // precision already set
316         this.skin = head.skin;
317
318         this.cnt = -1;
319
320         if(this.message == "")
321                 this.message = " has captured a control point";
322
323         if(this.frags <= 0)
324                 this.frags = 1;
325         if(this.wait <= 0)
326                 this.wait = 5;
327
328         float points, waittime;
329         if (autocvar_g_domination_point_amt)
330                 points = autocvar_g_domination_point_amt;
331         else
332                 points = this.frags;
333         if (autocvar_g_domination_point_rate)
334                 waittime = autocvar_g_domination_point_rate;
335         else
336                 waittime = this.wait;
337
338         total_pps += points/waittime;
339
340         if(!this.t_width)
341                 this.t_width = 0.02; // frame animation rate
342         if(!this.t_length)
343                 this.t_length = 239; // maximum frame
344
345         setthink(this, dompointthink);
346         this.nextthink = time;
347         settouch(this, dompointtouch);
348         this.solid = SOLID_TRIGGER;
349         this.flags = FL_ITEM;
350         setsize(this, '-32 -32 -32', '32 32 32');
351         setorigin(this, this.origin + '0 0 20');
352         droptofloor(this);
353
354         waypoint_spawnforitem(this);
355         WaypointSprite_SpawnFixed(WP_DomNeut, this.origin + '0 0 32', this, sprite, RADARICON_DOMPOINT);
356 }
357
358 float total_controlpoints;
359 void Domination_count_controlpoints()
360 {
361         total_controlpoints = redowned = blueowned = yellowowned = pinkowned = 0;
362         FOREACH_ENTITY_CLASS("dom_controlpoint", true,
363         {
364                 ++total_controlpoints;
365                 redowned += (it.goalentity.team == NUM_TEAM_1);
366                 blueowned += (it.goalentity.team == NUM_TEAM_2);
367                 yellowowned += (it.goalentity.team == NUM_TEAM_3);
368                 pinkowned += (it.goalentity.team == NUM_TEAM_4);
369         });
370 }
371
372 float Domination_GetWinnerTeam()
373 {
374         float winner_team = 0;
375         if(redowned == total_controlpoints)
376                 winner_team = NUM_TEAM_1;
377         if(blueowned == total_controlpoints)
378         {
379                 if(winner_team) return 0;
380                 winner_team = NUM_TEAM_2;
381         }
382         if(yellowowned == total_controlpoints)
383         {
384                 if(winner_team) return 0;
385                 winner_team = NUM_TEAM_3;
386         }
387         if(pinkowned == total_controlpoints)
388         {
389                 if(winner_team) return 0;
390                 winner_team = NUM_TEAM_4;
391         }
392         if(winner_team)
393                 return winner_team;
394         return -1; // no control points left?
395 }
396
397 #define DOM_OWNED_CONTROLPOINTS() ((redowned > 0) + (blueowned > 0) + (yellowowned > 0) + (pinkowned > 0))
398 #define DOM_OWNED_CONTROLPOINTS_OK() (DOM_OWNED_CONTROLPOINTS() < total_controlpoints)
399 float Domination_CheckWinner()
400 {
401         if(round_handler_GetEndTime() > 0 && round_handler_GetEndTime() - time <= 0)
402         {
403                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_ROUND_OVER);
404                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_ROUND_OVER);
405                 round_handler_Init(5, autocvar_g_domination_warmup, autocvar_g_domination_round_timelimit);
406                 return 1;
407         }
408
409         Domination_count_controlpoints();
410
411         float winner_team = Domination_GetWinnerTeam();
412
413         if(winner_team == -1)
414                 return 0;
415
416         if(winner_team > 0)
417         {
418                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, APP_TEAM_NUM(winner_team, CENTER_ROUND_TEAM_WIN));
419                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(winner_team, INFO_ROUND_TEAM_WIN));
420                 TeamScore_AddToTeam(winner_team, ST_DOM_CAPS, +1);
421         }
422         else if(winner_team == -1)
423         {
424                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_ROUND_TIED);
425                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_ROUND_TIED);
426         }
427
428         round_handler_Init(5, autocvar_g_domination_warmup, autocvar_g_domination_round_timelimit);
429
430         return 1;
431 }
432
433 float Domination_CheckPlayers()
434 {
435         return 1;
436 }
437
438 void Domination_RoundStart()
439 {
440         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(it.player_blocked = false));
441 }
442
443 //go to best items, or control points you don't own
444 void havocbot_role_dom(entity this)
445 {
446         if(IS_DEAD(this))
447                 return;
448
449         if (this.bot_strategytime < time)
450         {
451                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
452                 navigation_goalrating_start(this);
453                 havocbot_goalrating_controlpoints(this, 10000, this.origin, 15000);
454                 havocbot_goalrating_items(this, 8000, this.origin, 8000);
455                 //havocbot_goalrating_enemyplayers(this, 3000, this.origin, 2000);
456                 //havocbot_goalrating_waypoints(1, this.origin, 1000);
457                 navigation_goalrating_end(this);
458         }
459 }
460
461 MUTATOR_HOOKFUNCTION(dom, GetTeamCount)
462 {
463         // fallback?
464         M_ARGV(0, float) = domination_teams;
465         string ret_string = "dom_team";
466
467         entity head = find(NULL, classname, ret_string);
468         while(head)
469         {
470                 if(head.netname != "")
471                 {
472                         switch(head.team)
473                         {
474                                 case NUM_TEAM_1: c1 = 0; break;
475                                 case NUM_TEAM_2: c2 = 0; break;
476                                 case NUM_TEAM_3: c3 = 0; break;
477                                 case NUM_TEAM_4: c4 = 0; break;
478                         }
479                 }
480
481                 head = find(head, classname, ret_string);
482         }
483
484         M_ARGV(1, string) = string_null;
485
486         return true;
487 }
488
489 MUTATOR_HOOKFUNCTION(dom, reset_map_players)
490 {
491         total_pps = 0, pps_red = 0, pps_blue = 0, pps_yellow = 0, pps_pink = 0;
492         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
493                 PutClientInServer(it);
494                 if(domination_roundbased)
495                         it.player_blocked = 1;
496                 if(IS_REAL_CLIENT(it))
497                         set_dom_state(it);
498         ));
499         return true;
500 }
501
502 MUTATOR_HOOKFUNCTION(dom, PlayerSpawn)
503 {
504         entity player = M_ARGV(0, entity);
505
506         if(domination_roundbased)
507         if(!round_handler_IsRoundStarted())
508                 player.player_blocked = 1;
509         else
510                 player.player_blocked = 0;
511 }
512
513 MUTATOR_HOOKFUNCTION(dom, ClientConnect)
514 {
515         entity player = M_ARGV(0, entity);
516
517         set_dom_state(player);
518 }
519
520 MUTATOR_HOOKFUNCTION(dom, HavocBot_ChooseRole)
521 {
522         entity bot = M_ARGV(0, entity);
523
524         bot.havocbot_role = havocbot_role_dom;
525         return true;
526 }
527
528 /*QUAKED spawnfunc_dom_controlpoint (0 .5 .8) (-16 -16 -24) (16 16 32)
529 Control point for Domination gameplay.
530 */
531 spawnfunc(dom_controlpoint)
532 {
533         if(!g_domination)
534         {
535                 delete(this);
536                 return;
537         }
538         setthink(this, dom_controlpoint_setup);
539         this.nextthink = time + 0.1;
540         this.reset = dom_controlpoint_setup;
541
542         if(!this.scale)
543                 this.scale = 0.6;
544
545         this.effects = this.effects | EF_LOWPRECISION;
546         if (autocvar_g_domination_point_fullbright)
547                 this.effects |= EF_FULLBRIGHT;
548 }
549
550 /*QUAKED spawnfunc_dom_team (0 .5 .8) (-32 -32 -24) (32 32 32)
551 Team declaration for Domination gameplay, this allows you to decide what team
552 names and control point models are used in your map.
553
554 Note: If you use spawnfunc_dom_team entities you must define at least 3 and only two
555 can have netname set!  The nameless team owns all control points at start.
556
557 Keys:
558 "netname"
559  Name of the team (for example Red Team, Blue Team, Green Team, Yellow Team, Life, Death, etc)
560 "cnt"
561  Scoreboard color of the team (for example 4 is red and 13 is blue)
562 "model"
563  Model to use for control points owned by this team (for example
564  "progs/b_g_key.mdl" is a gold keycard, and "progs/b_s_key.mdl" is a silver
565  keycard)
566 "skin"
567  Skin of the model to use (for team skins on a single model)
568 "noise"
569  Sound to play when this team captures a point.
570  (this is a localized sound, like a small alarm or other effect)
571 "noise1"
572  Narrator speech to play when this team captures a point.
573  (this is a global sound, like "Red team has captured a control point")
574 */
575
576 spawnfunc(dom_team)
577 {
578         if(!g_domination || autocvar_g_domination_teams_override >= 2)
579         {
580                 delete(this);
581                 return;
582         }
583         precache_model(this.model);
584         if (this.noise != "")
585                 precache_sound(this.noise);
586         if (this.noise1 != "")
587                 precache_sound(this.noise1);
588         this.classname = "dom_team";
589         _setmodel(this, this.model); // precision not needed
590         this.mdl = this.model;
591         this.dmg = this.modelindex;
592         this.model = "";
593         this.modelindex = 0;
594         // this would have to be changed if used in quakeworld
595         if(this.cnt)
596                 this.team = this.cnt + 1; // WHY are these different anyway?
597 }
598
599 // scoreboard setup
600 void ScoreRules_dom(int teams)
601 {
602         if(domination_roundbased)
603         {
604                 ScoreRules_basics(teams, SFL_SORT_PRIO_PRIMARY, 0, true);
605                 ScoreInfo_SetLabel_TeamScore  (ST_DOM_CAPS, "caps", SFL_SORT_PRIO_PRIMARY);
606                 ScoreInfo_SetLabel_PlayerScore(SP_DOM_TAKES, "takes", 0);
607                 ScoreRules_basics_end();
608         }
609         else
610         {
611                 float sp_domticks, sp_score;
612                 sp_score = sp_domticks = 0;
613                 if(autocvar_g_domination_disable_frags)
614                         sp_domticks = SFL_SORT_PRIO_PRIMARY;
615                 else
616                         sp_score = SFL_SORT_PRIO_PRIMARY;
617                 ScoreRules_basics(teams, sp_score, sp_score, true);
618                 ScoreInfo_SetLabel_TeamScore  (ST_DOM_TICKS,    "ticks",     sp_domticks);
619                 ScoreInfo_SetLabel_PlayerScore(SP_DOM_TICKS,    "ticks",     sp_domticks);
620                 ScoreInfo_SetLabel_PlayerScore(SP_DOM_TAKES,    "takes",     0);
621                 ScoreRules_basics_end();
622         }
623 }
624
625 // code from here on is just to support maps that don't have control point and team entities
626 void dom_spawnteam (string teamname, float teamcolor, string pointmodel, float pointskin, Sound capsound, string capnarration, string capmessage)
627 {
628     TC(Sound, capsound);
629     entity e = new_pure(dom_team);
630         e.netname = strzone(teamname);
631         e.cnt = teamcolor;
632         e.model = pointmodel;
633         e.skin = pointskin;
634         e.noise = strzone(Sound_fixpath(capsound));
635         e.noise1 = strzone(capnarration);
636         e.message = strzone(capmessage);
637
638         // this code is identical to spawnfunc_dom_team
639         _setmodel(e, e.model); // precision not needed
640         e.mdl = e.model;
641         e.dmg = e.modelindex;
642         e.model = "";
643         e.modelindex = 0;
644         // this would have to be changed if used in quakeworld
645         e.team = e.cnt + 1;
646
647         //eprint(e);
648 }
649
650 void dom_spawnpoint(vector org)
651 {
652         entity e = spawn();
653         e.classname = "dom_controlpoint";
654         setthink(e, spawnfunc_dom_controlpoint);
655         e.nextthink = time;
656         setorigin(e, org);
657         spawnfunc_dom_controlpoint(e);
658 }
659
660 // spawn some default teams if the map is not set up for domination
661 void dom_spawnteams(int teams)
662 {
663     TC(int, teams);
664         dom_spawnteam(Team_ColoredFullName(NUM_TEAM_1), NUM_TEAM_1-1, "models/domination/dom_red.md3", 0, SND_DOM_CLAIM, "", "Red team has captured a control point");
665         dom_spawnteam(Team_ColoredFullName(NUM_TEAM_2), NUM_TEAM_2-1, "models/domination/dom_blue.md3", 0, SND_DOM_CLAIM, "", "Blue team has captured a control point");
666         if(teams >= 3)
667                 dom_spawnteam(Team_ColoredFullName(NUM_TEAM_3), NUM_TEAM_3-1, "models/domination/dom_yellow.md3", 0, SND_DOM_CLAIM, "", "Yellow team has captured a control point");
668         if(teams >= 4)
669                 dom_spawnteam(Team_ColoredFullName(NUM_TEAM_4), NUM_TEAM_4-1, "models/domination/dom_pink.md3", 0, SND_DOM_CLAIM, "", "Pink team has captured a control point");
670         dom_spawnteam("", 0, "models/domination/dom_unclaimed.md3", 0, SND_Null, "", "");
671 }
672
673 void dom_DelayedInit(entity this) // Do this check with a delay so we can wait for teams to be set up.
674 {
675         // if no teams are found, spawn defaults
676         if(find(NULL, classname, "dom_team") == NULL || autocvar_g_domination_teams_override >= 2)
677         {
678                 LOG_TRACE("No \"dom_team\" entities found on this map, creating them anyway.\n");
679                 domination_teams = bound(2, ((autocvar_g_domination_teams_override < 2) ? autocvar_g_domination_default_teams : autocvar_g_domination_teams_override), 4);
680                 dom_spawnteams(domination_teams);
681         }
682
683         CheckAllowedTeams(NULL);
684         //domination_teams = ((c4>=0) ? 4 : (c3>=0) ? 3 : 2);
685
686         int teams = 0;
687         if(c1 >= 0) teams |= BIT(0);
688         if(c2 >= 0) teams |= BIT(1);
689         if(c3 >= 0) teams |= BIT(2);
690         if(c4 >= 0) teams |= BIT(3);
691         domination_teams = teams;
692
693         domination_roundbased = autocvar_g_domination_roundbased;
694
695         ScoreRules_dom(domination_teams);
696
697         if(domination_roundbased)
698         {
699                 round_handler_Spawn(Domination_CheckPlayers, Domination_CheckWinner, Domination_RoundStart);
700                 round_handler_Init(5, autocvar_g_domination_warmup, autocvar_g_domination_round_timelimit);
701         }
702 }
703
704 void dom_Initialize()
705 {
706         g_domination = true;
707         InitializeEntity(NULL, dom_DelayedInit, INITPRIO_GAMETYPE);
708 }
709
710 #endif