This graph shows which files directly or indirectly include this file:

Enumerations
enum	{ TEAM_CHANGE_AUTO = 2 , TEAM_CHANGE_MANUAL = 3 , TEAM_CHANGE_SPECTATOR = 4 }
enum	{ TEAMS_COMPARE_INVALID , TEAMS_COMPARE_LESS , TEAMS_COMPARE_EQUAL , TEAMS_COMPARE_GREATER }
	Describes the result of comparing teams. More...
enum	{ TEAM_FORCE_SPECTATOR = -1 , TEAM_FORCE_DEFAULT = 0 }

Functions
entity	Entity_GetTeam (entity this)
	Returns the team entity of the given entity.
int	Entity_GetTeamIndex (entity this)
	Returns the team index of the given entity.
bool	Entity_HasValidTeam (entity this)
	Returns whether the given entity belongs to a valid team.
void	KillPlayerForTeamChange (entity player)
	Kills player as a result of team change.
void	LogTeamChange (float player_id, float team_number, int type)
bool	MoveToTeam (entity client, int team_index, int type)
	Moves player to the specified team.
void	Player_DetermineForcedTeam (entity player)
	Determines the forced team of the player using current global config.
int	Player_GetForcedTeamIndex (entity player)
	Returns the index of the forced team of the given player.
bool	Player_HasRealForcedTeam (entity player)
	Returns whether player has real forced team.
void	Player_SetForcedTeamIndex (entity player, int team_index)
	Sets the index of the forced team of the given player.
bool	Player_SetTeamIndex (entity player, int index)
	Sets the team of the player using its index.
bool	QueuedPlayersReady (entity this, bool checkspecificteam)
	Returns true when enough players are queued that the next will join directly to the only available team (also triggering the joins of the queued players).
bool	QueueNeeded (entity ignore)
void	setcolor (entity this, int clr)
void	SetPlayerColors (entity player, float _color)
bool	SetPlayerTeam (entity player, int team_index, int type)
	Sets the team of the player.
void	SV_ChangeTeam (entity player, int new_color)
	Called when the player changes color with the "color" command.
int	Team_GetNumberOfAlivePlayers (entity team_ent)
	Returns the number of alive players in a team.
int	Team_GetNumberOfAliveTeams ()
	Returns the number of alive teams.
int	Team_GetNumberOfOwnedItems (entity team_ent)
	Returns the number of items owned by a team.
int	Team_GetNumberOfTeamsWithOwnedItems ()
	Returns the number of teams that own items.
entity	Team_GetTeam (int team_num)
	Returns the global team entity that corresponds to the given TEAM_NUM value.
entity	Team_GetTeamFromIndex (int index)
	Returns the global team entity at the given index.
float	Team_GetTeamScore (entity team_ent)
	Returns the score of the team.
int	Team_GetWinnerAliveTeam ()
	Returns the winner team.
int	Team_GetWinnerTeam_WithOwnedItems (int min_owned_items)
	Returns the winner team.
void	Team_InitTeams ()
void	Team_SetNumberOfAlivePlayers (entity team_ent, int number)
	Sets the number of alive players in a team.
void	Team_SetNumberOfOwnedItems (entity team_ent, int number)
	Sets the number of items owned by a team.
void	Team_SetTeamScore (entity team_ent, float score)
	Sets the score of the team.
bool	TeamBalance_AreEqual (entity ignore, bool would_leave)
void	TeamBalance_AutoBalanceBots ()
	Switches a bot from one team to another if teams are not balanced.
void	TeamBalance_BanTeamsExcept (entity balance, int index)
	Bans team change to all teams except the given one.
entity	TeamBalance_CheckAllowedTeams (entity for_whom)
	Checks whether the player can join teams according to global configuration and mutator settings.
int	TeamBalance_CompareTeams (entity balance, int team_index_a, int team_index_b, entity player, bool use_score)
	Compares two teams for the purposes of game balance.
int	TeamBalance_CompareTeamsInternal (entity team_a, entity team_index_b, entity player, bool use_score)
	Compares two teams for the purposes of game balance.
void	TeamBalance_Destroy (entity balance)
	Destroy the team balance entity.
int	TeamBalance_FindBestTeam (entity balance, entity player, bool ignore_player)
	Finds the team that will make the game most balanced if the player joins it.
int	TeamBalance_FindBestTeams (entity balance, entity player, bool use_score)
	Returns the bitmask of the teams that will make the game most balanced if the player joins any of them.
int	TeamBalance_GetAllowedTeams (entity balance)
	Returns the bitmask of allowed teams.
int	TeamBalance_GetLargestTeamIndex (entity balance, int teams)
	Returns the index of the team with most players that is contained in the given bitmask of teams.
int	TeamBalance_GetNumberOfPlayers (entity balance, int index)
	Returns the number of players (both humans and bots) in a team.
entity	TeamBalance_GetPlayerForTeamSwitch (int source_team_index, int destination_team_index, bool is_bot)
	Returns the player who is the most suitable for switching between the given teams.
entity	TeamBalance_GetTeam (entity balance, int team_num)
	Returns the team entity of the team balance entity that corresponds to the given TEAM_NUM value.
void	TeamBalance_GetTeamCounts (entity balance, entity ignore)
	Counts the number of players and various other information about each team.
entity	TeamBalance_GetTeamFromIndex (entity balance, int index)
	Returns the team entity of the team balance entity at the given index.
bool	TeamBalance_IsTeamAllowed (entity balance, int index)
	Returns whether the team change to the specified team is allowed.
bool	TeamBalance_IsTeamAllowedInternal (entity balance, int index)
	Returns whether the team change to the specified team is allowed.
void	TeamBalance_JoinBestTeam (entity player)
	Assigns the given player to a team that will make the game most balanced.
bool	TeamBalance_QueuedPlayersTagIn (entity ignore)
	Joins queued player(s) to team(s) with a shortage, this should be more robust than only replacing the player that left.
void	TeamBalance_RemoveExcessPlayers (entity ignore)
int	TeamBalance_SizeDifference (entity ignore)
	Returns the size difference between the largest and smallest team (bots included).
int	TeamBalanceTeam_GetNumberOfBots (entity team_ent)
	Returns the number of bots in a team.
int	TeamBalanceTeam_GetNumberOfPlayers (entity team_ent)
	Returns the number of players (both humans and bots) in a team.
bool	TeamBalanceTeam_IsAllowed (entity team_ent)
	Returns whether the team is allowed.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
TEAM_CHANGE_AUTO	The team was selected by autobalance.
TEAM_CHANGE_MANUAL	Player has manually selected their team.
TEAM_CHANGE_SPECTATOR	Player is joining spectators. //TODO: Remove?

Definition at line 112 of file teamplay.qh.

{
    TEAM_CHANGE_AUTO = 2, 
    TEAM_CHANGE_MANUAL = 3, 
    TEAM_CHANGE_SPECTATOR = 4 
};

◆ anonymous enum

anonymous enum

Describes the result of comparing teams.

Enumerator
TEAMS_COMPARE_INVALID	One or both teams are invalid.
TEAMS_COMPARE_LESS	First team is less than the second one.
TEAMS_COMPARE_EQUAL	Both teams are equal.
TEAMS_COMPARE_GREATER	First team the greater than the second one.

Definition at line 245 of file teamplay.qh.

{
    TEAMS_COMPARE_INVALID, 
    TEAMS_COMPARE_LESS, 
    TEAMS_COMPARE_EQUAL, 
    TEAMS_COMPARE_GREATER 
};

◆ anonymous enum

anonymous enum

Enumerator
TEAM_FORCE_SPECTATOR	Force the player to spectator team.
TEAM_FORCE_DEFAULT	Don't force any team.

Definition at line 135 of file teamplay.qh.

{
    TEAM_FORCE_SPECTATOR = -1, 
    TEAM_FORCE_DEFAULT = 0 
};

Function Documentation

◆ Entity_GetTeam()

entity Entity_GetTeam ( entity this )

Returns the team entity of the given entity.

Parameters

[in] this Entity to check.

Returns: Team entity of the given entity or NULL if the entity doesn't belong to any team.

Definition at line 186 of file teamplay.qc.

{
    int index = Entity_GetTeamIndex(this);
    if (!Team_IsValidIndex(index))
    {
        return NULL;
    }
    return Team_GetTeamFromIndex(index);
}

References entity(), Entity_GetTeamIndex(), NULL, Team_GetTeamFromIndex(), and Team_IsValidIndex().

Referenced by CA_count_alive_players(), Domination_count_controlpoints(), freezetag_count_alive_players(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), and Onslaught_count_generators().

◆ Entity_GetTeamIndex()

int Entity_GetTeamIndex ( entity this )

Returns the team index of the given entity.

Parameters

[in] this Entity to check.

Returns: Team index of the entity.

Definition at line 181 of file teamplay.qc.

{
    return Team_TeamToIndex(this.team);
}

References entity(), team, and Team_TeamToIndex().

Referenced by Entity_GetTeam(), SetPlayerTeam(), shuffleteams(), and TeamBalance_GetPlayerForTeamSwitch().

◆ Entity_HasValidTeam()

bool Entity_HasValidTeam ( entity this )

Returns whether the given entity belongs to a valid team.

Parameters

[in] this Entity to check.

Returns: True if entity belongs to a valid team, false otherwise.

Definition at line 176 of file teamplay.qc.

{
    return Team_IsValidTeam(this.team);
}

References entity(), team, and Team_IsValidTeam().

Referenced by CA_count_alive_players(), CA_PreventStalemate(), Domination_count_controlpoints(), and freezetag_count_alive_players().

◆ KillPlayerForTeamChange()

void KillPlayerForTeamChange ( entity player )

Kills player as a result of team change.

Parameters

[in,out] player Player to kill.

Definition at line 1213 of file teamplay.qc.

