teamplay.qc File Reference

#include "teamplay.qh"
#include <common/deathtypes/all.qh>
#include <common/gamemodes/_mod.qh>
#include <common/teams.qh>
#include <server/bot/api.qh>
#include <server/bot/default/cvars.qh>
#include <server/campaign.qh>
#include <server/client.qh>
#include <server/command/vote.qh>
#include <server/damage.qh>
#include <server/gamelog.qh>
#include <server/mutators/_mod.qh>
#include <server/race.qh>
#include <server/scores.qh>
#include <server/scores_rules.qh>

Include dependency graph for teamplay.qc:

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

Go to the source code of this file.

Enumerations
enum	{ TEAM_BALANCE_UNINITIALIZED, TEAM_BALANCE_TEAMS_CHECKED, TEAM_BALANCE_TEAM_COUNTS_FILLED }
	Describes a state of team balance entity. More...

Functions
entity	Entity_GetTeam (entity this)
	Returns the team entity of the given entity. More...
int	Entity_GetTeamIndex (entity this)
	Returns the team index of the given entity. More...
bool	Entity_HasValidTeam (entity this)
	Returns whether the given entity belongs to a valid team. More...
void	KillPlayerForTeamChange (entity player)
	Kills player as a result of team change. More...
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. More...
void	Player_DetermineForcedTeam (entity player)
	Determines the forced team of the player using current global config. More...
int	Player_GetForcedTeamIndex (entity player)
	Returns the index of the forced team of the given player. More...
bool	Player_HasRealForcedTeam (entity player)
	Returns whether player has real forced team. More...
void	Player_SetForcedTeamIndex (entity player, int team_index)
	Sets the index of the forced team of the given player. More...
bool	Player_SetTeamIndex (entity player, int index)
	Sets the team of the player using its index. More...
void	Player_SetTeamIndexChecked (entity player, int team_index)
	Sets the team of the player with all sanity checks. More...
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. More...
void	SV_ChangeTeam (entity player, int new_color)
	Called when the player changes color with the "color" command. More...
int	Team_GetNumberOfAlivePlayers (entity team_ent)
	Returns the number of alive players in a team. More...
int	Team_GetNumberOfAliveTeams ()
	Returns the number of alive teams. More...
int	Team_GetNumberOfOwnedItems (entity team_ent)
	Returns the number of items owned by a team. More...
int	Team_GetNumberOfTeamsWithOwnedItems ()
	Returns the number of teams that own items. More...
entity	Team_GetTeam (int team_num)
	Returns the global team entity that corresponds to the given TEAM_NUM value. More...
entity	Team_GetTeamFromIndex (int index)
	Returns the global team entity at the given index. More...
float	Team_GetTeamScore (entity team_ent)
	Returns the score of the team. More...
int	Team_GetWinnerAliveTeam ()
	Returns the winner team. More...
int	Team_GetWinnerTeam_WithOwnedItems (int min_control_points)
	Returns the winner team. More...
void	Team_InitTeams ()
void	Team_SetNumberOfAlivePlayers (entity team_ent, int number)
	Sets the number of alive players in a team. More...
void	Team_SetNumberOfOwnedItems (entity team_ent, int number)
	Sets the number of items owned by a team. More...
void	Team_SetTeamScore (entity team_ent, float score)
	Sets the score of the team. More...
void	TeamBalance_AutoBalanceBots ()
	Switches a bot from one team to another if teams are not balanced. More...
void	TeamBalance_BanTeamsExcept (entity balance, int index)
	Bans team change to all teams except the given one. More...
entity	TeamBalance_CheckAllowedTeams (entity for_whom)
	Checks whether the player can join teams according to global configuration and mutator settings. More...
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. More...
int	TeamBalance_CompareTeamsInternal (entity team_a, entity team_b, entity player, bool use_score)
	Compares two teams for the purposes of game balance. More...
void	TeamBalance_Destroy (entity balance)
	Destroy the team balance entity. More...
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. More...
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. More...
int	TeamBalance_GetAllowedTeams (entity balance)
	Returns the bitmask of allowed teams. More...
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. More...
int	TeamBalance_GetNumberOfPlayers (entity balance, int index)
	Returns the number of players (both humans and bots) in a team. More...
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. More...
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. More...
void	TeamBalance_GetTeamCounts (entity balance, entity ignore)
	Counts the number of players and various other information about each team. More...
