teamplay.qh

Go to the documentation of this file.

#pragma once
 
int autocvar_teamplay_mode;
 
bool autocvar_teamplay_lockonrestart;
 
bool autocvar_g_balance_teams;
bool autocvar_g_balance_teams_prevent_imbalance;
bool autocvar_g_balance_teams_queue;
bool autocvar_g_balance_teams_remove;
int autocvar_g_balance_teams_remove_wait;
 
string autocvar_g_forced_team_otherwise;
 
bool lockteams;
 
.int team_forced; // can be a team number to force a team, or 0 for default action, or -1 for forced spectator
 
 
// ========================== Global teams API ================================
 
void Team_InitTeams();

entity Team_GetTeamFromIndex(int index);

entity Team_GetTeam(int team_num);
 
// ========================= Team specific API ================================

float Team_GetTeamScore(entity team_ent);

void Team_SetTeamScore(entity team_ent, float score);

int Team_GetNumberOfAlivePlayers(entity team_ent);

void Team_SetNumberOfAlivePlayers(entity team_ent, int number);

int Team_GetWinnerAliveTeam();

int Team_GetNumberOfAliveTeams();

int Team_GetWinnerTeam_WithOwnedItems(int min_owned_items);

int Team_GetNumberOfOwnedItems(entity team_ent);

void Team_SetNumberOfOwnedItems(entity team_ent, int number);

int Team_GetNumberOfTeamsWithOwnedItems();
 
// ======================= Entity specific API ================================
 
void setcolor(entity this, int clr);

bool Entity_HasValidTeam(entity this);

int Entity_GetTeamIndex(entity this);

entity Entity_GetTeam(entity this);
 
void SetPlayerColors(entity player, float _color);

bool Player_SetTeamIndex(entity player, int index);
 
enum
{
    TEAM_CHANGE_AUTO = 2, 
    TEAM_CHANGE_MANUAL = 3, 
    TEAM_CHANGE_SPECTATOR = 4 
};
 
bool QueuedPlayersReady(entity this, bool checkspecificteam);

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

bool MoveToTeam(entity client, int team_index, int type);
 
enum
{
    TEAM_FORCE_SPECTATOR = -1, 
    TEAM_FORCE_DEFAULT = 0 
};

bool Player_HasRealForcedTeam(entity player);

int Player_GetForcedTeamIndex(entity player);

void Player_SetForcedTeamIndex(entity player, int team_index);

void Player_DetermineForcedTeam(entity player);
 
// ========================= Team balance API =================================

void TeamBalance_JoinBestTeam(entity player);

entity TeamBalance_CheckAllowedTeams(entity for_whom);

void TeamBalance_Destroy(entity balance);

int TeamBalance_GetAllowedTeams(entity balance);

int TeamBalance_SizeDifference(entity ignore);
 
bool TeamBalance_AreEqual(entity ignore, bool would_leave);
void TeamBalance_RemoveExcessPlayers(entity ignore);
bool TeamBalance_QueuedPlayersTagIn(entity ignore);

bool TeamBalance_IsTeamAllowed(entity balance, int index);

void TeamBalance_GetTeamCounts(entity balance, entity ignore);

int TeamBalance_GetNumberOfPlayers(entity balance, int index);

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

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

enum
{
    TEAMS_COMPARE_INVALID, 
    TEAMS_COMPARE_LESS, 
    TEAMS_COMPARE_EQUAL, 
    TEAMS_COMPARE_GREATER 
};

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

void TeamBalance_AutoBalanceBots();

int TeamBalance_GetLargestTeamIndex(entity balance, int teams);

entity TeamBalance_GetPlayerForTeamSwitch(int source_team_index,
    int destination_team_index, bool is_bot);
 
// ============================ Internal API ==================================
 
void LogTeamChange(float player_id, float team_number, int type);

void KillPlayerForTeamChange(entity player);

bool TeamBalance_IsTeamAllowedInternal(entity balance, int index);

void TeamBalance_BanTeamsExcept(entity balance, int index);

entity TeamBalance_GetTeamFromIndex(entity balance, int index);

entity TeamBalance_GetTeam(entity balance, int team_num);

bool TeamBalanceTeam_IsAllowed(entity team_ent);

int TeamBalanceTeam_GetNumberOfPlayers(entity team_ent);

int TeamBalanceTeam_GetNumberOfBots(entity team_ent);

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

void SV_ChangeTeam(entity player, int new_color);
 
 
bool QueueNeeded(entity ignore);