{
    if (IS_DEAD(player))
    {
        return;
    }
    if (MUTATOR_CALLHOOK(Player_ChangeTeamKill, player) == true)
    {
        return;
    }
    Damage(player, player, player, 100000, DEATH_TEAMCHANGE.m_id, DMG_NOWEP,
        player.origin, '0 0 0');
}

References Damage(), DMG_NOWEP, entity(), IS_DEAD, and MUTATOR_CALLHOOK.

Referenced by SetPlayerTeam().

◆ LogTeamChange()

void LogTeamChange	(	float	player_id,
		float	team_number,
		int	type )

Definition at line 1200 of file teamplay.qc.

{
    if (!autocvar_sv_eventlog)
    {
        return;
    }
    if (player_id < 1)
    {
        return;
    }
    GameLogEcho(sprintf(":team:%d:%d:%d", player_id, team_number, type));
}

References autocvar_sv_eventlog, and GameLogEcho().

Referenced by SetPlayerTeam().

◆ MoveToTeam()

bool MoveToTeam	(	entity	client,
		int	team_index,
		int	type )

Moves player to the specified team.

Parameters

[in,out]	client	Client to move.
[in]	team_index	Index of the team.
[in]	type	???

Returns: True on success, false otherwise.

Definition at line 299 of file teamplay.qc.

{
    //PrintToChatAll(sprintf("MoveToTeam: %s, %f", client.netname, team_index));
    int lockteams_backup = lockteams;  // backup any team lock
    lockteams = 0;  // disable locked teams
    if (!SetPlayerTeam(client, team_index, type))
    {
        lockteams = lockteams_backup;  // restore the team lock
        return false;
    }
    lockteams = lockteams_backup;  // restore the team lock
    return true;
}

References entity(), lockteams, and SetPlayerTeam().

Referenced by GameCommand_moveplayer(), MatchEnd_RestoreSpectatorAndTeamStatus(), and shuffleteams().

◆ Player_DetermineForcedTeam()

void Player_DetermineForcedTeam ( entity player )

Determines the forced team of the player using current global config.

Parameters

[in,out] player Player to adjust.

Definition at line 348 of file teamplay.qc.

{
    if (autocvar_g_campaign)
    {
        if (IS_REAL_CLIENT(player)) // only players, not bots
        {
            if (Team_IsValidIndex(autocvar_g_campaign_forceteam))
            {
                player.team_forced = autocvar_g_campaign_forceteam;
            }
            else
            {
                player.team_forced = TEAM_FORCE_DEFAULT;
            }
        }
    }
    else if (PlayerInList(player, autocvar_g_forced_team_red))
    {
        player.team_forced = 1;
    }
    else if (PlayerInList(player, autocvar_g_forced_team_blue))
    {
        player.team_forced = 2;
    }
    else if (PlayerInList(player, autocvar_g_forced_team_yellow))
    {
        player.team_forced = 3;
    }
    else if (PlayerInList(player, autocvar_g_forced_team_pink))
    {
        player.team_forced = 4;
    }
    else
    {
        switch (autocvar_g_forced_team_otherwise)
        {
            case "red":
            {
                player.team_forced = 1;
                break;
            }
            case "blue":
            {
                player.team_forced = 2;
                break;
            }
            case "yellow":
            {
                player.team_forced = 3;
                break;
            }
            case "pink":
            {
                player.team_forced = 4;
                break;
            }
            case "spectate":
            case "spectator":
            {
                player.team_forced = TEAM_FORCE_SPECTATOR;
                break;
            }
            default:
            {
                player.team_forced = TEAM_FORCE_DEFAULT;
                break;
            }
        }
    }
    if (!teamplay && Player_HasRealForcedTeam(player))
    {
        player.team_forced = TEAM_FORCE_DEFAULT;
    }
}

References autocvar_g_campaign, autocvar_g_campaign_forceteam, autocvar_g_forced_team_blue, autocvar_g_forced_team_otherwise, autocvar_g_forced_team_pink, autocvar_g_forced_team_red, autocvar_g_forced_team_yellow, entity(), IS_REAL_CLIENT, Player_HasRealForcedTeam(), PlayerInList(), TEAM_FORCE_DEFAULT, TEAM_FORCE_SPECTATOR, Team_IsValidIndex(), and teamplay.

Referenced by ClientConnect().

◆ Player_GetForcedTeamIndex()

int Player_GetForcedTeamIndex ( entity player )

Returns the index of the forced team of the given player.

Parameters

[in] player Player to check.

Returns: Index of the forced team.

Definition at line 318 of file teamplay.qc.

{
    return player.team_forced;
}

References entity().

Referenced by ClientCommand_clientversion(), ClientCommand_selectteam(), GameCommand_moveplayer(), joinAllowed(), and PlayerPreThink().

◆ Player_HasRealForcedTeam()

bool Player_HasRealForcedTeam ( entity player )

Returns whether player has real forced team.

Spectator team is ignored.

Parameters

[in] player Player to check.

Returns: True if player has real forced team, false otherwise.

Definition at line 313 of file teamplay.qc.

{
    return player.team_forced > TEAM_FORCE_DEFAULT;
}

References entity(), and TEAM_FORCE_DEFAULT.

Referenced by Player_DetermineForcedTeam(), ShowTeamSelection(), shuffleteams(), TeamBalance_GetTeamCounts(), and TeamBalance_JoinBestTeam().

◆ Player_SetForcedTeamIndex()

void Player_SetForcedTeamIndex	(	entity	player,
		int	team_index )

Sets the index of the forced team of the given player.

Parameters

[in,out]	player	Player to adjust.
[in]	team_index	Index of the team to set.

Definition at line 323 of file teamplay.qc.

{
    switch (team_index)
    {
        case TEAM_FORCE_SPECTATOR:
        case TEAM_FORCE_DEFAULT:
        {
            player.team_forced = team_index;
            break;
        }
        default:
        {
            if (!Team_IsValidIndex(team_index))
            {
                LOG_FATAL("Invalid team index.");
            }
            else
            {
                player.team_forced = team_index;
                break;
            }
        }
    }
}

References entity(), LOG_FATAL, TEAM_FORCE_DEFAULT, TEAM_FORCE_SPECTATOR, and Team_IsValidIndex().

Referenced by GameCommand_moveplayer(), MatchEnd_RestoreSpectatorAndTeamStatus(), minigame_addplayer(), and player_clear_minigame().

◆ Player_SetTeamIndex()

bool Player_SetTeamIndex	(	entity	player,
		int	index )

Sets the team of the player using its index.

Parameters

[in,out]	player	Player to adjust.
[in]	index	Index of the team to set.

Returns: True if team switch was successful, false otherwise.

Definition at line 210 of file teamplay.qc.

{
    int new_team = Team_IndexToTeam(index);
    if (player.team == new_team)
        return true;
 
    int old_index = Team_TeamToIndex(player.team);
    if (MUTATOR_CALLHOOK(Player_ChangeTeam, player, old_index, index) == true)
    {
        // Mutator has blocked team change.
        return false;
    }
    if (new_team == -1)
    {
        player.team = -1;
    }
    else
    {
        SetPlayerColors(player, new_team - 1);
    }
    MUTATOR_CALLHOOK(Player_ChangedTeam, player, old_index, index);
    return true;
}

References entity(), MUTATOR_CALLHOOK, SetPlayerColors(), Team_IndexToTeam(), and Team_TeamToIndex().

Referenced by SetPlayerTeam().

◆ QueuedPlayersReady()

bool QueuedPlayersReady	(	entity	this,
		bool	checkspecificteam )

Returns true when enough players are queued that the next will join directly to the only available team (also triggering the joins of the queued players).

Optionally only counts players who selected a specific team when joining the queue.

Definition at line 238 of file teamplay.qc.

{
    int numplayersqueued = 0;
 
    FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != this
    && (checkspecificteam ? it.wants_join > 0 : it.wants_join),
    {
        LOG_DEBUGF("Player %s is waiting to join team %d", it.netname, it.wants_join);
        ++numplayersqueued;
        if (numplayersqueued >= AVAILABLE_TEAMS - 1)
            return true;
    });
 
    LOG_DEBUG("No players waiting to join.");
    return false;
}

References entity(), FOREACH_CLIENT, IS_REAL_CLIENT, and LOG_DEBUG.

Referenced by ShowTeamSelection().

◆ QueueNeeded()

bool QueueNeeded ( entity ignore )

Definition at line 1325 of file teamplay.qc.

{
    if (!teamplay || warmup_stage || !autocvar_g_balance_teams_queue || autocvar_g_campaign || ignore.team > 0)
        return false;
 
    int human_clients = 0;
    FOREACH_CLIENT(IS_REAL_CLIENT(it),
    {
        if (++human_clients > 1)
            return TeamBalance_AreEqual(ignore, true);
    });
    return false;
}

References autocvar_g_balance_teams_queue, autocvar_g_campaign, entity(), FOREACH_CLIENT, IS_REAL_CLIENT, TeamBalance_AreEqual(), teamplay, and warmup_stage.

Referenced by joinAllowed().

◆ setcolor()

void setcolor	(	entity	this,
		int	clr )

Definition at line 161 of file teamplay.qc.

{
#if 1
    this.clientcolors = clr;
    if(teamplay)
        this.team = (clr & 15) + 1;
    else
        this.team = -1;
#else
    // sets clientcolors and team (even in FFA games)
    // and sends notification to all clients
    builtin_setcolor(this, clr);
#endif
}

References clientcolors, entity(), team, and teamplay.

◆ SetPlayerColors()

void SetPlayerColors	(	entity	player,
		float	_color )

Definition at line 196 of file teamplay.qc.

{
    float pants = _color & 0x0F;
    float shirt = _color & 0xF0;
    if (teamplay)
    {
        setcolor(player, 16 * pants + pants);
    }
    else
    {
        setcolor(player, shirt + pants);
    }
}

References entity(), setcolor, and teamplay.

