qcsrc/server/teamplay.qc

   1 string cache_mutatormsg;
   2 string cache_lastmutatormsg;
   3
   4 // client counts for each team
   5 float c1, c2, c3, c4;
   6 // # of bots on those teams
   7 float cb1, cb2, cb3, cb4;
   8
   9 //float audit_teams_time;
  10
  11 void TeamchangeFrags(entity e)
  12 {
  13         PlayerScore_Clear(e);
  14 }
  15
  16 void runematch_init();
  17 void tdm_init();
  18 void entcs_init();
  19
  20 void LogTeamchange(float player_id, float team_number, float type)
  21 {
  22         if(!autocvar_sv_eventlog)
  23                 return;
  24
  25         if(player_id < 1)
  26                 return;
  27
  28         GameLogEcho(strcat(":team:", ftos(player_id), ":", ftos(team_number), ":", ftos(type)));
  29 }
  30
  31 void default_delayedinit()
  32 {
  33         if(!scores_initialized)
  34                 ScoreRules_generic();
  35 }
  36
  37 void ActivateTeamplay()
  38 {
  39         serverflags |= SERVERFLAG_TEAMPLAY;
  40         teamplay = 1;
  41 }
  42
  43 void InitGameplayMode()
  44 {
  45         float fraglimit_override, timelimit_override, leadlimit_override, qualifying_override;
  46
  47         qualifying_override = -1;
  48
  49         VoteReset();
  50
  51         // find out good world mins/maxs bounds, either the static bounds found by looking for solid, or the mapinfo specified bounds
  52         get_mi_min_max(1);
  53         world.mins = mi_min;
  54         world.maxs = mi_max;
  55
  56         MapInfo_LoadMapSettings(mapname);
  57         teamplay = 0;
  58         serverflags &~= SERVERFLAG_TEAMPLAY;
  59
  60         if not(cvar_value_issafe(world.fog))
  61         {
  62                 print("The current map contains a potentially harmful fog setting, ignored\n");
  63                 world.fog = string_null;
  64         }
  65         if(MapInfo_Map_fog != "")
  66                 if(MapInfo_Map_fog == "none")
  67                         world.fog = string_null;
  68                 else
  69                         world.fog = strzone(MapInfo_Map_fog);
  70         clientstuff = strzone(MapInfo_Map_clientstuff);
  71
  72         MapInfo_ClearTemps();
  73
  74         // set both here, gamemode can override it later
  75         timelimit_override = autocvar_timelimit_override;
  76         fraglimit_override = autocvar_fraglimit_override;
  77         leadlimit_override = autocvar_leadlimit_override;
  78         gamemode_name = MapInfo_Type_ToText(MapInfo_LoadedGametype);
  79
  80         if(g_dm)
  81         {
  82         }
  83
  84         if(g_tdm)
  85         {
  86                 ActivateTeamplay();
  87                 tdm_init();
  88                 if(autocvar_g_tdm_team_spawns)
  89                         have_team_spawns = -1; // request team spawns
  90         }
  91
  92         if(g_domination)
  93         {
  94                 ActivateTeamplay();
  95                 fraglimit_override = autocvar_g_domination_point_limit;
  96                 leadlimit_override = autocvar_g_domination_point_leadlimit;
  97                 MUTATOR_ADD(gamemode_domination);
  98                 have_team_spawns = -1; // request team spawns
  99         }
 100
 101         if(g_ctf)
 102         {
 103                 ActivateTeamplay();
 104                 fraglimit_override = autocvar_capturelimit_override;
 105                 leadlimit_override = autocvar_captureleadlimit_override;
 106                 MUTATOR_ADD(gamemode_ctf);
 107                 have_team_spawns = -1; // request team spawns
 108         }
 109
 110         if(g_td)
 111         {
 112                 fraglimit_override = 0; // no limits in TD - it's a survival mode
 113                 leadlimit_override = 0;
 114                 MUTATOR_ADD(gamemode_td);
 115         }
 116
 117         if(g_rts)
 118         {
 119                 ActivateTeamplay();
 120                 fraglimit_override = 0;
 121                 leadlimit_override = 0;
 122                 MUTATOR_ADD(gamemode_rts);
 123                 have_team_spawns = -1; // request team spawns
 124         }
 125
 126         if(g_runematch)
 127         {
 128                 // ActivateTeamplay();
 129                 fraglimit_override = autocvar_g_runematch_point_limit;
 130                 leadlimit_override = autocvar_g_runematch_point_leadlimit;
 131                 runematch_init();
 132         }
 133
 134         if(g_lms)
 135         {
 136                 fraglimit_override = autocvar_g_lms_lives_override;
 137                 leadlimit_override = 0; // not supported by LMS
 138                 if(fraglimit_override == 0)
 139                         fraglimit_override = -1;
 140                 lms_lowest_lives = 9999;
 141                 lms_next_place = 0;
 142                 ScoreRules_lms();
 143         }
 144
 145         if(g_arena)
 146         {
 147                 fraglimit_override = autocvar_g_arena_point_limit;
 148                 leadlimit_override = autocvar_g_arena_point_leadlimit;
 149                 maxspawned = autocvar_g_arena_maxspawned;
 150                 if(maxspawned < 2)
 151                         maxspawned = 2;
 152                 arena_roundbased = autocvar_g_arena_roundbased;
 153         }
 154
 155         if(g_ca)
 156         {
 157                 ActivateTeamplay();
 158                 fraglimit_override = autocvar_g_ca_point_limit;
 159                 leadlimit_override = autocvar_g_ca_point_leadlimit;
 160                 precache_sound("ctf/red_capture.wav");
 161                 precache_sound("ctf/blue_capture.wav");
 162         }
 163         if(g_keyhunt)
 164         {
 165                 ActivateTeamplay();
 166                 fraglimit_override = autocvar_g_keyhunt_point_limit;
 167                 leadlimit_override = autocvar_g_keyhunt_point_leadlimit;
 168                 MUTATOR_ADD(gamemode_keyhunt);
 169         }
 170
 171         if(g_freezetag)
 172         {
 173                 ActivateTeamplay();
 174                 fraglimit_override = autocvar_g_freezetag_point_limit;
 175                 leadlimit_override = autocvar_g_freezetag_point_leadlimit;
 176                 MUTATOR_ADD(gamemode_freezetag);
 177         }
 178
 179         if(g_assault)
 180         {
 181                 ActivateTeamplay();
 182                 ScoreRules_assault();
 183                 have_team_spawns = -1; // request team spawns
 184         }
 185
 186         if(g_onslaught)
 187         {
 188                 ActivateTeamplay();
 189                 have_team_spawns = -1; // request team spawns
 190                 MUTATOR_ADD(gamemode_onslaught);
 191         }
 192
 193         if(g_race)
 194         {
 195
 196                 if(autocvar_g_race_teams)
 197                 {
 198                         ActivateTeamplay();
 199                         race_teams = bound(2, autocvar_g_race_teams, 4);
 200                         have_team_spawns = -1; // request team spawns
 201                 }
 202                 else
 203                         race_teams = 0;
 204
 205                 qualifying_override = autocvar_g_race_qualifying_timelimit_override;
 206                 fraglimit_override = autocvar_g_race_laps_limit;
 207                 leadlimit_override = 0; // currently not supported by race
 208         }
 209
 210         if(g_cts)
 211         {
 212                 g_race_qualifying = 1;
 213                 fraglimit_override = 0;
 214                 leadlimit_override = 0;
 215         }
 216
 217         if(g_nexball)
 218         {
 219         fraglimit_override = autocvar_g_nexball_goallimit;
 220         leadlimit_override = autocvar_g_nexball_goalleadlimit;
 221         ActivateTeamplay();
 222         have_team_spawns = -1; // request team spawns
 223             MUTATOR_ADD(gamemode_nexball);
 224         }
 225
 226         if(g_keepaway)
 227         {
 228                 MUTATOR_ADD(gamemode_keepaway);
 229         }
 230
 231         if(teamplay)
 232                 entcs_init();
 233
 234         cache_mutatormsg = strzone("");
 235         cache_lastmutatormsg = strzone("");
 236
 237         // enforce the server's universal frag/time limits
 238         if(!autocvar_g_campaign)
 239         {
 240                 if(fraglimit_override >= 0)
 241                         cvar_set("fraglimit", ftos(fraglimit_override));
 242                 if(timelimit_override >= 0)
 243                         cvar_set("timelimit", ftos(timelimit_override));
 244                 if(leadlimit_override >= 0)
 245                         cvar_set("leadlimit", ftos(leadlimit_override));
 246                 if(qualifying_override >= 0)
 247                         cvar_set("g_race_qualifying_timelimit", ftos(qualifying_override));
 248         }
 249
 250         if(g_race)
 251         {
 252                 // we need to find out the correct value for g_race_qualifying
 253                 if(autocvar_g_campaign)
 254                 {
 255                         g_race_qualifying = 1;
 256                 }
 257                 else if(!autocvar_g_campaign && autocvar_g_race_qualifying_timelimit > 0)
 258                 {
 259                         g_race_qualifying = 2;
 260                         race_fraglimit = autocvar_fraglimit;
 261                         race_leadlimit = autocvar_leadlimit;
 262                         race_timelimit = autocvar_timelimit;
 263                         cvar_set("fraglimit", "0");
 264                         cvar_set("leadlimit", "0");
 265                         cvar_set("timelimit", ftos(autocvar_g_race_qualifying_timelimit));
 266                 }
 267                 else
 268                         g_race_qualifying = 0;
 269         }
 270
 271         if(g_race || g_cts)
 272         {
 273                 if(g_race_qualifying)
 274                         independent_players = 1;
 275
 276                 ScoreRules_race();
 277         }
 278
 279         InitializeEntity(world, default_delayedinit, INITPRIO_GAMETYPE_FALLBACK);
 280 }
 281
 282 string GetClientVersionMessage() {
 283         string versionmsg;
 284         if (self.version_mismatch) {
 285                 if(self.version < autocvar_gameversion) {
 286                         versionmsg = "^3Your client version is outdated.\n\n\n### YOU WON'T BE ABLE TO PLAY ON THIS SERVER ###\n\n\nPlease update!!!^8";
 287                 } else {
 288                         versionmsg = "^3This server is using an outdated Xonotic version.\n\n\n ### THIS SERVER IS INCOMPATIBLE AND THUS YOU CANNOT JOIN ###.^8";
 289                 }
 290         } else {
 291                 versionmsg = "^2client version and server version are compatible.^8";
 292         }
 293         return versionmsg;
 294 }
 295
 296 string getwelcomemessage(void)
 297 {
 298         string s, modifications, motd;
 299
 300         ret_string = "";
 301         MUTATOR_CALLHOOK(BuildMutatorsPrettyString);
 302         modifications = ret_string;
 303
 304         if(g_minstagib)
 305                 modifications = strcat(modifications, ", MinstaGib");
 306         if(g_weaponarena)
 307         {
 308                 if(g_weaponarena_random)
 309                         modifications = strcat(modifications, ", ", ftos(g_weaponarena_random), " of ", g_weaponarena_list, " Arena");
 310                 else
 311                         modifications = strcat(modifications, ", ", g_weaponarena_list, " Arena");
 312         }
 313         if(autocvar_g_start_weapon_laser == 0)
 314                 modifications = strcat(modifications, ", No start weapons");
 315         if(autocvar_sv_gravity < 800)
 316                 modifications = strcat(modifications, ", Low gravity");
 317         if(g_cloaked && !g_cts)
 318                 modifications = strcat(modifications, ", Cloaked");
 319         if(g_grappling_hook)
 320                 modifications = strcat(modifications, ", Hook");
 321         if(g_midair)
 322                 modifications = strcat(modifications, ", Midair");
 323         if(g_pinata)
 324                 modifications = strcat(modifications, ", Piñata");
 325         if(g_weapon_stay && !g_cts)
 326                 modifications = strcat(modifications, ", Weapons stay");
 327         if(g_bloodloss > 0)
 328                 modifications = strcat(modifications, ", Blood loss");
 329         if(g_jetpack)
 330                 modifications = strcat(modifications, ", Jet pack");
 331         if(autocvar_g_powerups == 0)
 332                 modifications = strcat(modifications, ", No powerups");
 333         if(autocvar_g_powerups > 0)
 334                 modifications = strcat(modifications, ", Powerups");
 335         modifications = substring(modifications, 2, strlen(modifications) - 2);
 336
 337         string versionmessage;
 338         versionmessage = GetClientVersionMessage();
 339
 340         s = strcat("This is Xonotic ", autocvar_g_xonoticversion, "\n", versionmessage);
 341         s = strcat(s, "^8\n\nmatch type is ^1", gamemode_name, "^8\n");
 342
 343         if(modifications != "")
 344                 s = strcat(s, "^8\nactive modifications: ^3", modifications, "^8\n");
 345
 346         if (g_grappling_hook)
 347                 s = strcat(s, "\n\n^3grappling hook^8 is enabled, press 'e' to use it\n");
 348
 349         if(cache_lastmutatormsg != autocvar_g_mutatormsg)
 350         {
 351                 if(cache_lastmutatormsg)
 352                         strunzone(cache_lastmutatormsg);
 353                 if(cache_mutatormsg)
 354                         strunzone(cache_mutatormsg);
 355                 cache_lastmutatormsg = strzone(autocvar_g_mutatormsg);
 356                 cache_mutatormsg = strzone(cache_lastmutatormsg);
 357         }
 358
 359         if (cache_mutatormsg != "") {
 360                 s = strcat(s, "\n\n^8special gameplay tips: ^7", cache_mutatormsg);
 361         }
 362
 363         motd = autocvar_sv_motd;
 364         if (motd != "") {
 365                 s = strcat(s, "\n\n^8MOTD: ^7", strreplace("\\n", "\n", motd));
 366         }
 367         return s;
 368 }
 369
 370 void SetPlayerColors(entity pl, float _color)
 371 {
 372         /*string s;
 373         s = ftos(cl);
 374         stuffcmd(pl, strcat("color ", s, " ", s, "\n")  );
 375         pl.team = cl + 1;
 376         //pl.clientcolors = pl.clientcolors - (pl.clientcolors & 15) + cl;
 377         pl.clientcolors = 16*cl + cl;*/
 378
 379         float pants, shirt;
 380         pants = _color & 0x0F;
 381         shirt = _color & 0xF0;
 382
 383
 384         if(teamplay) {
 385                 setcolor(pl, 16*pants + pants);
 386         } else {
 387                 setcolor(pl, shirt + pants);
 388         }
 389 }
 390
 391 void SetPlayerTeam(entity pl, float t, float s, float noprint)
 392 {
 393         float _color;
 394
 395         if(t == 4)
 396                 _color = NUM_TEAM_4 - 1;
 397         else if(t == 3)
 398                 _color = NUM_TEAM_3 - 1;
 399         else if(t == 2)
 400                 _color = NUM_TEAM_2 - 1;
 401         else
 402                 _color = NUM_TEAM_1 - 1;
 403
 404         SetPlayerColors(pl,_color);
 405
 406         if(t != s) {
 407                 LogTeamchange(pl.playerid, pl.team, 3);  // log manual team join
 408
 409                 if(!noprint)
 410                 bprint(pl.netname, "^7 has changed from ", Team_NumberToColoredFullName(s), "^7 to ", Team_NumberToColoredFullName(t), "\n");
 411         }
 412
 413 }
 414
 415 // set c1...c4 to show what teams are allowed
 416 void CheckAllowedTeams (entity for_whom)
 417 {
 418         float dm;
 419         entity head;
 420         string teament_name;
 421
 422         c1 = c2 = c3 = c4 = -1;
 423         cb1 = cb2 = cb3 = cb4 = 0;
 424
 425         teament_name = string_null;
 426         if(g_onslaught)
 427         {
 428                 // onslaught is special
 429                 head = findchain(classname, "onslaught_generator");
 430                 while (head)
 431                 {
 432                         if (head.team == NUM_TEAM_1) c1 = 0;
 433                         if (head.team == NUM_TEAM_2) c2 = 0;
 434                         if (head.team == NUM_TEAM_3) c3 = 0;
 435                         if (head.team == NUM_TEAM_4) c4 = 0;
 436                         head = head.chain;
 437                 }
 438         }
 439         else if(g_domination)
 440                 teament_name = "dom_team";
 441         else if(g_ctf)
 442                 teament_name = "ctf_team";
 443         else if(g_tdm)
 444                 teament_name = "tdm_team";
 445         else if(g_nexball)
 446                 teament_name = "nexball_team";
 447         else if(g_assault)
 448                 c1 = c2 = 0; // Assault always has 2 teams
 449         else
 450         {
 451                 // cover anything else by treating it like tdm with no teams spawned
 452                 if(g_race)
 453                         dm = race_teams;
 454                 else
 455                         dm = 2;
 456
 457                 ret_float = dm;
 458                 MUTATOR_CALLHOOK(GetTeamCount);
 459                 dm = ret_float;
 460
 461                 if(dm >= 4)
 462                         c1 = c2 = c3 = c4 = 0;
 463                 else if(dm >= 3)
 464                         c1 = c2 = c3 = 0;
 465                 else
 466                         c1 = c2 = 0;
 467         }
 468
 469         // find out what teams are allowed if necessary
 470         if(teament_name)
 471         {
 472                 head = find(world, classname, teament_name);
 473                 while(head)
 474                 {
 475                         if(!(g_domination && head.netname == ""))
 476                         {
 477                                 if(head.team == NUM_TEAM_1)
 478                                         c1 = 0;
 479                                 else if(head.team == NUM_TEAM_2)
 480                                         c2 = 0;
 481                                 else if(head.team == NUM_TEAM_3)
 482                                         c3 = 0;
 483                                 else if(head.team == NUM_TEAM_4)
 484                                         c4 = 0;
 485                         }
 486                         head = find(head, classname, teament_name);
 487                 }
 488         }
 489
 490         // TODO: Balance quantity of bots across > 2 teams when bot_vs_human is set (and remove next line)
 491         if(c3==-1 && c4==-1)
 492         if(autocvar_bot_vs_human && for_whom)
 493         {
 494                 if(autocvar_bot_vs_human > 0)
 495                 {
 496                         // bots are all blue
 497                         if(clienttype(for_whom) == CLIENTTYPE_BOT)
 498                                 c1 = c3 = c4 = -1;
 499                         else
 500                                 c2 = -1;
 501                 }
 502                 else
 503                 {
 504                         // bots are all red
 505                         if(clienttype(for_whom) == CLIENTTYPE_BOT)
 506                                 c2 = c3 = c4 = -1;
 507                         else
 508                                 c1 = -1;
 509                 }
 510         }
 511
 512         // if player has a forced team, ONLY allow that one
 513         if(self.team_forced == NUM_TEAM_1 && c1 >= 0)
 514                 c2 = c3 = c4 = -1;
 515         else if(self.team_forced == NUM_TEAM_2 && c2 >= 0)
 516                 c1 = c3 = c4 = -1;
 517         else if(self.team_forced == NUM_TEAM_3 && c3 >= 0)
 518                 c1 = c2 = c4 = -1;
 519         else if(self.team_forced == NUM_TEAM_4 && c4 >= 0)
 520                 c1 = c2 = c3 = -1;
 521 }
 522
 523 float PlayerValue(entity p)
 524 {
 525         return 1;
 526         // FIXME: it always returns 1...
 527 }
 528
 529 // c1...c4 should be set to -1 (not allowed) or 0 (allowed).
 530 // teams that are allowed will now have their player counts stored in c1...c4
 531 void GetTeamCounts(entity ignore)
 532 {
 533         entity head;
 534         float value, bvalue;
 535         // now count how many players are on each team already
 536
 537         // FIXME: also find and memorize the lowest-scoring bot on each team (in case players must be shuffled around)
 538         // also remember the lowest-scoring player
 539
 540         FOR_EACH_CLIENT(head)
 541         {
 542                 float t;
 543                 if(head.classname == "player")
 544                         t = head.team;
 545                 else if(head.team_forced > 0)
 546                         t = head.team_forced; // reserve the spot
 547                 else
 548                         continue;
 549                 if(head != ignore)// && head.netname != "")
 550                 {
 551                         value = PlayerValue(head);
 552                         if(clienttype(head) == CLIENTTYPE_BOT)
 553                                 bvalue = value;
 554                         else
 555                                 bvalue = 0;
 556                         if(t == NUM_TEAM_1)
 557                         {
 558                                 if(c1 >= 0)
 559                                 {
 560                                         c1 = c1 + value;
 561                                         cb1 = cb1 + bvalue;
 562                                 }
 563                         }
 564                         if(t == NUM_TEAM_2)
 565                         {
 566                                 if(c2 >= 0)
 567                                 {
 568                                         c2 = c2 + value;
 569                                         cb2 = cb2 + bvalue;
 570                                 }
 571                         }
 572                         if(t == NUM_TEAM_3)
 573                         {
 574                                 if(c3 >= 0)
 575                                 {
 576                                         c3 = c3 + value;
 577                                         cb3 = cb3 + bvalue;
 578                                 }
 579                         }
 580                         if(t == NUM_TEAM_4)
 581                         {
 582                                 if(c4 >= 0)
 583                                 {
 584                                         c4 = c4 + value;
 585                                         cb4 = cb4 + bvalue;
 586                                 }
 587                         }
 588                 }
 589         }
 590
 591         // if the player who has a forced team has not joined yet, reserve the spot
 592         if(autocvar_g_campaign)
 593         {
 594                 switch(autocvar_g_campaign_forceteam)
 595                 {
 596                         case 1: if(c1 == cb1) ++c1; break;
 597                         case 2: if(c2 == cb2) ++c2; break;
 598                         case 3: if(c3 == cb3) ++c3; break;
 599                         case 4: if(c4 == cb4) ++c4; break;
 600                 }
 601         }
 602 }
 603
 604 float TeamSmallerEqThanTeam(float ta, float tb, entity e)
 605 {
 606         // we assume that CheckAllowedTeams and GetTeamCounts have already been called
 607         float f;
 608         float ca = -1, cb = -1, cba = 0, cbb = 0, sa = 0, sb = 0;
 609
 610         switch(ta)
 611         {
 612                 case 1: ca = c1; cba = cb1; sa = team1_score; break;
 613                 case 2: ca = c2; cba = cb2; sa = team2_score; break;
 614                 case 3: ca = c3; cba = cb3; sa = team3_score; break;
 615                 case 4: ca = c4; cba = cb4; sa = team4_score; break;
 616         }
 617         switch(tb)
 618         {
 619                 case 1: cb = c1; cbb = cb1; sb = team1_score; break;
 620                 case 2: cb = c2; cbb = cb2; sb = team2_score; break;
 621                 case 3: cb = c3; cbb = cb3; sb = team3_score; break;
 622                 case 4: cb = c4; cbb = cb4; sb = team4_score; break;
 623         }
 624
 625         // invalid
 626         if(ca < 0 || cb < 0)
 627                 return FALSE;
 628
 629         // equal
 630         if(ta == tb)
 631                 return TRUE;
 632
 633         if(clienttype(e) == CLIENTTYPE_REAL)
 634         {
 635                 if(bots_would_leave)
 636                 {
 637                         ca -= cba * 0.999;
 638                         cb -= cbb * 0.999;
 639                 }
 640         }
 641
 642         // keep teams alive (teams of size 0 always count as smaller, ignoring score)
 643         if(ca < 1)
 644                 if(cb >= 1)
 645                         return TRUE;
 646         if(ca >= 1)
 647                 if(cb < 1)
 648                         return FALSE;
 649
 650         // first, normalize
 651         f = max(ca, cb, 1);
 652         ca /= f;
 653         cb /= f;
 654         f = max(sa, sb, 1);
 655         sa /= f;
 656         sb /= f;
 657
 658         // the more we're at the end of the match, the more take scores into account
 659         f = bound(0, game_completion_ratio * autocvar_g_balance_teams_scorefactor, 1);
 660         ca += (sa - ca) * f;
 661         cb += (sb - cb) * f;
 662
 663         return ca <= cb;
 664 }
 665
 666 // returns # of smallest team (1, 2, 3, 4)
 667 // NOTE: Assumes CheckAllowedTeams has already been called!
 668 float FindSmallestTeam(entity pl, float ignore_pl)
 669 {
 670         float totalteams, t;
 671         totalteams = 0;
 672
 673         // find out what teams are available
 674         //CheckAllowedTeams();
 675
 676         // make sure there are at least 2 teams to join
 677         if(c1 >= 0)
 678                 totalteams = totalteams + 1;
 679         if(c2 >= 0)
 680                 totalteams = totalteams + 1;
 681         if(c3 >= 0)
 682                 totalteams = totalteams + 1;
 683         if(c4 >= 0)
 684                 totalteams = totalteams + 1;
 685
 686         if((autocvar_bot_vs_human || pl.team_forced > 0) && totalteams == 1)
 687                 totalteams += 1;
 688
 689         if(totalteams <= 1)
 690         {
 691                 if(autocvar_g_campaign && pl && clienttype(pl) == CLIENTTYPE_REAL)
 692                         return 1; // special case for campaign and player joining
 693                 else if(g_domination)
 694                         error("Too few teams available for domination\n");
 695                 else if(g_ctf)
 696                         error("Too few teams available for ctf\n");
 697                 else if(g_keyhunt)
 698                         error("Too few teams available for key hunt\n");
 699                 else if(g_freezetag)
 700                         error("Too few teams available for freeze tag\n");
 701                 else
 702                         error("Too few teams available for team deathmatch\n");
 703         }
 704
 705         // count how many players are in each team
 706         if(ignore_pl)
 707                 GetTeamCounts(pl);
 708         else
 709                 GetTeamCounts(world);
 710
 711         RandomSelection_Init();
 712
 713         t = 1;
 714         if(TeamSmallerEqThanTeam(2, t, pl))
 715                 t = 2;
 716         if(TeamSmallerEqThanTeam(3, t, pl))
 717                 t = 3;
 718         if(TeamSmallerEqThanTeam(4, t, pl))
 719                 t = 4;
 720
 721         // now t is the minimum, or A minimum!
 722         if(t == 1 || TeamSmallerEqThanTeam(1, t, pl))
 723                 RandomSelection_Add(world, 1, string_null, 1, 1);
 724         if(t == 2 || TeamSmallerEqThanTeam(2, t, pl))
 725                 RandomSelection_Add(world, 2, string_null, 1, 1);
 726         if(t == 3 || TeamSmallerEqThanTeam(3, t, pl))
 727                 RandomSelection_Add(world, 3, string_null, 1, 1);
 728         if(t == 4 || TeamSmallerEqThanTeam(4, t, pl))
 729                 RandomSelection_Add(world, 4, string_null, 1, 1);
 730
 731         return RandomSelection_chosen_float;
 732 }
 733
 734 float JoinBestTeam(entity pl, float only_return_best, float forcebestteam)
 735 {
 736         float smallest, selectedteam;
 737
 738         // don't join a team if we're not playing a team game
 739         if(!teamplay)
 740                 return 0;
 741
 742         // find out what teams are available
 743         CheckAllowedTeams(pl);
 744
 745         // if we don't care what team he ends up on, put him on whatever team he entered as.
 746         // if he's not on a valid team, then let other code put him on the smallest team
 747         if(!forcebestteam)
 748         {
 749                 if(     c1 >= 0 && pl.team == NUM_TEAM_1)
 750                         selectedteam = pl.team;
 751                 else if(c2 >= 0 && pl.team == NUM_TEAM_2)
 752                         selectedteam = pl.team;
 753                 else if(c3 >= 0 && pl.team == NUM_TEAM_3)
 754                         selectedteam = pl.team;
 755                 else if(c4 >= 0 && pl.team == NUM_TEAM_4)
 756                         selectedteam = pl.team;
 757                 else
 758                         selectedteam = -1;
 759
 760                 if(selectedteam > 0)
 761                 {
 762                         if(!only_return_best)
 763                         {
 764                                 SetPlayerColors(pl, selectedteam - 1);
 765
 766                                 // when JoinBestTeam is called by client.qc/ClientKill_Now_TeamChange the players team is -1 and thus skipped
 767                                 // when JoinBestTeam is called by cl_client.qc/ClientConnect the player_id is 0 the log attempt is rejected
 768                                 LogTeamchange(pl.playerid, pl.team, 99);
 769                         }
 770                         return selectedteam;
 771                 }
 772                 // otherwise end up on the smallest team (handled below)
 773         }
 774
 775         smallest = FindSmallestTeam(pl, TRUE);
 776
 777         if(!only_return_best && !pl.bot_forced_team)
 778         {
 779                 TeamchangeFrags(self);
 780                 if(smallest == 1)
 781                 {
 782                         SetPlayerColors(pl, NUM_TEAM_1 - 1);
 783                 }
 784                 else if(smallest == 2)
 785                 {
 786                         SetPlayerColors(pl, NUM_TEAM_2 - 1);
 787                 }
 788                 else if(smallest == 3)
 789                 {
 790                         SetPlayerColors(pl, NUM_TEAM_3 - 1);
 791                 }
 792                 else if(smallest == 4)
 793                 {
 794                         SetPlayerColors(pl, NUM_TEAM_4 - 1);
 795                 }
 796                 else
 797                 {
 798                         error("smallest team: invalid team\n");
 799                 }
 800
 801                 LogTeamchange(pl.playerid, pl.team, 2); // log auto join
 802
 803                 if(pl.deadflag == DEAD_NO)
 804                         Damage(pl, pl, pl, 100000, DEATH_TEAMCHANGE, pl.origin, '0 0 0');
 805         }
 806
 807         return smallest;
 808 }
 809
 810 //void() ctf_playerchanged;
 811 void SV_ChangeTeam(float _color)
 812 {
 813         float scolor, dcolor, steam, dteam; //, dbotcount, scount, dcount;
 814
 815         // in normal deathmatch we can just apply the color and we're done
 816         if(!teamplay) {
 817                 SetPlayerColors(self, _color);
 818                 return;
 819         }
 820
 821         scolor = self.clientcolors & 0x0F;
 822         dcolor = _color & 0x0F;
 823
 824         if(scolor == NUM_TEAM_1 - 1)
 825                 steam = 1;
 826         else if(scolor == NUM_TEAM_2 - 1)
 827                 steam = 2;
 828         else if(scolor == NUM_TEAM_3 - 1)
 829                 steam = 3;
 830         else // if(scolor == NUM_TEAM_4 - 1)
 831                 steam = 4;
 832         if(dcolor == NUM_TEAM_1 - 1)
 833                 dteam = 1;
 834         else if(dcolor == NUM_TEAM_2 - 1)
 835                 dteam = 2;
 836         else if(dcolor == NUM_TEAM_3 - 1)
 837                 dteam = 3;
 838         else // if(dcolor == NUM_TEAM_4 - 1)
 839                 dteam = 4;
 840
 841         CheckAllowedTeams(self);
 842
 843         if(dteam == 1 && c1 < 0) dteam = 4;
 844         if(dteam == 4 && c4 < 0) dteam = 3;
 845         if(dteam == 3 && c3 < 0) dteam = 2;
 846         if(dteam == 2 && c2 < 0) dteam = 1;
 847
 848         // not changing teams
 849         if(scolor == dcolor)
 850         {
 851                 //bprint("same team change\n");
 852                 SetPlayerTeam(self, dteam, steam, TRUE);
 853                 return;
 854         }
 855
 856         if((autocvar_g_campaign) || (autocvar_g_changeteam_banned && self.wasplayer)) {
 857                 sprint(self, "Team changes not allowed\n");
 858                 return; // changing teams is not allowed
 859         }
 860
 861         // autocvar_g_balance_teams_prevent_imbalance only makes sense if autocvar_g_balance_teams is on, as it makes the team selection dialog pointless
 862         if(autocvar_g_balance_teams && autocvar_g_balance_teams_prevent_imbalance)
 863         {
 864                 GetTeamCounts(self);
 865                 if(!TeamSmallerEqThanTeam(dteam, steam, self))
 866                 {
 867                         sprint(self, "Cannot change to a larger/better/shinier team\n");
 868                         return;
 869                 }
 870         }
 871
 872 //      bprint("allow change teams from ", ftos(steam), " to ", ftos(dteam), "\n");
 873
 874         if(self.classname == "player" && steam != dteam)
 875         {
 876                 // reduce frags during a team change
 877                 TeamchangeFrags(self);
 878         }
 879
 880         SetPlayerTeam(self, dteam, steam, FALSE);
 881
 882         if(self.classname == "player" && steam != dteam)
 883         {
 884                 // kill player when changing teams
 885                 if(self.deadflag == DEAD_NO)
 886                         Damage(self, self, self, 100000, DEATH_TEAMCHANGE, self.origin, '0 0 0');
 887         }
 888 }
 889
 890 void ShufflePlayerOutOfTeam (float source_team)
 891 {
 892         float smallestteam, smallestteam_count, steam;
 893         float lowest_bot_score, lowest_player_score;
 894         entity head, lowest_bot, lowest_player, selected;
 895
 896         smallestteam = 0;
 897         smallestteam_count = 999999999;
 898
 899         if(c1 >= 0 && c1 < smallestteam_count)
 900         {
 901                 smallestteam = 1;
 902                 smallestteam_count = c1;
 903         }
 904         if(c2 >= 0 && c2 < smallestteam_count)
 905         {
 906                 smallestteam = 2;
 907                 smallestteam_count = c2;
 908         }
 909         if(c3 >= 0 && c3 < smallestteam_count)
 910         {
 911                 smallestteam = 3;
 912                 smallestteam_count = c3;
 913         }
 914         if(c4 >= 0 && c4 < smallestteam_count)
 915         {
 916                 smallestteam = 4;
 917                 smallestteam_count = c4;
 918         }
 919
 920         if(!smallestteam)
 921         {
 922                 bprint("warning: no smallest team\n");
 923                 return;
 924         }
 925
 926         if(source_team == 1)
 927                 steam = NUM_TEAM_1;
 928         else if(source_team == 2)
 929                 steam = NUM_TEAM_2;
 930         else if(source_team == 3)
 931                 steam = NUM_TEAM_3;
 932         else // if(source_team == 4)
 933                 steam = NUM_TEAM_4;
 934
 935         lowest_bot = world;
 936         lowest_bot_score = 999999999;
 937         lowest_player = world;
 938         lowest_player_score = 999999999;
 939
 940         // find the lowest-scoring player & bot of that team
 941         FOR_EACH_PLAYER(head)
 942         {
 943                 if(head.team == steam)
 944                 {
 945                         if(head.isbot)
 946                         {
 947                                 if(head.totalfrags < lowest_bot_score)
 948                                 {
 949                                         lowest_bot = head;
 950                                         lowest_bot_score = head.totalfrags;
 951                                 }
 952                         }
 953                         else
 954                         {
 955                                 if(head.totalfrags < lowest_player_score)
 956                                 {
 957                                         lowest_player = head;
 958                                         lowest_player_score = head.totalfrags;
 959                                 }
 960                         }
 961                 }
 962         }
 963
 964         // prefers to move a bot...
 965         if(lowest_bot != world)
 966                 selected = lowest_bot;
 967         // but it will move a player if it has to
 968         else
 969                 selected = lowest_player;
 970         // don't do anything if it couldn't find anyone
 971         if(!selected)
 972         {
 973                 bprint("warning: couldn't find a player to move from team\n");
 974                 return;
 975         }
 976
 977         // smallest team gains a member
 978         if(smallestteam == 1)
 979         {
 980                 c1 = c1 + 1;
 981         }
 982         else if(smallestteam == 2)
 983         {
 984                 c2 = c2 + 1;
 985         }
 986         else if(smallestteam == 3)
 987         {
 988                 c3 = c3 + 1;
 989         }
 990         else if(smallestteam == 4)
 991         {
 992                 c4 = c4 + 1;
 993         }
 994         else
 995         {
 996                 bprint("warning: destination team invalid\n");
 997                 return;
 998         }
 999         // source team loses a member
1000         if(source_team == 1)
1001         {
1002                 c1 = c1 + 1;
1003         }
1004         else if(source_team == 2)
1005         {
1006                 c2 = c2 + 2;
1007         }
1008         else if(source_team == 3)
1009         {
1010                 c3 = c3 + 3;
1011         }
1012         else if(source_team == 4)
1013         {
1014                 c4 = c4 + 4;
1015         }
1016         else
1017         {
1018                 bprint("warning: source team invalid\n");
1019                 return;
1020         }
1021
1022         // move the player to the new team
1023         TeamchangeFrags(selected);
1024         SetPlayerTeam(selected, smallestteam, source_team, FALSE);
1025
1026         if(selected.deadflag == DEAD_NO)
1027                 Damage(selected, selected, selected, 100000, DEATH_AUTOTEAMCHANGE, selected.origin, '0 0 0');
1028         centerprint(selected, strcat("You have been moved into a different team to improve team balance\nYou are now on: ", Team_ColoredFullName(selected.team)));
1029 }
1030
1031 // code from here on is just to support maps that don't have team entities
1032 void tdm_spawnteam (string teamname, float teamcolor)
1033 {
1034         entity e;
1035         e = spawn();
1036         e.classname = "tdm_team";
1037         e.netname = teamname;
1038         e.cnt = teamcolor;
1039         e.team = e.cnt + 1;
1040 }
1041
1042 // spawn some default teams if the map is not set up for tdm
1043 void tdm_spawnteams()
1044 {
1045         float numteams;
1046
1047         numteams = autocvar_g_tdm_teams_override;
1048         if(numteams < 2)
1049                 numteams = autocvar_g_tdm_teams;
1050         numteams = bound(2, numteams, 4);
1051
1052         tdm_spawnteam("Red", NUM_TEAM_1-1);
1053         tdm_spawnteam("Blue", NUM_TEAM_2-1);
1054         if(numteams >= 3)
1055                 tdm_spawnteam("Yellow", NUM_TEAM_3-1);
1056         if(numteams >= 4)
1057                 tdm_spawnteam("Pink", NUM_TEAM_4-1);
1058 }
1059
1060 void tdm_delayedinit()
1061 {
1062         // if no teams are found, spawn defaults
1063         if (find(world, classname, "tdm_team") == world)
1064                 tdm_spawnteams();
1065 }
1066
1067 void tdm_init()
1068 {
1069         InitializeEntity(world, tdm_delayedinit, INITPRIO_GAMETYPE);
1070 }