data/qcsrc/server/teamplay.qc

   1 string cache_mutatormsg;\r
   2 string cache_lastmutatormsg;\r
   3 \r
   4 // client counts for each team\r
   5 float c1, c2, c3, c4;\r
   6 // # of bots on those teams\r
   7 float cb1, cb2, cb3, cb4;\r
   8 \r
   9 float audit_teams_time;\r
  10 \r
  11 float IsTeamBalanceForced()\r
  12 {\r
  13         if(intermission_running)\r
  14                 return 0; // no rebalancing whatsoever please\r
  15         if(!teams_matter)\r
  16                 return 0;\r
  17         if(cvar("g_campaign"))\r
  18                 return 0;\r
  19         if(!cvar("g_balance_teams_force"))\r
  20                 return -1;\r
  21         return 1;\r
  22 }\r
  23 \r
  24 void TeamchangeFrags(entity e)\r
  25 {\r
  26         PlayerScore_Clear(e);\r
  27 }\r
  28 \r
  29 vector TeamColor(float teem)\r
  30 {\r
  31         switch(teem)\r
  32         {\r
  33                 case COLOR_TEAM1:\r
  34                         return '1 0.0625 0.0625';\r
  35                 case COLOR_TEAM2:\r
  36                         return '0.0625 0.0625 1';\r
  37                 case COLOR_TEAM3:\r
  38                         return '1 1 0.0625';\r
  39                 case COLOR_TEAM4:\r
  40                         return '1 0.0625 1';\r
  41                 default:\r
  42                         return '1 1 1';\r
  43         }\r
  44 }\r
  45 \r
  46 string TeamName(float t)\r
  47 {\r
  48         return strcat(Team_ColorName(t), " Team");\r
  49 }\r
  50 string ColoredTeamName(float t)\r
  51 {\r
  52         return strcat(Team_ColorCode(t), Team_ColorName(t), " Team^7");\r
  53 }\r
  54 string TeamNoName(float t)\r
  55 {\r
  56         // fixme: Search for team entities and get their .netname's!\r
  57         if(t == 1)\r
  58                 return "Red Team";\r
  59         if(t == 2)\r
  60                 return "Blue Team";\r
  61         if(t == 3)\r
  62                 return "Yellow Team";\r
  63         if(t == 4)\r
  64                 return "Pink Team";\r
  65         return "Neutral Team";\r
  66 }\r
  67 \r
  68 void dom_init();\r
  69 void ctf_init();\r
  70 void tdm_init();\r
  71 void entcs_init();\r
  72 \r
  73 void LogTeamchange(float player_id, float team_number, float type)\r
  74 {\r
  75         if(!cvar("sv_eventlog"))\r
  76                 return;\r
  77 \r
  78         if(player_id < 1)\r
  79                 return;\r
  80 \r
  81         GameLogEcho(strcat(":team:", ftos(player_id), ":", ftos(team_number), ":", ftos(type)));\r
  82 }\r
  83 \r
  84 void WriteGameCvars()\r
  85 {\r
  86         cvar_set("g_dm", ftos(g_dm));\r
  87         cvar_set("g_tdm", ftos(g_tdm));\r
  88         cvar_set("g_domination", ftos(g_domination));\r
  89         cvar_set("g_ctf", ftos(g_ctf));\r
  90         cvar_set("g_lms", ftos(g_lms));\r
  91         cvar_set("g_arena", ftos(g_arena));\r
  92         cvar_set("g_ca", ftos(g_ca));\r
  93         cvar_set("g_keyhunt", ftos(g_keyhunt));\r
  94         cvar_set("g_assault", ftos(g_assault));\r
  95         cvar_set("g_onslaught", ftos(g_onslaught));\r
  96         cvar_set("g_race", ftos(g_race));\r
  97         cvar_set("g_cts", ftos(g_cts));\r
  98         cvar_set("g_rpg", ftos(g_rpg));\r
  99 }\r
 100 \r
 101 void ReadGameCvars()\r
 102 {\r
 103         float found;\r
 104         float prev;\r
 105         float i;\r
 106 \r
 107         found = 0;\r
 108         prev = cvar("gamecfg");\r
 109         for(i = 0; i < 2; ++i)\r
 110         {\r
 111                 found += (g_dm = (!found && (prev != GAME_DEATHMATCH) && cvar("g_dm")));\r
 112                 found += (g_tdm = (!found && (prev != GAME_TEAM_DEATHMATCH) && cvar("g_tdm")));\r
 113                 found += (g_domination = (!found && (prev != GAME_DOMINATION) && cvar("g_domination")));\r
 114                 found += (g_ctf = (!found && (prev != GAME_CTF) && cvar("g_ctf")));\r
 115                 found += (g_lms = (!found && (prev != GAME_LMS) && cvar("g_lms")));\r
 116                 found += (g_arena = (!found && (prev != GAME_ARENA) && cvar("g_arena")));\r
 117                 found += (g_ca = (!found && (prev != GAME_CA) && cvar("g_ca")));\r
 118                 found += (g_keyhunt = (!found && (prev != GAME_KEYHUNT) && cvar("g_keyhunt")));\r
 119                 found += (g_assault = (!found && (prev != GAME_ASSAULT) && cvar("g_assault")));\r
 120                 found += (g_onslaught = (!found && (prev != GAME_ONSLAUGHT) && cvar("g_onslaught")));\r
 121                 found += (g_race = (!found && (prev != GAME_RACE) && cvar("g_race")));\r
 122                 found += (g_cts = (!found && (prev != GAME_CTS) && cvar("g_cts")));\r
 123                 found += (g_rpg = (!found && (prev != GAME_RPG) && cvar("g_rpg")));\r
 124 \r
 125                 if(found)\r
 126                         break;\r
 127 \r
 128                 prev = -1; // second attempt takes place WITHOUT prev set\r
 129         }\r
 130 \r
 131         if(!found)\r
 132                 g_dm = 1;\r
 133 \r
 134         if(g_dm && cvar("deathmatch_force_teamplay"))\r
 135         {\r
 136                 g_dm = 0;\r
 137                 g_tdm = 1;\r
 138         }\r
 139 \r
 140         teams_matter = 0;\r
 141 }\r
 142 \r
 143 void default_delayedinit()\r
 144 {\r
 145         if(!scores_initialized)\r
 146                 ScoreRules_generic();\r
 147 }\r
 148 \r
 149 void ActivateTeamplay()\r
 150 {\r
 151         float teamplay_default;\r
 152         teamplay_default = cvar("teamplay_default");\r
 153 \r
 154         if(teamplay_default)\r
 155                 teamplay = teamplay_default;\r
 156         else\r
 157                 teamplay = 3;\r
 158         cvar_set("teamplay", ftos(teamplay));\r
 159 \r
 160         teams_matter = 1;\r
 161 }\r
 162 \r
 163 void InitGameplayMode()\r
 164 {\r
 165         float fraglimit_override, timelimit_override, leadlimit_override, qualifying_override;\r
 166 \r
 167         qualifying_override = -1;\r
 168 \r
 169         VoteReset();\r
 170 \r
 171         teams_matter = 0;\r
 172         cvar_set("teamplay", "0");\r
 173 \r
 174         // make sure only ONE type is selected\r
 175         ReadGameCvars();\r
 176         WriteGameCvars();\r
 177 \r
 178         // find out good world mins/maxs bounds, either the static bounds found by looking for solid, or the mapinfo specified bounds\r
 179         get_mi_min_max(1);\r
 180         world.mins = mi_min;\r
 181         world.maxs = mi_max;\r
 182 \r
 183         MapInfo_LoadMapSettings(mapname);\r
 184 \r
 185         if not(cvar_value_issafe(world.fog))\r
 186         {\r
 187                 print("The current map contains a potentially harmful fog setting, ignored\n");\r
 188                 world.fog = string_null;\r
 189         }\r
 190         if(MapInfo_Map_fog != "")\r
 191                 if(MapInfo_Map_fog == "none")\r
 192                         world.fog = string_null;\r
 193                 else\r
 194                         world.fog = strzone(MapInfo_Map_fog);\r
 195         clientstuff = strzone(MapInfo_Map_clientstuff);\r
 196 \r
 197         MapInfo_ClearTemps();\r
 198 \r
 199         // in case mapinfo switched the type\r
 200         ReadGameCvars();\r
 201 \r
 202         // set both here, gamemode can override it later\r
 203         timelimit_override = cvar("timelimit_override");\r
 204         fraglimit_override = cvar("fraglimit_override");\r
 205         leadlimit_override = cvar("leadlimit_override");\r
 206 \r
 207         if(g_dm)\r
 208         {\r
 209                 game = GAME_DEATHMATCH;\r
 210                 gamemode_name = "Deathmatch";\r
 211         }\r
 212 \r
 213         if(g_tdm)\r
 214         {\r
 215                 game = GAME_TEAM_DEATHMATCH;\r
 216                 gamemode_name = "Team Deathmatch";\r
 217                 ActivateTeamplay();\r
 218                 tdm_init();\r
 219                 if(cvar("g_tdm_team_spawns"))\r
 220                         have_team_spawns = -1; // request team spawns\r
 221         }\r
 222 \r
 223         if(g_domination)\r
 224         {\r
 225                 game = GAME_DOMINATION;\r
 226                 gamemode_name = "Domination";\r
 227                 ActivateTeamplay();\r
 228                 fraglimit_override = cvar("g_domination_point_limit");\r
 229                 leadlimit_override = cvar("g_domination_point_leadlimit");\r
 230                 dom_init();\r
 231                 have_team_spawns = -1; // request team spawns\r
 232         }\r
 233 \r
 234         if(g_ctf)\r
 235         {\r
 236                 game = GAME_CTF;\r
 237                 gamemode_name = "Capture the Flag";\r
 238                 ActivateTeamplay();\r
 239                 if(cvar("g_campaign"))\r
 240                         g_ctf_win_mode = 2;\r
 241                 else\r
 242                         g_ctf_win_mode = cvar("g_ctf_win_mode");\r
 243                 g_ctf_ignore_frags = cvar("g_ctf_ignore_frags");\r
 244                 if(g_ctf_win_mode == 2)\r
 245                 {\r
 246                         fraglimit_override = cvar("g_ctf_capture_limit");\r
 247                         leadlimit_override = cvar("g_ctf_capture_leadlimit");\r
 248                 }\r
 249                 else\r
 250                 {\r
 251                         fraglimit_override = cvar("capturelimit_override");\r
 252                         leadlimit_override = cvar("captureleadlimit_override");\r
 253                 }\r
 254                 ctf_init();\r
 255                 have_team_spawns = -1; // request team spawns\r
 256         }\r
 257 \r
 258         if(g_lms)\r
 259         {\r
 260                 game = GAME_LMS;\r
 261                 gamemode_name = "Last Man Standing";\r
 262                 fraglimit_override = cvar("g_lms_lives_override");\r
 263                 leadlimit_override = 0; // not supported by LMS\r
 264                 if(fraglimit_override == 0)\r
 265                         fraglimit_override = -1;\r
 266                 lms_lowest_lives = 9999;\r
 267                 lms_next_place = 0;\r
 268                 ScoreRules_lms();\r
 269         }\r
 270 \r
 271         if(g_arena)\r
 272         {\r
 273                 game = GAME_ARENA;\r
 274                 gamemode_name = "Arena";\r
 275                 fraglimit_override = cvar("g_arena_point_limit");\r
 276                 leadlimit_override = cvar("g_arena_point_leadlimit");\r
 277                 maxspawned = cvar("g_arena_maxspawned");\r
 278                 if(maxspawned < 2)\r
 279                         maxspawned = 2;\r
 280                 arena_roundbased = cvar("g_arena_roundbased");\r
 281         }\r
 282 \r
 283         if(g_ca)\r
 284         {\r
 285                 game = GAME_CA;\r
 286                 gamemode_name = "Clan Arena";\r
 287                 ActivateTeamplay();\r
 288                 fraglimit_override = cvar("g_ca_point_limit");\r
 289                 leadlimit_override = cvar("g_ca_point_leadlimit");\r
 290                 precache_sound("ctf/red_capture.wav");\r
 291                 precache_sound("ctf/blue_capture.wav");\r
 292         }\r
 293         if(g_keyhunt)\r
 294         {\r
 295                 game = GAME_KEYHUNT;\r
 296                 gamemode_name = "Key Hunt";\r
 297                 ActivateTeamplay();\r
 298                 fraglimit_override = cvar("g_keyhunt_point_limit");\r
 299                 leadlimit_override = cvar("g_keyhunt_point_leadlimit");\r
 300                 kh_init();\r
 301         }\r
 302 \r
 303         if(g_assault)\r
 304         {\r
 305                 game = GAME_ASSAULT;\r
 306                 gamemode_name = "Assault";\r
 307                 ActivateTeamplay();\r
 308                 ScoreRules_assault();\r
 309                 have_team_spawns = -1; // request team spawns\r
 310         }\r
 311 \r
 312         if(g_onslaught)\r
 313         {\r
 314                 game = GAME_ONSLAUGHT;\r
 315                 gamemode_name = "Onslaught";\r
 316                 ActivateTeamplay();\r
 317                 have_team_spawns = -1; // request team spawns\r
 318         }\r
 319 \r
 320         if(g_race)\r
 321         {\r
 322                 game = GAME_RACE;\r
 323                 gamemode_name = "Race";\r
 324 \r
 325                 if(cvar("g_race_teams"))\r
 326                 {\r
 327                         ActivateTeamplay();\r
 328                         race_teams = bound(2, cvar("g_race_teams"), 4);\r
 329                         have_team_spawns = -1; // request team spawns\r
 330                 }\r
 331                 else\r
 332                         race_teams = 0;\r
 333 \r
 334                 qualifying_override = cvar("g_race_qualifying_timelimit_override");\r
 335                 fraglimit_override = cvar("g_race_laps_limit");\r
 336                 leadlimit_override = 0; // currently not supported by race\r
 337         }\r
 338 \r
 339         if(g_cts)\r
 340         {\r
 341                 game = GAME_CTS;\r
 342                 gamemode_name = "CTS";\r
 343                 g_race_qualifying = 1;\r
 344                 fraglimit_override = 0;\r
 345                 leadlimit_override = 0;\r
 346         }\r
 347 \r
 348         if(g_rpg)\r
 349         {\r
 350                 game = GAME_RPG;\r
 351                 gamemode_name = "Role Play";\r
 352                 fraglimit_override = 0;\r
 353                 leadlimit_override = 0;\r
 354                 ScoreRules_rpg();\r
 355         }\r
 356 \r
 357         if(teams_matter)\r
 358                 entcs_init();\r
 359 \r
 360         // save it (for the next startup)\r
 361         cvar_set("gamecfg", ftos(game));\r
 362 \r
 363         cache_mutatormsg = strzone("");\r
 364         cache_lastmutatormsg = strzone("");\r
 365 \r
 366         // enforce the server's universal frag/time limits\r
 367         if(!cvar("g_campaign"))\r
 368         {\r
 369                 if(fraglimit_override >= 0)\r
 370                         cvar_set("fraglimit", ftos(fraglimit_override));\r
 371                 if(timelimit_override >= 0)\r
 372                         cvar_set("timelimit", ftos(timelimit_override));\r
 373                 if(leadlimit_override >= 0)\r
 374                         cvar_set("leadlimit", ftos(leadlimit_override));\r
 375                 if(qualifying_override >= 0)\r
 376                         cvar_set("g_race_qualifying_timelimit", ftos(qualifying_override));\r
 377         }\r
 378 \r
 379         if(g_race)\r
 380         {\r
 381                 // we need to find out the correct value for g_race_qualifying\r
 382                 if(cvar("g_campaign"))\r
 383                 {\r
 384                         g_race_qualifying = 1;\r
 385                 }\r
 386                 else if(!cvar("g_campaign") && cvar("g_race_qualifying_timelimit") > 0)\r
 387                 {\r
 388                         g_race_qualifying = 2;\r
 389                         race_fraglimit = cvar("fraglimit");\r
 390                         race_leadlimit = cvar("leadlimit");\r
 391                         race_timelimit = cvar("timelimit");\r
 392                         cvar_set("fraglimit", "0");\r
 393                         cvar_set("leadlimit", "0");\r
 394                         cvar_set("timelimit", cvar_string("g_race_qualifying_timelimit"));\r
 395                 }\r
 396                 else\r
 397                         g_race_qualifying = 0;\r
 398         }\r
 399 \r
 400         if(g_race || g_cts)\r
 401         {\r
 402                 if(g_race_qualifying)\r
 403                         independent_players = 1;\r
 404 \r
 405                 ScoreRules_race();\r
 406         }\r
 407 \r
 408         InitializeEntity(world, default_delayedinit, INITPRIO_GAMETYPE_FALLBACK);\r
 409 }\r
 410 \r
 411 string GetClientVersionMessage() {\r
 412         local string versionmsg;\r
 413         if (self.version_mismatch) {\r
 414                 if(self.version < cvar("gameversion")) {\r
 415                         versionmsg = "^3Your client version is outdated.\n\n\n### YOU WON'T BE ABLE TO PLAY ON THIS SERVER ###\n\n\nPlease update!!!^8";\r
 416                 } else {\r
 417                         versionmsg = "^3This server is using an outdated Voretournament version.\n\n\n ### THIS SERVER IS INCOMPATIBLE AND THUS YOU CANNOT JOIN ###.^8";\r
 418                 }\r
 419         } else {\r
 420                 versionmsg = "^2client version and server version are compatible.^8";\r
 421         }\r
 422         return versionmsg;\r
 423 }\r
 424 \r
 425 \r
 426 void PrintWelcomeMessage(entity pl)\r
 427 {\r
 428         string s, modifications, motd;\r
 429 \r
 430         if(self.cvar_scr_centertime == 0) return;\r
 431 \r
 432         if(cvar("g_campaign"))\r
 433         {\r
 434                 if(self.classname == "player" && !self.BUTTON_INFO)\r
 435                         return;\r
 436         }\r
 437         else\r
 438         {\r
 439                 if((time - self.jointime) > cvar("welcome_message_time") && !self.BUTTON_INFO)\r
 440                         return;\r
 441         }\r
 442 \r
 443         if( !(timeoutStatus >= 1) ) { //really print the WelcomeMessage to the player every frame when timeout-seconds are shown or the game is restarted, to make sure that the shown number is accurate\r
 444                 if(self.welcomemessage_time > time) return;\r
 445                 self.welcomemessage_time = time + max(0.5, self.cvar_scr_centertime * 0.6);\r
 446         }\r
 447 \r
 448         if(cvar("g_campaign"))\r
 449         {\r
 450                 centerprint(pl, campaign_message);\r
 451                 return;\r
 452         }\r
 453 \r
 454 //TODO GreEn`mArine: make the timeout-messages clientside as well (just like the ready restart countdown)!\r
 455         if(!self.BUTTON_INFO)\r
 456         {\r
 457                 // TODO get rid of this too\r
 458                 local string specString;\r
 459                 specString = NEWLINES;\r
 460                 //if(time < game_starttime) //also show the countdown when being a spectator\r
 461                 //      specString = strcat(specString, "\n\n^1Game starts in ", ftos(ceil(game_starttime - time)), " seconds^7");\r
 462                 //else\r
 463                 if (timeoutStatus != 0)\r
 464                         specString = strcat(specString, "\n\n", getTimeoutText(1));\r
 465                 else\r
 466                 {\r
 467                         if(self.classname == "player")\r
 468                                 return;\r
 469                         goto normal;\r
 470                 }\r
 471                 return centerprint_atprio(self, CENTERPRIO_SPAM, specString);\r
 472         }\r
 473 \r
 474 :normal\r
 475         modifications = "";\r
 476         if(cvar("sv_gravity") < 800)\r
 477                 modifications = strcat(modifications, ", Low gravity");\r
 478         if(g_cloaked)\r
 479                 modifications = strcat(modifications, ", Cloaked");\r
 480         if(g_midair)\r
 481                 modifications = strcat(modifications, ", Midair");\r
 482         if(g_vampire)\r
 483                 modifications = strcat(modifications, ", Vampire");\r
 484         if(g_weapon_stay)\r
 485                 modifications = strcat(modifications, ", Weapons stay");\r
 486         if(g_bloodloss > 0)\r
 487                 modifications = strcat(modifications, ", Bloodloss");\r
 488         if(g_jetpack)\r
 489                 modifications = strcat(modifications, ", Jet pack");\r
 490         if(cvar("g_balance_vore_weight_gravity") < 0)\r
 491                 modifications = strcat(modifications, ", Lighten");\r
 492         if(cvar("g_balance_vore_digestion_damage") >= 1000)\r
 493                 modifications = strcat(modifications, ", InstaDigestion");\r
 494         modifications = substring(modifications, 2, strlen(modifications) - 2);\r
 495 \r
 496         local string versionmessage;\r
 497         versionmessage = GetClientVersionMessage();\r
 498 \r
 499         s = strcat(s, NEWLINES, "This is Voretournament ", cvar_string("g_voretournamentversion"), "\n", versionmessage);\r
 500         s = strcat(s, "^8\n\nmatch type is ^1", gamemode_name, "^8\n");\r
 501 \r
 502         if(modifications != "")\r
 503                 s = strcat(s, "^8\nactive modifications: ^3", modifications, "^8\n");\r
 504 \r
 505         if(timeoutStatus != 0)\r
 506                 s = strcat(s, "\n\n", getTimeoutText(1));\r
 507 \r
 508         if(cache_lastmutatormsg != cvar_string("g_mutatormsg"))\r
 509         {\r
 510                 if(cache_lastmutatormsg)\r
 511                         strunzone(cache_lastmutatormsg);\r
 512                 if(cache_mutatormsg)\r
 513                         strunzone(cache_mutatormsg);\r
 514                 cache_lastmutatormsg = strzone(cvar_string("g_mutatormsg"));\r
 515                 cache_mutatormsg = strzone(cache_lastmutatormsg);\r
 516         }\r
 517 \r
 518         if (cache_mutatormsg != "") {\r
 519                 s = strcat(s, "\n\n^8special gameplay tips: ^7", cache_mutatormsg);\r
 520         }\r
 521 \r
 522         motd = cvar_string("sv_motd");\r
 523         if (motd != "") {\r
 524                 s = strcat(s, "\n\n^8MOTD: ^7", strreplace("\\n", "\n", motd));\r
 525         }\r
 526         s = strcat(s, "\n");\r
 527 \r
 528         centerprint(pl, s);\r
 529 }\r
 530 \r
 531 \r
 532 void SetPlayerColors(entity pl, float _color)\r
 533 {\r
 534         /*string s;\r
 535         s = ftos(cl);\r
 536         stuffcmd(pl, strcat("color ", s, " ", s, "\n")  );\r
 537         pl.team = cl + 1;\r
 538         //pl.clientcolors = pl.clientcolors - (pl.clientcolors & 15) + cl;\r
 539         pl.clientcolors = 16*cl + cl;*/\r
 540 \r
 541         float pants, shirt;\r
 542         pants = _color & 0x0F;\r
 543         shirt = _color & 0xF0;\r
 544 \r
 545 \r
 546         if(teams_matter) {\r
 547                 setcolor(pl, 16*pants + pants);\r
 548         } else {\r
 549                 setcolor(pl, shirt + pants);\r
 550         }\r
 551 }\r
 552 \r
 553 void SetPlayerTeam(entity pl, float t, float s, float noprint)\r
 554 {\r
 555         float _color;\r
 556 \r
 557         if(t == 4)\r
 558                 _color = COLOR_TEAM4 - 1;\r
 559         else if(t == 3)\r
 560                 _color = COLOR_TEAM3 - 1;\r
 561         else if(t == 2)\r
 562                 _color = COLOR_TEAM2 - 1;\r
 563         else\r
 564                 _color = COLOR_TEAM1 - 1;\r
 565 \r
 566         SetPlayerColors(pl,_color);\r
 567 \r
 568         if(t != s) {\r
 569                 LogTeamchange(pl.playerid, pl.team, 3);  // log manual team join\r
 570 \r
 571                 if(!noprint)\r
 572                 bprint(pl.netname, "^7 has changed from ", TeamNoName(s), " to ", TeamNoName(t), "\n");\r
 573         }\r
 574 \r
 575 }\r
 576 \r
 577 // set c1...c4 to show what teams are allowed\r
 578 void CheckAllowedTeams (entity for_whom)\r
 579 {\r
 580         float dm;\r
 581         entity head;\r
 582         string teament_name;\r
 583 \r
 584         c1 = c2 = c3 = c4 = -1;\r
 585         cb1 = cb2 = cb3 = cb4 = 0;\r
 586 \r
 587         if(g_onslaught)\r
 588         {\r
 589                 // onslaught is special\r
 590                 head = findchain(classname, "onslaught_generator");\r
 591                 while (head)\r
 592                 {\r
 593                         if (head.team == COLOR_TEAM1) c1 = 0;\r
 594                         if (head.team == COLOR_TEAM2) c2 = 0;\r
 595                         if (head.team == COLOR_TEAM3) c3 = 0;\r
 596                         if (head.team == COLOR_TEAM4) c4 = 0;\r
 597                         head = head.chain;\r
 598                 }\r
 599         }\r
 600         else if(g_domination)\r
 601                 teament_name = "dom_team";\r
 602         else if(g_ctf)\r
 603                 teament_name = "ctf_team";\r
 604         else if(g_tdm)\r
 605                 teament_name = "tdm_team";\r
 606         else if(g_assault)\r
 607                 c1 = c2 = 0; // Assault always has 2 teams\r
 608         else\r
 609         {\r
 610                 // cover anything else by treating it like tdm with no teams spawned\r
 611                 if(g_keyhunt)\r
 612                         dm = kh_teams;\r
 613                 else if(g_race)\r
 614                         dm = race_teams;\r
 615                 else\r
 616                         dm = 2;\r
 617 \r
 618                 if(dm >= 4)\r
 619                         c1 = c2 = c3 = c4 = 0;\r
 620                 else if(dm >= 3)\r
 621                         c1 = c2 = c3 = 0;\r
 622                 else\r
 623                         c1 = c2 = 0;\r
 624         }\r
 625 \r
 626         // find out what teams are allowed if necessary\r
 627         if(teament_name)\r
 628         {\r
 629                 head = find(world, classname, teament_name);\r
 630                 while(head)\r
 631                 {\r
 632                         if(!(g_domination && head.netname == ""))\r
 633                         {\r
 634                                 if(head.team == COLOR_TEAM1)\r
 635                                         c1 = 0;\r
 636                                 else if(head.team == COLOR_TEAM2)\r
 637                                         c2 = 0;\r
 638                                 else if(head.team == COLOR_TEAM3)\r
 639                                         c3 = 0;\r
 640                                 else if(head.team == COLOR_TEAM4)\r
 641                                         c4 = 0;\r
 642                         }\r
 643                         head = find(head, classname, teament_name);\r
 644                 }\r
 645         }\r
 646 \r
 647         // TODO: Balance quantity of bots across > 2 teams when bot_vs_human is set (and remove next line)\r
 648         if(c3==-1&&c4==-1)\r
 649         if(cvar("bot_vs_human") && for_whom)\r
 650         {\r
 651                 if(cvar("bot_vs_human") > 0)\r
 652                 {\r
 653                         // bots are all blue\r
 654                         if(clienttype(for_whom) == CLIENTTYPE_BOT)\r
 655                                 c1 = c3 = c4 = -1;\r
 656                         else\r
 657                                 c2 = -1;\r
 658                 }\r
 659                 else\r
 660                 {\r
 661                         // bots are all red\r
 662                         if(clienttype(for_whom) == CLIENTTYPE_BOT)\r
 663                                 c2 = c3 = c4 = -1;\r
 664                         else\r
 665                                 c1 = -1;\r
 666                 }\r
 667         }\r
 668 }\r
 669 \r
 670 float PlayerValue(entity p)\r
 671 {\r
 672         if(IsTeamBalanceForced() == 1)\r
 673                 return 1;\r
 674         return 1;\r
 675 }\r
 676 \r
 677 // c1...c4 should be set to -1 (not allowed) or 0 (allowed).\r
 678 // teams that are allowed will now have their player counts stored in c1...c4\r
 679 void GetTeamCounts(entity ignore)\r
 680 {\r
 681         entity head;\r
 682         float value, bvalue;\r
 683         // now count how many players are on each team already\r
 684 \r
 685         // FIXME: also find and memorize the lowest-scoring bot on each team (in case players must be shuffled around)\r
 686         // also remember the lowest-scoring player\r
 687 \r
 688         FOR_EACH_PLAYER(head)\r
 689         {\r
 690                 if(head != ignore)// && head.netname != "")\r
 691                 {\r
 692                         value = PlayerValue(head);\r
 693                         if(clienttype(head) == CLIENTTYPE_BOT)\r
 694                                 bvalue = value;\r
 695                         else\r
 696                                 bvalue = 0;\r
 697                         if(head.team == COLOR_TEAM1)\r
 698                         {\r
 699                                 if(c1 >= 0)\r
 700                                 {\r
 701                                         c1 = c1 + value;\r
 702                                         cb1 = cb1 + bvalue;\r
 703                                 }\r
 704                         }\r
 705                         if(head.team == COLOR_TEAM2)\r
 706                         {\r
 707                                 if(c2 >= 0)\r
 708                                 {\r
 709                                         c2 = c2 + value;\r
 710                                         cb2 = cb2 + bvalue;\r
 711                                 }\r
 712                         }\r
 713                         if(head.team == COLOR_TEAM3)\r
 714                         {\r
 715                                 if(c3 >= 0)\r
 716                                 {\r
 717                                         c3 = c3 + value;\r
 718                                         cb3 = cb3 + bvalue;\r
 719                                 }\r
 720                         }\r
 721                         if(head.team == COLOR_TEAM4)\r
 722                         {\r
 723                                 if(c4 >= 0)\r
 724                                 {\r
 725                                         c4 = c4 + value;\r
 726                                         cb4 = cb4 + bvalue;\r
 727                                 }\r
 728                         }\r
 729                 }\r
 730         }\r
 731 }\r
 732 \r
 733 // returns # of smallest team (1, 2, 3, 4)\r
 734 // NOTE: Assumes CheckAllowedTeams has already been called!\r
 735 float FindSmallestTeam(entity pl, float ignore_pl)\r
 736 {\r
 737         float totalteams, balance_type, maxc;\r
 738         totalteams = 0;\r
 739 \r
 740         // find out what teams are available\r
 741         //CheckAllowedTeams();\r
 742 \r
 743         // make sure there are at least 2 teams to join\r
 744         if(c1 >= 0)\r
 745                 totalteams = totalteams + 1;\r
 746         if(c2 >= 0)\r
 747                 totalteams = totalteams + 1;\r
 748         if(c3 >= 0)\r
 749                 totalteams = totalteams + 1;\r
 750         if(c4 >= 0)\r
 751                 totalteams = totalteams + 1;\r
 752 \r
 753         if(cvar("bot_vs_human"))\r
 754                 totalteams += 1;\r
 755 \r
 756         if(totalteams <= 1)\r
 757         {\r
 758                 if(g_domination)\r
 759                         error("Too few teams available for domination\n");\r
 760                 else if(g_ctf)\r
 761                         error("Too few teams available for ctf\n");\r
 762                 else if(g_keyhunt)\r
 763                         error("Too few teams available for key hunt\n");\r
 764                 else\r
 765                         error("Too few teams available for team deathmatch\n");\r
 766         }\r
 767 \r
 768         // count how many players are in each team\r
 769         if(ignore_pl)\r
 770                 GetTeamCounts(pl);\r
 771         else\r
 772                 GetTeamCounts(world);\r
 773 \r
 774         // c1...c4 now have counts of each team\r
 775         // figure out which is smallest, giving priority to the team the player is already on as a tie-breaker\r
 776 \r
 777         // 2 gives priority to what team you're already on, 1 goes in order\r
 778         // 2 doesn't seem to work though...\r
 779         balance_type = 1;\r
 780 \r
 781         if(bots_would_leave)\r
 782         //if(pl.classname != "player")\r
 783         if(clienttype(pl) != CLIENTTYPE_BOT)\r
 784         {\r
 785                 c1 -= cb1 * 255.0/256.0;\r
 786                 c2 -= cb2 * 255.0/256.0;\r
 787                 c3 -= cb3 * 255.0/256.0;\r
 788                 c4 -= cb4 * 255.0/256.0;\r
 789         }\r
 790         maxc = max4(c1, c2, c3, c4);\r
 791 \r
 792         RandomSelection_Init();\r
 793         if(balance_type == 1)\r
 794         {\r
 795                 // 1: use team count, then score (note: can only use 8 significant bits of score)\r
 796                 if(c1 >= 0) RandomSelection_Add(world, 1, string_null, 1, (maxc - c1) + float2range01(-team1_score) / 256.0);\r
 797                 if(c2 >= 0) RandomSelection_Add(world, 2, string_null, 1, (maxc - c2) + float2range01(-team2_score) / 256.0);\r
 798                 if(c3 >= 0) RandomSelection_Add(world, 3, string_null, 1, (maxc - c3) + float2range01(-team3_score) / 256.0);\r
 799                 if(c4 >= 0) RandomSelection_Add(world, 4, string_null, 1, (maxc - c4) + float2range01(-team4_score) / 256.0);\r
 800         }\r
 801         else if(balance_type == 2)\r
 802         {\r
 803                 // 1: use team count, if equal prefer own team\r
 804                 if(c1 >= 0) RandomSelection_Add(world, 1, string_null, 1, (maxc - c1) + (self.team == COLOR_TEAM1) / 512.0);\r
 805                 if(c2 >= 0) RandomSelection_Add(world, 1, string_null, 1, (maxc - c1) + (self.team == COLOR_TEAM2) / 512.0);\r
 806                 if(c3 >= 0) RandomSelection_Add(world, 1, string_null, 1, (maxc - c1) + (self.team == COLOR_TEAM3) / 512.0);\r
 807                 if(c4 >= 0) RandomSelection_Add(world, 1, string_null, 1, (maxc - c1) + (self.team == COLOR_TEAM4) / 512.0);\r
 808         }\r
 809         else if(balance_type == 3)\r
 810         {\r
 811                 // 1: use team count, then score, if equal prefer own team (probably fails due to float accuracy problems)\r
 812                 if(c1 >= 0) RandomSelection_Add(world, 1, string_null, 1, (maxc - c1) + float2range01(-team1_score + 0.5 * (self.team == COLOR_TEAM1)) / 256.0);\r
 813                 if(c2 >= 0) RandomSelection_Add(world, 2, string_null, 1, (maxc - c2) + float2range01(-team2_score + 0.5 * (self.team == COLOR_TEAM2)) / 256.0);\r
 814                 if(c3 >= 0) RandomSelection_Add(world, 3, string_null, 1, (maxc - c3) + float2range01(-team3_score + 0.5 * (self.team == COLOR_TEAM3)) / 256.0);\r
 815                 if(c4 >= 0) RandomSelection_Add(world, 4, string_null, 1, (maxc - c4) + float2range01(-team4_score + 0.5 * (self.team == COLOR_TEAM4)) / 256.0);\r
 816         }\r
 817         return RandomSelection_chosen_float;\r
 818 }\r
 819 \r
 820 float JoinBestTeam(entity pl, float only_return_best, float forcebestteam)\r
 821 {\r
 822         float smallest, selectedteam;\r
 823 \r
 824         // don't join a team if we're not playing a team game\r
 825         if(!teams_matter)\r
 826                 return 0;\r
 827 \r
 828         // find out what teams are available\r
 829         CheckAllowedTeams(pl);\r
 830 \r
 831         // if we don't care what team he ends up on, put him on whatever team he entered as.\r
 832         // if he's not on a valid team, then let other code put him on the smallest team\r
 833         if(!forcebestteam)\r
 834         {\r
 835                 if(     c1 >= 0 && pl.team == COLOR_TEAM1)\r
 836                         selectedteam = pl.team;\r
 837                 else if(c2 >= 0 && pl.team == COLOR_TEAM2)\r
 838                         selectedteam = pl.team;\r
 839                 else if(c3 >= 0 && pl.team == COLOR_TEAM3)\r
 840                         selectedteam = pl.team;\r
 841                 else if(c4 >= 0 && pl.team == COLOR_TEAM4)\r
 842                         selectedteam = pl.team;\r
 843                 else\r
 844                         selectedteam = -1;\r
 845 \r
 846                 if(selectedteam > 0)\r
 847                 {\r
 848                         if(!only_return_best)\r
 849                         {\r
 850                                 SetPlayerColors(pl, selectedteam - 1);\r
 851 \r
 852                                 // when JoinBestTeam is called by client.qc/ClientKill_Now_TeamChange the players team is -1 and thus skipped\r
 853                                 // when JoinBestTeam is called by cl_client.qc/ClientConnect the player_id is 0 the log attempt is rejected\r
 854                                 LogTeamchange(pl.playerid, pl.team, 99);\r
 855                         }\r
 856                         return selectedteam;\r
 857                 }\r
 858                 // otherwise end up on the smallest team (handled below)\r
 859         }\r
 860 \r
 861         smallest = FindSmallestTeam(pl, TRUE);\r
 862 \r
 863         if(!only_return_best)\r
 864         {\r
 865                 TeamchangeFrags(self);\r
 866                 if(smallest == 1)\r
 867                 {\r
 868                         SetPlayerColors(pl, COLOR_TEAM1 - 1);\r
 869                 }\r
 870                 else if(smallest == 2)\r
 871                 {\r
 872                         SetPlayerColors(pl, COLOR_TEAM2 - 1);\r
 873                 }\r
 874                 else if(smallest == 3)\r
 875                 {\r
 876                         SetPlayerColors(pl, COLOR_TEAM3 - 1);\r
 877                 }\r
 878                 else if(smallest == 4)\r
 879                 {\r
 880                         SetPlayerColors(pl, COLOR_TEAM4 - 1);\r
 881                 }\r
 882                 else\r
 883                 {\r
 884                         error("smallest team: invalid team\n");\r
 885                 }\r
 886 \r
 887                 LogTeamchange(pl.playerid, pl.team, 2); // log auto join\r
 888 \r
 889                 if(pl.deadflag == DEAD_NO)\r
 890                         Damage(pl, pl, pl, 100000, DEATH_TEAMCHANGE, pl.origin, '0 0 0');\r
 891         }\r
 892 \r
 893         return smallest;\r
 894 }\r
 895 \r
 896 //void() ctf_playerchanged;\r
 897 void SV_ChangeTeam(float _color)\r
 898 {\r
 899         float scolor, dcolor, steam, dteam, dbotcount, scount, dcount;\r
 900 \r
 901         // in normal deathmatch we can just apply the color and we're done\r
 902         if(!teams_matter) {\r
 903                 SetPlayerColors(self, _color);\r
 904                 return;\r
 905         }\r
 906 \r
 907         scolor = self.clientcolors & 0x0F;\r
 908         dcolor = _color & 0x0F;\r
 909 \r
 910         if(scolor == COLOR_TEAM1 - 1)\r
 911                 steam = 1;\r
 912         else if(scolor == COLOR_TEAM2 - 1)\r
 913                 steam = 2;\r
 914         else if(scolor == COLOR_TEAM3 - 1)\r
 915                 steam = 3;\r
 916         else // if(scolor == COLOR_TEAM4 - 1)\r
 917                 steam = 4;\r
 918         if(dcolor == COLOR_TEAM1 - 1)\r
 919                 dteam = 1;\r
 920         else if(dcolor == COLOR_TEAM2 - 1)\r
 921                 dteam = 2;\r
 922         else if(dcolor == COLOR_TEAM3 - 1)\r
 923                 dteam = 3;\r
 924         else // if(dcolor == COLOR_TEAM4 - 1)\r
 925                 dteam = 4;\r
 926 \r
 927         CheckAllowedTeams(self);\r
 928 \r
 929         if(dteam == 1 && c1 < 0) dteam = 4;\r
 930         if(dteam == 4 && c4 < 0) dteam = 3;\r
 931         if(dteam == 3 && c3 < 0) dteam = 2;\r
 932         if(dteam == 2 && c2 < 0) dteam = 1;\r
 933 \r
 934         // not changing teams\r
 935         if(scolor == dcolor)\r
 936         {\r
 937                 //bprint("same team change\n");\r
 938                 SetPlayerTeam(self, dteam, steam, TRUE);\r
 939                 return;\r
 940         }\r
 941 \r
 942         if((cvar("g_campaign")) || (cvar("g_changeteam_banned") && self.wasplayer)) {\r
 943                 sprint(self, "Team changes not allowed\n");\r
 944                 return; // changing teams is not allowed\r
 945         }\r
 946 \r
 947         if(cvar("g_balance_teams_prevent_imbalance"))\r
 948         {\r
 949                 // only allow changing to a smaller or equal size team\r
 950 \r
 951                 // find out what teams are available\r
 952                 //CheckAllowedTeams();\r
 953                 // count how many players on each team\r
 954                 GetTeamCounts(world);\r
 955 \r
 956                 // get desired team\r
 957                 if(dteam == 1 && c1 >= 0)//dcolor == COLOR_TEAM1 - 1)\r
 958                 {\r
 959                         dcount = c1;\r
 960                         dbotcount = cb1;\r
 961                 }\r
 962                 else if(dteam == 2 && c2 >= 0)//dcolor == COLOR_TEAM2 - 1)\r
 963                 {\r
 964                         dcount = c2;\r
 965                         dbotcount = cb2;\r
 966                 }\r
 967                 else if(dteam == 3 && c3 >= 0)//dcolor == COLOR_TEAM3 - 1)\r
 968                 {\r
 969                         dcount = c3;\r
 970                         dbotcount = cb3;\r
 971                 }\r
 972                 else if(dteam == 4 && c4 >= 0)//dcolor == COLOR_TEAM4 - 1)\r
 973                 {\r
 974                         dcount = c4;\r
 975                         dbotcount = cb4;\r
 976                 }\r
 977                 else\r
 978                 {\r
 979                         sprint(self, "Cannot change to an invalid team\n");\r
 980 \r
 981                         return;\r
 982                 }\r
 983 \r
 984                 // get starting team\r
 985                 if(steam == 1)//scolor == COLOR_TEAM1 - 1)\r
 986                         scount = c1;\r
 987                 else if(steam == 2)//scolor == COLOR_TEAM2 - 1)\r
 988                         scount = c2;\r
 989                 else if(steam == 3)//scolor == COLOR_TEAM3 - 1)\r
 990                         scount = c3;\r
 991                 else if(steam == 4)//scolor == COLOR_TEAM4 - 1)\r
 992                         scount = c4;\r
 993 \r
 994                 if(scount) // started at a valid, nonempty team\r
 995                 {\r
 996                         // check if we're trying to change to a larger team that doens't have bots to swap with\r
 997                         if(dcount >= scount && dbotcount <= 0)\r
 998                         {\r
 999                                 sprint(self, "Cannot change to a larger team\n");\r
1000                                 return; // can't change to a larger team\r
1001                         }\r
1002                 }\r
1003         }\r
1004 \r
1005 //      bprint("allow change teams from ", ftos(steam), " to ", ftos(dteam), "\n");\r
1006 \r
1007         if(self.classname == "player" && steam != dteam)\r
1008         {\r
1009                 // reduce frags during a team change\r
1010                 TeamchangeFrags(self);\r
1011         }\r
1012 \r
1013         SetPlayerTeam(self, dteam, steam, FALSE);\r
1014 \r
1015         if(self.classname == "player" && steam != dteam)\r
1016         {\r
1017                 // kill player when changing teams\r
1018                 if(self.deadflag == DEAD_NO)\r
1019                         Damage(self, self, self, 100000, DEATH_TEAMCHANGE, self.origin, '0 0 0');\r
1020         }\r
1021         //ctf_playerchanged();\r
1022 }\r
1023 \r
1024 void ShufflePlayerOutOfTeam (float source_team)\r
1025 {\r
1026         float smallestteam, smallestteam_count, steam;\r
1027         float lowest_bot_score, lowest_player_score;\r
1028         entity head, lowest_bot, lowest_player, selected;\r
1029 \r
1030         smallestteam = 0;\r
1031         smallestteam_count = 999999999;\r
1032 \r
1033         if(c1 >= 0 && c1 < smallestteam_count)\r
1034         {\r
1035                 smallestteam = 1;\r
1036                 smallestteam_count = c1;\r
1037         }\r
1038         if(c2 >= 0 && c2 < smallestteam_count)\r
1039         {\r
1040                 smallestteam = 2;\r
1041                 smallestteam_count = c2;\r
1042         }\r
1043         if(c3 >= 0 && c3 < smallestteam_count)\r
1044         {\r
1045                 smallestteam = 3;\r
1046                 smallestteam_count = c3;\r
1047         }\r
1048         if(c4 >= 0 && c4 < smallestteam_count)\r
1049         {\r
1050                 smallestteam = 4;\r
1051                 smallestteam_count = c4;\r
1052         }\r
1053 \r
1054         if(!smallestteam)\r
1055         {\r
1056                 bprint("warning: no smallest team\n");\r
1057                 return;\r
1058         }\r
1059 \r
1060         if(source_team == 1)\r
1061                 steam = COLOR_TEAM1;\r
1062         else if(source_team == 2)\r
1063                 steam = COLOR_TEAM2;\r
1064         else if(source_team == 3)\r
1065                 steam = COLOR_TEAM3;\r
1066         else if(source_team == 4)\r
1067                 steam = COLOR_TEAM4;\r
1068 \r
1069         lowest_bot = world;\r
1070         lowest_bot_score = 999999999;\r
1071         lowest_player = world;\r
1072         lowest_player_score = 999999999;\r
1073 \r
1074         // find the lowest-scoring player & bot of that team\r
1075         FOR_EACH_PLAYER(head)\r
1076         {\r
1077                 if(head.team == steam)\r
1078                 {\r
1079                         if(head.isbot)\r
1080                         {\r
1081                                 if(head.totalfrags < lowest_bot_score)\r
1082                                 {\r
1083                                         lowest_bot = head;\r
1084                                         lowest_bot_score = head.totalfrags;\r
1085                                 }\r
1086                         }\r
1087                         else\r
1088                         {\r
1089                                 if(head.totalfrags < lowest_player_score)\r
1090                                 {\r
1091                                         lowest_player = head;\r
1092                                         lowest_player_score = head.totalfrags;\r
1093                                 }\r
1094                         }\r
1095                 }\r
1096         }\r
1097 \r
1098         // prefers to move a bot...\r
1099         if(lowest_bot != world)\r
1100                 selected = lowest_bot;\r
1101         // but it will move a player if it has to\r
1102         else\r
1103                 selected = lowest_player;\r
1104         // don't do anything if it couldn't find anyone\r
1105         if(!selected)\r
1106         {\r
1107                 bprint("warning: couldn't find a player to move from team\n");\r
1108                 return;\r
1109         }\r
1110 \r
1111         // smallest team gains a member\r
1112         if(smallestteam == 1)\r
1113         {\r
1114                 c1 = c1 + 1;\r
1115         }\r
1116         else if(smallestteam == 2)\r
1117         {\r
1118                 c2 = c2 + 1;\r
1119         }\r
1120         else if(smallestteam == 3)\r
1121         {\r
1122                 c3 = c3 + 1;\r
1123         }\r
1124         else if(smallestteam == 4)\r
1125         {\r
1126                 c4 = c4 + 1;\r
1127         }\r
1128         else\r
1129         {\r
1130                 bprint("warning: destination team invalid\n");\r
1131                 return;\r
1132         }\r
1133         // source team loses a member\r
1134         if(source_team == 1)\r
1135         {\r
1136                 c1 = c1 + 1;\r
1137         }\r
1138         else if(source_team == 2)\r
1139         {\r
1140                 c2 = c2 + 2;\r
1141         }\r
1142         else if(source_team == 3)\r
1143         {\r
1144                 c3 = c3 + 3;\r
1145         }\r
1146         else if(source_team == 4)\r
1147         {\r
1148                 c4 = c4 + 4;\r
1149         }\r
1150         else\r
1151         {\r
1152                 bprint("warning: source team invalid\n");\r
1153                 return;\r
1154         }\r
1155 \r
1156         // move the player to the new team\r
1157         TeamchangeFrags(selected);\r
1158         SetPlayerTeam(selected, smallestteam, source_team, FALSE);\r
1159 \r
1160         if(selected.deadflag == DEAD_NO)\r
1161                 Damage(selected, selected, selected, 100000, DEATH_AUTOTEAMCHANGE, selected.origin, '0 0 0');\r
1162         centerprint(selected, strcat("You have been moved into a different team to improve team balance\nYou are now on: ", ColoredTeamName(selected.team)));\r
1163 }\r
1164 \r
1165 void CauseRebalance(float source_team, float howmany_toomany)\r
1166 {\r
1167         if(IsTeamBalanceForced() == 1)\r
1168         {\r
1169                 bprint("Rebalancing Teams\n");\r
1170                 ShufflePlayerOutOfTeam(source_team);\r
1171         }\r
1172 }\r
1173 \r
1174 // part of g_balance_teams_force\r
1175 // occasionally perform an audit of the teams to make\r
1176 // sure they're more or less balanced in player count.\r
1177 void AuditTeams()\r
1178 {\r
1179         float numplayers, numteams, smallest, toomany;\r
1180         float balance;\r
1181         balance = IsTeamBalanceForced();\r
1182         if(balance == 0)\r
1183                 return;\r
1184 \r
1185         if(audit_teams_time > time)\r
1186                 return;\r
1187 \r
1188         audit_teams_time = time + 4 + random();\r
1189 \r
1190 //      bprint("Auditing teams\n");\r
1191 \r
1192         CheckAllowedTeams(world);\r
1193         GetTeamCounts(world);\r
1194 \r
1195 \r
1196         numteams = numplayers = smallest = 0;\r
1197         if(c1 >= 0)\r
1198         {\r
1199                 numteams = numteams + 1;\r
1200                 numplayers = numplayers + c1;\r
1201                 smallest = c1;\r
1202         }\r
1203         if(c2 >= 0)\r
1204         {\r
1205                 numteams = numteams + 1;\r
1206                 numplayers = numplayers + c2;\r
1207                 if(c2 < smallest)\r
1208                         smallest = c2;\r
1209         }\r
1210         if(c3 >= 0)\r
1211         {\r
1212                 numteams = numteams + 1;\r
1213                 numplayers = numplayers + c3;\r
1214                 if(c3 < smallest)\r
1215                         smallest = c3;\r
1216         }\r
1217         if(c4 >= 0)\r
1218         {\r
1219                 numteams = numteams + 1;\r
1220                 numplayers = numplayers + c4;\r
1221                 if(c4 < smallest)\r
1222                         smallest = c4;\r
1223         }\r
1224 \r
1225         if(numplayers <= 0)\r
1226                 return; // no players to move around\r
1227         if(numteams < 2)\r
1228                 return; // don't bother shuffling if for some reason there aren't any teams\r
1229 \r
1230         toomany = smallest + 1;\r
1231 \r
1232         if(c1 && c1 > toomany)\r
1233                 CauseRebalance(1, c1 - toomany);\r
1234         if(c2 && c2 > toomany)\r
1235                 CauseRebalance(2, c2 - toomany);\r
1236         if(c3 && c3 > toomany)\r
1237                 CauseRebalance(3, c3 - toomany);\r
1238         if(c4 && c4 > toomany)\r
1239                 CauseRebalance(4, c4 - toomany);\r
1240 \r
1241         // if teams are still unbalanced, balance them further in the next audit,\r
1242         // which will happen sooner (keep doing rapid audits until things are in order)\r
1243         audit_teams_time = time + 0.7 + random()*0.3;\r
1244 }\r
1245 \r
1246 // code from here on is just to support maps that don't have team entities\r
1247 void tdm_spawnteam (string teamname, float teamcolor)\r
1248 {\r
1249         local entity e;\r
1250         e = spawn();\r
1251         e.classname = "tdm_team";\r
1252         e.netname = teamname;\r
1253         e.cnt = teamcolor;\r
1254         e.team = e.cnt + 1;\r
1255 };\r
1256 \r
1257 // spawn some default teams if the map is not set up for tdm\r
1258 void tdm_spawnteams()\r
1259 {\r
1260         float numteams;\r
1261 \r
1262         numteams = cvar("g_tdm_teams_override");\r
1263         if(numteams < 2)\r
1264                 numteams = cvar("g_tdm_teams");\r
1265         numteams = bound(2, numteams, 4);\r
1266 \r
1267         tdm_spawnteam("Red", COLOR_TEAM1-1);\r
1268         tdm_spawnteam("Blue", COLOR_TEAM2-1);\r
1269         if(numteams >= 3)\r
1270                 tdm_spawnteam("Yellow", COLOR_TEAM3-1);\r
1271         if(numteams >= 4)\r
1272                 tdm_spawnteam("Pink", COLOR_TEAM4-1);\r
1273 };\r
1274 \r
1275 void tdm_delayedinit()\r
1276 {\r
1277         // if no teams are found, spawn defaults\r
1278         if (find(world, classname, "tdm_team") == world)\r
1279                 tdm_spawnteams();\r
1280 };\r
1281 \r
1282 void tdm_init()\r
1283 {\r
1284         InitializeEntity(world, tdm_delayedinit, INITPRIO_GAMETYPE);\r
1285 };\r