X-Git-Url: https://de.git.xonotic.org/?p=xonotic%2Fxonotic-data.pk3dir.git;a=blobdiff_plain;f=qcsrc%2Fserver%2Fteamplay.qc;h=eadbe0f688f096666b2f0ed674174aa144619376;hp=2d6ceb8e0257f3546820544f276cb873d946e863;hb=050fb0011ae5fb2b36c7c7f3d560f9453807a8ab;hpb=38cbcd4d9ed347f6a88a074bdedee90a164d4c71

diff --git a/qcsrc/server/teamplay.qc b/qcsrc/server/teamplay.qc
index 2d6ceb8e0..eadbe0f68 100644
--- a/qcsrc/server/teamplay.qc
+++ b/qcsrc/server/teamplay.qc
@@ -169,49 +169,54 @@ void setcolor(entity this, int clr)
 #endif
 }
 
-void SetPlayerColors(entity pl, float _color)
+void SetPlayerColors(entity player, float _color)
 {
-	/*string s;
-	s = ftos(cl);
-	stuffcmd(pl, strcat("color ", s, " ", s, "\n")  );
-	pl.team = cl + 1;
-	//pl.clientcolors = pl.clientcolors - (pl.clientcolors & 15) + cl;
-	pl.clientcolors = 16*cl + cl;*/
-
-	float pants, shirt;
-	pants = _color & 0x0F;
-	shirt = _color & 0xF0;
-
-
-	if(teamplay) {
-		setcolor(pl, 16*pants + pants);
-	} else {
-		setcolor(pl, shirt + pants);
+	float pants = _color & 0x0F;
+	float shirt = _color & 0xF0;
+	if (teamplay)
+	{
+		setcolor(player, 16 * pants + pants);
+	}
+	else
+	{
+		setcolor(player, shirt + pants);
 	}
 }
 
-void SetPlayerTeam(entity pl, float t, float s, float noprint)
+bool SetPlayerTeamSimple(entity player, int teamnum)
 {
-	float _color;
-
-	if(t == 4)
-		_color = NUM_TEAM_4 - 1;
-	else if(t == 3)
-		_color = NUM_TEAM_3 - 1;
-	else if(t == 2)
-		_color = NUM_TEAM_2 - 1;
-	else
-		_color = NUM_TEAM_1 - 1;
-
-	SetPlayerColors(pl,_color);
-
-	if(t != s) {
-		LogTeamchange(pl.playerid, pl.team, 3);  // log manual team join
-
-		if(!noprint)
-			bprint(playername(pl, false), "^7 has changed from ", Team_NumberToColoredFullName(s), "^7 to ", Team_NumberToColoredFullName(t), "\n");
+	if (player.team == teamnum)
+	{
+		// This is important when players join the game and one of their color
+		// matches the team color while other doesn't. For example [BOT]Lion.
+		SetPlayerColors(player, teamnum - 1);
+		return true;
 	}
+	if (MUTATOR_CALLHOOK(Player_ChangeTeam, player, Team_TeamToNumber(
+		player.team), Team_TeamToNumber(teamnum)) == true)
+	{
+		// Mutator has blocked team change.
+		return false;
+	}
+	int oldteam = player.team;
+	SetPlayerColors(player, teamnum - 1);
+	MUTATOR_CALLHOOK(Player_ChangedTeam, player, oldteam, player.team);
+	return true;
+}
 
+void SetPlayerTeam(entity player, int destinationteam, int sourceteam, bool noprint)
+{
+	int teamnum = Team_NumberToTeam(destinationteam);
+	if (!SetPlayerTeamSimple(player, teamnum))
+	{
+		return;
+	}
+	LogTeamchange(player.playerid, player.team, 3);  // log manual team join
+	if (noprint)
+	{
+		return;
+	}
+	bprint(playername(player, false), "^7 has changed from ", Team_NumberToColoredFullName(sourceteam), "^7 to ", Team_NumberToColoredFullName(destinationteam), "\n");
 }
 
 // set c1...c4 to show what teams are allowed
@@ -220,7 +225,7 @@ void CheckAllowedTeams (entity for_whom)
 	int teams_mask = 0;
 
 	c1 = c2 = c3 = c4 = -1;
-	cb1 = cb2 = cb3 = cb4 = 0;
+	numbotsteam1 = numbotsteam2 = numbotsteam3 = numbotsteam4 = 0;
 
 	string teament_name = string_null;
 
@@ -322,218 +327,430 @@ float PlayerValue(entity p)
 // teams that are allowed will now have their player counts stored in c1...c4
 void GetTeamCounts(entity ignore)
 {
-	float value, bvalue;
-	// now count how many players are on each team already
-
-	// FIXME: also find and memorize the lowest-scoring bot on each team (in case players must be shuffled around)
-	// also remember the lowest-scoring player
-
-	FOREACH_CLIENT(true, LAMBDA(
-		float t;
-		if(IS_PLAYER(it) || it.caplayer)
-			t = it.team;
-		else if(it.team_forced > 0)
-			t = it.team_forced; // reserve the spot
-		else
-			continue;
-		if(it != ignore)// && it.netname != "")
+	if (MUTATOR_CALLHOOK(GetTeamCounts) == true)
+	{
+		if (c1 >= 0)
+		{
+			MUTATOR_CALLHOOK(GetTeamCount, NUM_TEAM_1, ignore, c1, numbotsteam1,
+				lowestplayerteam1, lowestbotteam1);
+			c1 = M_ARGV(2, float);
+			numbotsteam1 = M_ARGV(3, float);
+			lowestplayerteam1 = M_ARGV(4, entity);
+			lowestbotteam1 = M_ARGV(5, entity);
+		}
+		if (c2 >= 0)
+		{
+			MUTATOR_CALLHOOK(GetTeamCount, NUM_TEAM_2, ignore, c2, numbotsteam2,
+				lowestplayerteam2, lowestbotteam2);
+			c2 = M_ARGV(2, float);
+			numbotsteam2 = M_ARGV(3, float);
+			lowestplayerteam2 = M_ARGV(4, entity);
+			lowestbotteam2 = M_ARGV(5, entity);
+		}
+		if (c3 >= 0)
 		{
+			MUTATOR_CALLHOOK(GetTeamCount, NUM_TEAM_3, ignore, c3, numbotsteam3,
+				lowestplayerteam3, lowestbotteam3);
+			c3 = M_ARGV(2, float);
+			numbotsteam3 = M_ARGV(3, float);
+			lowestplayerteam3 = M_ARGV(4, entity);
+			lowestbotteam3 = M_ARGV(5, entity);
+		}
+		if (c4 >= 0)
+		{
+			MUTATOR_CALLHOOK(GetTeamCount, NUM_TEAM_4, ignore, c4, numbotsteam4,
+				lowestplayerteam4, lowestbotteam4);
+			c4 = M_ARGV(2, float);
+			numbotsteam4 = M_ARGV(3, float);
+			lowestplayerteam4 = M_ARGV(4, entity);
+			lowestbotteam4 = M_ARGV(5, entity);
+		}
+	}
+	else
+	{
+		float value, bvalue;
+		// now count how many players are on each team already
+		float lowestplayerscore1 = FLOAT_MAX;
+		float lowestbotscore1 = FLOAT_MAX;
+		float lowestplayerscore2 = FLOAT_MAX;
+		float lowestbotscore2 = FLOAT_MAX;
+		float lowestplayerscore3 = FLOAT_MAX;
+		float lowestbotscore3 = FLOAT_MAX;
+		float lowestplayerscore4 = FLOAT_MAX;
+		float lowestbotscore4 = FLOAT_MAX;
+		FOREACH_CLIENT(true, LAMBDA(
+			float t;
+			if (IS_PLAYER(it) || it.caplayer)
+			{
+				t = it.team;
+			}
+			else if (it.team_forced > 0)
+			{
+				t = it.team_forced; // reserve the spot
+			}
+			else
+			{
+				continue;
+			}
+			if (it == ignore)
+			{
+				continue;
+			}
 			value = PlayerValue(it);
-			if(IS_BOT_CLIENT(it))
+			if (IS_BOT_CLIENT(it))
+			{
 				bvalue = value;
+			}
 			else
+			{
 				bvalue = 0;
-			if(t == NUM_TEAM_1)
+			}
+			if (value == 0)
 			{
-				if(c1 >= 0)
-				{
-					c1 = c1 + value;
-					cb1 = cb1 + bvalue;
-				}
+				continue;
 			}
-			else if(t == NUM_TEAM_2)
+			switch (t)
 			{
-				if(c2 >= 0)
+				case NUM_TEAM_1:
 				{
-					c2 = c2 + value;
-					cb2 = cb2 + bvalue;
+					if (c1 < 0)
+					{
+						break;
+					}
+					c1 += value;
+					numbotsteam1 += bvalue;
+					float tempscore = PlayerScore_Get(it, SP_SCORE);
+					if (!bvalue)
+					{
+						if (tempscore < lowestplayerscore1)
+						{
+							lowestplayerteam1 = it;
+							lowestplayerscore1 = tempscore;
+						}
+						break;
+					}
+					if (tempscore < lowestbotscore1)
+					{
+						lowestbotteam1 = it;
+						lowestbotscore1 = tempscore;
+					}
+					break;
 				}
-			}
-			else if(t == NUM_TEAM_3)
-			{
-				if(c3 >= 0)
+				case NUM_TEAM_2:
 				{
-					c3 = c3 + value;
-					cb3 = cb3 + bvalue;
+					if (c2 < 0)
+					{
+						break;
+					}
+					c2 += value;
+					numbotsteam2 += bvalue;
+					float tempscore = PlayerScore_Get(it, SP_SCORE);
+					if (!bvalue)
+					{
+						if (tempscore < lowestplayerscore2)
+						{
+							lowestplayerteam2 = it;
+							lowestplayerscore2 = tempscore;
+						}
+						break;
+					}
+					if (tempscore < lowestbotscore2)
+					{
+						lowestbotteam2 = it;
+						lowestbotscore2 = tempscore;
+					}
+					break;
 				}
-			}
-			else if(t == NUM_TEAM_4)
-			{
-				if(c4 >= 0)
+				case NUM_TEAM_3:
 				{
-					c4 = c4 + value;
-					cb4 = cb4 + bvalue;
+					if (c3 < 0)
+					{
+						break;
+					}
+					c3 += value;
+					numbotsteam3 += bvalue;
+					float tempscore = PlayerScore_Get(it, SP_SCORE);
+					if (!bvalue)
+					{
+						if (tempscore < lowestplayerscore3)
+						{
+							lowestplayerteam3 = it;
+							lowestplayerscore3 = tempscore;
+						}
+						break;
+					}
+					if (tempscore < lowestbotscore3)
+					{
+						lowestbotteam3 = it;
+						lowestbotscore3 = tempscore;
+					}
+					break;
+				}
+				case NUM_TEAM_4:
+				{
+					if (c4 < 0)
+					{
+						break;
+					}
+					c4 += value;
+					numbotsteam4 += bvalue;
+					float tempscore = PlayerScore_Get(it, SP_SCORE);
+					if (!bvalue)
+					{
+						if (tempscore < lowestplayerscore4)
+						{
+							lowestplayerteam4 = it;
+							lowestplayerscore4 = tempscore;
+						}
+						break;
+					}
+					if (tempscore < lowestbotscore4)
+					{
+						lowestbotteam4 = it;
+						lowestbotscore4 = tempscore;
+					}
+					break;
 				}
 			}
-		}
-	));
+		));
+	}
 
 	// if the player who has a forced team has not joined yet, reserve the spot
 	if(autocvar_g_campaign)
 	{
 		switch(autocvar_g_campaign_forceteam)
 		{
-			case 1: if(c1 == cb1) ++c1; break;
-			case 2: if(c2 == cb2) ++c2; break;
-			case 3: if(c3 == cb3) ++c3; break;
-			case 4: if(c4 == cb4) ++c4; break;
+			case 1: if(c1 == numbotsteam1) ++c1; break;
+			case 2: if(c2 == numbotsteam2) ++c2; break;
+			case 3: if(c3 == numbotsteam3) ++c3; break;
+			case 4: if(c4 == numbotsteam4) ++c4; break;
 		}
 	}
 }
 
-float TeamSmallerEqThanTeam(float ta, float tb, entity e)
+bool IsTeamSmallerThanTeam(int teama, int teamb, entity e, bool usescore)
 {
+	// equal
+	if (teama == teamb)
+	{
+		return false;
+	}
 	// we assume that CheckAllowedTeams and GetTeamCounts have already been called
-	float f;
-	float ca = -1, cb = -1, cba = 0, cbb = 0, sa = 0, sb = 0;
+	float numplayersteama = -1, numplayersteamb = -1;
+	float numbotsteama = 0, numbotsteamb = 0;
+	float scoreteama = 0, scoreteamb = 0;
 
-	switch(ta)
+	switch (teama)
 	{
-		case 1: ca = c1; cba = cb1; sa = team1_score; break;
-		case 2: ca = c2; cba = cb2; sa = team2_score; break;
-		case 3: ca = c3; cba = cb3; sa = team3_score; break;
-		case 4: ca = c4; cba = cb4; sa = team4_score; break;
+		case 1: numplayersteama = c1; numbotsteama = numbotsteam1; scoreteama = team1_score; break;
+		case 2: numplayersteama = c2; numbotsteama = numbotsteam2; scoreteama = team2_score; break;
+		case 3: numplayersteama = c3; numbotsteama = numbotsteam3; scoreteama = team3_score; break;
+		case 4: numplayersteama = c4; numbotsteama = numbotsteam4; scoreteama = team4_score; break;
 	}
-	switch(tb)
+	switch (teamb)
 	{
-		case 1: cb = c1; cbb = cb1; sb = team1_score; break;
-		case 2: cb = c2; cbb = cb2; sb = team2_score; break;
-		case 3: cb = c3; cbb = cb3; sb = team3_score; break;
-		case 4: cb = c4; cbb = cb4; sb = team4_score; break;
+		case 1: numplayersteamb = c1; numbotsteamb = numbotsteam1; scoreteamb = team1_score; break;
+		case 2: numplayersteamb = c2; numbotsteamb = numbotsteam2; scoreteamb = team2_score; break;
+		case 3: numplayersteamb = c3; numbotsteamb = numbotsteam3; scoreteamb = team3_score; break;
+		case 4: numplayersteamb = c4; numbotsteamb = numbotsteam4; scoreteamb = team4_score; break;
 	}
 
 	// invalid
-	if(ca < 0 || cb < 0)
+	if (numplayersteama < 0 || numplayersteamb < 0)
 		return false;
 
-	// equal
-	if(ta == tb)
+	if ((IS_REAL_CLIENT(e) && bots_would_leave))
+	{
+		numplayersteama -= numbotsteama;
+		numplayersteamb -= numbotsteamb;
+	}
+	if (!usescore)
+	{
+		return numplayersteama < numplayersteamb;
+	}
+	if (numplayersteama < numplayersteamb)
+	{
 		return true;
-
-	if(IS_REAL_CLIENT(e))
+	}
+	if (numplayersteama > numplayersteamb)
 	{
-		if(bots_would_leave)
-		{
-			ca -= cba * 0.999;
-			cb -= cbb * 0.999;
-		}
+		return false;
 	}
-
-	// keep teams alive (teams of size 0 always count as smaller, ignoring score)
-	if(ca < 1)
-		if(cb >= 1)
-			return true;
-	if(ca >= 1)
-		if(cb < 1)
-			return false;
-
-	// first, normalize
-	f = max(ca, cb, 1);
-	ca /= f;
-	cb /= f;
-	f = max(sa, sb, 1);
-	sa /= f;
-	sb /= f;
-
-	// the more we're at the end of the match, the more take scores into account
-	f = bound(0, game_completion_ratio * autocvar_g_balance_teams_scorefactor, 1);
-	ca += (sa - ca) * f;
-	cb += (sb - cb) * f;
-
-	return ca <= cb;
+	return scoreteama < scoreteamb;	
 }
 
-// returns # of smallest team (1, 2, 3, 4)
-// NOTE: Assumes CheckAllowedTeams has already been called!
-float FindSmallestTeam(entity pl, float ignore_pl)
+bool IsTeamEqualToTeam(int teama, int teamb, entity e, bool usescore)
 {
-	int totalteams = 0;
-	int t = 1; // initialize with a random team?
-	if(c4 >= 0) t = 4;
-	if(c3 >= 0) t = 3;
-	if(c2 >= 0) t = 2;
-	if(c1 >= 0) t = 1;
+	// equal
+	if (teama == teamb)
+	{
+		return true;
+	}
+	// we assume that CheckAllowedTeams and GetTeamCounts have already been called
+	float numplayersteama = -1, numplayersteamb = -1;
+	float numbotsteama = 0, numbotsteamb = 0;
+	float scoreteama = 0, scoreteamb = 0;
 
-	// find out what teams are available
-	//CheckAllowedTeams();
+	switch (teama)
+	{
+		case 1: numplayersteama = c1; numbotsteama = numbotsteam1; scoreteama = team1_score; break;
+		case 2: numplayersteama = c2; numbotsteama = numbotsteam2; scoreteama = team2_score; break;
+		case 3: numplayersteama = c3; numbotsteama = numbotsteam3; scoreteama = team3_score; break;
+		case 4: numplayersteama = c4; numbotsteama = numbotsteam4; scoreteama = team4_score; break;
+	}
+	switch (teamb)
+	{
+		case 1: numplayersteamb = c1; numbotsteamb = numbotsteam1; scoreteamb = team1_score; break;
+		case 2: numplayersteamb = c2; numbotsteamb = numbotsteam2; scoreteamb = team2_score; break;
+		case 3: numplayersteamb = c3; numbotsteamb = numbotsteam3; scoreteamb = team3_score; break;
+		case 4: numplayersteamb = c4; numbotsteamb = numbotsteam4; scoreteamb = team4_score; break;
+	}
 
-	// make sure there are at least 2 teams to join
-	if(c1 >= 0)
-		totalteams = totalteams + 1;
-	if(c2 >= 0)
-		totalteams = totalteams + 1;
-	if(c3 >= 0)
-		totalteams = totalteams + 1;
-	if(c4 >= 0)
-		totalteams = totalteams + 1;
+	// invalid
+	if (numplayersteama < 0 || numplayersteamb < 0)
+		return false;
 
-	if((autocvar_bot_vs_human || pl.team_forced > 0) && totalteams == 1)
-		totalteams += 1;
+	if ((IS_REAL_CLIENT(e) && bots_would_leave))
+	{
+		numplayersteama -= numbotsteama;
+		numplayersteamb -= numbotsteamb;
+	}
+	if (!usescore)
+	{
+		return numplayersteama == numplayersteamb;
+	}
+	if (numplayersteama < numplayersteamb)
+	{
+		return false;
+	}
+	if (numplayersteama > numplayersteamb)
+	{
+		return false;
+	}
+	return scoreteama == scoreteamb;	
+}
 
-	if(totalteams <= 1)
+int FindBestTeams(entity player, bool usescore)
+{
+	if (MUTATOR_CALLHOOK(FindBestTeams, player) == true)
+	{
+		return M_ARGV(1, float);
+	}
+	int teambits = 0;
+	int previousteam = 0;
+	if (c1 >= 0)
+	{
+		teambits = BIT(0);
+		previousteam = 1;
+	}
+	if (c2 >= 0)
+	{
+		if (previousteam == 0)
+		{
+			teambits = BIT(1);
+			previousteam = 2;
+		}
+		else if (IsTeamSmallerThanTeam(2, previousteam, player, usescore))
+		{
+			teambits = BIT(1);
+			previousteam = 2;
+		}
+		else if (IsTeamEqualToTeam(2, previousteam, player, usescore))
+		{
+			teambits |= BIT(1);
+			previousteam = 2;
+		}
+	}
+	if (c3 >= 0)
+	{
+		if (previousteam == 0)
+		{
+			teambits = BIT(2);
+			previousteam = 3;
+		}
+		else if (IsTeamSmallerThanTeam(3, previousteam, player, usescore))
+		{
+			teambits = BIT(2);
+			previousteam = 3;
+		}
+		else if (IsTeamEqualToTeam(3, previousteam, player, usescore))
+		{
+			teambits |= BIT(2);
+			previousteam = 3;
+		}
+	}
+	if (c4 >= 0)
 	{
-		if(autocvar_g_campaign && pl && IS_REAL_CLIENT(pl))
-			return 1; // special case for campaign and player joining
-		else if(totalteams == 1) // single team
-			LOG_TRACEF("Only 1 team available for %s, you may need to fix your map", MapInfo_Type_ToString(MapInfo_CurrentGametype()));
-		else // no teams, major no no
-			error(sprintf("No teams available for %s\n", MapInfo_Type_ToString(MapInfo_CurrentGametype())));
+		if (previousteam == 0)
+		{
+			teambits = BIT(3);
+		}
+		else if (IsTeamSmallerThanTeam(4, previousteam, player, usescore))
+		{
+			teambits = BIT(3);
+		}
+		else if (IsTeamEqualToTeam(4, previousteam, player, usescore))
+		{
+			teambits |= BIT(3);
+		}
 	}
+	return teambits;
+}
 
+// returns # of smallest team (1, 2, 3, 4)
+// NOTE: Assumes CheckAllowedTeams has already been called!
+float FindSmallestTeam(entity pl, float ignore_pl)
+{
 	// count how many players are in each team
-	if(ignore_pl)
+	if (ignore_pl)
+	{
 		GetTeamCounts(pl);
+	}
 	else
+	{
 		GetTeamCounts(NULL);
-
+	}
+	int teambits = FindBestTeams(pl, true);
+	if (teambits == 0)
+	{
+		error(sprintf("No teams available for %s\n", MapInfo_Type_ToString(MapInfo_CurrentGametype())));
+	}
 	RandomSelection_Init();
-
-	if(TeamSmallerEqThanTeam(1, t, pl))
-		t = 1;
-	if(TeamSmallerEqThanTeam(2, t, pl))
-		t = 2;
-	if(TeamSmallerEqThanTeam(3, t, pl))
-		t = 3;
-	if(TeamSmallerEqThanTeam(4, t, pl))
-		t = 4;
-
-	// now t is the minimum, or A minimum!
-	if(t == 1 || TeamSmallerEqThanTeam(1, t, pl))
+	if ((teambits & BIT(0)) != 0)
+	{
 		RandomSelection_AddFloat(1, 1, 1);
-	if(t == 2 || TeamSmallerEqThanTeam(2, t, pl))
+	}
+	if ((teambits & BIT(1)) != 0)
+	{
 		RandomSelection_AddFloat(2, 1, 1);
-	if(t == 3 || TeamSmallerEqThanTeam(3, t, pl))
+	}
+	if ((teambits & BIT(2)) != 0)
+	{
 		RandomSelection_AddFloat(3, 1, 1);
-	if(t == 4 || TeamSmallerEqThanTeam(4, t, pl))
+	}
+	if ((teambits & BIT(3)) != 0)
+	{
 		RandomSelection_AddFloat(4, 1, 1);
-
+	}
 	return RandomSelection_chosen_float;
 }
 
 int JoinBestTeam(entity this, bool only_return_best, bool forcebestteam)
 {
-	float smallest, selectedteam;
-
 	// don't join a team if we're not playing a team game
-	if(!teamplay)
+	if (!teamplay)
+	{
 		return 0;
+	}
 
 	// find out what teams are available
 	CheckAllowedTeams(this);
 
+	float selectedteam;
+
 	// if we don't care what team he ends up on, put him on whatever team he entered as.
 	// if he's not on a valid team, then let other code put him on the smallest team
-	if(!forcebestteam)
+	if (!forcebestteam)
 	{
 		if(     c1 >= 0 && this.team == NUM_TEAM_1)
 			selectedteam = this.team;
@@ -546,11 +763,11 @@ int JoinBestTeam(entity this, bool only_return_best, bool forcebestteam)
 		else
 			selectedteam = -1;
 
-		if(selectedteam > 0)
+		if (selectedteam > 0)
 		{
-			if(!only_return_best)
+			if (!only_return_best)
 			{
-				SetPlayerColors(this, selectedteam - 1);
+				SetPlayerTeamSimple(this, selectedteam);
 
 				// when JoinBestTeam is called by client.qc/ClientKill_Now_TeamChange the players team is -1 and thus skipped
 				// when JoinBestTeam is called by client.qc/ClientConnect the player_id is 0 the log attempt is rejected
@@ -561,45 +778,35 @@ int JoinBestTeam(entity this, bool only_return_best, bool forcebestteam)
 		// otherwise end up on the smallest team (handled below)
 	}
 
-	smallest = FindSmallestTeam(this, true);
-
-	if(!only_return_best && !this.bot_forced_team)
+	float bestteam = FindSmallestTeam(this, true);
+	if (only_return_best || this.bot_forced_team)
 	{
-		TeamchangeFrags(this);
-		if(smallest == 1)
-		{
-			SetPlayerColors(this, NUM_TEAM_1 - 1);
-		}
-		else if(smallest == 2)
-		{
-			SetPlayerColors(this, NUM_TEAM_2 - 1);
-		}
-		else if(smallest == 3)
-		{
-			SetPlayerColors(this, NUM_TEAM_3 - 1);
-		}
-		else if(smallest == 4)
-		{
-			SetPlayerColors(this, NUM_TEAM_4 - 1);
-		}
-		else
-		{
-			error("smallest team: invalid team\n");
-		}
-
-		LogTeamchange(this.playerid, this.team, 2); // log auto join
-
-		if(!IS_DEAD(this))
-			Damage(this, this, this, 100000, DEATH_TEAMCHANGE.m_id, this.origin, '0 0 0');
+		return bestteam;
 	}
-
-	return smallest;
+	bestteam = Team_NumberToTeam(bestteam);
+	if (bestteam == -1)
+	{
+		error("JoinBestTeam: invalid team\n");
+	}
+	int oldteam = Team_TeamToNumber(this.team);
+	TeamchangeFrags(this);
+	SetPlayerTeamSimple(this, bestteam);
+	LogTeamchange(this.playerid, this.team, 2); // log auto join
+	if (!IS_BOT_CLIENT(this))
+	{
+		AutoBalanceBots(oldteam, Team_TeamToNumber(bestteam));
+	}
+	if (!IS_DEAD(this) && (MUTATOR_CALLHOOK(Player_ChangeTeamKill, this) ==
+		false))
+	{
+		Damage(this, this, this, 100000, DEATH_TEAMCHANGE.m_id, this.origin, '0 0 0');
+	}
+	return bestteam;
 }
 
-//void() ctf_playerchanged;
 void SV_ChangeTeam(entity this, float _color)
 {
-	float scolor, dcolor, steam, dteam; //, dbotcount, scount, dcount;
+	float sourcecolor, destinationcolor, sourceteam, destinationteam;
 
 	// in normal deathmatch we can just apply the color and we're done
 	if(!teamplay)
@@ -615,38 +822,23 @@ void SV_ChangeTeam(entity this, float _color)
 	if(!teamplay)
 		return;
 
-	scolor = this.clientcolors & 0x0F;
-	dcolor = _color & 0x0F;
-
-	if(scolor == NUM_TEAM_1 - 1)
-		steam = 1;
-	else if(scolor == NUM_TEAM_2 - 1)
-		steam = 2;
-	else if(scolor == NUM_TEAM_3 - 1)
-		steam = 3;
-	else // if(scolor == NUM_TEAM_4 - 1)
-		steam = 4;
-	if(dcolor == NUM_TEAM_1 - 1)
-		dteam = 1;
-	else if(dcolor == NUM_TEAM_2 - 1)
-		dteam = 2;
-	else if(dcolor == NUM_TEAM_3 - 1)
-		dteam = 3;
-	else // if(dcolor == NUM_TEAM_4 - 1)
-		dteam = 4;
+	sourcecolor = this.clientcolors & 0x0F;
+	destinationcolor = _color & 0x0F;
 
+	sourceteam = Team_TeamToNumber(sourcecolor + 1);
+	destinationteam = Team_TeamToNumber(destinationcolor + 1);
+	
 	CheckAllowedTeams(this);
 
-	if(dteam == 1 && c1 < 0) dteam = 4;
-	if(dteam == 4 && c4 < 0) dteam = 3;
-	if(dteam == 3 && c3 < 0) dteam = 2;
-	if(dteam == 2 && c2 < 0) dteam = 1;
+	if (destinationteam == 1 && c1 < 0) destinationteam = 4;
+	if (destinationteam == 4 && c4 < 0) destinationteam = 3;
+	if (destinationteam == 3 && c3 < 0) destinationteam = 2;
+	if (destinationteam == 2 && c2 < 0) destinationteam = 1;
 
 	// not changing teams
-	if(scolor == dcolor)
+	if (sourcecolor == destinationcolor)
 	{
-		//bprint("same team change\n");
-		SetPlayerTeam(this, dteam, steam, true);
+		SetPlayerTeam(this, destinationteam, sourceteam, true);
 		return;
 	}
 
@@ -656,34 +848,112 @@ void SV_ChangeTeam(entity this, float _color)
 	}
 
 	// autocvar_g_balance_teams_prevent_imbalance only makes sense if autocvar_g_balance_teams is on, as it makes the team selection dialog pointless
-	if(autocvar_g_balance_teams && autocvar_g_balance_teams_prevent_imbalance)
+	if (autocvar_g_balance_teams && autocvar_g_balance_teams_prevent_imbalance)
 	{
 		GetTeamCounts(this);
-		if(!TeamSmallerEqThanTeam(dteam, steam, this))
+		if ((BIT(destinationteam - 1) & FindBestTeams(this, false)) == 0)
 		{
 			Send_Notification(NOTIF_ONE, this, MSG_INFO, INFO_TEAMCHANGE_LARGERTEAM);
 			return;
 		}
 	}
-
-//	bprint("allow change teams from ", ftos(steam), " to ", ftos(dteam), "\n");
-
-	if(IS_PLAYER(this) && steam != dteam)
+	if(IS_PLAYER(this) && sourceteam != destinationteam)
 	{
 		// reduce frags during a team change
 		TeamchangeFrags(this);
 	}
+	SetPlayerTeam(this, destinationteam, sourceteam, !IS_CLIENT(this));
+	AutoBalanceBots(sourceteam, destinationteam);
+	if (!IS_PLAYER(this) || (sourceteam == destinationteam))
+	{
+		return;
+	}
+	// kill player when changing teams
+	if (IS_DEAD(this) || (MUTATOR_CALLHOOK(Player_ChangeTeamKill, this) == true))
+	{
+		return;
+	}
+	Damage(this, this, this, 100000, DEATH_TEAMCHANGE.m_id, this.origin, '0 0 0');
+}
 
-	MUTATOR_CALLHOOK(Player_ChangeTeam, this, steam, dteam);
-
-	SetPlayerTeam(this, dteam, steam, !IS_CLIENT(this));
-
-	if(IS_PLAYER(this) && steam != dteam)
+void AutoBalanceBots(int sourceteam, int destinationteam)
+{
+	if ((sourceteam == -1) || (destinationteam == -1))
+	{
+		return;
+	}
+	if (!autocvar_g_balance_teams ||
+		!autocvar_g_balance_teams_prevent_imbalance)
+	{
+		return;
+	}
+	int numplayerssourceteam = 0;
+	int numplayersdestinationteam = 0;
+	entity lowestbotdestinationteam = NULL;
+	switch (sourceteam)
+	{
+		case 1:
+		{
+			numplayerssourceteam = c1;
+			break;
+		}
+		case 2:
+		{
+			numplayerssourceteam = c2;
+			break;
+		}
+		case 3:
+		{
+			numplayerssourceteam = c3;
+			break;
+		}
+		case 4:
+		{
+			numplayerssourceteam = c4;
+			break;
+		}
+	}
+	switch (destinationteam)
+	{
+		case 1:
+		{
+			numplayersdestinationteam = c1;
+			lowestbotdestinationteam = lowestbotteam1;
+			break;
+		}
+		case 2:
+		{
+			numplayersdestinationteam = c2;
+			lowestbotdestinationteam = lowestbotteam2;
+			break;
+		}
+		case 3:
+		{
+			numplayersdestinationteam = c3;
+			lowestbotdestinationteam = lowestbotteam3;
+			break;
+		}
+		case 4:
+		{
+			numplayersdestinationteam = c4;
+			lowestbotdestinationteam = lowestbotteam4;
+			break;
+		}
+	}
+	if ((numplayersdestinationteam <= numplayerssourceteam) ||
+		(lowestbotdestinationteam == NULL))
 	{
-		// kill player when changing teams
-		if(!IS_DEAD(this))
-			Damage(this, this, this, 100000, DEATH_TEAMCHANGE.m_id, this.origin, '0 0 0');
+		return;
+	}
+	SetPlayerTeamSimple(lowestbotdestinationteam, Team_NumberToTeam(sourceteam));
+	if (IS_DEAD(lowestbotdestinationteam) || (MUTATOR_CALLHOOK(
+		Player_ChangeTeamKill, lowestbotdestinationteam) == true))
+	{
+		return;
 	}
+	Damage(lowestbotdestinationteam, lowestbotdestinationteam,
+		lowestbotdestinationteam, 100000, DEATH_TEAMCHANGE.m_id,
+		lowestbotdestinationteam.origin, '0 0 0');
 }
 
 void ShufflePlayerOutOfTeam (float source_team)
@@ -818,7 +1088,10 @@ void ShufflePlayerOutOfTeam (float source_team)
 	TeamchangeFrags(selected);
 	SetPlayerTeam(selected, smallestteam, source_team, false);
 
-	if(!IS_DEAD(selected))
-		Damage(selected, selected, selected, 100000, DEATH_AUTOTEAMCHANGE.m_id, selected.origin, '0 0 0');
+	if (IS_DEAD(selected) || MUTATOR_CALLHOOK(Player_ChangeTeamKill, selected) == true)
+	{
+		return;
+	}
+	Damage(selected, selected, selected, 100000, DEATH_AUTOTEAMCHANGE.m_id, selected.origin, '0 0 0');
 	Send_Notification(NOTIF_ONE, selected, MSG_CENTER, CENTER_DEATH_SELF_AUTOTEAMCHANGE, selected.team);
 }