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