#include "utils.qh"
#include <server/intermission.qh>
#include <common/replicate.qh>
#include <common/sounds/all.qh>

Include dependency graph for client.qh:

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

Go to the source code of this file.

Classes
class	Client

class	Observer

class	Player

class	Spectator

Macros
#define	GAMETYPE_DEFAULTED_SETTING(str)

#define	INDEPENDENT_PLAYERS (autocvar__independent_players ? (autocvar__independent_players > 0) : independent_players)

#define	IS_INDEPENDENT_PLAYER(e) ((e).solid == SOLID_TRIGGER)

#define	MAKE_INDEPENDENT_PLAYER(e) (((e).solid = SOLID_TRIGGER), ((e).frags = FRAGS_PLAYER_OUT_OF_GAME))

#define	SPECTATE_COPY() ACCUMULATE void SpectateCopy(entity this, entity spectatee)

#define	SPECTATE_COPYFIELD(fld) SPECTATE_COPY() { this.(fld) = spectatee.(fld); }

#define	UNWIND(class) MACRO_BEGIN if (this.instanceOf##class) { METHOD_REFERENCE(class, dtorimpl)(this); } MACRO_END

Functions
void	calculate_player_respawn_time (entity this)

void	ClientData_Touch (entity e)

void	ClientInit_misc (entity this)

void	ClientInit_Spawn ()

void	ClientState_attach (entity this)

void	FixClientCvars (entity e)

void	FixPlayermodel (entity player)

int	GetPlayerLimit ()

void	Join (entity this)

bool	joinAllowed (entity this)

int	nJoinAllowed (entity this, entity ignore)
	Determines whether the player is allowed to join. More...

void	play_countdown (entity this, float finished, Sound samp)

void	player_powerups_remove_all (entity this)

bool	PlayerInList (entity player, string list)

void	PlayerUseKey (entity this)

void	PutObserverInServer (entity this, bool is_forced, bool use_spawnpoint)
	putting a client as observer in the server More...

void	RotRegen (entity this, entity current, float limit_mod, float regenstable, float regenfactor, float regenlinear, float regenframetime, float rotstable, float rotfactor, float rotlinear, float rotframetime)

void	SetSpectatee (entity this, entity spectatee)

void	SetSpectatee_status (entity this, int spectatee_num)

bool	Spectate (entity this, entity pl)

	STATIC_INIT (g_players)

	STATIC_INIT (g_initforplayer)

	void (entity this, entity player) init_for_player

Variables
float	alivetime

int	autocvar__independent_players

bool	autocvar__notarget

int	autocvar_g_balance_armor_start

float	autocvar_g_balance_pause_armor_rot_spawn

float	autocvar_g_balance_pause_fuel_rot_spawn

float	autocvar_g_balance_pause_health_regen_spawn

float	autocvar_g_balance_pause_health_rot_spawn

bool	autocvar_g_botclip_collisions

bool	autocvar_g_forced_respawn

bool	autocvar_g_fullbrightplayers

int	autocvar_g_maxplayers

float	autocvar_g_maxplayers_spectator_blocktime

string	autocvar_g_mutatormsg

bool	autocvar_g_nodepthtestplayers

float	autocvar_g_player_alpha

float	autocvar_g_player_brightness

float	autocvar_g_player_damageforcescale = 2

bool	autocvar_g_playerclip_collisions

bool	autocvar_g_respawn_delay_forced

float	autocvar_g_respawn_delay_large

int	autocvar_g_respawn_delay_large_count

float	autocvar_g_respawn_delay_max

float	autocvar_g_respawn_delay_small

int	autocvar_g_respawn_delay_small_count

bool	autocvar_g_respawn_ghosts

float	autocvar_g_respawn_ghosts_alpha = 1

float	autocvar_g_respawn_ghosts_fadetime = 1.5

float	autocvar_g_respawn_ghosts_speed

float	autocvar_g_respawn_ghosts_time = 4.5

int	autocvar_g_respawn_waves

string	autocvar_g_xonoticversion

float	autocvar_gameversion

float	autocvar_gameversion_max

float	autocvar_gameversion_min

string	autocvar_hostname

int	autocvar_spawn_debug

float	autocvar_sv_foginterval

float	autocvar_sv_maxidle

bool	autocvar_sv_maxidle_alsokickspectators

int	autocvar_sv_maxidle_minplayers = 2

float	autocvar_sv_maxidle_playertospectator = 60

int	autocvar_sv_maxidle_slots

bool	autocvar_sv_maxidle_slots_countbots

string	autocvar_sv_motd

int	autocvar_sv_name_maxlength = 64

float	autocvar_sv_player_scale

bool	autocvar_sv_servermodelsonly

bool	autocvar_sv_showspectators

int	autocvar_sv_spectate

bool	autocvar_sv_teamnagger

float	blockSpectators

entity	clientdata

IntrusiveList	g_initforplayer

IntrusiveList	g_players

bool	independent_players

float	jointime

bool	just_joined

int	killcount

const int	MAX_SPECTATORS = 7

const int	MIN_SPEC_TIME = 1

float	motd_actived_time

float	nickspamcount

float	nickspamtime

float	pauseregen_finished

float	pauserotarmor_finished

float	pauserotfuel_finished

float	pauserothealth_finished

bool	player_blocked

int	playerid

string	playermodel

string	playerskin