Referenced by Player_SetTeamIndex(), and SV_ChangeTeam().

◆ SetPlayerTeam()

bool SetPlayerTeam	(	entity	player,
		int	team_index,
		int	type )

Sets the team of the player.

Parameters

[in,out]	player	Player to adjust.
[in]	team_index	Index of the team to set.
[in]	type	Type of the team change. See TEAM_CHANGE constants.

Returns: True if team switch was successful, false otherwise.

Definition at line 255 of file teamplay.qc.

{
    int old_team_index = Entity_GetTeamIndex(player);
 
    if (!Player_SetTeamIndex(player, team_index))
        return false;
 
    LogTeamChange(player.playerid, player.team, type);
 
    if (team_index != old_team_index)
    {
        KillPlayerForTeamChange(player);
        PlayerScore_Clear(player); // works only in gametypes without teams
 
        if (!IS_BOT_CLIENT(player))
            TeamBalance_AutoBalanceBots();
 
        if (team_index != -1)
        {
            Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(player.team, INFO_JOIN_PLAY_TEAM), player.netname);
            player.team_selected = team_index; // no autoselect in Join()
 
            if (warmup_stage)
                ReadyCount(); // teams might be balanced now
        }
    }
 
    if (team_index == -1)
    {
        if (autocvar_sv_maxidle_playertospectator > 0 && CS(player).idlekick_lasttimeleft)
        {
            // this done here so it happens even when manually speccing during the countdown
            Kill_Notification(NOTIF_ONE_ONLY, player, MSG_CENTER, CPID_IDLING);
            CS(player).idlekick_lasttimeleft = 0;
        }
        else if (!CS(player).just_joined && player.frags != FRAGS_SPECTATOR)
        {
            Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_QUIT_SPECTATE, player.netname);
        }
    }
 
    return true;
}

References APP_TEAM_NUM, autocvar_sv_maxidle_playertospectator, CPID_IDLING, CS(), entity(), Entity_GetTeamIndex(), FRAGS_SPECTATOR, IS_BOT_CLIENT, just_joined, Kill_Notification(), KillPlayerForTeamChange(), LogTeamChange(), NULL, Player_SetTeamIndex(), PlayerScore_Clear(), ReadyCount(), Send_Notification(), TeamBalance_AutoBalanceBots(), and warmup_stage.

Referenced by ClientKill_Now_TeamChange(), MoveToTeam(), PutObserverInServer(), PutPlayerInServer(), TeamBalance_AutoBalanceBots(), and TeamBalance_JoinBestTeam().

◆ SV_ChangeTeam()

void SV_ChangeTeam	(	entity	player,
		int	new_color )

Called when the player changes color with the "color" command.

Note: the "color" command is always called early on player connection

Parameters

[in,out]	player	Player that requested a new color.
[in]	new_color	Requested color.

Definition at line 1319 of file teamplay.qc.

{
    if (!teamplay)
        SetPlayerColors(player, new_color);
}

References entity(), SetPlayerColors(), and teamplay.

◆ Team_GetNumberOfAlivePlayers()

int Team_GetNumberOfAlivePlayers ( entity team_ent )

Returns the number of alive players in a team.

Parameters

[in] team_ent Team entity.

Returns: Number of alive players in a team.

Definition at line 85 of file teamplay.qc.

{
    return team_ent.m_num_players_alive;
}

References entity().

Referenced by CA_CheckTeams(), CA_count_alive_players(), CA_PreventStalemate(), freezetag_CheckTeams(), freezetag_count_alive_players(), MUTATOR_HOOKFUNCTION(), and MUTATOR_HOOKFUNCTION().

◆ Team_GetNumberOfAliveTeams()

int Team_GetNumberOfAliveTeams ( )

Returns the number of alive teams.

Returns: Number of alive teams.

Definition at line 110 of file teamplay.qc.

{
    int result = 0;
    for (int i = 0; i < NUM_TEAMS; ++i)
    {
        if (g_team_entities[i].m_num_players_alive > 0)
        {
            ++result;
        }
    }
    return result;
}

References g_team_entities, m_num_players_alive, NUM_TEAMS, and result.

Referenced by CA_CheckTeams(), and freezetag_CheckTeams().

◆ Team_GetNumberOfOwnedItems()

int Team_GetNumberOfOwnedItems ( entity team_ent )

Returns the number of items owned by a team.

Parameters

[in] team_ent Team entity.

Returns: Number of items owned by a team.

Definition at line 138 of file teamplay.qc.

{
    return team_ent.m_num_owned_items;
}

References entity().

Referenced by Domination_count_controlpoints(), and Onslaught_count_generators().

◆ Team_GetNumberOfTeamsWithOwnedItems()

int Team_GetNumberOfTeamsWithOwnedItems ( )

Returns the number of teams that own items.

Returns: Number of teams that own items.

Definition at line 148 of file teamplay.qc.

{
    int result = 0;
    for (int i = 0; i < NUM_TEAMS; ++i)
    {
        if (g_team_entities[i].m_num_owned_items > 0)
        {
            ++result;
        }
    }
    return result;
}

References g_team_entities, m_num_owned_items, NUM_TEAMS, and result.

◆ Team_GetTeam()

entity Team_GetTeam ( int team_num )

Returns the global team entity that corresponds to the given TEAM_NUM value.

Parameters

[in] team_num Team value. See TEAM_NUM constants.

Returns: Global team entity that corresponds to the given TEAM_NUM value.

Definition at line 66 of file teamplay.qc.

{
    if (!Team_IsValidTeam(team_num))
    {
        LOG_FATALF("Value is invalid: %f", team_num);
    }
    return g_team_entities[Team_TeamToIndex(team_num) - 1];
}

References entity(), g_team_entities, LOG_FATALF, Team_IsValidTeam(), and Team_TeamToIndex().

Referenced by CA_PreventStalemate(), and WinningCondition_RanOutOfSpawns().

◆ Team_GetTeamFromIndex()

entity Team_GetTeamFromIndex ( int index )

Returns the global team entity at the given index.

Parameters

[in] index Index of the team.

Returns: Global team entity at the given index.

Definition at line 57 of file teamplay.qc.

{
    if (!Team_IsValidIndex(index))
    {
        LOG_FATALF("Index is invalid: %f", index);
    }
    return g_team_entities[index - 1];
}

References entity(), g_team_entities, LOG_FATALF, and Team_IsValidIndex().

Referenced by CA_CheckTeams(), CA_count_alive_players(), CA_PreventStalemate(), Domination_count_controlpoints(), Entity_GetTeam(), freezetag_CheckTeams(), freezetag_count_alive_players(), Onslaught_count_generators(), WinningCondition_RanOutOfSpawns(), and WinningCondition_Scores().

◆ Team_GetTeamScore()

float Team_GetTeamScore ( entity team_ent )

Returns the score of the team.

Parameters

[in] team_ent Team entity.

Returns: Score of the team.

Definition at line 75 of file teamplay.qc.

{
    return team_ent.m_team_score;
}

References entity().

Referenced by WinningCondition_RanOutOfSpawns().

◆ Team_GetWinnerAliveTeam()

int Team_GetWinnerAliveTeam ( )

Returns the winner team.

Returns: Winner team or 0 if 2 or more teams have alive players or -1 if no team has any alive players.

Definition at line 95 of file teamplay.qc.

{
    int winner = 0;
    for (int i = 0; i < NUM_TEAMS; ++i)
    {
        if (g_team_entities[i].m_num_players_alive > 0)
        {
            if (winner)
                return 0;
            winner = Team_IndexToTeam(i + 1);
        }
    }
    return (winner ? winner : -1);
}

References g_team_entities, m_num_players_alive, NUM_TEAMS, and Team_IndexToTeam().

Referenced by CA_CheckWinner(), and freezetag_CheckWinner().

◆ Team_GetWinnerTeam_WithOwnedItems()

int Team_GetWinnerTeam_WithOwnedItems ( int min_owned_items )

Returns the winner team.

Parameters

[in] min_owned_items Minimum number of items the winner team must have.

Returns: Winner team or 0 if 2 or more teams own items or -1 if no team own any items.

Definition at line 123 of file teamplay.qc.

{
    int winner = 0;
    for (int i = 0; i < NUM_TEAMS; ++i)
    {
        if (g_team_entities[i].m_num_owned_items >= min_control_points)
        {
            if (winner)
                return 0;
            winner = Team_IndexToTeam(i + 1);
        }
    }
    return (winner ? winner : -1);
}

References g_team_entities, m_num_owned_items, NUM_TEAMS, and Team_IndexToTeam().

Referenced by Domination_CheckWinner(), and Onslaught_CheckWinner().

◆ Team_InitTeams()

void Team_InitTeams ( )

Definition at line 47 of file teamplay.qc.

{
    if (g_team_entities[0])
        return;
    for (int i = 0; i < NUM_TEAMS; ++i)
    {
        g_team_entities[i] = new_pure(team_entity);
    }
}

References g_team_entities, new_pure, and NUM_TEAMS.

Referenced by GameRules_teams().

◆ Team_SetNumberOfAlivePlayers()

void Team_SetNumberOfAlivePlayers	(	entity	team_ent,
		int	number )

Sets the number of alive players in a team.

Parameters

[in,out]	team_ent	Team entity.
[in]	number	Number of players to set.

Definition at line 90 of file teamplay.qc.

{
    team_ent.m_num_players_alive = number;
}

References entity(), and number.

Referenced by CA_count_alive_players(), and freezetag_count_alive_players().

◆ Team_SetNumberOfOwnedItems()

void Team_SetNumberOfOwnedItems	(	entity	team_ent,
		int	number )

Sets the number of items owned by a team.

Parameters

[in,out]	team_ent	Team entity.
[in]	number	Number of items to set.

Definition at line 143 of file teamplay.qc.

{
    team_ent.m_num_owned_items = number;
}

References entity(), and number.

Referenced by Domination_count_controlpoints(), and Onslaught_count_generators().