entity	TeamBalance_GetTeamFromIndex (entity balance, int index)
	Returns the team entity of the team balance entity at the given index. More...
bool	TeamBalance_IsTeamAllowed (entity balance, int index)
	Returns whether the team change to the specified team is allowed. More...
bool	TeamBalance_IsTeamAllowedInternal (entity balance, int index)
	Returns whether the team change to the specified team is allowed. More...
void	TeamBalance_JoinBestTeam (entity player)
	Assigns the given player to a team that will make the game most balanced. More...
int	TeamBalanceTeam_GetNumberOfBots (entity team_ent)
	Returns the number of bots in a team. More...
int	TeamBalanceTeam_GetNumberOfPlayers (entity team_ent)
	Returns the number of players (both humans and bots) in a team. More...
bool	TeamBalanceTeam_IsAllowed (entity team_ent)
	Returns whether the team is allowed. More...

Variables
string	autocvar_g_forced_team_blue
string	autocvar_g_forced_team_pink
string	autocvar_g_forced_team_red
string	autocvar_g_forced_team_yellow
entity	g_team_entities [NUM_TEAMS]
	Holds global team entities. More...
int	m_num_bots
	Number of bots in a team. More...
int	m_num_owned_items
	Number of items owned by a team. More...
int	m_num_players
	Number of players (both humans and bots) in a team. More...
int	m_num_players_alive
	Number of alive players in a team. More...
int	m_team_balance_state
	Holds the state of the team balance entity. More...
entity	m_team_balance_team [NUM_TEAMS]
	??? More...
float	m_team_score
	The score of the team. More...
const int	TEAM_NOT_ALLOWED = -1
	Indicates that the player is not allowed to join a team. More...

Enumeration Type Documentation

anonymous enum

anonymous enum

Describes a state of team balance entity.

Enumerator
TEAM_BALANCE_UNINITIALIZED	The team balance has not been initialized.
TEAM_BALANCE_TEAMS_CHECKED	TeamBalance_CheckAllowedTeams has been called.
TEAM_BALANCE_TEAM_COUNTS_FILLED	TeamBalance_GetTeamCounts has been called.

Definition at line 19 of file teamplay.qc.

{
    TEAM_BALANCE_UNINITIALIZED, 
    TEAM_BALANCE_TEAMS_CHECKED,
    TEAM_BALANCE_TEAM_COUNTS_FILLED
};

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 181 of file teamplay.qc.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 176 of file teamplay.qc.

References team, and Team_TeamToIndex().

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

