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