◆ Team_SetTeamScore()

void Team_SetTeamScore	(	entity	team_ent,
		float	score )

Sets the score of the team.

Parameters

[in,out]	team_ent	Team entity.
[in]	score	Score to set.

Definition at line 80 of file teamplay.qc.

{
    team_ent.m_team_score = score;
}

References entity().

Referenced by WinningCondition_RanOutOfSpawns(), and WinningCondition_Scores().

◆ TeamBalance_AreEqual()

bool TeamBalance_AreEqual	(	entity	ignore,
		bool	would_leave )

Definition at line 656 of file teamplay.qc.

{
    entity balance = TeamBalance_CheckAllowedTeams(ignore);
    TeamBalance_GetTeamCounts(balance, ignore);
 
    bool equality = true;
    int total;
    int prev_total = 0;
    int bots = 0;
 
    for(int i = 1; i <= AVAILABLE_TEAMS; ++i)
    {
        total = TeamBalance_GetTeamFromIndex(balance, i).m_num_players;
        bots += TeamBalance_GetTeamFromIndex(balance, i).m_num_bots;
        if(i > 1 && total != prev_total)
        {
            equality = false;
            break;
        }
        prev_total = total;
    }
    TeamBalance_Destroy(balance);
 
    // Ignore if there are "ghost" bots that would leave if anyone joined
    if (would_leave && bots_would_leave)
        return false;
 
    return equality;
}

