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