teamplay.qc File Reference

#include "teamplay.qh"
#include <common/deathtypes/all.qh>
#include <common/gametypes/_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 data entity. More...

Functions
void	_SpawnTeam (string teament_classname, int team_num)
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 client, int team_index)
void	Remove_Countdown (entity this)
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_control_points)
	Returns the winner team.
void	Team_InitTeams ()
int	Team_MapEnts_FindOrSpawn (string ent_classname, int defaultmask)
	Finds any team map entities and returns their bitmask, else spawns them.
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_CompareTeamsInternal (entity team_a, entity team_b, 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.

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.
int	killindicator_teamchange
int	m_num_bots
	Number of bots in a team.
int	m_num_owned_items
	Number of items owned by a team.
int	m_num_players
	Number of players (both humans and bots) in a team.
int	m_num_players_alive
	Number of alive players in a team.
int	m_num_players_net
	.m_num_players but excluding bots that would leave if a human joined their team.
int	m_team_balance_state
	Holds the state of the team balance data entity.
entity	m_team_balance_team [NUM_TEAMS]
	???
float	m_team_score
	The score of the team.
entity	remove_countdown
const int	TEAM_NOT_ALLOWED = -1
	Indicates that the player is not allowed to join a team.

Enumeration Type Documentation

anonymous enum

anonymous enum

Describes a state of team balance data 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

_SpawnTeam()

void _SpawnTeam	(	string	teament_classname,
		int	team_num )

Definition at line 48 of file teamplay.qc.

{
    entity this = new_pure(teament_classname);
    this.netname = Static_Team_ColorName(team_num);
    this.cnt = team_num - 1;
    this.spawnfunc_checked = true;
    this.team = team_num;
}

References cnt, entity(), netname, new_pure, spawnfunc_checked, Static_Team_ColorName(), and team.

Referenced by Team_MapEnts_FindOrSpawn().

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 215 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 210 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 205 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 1232 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 1219 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 328 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 377 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 347 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 342 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 352 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 239 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 267 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	client,
		int	team_index )

Definition at line 1333 of file teamplay.qc.

{
    if (!teamplay || warmup_stage || !autocvar_g_balance_teams_queue || autocvar_g_campaign || client.team > 0)
        return false;
 
    int human_clients = 0;
    FOREACH_CLIENT(IS_REAL_CLIENT(it),
    {
        if (++human_clients > 1)
        {
            if (TeamBalance_AreEqual(client, true))
                return true;
            if (team_index <= 0)
                return false; // auto-select will join a smaller team
 
            entity balance = TeamBalance_CheckAllowedTeams(client);
            TeamBalance_GetTeamCounts(balance, client);
            if ((Team_IndexToBit(team_index) & TeamBalance_FindBestTeams(balance, client, false)) == 0)
            {
                TeamBalance_Destroy(balance);
                return true;
            }
            TeamBalance_Destroy(balance);
            return false;
        }
    });
    return false;
}

References autocvar_g_balance_teams_queue, autocvar_g_campaign, entity(), FOREACH_CLIENT, IS_REAL_CLIENT, Team_IndexToBit(), TeamBalance_AreEqual(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_FindBestTeams(), TeamBalance_GetTeamCounts(), teamplay, and warmup_stage.

Referenced by joinAllowed().

Remove_Countdown()

void Remove_Countdown

(

entity

this

)

Definition at line 675 of file teamplay.qc.

{
    if(this.lifetime <= 0 || TeamBalance_AreEqual(NULL, false))
    {
        if(this.lifetime <= 0)
        {
            Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_MOVETOSPEC_REMOVE, playername(remove_countdown.enemy.netname, remove_countdown.enemy.team, true));
            PutObserverInServer(remove_countdown.enemy, true, true);
        }
 
        Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_REMOVE);
 
        delete(this);
        remove_countdown = NULL;
 
        TeamBalance_RemoveExcessPlayers(NULL); // Check again for excess players in case someone also left while in countdown
        return;
    }
 
    --this.lifetime;
    this.nextthink = time + 1;
}