{
    return Team_TeamToIndex(this.team);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 171 of file teamplay.qc.

References team, and Team_IsValidTeam().

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

{
    return Team_IsValidTeam(this.team);
}

Here is the call graph for this function:

Here is the caller graph for this function:

KillPlayerForTeamChange()

void KillPlayerForTeamChange

(

entity

player

)

Kills player as a result of team change.

Parameters

[in,out]

player

Player to kill.

Definition at line 1049 of file teamplay.qc.

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

Referenced by SetPlayerTeam().

{
    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');
}

Here is the call graph for this function:

Here is the caller graph for this function:

LogTeamChange()

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

Definition at line 1036 of file teamplay.qc.

References autocvar_sv_eventlog, and GameLogEcho().

Referenced by SetPlayerTeam().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 327 of file teamplay.qc.

References lockteams, and SetPlayerTeam().

Referenced by GameCommand_moveplayer(), and shuffleteams().

{
    //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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 376 of file teamplay.qc.

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, IS_REAL_CLIENT, Player_HasRealForcedTeam(), PlayerInList(), TEAM_FORCE_DEFAULT, TEAM_FORCE_SPECTATOR, Team_IsValidIndex(), and teamplay.

Referenced by ClientConnect().

{
    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;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 346 of file teamplay.qc.

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

{
    return player.team_forced;
}

Here is the caller graph for this function:

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 341 of file teamplay.qc.

References TEAM_FORCE_DEFAULT.

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

{
    return player.team_forced > TEAM_FORCE_DEFAULT;
}

Here is the caller graph for this function:

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 351 of file teamplay.qc.

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

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

{
    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("Player_SetForcedTeamIndex: Invalid team index.");
            }
            else
            {
                player.team_forced = team_index;
                break;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 205 of file teamplay.qc.

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

Referenced by SetPlayerTeam().

{
    int new_team = Team_IndexToTeam(index);
    if (player.team == new_team)
    {
        if (new_team != -1)
        {
            // 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: color 0 4.
            SetPlayerColors(player, new_team - 1);
        }
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Player_SetTeamIndexChecked()

void Player_SetTeamIndexChecked	(	entity	player,
		int	team_index
	)

Sets the team of the player with all sanity checks.

Parameters

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

Definition at line 276 of file teamplay.qc.

References autocvar_g_balance_teams, autocvar_g_balance_teams_prevent_imbalance, autocvar_g_campaign, autocvar_g_changeteam_banned, CS(), entity(), SetPlayerTeam(), TEAM_CHANGE_MANUAL, Team_IndexToBit(), Team_IsValidIndex(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_FindBestTeams(), TeamBalance_GetTeamCounts(), TeamBalance_IsTeamAllowedInternal(), teamplay, and wasplayer.

Referenced by ClientKill_Now_TeamChange(), and SV_ChangeTeam().

{
    if (!teamplay)
    {
        return;
    }
    if (!Team_IsValidIndex(team_index))
    {
        return;
    }
    if ((autocvar_g_campaign) || (autocvar_g_changeteam_banned &&
        CS(player).wasplayer))
    {
        Send_Notification(NOTIF_ONE, player, MSG_INFO,
            INFO_TEAMCHANGE_NOTALLOWED);
        return;
    }
    entity balance = TeamBalance_CheckAllowedTeams(player);
    if (team_index == 1 && !TeamBalance_IsTeamAllowedInternal(balance, 1))
    {
        team_index = 4;
    }
    if (team_index == 4 && !TeamBalance_IsTeamAllowedInternal(balance, 4))
    {
        team_index = 3;
    }
    if (team_index == 3 && !TeamBalance_IsTeamAllowedInternal(balance, 3))
    {
        team_index = 2;
    }
    if (team_index == 2 && !TeamBalance_IsTeamAllowedInternal(balance, 2))
    {
        team_index = 1;
    }
    // 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)
    {
        TeamBalance_GetTeamCounts(balance, player);
        if ((Team_IndexToBit(team_index) & TeamBalance_FindBestTeams(balance,
            player, false)) == 0)
        {
            Send_Notification(NOTIF_ONE, player, MSG_INFO,
                INFO_TEAMCHANGE_LARGERTEAM);
            TeamBalance_Destroy(balance);
            return;
        }
    }
    TeamBalance_Destroy(balance);
    SetPlayerTeam(player, team_index, TEAM_CHANGE_MANUAL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setcolor()

void setcolor	(	entity	this,
		int	clr
	)

Definition at line 161 of file teamplay.qc.

References clientcolors, and team.

Referenced by SetPlayerColors().

{
#if 0
    this.clientcolors = clr;
    this.team = (clr & 15) + 1;
#else
    builtin_setcolor(this, clr);
#endif
}

Here is the caller graph for this function:

SetPlayerColors()

void SetPlayerColors	(	entity	player,
		float	_color
	)

Definition at line 191 of file teamplay.qc.

References setcolor(), and teamplay.

Referenced by Player_SetTeamIndex(), and SV_ChangeTeam().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 237 of file teamplay.qc.

References APP_TEAM_NUM, autocvar_sv_maxidle_playertospectator, CPID_IDLING, CS(), Entity_GetTeamIndex(), FRAGS_SPECTATOR, IS_BOT_CLIENT, just_joined, KillPlayerForTeamChange(), LogTeamChange(), NULL, Player_SetTeamIndex(), PlayerScore_Clear(), TeamBalance_AutoBalanceBots(), and time.

Referenced by bot_clientconnect(), MoveToTeam(), Player_SetTeamIndexChecked(), PutObserverInServer(), TeamBalance_AutoBalanceBots(), and TeamBalance_JoinBestTeam().

{
    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);
        CS(player).parm_idlesince = time;

        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);
    }

    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SV_ChangeTeam()

void SV_ChangeTeam	(	entity	player,
		int	new_color
	)

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

Note that 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 1151 of file teamplay.qc.

References IS_CLIENT, Player_SetTeamIndexChecked(), SetPlayerColors(), Team_TeamToIndex(), and teamplay.

{
    if (!teamplay)
    {
        SetPlayerColors(player, new_color);
    }
    if(!IS_CLIENT(player))
    {
        return;
    }
    if (!teamplay)
    {
        return;
    }
    Player_SetTeamIndexChecked(player, Team_TeamToIndex((new_color & 0x0F) + 1));
}

Here is the call graph for this function:

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.

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

{
    return team_ent.m_num_players_alive;
}

Here is the caller graph for this function:

Team_GetNumberOfAliveTeams()

int Team_GetNumberOfAliveTeams

(

)

Returns the number of alive teams.

Returns

Number of alive teams.

Definition at line 110 of file teamplay.qc.

References g_team_entities, m_num_players_alive, NUM_TEAMS, and result.

Referenced by CA_CheckTeams(), and freezetag_CheckTeams().

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

Here is the caller graph for this function:

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.

Referenced by Domination_count_controlpoints(), and Onslaught_count_generators().

{
    return team_ent.m_num_owned_items;
}

Here is the caller graph for this function:

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.

References g_team_entities, m_num_owned_items, NUM_TEAMS, and result.

{
    int result = 0;
    for (int i = 0; i < NUM_TEAMS; ++i)
    {
        if (g_team_entities[i].m_num_owned_items > 0)
        {
            ++result;
        }
    }
    return 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.

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

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

Here is the call graph for this function:

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.

References g_team_entities, LOG_FATALF, and Team_IsValidIndex().

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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.

Referenced by WinningCondition_RanOutOfSpawns().

{
    return team_ent.m_team_score;
}

Here is the caller graph for this function:

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.

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

Referenced by CA_CheckWinner(), and freezetag_CheckWinner().

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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.

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

Referenced by Domination_CheckWinner(), and Onslaught_CheckWinner().

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Team_InitTeams()

void Team_InitTeams

(

)

Definition at line 47 of file teamplay.qc.

References g_team_entities, new_pure, and NUM_TEAMS.

Referenced by GameRules_teams().

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

Here is the caller graph for this function:

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.

References number.

Referenced by CA_count_alive_players(), and freezetag_count_alive_players().

{
    team_ent.m_num_players_alive = number;
}

Here is the caller graph for this function:

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.

References number.

Referenced by Domination_count_controlpoints(), and Onslaught_count_generators().

{
    team_ent.m_num_owned_items = number;
}

Here is the caller graph for this function:

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.

Referenced by WinningCondition_RanOutOfSpawns(), and WinningCondition_Scores().

{
    team_ent.m_team_score = score;
}

Here is the caller graph for this function:

TeamBalance_AutoBalanceBots()

void TeamBalance_AutoBalanceBots

(

)

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

Definition at line 897 of file teamplay.qc.

References BITS, entity(), 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().

{
    // checks disabled because we always want auto-balanced bots
    //if (!(autocvar_g_balance_teams && autocvar_g_balance_teams_prevent_imbalance))
    //  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 1069 of file teamplay.qc.

References NUM_TEAMS, and TEAM_NOT_ALLOWED.

Referenced by TeamBalance_CheckAllowedTeams().

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

Here is the caller graph for this function:

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 487 of file teamplay.qc.

References autocvar_bot_vs_human, AvailableTeams(), 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.

Referenced by adjust_respawntime(), bot_removefromlargestteam(), bot_setnameandstuff(), ClientCommand_selectteam(), ClientConnect(), dom_DelayedInit(), GameCommand_moveplayer(), ons_ScoreRules(), Player_SetTeamIndexChecked(), ScoreRules_generic(), shuffleteams(), TeamBalance_AutoBalanceBots(), TeamBalance_CheckAllowedTeams(), TeamBalance_GetPlayerForTeamSwitch(), TeamBalance_JoinBestTeam(), and WinningCondition_RanOutOfSpawns().

{
    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 && AvailableTeams() == 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 866 of file teamplay.qc.

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().

{
    if (balance == NULL)
    {
        LOG_FATAL("TeamBalance_CompareTeams: Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state != TEAM_BALANCE_TEAM_COUNTS_FILLED)
    {
        LOG_FATAL("TeamBalance_CompareTeams: "
            "TeamBalance_GetTeamCounts has not been called.");
    }
    if (!Team_IsValidIndex(team_index_a))
    {
        LOG_FATALF("TeamBalance_CompareTeams: team_index_a is invalid: %f",
            team_index_a);
    }
    if (!Team_IsValidIndex(team_index_b))
    {
        LOG_FATALF("TeamBalance_CompareTeams: 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 1109 of file teamplay.qc.

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

Referenced by TeamBalance_CompareTeams().

{
    if (team_a == team_b)
    {
        return TEAMS_COMPARE_EQUAL;
    }
    if (!TeamBalanceTeam_IsAllowed(team_a) ||
        !TeamBalanceTeam_IsAllowed(team_b))
    {
        return TEAMS_COMPARE_INVALID;
    }
    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)
    {
        num_players_team_a -= team_a.m_num_bots;
        num_players_team_b -= team_b.m_num_bots;
    }
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 627 of file teamplay.qc.

References NULL, and NUM_TEAMS.

Referenced by adjust_respawntime(), bot_setnameandstuff(), ClientCommand_selectteam(), ClientConnect(), dom_DelayedInit(), GameCommand_moveplayer(), ons_ScoreRules(), Player_SetTeamIndexChecked(), ScoreRules_generic(), shuffleteams(), TeamBalance_AutoBalanceBots(), TeamBalance_CheckAllowedTeams(), TeamBalance_GetPlayerForTeamSwitch(), and TeamBalance_JoinBestTeam().

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

Here is the caller graph for this function:

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.

Definition at line 783 of file teamplay.qc.

References LOG_FATAL, LOG_FATALF, MapInfo_CurrentGametype(), MapInfo_Type_ToString(), NULL, NUM_TEAMS, RandomSelection_AddFloat, RandomSelection_chosen_float, RandomSelection_Init(), TEAM_BALANCE_UNINITIALIZED, Team_IndexToBit(), TeamBalance_FindBestTeams(), and TeamBalance_GetTeamCounts().

Referenced by GameCommand_moveplayer(), and TeamBalance_JoinBestTeam().

{
    if (balance == NULL)
    {
        LOG_FATAL("TeamBalance_FindBestTeam: Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
    {
        LOG_FATAL("TeamBalance_FindBestTeam: "
            "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("TeamBalance_FindBestTeam: No teams available for %s\n",
            MapInfo_Type_ToString(MapInfo_CurrentGametype()));
    }
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 820 of file teamplay.qc.

References 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(), Player_SetTeamIndexChecked(), TeamBalance_FindBestTeam(), and TeamBalance_FindBestTeams().

{
    if (balance == NULL)
    {
        LOG_FATAL("TeamBalance_FindBestTeams: Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state != TEAM_BALANCE_TEAM_COUNTS_FILLED)
    {
        LOG_FATAL("TeamBalance_FindBestTeams: "
            "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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 640 of file teamplay.qc.

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

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

{
    if (balance == NULL)
    {
        LOG_FATAL("TeamBalance_GetAllowedTeams: Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
    {
        LOG_FATAL("TeamBalance_GetAllowedTeams: "
            "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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 967 of file teamplay.qc.

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

Referenced by TeamBalance_AutoBalanceBots().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 763 of file teamplay.qc.

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

Referenced by adjust_respawntime(), and bot_setnameandstuff().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 997 of file teamplay.qc.

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 TeamBalance_AutoBalanceBots(), and TeamBalance_GetPlayerForTeamSwitch().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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.

Definition at line 1089 of file teamplay.qc.

References Team_TeamToIndex(), and TeamBalance_GetTeamFromIndex().

Referenced by TeamBalance_CheckAllowedTeams(), and TeamBalance_GetTeamCounts().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 681 of file teamplay.qc.

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(), Player_SetTeamIndexChecked(), TeamBalance_AutoBalanceBots(), TeamBalance_FindBestTeam(), and TeamBalance_GetTeamCounts().

{
    if (balance == NULL)
    {
        LOG_FATAL("TeamBalance_GetTeamCounts: Team balance entity is NULL.");
    }
    if (balance.m_team_balance_state == TEAM_BALANCE_UNINITIALIZED)
    {
        LOG_FATAL("TeamBalance_GetTeamCounts: "
            "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.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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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.

Definition at line 1080 of file teamplay.qc.

References LOG_FATALF, and Team_IsValidIndex().

Referenced by TeamBalance_AutoBalanceBots(), TeamBalance_CompareTeams(), TeamBalance_GetLargestTeamIndex(), TeamBalance_GetTeam(), and TeamBalance_GetTeamCounts().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 662 of file teamplay.qc.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 1063 of file teamplay.qc.

References TEAM_NOT_ALLOWED.

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

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

Here is the caller graph for this function:

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 451 of file teamplay.qc.

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

Referenced by bot_clientconnect(), ClientKill_Now_TeamChange(), Join(), and PutPlayerInServer().

{
    //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;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 1104 of file teamplay.qc.

{
    return team_ent.m_num_bots;
}

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 1099 of file teamplay.qc.

Referenced by TeamBalance_AutoBalanceBots(), and TeamBalance_GetLargestTeamIndex().

{
    return team_ent.m_num_players;
}

Here is the caller graph for this function:

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 1094 of file teamplay.qc.

References TEAM_NOT_ALLOWED.

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

{
    return team_ent.m_num_players != TEAM_NOT_ALLOWED;
}

Here is the caller graph for this function:

Variable Documentation

autocvar_g_forced_team_blue

string autocvar_g_forced_team_blue

Definition at line 41 of file teamplay.qc.

Referenced by Player_DetermineForcedTeam().

autocvar_g_forced_team_pink

string autocvar_g_forced_team_pink

Definition at line 43 of file teamplay.qc.

Referenced by Player_DetermineForcedTeam().

autocvar_g_forced_team_red

string autocvar_g_forced_team_red

Definition at line 40 of file teamplay.qc.

Referenced by Player_DetermineForcedTeam().

autocvar_g_forced_team_yellow

string autocvar_g_forced_team_yellow

Definition at line 42 of file teamplay.qc.

Referenced by Player_DetermineForcedTeam().

g_team_entities

entity g_team_entities[NUM_TEAMS]

Holds global team entities.

Definition at line 45 of file teamplay.qc.

Referenced by Team_GetNumberOfAliveTeams(), Team_GetNumberOfTeamsWithOwnedItems(), Team_GetTeam(), Team_GetTeamFromIndex(), Team_GetWinnerAliveTeam(), Team_GetWinnerTeam_WithOwnedItems(), Team_InitTeams(), and TeamBalance_CheckAllowedTeams().

m_num_bots

int m_num_bots

Number of bots in a team.

Definition at line 36 of file teamplay.qc.

m_num_owned_items

int m_num_owned_items

Number of items owned by a team.

Definition at line 38 of file teamplay.qc.

Referenced by Team_GetNumberOfTeamsWithOwnedItems(), and Team_GetWinnerTeam_WithOwnedItems().

m_num_players

int m_num_players

Number of players (both humans and bots) in a team.

Definition at line 35 of file teamplay.qc.

m_num_players_alive

int m_num_players_alive

Number of alive players in a team.

Definition at line 37 of file teamplay.qc.

Referenced by Team_GetNumberOfAliveTeams(), and Team_GetWinnerAliveTeam().

m_team_balance_state

int m_team_balance_state

Holds the state of the team balance entity.

Definition at line 31 of file teamplay.qc.

m_team_balance_team

entity m_team_balance_team[NUM_TEAMS]

???

Definition at line 32 of file teamplay.qc.

m_team_score

float m_team_score

The score of the team.

Definition at line 34 of file teamplay.qc.

TEAM_NOT_ALLOWED

const int TEAM_NOT_ALLOWED = -1

Indicates that the player is not allowed to join a team.

Definition at line 29 of file teamplay.qc.

Referenced by TeamBalance_BanTeamsExcept(), TeamBalance_CheckAllowedTeams(), TeamBalance_IsTeamAllowedInternal(), and TeamBalanceTeam_IsAllowed().