int	pressedkeys

float	respawn_countdown

const int	RESPAWN_DENY = BIT(2)

int	respawn_flags

const int	RESPAWN_FORCE = BIT(0)

const int	RESPAWN_SILENT = BIT(1)

float	respawn_time

float	respawn_time_max

int	spectatee_status

float	spectatortime

float	startplaytime

const int	SVC_SETVIEW = 5

bool	wasplayer

string	weaponorder_byimpulse

bool	zoomstate

Macro Definition Documentation

◆ GAMETYPE_DEFAULTED_SETTING

#define GAMETYPE_DEFAULTED_SETTING ( str )

Value:

((gametype_setting_tmp = cvar(strcat("g_", GetGametype(), "_" #str))), \
    (gametype_setting_tmp < 0) ? 0 \
    : (gametype_setting_tmp == 0 || autocvar_g_respawn_delay_forced) ? max(0, autocvar_g_##str) \
    : gametype_setting_tmp)

Definition at line 352 of file client.qh.

Referenced by calculate_player_respawn_time().

◆ INDEPENDENT_PLAYERS

#define INDEPENDENT_PLAYERS (autocvar__independent_players ? (autocvar__independent_players > 0) : independent_players)

Definition at line 313 of file client.qh.

Referenced by PutPlayerInServer(), and ScoreRules_basics().

◆ IS_INDEPENDENT_PLAYER

#define IS_INDEPENDENT_PLAYER ( e ) ((e).solid == SOLID_TRIGGER)

Definition at line 314 of file client.qh.

Referenced by accuracy_add(), buff_Inferno_CalculateTime(), buff_Touch(), calculate_player_respawn_time(), Damage(), Fire_ApplyDamage(), havocbot_ai(), havocbot_chooseenemy(), MUTATOR_HOOKFUNCTION(), PlayerPreThink(), PlayerUseKey(), Portal_Customize(), Portal_Damage(), Portal_Think(), Portal_Touch(), and target_init_use().

◆ MAKE_INDEPENDENT_PLAYER

#define MAKE_INDEPENDENT_PLAYER ( e ) (((e).solid = SOLID_TRIGGER), ((e).frags = FRAGS_PLAYER_OUT_OF_GAME))

Definition at line 315 of file client.qh.

Referenced by PutPlayerInServer(), race_AbandonRaceCheck(), and race_SendTime().

◆ SPECTATE_COPY

#define SPECTATE_COPY ( ) ACCUMULATE void SpectateCopy(entity this, entity spectatee)

Definition at line 403 of file client.qh.

◆ SPECTATE_COPYFIELD

#define SPECTATE_COPYFIELD ( fld ) SPECTATE_COPY() { this.(fld) = spectatee.(fld); }

Definition at line 404 of file client.qh.

◆ UNWIND

#define UNWIND ( class ) MACRO_BEGIN if (this.instanceOf##class) { METHOD_REFERENCE(class, dtorimpl)(this); } MACRO_END

Referenced by Player::Player ::~ Player().

Function Documentation

◆ calculate_player_respawn_time()

void calculate_player_respawn_time ( entity this )

Definition at line 1315 of file client.qc.

References autocvar_g_forced_respawn, ceil(), FOREACH_CLIENT, GAMETYPE_DEFAULTED_SETTING, IS_INDEPENDENT_PLAYER, IS_PLAYER, MUTATOR_CALLHOOK, respawn_countdown, respawn_flags, RESPAWN_FORCE, respawn_time, respawn_time_max, teamplay, and time.

Referenced by PlayerDamage().

 {
     if(MUTATOR_CALLHOOK(CalculateRespawnTime, this))
         return;
 
     float gametype_setting_tmp;
     float sdelay_max = GAMETYPE_DEFAULTED_SETTING(respawn_delay_max);
     float sdelay_small = GAMETYPE_DEFAULTED_SETTING(respawn_delay_small);
     float sdelay_large = GAMETYPE_DEFAULTED_SETTING(respawn_delay_large);
     float sdelay_small_count = GAMETYPE_DEFAULTED_SETTING(respawn_delay_small_count);
     float sdelay_large_count = GAMETYPE_DEFAULTED_SETTING(respawn_delay_large_count);
     float waves = GAMETYPE_DEFAULTED_SETTING(respawn_waves);
 
     float pcount = 1;  // Include myself whether or not team is already set right and I'm a "player".
     if (teamplay)
     {
         FOREACH_CLIENT(IS_PLAYER(it) && it != this, {
             if(it.team == this.team)
                 ++pcount;
         });
         if (sdelay_small_count == 0)
             sdelay_small_count = 1;
         if (sdelay_large_count == 0)
             sdelay_large_count = 1;
     }
     else
     {
         FOREACH_CLIENT(IS_PLAYER(it) && it != this, {
             ++pcount;
         });
         if (sdelay_small_count == 0)
         {
             if (IS_INDEPENDENT_PLAYER(this))
             {
                 // Players play independently. No point in requiring enemies.
                 sdelay_small_count = 1;
             }
             else
             {
                 // Players play AGAINST each other. Enemies required.
                 sdelay_small_count = 2;
             }
         }
         if (sdelay_large_count == 0)
         {
             if (IS_INDEPENDENT_PLAYER(this))
             {
                 // Players play independently. No point in requiring enemies.
                 sdelay_large_count = 1;
             }
             else
             {
                 // Players play AGAINST each other. Enemies required.
                 sdelay_large_count = 2;
             }
         }
     }
 
     float sdelay;
 
     if (pcount <= sdelay_small_count)
         sdelay = sdelay_small;
     else if (pcount >= sdelay_large_count)
         sdelay = sdelay_large;
     else  // NOTE: this case implies sdelay_large_count > sdelay_small_count.
         sdelay = sdelay_small + (sdelay_large - sdelay_small) * (pcount - sdelay_small_count) / (sdelay_large_count - sdelay_small_count);
 
     if(waves)
         this.respawn_time = ceil((time + sdelay) / waves) * waves;
     else
         this.respawn_time = time + sdelay;
 
     if(sdelay < sdelay_max)
         this.respawn_time_max = time + sdelay_max;
     else
         this.respawn_time_max = this.respawn_time;
 
     if((sdelay + waves >= 5.0) && (this.respawn_time - time > 1.75))
         this.respawn_countdown = 10; // first number to count down from is 10
     else
         this.respawn_countdown = -1; // do not count down
 
     if(autocvar_g_forced_respawn)
         this.respawn_flags = this.respawn_flags | RESPAWN_FORCE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClientData_Touch()

void ClientData_Touch ( entity e )

Definition at line 171 of file client.qc.

References CS(), entity(), FOREACH_CLIENT, IS_REAL_CLIENT, and IS_SPEC.

Referenced by race_AbandonRaceCheck(), race_SendTime(), SetSpectatee(), SetSpectatee_status(), SetZoomState(), and SpectateSet().

 {
     entity cd = CS(e).clientdata;
     if (cd) { cd.SendFlags = 1; }
 
     // make it spectatable
     FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != e && IS_SPEC(it) && it.enemy == e,
     {
         entity cd = CS(it).clientdata;
         if (cd) { cd.SendFlags = 1; }
     });
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClientInit_misc()

void ClientInit_misc ( entity this )

Definition at line 855 of file client.qc.

References autocvar_g_trueaim_minrange, autocvar_sv_foginterval, cnt, compressShotOrigin(), count, g_nexball_meter_period, hook_shotorigin, MSG_ONE, serverflags, world, WriteByte(), WriteCoord(), and WriteString().

Referenced by ClientInit_SendEntity(), and STATIC_INIT().

 {
     int channel = MSG_ONE;
     WriteHeader(channel, ENT_CLIENT_INIT);
     WriteByte(channel, g_nexball_meter_period * 32);
     WriteInt24_t(channel, compressShotOrigin(hook_shotorigin[0]));
     WriteInt24_t(channel, compressShotOrigin(hook_shotorigin[1]));
     WriteInt24_t(channel, compressShotOrigin(hook_shotorigin[2]));
     WriteInt24_t(channel, compressShotOrigin(hook_shotorigin[3]));
     WriteInt24_t(channel, compressShotOrigin(arc_shotorigin[0]));
     WriteInt24_t(channel, compressShotOrigin(arc_shotorigin[1]));
     WriteInt24_t(channel, compressShotOrigin(arc_shotorigin[2]));
     WriteInt24_t(channel, compressShotOrigin(arc_shotorigin[3]));
 
     if(autocvar_sv_foginterval && world.fog != "")
         WriteString(channel, world.fog);
     else
         WriteString(channel, "");
     WriteByte(channel, this.count * 255.0); // g_balance_armor_blockpercent
     WriteByte(channel, this.cnt * 255.0); // g_balance_damagepush_speedfactor
     WriteByte(channel, serverflags);
     WriteCoord(channel, autocvar_g_trueaim_minrange);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClientInit_Spawn()

void ClientInit_Spawn ( )

Definition at line 894 of file client.qc.

References ClientInit_CheckUpdate(), ClientInit_SendEntity(), entity(), new_pure, and setthink.

Referenced by spawnfunc(), and STATIC_INIT().

 {
     entity e = new_pure(clientinit);
     setthink(e, ClientInit_CheckUpdate);
     Net_LinkEntity(e, false, 0, ClientInit_SendEntity);
 
     ClientInit_CheckUpdate(e);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClientState_attach()

void ClientState_attach ( entity this )

Definition at line 46 of file state.qc.

References _cs, accuracy_free(), accuracy_init(), anticheat_init(), anticheat_report_to_eventlog(), bot_clientdisconnect(), ClientData_Attach(), ClientData_Detach(), DecodeLevelParms(), entcs_attach(), entcs_detach(), entity(), InventoryStorage_attach(), NEW, PlayerScore_Attach(), PlayerScore_Detach(), W_HitPlotClose(), and W_HitPlotOpen().

Referenced by Client::Client ::Client().

 {
     this._cs = NEW(ClientState, this);
 
     // TODO: fold all of these into ClientState
 
     DecodeLevelParms(this);
 
     PlayerScore_Attach(this);
     PlayerStats_PlayerBasic_CheckUpdate(this);
     ClientData_Attach(this);
     accuracy_init(this);
     entcs_attach(this);
     anticheat_init(this);
     W_HitPlotOpen(this);
     InventoryStorage_attach(this);
     StatusEffectsStorage_attach(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FixClientCvars()

void FixClientCvars ( entity e )

Definition at line 947 of file client.qc.

References autocvar_g_antilag, FixClientCvars(), MUTATOR_CALLHOOK, and stuffcmd.

Referenced by ClientConnect(), FixClientCvars(), and MapVote_Finished().

 {
     // send prediction settings to the client
     if(autocvar_g_antilag == 3) // client side hitscan
         stuffcmd(e, "cl_cmd settemp cl_prydoncursor_notrace 0\n");
     if(autocvar_sv_gentle)
         stuffcmd(e, "cl_cmd settemp cl_gentle 1\n");
 
     stuffcmd(e, sprintf("\ncl_jumpspeedcap_min \"%s\"\n", autocvar_sv_jumpspeedcap_min));
     stuffcmd(e, sprintf("\ncl_jumpspeedcap_max \"%s\"\n", autocvar_sv_jumpspeedcap_max));
 
     stuffcmd(e, sprintf("\ncl_shootfromfixedorigin \"%s\"\n", autocvar_g_shootfromfixedorigin));
 
     MUTATOR_CALLHOOK(FixClientCvars, e);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FixPlayermodel()

void FixPlayermodel ( entity player )

Definition at line 423 of file client.qc.

Referenced by FixPlayermodel(), PlayerThink(), PutObserverInServer(), PutPlayerInServer(), and STATIC_INIT().

 {
     string defaultmodel = "";
     int defaultskin = 0;
     if(autocvar_sv_defaultcharacter)
     {
         if(teamplay)
         {
             switch(player.team)
             {
                 case NUM_TEAM_1: defaultmodel = autocvar_sv_defaultplayermodel_red; defaultskin = autocvar_sv_defaultplayerskin_red; break;
                 case NUM_TEAM_2: defaultmodel = autocvar_sv_defaultplayermodel_blue; defaultskin = autocvar_sv_defaultplayerskin_blue; break;
                 case NUM_TEAM_3: defaultmodel = autocvar_sv_defaultplayermodel_yellow; defaultskin = autocvar_sv_defaultplayerskin_yellow; break;
                 case NUM_TEAM_4: defaultmodel = autocvar_sv_defaultplayermodel_pink; defaultskin = autocvar_sv_defaultplayerskin_pink; break;
             }
         }
 
         if(defaultmodel == "")
         {
             defaultmodel = autocvar_sv_defaultplayermodel;
             defaultskin = autocvar_sv_defaultplayerskin;
         }
 
         int n = tokenize_console(defaultmodel);
         if(n > 0)
         {
             defaultmodel = argv(floor(n * CS(player).model_randomizer));
             // However, do NOT randomize if the player-selected model is in the list.
             for (int i = 0; i < n; ++i)
                 if ((argv(i) == player.playermodel && defaultskin == stof(player.playerskin)) || argv(i) == strcat(player.playermodel, ":", player.playerskin))
                     defaultmodel = argv(i);
         }
 
         int i = strstrofs(defaultmodel, ":", 0);
         if(i >= 0)
         {
             defaultskin = stof(substring(defaultmodel, i+1, -1));
             defaultmodel = substring(defaultmodel, 0, i);
         }
     }
     if(autocvar_sv_defaultcharacterskin && !defaultskin)
     {
         if(teamplay)
         {
             switch(player.team)
             {
                 case NUM_TEAM_1: defaultskin = autocvar_sv_defaultplayerskin_red; break;
                 case NUM_TEAM_2: defaultskin = autocvar_sv_defaultplayerskin_blue; break;
                 case NUM_TEAM_3: defaultskin = autocvar_sv_defaultplayerskin_yellow; break;
                 case NUM_TEAM_4: defaultskin = autocvar_sv_defaultplayerskin_pink; break;
             }
         }
 
         if(!defaultskin)
             defaultskin = autocvar_sv_defaultplayerskin;
     }
 
     MUTATOR_CALLHOOK(FixPlayermodel, defaultmodel, defaultskin, player);
     defaultmodel = M_ARGV(0, string);
     defaultskin = M_ARGV(1, int);
 
     bool chmdl = false;
     int oldskin;
     if(defaultmodel != "")
     {
         if (defaultmodel != player.model)
         {
             vector m1 = player.mins;
             vector m2 = player.maxs;
             setplayermodel (player, defaultmodel);
             setsize (player, m1, m2);
             chmdl = true;
         }
 
         oldskin = player.skin;
         player.skin = defaultskin;
     } else {
         if (player.playermodel != player.model || player.playermodel == "")
         {
             player.playermodel = CheckPlayerModel(player.playermodel); // this is never "", so no endless loop
             vector m1 = player.mins;
             vector m2 = player.maxs;
             setplayermodel (player, player.playermodel);
             setsize (player, m1, m2);
             chmdl = true;
         }
 
         if(!autocvar_sv_defaultcharacterskin)
         {
             oldskin = player.skin;
             player.skin = stof(player.playerskin);
         }
         else
         {
             oldskin = player.skin;
             player.skin = defaultskin;
         }
     }
 
     if(chmdl || oldskin != player.skin) // model or skin has changed
     {
         player.species = player_getspecies(player); // update species
         if(!autocvar_g_debug_globalsounds)
             UpdatePlayerSounds(player); // update skin sounds
     }
 
     if(!teamplay)
         if(strlen(autocvar_sv_defaultplayercolors))
             if(player.clientcolors != stof(autocvar_sv_defaultplayercolors))
                 setcolor(player, stof(autocvar_sv_defaultplayercolors));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPlayerLimit()

int GetPlayerLimit ( )

Definition at line 1990 of file client.qc.

References autocvar_g_maxplayers, g_duel, GetPlayerLimit(), M_ARGV, and MUTATOR_CALLHOOK.

Referenced by bot_fixcount(), GetPlayerLimit(), MapHasRightSize(), nJoinAllowed(), and STATIC_INIT().

 {
     if(g_duel)
         return 2; // TODO: this workaround is needed since the mutator hook from duel can't be activated before the gametype is loaded (e.g. switching modes via gametype vote screen)
     int player_limit = autocvar_g_maxplayers;
     MUTATOR_CALLHOOK(GetPlayerLimit, player_limit);
     player_limit = M_ARGV(0, int);
     return player_limit;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Join()

void Join ( entity this )

Definition at line 1966 of file client.qc.

References autocvar_g_balance_teams, autocvar_g_campaign, campaign_bots_may_start, IS_PLAYER, netname, NULL, PutClientInServer(), team, team_selected, TeamBalance_JoinBestTeam(), teamplay, and TRANSMUTE().

Referenced by ClientCommand_join(), ObserverOrSpectatorThink(), and PlayerPreThink().

 {
     TRANSMUTE(Player, this);
 
     if(!this.team_selected)
     if(autocvar_g_campaign || autocvar_g_balance_teams)
         TeamBalance_JoinBestTeam(this);
 
     if(autocvar_g_campaign)
         campaign_bots_may_start = true;
 
     Kill_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CPID_PREVENT_JOIN);
 
     PutClientInServer(this);
 
     if(IS_PLAYER(this))
     if(teamplay && this.team != -1)
     {
     }
     else
         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_JOIN_PLAY, this.netname);
     this.team_selected = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ joinAllowed()

bool joinAllowed ( entity this )

Definition at line 2108 of file client.qc.

References CS(), jointime, lockteams, MIN_SPEC_TIME, MUTATOR_CALLHOOK, nJoinAllowed(), ShowTeamSelection(), teamplay, and time.

Referenced by ClientCommand_join(), ObserverOrSpectatorThink(), and PlayerPreThink().

 {
     if (CS(this).version_mismatch) return false;
     if (time < CS(this).jointime + MIN_SPEC_TIME) return false;
     if (!nJoinAllowed(this, this)) return false;
     if (teamplay && lockteams) return false;
     if (MUTATOR_CALLHOOK(ForbidSpawn, this)) return false;
     if (ShowTeamSelection(this)) return false;
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nJoinAllowed()

int nJoinAllowed	(	entity	this,
		entity	ignore
	)

Determines whether the player is allowed to join.

This depends on cvar g_maxplayers, if it isn't used this function always return true, otherwise it checks whether the number of currently playing players exceeds g_maxplayers.

Returns: int number of free slots for players, 0 if none

Definition at line 2006 of file client.qc.

References autocvar_g_forced_team_otherwise, FOREACH_CLIENT, GetPlayerLimit(), INGAME, IS_PLAYER, IS_REAL_CLIENT, maxclients, min(), Player_GetForcedTeamIndex(), TEAM_FORCE_SPECTATOR, and time.

Referenced by joinAllowed(), and WinningConditionHelper().

 {
     if(!ignore)
     // this is called that way when checking if anyone may be able to join (to build qcstatus)
     // so report 0 free slots if restricted
     {
         if(autocvar_g_forced_team_otherwise == "spectate")
             return 0;
         if(autocvar_g_forced_team_otherwise == "spectator")
             return 0;
     }
 
     if(this && (Player_GetForcedTeamIndex(this) == TEAM_FORCE_SPECTATOR))
         return 0; // forced spectators can never join
 
     // TODO simplify this
     int totalClients = 0;
     int currentlyPlaying = 0;
     FOREACH_CLIENT(true, {
         if(it != ignore)
             ++totalClients;
         if(IS_REAL_CLIENT(it) && (IS_PLAYER(it) || INGAME(it)))
             ++currentlyPlaying;
     });
 
     int player_limit = GetPlayerLimit();
 
     int free_slots = 0;
     if (!player_limit)
         free_slots = maxclients - totalClients;
     else if(player_limit > 0 && currentlyPlaying < player_limit)
         free_slots = min(maxclients - totalClients, player_limit - currentlyPlaying);
 
     static float msg_time = 0;
     if(this && !INGAME(this) && ignore && !free_slots && time > msg_time)
     {
         Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_JOIN_PREVENT);
         msg_time = time + 0.5;
     }
 
     return free_slots;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ play_countdown()

void play_countdown	(	entity	this,
		float	finished,
		Sound	samp
	)

Definition at line 1447 of file client.qc.

References ATTEN_NORM, CH_INFO, floor(), frametime, IS_REAL_CLIENT, sound, TC, time, and VOL_BASE.

Referenced by player_powerups(), and STATIC_INIT().

 {
     TC(Sound, samp);
     if(IS_REAL_CLIENT(this))
         if(floor(finished - time - frametime) != floor(finished - time))
             if(finished - time < 6)
                 sound (this, CH_INFO, samp, VOL_BASE, ATTEN_NORM);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ player_powerups_remove_all()

void player_powerups_remove_all ( entity this )

Definition at line 1457 of file client.qc.

References ATTEN_NORM, CH_INFO, CH_TRIGGER_SINGLE, IS_CLIENT, items, sound, time, and VOL_BASE.

Referenced by ClientDisconnect(), player_powerups(), PutObserverInServer(), reset_map(), and STATIC_INIT().

 {
     if (this.items & (IT_SUPERWEAPON | IT_UNLIMITED_AMMO | IT_UNLIMITED_SUPERWEAPONS))
     {
         // don't play the poweroff sound when the game restarts or the player disconnects
         if (time > game_starttime + 1 && IS_CLIENT(this))
             sound(this, CH_INFO, SND_POWEROFF, VOL_BASE, ATTEN_NORM);
         if (this.items & (IT_UNLIMITED_AMMO | IT_UNLIMITED_SUPERWEAPONS))
             stopsound(this, CH_TRIGGER_SINGLE); // get rid of the pickup sound
         this.items -= (this.items & (IT_SUPERWEAPON | IT_UNLIMITED_AMMO | IT_UNLIMITED_SUPERWEAPONS));
     }
 }

Here is the caller graph for this function:

◆ PlayerInList()

bool PlayerInList	(	entity	player,
		string	list
	)

Definition at line 995 of file client.qc.

References autocvar_sv_eventlog, boolean, entity(), etof(), GameLogEcho(), IS_REAL_CLIENT, netaddress, playerid, PlayerInIDList(), and PlayerInIPList().

Referenced by Player_DetermineForcedTeam().

 {
     return boolean(PlayerInIDList(player, list) || PlayerInIPList(player, list));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PlayerUseKey()

void PlayerUseKey ( entity this )

Definition at line 2349 of file client.qc.

References DAMAGE_NO, entity(), IS_DEAD, IS_INDEPENDENT_PLAYER, IS_PLAYER, IS_VEHICLE, MUTATOR_CALLHOOK, NULL, origin, PlayerUseKey(), SAME_TEAM, vehicle, vehicles_enter(), vehicles_exit(), VHF_MULTISLOT, vlen2, and WarpZone_FindRadius().

Referenced by IMPULSE(), PlayerPreThink(), and PlayerUseKey().

 {
     if (!IS_PLAYER(this))
         return;
 
     if(this.vehicle)
     {
         if(!game_stopped)
         {
             vehicles_exit(this.vehicle, VHEF_NORMAL);
             return;
         }
     }
     else if(autocvar_g_vehicles_enter)
     {
         if(!game_stopped && !STAT(FROZEN, this) && !IS_DEAD(this) && !IS_INDEPENDENT_PLAYER(this))
         {
             entity head, closest_target = NULL;
             head = WarpZone_FindRadius(this.origin, autocvar_g_vehicles_enter_radius, true);
 
             while(head) // find the closest acceptable target to enter
             {
                 if(IS_VEHICLE(head) && !IS_DEAD(head) && head.takedamage != DAMAGE_NO)
                 if(!head.owner || ((head.vehicle_flags & VHF_MULTISLOT) && SAME_TEAM(head.owner, this)))
                 {
                     if(closest_target)
                     {
                         if(vlen2(this.origin - head.origin) < vlen2(this.origin - closest_target.origin))
                         { closest_target = head; }
                     }
                     else { closest_target = head; }
                 }
 
                 head = head.chain;
             }
 
             if(closest_target) { vehicles_enter(this, closest_target); return; }
         }
     }
 
     // a use key was pressed; call handlers
     MUTATOR_CALLHOOK(PlayerUseKey, this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PutObserverInServer()

void PutObserverInServer	(	entity	this,
		bool	is_forced,
		bool	use_spawnpoint
	)

putting a client as observer in the server

Definition at line 238 of file client.qc.

References accuracy_resend(), alivetime, alpha, angles, autocvar_g_balance_armor_start, autocvar_g_playerclip_collisions, AuxiliaryXhair, avelocity, bot_attack, bot_relinkplayerlist(), CHAT_NOSPECTATORS, CS(), DAMAGE_NO, damagedbycontents, damageforcescale, DEAD_NO, deadflag, death_time, DPCONTENTS_PLAYERCLIP, DPCONTENTS_SOLID, dphitcontentsmask, drag_undraggable(), drawonlytoclient, effects, entity(), etof(), fade_time, fixangle, FixPlayermodel(), FL_CLIENT, FL_NOTARGET, flags, frags, FRAGS_SPECTATOR, func_null(), g_bot_targets, g_damagedbycontents, g_monster_targets, GetResource(), IL_REMOVE(), IS_PLAYER, IS_REAL_CLIENT, iscreature, istypefrag, items, just_joined, killcount, LOG_FATAL, MAX_AXH, MAX_WEAPONSLOTS, model, monster_attack, MOVETYPE_FLY_WORLDONLY, msg_entity, MSG_ONE, MUTATOR_CALLHOOK, nextthink, NULL, oldvelocity, origin, pain_finished, pauseregen_finished, pauserotarmor_finished, pauserothealth_finished, player_powerups_remove_all(), PlayerState_detach(), Portal_ClearAll(), punchangle, punchvector, pushltime, ready, ReadyCount(), RemoveGrapplingHooks(), RES_HEALTH, respawn_flags, respawn_time, revival_time, scale, SelectSpawnPoint(), set_movetype(), setmodel, setorigin(), SetPlayerTeam(), SetResourceExplicit(), SetSpectatee(), SetSpectatee_status(), setthink, solid, SOLID_NOT, SVC_SETVIEW, takedamage, TEAM_CHANGE_SPECTATOR, TELEPORT_SIMPLE, teleportable, time, TRANSMUTE(), Unfreeze(), UNSET_DUCKED, vec2, vehicle, vehicles_exit(), velocity, view_ofs, viewloc, vote_called, VoteCount(), warmup_stage, weaponentities, weaponmodel, WriteByte(), and WriteEntity().

Referenced by ClientKill_Now_TeamChange(), GameCommand_allspec(), GameCommand_moveplayer(), minigame_addplayer(), ObserverOrSpectatorThink(), PlayerPostThink(), PutClientInServer(), SpectateSet(), and STATIC_INIT().

 {
     bool mutator_returnvalue = MUTATOR_CALLHOOK(MakePlayerObserver, this, is_forced);
     bool recount_ready = false;
     PlayerState_detach(this);
 
     if (IS_PLAYER(this))
     {
         if(GetResource(this, RES_HEALTH) >= 1)
         {
             // despawn effect
             Send_Effect(EFFECT_SPAWN_NEUTRAL, this.origin, '0 0 0', 1);
         }
 
         // was a player, recount votes and ready status
         if(IS_REAL_CLIENT(this))
         {
             if (vote_called) { VoteCount(false); }
             this.ready = false;
             recount_ready = true;
         }
         entcs_update_players(this);
     }
 
     if (use_spawnpoint)
     {
         entity spot = SelectSpawnPoint(this, true);
         if (!spot) LOG_FATAL("No spawnpoints for observers?!?");
         this.angles = vec2(spot.angles);
         // offset it so that the spectator spawns higher off the ground, looks better this way
         setorigin(this, spot.origin + STAT(PL_VIEW_OFS, this));
     }
     else // change origin to restore previous view origin
         setorigin(this, this.origin + STAT(PL_VIEW_OFS, this) - STAT(PL_CROUCH_VIEW_OFS, this));
     this.fixangle = true;
 
     if (IS_REAL_CLIENT(this))
     {
         msg_entity = this;
         WriteByte(MSG_ONE, SVC_SETVIEW);
         WriteEntity(MSG_ONE, this);
     }
     // give the spectator some space between walls for MOVETYPE_FLY_WORLDONLY
     // so that your view doesn't go into the ceiling with MOVETYPE_FLY_WORLDONLY, previously "PL_VIEW_OFS"
     if(!autocvar_g_debug_globalsounds)
     {
         // needed for player sounds
         this.model = "";
         FixPlayermodel(this);
     }
     setmodel(this, MDL_Null);
     setsize(this, STAT(PL_CROUCH_MIN, this), STAT(PL_CROUCH_MAX, this));
     this.view_ofs = '0 0 0';
 
     RemoveGrapplingHooks(this);
     Portal_ClearAll(this);
     Unfreeze(this, false);
     SetSpectatee(this, NULL);
 
     if (this.alivetime)
     {
         if (!warmup_stage)
             PlayerStats_GameReport_Event_Player(this, PLAYERSTATS_ALIVETIME, time - this.alivetime);
         this.alivetime = 0;
     }
 
     if (this.vehicle) vehicles_exit(this.vehicle, VHEF_RELEASE);
 
     TRANSMUTE(Observer, this);
 
     if(recount_ready) ReadyCount();
 
     WaypointSprite_PlayerDead(this);
     accuracy_resend(this);
 
     if (CS(this).killcount != FRAGS_SPECTATOR && !game_stopped && CHAT_NOSPECTATORS())
         Send_Notification(NOTIF_ONE_ONLY, this, MSG_INFO, INFO_CHAT_NOSPECTATORS);
 
     CS(this).spectatortime = time;
     if(this.bot_attack)
         IL_REMOVE(g_bot_targets, this);
     this.bot_attack = false;
     if(this.monster_attack)
         IL_REMOVE(g_monster_targets, this);
     this.monster_attack = false;
     STAT(HUD, this) = HUD_NORMAL;
     this.iscreature = false;
     this.teleportable = TELEPORT_SIMPLE;
     if(this.damagedbycontents)
         IL_REMOVE(g_damagedbycontents, this);
     this.damagedbycontents = false;
     SetResourceExplicit(this, RES_HEALTH, FRAGS_SPECTATOR);
     SetSpectatee_status(this, etof(this));
     this.takedamage = DAMAGE_NO;
     this.solid = SOLID_NOT;
     set_movetype(this, MOVETYPE_FLY_WORLDONLY); // user preference is controlled by playerprethink
     this.flags = FL_CLIENT | FL_NOTARGET;
     this.effects = 0;
     SetResourceExplicit(this, RES_ARMOR, autocvar_g_balance_armor_start); // was 666?!
     this.pauserotarmor_finished = 0;
     this.pauserothealth_finished = 0;
     this.pauseregen_finished = 0;
     this.damageforcescale = 0;
     this.death_time = 0;
     this.respawn_flags = 0;
     this.respawn_time = 0;
     STAT(RESPAWN_TIME, this) = 0;
     this.alpha = 0;
     this.scale = 0;
     this.fade_time = 0;
     this.pain_finished = 0;
     STAT(AIR_FINISHED, this) = 0;
     //this.dphitcontentsmask = 0;
     this.dphitcontentsmask = DPCONTENTS_SOLID;
     if (autocvar_g_playerclip_collisions)
         this.dphitcontentsmask |= DPCONTENTS_PLAYERCLIP;
     this.pushltime = 0;
     this.istypefrag = 0;
     setthink(this, func_null);
     this.nextthink = 0;
     this.deadflag = DEAD_NO;
     UNSET_DUCKED(this);
     STAT(REVIVE_PROGRESS, this) = 0;
     this.revival_time = 0;
     this.draggable = drag_undraggable;
 
     player_powerups_remove_all(this);
     this.items = 0;
     STAT(WEAPONS, this) = '0 0 0';
     this.drawonlytoclient = this;
 
     this.viewloc = NULL;
 
     //this.spawnpoint_targ = NULL; // keep it so they can return to where they were?
 
     this.weaponmodel = "";
     for (int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
     {
         this.weaponentities[slot] = NULL;
     }
     this.exteriorweaponentity = NULL;
     CS(this).killcount = FRAGS_SPECTATOR;
     this.velocity = '0 0 0';
     this.avelocity = '0 0 0';
     this.punchangle = '0 0 0';
     this.punchvector = '0 0 0';
     this.oldvelocity = this.velocity;
     this.event_damage = func_null;
     this.event_heal = func_null;
 
     for(int slot = 0; slot < MAX_AXH; ++slot)
     {
         entity axh = this.(AuxiliaryXhair[slot]);
         this.(AuxiliaryXhair[slot]) = NULL;
 
         if(axh.owner == this && axh != NULL && !wasfreed(axh))
             delete(axh);
     }
 
     if (mutator_returnvalue)
     {
         // mutator prevents resetting teams+score
     }
     else
     {
         SetPlayerTeam(this, -1, TEAM_CHANGE_SPECTATOR);
         this.frags = FRAGS_SPECTATOR;
     }
 
     bot_relinkplayerlist();
 
     if (CS(this).just_joined)
         CS(this).just_joined = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RotRegen()

void RotRegen	(	entity	this,
		entity	current,
		float	limit_mod,
		float	regenstable,
		float	regenfactor,
		float	regenlinear,
		float	regenframetime,
		float	rotstable,
		float	rotfactor,
		float	rotlinear,
		float	rotframetime
	)

Referenced by STATIC_INIT().

Here is the caller graph for this function:

◆ SetSpectatee()

void SetSpectatee	(	entity	this,
		entity	spectatee
	)

Definition at line 1836 of file client.qc.

References ClientData_Touch(), enemy, entity(), etof(), IS_BOT_CLIENT, MAX_WEAPONSLOTS, SetSpectatee_status(), and weaponentities.

Referenced by ClientDisconnect(), PutClientInServer(), PutObserverInServer(), Spectate(), SpectateNext(), SpectatePrev(), SpectateUpdate(), and STATIC_INIT().

 {
     if(IS_BOT_CLIENT(this))
         return; // bots abuse .enemy, this code is useless to them
 
     entity old_spectatee = this.enemy;
 
     this.enemy = spectatee;
 
     // WEAPONTODO
     // these are required to fix the spectator bug with arc
     if(old_spectatee)
     {
         for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
         {
             .entity weaponentity = weaponentities[slot];
             if(old_spectatee.(weaponentity).arc_beam)
                 old_spectatee.(weaponentity).arc_beam.SendFlags |= ARC_SF_SETTINGS;
         }
     }
     if(spectatee)
     {
         for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
         {
             .entity weaponentity = weaponentities[slot];
             if(spectatee.(weaponentity).arc_beam)
                 spectatee.(weaponentity).arc_beam.SendFlags |= ARC_SF_SETTINGS;
         }
     }
 
     if (spectatee)
         SetSpectatee_status(this, etof(spectatee));
 
     // needed to update spectator list
     if(old_spectatee) { ClientData_Touch(old_spectatee); }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetSpectatee_status()

void SetSpectatee_status	(	entity	this,
		int	spectatee_num
	)

Definition at line 1819 of file client.qc.

References ClientData_Touch(), CS(), g_cts, g_race, race_InitSpectator(), and spectatee_status.

Referenced by PutObserverInServer(), PutPlayerInServer(), SetSpectatee(), and STATIC_INIT().

 {
     int oldspectatee_status = CS(this).spectatee_status;
     CS(this).spectatee_status = spectatee_num;
 
     if (CS(this).spectatee_status != oldspectatee_status)
     {
         if (STAT(PRESSED_KEYS, this))
         {
             CS(this).pressedkeys = 0;
             STAT(PRESSED_KEYS, this) = 0;
         }
         ClientData_Touch(this);
         if (g_race || g_cts) race_InitSpectator();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Spectate()

bool Spectate	(	entity	this,
		entity	pl
	)

Definition at line 1873 of file client.qc.

References entity(), M_ARGV, MUTATOR_CALLHOOK, SetSpectatee(), and SpectateSet().

Referenced by ClientCommand_spectate(), STATIC_INIT(), and superspec_Spectate().

 {
     if(MUTATOR_CALLHOOK(SpectateSet, this, pl))
         return false;
     pl = M_ARGV(1, entity);
 
     SetSpectatee(this, pl);
     return SpectateSet(this);
 }