References CPID_REMOVE, entity(), Kill_Notification(), lifetime, nextthink, NULL, playername(), PutObserverInServer(), remove_countdown, Send_Notification(), TeamBalance_AreEqual(), TeamBalance_RemoveExcessPlayers(), and time.

Referenced by TeamBalance_RemoveExcessPlayers().

setcolor()

void setcolor	(	entity	this,
		int	clr )

Definition at line 190 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 225 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 284 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);
 
        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(), Join(), 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 1327 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 114 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 139 of file teamplay.qc.

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

References AVAILABLE_TEAMS, g_team_entities, m_num_players_alive, 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 167 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 177 of file teamplay.qc.

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

References AVAILABLE_TEAMS, g_team_entities, m_num_owned_items, 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 95 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 86 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 104 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 124 of file teamplay.qc.

{
    int winner = 0;
    for (int i = 0; i < AVAILABLE_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 AVAILABLE_TEAMS, g_team_entities, m_num_players_alive, 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 152 of file teamplay.qc.

{
    int winner = 0;
    for (int i = 0; i < AVAILABLE_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 AVAILABLE_TEAMS, g_team_entities, m_num_owned_items, and Team_IndexToTeam().

Referenced by Domination_CheckWinner(), and Onslaught_CheckWinner().

Team_InitTeams()

void Team_InitTeams

(

)

Definition at line 76 of file teamplay.qc.

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

References AVAILABLE_TEAMS, g_team_entities, and new_pure.

Referenced by ScoreRules_basics().

Team_MapEnts_FindOrSpawn()

int Team_MapEnts_FindOrSpawn	(	string	ent_classname,
		int	defaultmask )

Finds any team map entities and returns their bitmask, else spawns them.

Parameters

[in]	ent_classname	The gametype-specific entity classname to search for.
[in]	defaultmask	The bitmask of the team entities to spawn if the map has none.

Returns

The bitmask of the teams found, == defaultmask if there were none.

Definition at line 56 of file teamplay.qc.

{
    int teams = 0;
    entity head = findchain(classname, ent_classname);
    while (head)
    {
        if (Team_IsValidTeam(head.team))
            teams |= Team_TeamToBit(head.team);
        head = head.chain;
    }
    if (teams)
        return teams;
 
    LOG_TRACEF("No \"%s\" entities found on this map, creating them anyway.", ent_classname);
    for (int i = 1; i <= NUM_TEAMS; ++i)
        if (defaultmask & Team_IndexToBit(i))
            _SpawnTeam(ent_classname, Team_IndexToTeam(i));
    return defaultmask;
}

References _SpawnTeam(), classname, entity(), LOG_TRACEF, NUM_TEAMS, Team_IndexToBit(), Team_IndexToTeam(), Team_IsValidTeam(), Team_TeamToBit(), and teams.

Referenced by ctf_DelayedInit(), tdm_DelayedInit(), and tmayhem_DelayedInit().

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 119 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 172 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 109 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 654 of file teamplay.qc.

{
    entity balance = TeamBalance_CheckAllowedTeams(ignore);
    TeamBalance_GetTeamCounts(balance, ignore);
 
    int prev_size = 0, i = 1;
 
    for (; i <= AVAILABLE_TEAMS; ++i)
    {
        entity team_ent = TeamBalance_GetTeamFromIndex(balance, i);
        int team_size = would_leave ? team_ent.m_num_players_net : team_ent.m_num_players;
        if (i > 1 && team_size != prev_size)
            break;
        prev_size = team_size;
    }
 
    TeamBalance_Destroy(balance);
    return i > AVAILABLE_TEAMS;
}

References AVAILABLE_TEAMS, entity(), team_size, 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 1078 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 <= AVAILABLE_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(AVAILABLE_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 AVAILABLE_TEAMS, BITS, entity(), intermission_running, NULL, 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 1252 of file teamplay.qc.

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

References AVAILABLE_TEAMS, entity(), 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 488 of file teamplay.qc.

{
    entity balance = spawn();
    for (int i = 0; i < AVAILABLE_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 = teamplay_bitmask & BIT(i) ? 0 : TEAM_NOT_ALLOWED;
    }
    setthink(balance, TeamBalance_Destroy);
    balance.nextthink = time;
 
    // 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 <= AVAILABLE_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, entity(), g_team_entities, IS_BOT_CLIENT, setthink, spawn, TEAM_BALANCE_TEAMS_CHECKED, TEAM_NOT_ALLOWED, TeamBalance_BanTeamsExcept(), TeamBalance_Destroy(), TeamBalance_IsTeamAllowedInternal(), teamplay_bitmask, and time.

Referenced by adjust_respawntime(), bot_removefromlargestteam(), bot_setnameandstuff(), ClientCommand_selectteam(), ClientConnect(), ClientKill_TeamChange(), GameCommand_moveplayer(), Join(), MUTATOR_HOOKABLE(), QueueNeeded(), shuffleteams(), TeamBalance_AreEqual(), TeamBalance_AutoBalanceBots(), TeamBalance_GetPlayerForTeamSwitch(), TeamBalance_JoinBestTeam(), TeamBalance_QueuedPlayersTagIn(), TeamBalance_RemoveExcessPlayers(), TeamBalance_SizeDifference(), and WinningCondition_RanOutOfSpawns().

TeamBalance_CompareTeamsInternal()

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

Compares two teams for the purposes of game balance.

Parameters

[in]	team_a	First team.
[in]	team_b	Second team.
[in]	use_score	Whether to take into account team scores and skill ratings.

Returns

TEAMS_COMPARE value. See above.

Note

You need to call TeamBalance_GetTeamCounts before calling this function.

Definition at line 1292 of file teamplay.qc.

{
    if (team_a == team_b)
        return TEAMS_COMPARE_EQUAL;
 
    if (team_a.m_num_players_net < team_b.m_num_players_net)
        return TEAMS_COMPARE_LESS;
    if (team_a.m_num_players_net > team_b.m_num_players_net)
        return TEAMS_COMPARE_GREATER;
    if (!use_score)
        return TEAMS_COMPARE_EQUAL;
 
// Compare skill and score together as team strength.
    // Teams without players have 0 skill_mu but may have a score which must still apply.
    bool use_skill = team_a.m_skill_var && team_b.m_skill_var && autocvar_g_balance_teams_skill
        // z-score, <= threshold SDs means difference isn't significant, formula squared for perf
        && (((team_a.m_skill_mu - team_b.m_skill_mu)**2) / (team_a.m_skill_var + team_b.m_skill_var) > autocvar_g_balance_teams_skill_significance_threshold**2);
    float team_a_strength = use_skill ? team_a.m_skill_mu : 1;
    float team_b_strength = use_skill ? team_b.m_skill_mu : 1;
    // Early in the match scores are ~random due to too few samples,
    // as the match progresses scores become more reliable indicators of team strength.
    // 0.96875 (31/32): if at halftime one team has score 0 and the other has 2 its skill is multiplied by 1.376,
    // < 1 so that a team with 1 point is better than one with 0 (but not by much as sample size is small).
    // Applying full score ratio to one team is equivalent here to applying half of it to each.
    if (!warmup_stage && time > game_starttime)
        team_a_strength *= (1 + ((team_a.m_team_score ? team_a.m_team_score : 0.96875) / (team_b.m_team_score ? team_b.m_team_score : 0.96875) - 1)
                              * ((time - game_starttime) / (autocvar_timelimit * 60))**1.5);
 
    if (team_a_strength < team_b_strength)
        return TEAMS_COMPARE_LESS;
    if (team_a_strength > team_b_strength)
        return TEAMS_COMPARE_GREATER;
    return TEAMS_COMPARE_EQUAL;
}

References autocvar_g_balance_teams_skill, autocvar_g_balance_teams_skill_significance_threshold, autocvar_timelimit, entity(), game_starttime, TEAMS_COMPARE_EQUAL, TEAMS_COMPARE_GREATER, TEAMS_COMPARE_LESS, time, and warmup_stage.

Referenced by TeamBalance_FindBestTeams().

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

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

References AVAILABLE_TEAMS, entity(), and NULL.

Referenced by adjust_respawntime(), bot_setnameandstuff(), ClientCommand_selectteam(), ClientConnect(), ClientKill_TeamChange(), GameCommand_moveplayer(), Join(), QueueNeeded(), 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 962 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 <= AVAILABLE_TEAMS; ++i)
    {
        if (team_bits & Team_IndexToBit(i))
        {
            RandomSelection_AddFloat(i, 1, 1);
        }
    }
    return RandomSelection_chosen_float;
}

References AVAILABLE_TEAMS, entity(), GetGametype(), LOG_FATAL, LOG_FATALF, NULL, 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(), Join(), 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 and skill ratings.

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 1002 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;
    float player_skill_mu = 0, player_skill_var = 0;
    for (int i = 1; i <= AVAILABLE_TEAMS; ++i)
    {
        if (!TeamBalance_IsTeamAllowedInternal(balance, i))
            continue;
        if (previous_team == 0)
        {
            team_bits = Team_IndexToBit(i);
            previous_team = i;
            continue;
        }
 
        entity team_i = TeamBalance_GetTeamFromIndex(balance, i);
        entity team_p = TeamBalance_GetTeamFromIndex(balance, previous_team);
 
        // During warmup the "best" team isn't the smallest or weakest one,
        // that method puts all the noobs on the same team when players join in the "wrong" order.
        // This picks the team(s) whose weighted mean skill differs the most from the joining player's skill,
        // unless they're all close enough in which case it picks smaller team(s).
        // Warmup-only as it must unbalance team sizes in extreme cases, swaps needed should be minimal.
        if (warmup_stage && autocvar_sv_teamnagger && autocvar_g_balance_teams_skill)
        {
            if (!player_skill_mu)
            {
                player_skill_mu = player.m_skill_mu ? player.m_skill_mu : server_skill_average;
                player_skill_var = player.m_skill_var ? player.m_skill_var : (server_skill_average * 0.25)**2;
            }
            // To determine significance, we'll use a z-score of the inverse-variance weightings
            // with an adjustable threshold
            float team_i_z = (team_i.m_skill_mu - player_skill_mu) / sqrt(team_i.m_skill_var + player_skill_var);
            float team_p_z = (team_p.m_skill_mu - player_skill_mu) / sqrt(team_p.m_skill_var + player_skill_var);
            bool significant = fabs(team_i_z - team_p_z) > autocvar_g_balance_teams_skill_significance_threshold;
            // Do fabs afterwards, since the player can be in the middle of the teams (one z +ve, other -ve)
            team_i_z = fabs(team_i_z);
            team_p_z = fabs(team_p_z);
            if ((!significant && team_i.m_num_players_net < team_p.m_num_players_net)
            || ((significant || team_i.m_num_players_net == team_p.m_num_players_net) && team_i_z > team_p_z))
            {
                team_bits = Team_IndexToBit(i);
                previous_team = i;
            }
            else if (team_i_z == team_p_z) // rather unlikely
            {
                team_bits |= Team_IndexToBit(i);
                previous_team = i;
            }
            continue;
        }
 
        int compare = TeamBalance_CompareTeamsInternal(team_i, team_p, use_score);
        if (compare == TEAMS_COMPARE_LESS)
        {
            team_bits = Team_IndexToBit(i);
            previous_team = i;
        }
        else if (compare == TEAMS_COMPARE_EQUAL)
        {
            team_bits |= Team_IndexToBit(i);
            previous_team = i;
        }
    }
    return team_bits;
}

References autocvar_g_balance_teams_skill, autocvar_g_balance_teams_skill_significance_threshold, autocvar_sv_teamnagger, AVAILABLE_TEAMS, entity(), fabs(), LOG_FATAL, M_ARGV, MUTATOR_CALLHOOK, NULL, server_skill_average, sqrt(), TEAM_BALANCE_TEAM_COUNTS_FILLED, Team_IndexToBit(), TeamBalance_CompareTeamsInternal(), TeamBalance_FindBestTeams(), TeamBalance_GetTeamFromIndex(), TeamBalance_IsTeamAllowedInternal(), TEAMS_COMPARE_EQUAL, TEAMS_COMPARE_LESS, and warmup_stage.

Referenced by ClientCommand_selectteam(), MUTATOR_HOOKABLE(), QueueNeeded(), 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 610 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 <= AVAILABLE_TEAMS; ++i)
    {
        if (TeamBalance_IsTeamAllowedInternal(balance, i))
        {
            result |= Team_IndexToBit(i);
        }
    }
    return result;
}

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

Referenced by ClientConnect().

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

{
    int largest_team_index = 0;
    int largest_team_player_count = 0;
    for (int i = 1; i <= AVAILABLE_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 AVAILABLE_TEAMS, entity(), 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 945 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 1180 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 1272 of file teamplay.qc.

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

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

Referenced by 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 827 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 <= AVAILABLE_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
    {
        float skill_weight = 0, skill_weight_sum = 0;
        server_skill_average = 0;
        // Manually count all players.
        FOREACH_CLIENT(true,
        {
            if (it.m_skill_mu && it.m_skill_var)
            {
                skill_weight = 1 / it.m_skill_var;
                server_skill_average += it.m_skill_mu * skill_weight;
                skill_weight_sum += skill_weight;
            }
 
            if (it == ignore)
                continue;
 
            int team_num = it.killindicator_teamchange > 0 ? it.killindicator_teamchange : it.team;
            if (team_num <= 0)
            {
                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_net = ++team_ent.m_num_players;
            if (IS_BOT_CLIENT(it))
                ++team_ent.m_num_bots;
 
            if (it.m_skill_mu && it.m_skill_var)
            {
                // skill_weight calculated above
                team_ent.m_skill_mu += it.m_skill_mu * skill_weight;
                team_ent.mass += skill_weight;
                ++team_ent.count;
            }
        });
 
        // deduct bots that would leave if a player joined their team, distributing the deductions between teams
        // bones_was_here: not sure if it's safe to apply this to .m_num_players so using .m_num_players_net
        for (int i = 1, bots_todo = bots_would_leave; bots_todo > 0 && i <= AVAILABLE_TEAMS; ++i)
        {
            entity team_ent = TeamBalance_GetTeamFromIndex(balance, i);
            int to_remove = min(team_ent.m_num_bots, ceil(bots_todo / AVAILABLE_TEAMS));
            team_ent.m_num_players_net -= to_remove;
            bots_todo -= to_remove;
        }
 
        // Calculate inverse-variance weighted mean skill ratings,
        // for each unranked client use a fraction of the mean of all clients' skill ratings.
        server_skill_average = (skill_weight_sum && autocvar_g_balance_teams_skill_unranked_factor > 0)
            ? autocvar_g_balance_teams_skill_unranked_factor * server_skill_average / skill_weight_sum
            : 1000;
        float server_skill_average_var = 0; skill_weight = 0; // will only be calculated once, if needed
        for (int i = 1; i <= AVAILABLE_TEAMS; ++i)
        {
            entity team_ent = TeamBalance_GetTeamFromIndex(balance, i);
            int unranked_clients = team_ent.m_num_players_net - team_ent.count;
            if (unranked_clients)
            {
                if (!server_skill_average_var)
                {
                    server_skill_average_var = (server_skill_average * 0.25)**2;
                    skill_weight = 1 / server_skill_average_var;
                }
                team_ent.m_skill_mu += (server_skill_average * skill_weight) * unranked_clients;
                team_ent.mass += skill_weight * unranked_clients;
            }
            if (team_ent.mass)
            {
                // .mass is storing the arithmetic sum of members' inverse-variance weightings
                // Hence the team's   mean   is: team_ent.m_skill_mu / team_ent.mass
                // Hence the team's variance is: 1 / team_ent.mass
                team_ent.m_skill_mu /= team_ent.mass;
                team_ent.m_skill_var = 1 / team_ent.mass;
            }
        }
    }
 
    // 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_balance_teams_skill_unranked_factor, autocvar_g_campaign, autocvar_g_campaign_forceteam, AVAILABLE_TEAMS, bots_would_leave, ceil(), entity(), FOREACH_CLIENT, IS_BOT_CLIENT, LOG_FATAL, M_ARGV, min(), MUTATOR_CALLHOOK, NULL, Player_HasRealForcedTeam(), server_skill_average, 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(), QueueNeeded(), 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 1263 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_FindBestTeams(), 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 807 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 1246 of file teamplay.qc.

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

References AVAILABLE_TEAMS, 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 452 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 763 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 j = 1; j <= AVAILABLE_TEAMS; ++j)
    {
        it = TeamBalance_GetTeamFromIndex(balance, j);
        // find the largest team size
        if (it.m_num_players_net > teamplayers_max)
            teamplayers_max = it.m_num_players_net;
    }
    // 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_net;
 
    // 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_net >= teamplayers_max) continue;
        Join(it, false);
        ++TeamBalance_GetTeam(balance, it.team).m_num_players_net;
        --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_net as we won't read it again
    }
 
    TeamBalance_Destroy(balance);
    return teamplayers_deficit <= 0; // return true if teams are now balanced
}

References AVAILABLE_TEAMS, entity(), ftoe, Join(), maxclients, 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 700 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 631 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 1287 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 1282 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 1277 of file teamplay.qc.

{
    return team_ent && team_ent.m_num_players != TEAM_NOT_ALLOWED;
}

References entity(), and TEAM_NOT_ALLOWED.

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

Variable Documentation

autocvar_g_forced_team_blue

string autocvar_g_forced_team_blue

Definition at line 42 of file teamplay.qc.

Referenced by Player_DetermineForcedTeam().

autocvar_g_forced_team_pink

string autocvar_g_forced_team_pink

Definition at line 44 of file teamplay.qc.

Referenced by Player_DetermineForcedTeam().

autocvar_g_forced_team_red

string autocvar_g_forced_team_red

Definition at line 41 of file teamplay.qc.

Referenced by Player_DetermineForcedTeam().

autocvar_g_forced_team_yellow

string autocvar_g_forced_team_yellow

Definition at line 43 of file teamplay.qc.

Referenced by Player_DetermineForcedTeam().

g_team_entities

entity g_team_entities[NUM_TEAMS]

Holds global team entities.

Definition at line 46 of file teamplay.qc.

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

killindicator_teamchange

int killindicator_teamchange

Definition at line 826 of file teamplay.qc.

m_num_bots

int m_num_bots

Number of bots in a team.

Definition at line 37 of file teamplay.qc.

m_num_owned_items

int m_num_owned_items

Number of items owned by a team.

Definition at line 39 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 38 of file teamplay.qc.

Referenced by Team_GetNumberOfAliveTeams(), and Team_GetWinnerAliveTeam().

m_num_players_net

int m_num_players_net

.m_num_players but excluding bots that would leave if a human joined their team.

Definition at line 36 of file teamplay.qc.

m_team_balance_state

int m_team_balance_state

Holds the state of the team balance data 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.

remove_countdown

entity remove_countdown

Definition at line 674 of file teamplay.qc.

Referenced by Remove_Countdown(), and TeamBalance_RemoveExcessPlayers().

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