Split the gamelog code out of miscfunctions and into its own file
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / teamplay.qc
1 #include "teamplay.qh"
2
3 #include "client.qh"
4 #include <server/gamelog.qh>
5 #include "race.qh"
6 #include "scores.qh"
7 #include "scores_rules.qh"
8
9 #include "bot/api.qh"
10
11 #include "command/vote.qh"
12
13 #include <server/mutators/_mod.qh>
14
15 #include "../common/deathtypes/all.qh"
16 #include <common/gamemodes/_mod.qh>
17 #include "../common/teams.qh"
18
19 /// \brief Describes a state of team balance entity.
20 enum
21 {
22         TEAM_BALANCE_UNINITIALIZED, ///< The team balance has not been initialized.
23         /// \brief TeamBalance_CheckAllowedTeams has been called.
24         TEAM_BALANCE_TEAMS_CHECKED,
25         /// \brief TeamBalance_GetTeamCounts has been called.
26         TEAM_BALANCE_TEAM_COUNTS_FILLED
27 };
28
29 /// \brief Indicates that the player is not allowed to join a team.
30 const int TEAM_NOT_ALLOWED = -1;
31
32 .float team_forced; // can be a team number to force a team, or 0 for default action, or -1 for forced spectator
33
34 .int m_team_balance_state; ///< Holds the state of the team balance entity.
35 .entity m_team_balance_team[NUM_TEAMS]; ///< ???
36
37 .float m_team_score; ///< The score of the team.
38 .int m_num_players; ///< Number of players (both humans and bots) in a team.
39 .int m_num_bots; ///< Number of bots in a team.
40 .int m_num_players_alive; ///< Number of alive players in a team.
41 .int m_num_control_points; ///< Number of control points owned by a team.
42
43 string autocvar_g_forced_team_red;
44 string autocvar_g_forced_team_blue;
45 string autocvar_g_forced_team_yellow;
46 string autocvar_g_forced_team_pink;
47
48 entity g_team_entities[NUM_TEAMS]; ///< Holds global team entities.
49
50 STATIC_INIT(g_team_entities)
51 {
52         for (int i = 0; i < NUM_TEAMS; ++i)
53         {
54                 g_team_entities[i] = spawn();
55         }
56 }
57
58 entity Team_GetTeamFromIndex(int index)
59 {
60         if (!Team_IsValidIndex(index))
61         {
62                 LOG_FATALF("Team_GetTeamFromIndex: Index is invalid: %f", index);
63         }
64         return g_team_entities[index - 1];
65 }
66
67 entity Team_GetTeam(int team_num)
68 {
69         if (!Team_IsValidTeam(team_num))
70         {
71                 LOG_FATALF("Team_GetTeam: Value is invalid: %f", team_num);
72         }
73         return g_team_entities[Team_TeamToIndex(team_num) - 1];
74 }
75
76 float Team_GetTeamScore(entity team_ent)
77 {
78         return team_ent.m_team_score;
79 }
80
81 void Team_SetTeamScore(entity team_ent, float score)
82 {
83         team_ent.m_team_score = score;
84 }
85
86 int Team_GetNumberOfAlivePlayers(entity team_ent)
87 {
88         return team_ent.m_num_players_alive;
89 }
90
91 void Team_SetNumberOfAlivePlayers(entity team_ent, int number)
92 {
93         team_ent.m_num_players_alive = number;
94 }
95
96 int Team_GetNumberOfAliveTeams()
97 {
98         int result = 0;
99         for (int i = 0; i < NUM_TEAMS; ++i)
100         {
101                 if (g_team_entities[i].m_num_players_alive > 0)
102                 {
103                         ++result;
104                 }
105         }
106         return result;
107 }
108
109 int Team_GetNumberOfControlPoints(entity team_ent)
110 {
111         return team_ent.m_num_control_points;
112 }
113
114 void Team_SetNumberOfControlPoints(entity team_ent, int number)
115 {
116         team_ent.m_num_control_points = number;
117 }
118
119 int Team_GetNumberOfTeamsWithControlPoints()
120 {
121         int result = 0;
122         for (int i = 0; i < NUM_TEAMS; ++i)
123         {
124                 if (g_team_entities[i].m_num_control_points > 0)
125                 {
126                         ++result;
127                 }
128         }
129         return result;
130 }
131
132 void setcolor(entity this, int clr)
133 {
134 #if 0
135         this.clientcolors = clr;
136         this.team = (clr & 15) + 1;
137 #else
138         builtin_setcolor(this, clr);
139 #endif
140 }
141
142 bool Entity_HasValidTeam(entity this)
143 {
144         return Team_IsValidTeam(this.team);
145 }
146
147 int Entity_GetTeamIndex(entity this)
148 {
149         return Team_TeamToIndex(this.team);
150 }
151
152 entity Entity_GetTeam(entity this)
153 {
154         int index = Entity_GetTeamIndex(this);
155         if (!Team_IsValidIndex(index))
156         {
157                 return NULL;
158         }
159         return Team_GetTeamFromIndex(index);
160 }
161
162 void SetPlayerColors(entity player, float _color)
163 {
164         float pants = _color & 0x0F;
165         float shirt = _color & 0xF0;
166         if (teamplay)
167         {
168                 setcolor(player, 16 * pants + pants);
169         }
170         else
171         {
172                 setcolor(player, shirt + pants);
173         }
174 }
175
176 bool Player_SetTeamIndex(entity player, int index)
177 {
178         int new_team = Team_IndexToTeam(index);
179         if (player.team == new_team)
180         {
181                 if (new_team != -1)
182                 {
183                         // This is important when players join the game and one of their
184                         // color matches the team color while other doesn't. For example
185                         // [BOT]Lion: color 0 4.
186                         SetPlayerColors(player, new_team - 1);
187                 }
188                 return true;
189         }
190         int old_index = Team_TeamToIndex(player.team);
191         if (MUTATOR_CALLHOOK(Player_ChangeTeam, player, old_index, index) == true)
192         {
193                 // Mutator has blocked team change.
194                 return false;
195         }
196         if (new_team == -1)
197         {
198                 player.team = -1;
199         }
200         else
201         {
202                 SetPlayerColors(player, new_team - 1);
203         }
204         MUTATOR_CALLHOOK(Player_ChangedTeam, player, old_index, index);
205         return true;
206 }
207
208 bool SetPlayerTeam(entity player, int team_index, int type)
209 {
210         int old_team_index = Entity_GetTeamIndex(player);
211         if (!Player_SetTeamIndex(player, team_index))
212         {
213                 return false;
214         }
215         LogTeamChange(player.playerid, player.team, type);
216         if (team_index != old_team_index)
217         {
218                 PlayerScore_Clear(player);
219                 if (team_index != -1)
220                 {
221                         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(
222                                 player.team, INFO_JOIN_PLAY_TEAM), player.netname);
223                 }
224                 else
225                 {
226                         if (!CS(player).just_joined)
227                         {
228                                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_QUIT_SPECTATE,
229                                         player.netname);
230                         }
231                 }
232                 KillPlayerForTeamChange(player);
233                 if (!IS_BOT_CLIENT(player))
234                 {
235                         TeamBalance_AutoBalanceBots();
236                 }
237         }
238         else if (team_index == -1)
239         {
240                 if (!CS(player).just_joined && player.frags != FRAGS_SPECTATOR)
241                         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_QUIT_SPECTATE, player.netname);
242         }
243         return true;
244 }
245
246 void Player_SetTeamIndexChecked(entity player, int team_index)
247 {
248         if (!teamplay)
249         {
250                 return;
251         }
252         if (!Team_IsValidIndex(team_index))
253         {
254                 return;
255         }
256         if ((autocvar_g_campaign) || (autocvar_g_changeteam_banned &&
257                 CS(player).wasplayer))
258         {
259                 Send_Notification(NOTIF_ONE, player, MSG_INFO,
260                         INFO_TEAMCHANGE_NOTALLOWED);
261                 return;
262         }
263         entity balance = TeamBalance_CheckAllowedTeams(player);
264         if (team_index == 1 && !TeamBalance_IsTeamAllowedInternal(balance, 1))
265         {
266                 team_index = 4;
267         }
268         if (team_index == 4 && !TeamBalance_IsTeamAllowedInternal(balance, 4))
269         {
270                 team_index = 3;
271         }
272         if (team_index == 3 && !TeamBalance_IsTeamAllowedInternal(balance, 3))
273         {
274                 team_index = 2;
275         }
276         if (team_index == 2 && !TeamBalance_IsTeamAllowedInternal(balance, 2))
277         {
278                 team_index = 1;
279         }
280         // autocvar_g_balance_teams_prevent_imbalance only makes sense if autocvar_g_balance_teams is on, as it makes the team selection dialog pointless
281         if (autocvar_g_balance_teams && autocvar_g_balance_teams_prevent_imbalance)
282         {
283                 TeamBalance_GetTeamCounts(balance, player);
284                 if ((Team_IndexToBit(team_index) & TeamBalance_FindBestTeams(balance,
285                         player, false)) == 0)
286                 {
287                         Send_Notification(NOTIF_ONE, player, MSG_INFO,
288                                 INFO_TEAMCHANGE_LARGERTEAM);
289                         TeamBalance_Destroy(balance);
290                         return;
291                 }
292         }
293         TeamBalance_Destroy(balance);
294         SetPlayerTeam(player, team_index, TEAM_CHANGE_MANUAL);
295 }
296
297 bool MoveToTeam(entity client, int team_index, int type)
298 {
299         //PrintToChatAll(sprintf("MoveToTeam: %s, %f", client.netname, team_index));
300         int lockteams_backup = lockteams;  // backup any team lock
301         lockteams = 0;  // disable locked teams
302         if (!SetPlayerTeam(client, team_index, type))
303         {
304                 lockteams = lockteams_backup;  // restore the team lock
305                 return false;
306         }
307         lockteams = lockteams_backup;  // restore the team lock
308         return true;
309 }
310
311 bool Player_HasRealForcedTeam(entity player)
312 {
313         return player.team_forced > TEAM_FORCE_DEFAULT;
314 }
315
316 int Player_GetForcedTeamIndex(entity player)
317 {
318         return player.team_forced;
319 }
320
321 void Player_SetForcedTeamIndex(entity player, int team_index)
322 {
323         switch (team_index)
324         {
325                 case TEAM_FORCE_SPECTATOR:
326                 case TEAM_FORCE_DEFAULT:
327                 {
328                         player.team_forced = team_index;
329                         break;
330                 }
331                 default:
332                 {
333                         if (!Team_IsValidIndex(team_index))
334                         {
335                                 LOG_FATAL("Player_SetForcedTeamIndex: Invalid team index.");
336                         }
337                         else
338                         {
339                                 player.team_forced = team_index;
340                                 break;
341                         }
342                 }
343         }
344 }
345
346 void Player_DetermineForcedTeam(entity player)
347 {
348         if (autocvar_g_campaign)
349         {
350                 if (IS_REAL_CLIENT(player)) // only players, not bots
351                 {
352                         if (Team_IsValidIndex(autocvar_g_campaign_forceteam))
353                         {
354                                 player.team_forced = autocvar_g_campaign_forceteam;
355                         }
356                         else
357                         {
358                                 player.team_forced = TEAM_FORCE_DEFAULT;
359                         }
360                 }
361         }
362         else if (PlayerInList(player, autocvar_g_forced_team_red))
363         {
364                 player.team_forced = 1;
365         }
366         else if (PlayerInList(player, autocvar_g_forced_team_blue))
367         {
368                 player.team_forced = 2;
369         }
370         else if (PlayerInList(player, autocvar_g_forced_team_yellow))
371         {
372                 player.team_forced = 3;
373         }
374         else if (PlayerInList(player, autocvar_g_forced_team_pink))
375         {
376                 player.team_forced = 4;
377         }
378         else
379         {
380                 switch (autocvar_g_forced_team_otherwise)
381                 {
382                         case "red":
383                         {
384                                 player.team_forced = 1;
385                                 break;
386                         }
387                         case "blue":
388                         {
389                                 player.team_forced = 2;
390                                 break;
391                         }
392                         case "yellow":
393                         {
394                                 player.team_forced = 3;
395                                 break;
396                         }
397                         case "pink":
398                         {
399                                 player.team_forced = 4;
400                                 break;
401                         }
402                         case "spectate":
403                         case "spectator":
404                         {
405                                 player.team_forced = TEAM_FORCE_SPECTATOR;
406                                 break;
407                         }
408                         default:
409                         {
410                                 player.team_forced = TEAM_FORCE_DEFAULT;
411                                 break;
412                         }
413                 }
414         }
415         if (!teamplay && Player_HasRealForcedTeam(player))
416         {
417                 player.team_forced = TEAM_FORCE_DEFAULT;
418         }
419 }
420
421 void TeamBalance_JoinBestTeam(entity player)
422 {
423         //PrintToChatAll(sprintf("TeamBalance_JoinBestTeam: %s", player.netname));
424         if (!teamplay)
425         {
426                 return;
427         }
428         if (player.bot_forced_team)
429         {
430                 return;
431         }
432         entity balance = TeamBalance_CheckAllowedTeams(player);
433         if (Player_HasRealForcedTeam(player))
434         {
435                 int forced_team_index = player.team_forced;
436                 bool is_team_allowed = TeamBalance_IsTeamAllowedInternal(balance,
437                         forced_team_index);
438                 TeamBalance_Destroy(balance);
439                 if (!is_team_allowed)
440                 {
441                         return;
442                 }
443                 if (!SetPlayerTeam(player, forced_team_index, TEAM_CHANGE_AUTO))
444                 {
445                         return;
446                 }
447                 return;
448         }
449         int best_team_index = TeamBalance_FindBestTeam(balance, player, true);
450         TeamBalance_Destroy(balance);
451         if (!SetPlayerTeam(player, best_team_index, TEAM_CHANGE_AUTO))
452         {
453                 return;
454         }
455 }
456
457 entity TeamBalance_CheckAllowedTeams(entity for_whom)
458 {
459         entity balance = spawn();
460         for (int i = 0; i < NUM_TEAMS; ++i)
461         {
462                 entity team_ent = balance.m_team_balance_team[i] = spawn();
463                 team_ent.m_team_score = g_team_entities[i].m_team_score;
464                 team_ent.m_num_players = TEAM_NOT_ALLOWED;
465                 team_ent.m_num_bots = 0;
466         }
467         setthink(balance, TeamBalance_Destroy);
468
469         int teams_mask = 0;
470         string teament_name = string_null;
471         bool mutator_returnvalue = MUTATOR_CALLHOOK(TeamBalance_CheckAllowedTeams,
472                 teams_mask, teament_name, for_whom);
473         teams_mask = M_ARGV(0, float);
474         teament_name = M_ARGV(1, string);
475         if (mutator_returnvalue)
476         {
477                 for (int i = 0; i < NUM_TEAMS; ++i)
478                 {
479                         if (teams_mask & BIT(i))
480                         {
481                                 balance.m_team_balance_team[i].m_num_players = 0;
482                         }
483                 }
484         }
485
486         if (teament_name)
487         {
488                 entity head = find(NULL, classname, teament_name);
489                 while (head)
490                 {
491                         if (Team_IsValidTeam(head.team))
492                         {
493                                 TeamBalance_GetTeam(balance, head.team).m_num_players = 0;
494                         }
495                         head = find(head, classname, teament_name);
496                 }
497         }
498
499         // TODO: Balance quantity of bots across > 2 teams when bot_vs_human is set (and remove next line)
500         if (autocvar_bot_vs_human && AvailableTeams() == 2 && for_whom)
501         {
502                 if (autocvar_bot_vs_human > 0)
503                 {
504                         // find last team available
505                         if (IS_BOT_CLIENT(for_whom))
506                         {
507                                 if (TeamBalance_IsTeamAllowedInternal(balance, 4))
508                                 {
509                                         TeamBalance_BanTeamsExcept(balance, 4);
510                                 }
511                                 else if (TeamBalance_IsTeamAllowedInternal(balance, 3))
512                                 {
513                                         TeamBalance_BanTeamsExcept(balance, 3);
514                                 }
515                                 else
516                                 {
517                                         TeamBalance_BanTeamsExcept(balance, 2);
518                                 }
519                                 // no further cases, we know at least 2 teams exist
520                         }
521                         else
522                         {
523                                 if (TeamBalance_IsTeamAllowedInternal(balance, 1))
524                                 {
525                                         TeamBalance_BanTeamsExcept(balance, 1);
526                                 }
527                                 else if (TeamBalance_IsTeamAllowedInternal(balance, 2))
528                                 {
529                                         TeamBalance_BanTeamsExcept(balance, 2);
530                                 }
531                                 else
532                                 {
533                                         TeamBalance_BanTeamsExcept(balance, 3);
534                                 }
535                                 // no further cases, bots have one of the teams
536                         }
537                 }
538                 else
539                 {
540                         // find first team available
541                         if (IS_BOT_CLIENT(for_whom))
542                         {
543                                 if (TeamBalance_IsTeamAllowedInternal(balance, 1))
544                                 {
545                                         TeamBalance_BanTeamsExcept(balance, 1);
546                                 }
547                                 else if (TeamBalance_IsTeamAllowedInternal(balance, 2))
548                                 {
549                                         TeamBalance_BanTeamsExcept(balance, 2);
550                                 }
551                                 else
552                                 {
553                                         TeamBalance_BanTeamsExcept(balance, 3);
554                                 }
555                                 // no further cases, we know at least 2 teams exist
556                         }
557                         else
558                         {
559                                 if (TeamBalance_IsTeamAllowedInternal(balance, 4))
560                                 {
561                                         TeamBalance_BanTeamsExcept(balance, 4);
562                                 }
563                                 else if (TeamBalance_IsTeamAllowedInternal(balance, 3))
564                                 {
565                                         TeamBalance_BanTeamsExcept(balance, 3);
566                                 }
567                                 else
568                                 {
569                                         TeamBalance_BanTeamsExcept(balance, 2);
570                                 }
571                                 // no further cases, bots have one of the teams
572                         }
573                 }
574         }
575
576         if (!for_whom)
577         {
578                 balance.m_team_balance_state = TEAM_BALANCE_TEAMS_CHECKED;
579                 return balance;
580         }
581
582         // if player has a forced team, ONLY allow that one
583         for (int i = 1; i <= NUM_TEAMS; ++i)
584         {
585                 if (for_whom.team_forced == i &&
586                         TeamBalance_IsTeamAllowedInternal(balance, i))
587                 {
588                         TeamBalance_BanTeamsExcept(balance, i);
589                         break;
590                 }
591         }
592         balance.m_team_balance_state = TEAM_BALANCE_TEAMS_CHECKED;
593         return balance;
594 }
595
596 void TeamBalance_Destroy(entity balance)
597 {
598         if (balance == NULL)
599         {
600                 return;
601         }
602         for (int i = 0; i < NUM_TEAMS; ++i)
603         {
604                 delete(balance.(m_team_balance_team[i]));
605         }
606         delete(balance);
607 }
608
609 int TeamBalance_GetAllowedTeams(entity balance)
610 {
611         if (balance == NULL)
612         {
613                 LOG_FATAL("TeamBalance_GetAllowedTeams: Team balance entity is NULL.");
614         }
615         if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
616         {
617                 LOG_FATAL("TeamBalance_GetAllowedTeams: "
618                         "Team balance entity is not initialized.");
619         }
620         int result = 0;
621         for (int i = 1; i <= NUM_TEAMS; ++i)
622         {
623                 if (TeamBalance_IsTeamAllowedInternal(balance, i))
624                 {
625                         result |= Team_IndexToBit(i);
626                 }
627         }
628         return result;
629 }
630
631 bool TeamBalance_IsTeamAllowed(entity balance, int index)
632 {
633         if (balance == NULL)
634         {
635                 LOG_FATAL("TeamBalance_IsTeamAllowed: Team balance entity is NULL.");
636         }
637         if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
638         {
639                 LOG_FATAL("TeamBalance_IsTeamAllowed: "
640                         "Team balance entity is not initialized.");
641         }
642         if (!Team_IsValidIndex(index))
643         {
644                 LOG_FATALF("TeamBalance_IsTeamAllowed: Team index is invalid: %f",
645                         index);
646         }
647         return TeamBalance_IsTeamAllowedInternal(balance, index);
648 }
649
650 void TeamBalance_GetTeamCounts(entity balance, entity ignore)
651 {
652         if (balance == NULL)
653         {
654                 LOG_FATAL("TeamBalance_GetTeamCounts: Team balance entity is NULL.");
655         }
656         if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
657         {
658                 LOG_FATAL("TeamBalance_GetTeamCounts: "
659                         "Team balance entity is not initialized.");
660         }
661         if (MUTATOR_CALLHOOK(TeamBalance_GetTeamCounts) == true)
662         {
663                 // Mutator has overriden the configuration.
664                 for (int i = 1; i <= NUM_TEAMS; ++i)
665                 {
666                         entity team_ent = TeamBalance_GetTeamFromIndex(balance, i);
667                         if (TeamBalanceTeam_IsAllowed(team_ent))
668                         {
669                                 MUTATOR_CALLHOOK(TeamBalance_GetTeamCount, i, ignore);
670                                 team_ent.m_num_players = M_ARGV(2, float);
671                                 team_ent.m_num_bots = M_ARGV(3, float);
672                         }
673                 }
674         }
675         else
676         {
677                 // Manually count all players.
678                 FOREACH_CLIENT(true,
679                 {
680                         if (it == ignore)
681                         {
682                                 continue;
683                         }
684                         int team_num;
685                         // TODO: Reconsider when the player is truly on the team.
686                         if (IS_CLIENT(it) || (it.caplayer))
687                         {
688                                 team_num = it.team;
689                         }
690                         else if (Player_HasRealForcedTeam(it))
691                         {
692                                 // Do we really need this? Probably not.
693                                 team_num = Team_IndexToTeam(it.team_forced); // reserve the spot
694                         }
695                         else
696                         {
697                                 continue;
698                         }
699                         if (!Team_IsValidTeam(team_num))
700                         {
701                                 continue;
702                         }
703                         entity team_ent = TeamBalance_GetTeam(balance, team_num);
704                         if (!TeamBalanceTeam_IsAllowed(team_ent))
705                         {
706                                 continue;
707                         }
708                         ++team_ent.m_num_players;
709                         if (IS_BOT_CLIENT(it))
710                         {
711                                 ++team_ent.m_num_bots;
712                         }
713                 });
714         }
715
716         // if the player who has a forced team has not joined yet, reserve the spot
717         if (autocvar_g_campaign)
718         {
719                 if (Team_IsValidIndex(autocvar_g_campaign_forceteam))
720                 {
721                         entity team_ent = TeamBalance_GetTeamFromIndex(balance,
722                                 autocvar_g_campaign_forceteam);
723                         if (team_ent.m_num_players == team_ent.m_num_bots)
724                         {
725                                 ++team_ent.m_num_players;
726                         }
727                 }
728         }
729         balance.m_team_balance_state = TEAM_BALANCE_TEAM_COUNTS_FILLED;
730 }
731
732 int TeamBalance_GetNumberOfPlayers(entity balance, int index)
733 {
734         if (balance == NULL)
735         {
736                 LOG_FATAL("TeamBalance_GetNumberOfPlayers: "
737                         "Team balance entity is NULL.");
738         }
739         if (balance.m_team_balance_state != TEAM_BALANCE_TEAM_COUNTS_FILLED)
740         {
741                 LOG_FATAL("TeamBalance_GetNumberOfPlayers: "
742                         "TeamBalance_GetTeamCounts has not been called.");
743         }
744         if (!Team_IsValidIndex(index))
745         {
746                 LOG_FATALF("TeamBalance_GetNumberOfPlayers: Team index is invalid: %f",
747                         index);
748         }
749         return balance.m_team_balance_team[index - 1].m_num_players;
750 }
751
752 int TeamBalance_FindBestTeam(entity balance, entity player, bool ignore_player)
753 {
754         if (balance == NULL)
755         {
756                 LOG_FATAL("TeamBalance_FindBestTeam: Team balance entity is NULL.");
757         }
758         if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
759         {
760                 LOG_FATAL("TeamBalance_FindBestTeam: "
761                         "Team balance entity is not initialized.");
762         }
763         // count how many players are in each team
764         if (ignore_player)
765         {
766                 TeamBalance_GetTeamCounts(balance, player);
767         }
768         else
769         {
770                 TeamBalance_GetTeamCounts(balance, NULL);
771         }
772         int team_bits = TeamBalance_FindBestTeams(balance, player, true);
773         if (team_bits == 0)
774         {
775                 LOG_FATALF("TeamBalance_FindBestTeam: No teams available for %s\n",
776                         MapInfo_Type_ToString(MapInfo_CurrentGametype()));
777         }
778         RandomSelection_Init();
779         for (int i = 1; i <= NUM_TEAMS; ++i)
780         {
781                 if (team_bits & Team_IndexToBit(i))
782                 {
783                         RandomSelection_AddFloat(i, 1, 1);
784                 }
785         }
786         return RandomSelection_chosen_float;
787 }
788
789 int TeamBalance_FindBestTeams(entity balance, entity player, bool use_score)
790 {
791         if (balance == NULL)
792         {
793                 LOG_FATAL("TeamBalance_FindBestTeams: Team balance entity is NULL.");
794         }
795         if (balance.m_team_balance_state != TEAM_BALANCE_TEAM_COUNTS_FILLED)
796         {
797                 LOG_FATAL("TeamBalance_FindBestTeams: "
798                         "TeamBalance_GetTeamCounts has not been called.");
799         }
800         if (MUTATOR_CALLHOOK(TeamBalance_FindBestTeams, player) == true)
801         {
802                 return M_ARGV(1, float);
803         }
804         int team_bits = 0;
805         int previous_team = 0;
806         for (int i = 1; i <= NUM_TEAMS; ++i)
807         {
808                 if (!TeamBalance_IsTeamAllowedInternal(balance, i))
809                 {
810                         continue;
811                 }
812                 if (previous_team == 0)
813                 {
814                         team_bits = Team_IndexToBit(i);
815                         previous_team = i;
816                         continue;
817                 }
818                 int compare = TeamBalance_CompareTeams(balance, i, previous_team,
819                         player, use_score);
820                 if (compare == TEAMS_COMPARE_LESS)
821                 {
822                         team_bits = Team_IndexToBit(i);
823                         previous_team = i;
824                         continue;
825                 }
826                 if (compare == TEAMS_COMPARE_EQUAL)
827                 {
828                         team_bits |= Team_IndexToBit(i);
829                         previous_team = i;
830                 }
831         }
832         return team_bits;
833 }
834
835 int TeamBalance_CompareTeams(entity balance, int team_index_a, int team_index_b,
836         entity player, bool use_score)
837 {
838         if (balance == NULL)
839         {
840                 LOG_FATAL("TeamBalance_CompareTeams: Team balance entity is NULL.");
841         }
842         if (balance.m_team_balance_state != TEAM_BALANCE_TEAM_COUNTS_FILLED)
843         {
844                 LOG_FATAL("TeamBalance_CompareTeams: "
845                         "TeamBalance_GetTeamCounts has not been called.");
846         }
847         if (!Team_IsValidIndex(team_index_a))
848         {
849                 LOG_FATALF("TeamBalance_CompareTeams: team_index_a is invalid: %f",
850                         team_index_a);
851         }
852         if (!Team_IsValidIndex(team_index_b))
853         {
854                 LOG_FATALF("TeamBalance_CompareTeams: team_index_b is invalid: %f",
855                         team_index_b);
856         }
857         if (team_index_a == team_index_b)
858         {
859                 return TEAMS_COMPARE_EQUAL;
860         }
861         entity team_a = TeamBalance_GetTeamFromIndex(balance, team_index_a);
862         entity team_b = TeamBalance_GetTeamFromIndex(balance, team_index_b);
863         return TeamBalance_CompareTeamsInternal(team_a, team_b, player, use_score);
864 }
865
866 void TeamBalance_AutoBalanceBots()
867 {
868         // checks disabled because we always want auto-balanced bots
869         //if (!(autocvar_g_balance_teams && autocvar_g_balance_teams_prevent_imbalance))
870         //      return;
871
872         entity balance = TeamBalance_CheckAllowedTeams(NULL);
873         TeamBalance_GetTeamCounts(balance, NULL);
874         int smallest_team_index = 0;
875         int smallest_team_player_count = 0;
876         for (int i = 1; i <= NUM_TEAMS; ++i)
877         {
878                 entity team_ = TeamBalance_GetTeamFromIndex(balance, i);
879                 if (!TeamBalanceTeam_IsAllowed(team_))
880                 {
881                         continue;
882                 }
883                 int playercount = TeamBalanceTeam_GetNumberOfPlayers(team_);
884                 if (smallest_team_index == 0)
885                 {
886                         smallest_team_index = i;
887                         smallest_team_player_count = playercount;
888                 }
889                 else if (playercount < smallest_team_player_count)
890                 {
891                         smallest_team_index = i;
892                         smallest_team_player_count = playercount;
893                 }
894         }
895         //PrintToChatAll(sprintf("Smallest team: %f", smallest_team_index));
896         //PrintToChatAll(sprintf("Smallest team players: %f", smallest_team_player_count));
897         entity switchable_bot = NULL;
898         int teams = BITS(NUM_TEAMS);
899         while (teams != 0)
900         {
901                 int largest_team_index = TeamBalance_GetLargestTeamIndex(balance,
902                         teams);
903                 if (smallest_team_index == largest_team_index)
904                 {
905                         TeamBalance_Destroy(balance);
906                         return;
907                 }
908                 entity largest_team = TeamBalance_GetTeamFromIndex(balance,
909                         largest_team_index);
910                 int largest_team_player_count = TeamBalanceTeam_GetNumberOfPlayers(
911                         largest_team);
912                 if (largest_team_player_count - smallest_team_player_count < 2)
913                 {
914                         TeamBalance_Destroy(balance);
915                         return;
916                 }
917                 //PrintToChatAll(sprintf("Largest team: %f", largest_team_index));
918                 //PrintToChatAll(sprintf("Largest team players: %f", largest_team_player_count));
919                 switchable_bot = TeamBalance_GetPlayerForTeamSwitch(largest_team_index,
920                         smallest_team_index, true);
921                 if (switchable_bot != NULL)
922                 {
923                         break;
924                 }
925                 teams &= ~Team_IndexToBit(largest_team_index);
926         }
927         TeamBalance_Destroy(balance);
928         if (switchable_bot == NULL)
929         {
930                 //PrintToChatAll("No bot found after searching through all the teams");
931                 return;
932         }
933         SetPlayerTeam(switchable_bot, smallest_team_index, TEAM_CHANGE_AUTO);
934 }
935
936 int TeamBalance_GetLargestTeamIndex(entity balance, int teams)
937 {
938         int largest_team_index = 0;
939         int largest_team_player_count = 0;
940         for (int i = 1; i <= NUM_TEAMS; ++i)
941         {
942                 if (!(Team_IndexToBit(i) & teams))
943                 {
944                         continue;
945                 }
946                 entity team_ = TeamBalance_GetTeamFromIndex(balance, i);
947                 if (!TeamBalanceTeam_IsAllowed(team_))
948                 {
949                         continue;
950                 }
951                 int playercount = TeamBalanceTeam_GetNumberOfPlayers(team_);
952                 if (largest_team_index == 0)
953                 {
954                         largest_team_index = i;
955                         largest_team_player_count = playercount;
956                 }
957                 else if (playercount > largest_team_player_count)
958                 {
959                         largest_team_index = i;
960                         largest_team_player_count = playercount;
961                 }
962         }
963         return largest_team_index;
964 }
965
966 entity TeamBalance_GetPlayerForTeamSwitch(int source_team_index,
967         int destination_team_index, bool is_bot)
968 {
969         if (MUTATOR_CALLHOOK(TeamBalance_GetPlayerForTeamSwitch, source_team_index,
970                 destination_team_index, is_bot))
971         {
972                 return M_ARGV(3, entity);
973         }
974         entity lowest_player = NULL;
975         float lowest_score = FLOAT_MAX;
976         FOREACH_CLIENT(Entity_GetTeamIndex(it) == source_team_index,
977         {
978                 if (IS_BOT_CLIENT(it) != is_bot)
979                 {
980                         continue;
981                 }
982                 float temp_score = PlayerScore_Get(it, SP_SCORE);
983                 if (temp_score >= lowest_score)
984                 {
985                         continue;
986                 }
987                 //PrintToChatAll(sprintf(
988                 //      "Found %s with lowest score, checking allowed teams", it.netname));
989                 entity balance = TeamBalance_CheckAllowedTeams(it);
990                 if (TeamBalance_IsTeamAllowed(balance, source_team_index))
991                 {
992                         //PrintToChatAll("Allowed");
993                         lowest_player = it;
994                         lowest_score = temp_score;
995                 }
996                 else
997                 {
998                         //PrintToChatAll("Not allowed");
999                 }
1000                 TeamBalance_Destroy(balance);
1001         });
1002         return lowest_player;
1003 }
1004
1005 void LogTeamChange(float player_id, float team_number, int type)
1006 {
1007         if (!autocvar_sv_eventlog)
1008         {
1009                 return;
1010         }
1011         if (player_id < 1)
1012         {
1013                 return;
1014         }
1015         GameLogEcho(sprintf(":team:%d:%d:%d", player_id, team_number, type));
1016 }
1017
1018 void KillPlayerForTeamChange(entity player)
1019 {
1020         if (IS_DEAD(player))
1021         {
1022                 return;
1023         }
1024         if (MUTATOR_CALLHOOK(Player_ChangeTeamKill, player) == true)
1025         {
1026                 return;
1027         }
1028         Damage(player, player, player, 100000, DEATH_TEAMCHANGE.m_id, DMG_NOWEP,
1029                 player.origin, '0 0 0');
1030 }
1031
1032 bool TeamBalance_IsTeamAllowedInternal(entity balance, int index)
1033 {
1034         return balance.m_team_balance_team[index - 1].m_num_players !=
1035                 TEAM_NOT_ALLOWED;
1036 }
1037
1038 void TeamBalance_BanTeamsExcept(entity balance, int index)
1039 {
1040         for (int i = 1; i <= NUM_TEAMS; ++i)
1041         {
1042                 if (i != index)
1043                 {
1044                         balance.m_team_balance_team[i - 1].m_num_players = TEAM_NOT_ALLOWED;
1045                 }
1046         }
1047 }
1048
1049 entity TeamBalance_GetTeamFromIndex(entity balance, int index)
1050 {
1051         if (!Team_IsValidIndex(index))
1052         {
1053                 LOG_FATALF("TeamBalance_GetTeamFromIndex: Index is invalid: %f", index);
1054         }
1055         return balance.m_team_balance_team[index - 1];
1056 }
1057
1058 entity TeamBalance_GetTeam(entity balance, int team_num)
1059 {
1060         return TeamBalance_GetTeamFromIndex(balance, Team_TeamToIndex(team_num));
1061 }
1062
1063 bool TeamBalanceTeam_IsAllowed(entity team_ent)
1064 {
1065         return team_ent.m_num_players != TEAM_NOT_ALLOWED;
1066 }
1067
1068 int TeamBalanceTeam_GetNumberOfPlayers(entity team_ent)
1069 {
1070         return team_ent.m_num_players;
1071 }
1072
1073 int TeamBalanceTeam_GetNumberOfBots(entity team_ent)
1074 {
1075         return team_ent.m_num_bots;
1076 }
1077
1078 int TeamBalance_CompareTeamsInternal(entity team_a, entity team_b,
1079         entity player, bool use_score)
1080 {
1081         if (team_a == team_b)
1082         {
1083                 return TEAMS_COMPARE_EQUAL;
1084         }
1085         if (!TeamBalanceTeam_IsAllowed(team_a) ||
1086                 !TeamBalanceTeam_IsAllowed(team_b))
1087         {
1088                 return TEAMS_COMPARE_INVALID;
1089         }
1090         int num_players_team_a = team_a.m_num_players;
1091         int num_players_team_b = team_b.m_num_players;
1092         if (IS_REAL_CLIENT(player) && bots_would_leave)
1093         {
1094                 num_players_team_a -= team_a.m_num_bots;
1095                 num_players_team_b -= team_b.m_num_bots;
1096         }
1097         if (num_players_team_a < num_players_team_b)
1098         {
1099                 return TEAMS_COMPARE_LESS;
1100         }
1101         if (num_players_team_a > num_players_team_b)
1102         {
1103                 return TEAMS_COMPARE_GREATER;
1104         }
1105         if (!use_score)
1106         {
1107                 return TEAMS_COMPARE_EQUAL;
1108         }
1109         if (team_a.m_team_score < team_b.m_team_score)
1110         {
1111                 return TEAMS_COMPARE_LESS;
1112         }
1113         if (team_a.m_team_score > team_b.m_team_score)
1114         {
1115                 return TEAMS_COMPARE_GREATER;
1116         }
1117         return TEAMS_COMPARE_EQUAL;
1118 }
1119
1120 void SV_ChangeTeam(entity player, int new_color)
1121 {
1122         if (!teamplay)
1123         {
1124                 SetPlayerColors(player, new_color);
1125         }
1126         // TODO: Should we really bother with this?
1127         if(!IS_CLIENT(player))
1128         {
1129                 // since this is an engine function, and gamecode doesn't have any calls earlier than this, do the connecting message here
1130                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_CONNECTING,
1131                         player.netname);
1132                 return;
1133         }
1134         if (!teamplay)
1135         {
1136                 return;
1137         }
1138         Player_SetTeamIndexChecked(player, Team_TeamToIndex((new_color & 0x0F) +
1139                 1));
1140 }