References AVAILABLE_TEAMS, bots_would_leave, entity(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_GetTeamCounts(), and TeamBalance_GetTeamFromIndex().

Referenced by Join(), QueueNeeded(), and Remove_Countdown().

◆ TeamBalance_AutoBalanceBots()

void TeamBalance_AutoBalanceBots ( )

Switches a bot from one team to another if teams are not balanced.

Definition at line 1059 of file teamplay.qc.

{
    // checks disabled because we always want auto-balanced bots
    //if (!autocvar_g_balance_teams_prevent_imbalance)
    //  return;
 
    if (intermission_running) return;
 
    entity balance = TeamBalance_CheckAllowedTeams(NULL);
    TeamBalance_GetTeamCounts(balance, NULL);
    int smallest_team_index = 0;
    int smallest_team_player_count = 0;
    for (int i = 1; i <= NUM_TEAMS; ++i)
    {
        entity team_ = TeamBalance_GetTeamFromIndex(balance, i);
        if (!TeamBalanceTeam_IsAllowed(team_))
        {
            continue;
        }
        int playercount = TeamBalanceTeam_GetNumberOfPlayers(team_);
        if (smallest_team_index == 0)
        {
            smallest_team_index = i;
            smallest_team_player_count = playercount;
        }
        else if (playercount < smallest_team_player_count)
        {
            smallest_team_index = i;
            smallest_team_player_count = playercount;
        }
    }
    //PrintToChatAll(sprintf("Smallest team: %f", smallest_team_index));
    //PrintToChatAll(sprintf("Smallest team players: %f", smallest_team_player_count));
    entity switchable_bot = NULL;
    int teams = BITS(NUM_TEAMS);
    while (teams != 0)
    {
        int largest_team_index = TeamBalance_GetLargestTeamIndex(balance,
            teams);
        if (smallest_team_index == largest_team_index)
        {
            TeamBalance_Destroy(balance);
            return;
        }
        entity largest_team = TeamBalance_GetTeamFromIndex(balance,
            largest_team_index);
        int largest_team_player_count = TeamBalanceTeam_GetNumberOfPlayers(
            largest_team);
        if (largest_team_player_count - smallest_team_player_count < 2)
        {
            TeamBalance_Destroy(balance);
            return;
        }
        //PrintToChatAll(sprintf("Largest team: %f", largest_team_index));
        //PrintToChatAll(sprintf("Largest team players: %f", largest_team_player_count));
        switchable_bot = TeamBalance_GetPlayerForTeamSwitch(largest_team_index,
            smallest_team_index, true);
        if (switchable_bot != NULL)
        {
            break;
        }
        teams &= ~Team_IndexToBit(largest_team_index);
    }
    TeamBalance_Destroy(balance);
    if (switchable_bot == NULL)
    {
        //PrintToChatAll("No bot found after searching through all the teams");
        return;
    }
    SetPlayerTeam(switchable_bot, smallest_team_index, TEAM_CHANGE_AUTO);
}

References BITS, entity(), intermission_running, NULL, NUM_TEAMS, SetPlayerTeam(), TEAM_CHANGE_AUTO, Team_IndexToBit(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_GetLargestTeamIndex(), TeamBalance_GetPlayerForTeamSwitch(), TeamBalance_GetTeamCounts(), TeamBalance_GetTeamFromIndex(), TeamBalanceTeam_GetNumberOfPlayers(), TeamBalanceTeam_IsAllowed(), and teams.

Referenced by SetPlayerTeam().

◆ TeamBalance_BanTeamsExcept()

void TeamBalance_BanTeamsExcept	(	entity	balance,
		int	index )

Bans team change to all teams except the given one.

Parameters

[in,out]	balance	Team balance entity.
[in]	index	Index of the team.

Definition at line 1233 of file teamplay.qc.

{
    for (int i = 1; i <= NUM_TEAMS; ++i)
    {
        if (i != index)
        {
            balance.m_team_balance_team[i - 1].m_num_players = TEAM_NOT_ALLOWED;
        }
    }
}

References entity(), NUM_TEAMS, and TEAM_NOT_ALLOWED.

Referenced by TeamBalance_CheckAllowedTeams().

◆ TeamBalance_CheckAllowedTeams()

entity TeamBalance_CheckAllowedTeams ( entity for_whom )

Checks whether the player can join teams according to global configuration and mutator settings.

Parameters

[in] for_whom Player to check for. Pass NULL for global rules.

Returns: Team balance entity that holds information about teams. This entity will be automatically destroyed on the next frame but you are encouraged to manually destroy it by calling TeamBalance_Destroy for performance reasons.

Definition at line 459 of file teamplay.qc.

{
    entity balance = spawn();
    for (int i = 0; i < NUM_TEAMS; ++i)
    {
        entity team_ent = balance.m_team_balance_team[i] = spawn();
        team_ent.m_team_score = g_team_entities[i].m_team_score;
        team_ent.m_num_players = TEAM_NOT_ALLOWED;
        team_ent.m_num_bots = 0;
    }
    setthink(balance, TeamBalance_Destroy);
    balance.nextthink = time;
 
    int teams_mask = 0;
    string teament_name = string_null;
    bool mutator_returnvalue = MUTATOR_CALLHOOK(TeamBalance_CheckAllowedTeams,
        teams_mask, teament_name, for_whom);
    teams_mask = M_ARGV(0, float);
    teament_name = M_ARGV(1, string);
    if (mutator_returnvalue)
    {
        for (int i = 0; i < NUM_TEAMS; ++i)
        {
            if (teams_mask & BIT(i))
            {
                balance.m_team_balance_team[i].m_num_players = 0;
            }
        }
    }
 
    if (teament_name)
    {
        entity head = find(NULL, classname, teament_name);
        while (head)
        {
            if (Team_IsValidTeam(head.team))
            {
                TeamBalance_GetTeam(balance, head.team).m_num_players = 0;
            }
            head = find(head, classname, teament_name);
        }
    }
 
    // TODO: Balance quantity of bots across > 2 teams when bot_vs_human is set (and remove next line)
    if (autocvar_bot_vs_human && AVAILABLE_TEAMS == 2 && for_whom)
    {
        if (autocvar_bot_vs_human > 0)
        {
            // find last team available
            if (IS_BOT_CLIENT(for_whom))
            {
                if (TeamBalance_IsTeamAllowedInternal(balance, 4))
                {
                    TeamBalance_BanTeamsExcept(balance, 4);
                }
                else if (TeamBalance_IsTeamAllowedInternal(balance, 3))
                {
                    TeamBalance_BanTeamsExcept(balance, 3);
                }
                else
                {
                    TeamBalance_BanTeamsExcept(balance, 2);
                }
                // no further cases, we know at least 2 teams exist
            }
            else
            {
                if (TeamBalance_IsTeamAllowedInternal(balance, 1))
                {
                    TeamBalance_BanTeamsExcept(balance, 1);
                }
                else if (TeamBalance_IsTeamAllowedInternal(balance, 2))
                {
                    TeamBalance_BanTeamsExcept(balance, 2);
                }
                else
                {
                    TeamBalance_BanTeamsExcept(balance, 3);
                }
                // no further cases, bots have one of the teams
            }
        }
        else
        {
            // find first team available
            if (IS_BOT_CLIENT(for_whom))
            {
                if (TeamBalance_IsTeamAllowedInternal(balance, 1))
                {
                    TeamBalance_BanTeamsExcept(balance, 1);
                }
                else if (TeamBalance_IsTeamAllowedInternal(balance, 2))
                {
                    TeamBalance_BanTeamsExcept(balance, 2);
                }
                else
                {
                    TeamBalance_BanTeamsExcept(balance, 3);
                }
                // no further cases, we know at least 2 teams exist
            }
            else
            {
                if (TeamBalance_IsTeamAllowedInternal(balance, 4))
                {
                    TeamBalance_BanTeamsExcept(balance, 4);
                }
                else if (TeamBalance_IsTeamAllowedInternal(balance, 3))
                {
                    TeamBalance_BanTeamsExcept(balance, 3);
                }
                else
                {
                    TeamBalance_BanTeamsExcept(balance, 2);
                }
                // no further cases, bots have one of the teams
            }
        }
    }
 
    if (!for_whom)
    {
        balance.m_team_balance_state = TEAM_BALANCE_TEAMS_CHECKED;
        return balance;
    }
 
    // if player has a forced team, ONLY allow that one
    for (int i = 1; i <= NUM_TEAMS; ++i)
    {
        if (for_whom.team_forced == i &&
            TeamBalance_IsTeamAllowedInternal(balance, i))
        {
            TeamBalance_BanTeamsExcept(balance, i);
            break;
        }
    }
    balance.m_team_balance_state = TEAM_BALANCE_TEAMS_CHECKED;
    return balance;
}

References autocvar_bot_vs_human, AVAILABLE_TEAMS, BIT, classname, entity(), find(), g_team_entities, IS_BOT_CLIENT, M_ARGV, MUTATOR_CALLHOOK, NULL, NUM_TEAMS, setthink, spawn, string_null, TEAM_BALANCE_TEAMS_CHECKED, Team_IsValidTeam(), TEAM_NOT_ALLOWED, TeamBalance_BanTeamsExcept(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_GetTeam(), TeamBalance_IsTeamAllowedInternal(), and time.

◆ TeamBalance_CompareTeams()

int TeamBalance_CompareTeams	(	entity	balance,
		int	team_index_a,
		int	team_index_b,
		entity	player,
		bool	use_score )

Compares two teams for the purposes of game balance.

Parameters

[in]	balance	Team balance entity.
[in]	team_index_a	Index of the first team.
[in]	team_index_b	Index of the second team.
[in]	player	Player to check.
[in]	use_score	Whether to take into account team scores.

Returns: TEAMS_COMPARE value. See above.

Note: You need to call TeamBalance_GetTeamCounts before calling this function.

Definition at line 1029 of file teamplay.qc.

{
    if (balance == NULL)
    {
        LOG_FATAL("Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state != TEAM_BALANCE_TEAM_COUNTS_FILLED)
    {
        LOG_FATAL("TeamBalance_GetTeamCounts has not been called.");
    }
    if (!Team_IsValidIndex(team_index_a))
    {
        LOG_FATALF("team_index_a is invalid: %f",
            team_index_a);
    }
    if (!Team_IsValidIndex(team_index_b))
    {
        LOG_FATALF("team_index_b is invalid: %f",
            team_index_b);
    }
    if (team_index_a == team_index_b)
    {
        return TEAMS_COMPARE_EQUAL;
    }
    entity team_a = TeamBalance_GetTeamFromIndex(balance, team_index_a);
    entity team_b = TeamBalance_GetTeamFromIndex(balance, team_index_b);
    return TeamBalance_CompareTeamsInternal(team_a, team_b, player, use_score);
}

References entity(), LOG_FATAL, LOG_FATALF, NULL, TEAM_BALANCE_TEAM_COUNTS_FILLED, Team_IsValidIndex(), TeamBalance_CompareTeamsInternal(), TeamBalance_GetTeamFromIndex(), and TEAMS_COMPARE_EQUAL.

Referenced by TeamBalance_FindBestTeams().

◆ TeamBalance_CompareTeamsInternal()

int TeamBalance_CompareTeamsInternal	(	entity	team_a,
		entity	team_index_b,
		entity	player,
		bool	use_score )

Compares two teams for the purposes of game balance.

Parameters

[in]	team_a	First team.
[in]	team_b	Second team.
[in]	player	Player to check.
[in]	use_score	Whether to take into account team scores.

Returns: TEAMS_COMPARE value. See above.

Note: You need to call TeamBalance_GetTeamCounts before calling this function.

Definition at line 1273 of file teamplay.qc.

{
    if (team_a == team_b)
    {
        return TEAMS_COMPARE_EQUAL;
    }
    if (!TeamBalanceTeam_IsAllowed(team_a) ||
        !TeamBalanceTeam_IsAllowed(team_b))
    {
        return TEAMS_COMPARE_INVALID;
    }
    // deduct bots that would leave if a player joined their team, distributing the deductions between teams
    int num_players_team_a = team_a.m_num_players;
    int num_players_team_b = team_b.m_num_players;
    if (IS_REAL_CLIENT(player) && bots_would_leave)
    {
        int bots_would_leave_remaining = bots_would_leave;
        int to_remove = min(team_a.m_num_bots, ceil(bots_would_leave_remaining * 0.5));
        num_players_team_a -= to_remove;
        bots_would_leave_remaining -= to_remove;
        num_players_team_b -= min(team_b.m_num_bots, bots_would_leave_remaining);
    }
    if (num_players_team_a < num_players_team_b)
    {
        return TEAMS_COMPARE_LESS;
    }
    if (num_players_team_a > num_players_team_b)
    {
        return TEAMS_COMPARE_GREATER;
    }
    if (!use_score)
    {
        return TEAMS_COMPARE_EQUAL;
    }
    if (team_a.m_team_score < team_b.m_team_score)
    {
        return TEAMS_COMPARE_LESS;
    }
    if (team_a.m_team_score > team_b.m_team_score)
    {
        return TEAMS_COMPARE_GREATER;
    }
    return TEAMS_COMPARE_EQUAL;
}

References bots_would_leave, ceil(), entity(), IS_REAL_CLIENT, min(), TeamBalanceTeam_IsAllowed(), TEAMS_COMPARE_EQUAL, TEAMS_COMPARE_GREATER, TEAMS_COMPARE_INVALID, and TEAMS_COMPARE_LESS.

Referenced by TeamBalance_CompareTeams().

◆ TeamBalance_Destroy()

void TeamBalance_Destroy ( entity balance )

Destroy the team balance entity.

Parameters

[in,out] balance Team balance entity to destroy.

Note: Team balance entity is allowed to be NULL.

Definition at line 599 of file teamplay.qc.

{
    if (balance == NULL)
    {
        return;
    }
    for (int i = 0; i < NUM_TEAMS; ++i)
    {
        delete(balance.(m_team_balance_team[i]));
    }
    delete(balance);
}

References entity(), NULL, and NUM_TEAMS.

Referenced by adjust_respawntime(), bot_setnameandstuff(), ClientCommand_selectteam(), ClientConnect(), ClientKill_TeamChange(), dom_DelayedInit(), GameCommand_moveplayer(), ons_ScoreRules(), ScoreRules_generic(), shuffleteams(), TeamBalance_AreEqual(), TeamBalance_AutoBalanceBots(), TeamBalance_CheckAllowedTeams(), TeamBalance_GetPlayerForTeamSwitch(), TeamBalance_JoinBestTeam(), TeamBalance_QueuedPlayersTagIn(), TeamBalance_RemoveExcessPlayers(), and TeamBalance_SizeDifference().

◆ TeamBalance_FindBestTeam()

int TeamBalance_FindBestTeam	(	entity	balance,
		entity	player,
		bool	ignore_player )

Finds the team that will make the game most balanced if the player joins it.

Parameters

[in]	balance	Team balance entity.
[in]	player	Player to check.
[in]	ignore_player	???

Returns: Index of the team that will make the game most balanced if the player joins it. If there are several equally good teams available the function will pick a random one, unless the player is already on one of them in which case that one is returned.

Definition at line 944 of file teamplay.qc.

{
    if (balance == NULL)
    {
        LOG_FATAL("Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
    {
        LOG_FATAL("Team balance entity is not initialized.");
    }
    // count how many players are in each team
    if (ignore_player)
    {
        TeamBalance_GetTeamCounts(balance, player);
    }
    else
    {
        TeamBalance_GetTeamCounts(balance, NULL);
    }
    int team_bits = TeamBalance_FindBestTeams(balance, player, true);
    if (team_bits == 0)
    {
        LOG_FATALF("No teams available for %s\n", GetGametype());
    }
 
    // don't punish players for UI mistakes by changing teams randomly when already on a best team
    if (player.team > 0 && (team_bits & Team_TeamToBit(player.team)))
        return Team_TeamToIndex(player.team);
 
    RandomSelection_Init();
    for (int i = 1; i <= NUM_TEAMS; ++i)
    {
        if (team_bits & Team_IndexToBit(i))
        {
            RandomSelection_AddFloat(i, 1, 1);
        }
    }
    return RandomSelection_chosen_float;
}

References entity(), GetGametype(), LOG_FATAL, LOG_FATALF, NULL, NUM_TEAMS, RandomSelection_AddFloat, RandomSelection_chosen_float, RandomSelection_Init(), TEAM_BALANCE_UNINITIALIZED, Team_IndexToBit(), Team_TeamToBit(), Team_TeamToIndex(), TeamBalance_FindBestTeams(), and TeamBalance_GetTeamCounts().

Referenced by ClientKill_TeamChange(), GameCommand_moveplayer(), and TeamBalance_JoinBestTeam().

◆ TeamBalance_FindBestTeams()

int TeamBalance_FindBestTeams	(	entity	balance,
		entity	player,
		bool	use_score )

Returns the bitmask of the teams that will make the game most balanced if the player joins any of them.

Parameters

[in]	balance	Team balance entity.
[in]	player	Player to check.
[in]	use_score	Whether to take into account team scores.

Returns: Bitmask of the teams that will make the game most balanced if the player joins any of them.

Note: You need to call TeamBalance_GetTeamCounts before calling this function.

Definition at line 984 of file teamplay.qc.

{
    if (balance == NULL)
    {
        LOG_FATAL("Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state != TEAM_BALANCE_TEAM_COUNTS_FILLED)
    {
        LOG_FATAL("TeamBalance_GetTeamCounts has not been called.");
    }
    if (MUTATOR_CALLHOOK(TeamBalance_FindBestTeams, player) == true)
    {
        return M_ARGV(1, float);
    }
    int team_bits = 0;
    int previous_team = 0;
    for (int i = 1; i <= NUM_TEAMS; ++i)
    {
        if (!TeamBalance_IsTeamAllowedInternal(balance, i))
        {
            continue;
        }
        if (previous_team == 0)
        {
            team_bits = Team_IndexToBit(i);
            previous_team = i;
            continue;
        }
        int compare = TeamBalance_CompareTeams(balance, i, previous_team,
            player, use_score);
        if (compare == TEAMS_COMPARE_LESS)
        {
            team_bits = Team_IndexToBit(i);
            previous_team = i;
            continue;
        }
        if (compare == TEAMS_COMPARE_EQUAL)
        {
            team_bits |= Team_IndexToBit(i);
            previous_team = i;
        }
    }
    return team_bits;
}

References entity(), LOG_FATAL, M_ARGV, MUTATOR_CALLHOOK, NULL, NUM_TEAMS, TEAM_BALANCE_TEAM_COUNTS_FILLED, Team_IndexToBit(), TeamBalance_CompareTeams(), TeamBalance_FindBestTeams(), TeamBalance_IsTeamAllowedInternal(), TEAMS_COMPARE_EQUAL, and TEAMS_COMPARE_LESS.

Referenced by ClientCommand_selectteam(), MUTATOR_HOOKABLE(), TeamBalance_FindBestTeam(), and TeamBalance_FindBestTeams().

◆ TeamBalance_GetAllowedTeams()

int TeamBalance_GetAllowedTeams ( entity balance )

Returns the bitmask of allowed teams.

Parameters

[in] balance Team balance entity.

Returns: Bitmask of allowed teams.

Definition at line 612 of file teamplay.qc.

{
    if (balance == NULL)
    {
        LOG_FATAL("Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
    {
        LOG_FATAL("Team balance entity is not initialized.");
    }
    int result = 0;
    for (int i = 1; i <= NUM_TEAMS; ++i)
    {
        if (TeamBalance_IsTeamAllowedInternal(balance, i))
        {
            result |= Team_IndexToBit(i);
        }
    }
    return result;
}

References entity(), LOG_FATAL, NULL, NUM_TEAMS, result, TEAM_BALANCE_UNINITIALIZED, Team_IndexToBit(), and TeamBalance_IsTeamAllowedInternal().

Referenced by ClientConnect(), dom_DelayedInit(), ons_ScoreRules(), and ScoreRules_generic().

◆ TeamBalance_GetLargestTeamIndex()

int TeamBalance_GetLargestTeamIndex	(	entity	balance,
		int	teams )

Returns the index of the team with most players that is contained in the given bitmask of teams.

Parameters

[in]	balance	Team balance entity.
[in]	teams	Bitmask of teams to search in.

Returns: Index of the team with most players.

Definition at line 1131 of file teamplay.qc.

{
    int largest_team_index = 0;
    int largest_team_player_count = 0;
    for (int i = 1; i <= NUM_TEAMS; ++i)
    {
        if (!(Team_IndexToBit(i) & teams))
        {
            continue;
        }
        entity team_ = TeamBalance_GetTeamFromIndex(balance, i);
        if (!TeamBalanceTeam_IsAllowed(team_))
        {
            continue;
        }
        int playercount = TeamBalanceTeam_GetNumberOfPlayers(team_);
        if (largest_team_index == 0)
        {
            largest_team_index = i;
            largest_team_player_count = playercount;
        }
        else if (playercount > largest_team_player_count)
        {
            largest_team_index = i;
            largest_team_player_count = playercount;
        }
    }
    return largest_team_index;
}

References entity(), NUM_TEAMS, Team_IndexToBit(), TeamBalance_GetTeamFromIndex(), TeamBalanceTeam_GetNumberOfPlayers(), TeamBalanceTeam_IsAllowed(), and teams.

Referenced by TeamBalance_AutoBalanceBots().

◆ TeamBalance_GetNumberOfPlayers()

int TeamBalance_GetNumberOfPlayers	(	entity	balance,
		int	index )

Returns the number of players (both humans and bots) in a team.

Parameters

[in]	balance	Team balance entity.
[in]	index	Index of the team.

Returns: Number of player (both humans and bots) in a team.

Note: You need to call TeamBalance_GetTeamCounts before calling this function.

Definition at line 927 of file teamplay.qc.

{
    if (balance == NULL)
    {
        LOG_FATAL("Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state != TEAM_BALANCE_TEAM_COUNTS_FILLED)
    {
        LOG_FATAL("TeamBalance_GetTeamCounts has not been called.");
    }
    if (!Team_IsValidIndex(index))
    {
        LOG_FATALF("Team index is invalid: %f", index);
    }
    return balance.m_team_balance_team[index - 1].m_num_players;
}

References entity(), LOG_FATAL, LOG_FATALF, NULL, TEAM_BALANCE_TEAM_COUNTS_FILLED, and Team_IsValidIndex().

Referenced by adjust_respawntime(), and bot_setnameandstuff().

◆ TeamBalance_GetPlayerForTeamSwitch()

entity TeamBalance_GetPlayerForTeamSwitch	(	int	source_team_index,
		int	destination_team_index,
		bool	is_bot )

Returns the player who is the most suitable for switching between the given teams.

Parameters

[in]	source_team_index	Index of the team to search in.
[in]	destination_team_index	Index of the team to switch to.
[in]	is_bot	True to search for bot, false for human.

Returns: Player who is the most suitable for switching between the given teams or NULL if not found.

Definition at line 1161 of file teamplay.qc.

{
    if (MUTATOR_CALLHOOK(TeamBalance_GetPlayerForTeamSwitch, source_team_index,
        destination_team_index, is_bot))
    {
        return M_ARGV(3, entity);
    }
    entity lowest_player = NULL;
    float lowest_score = FLOAT_MAX;
    FOREACH_CLIENT(Entity_GetTeamIndex(it) == source_team_index,
    {
        if (IS_BOT_CLIENT(it) != is_bot)
        {
            continue;
        }
        float temp_score = PlayerScore_Get(it, SP_SCORE);
        if (temp_score >= lowest_score)
        {
            continue;
        }
        //PrintToChatAll(sprintf(
        //  "Found %s with lowest score, checking allowed teams", it.netname));
        entity balance = TeamBalance_CheckAllowedTeams(it);
        if (TeamBalance_IsTeamAllowed(balance, source_team_index))
        {
            //PrintToChatAll("Allowed");
            lowest_player = it;
            lowest_score = temp_score;
        }
        else
        {
            //PrintToChatAll("Not allowed");
        }
        TeamBalance_Destroy(balance);
    });
    return lowest_player;
}

References entity(), Entity_GetTeamIndex(), FLOAT_MAX, FOREACH_CLIENT, IS_BOT_CLIENT, M_ARGV, MUTATOR_CALLHOOK, NULL, PlayerScore_Get, TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_GetPlayerForTeamSwitch(), and TeamBalance_IsTeamAllowed().

Referenced by MUTATOR_HOOKABLE(), TeamBalance_AutoBalanceBots(), and TeamBalance_GetPlayerForTeamSwitch().

◆ TeamBalance_GetTeam()

entity TeamBalance_GetTeam	(	entity	balance,
		int	team_num )

Returns the team entity of the team balance entity that corresponds to the given TEAM_NUM value.

Parameters

[in]	balance	Team balance entity.
[in]	team_num	Team value. See TEAM_NUM constants.

Returns: Team entity of the team balance entity that corresponds to the given TEAM_NUM value.

Note: The team entities are temporary so you may write to their fields.

Definition at line 1253 of file teamplay.qc.

{
    return TeamBalance_GetTeamFromIndex(balance, Team_TeamToIndex(team_num));
}

References entity(), Team_TeamToIndex(), and TeamBalance_GetTeamFromIndex().

Referenced by TeamBalance_CheckAllowedTeams(), TeamBalance_GetTeamCounts(), and TeamBalance_QueuedPlayersTagIn().

◆ TeamBalance_GetTeamCounts()

void TeamBalance_GetTeamCounts	(	entity	balance,
		entity	ignore )

Counts the number of players and various other information about each team.

Parameters

[in,out]	balance	Team balance entity.
[in]	ignore	Player to ignore. This is useful if you plan to switch the player's team. Pass NULL for global information.

Note: This function updates the internal state of the team balance entity.

Definition at line 846 of file teamplay.qc.

{
    if (balance == NULL)
    {
        LOG_FATAL("Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
    {
        LOG_FATAL("Team balance entity is not initialized.");
    }
    if (MUTATOR_CALLHOOK(TeamBalance_GetTeamCounts) == true)
    {
        // Mutator has overriden the configuration.
        for (int i = 1; i <= NUM_TEAMS; ++i)
        {
            entity team_ent = TeamBalance_GetTeamFromIndex(balance, i);
            if (TeamBalanceTeam_IsAllowed(team_ent))
            {
                MUTATOR_CALLHOOK(TeamBalance_GetTeamCount, i, ignore);
                team_ent.m_num_players = M_ARGV(2, float);
                team_ent.m_num_bots = M_ARGV(3, float);
            }
        }
    }
    else
    {
        // Manually count all players.
        FOREACH_CLIENT(true,
        {
            if (it == ignore)
            {
                continue;
            }
            int team_num;
            // TODO: Reconsider when the player is truly on the team.
            if (IS_CLIENT(it) || INGAME(it))
            {
                team_num = it.killindicator_teamchange > 0 ? it.killindicator_teamchange : it.team;
            }
            else if (Player_HasRealForcedTeam(it))
            {
                // Do we really need this? Probably not.
                team_num = Team_IndexToTeam(it.team_forced); // reserve the spot
            }
            else
            {
                continue;
            }
            if (!Team_IsValidTeam(team_num))
            {
                continue;
            }
            entity team_ent = TeamBalance_GetTeam(balance, team_num);
            if (!TeamBalanceTeam_IsAllowed(team_ent))
            {
                continue;
            }
            ++team_ent.m_num_players;
            if (IS_BOT_CLIENT(it))
            {
                ++team_ent.m_num_bots;
            }
        });
    }
 
    // if the player who has a forced team has not joined yet, reserve the spot
    if (autocvar_g_campaign)
    {
        if (Team_IsValidIndex(autocvar_g_campaign_forceteam))
        {
            entity team_ent = TeamBalance_GetTeamFromIndex(balance,
                autocvar_g_campaign_forceteam);
            if (team_ent.m_num_players == team_ent.m_num_bots)
            {
                ++team_ent.m_num_players;
            }
        }
    }
    balance.m_team_balance_state = TEAM_BALANCE_TEAM_COUNTS_FILLED;
}

References autocvar_g_campaign, autocvar_g_campaign_forceteam, entity(), FOREACH_CLIENT, INGAME, IS_BOT_CLIENT, IS_CLIENT, LOG_FATAL, M_ARGV, MUTATOR_CALLHOOK, NULL, NUM_TEAMS, Player_HasRealForcedTeam(), TEAM_BALANCE_TEAM_COUNTS_FILLED, TEAM_BALANCE_UNINITIALIZED, Team_IndexToTeam(), Team_IsValidIndex(), Team_IsValidTeam(), TeamBalance_GetTeam(), TeamBalance_GetTeamCounts(), TeamBalance_GetTeamFromIndex(), and TeamBalanceTeam_IsAllowed().

Referenced by adjust_respawntime(), bot_removefromlargestteam(), bot_setnameandstuff(), ClientCommand_selectteam(), MUTATOR_HOOKABLE(), TeamBalance_AreEqual(), TeamBalance_AutoBalanceBots(), TeamBalance_FindBestTeam(), TeamBalance_GetTeamCounts(), TeamBalance_QueuedPlayersTagIn(), TeamBalance_RemoveExcessPlayers(), and TeamBalance_SizeDifference().

◆ TeamBalance_GetTeamFromIndex()

entity TeamBalance_GetTeamFromIndex	(	entity	balance,
		int	index )

Returns the team entity of the team balance entity at the given index.

Parameters

[in]	balance	Team balance entity.
[in]	index	Index of the team.

Returns: Team entity of the team balance entity at the given index.

Note: The team entities are temporary so you may write to their fields.

Definition at line 1244 of file teamplay.qc.

{
    if (!Team_IsValidIndex(index))
    {
        LOG_FATALF("Index is invalid: %f", index);
    }
    return balance.m_team_balance_team[index - 1];
}

References entity(), LOG_FATALF, and Team_IsValidIndex().

Referenced by TeamBalance_AreEqual(), TeamBalance_AutoBalanceBots(), TeamBalance_CompareTeams(), TeamBalance_GetLargestTeamIndex(), TeamBalance_GetTeam(), TeamBalance_GetTeamCounts(), TeamBalance_QueuedPlayersTagIn(), TeamBalance_RemoveExcessPlayers(), and TeamBalance_SizeDifference().

◆ TeamBalance_IsTeamAllowed()

bool TeamBalance_IsTeamAllowed	(	entity	balance,
		int	index )

Returns whether the team change to the specified team is allowed.

Parameters

[in]	balance	Team balance entity.
[in]	index	Index of the team.

Returns: True if team change to the specified team is allowed, false otherwise.

Definition at line 826 of file teamplay.qc.

{
    if (balance == NULL)
    {
        LOG_FATAL("Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
    {
        LOG_FATAL("Team balance entity is not initialized.");
    }
    if (!Team_IsValidIndex(index))
    {
        LOG_FATALF("Team index is invalid: %f",
            index);
    }
    return TeamBalance_IsTeamAllowedInternal(balance, index);
}

References entity(), LOG_FATAL, LOG_FATALF, NULL, TEAM_BALANCE_UNINITIALIZED, Team_IsValidIndex(), and TeamBalance_IsTeamAllowedInternal().

Referenced by adjust_respawntime(), ClientCommand_selectteam(), GameCommand_moveplayer(), shuffleteams(), TeamBalance_GetPlayerForTeamSwitch(), and WinningCondition_RanOutOfSpawns().

◆ TeamBalance_IsTeamAllowedInternal()

bool TeamBalance_IsTeamAllowedInternal	(	entity	balance,
		int	index )

Returns whether the team change to the specified team is allowed.

Parameters

[in]	balance	Team balance entity.
[in]	index	Index of the team.

Returns: True if team change to the specified team is allowed, false otherwise.

Note: This function bypasses all the sanity checks.

Definition at line 1227 of file teamplay.qc.

{
    return balance.m_team_balance_team[index - 1].m_num_players !=
        TEAM_NOT_ALLOWED;
}

References entity(), and TEAM_NOT_ALLOWED.

Referenced by TeamBalance_CheckAllowedTeams(), TeamBalance_FindBestTeams(), TeamBalance_GetAllowedTeams(), TeamBalance_IsTeamAllowed(), and TeamBalance_JoinBestTeam().

◆ TeamBalance_JoinBestTeam()

void TeamBalance_JoinBestTeam ( entity player )

Assigns the given player to a team that will make the game most balanced.

Parameters

[in,out] player Player to assign.

Definition at line 423 of file teamplay.qc.

{
    //PrintToChatAll(sprintf("TeamBalance_JoinBestTeam: %s", player.netname));
    if (!teamplay)
    {
        return;
    }
    if (player.bot_forced_team)
    {
        return;
    }
    entity balance = TeamBalance_CheckAllowedTeams(player);
    if (Player_HasRealForcedTeam(player))
    {
        int forced_team_index = player.team_forced;
        bool is_team_allowed = TeamBalance_IsTeamAllowedInternal(balance,
            forced_team_index);
        TeamBalance_Destroy(balance);
        if (!is_team_allowed)
        {
            return;
        }
        if (!SetPlayerTeam(player, forced_team_index, TEAM_CHANGE_AUTO))
        {
            return;
        }
        return;
    }
    int best_team_index = TeamBalance_FindBestTeam(balance, player, true);
    TeamBalance_Destroy(balance);
    if (!SetPlayerTeam(player, best_team_index, TEAM_CHANGE_AUTO))
    {
        return;
    }
}

References entity(), Player_HasRealForcedTeam(), SetPlayerTeam(), TEAM_CHANGE_AUTO, TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_FindBestTeam(), TeamBalance_IsTeamAllowedInternal(), and teamplay.

Referenced by PutPlayerInServer().

◆ TeamBalance_QueuedPlayersTagIn()

bool TeamBalance_QueuedPlayersTagIn ( entity ignore )

Joins queued player(s) to team(s) with a shortage, this should be more robust than only replacing the player that left.

Chooses players with a specific team preference first to increase chances of everyone getting what they want. Returns true if the teams are now balanced.

Definition at line 775 of file teamplay.qc.

{
    if (!teamplay)
        return true;
 
    int j, teamplayers_deficit = 0, teamplayers_max = 0;
    entity it, balance = TeamBalance_CheckAllowedTeams(ignore);
    TeamBalance_GetTeamCounts(balance, ignore);
 
    for (int bots_would_leave_remaining = bots_would_leave, j = 1; j <= AVAILABLE_TEAMS; ++j)
    {
        it = TeamBalance_GetTeamFromIndex(balance, j);
        // deduct bots that would leave if a player joined their team, distributing the deductions between teams
        if (bots_would_leave_remaining)
        {
            int to_remove = min(it.m_num_bots, ceil(bots_would_leave_remaining / AVAILABLE_TEAMS));
            it.m_num_players -= to_remove;
            bots_would_leave_remaining -= to_remove;
        }
        // find the largest team size
        if (it.m_num_players > teamplayers_max)
            teamplayers_max = it.m_num_players;
    }
    // find how many players we'd need to join to achieve balanced numbers that way
    for (j = 1; j <= AVAILABLE_TEAMS; ++j)
        teamplayers_deficit += teamplayers_max - TeamBalance_GetTeamFromIndex(balance, j).m_num_players;
 
    // first pass: find clients(s) who want to play on a specific team
    for (j = 1; teamplayers_deficit > 0 && j <= maxclients; ++j)
    {
        it = ftoe(j);
        if (it.wants_join <= 0 || it == ignore) continue;
        if (TeamBalance_GetTeamFromIndex(balance, it.wants_join).m_num_players >= teamplayers_max) continue;
        Join(it, false);
        ++TeamBalance_GetTeam(balance, it.team).m_num_players;
        --teamplayers_deficit;
    }
 
    // second pass: find clients(s) who want to play on any team
    for (j = 1; teamplayers_deficit > 0 && j <= maxclients; ++j)
    {
        it = ftoe(j);
        if (it.wants_join >= 0 || it == ignore) continue;
        Join(it, false);
        --teamplayers_deficit; // don't need to update .m_num_players as we won't read it again
    }
 
    TeamBalance_Destroy(balance);
    return teamplayers_deficit <= 0; // return true if teams are now balanced
}

References AVAILABLE_TEAMS, bots_would_leave, ceil(), entity(), ftoe, Join(), maxclients, min(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_GetTeam(), TeamBalance_GetTeamCounts(), TeamBalance_GetTeamFromIndex(), and teamplay.

Referenced by ClientDisconnect(), and ClientKill_Now_TeamChange().

◆ TeamBalance_RemoveExcessPlayers()

void TeamBalance_RemoveExcessPlayers ( entity ignore )

Definition at line 712 of file teamplay.qc.

{
    if(AVAILABLE_TEAMS != 2 || autocvar_g_campaign) return;
 
    entity balance = TeamBalance_CheckAllowedTeams(ignore);
    TeamBalance_GetTeamCounts(balance, ignore);
 
    int min = 0;
 
    for(int i = 1; i <= AVAILABLE_TEAMS; ++i)
    {
        int cur = TeamBalance_GetTeamFromIndex(balance, i).m_num_players;
        if(i == 1 || cur < min)
            min = cur;
    }
 
    for(int tmi = 1; tmi <= AVAILABLE_TEAMS; ++tmi)
    {
        int cur = TeamBalance_GetTeamFromIndex(balance, tmi).m_num_players;
        if(cur > 0 && cur > min) // If this team has excess players
        {
            // Get newest player
            int latest_join = 0;
            entity latest_join_pl = NULL;
 
            FOREACH_CLIENT(IS_REAL_CLIENT(it) || INGAME(it), {
                if(it.team == Team_IndexToTeam(tmi) && CS(it).startplaytime > latest_join)
                {
                    latest_join = CS(it).startplaytime;
                    latest_join_pl = it;
                }
            });
 
            // Force player to spectate
            if(latest_join_pl)
            {
                // Send player to spectate
                if(autocvar_g_balance_teams_remove_wait)
                {
                    // Give a warning before moving to spect
                    if (!remove_countdown)
                    {
                        remove_countdown = new_pure(remove_countdown);
                        setthink(remove_countdown, Remove_Countdown);
                        remove_countdown.nextthink = time;
                        Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_MOVETOSPEC_REMOVE, playername(latest_join_pl.netname, latest_join_pl.team, true), autocvar_g_balance_teams_remove_wait);
                    }
                    remove_countdown.enemy = latest_join_pl;
                    remove_countdown.lifetime = autocvar_g_balance_teams_remove_wait;
                }
                else
                {
                    // Move to spects immediately
                    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_MOVETOSPEC_REMOVE, latest_join_pl.netname);
                    PutObserverInServer(latest_join_pl, true, true);
                }
            }
        }
    }
 
    TeamBalance_Destroy(balance);
}

References autocvar_g_balance_teams_remove_wait, autocvar_g_campaign, AVAILABLE_TEAMS, CS(), entity(), FOREACH_CLIENT, INGAME, IS_REAL_CLIENT, min(), new_pure, NULL, playername(), PutObserverInServer(), Remove_Countdown(), remove_countdown, Send_Notification(), setthink, startplaytime, Team_IndexToTeam(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_GetTeamCounts(), TeamBalance_GetTeamFromIndex(), and time.

Referenced by ClientDisconnect(), ClientKill_Now_TeamChange(), and Remove_Countdown().

◆ TeamBalance_SizeDifference()

int TeamBalance_SizeDifference ( entity ignore )

Returns the size difference between the largest and smallest team (bots included).

Definition at line 633 of file teamplay.qc.

{
    if (!teamplay)
        return 0;
 
    entity balance = TeamBalance_CheckAllowedTeams(ignore);
    TeamBalance_GetTeamCounts(balance, ignore);
 
    int ts_min = 255, ts_max = 0;
    for (int i = 1; i <= AVAILABLE_TEAMS; ++i)
    {
        int ts = TeamBalance_GetTeamFromIndex(balance, i).m_num_players;
        if (ts_min > ts)
            ts_min = ts;
        if (ts_max < ts)
            ts_max = ts;
    }
 
    TeamBalance_Destroy(balance);
 
    return ts_max - ts_min;
}

References AVAILABLE_TEAMS, entity(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_GetTeamCounts(), TeamBalance_GetTeamFromIndex(), teamplay, ts_max, and ts_min.

Referenced by ReadyCount().

◆ TeamBalanceTeam_GetNumberOfBots()

int TeamBalanceTeam_GetNumberOfBots ( entity team_ent )

Returns the number of bots in a team.

Parameters

[in] team_ent Team entity.

Returns: Number of bots in a team.

Note: You need to call TeamBalance_GetTeamCounts before calling this function.

Definition at line 1268 of file teamplay.qc.

{
    return team_ent.m_num_bots;
}

References entity().

◆ TeamBalanceTeam_GetNumberOfPlayers()

int TeamBalanceTeam_GetNumberOfPlayers ( entity team_ent )

Returns the number of players (both humans and bots) in a team.

Parameters

[in] team_ent Team entity.

Returns: Number of player (both humans and bots) in a team.

Note: You need to call TeamBalance_GetTeamCounts before calling this function.

Definition at line 1263 of file teamplay.qc.

{
    return team_ent.m_num_players;
}

References entity().

Referenced by TeamBalance_AutoBalanceBots(), and TeamBalance_GetLargestTeamIndex().

◆ TeamBalanceTeam_IsAllowed()

bool TeamBalanceTeam_IsAllowed ( entity team_ent )

Returns whether the team is allowed.

Parameters

[in] team_ent Team entity.

Returns: True if team is allowed, false otherwise.

Definition at line 1258 of file teamplay.qc.

{
    return team_ent.m_num_players != TEAM_NOT_ALLOWED;
}

References entity(), and TEAM_NOT_ALLOWED.

Referenced by TeamBalance_AutoBalanceBots(), TeamBalance_CompareTeamsInternal(), TeamBalance_GetLargestTeamIndex(), and TeamBalance_GetTeamCounts().

Variable Documentation

◆ autocvar_g_balance_teams

bool autocvar_g_balance_teams

Definition at line 7 of file teamplay.qh.

Referenced by ClientCommand_clientversion(), PlayerPreThink(), and ShowTeamSelection().

◆ autocvar_g_balance_teams_prevent_imbalance

bool autocvar_g_balance_teams_prevent_imbalance

Definition at line 8 of file teamplay.qh.

Referenced by ClientCommand_selectteam().

◆ autocvar_g_balance_teams_queue

bool autocvar_g_balance_teams_queue

Definition at line 9 of file teamplay.qh.

Referenced by QueueNeeded().

◆ autocvar_g_balance_teams_remove

bool autocvar_g_balance_teams_remove

Definition at line 10 of file teamplay.qh.

Referenced by ClientDisconnect(), and ClientKill_Now_TeamChange().

◆ autocvar_g_balance_teams_remove_wait

int autocvar_g_balance_teams_remove_wait

Definition at line 11 of file teamplay.qh.

Referenced by TeamBalance_RemoveExcessPlayers().

◆ autocvar_g_forced_team_otherwise

string autocvar_g_forced_team_otherwise

Definition at line 13 of file teamplay.qh.

Referenced by nJoinAllowed(), and Player_DetermineForcedTeam().

◆ autocvar_teamplay_lockonrestart

bool autocvar_teamplay_lockonrestart

Definition at line 5 of file teamplay.qh.

Referenced by ReadyRestart_force().

◆ autocvar_teamplay_mode

int autocvar_teamplay_mode

Definition at line 3 of file teamplay.qh.

Referenced by Damage().

◆ lockteams

bool lockteams

Definition at line 15 of file teamplay.qh.

Referenced by ClientCommand_selectteam(), GameCommand_lockteams(), GameCommand_unlockteams(), joinAllowed(), MoveToTeam(), nJoinAllowed(), ReadyRestart_force(), and SERVER_COMMAND().

◆ team_forced

int team_forced

Definition at line 17 of file teamplay.qh.

Variables
bool	autocvar_g_balance_teams
bool	autocvar_g_balance_teams_prevent_imbalance
bool	autocvar_g_balance_teams_queue
bool	autocvar_g_balance_teams_remove
int	autocvar_g_balance_teams_remove_wait
string	autocvar_g_forced_team_otherwise
bool	autocvar_teamplay_lockonrestart
int	autocvar_teamplay_mode
bool	lockteams
int	team_forced

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ Entity_GetTeam()

◆ Entity_GetTeamIndex()

◆ Entity_HasValidTeam()

◆ KillPlayerForTeamChange()

◆ LogTeamChange()

◆ MoveToTeam()

◆ Player_DetermineForcedTeam()

◆ Player_GetForcedTeamIndex()

◆ Player_HasRealForcedTeam()

◆ Player_SetForcedTeamIndex()

◆ Player_SetTeamIndex()

◆ QueuedPlayersReady()

◆ QueueNeeded()

◆ setcolor()

◆ SetPlayerColors()

◆ SetPlayerTeam()

◆ SV_ChangeTeam()

◆ Team_GetNumberOfAlivePlayers()

◆ Team_GetNumberOfAliveTeams()

◆ Team_GetNumberOfOwnedItems()

◆ Team_GetNumberOfTeamsWithOwnedItems()

◆ Team_GetTeam()

◆ Team_GetTeamFromIndex()

◆ Team_GetTeamScore()

◆ Team_GetWinnerAliveTeam()

◆ Team_GetWinnerTeam_WithOwnedItems()

◆ Team_InitTeams()

◆ Team_SetNumberOfAlivePlayers()

◆ Team_SetNumberOfOwnedItems()

◆ Team_SetTeamScore()

◆ TeamBalance_AreEqual()

◆ TeamBalance_AutoBalanceBots()

◆ TeamBalance_BanTeamsExcept()

◆ TeamBalance_CheckAllowedTeams()

◆ TeamBalance_CompareTeams()

◆ TeamBalance_CompareTeamsInternal()

◆ TeamBalance_Destroy()

◆ TeamBalance_FindBestTeam()

◆ TeamBalance_FindBestTeams()

◆ TeamBalance_GetAllowedTeams()

◆ TeamBalance_GetLargestTeamIndex()

◆ TeamBalance_GetNumberOfPlayers()

◆ TeamBalance_GetPlayerForTeamSwitch()

◆ TeamBalance_GetTeam()

◆ TeamBalance_GetTeamCounts()

◆ TeamBalance_GetTeamFromIndex()

◆ TeamBalance_IsTeamAllowed()

◆ TeamBalance_IsTeamAllowedInternal()

◆ TeamBalance_JoinBestTeam()

◆ TeamBalance_QueuedPlayersTagIn()

◆ TeamBalance_RemoveExcessPlayers()

◆ TeamBalance_SizeDifference()

◆ TeamBalanceTeam_GetNumberOfBots()

◆ TeamBalanceTeam_GetNumberOfPlayers()

◆ TeamBalanceTeam_IsAllowed()

Variable Documentation

◆ autocvar_g_balance_teams

◆ autocvar_g_balance_teams_prevent_imbalance

◆ autocvar_g_balance_teams_queue

◆ autocvar_g_balance_teams_remove

◆ autocvar_g_balance_teams_remove_wait

◆ autocvar_g_forced_team_otherwise

◆ autocvar_teamplay_lockonrestart

◆ autocvar_teamplay_mode

◆ lockteams

◆ team_forced