#include "client.qh"
#include <common/csqcmodel_settings.qh>
#include <common/deathtypes/all.qh>
#include <common/debug.qh>
#include <common/effects/all.qh>
#include <common/effects/qc/globalsound.qh>
#include <common/ent_cs.qh>
#include <common/gametypes/_mod.qh>
#include <common/gametypes/gametype/nexball/sv_nexball.qh>
#include <common/items/_mod.qh>
#include <common/items/inventory.qh>
#include <common/mapobjects/func/conveyor.qh>
#include <common/mapobjects/func/ladder.qh>
#include <common/mapobjects/subs.qh>
#include <common/mapobjects/target/spawnpoint.qh>
#include <common/mapobjects/teleporters.qh>
#include <common/mapobjects/trigger/counter.qh>
#include <common/mapobjects/trigger/secret.qh>
#include <common/mapobjects/trigger/swamp.qh>
#include <common/mapobjects/triggers.qh>
#include <common/minigames/sv_minigames.qh>
#include <common/monsters/sv_monsters.qh>
#include <common/mutators/mutator/instagib/sv_instagib.qh>
#include <common/mutators/mutator/nades/_mod.qh>
#include <common/mutators/mutator/overkill/oknex.qh>
#include <common/mutators/mutator/status_effects/_mod.qh>
#include <common/mutators/mutator/waypoints/all.qh>
#include <common/net_linked.qh>
#include <common/net_notice.qh>
#include <common/notifications/all.qh>
#include <common/physics/player.qh>
#include <common/playerstats.qh>
#include <common/resources/sv_resources.qh>
#include <common/state.qh>
#include <common/stats.qh>
#include <common/vehicles/all.qh>
#include <common/vehicles/sv_vehicles.qh>
#include <common/viewloc.qh>
#include <common/weapons/_all.qh>
#include <common/weapons/weapon/vortex.qh>
#include <common/wepent.qh>
#include <lib/csqcmodel/sv_model.qh>
#include <lib/warpzone/common.qh>
#include <lib/warpzone/server.qh>
#include <server/anticheat.qh>
#include <server/antilag.qh>
#include <server/bot/api.qh>
#include <server/bot/default/cvars.qh>
#include <server/bot/default/waypoints.qh>
#include <server/campaign.qh>
#include <server/chat.qh>
#include <server/cheats.qh>
#include <server/clientkill.qh>
#include <server/command/banning.qh>
#include <server/command/cmd.qh>
#include <server/command/common.qh>
#include <server/command/vote.qh>
#include <server/compat/quake3.qh>
#include <server/damage.qh>
#include <server/gamelog.qh>
#include <server/handicap.qh>
#include <server/hook.qh>
#include <server/impulse.qh>
#include <server/intermission.qh>
#include <server/ipban.qh>
#include <server/main.qh>
#include <server/mutators/_mod.qh>
#include <server/player.qh>
#include <server/portals.qh>
#include <server/race.qh>
#include <server/scores.qh>
#include <server/scores_rules.qh>
#include <server/spawnpoints.qh>
#include <server/teamplay.qh>
#include <server/weapons/accuracy.qh>
#include <server/weapons/common.qh>
#include <server/weapons/hitplot.qh>
#include <server/weapons/selection.qh>
#include <server/weapons/tracing.qh>
#include <server/weapons/weaponsystem.qh>
#include <server/world.qh>

Include dependency graph for client.qc:

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

Functions
float	CalcRegen (float current, float stable, float regenfactor, float regenframetime)
float	CalcRot (float current, float stable, float rotfactor, float rotframetime)
void	calculate_player_respawn_time (entity this)
void	ChatBubbleThink (entity this)
string	CheckPlayerModel (string plyermodel)
void	ClientConnect (entity this)
void	ClientData_Attach (entity this)
void	ClientData_Detach (entity this)
bool	ClientData_Send (entity this, entity to, int sf)
void	ClientData_Touch (entity e, bool to_spectators_too)
void	ClientDisconnect (entity this)
	ClientDisconnect (this)
void	ClientInit_CheckUpdate (entity this)
void	ClientInit_misc (entity this)
bool	ClientInit_SendEntity (entity this, entity to, int sf)
void	ClientInit_Spawn ()
int	CountSpectators (entity player, entity to)
void	DecodeLevelParms (entity this)
void	DrownPlayer (entity this)
bool	findinlist_abbrev (string tofind, string list)
void	FixClientCvars (entity e)
void	FixPlayermodel (entity player)
int	GetPlayerLimit ()
void	GetPressedKeys (entity this)
void	GiveWarmupResources (entity this)
void	Join (entity this, bool queued_join)
	it's assumed this isn't called for bots (campaign_bots_may_start, centreprints)
bool	joinAllowed (entity this, int team_index)
	NET_HANDLE (fpsreport, bool)
int	nJoinAllowed (entity this)
	Determines how many player slots are free.
void	ObserverOrSpectatorThink (entity this)
void	play_countdown (entity this, float finished, Sound samp)
int	player_getspecies (entity this)
void	Player_Physics (entity this)
void	player_powerups (entity this)
void	player_powerups_remove_all (entity this, bool allow_poweroff_sound)
void	player_regen (entity this)
void	PlayerFrame (entity this)
bool	PlayerInIDList (entity p, string idlist)
bool	PlayerInIPList (entity p, string iplist)
bool	PlayerInList (entity player, string list)
void	PlayerPostThink (entity this)
void	PlayerPreThink (entity this)
bool	PlayerThink (entity this)
void	PlayerUseKey (entity this)
void	PM_UpdateButtons (entity this, entity store)
void	PutClientInServer (entity this)
	Called when a client spawns in the server.
	PutClientInServer (this)
void	PutObserverInServer (entity this, bool is_forced, bool use_spawnpoint)
	putting a client as observer in the server
void	PutPlayerInServer (entity this)
bool	queuePlayer (entity this, int team_index)
void	respawn (entity this)
void	RotRegen (entity this, Resource res, float limit_mod, float regenstable, float regenfactor, float regenlinear, float regenframetime, float rotstable, float rotfactor, float rotlinear, float rotframetime)
entity	SelectObservePoint (entity this)
void	SendWelcomeMessage (entity this, int msg_type)
void	SetChangeParms (entity this)
void	SetNewParms ()
void	setplayermodel (entity e, string modelname)
void	SetSpectatee (entity this, entity spectatee)
void	SetSpectatee_status (entity this, int spectatee_num)
void	SetZoomState (entity this, float newzoom)
void	show_entnum (entity this)
void	ShowRespawnCountdown (entity this)
bool	ShowTeamSelection (entity this)
bool	Spectate (entity this, entity pl)
void	SpectateCopy (entity this, entity spectatee)
bool	SpectateNext (entity this)
bool	SpectatePrev (entity this)
bool	SpectateSet (entity this)
bool	SpectateUpdate (entity this)
	TRANSMUTE (Player, this)
void	UpdateChatBubble (entity this)
void	WriteSpectators (entity player, entity to)

Variables
float	autocvar_g_maxping
entity	chatbubbleentity
bool	dualwielding_prev
string	FallbackPlayerModel
this	frame = 12
float	last_vehiclecheck
float	model_randomizer
bool	move_qcphysics
string	shootfromfixedorigin
this	team = _team
bool	would_spectate
bool	zoomstate_set

Function Documentation

◆ CalcRegen()

float CalcRegen	(	float	current,
		float	stable,
		float	regenfactor,
		float	regenframetime )

Definition at line 1637 of file client.qc.

{
    if(current > stable)
        return current;
    else if(current > stable - 0.25) // when close enough, "snap"
        return stable;
    else
        return min(stable, current + (stable - current) * regenfactor * regenframetime);
}

References min().

Referenced by RotRegen().

◆ CalcRot()

float CalcRot	(	float	current,
		float	stable,
		float	rotfactor,
		float	rotframetime )

Definition at line 1647 of file client.qc.

{
    if(current < stable)
        return current;
    else if(current < stable + 0.25) // when close enough, "snap"
        return stable;
    else
        return max(stable, current + (stable - current) * rotfactor * rotframetime);
}

References max().

Referenced by RotRegen().

◆ calculate_player_respawn_time()

void calculate_player_respawn_time ( entity this )

Definition at line 1399 of file client.qc.

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

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

◆ ChatBubbleThink()

void ChatBubbleThink ( entity this )

Definition at line 1350 of file client.qc.

{
    this.nextthink = time;
 
    entity ownr = this.owner;
    if (ownr.alpha < 0 || ownr.chatbubbleentity != this)
    {
        if (ownr) // but why can that ever be NULL?
            ownr.chatbubbleentity = NULL;
        delete(this);
        return;
    }
 
    this.mdl = "";
 
    if (!IS_DEAD(ownr) && IS_PLAYER(ownr) && !MUTATOR_CALLHOOK(ShowChatBubble, ownr, this))
    {
        if (CS(ownr).active_minigame && PHYS_INPUT_BUTTON_MINIGAME(ownr))
            this.mdl = "models/sprites/minigame_busy.iqm";
        else if (PHYS_INPUT_BUTTON_CHAT(ownr))
            this.mdl = "models/misc/chatbubble.spr";
    }
 
    if (this.model != this.mdl)
        _setmodel(this, this.mdl);
}

References active_minigame, CS(), entity(), IS_DEAD, IS_PLAYER, mdl, model, MUTATOR_CALLHOOK, nextthink, NULL, owner, PHYS_INPUT_BUTTON_CHAT, PHYS_INPUT_BUTTON_MINIGAME, and time.

Referenced by UpdateChatBubble().

◆ CheckPlayerModel()

string CheckPlayerModel ( string plyermodel )

Definition at line 208 of file client.qc.

{
    if(FallbackPlayerModel != cvar_defstring("_cl_playermodel"))
    {
        // note: we cannot summon Don Strunzone here, some player may
        // still have the model string set. In case anyone manages how
        // to change a cvar default, we'll have a small leak here.
        FallbackPlayerModel = strzone(cvar_defstring("_cl_playermodel"));
    }
    // only in right path
    if(substring(plyermodel, 0, 14) != "models/player/")
        return FallbackPlayerModel;
    // only good file extensions
    if(substring(plyermodel, -4, 4) != ".iqm"
    && substring(plyermodel, -4, 4) != ".zym"
    && substring(plyermodel, -4, 4) != ".dpm"
    && substring(plyermodel, -4, 4) != ".md3"
    && substring(plyermodel, -4, 4) != ".psk")
        return FallbackPlayerModel;
 
    // forbid the LOD models
    if(substring(plyermodel, -9, 5) == "_lod1" || substring(plyermodel, -9, 5) == "_lod2")
        return FallbackPlayerModel;
    if(plyermodel != strtolower(plyermodel))
        return FallbackPlayerModel;
    // also, restrict to server models
    if(autocvar_sv_servermodelsonly)
        if(!fexists(plyermodel))
            return FallbackPlayerModel;
 
    return plyermodel;
}

References autocvar_sv_servermodelsonly, cvar_defstring(), FallbackPlayerModel, fexists(), strtolower(), strzone(), and substring().

Referenced by FixPlayermodel().

◆ ClientConnect()

void ClientConnect ( entity this )

ClientConnect

Called when a client connects to the server

Do not send temp entity headers directly here, they may arrive before CSQC is ready.

Definition at line 1143 of file client.qc.

{
    if (Ban_MaybeEnforceBanOnce(this)) return;
    assert(!IS_CLIENT(this), return);
    this.flags |= FL_CLIENT;
    assert(player_count >= 0, player_count = 0);
 
    TRANSMUTE(Client, this);
    CS(this).version_nagtime = time + 10 + random() * 10;
 
    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_JOIN_CONNECT, this.netname);
 
    bot_clientconnect(this);
 
    // after bot_clientconnect
    if (teamplay)
        this.clientcolors = 0;
 
    this.team = -1;
    Player_DetermineForcedTeam(this);
 
    TRANSMUTE(Observer, this);
 
    PlayerStats_GameReport_AddEvent(sprintf("kills-%d", this.playerid));
 
    // always track bots, don't ask for cl_allow_uidtracking
    if (IS_BOT_CLIENT(this))
        PlayerStats_GameReport_AddPlayer(this);
    else
        CS(this).allowed_timeouts = autocvar_sv_timeout_number;
 
    if (autocvar_sv_eventlog)
        GameLogEcho(strcat(":join:", ftos(this.playerid), ":", ftos(etof(this)), ":", ((IS_REAL_CLIENT(this)) ? GameLog_ProcessIP(this.netaddress) : "bot"), ":", playername(this.netname, this.team, false)));
 
    CS(this).just_joined = true;  // stop spamming the eventlog with additional lines when the client connects
    this.wants_join = 0;
 
    stuffcmd(this, clientstuff, "\n");
    stuffcmd(this, "cl_particles_reloadeffects\n"); // TODO do we still need this?
 
    FixClientCvars(this);
 
    // get version info from player
    stuffcmd(this, "cmd clientversion $gameversion\n");
 
    // notify about available teams
    if (teamplay)
    {
        entity balance = TeamBalance_CheckAllowedTeams(this);
        int t = TeamBalance_GetAllowedTeams(balance);
        TeamBalance_Destroy(balance);
        stuffcmd(this, sprintf("set _teams_available %d\n", t));
    }
    else
    {
        stuffcmd(this, "set _teams_available 0\n");
    }
 
    bot_relinkplayerlist();
 
    CS(this).spectatortime = time;
    CS(this).jointime = time;
 
    if (IS_REAL_CLIENT(this))
    {
        ignore_list_update_on_connection(this);
 
        if (g_weaponarena_weapons == WEPSET(TUBA))
            stuffcmd(this, "cl_cmd settemp chase_active 1\n");
        // quickmenu file must be put in a subfolder with an unique name
        // to reduce chances of overriding custom client quickmenus
        if (waypointeditor_enabled)
            stuffcmd(this, sprintf("cl_cmd settemp _hud_panel_quickmenu_file_from_server %s\n", "wpeditor.txt"));
        else if (autocvar_sv_quickmenu_file != "" && strstrofs(autocvar_sv_quickmenu_file, "/", 0) && fexists(autocvar_sv_quickmenu_file))
            stuffcmd(this, sprintf("cl_cmd settemp _hud_panel_quickmenu_file_from_server %s\n", autocvar_sv_quickmenu_file));
    }
 
    if (!autocvar_sv_foginterval && world.fog != "")
        stuffcmd(this, strcat("\nfog ", world.fog, "\nr_fog_exp2 0\nr_drawfog 1\n"));
 
    CSQCMODEL_AUTOINIT(this);
 
    CS(this).model_randomizer = random();
 
    if (IS_REAL_CLIENT(this))
        sv_notice_join(this);
 
    this.move_qcphysics = true;
 
    // update physics stats (players can spawn before physics runs)
    Physics_UpdateStats(this);
 
    IL_EACH(g_initforplayer, it.init_for_player,
    {
        it.init_for_player(it, this);
    });
 
    Handicap_Initialize(this);
 
    // playban
    if (PlayerInList(this, autocvar_g_playban_list))
        TRANSMUTE(Observer, this);
 
    if (PlayerInList(this, autocvar_g_chatban_list)) // chatban
        CS(this).muted = true;
 
    MUTATOR_CALLHOOK(ClientConnect, this);
 
    if (player_count == 1)
    {
        if (autocvar_sv_autopause && autocvar_sv_dedicated)
            setpause(0);
        localcmd("\nsv_hook_firstjoin\n");
    }
 
    if (get_nextmap() != "")
        Send_NextMap_To_Player(this);
 
    // cvar hook/callback TODO: recheck this when the cvar is changed
    if (autocvar_sv_vote_master_ids != "" && this.crypto_idfp_signed)
        if (strstrofs(autocvar_sv_vote_master_ids, this.crypto_idfp, 0) >= 0)
            this.vote_master = true;
}

References assert, autocvar_g_chatban_list, autocvar_g_playban_list, autocvar_sv_autopause, autocvar_sv_dedicated, autocvar_sv_eventlog, autocvar_sv_foginterval, autocvar_sv_quickmenu_file, autocvar_sv_timeout_number, autocvar_sv_vote_master_ids, Ban_MaybeEnforceBanOnce(), bot_clientconnect(), bot_relinkplayerlist(), clientcolors, ClientConnect, clientstuff, crypto_idfp, crypto_idfp_signed, CS(), CSQCMODEL_AUTOINIT, entity(), etof, fexists(), FixClientCvars(), FL_CLIENT, flags, ftos(), g_initforplayer, g_weaponarena_weapons, GameLog_ProcessIP(), GameLogEcho(), get_nextmap, Handicap_Initialize(), ignore_list_update_on_connection(), IL_EACH, IS_BOT_CLIENT, IS_CLIENT, IS_REAL_CLIENT, localcmd(), move_qcphysics, MUTATOR_CALLHOOK, netaddress, netname, NULL, Physics_UpdateStats(), player_count, Player_DetermineForcedTeam(), playerid, PlayerInList(), playername(), PlayerStats_GameReport_AddEvent(), PlayerStats_GameReport_AddPlayer(), random(), Send_NextMap_To_Player(), Send_Notification(), strcat(), strstrofs, stuffcmd, sv_notice_join(), team, TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_GetAllowedTeams(), teamplay, time, TRANSMUTE, vote_master, wants_join, waypointeditor_enabled, WEPSET, and world.

◆ ClientData_Attach()

void ClientData_Attach ( entity this )

Definition at line 172 of file client.qc.

{
    Net_LinkEntity(CS(this).clientdata = new_pure(clientdata), false, 0, ClientData_Send);
    CS(this).clientdata.drawonlytoclient = this;
    CS(this).clientdata.owner = this;
}

References clientdata, ClientData_Send(), CS(), entity(), Net_LinkEntity(), and new_pure.

Referenced by ClientState_attach().

◆ ClientData_Detach()

void ClientData_Detach ( entity this )

Definition at line 179 of file client.qc.

{
    delete(CS(this).clientdata);
    CS(this).clientdata = NULL;
}

References CS(), entity(), and NULL.

Referenced by ClientState_detach().

◆ ClientData_Send()

bool ClientData_Send	(	entity	this,
		entity	to,
		int	sf )

Definition at line 128 of file client.qc.

{
    assert(to == this.owner, return false);
 
    entity e = to;
    if (IS_SPEC(e)) e = e.enemy;
 
    sf = 0;
    if (CS(e).race_completed)       sf |= BIT(0); // forced scoreboard
    if (CS(to).spectatee_status)    sf |= BIT(1); // spectator ent number follows
    if (CS(e).zoomstate)            sf |= BIT(2); // zoomed
    if (observe_blocked_if_eliminated && INGAME(to))
                                    sf |= BIT(3); // observing blocked
    if (autocvar_sv_showspectators == 1 || (autocvar_sv_showspectators && IS_SPEC(to)))
                                    sf |= BIT(4); // show spectators
    if (autocvar_sv_teamnagger && teamplay && !(autocvar_bot_vs_human && AVAILABLE_TEAMS == 2))
                                    sf |= (autocvar_sv_teamnagger & 0x03) << 5; // BIT(5) | BIT(6)
    if (to.ignore_list && to.ignore_list_send_time == IGNORE_LIST_SEND_NOW && !IS_SPEC(to))
                                    sf |= BIT(7); // ignore list (private, won't be sent to spectators)
 
    WriteHeader(MSG_ENTITY, ENT_CLIENT_CLIENTDATA);
    WriteByte(MSG_ENTITY, sf);
 
    if (sf & BIT(1))
        WriteByte(MSG_ENTITY, CS(to).spectatee_status);
 
    // spectator list is cleared on the client if this flag is not set
    if(sf & BIT(4))
    {
        float specs = CountSpectators(e, to);
        WriteByte(MSG_ENTITY, specs);
        WriteSpectators(e, to);
    }
 
    // ignore list is NOT cleared on the client if this flag is not set
    if (sf & BIT(7))
    {
        to.ignore_list_send_time = 0;
        WriteString(MSG_ENTITY, strcat(to.ignore_list));
    }
 
    return true;
}

References assert, autocvar_bot_vs_human, autocvar_sv_showspectators, autocvar_sv_teamnagger, AVAILABLE_TEAMS, BIT, CountSpectators(), CS(), entity(), IGNORE_LIST_SEND_NOW, INGAME, IS_SPEC, MSG_ENTITY, observe_blocked_if_eliminated, owner, race_completed, spectatee_status, strcat(), teamplay, WriteByte(), WriteHeader, WriteSpectators(), WriteString(), and zoomstate.

Referenced by ClientData_Attach().

◆ ClientData_Touch()

void ClientData_Touch	(	entity	e,
		bool	to_spectators_too )

Definition at line 185 of file client.qc.

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

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

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

◆ ClientDisconnect() [1/2]

void ClientDisconnect ( entity this )

Definition at line 1278 of file client.qc.

{
    assert(IS_CLIENT(this), return);
 
    strfree(this.ignore_list);
    FOREACH_CLIENT(IS_REAL_CLIENT(it),
    {
        // don't remove permanent ignores from db, only from list
        ignore_remove_player(it, this, false);
    });
 
    PlayerStats_GameReport_FinalizePlayer(this);
    if (this.vehicle) vehicles_exit(this.vehicle, VHEF_RELEASE);
    if (CS(this).active_minigame) part_minigame(this);
    if (IS_PLAYER(this)) Send_Effect(EFFECT_SPAWN, this.origin, '0 0 0', 1);
 
    if (autocvar_sv_eventlog)
        GameLogEcho(strcat(":part:", ftos(this.playerid)));
 
    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_QUIT_DISCONNECT, this.netname);
 
    if(IS_SPEC(this))
        SetSpectatee(this, NULL);
 
    MUTATOR_CALLHOOK(ClientDisconnect, this);
 
    strfree(CS(this).netname_previous); // needs to be before the CS entity is removed!
    strfree(CS_CVAR(this).weaponorder_byimpulse);
    ClientState_detach(this);
 
    Portal_ClearAll(this);
 
    RemoveGrapplingHooks(this);
 
    strfree(this.shootfromfixedorigin);
 
    // Here, everything has been done that requires this player to be a client.
 
    this.flags &= ~FL_CLIENT;
 
    if (this.chatbubbleentity) delete(this.chatbubbleentity);
    if (this.killindicator) delete(this.killindicator);
 
    IL_EACH(g_counters, it.realowner == this,
    {
        delete(it);
    });
 
    WaypointSprite_PlayerGone(this);
 
    bot_relinkplayerlist();
 
    strfree(this.clientstatus);
    if (this.personal) delete(this.personal);
 
    this.playerid = 0;
    if (warmup_stage || game_starttime > time) /* warmup OR countdown */ ReadyCount();
    if (vote_called && IS_REAL_CLIENT(this)) VoteCount(false);
 
    player_powerups_remove_all(this, IS_PLAYER(this)); // stop powerup sound
 
    ONREMOVE(this);
 
    if (player_count == 0)
        localcmd("\nsv_hook_lastleave\n");
 
    if (!intermission_running)
    if (!TeamBalance_QueuedPlayersTagIn(this))
    if (autocvar_g_balance_teams_remove)
        TeamBalance_RemoveExcessPlayers(NULL);
}

References active_minigame, assert, autocvar_g_balance_teams_remove, autocvar_sv_eventlog, bot_relinkplayerlist(), chatbubbleentity, ClientDisconnect, ClientState_detach(), clientstatus, CS(), CS_CVAR, entity(), FL_CLIENT, flags, FOREACH_CLIENT, ftos(), g_counters, game_starttime, GameLogEcho(), ignore_list, ignore_remove_player(), IL_EACH, intermission_running, IS_CLIENT, IS_PLAYER, IS_REAL_CLIENT, IS_SPEC, killindicator, localcmd(), MUTATOR_CALLHOOK, netname, NULL, ONREMOVE(), origin, part_minigame(), personal, player_count, player_powerups_remove_all(), playerid, PlayerStats_GameReport_FinalizePlayer(), Portal_ClearAll(), ReadyCount(), RemoveGrapplingHooks(), Send_Effect(), Send_Notification(), SetSpectatee(), shootfromfixedorigin, strcat(), strfree, TeamBalance_QueuedPlayersTagIn(), TeamBalance_RemoveExcessPlayers(), time, vehicle, vehicles_exit(), VHEF_RELEASE, vote_called, VoteCount(), warmup_stage, WaypointSprite_PlayerGone(), and weaponorder_byimpulse.

◆ ClientDisconnect() [2/2]

ClientDisconnect ( this )

◆ ClientInit_CheckUpdate()

void ClientInit_CheckUpdate ( entity this )

Definition at line 931 of file client.qc.

{
    this.nextthink = time;
    if(this.count != autocvar_g_balance_armor_blockpercent)
    {
        this.count = autocvar_g_balance_armor_blockpercent;
        this.SendFlags |= 1;
    }
    if(this.cnt != autocvar_g_balance_damagepush_speedfactor)
    {
        this.cnt = autocvar_g_balance_damagepush_speedfactor;
        this.SendFlags |= 1;
    }
}

References autocvar_g_balance_armor_blockpercent, autocvar_g_balance_damagepush_speedfactor, cnt, count, entity(), nextthink, SendFlags, and time.

Referenced by ClientInit_Spawn().

◆ ClientInit_misc()

void ClientInit_misc ( entity this )

Definition at line 907 of file client.qc.

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

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

Referenced by ClientInit_SendEntity().

◆ ClientInit_SendEntity()

bool ClientInit_SendEntity	(	entity	this,
		entity	to,
		int	sf )

Definition at line 895 of file client.qc.

{
    WriteHeader(MSG_ENTITY, _ENT_CLIENT_INIT);
    return = true;
    msg_entity = to;
    // MSG_INIT replacement
    // TODO: make easier to use
    Registry_send_all();
    W_PROP_reload(MSG_ONE, to);
    ClientInit_misc(this);
    MUTATOR_CALLHOOK(Ent_Init);
}

References ClientInit_misc(), entity(), MSG_ENTITY, msg_entity, MSG_ONE, MUTATOR_CALLHOOK, Registry_send_all(), W_PROP_reload(), and WriteHeader.

Referenced by ClientInit_Spawn().

◆ ClientInit_Spawn()

void ClientInit_Spawn ( )

Definition at line 946 of file client.qc.

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

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

Referenced by spawnfunc().

◆ CountSpectators()

int CountSpectators	(	entity	player,
		entity	to )

Definition at line 100 of file client.qc.

{
    if(!player) return 0; // not sure how, but best to be safe
 
    int spec_count = 0;
 
    FOREACH_CLIENT(IS_REAL_CLIENT(it) && IS_SPEC(it) && it != to && it.enemy == player,
    {
        ++spec_count;
    });
 
    return spec_count;
}

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

Referenced by ClientData_Send().

◆ DecodeLevelParms()

void DecodeLevelParms ( entity this )

Definition at line 986 of file client.qc.

{
    // load parms
    CS(this).parm_idlesince = parm1;
    if (CS(this).parm_idlesince == -(86400 * 366))
        CS(this).parm_idlesince = time;
 
    // whatever happens, allow 60 seconds of idling directly after connect for map loading
    CS(this).parm_idlesince = max(CS(this).parm_idlesince, time - autocvar_sv_maxidle + 60);
 
    MUTATOR_CALLHOOK(DecodeLevelParms);
}

References autocvar_sv_maxidle, CS(), DecodeLevelParms(), entity(), max(), MUTATOR_CALLHOOK, parm1, and time.

Referenced by ClientState_attach(), DecodeLevelParms(), and MUTATOR_HOOKABLE().

◆ DrownPlayer()

void DrownPlayer ( entity this )

Definition at line 2757 of file client.qc.

{
    // TODO: mutator hook to prevent drowning?
    if(IS_DEAD(this) || game_stopped || time < game_starttime || this.vehicle
    || STAT(FROZEN, this) || this.watertype != CONTENT_WATER)
    {
        STAT(AIR_FINISHED, this) = 0;
        return;
    }
 
    if (this.waterlevel != WATERLEVEL_SUBMERGED)
    {
        if(STAT(AIR_FINISHED, this) && STAT(AIR_FINISHED, this) < time)
            PlayerSound(this, playersound_gasp, CH_PLAYER, VOL_BASE, VOICETYPE_PLAYERSOUND, 1);
        STAT(AIR_FINISHED, this) = 0;
    }
    else
    {
        if (!STAT(AIR_FINISHED, this))
            STAT(AIR_FINISHED, this) = time + autocvar_g_balance_contents_drowndelay;
        if (STAT(AIR_FINISHED, this) < time)
        {   // drown!
            if (this.pain_finished < time)
            {
                Damage (this, NULL, NULL, autocvar_g_balance_contents_playerdamage_drowning * autocvar_g_balance_contents_damagerate, DEATH_DROWN.m_id, DMG_NOWEP, this.origin, '0 0 0');
                this.pain_finished = time + 0.5;
            }
        }
    }
}

References autocvar_g_balance_contents_damagerate, autocvar_g_balance_contents_drowndelay, autocvar_g_balance_contents_playerdamage_drowning, CH_PLAYER, CONTENT_WATER, Damage(), DMG_NOWEP, entity(), game_starttime, game_stopped, IS_DEAD, NULL, pain_finished, PlayerSound, STAT, time, vehicle, VOICETYPE_PLAYERSOUND, VOL_BASE, waterlevel, WATERLEVEL_SUBMERGED, and watertype.

Referenced by PlayerPostThink().

◆ findinlist_abbrev()

bool findinlist_abbrev	(	string	tofind,
		string	list )

Definition at line 1015 of file client.qc.

{
    if(list == "" || tofind == "")
        return false; // empty list or search, just return
 
    // this function allows abbreviated strings!
    FOREACH_WORD(list, it != "" && it == substring(tofind, 0, strlen(it)),
    {
        return true;
    });
 
    return false;
}

References FOREACH_WORD, strlen, and substring().

Referenced by PlayerInIDList(), and PlayerInIPList().

◆ FixClientCvars()

void FixClientCvars ( entity e )

Definition at line 999 of file client.qc.

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

References autocvar_g_antilag, autocvar_g_shootfromfixedorigin, autocvar_sv_jumpspeedcap_max, autocvar_sv_jumpspeedcap_min, entity(), FixClientCvars(), MUTATOR_CALLHOOK, and stuffcmd.

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

◆ FixPlayermodel()

void FixPlayermodel ( entity player )

Definition at line 454 of file client.qc.

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

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

◆ GetPlayerLimit()

int GetPlayerLimit ( )

Definition at line 2155 of file client.qc.

{
    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)
    // don't return map_maxplayers during intermission as it would interfere with MapHasRightSize()
    int player_limit = (autocvar_g_maxplayers >= 0 || intermission_running) ? autocvar_g_maxplayers : map_maxplayers;
    MUTATOR_CALLHOOK(GetPlayerLimit, player_limit);
    player_limit = M_ARGV(0, int);
    return player_limit < maxclients && player_limit > 0 ? player_limit : 0;
}

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

Referenced by bot_fixcount(), GameplayMode_DelayedInit(), GetPlayerLimit(), MapHasRightSize(), MUTATOR_HOOKABLE(), MUTATOR_HOOKFUNCTION(), nJoinAllowed(), and SendWelcomeMessage().

◆ GetPressedKeys()

void GetPressedKeys ( entity this )

Definition at line 1767 of file client.qc.

{
    MUTATOR_CALLHOOK(GetPressedKeys, this);
    if (game_stopped)
    {
        CS(this).pressedkeys = 0;
        STAT(PRESSED_KEYS, this) = 0;
        return;
    }
 
    // NOTE: GetPressedKeys and PM_dodging_GetPressedKeys use similar code
    int keys = STAT(PRESSED_KEYS, this);
    keys = BITSET(keys, KEY_FORWARD,   CS(this).movement.x > 0);
    keys = BITSET(keys, KEY_BACKWARD,  CS(this).movement.x < 0);
    keys = BITSET(keys, KEY_RIGHT,     CS(this).movement.y > 0);
    keys = BITSET(keys, KEY_LEFT,      CS(this).movement.y < 0);
 
    keys = BITSET(keys, KEY_JUMP,      PHYS_INPUT_BUTTON_JUMP(this));
    keys = BITSET(keys, KEY_CROUCH,    IS_DUCKED(this)); // workaround: player can't un-crouch until their path is clear, so we keep the button held here
    keys = BITSET(keys, KEY_ATCK,      PHYS_INPUT_BUTTON_ATCK(this));
    keys = BITSET(keys, KEY_ATCK2,     PHYS_INPUT_BUTTON_ATCK2(this));
    CS(this).pressedkeys = keys; // store for other users
 
    STAT(PRESSED_KEYS, this) = keys;
}

References BITSET, CS(), entity(), game_stopped, GetPressedKeys(), IS_DUCKED, KEY_ATCK, KEY_ATCK2, KEY_BACKWARD, KEY_CROUCH, KEY_FORWARD, KEY_JUMP, KEY_LEFT, KEY_RIGHT, movement, MUTATOR_CALLHOOK, PHYS_INPUT_BUTTON_ATCK, PHYS_INPUT_BUTTON_ATCK2, PHYS_INPUT_BUTTON_JUMP, and STAT.

Referenced by GetPressedKeys(), MUTATOR_HOOKABLE(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), and PlayerPostThink().

◆ GiveWarmupResources()

void GiveWarmupResources ( entity this )

Definition at line 568 of file client.qc.

{
    SetResource(this, RES_SHELLS, warmup_start_ammo_shells);
    SetResource(this, RES_BULLETS, warmup_start_ammo_nails);
    SetResource(this, RES_ROCKETS, warmup_start_ammo_rockets);
    SetResource(this, RES_CELLS, warmup_start_ammo_cells);
    SetResource(this, RES_FUEL, warmup_start_ammo_fuel);
    SetResource(this, RES_HEALTH, warmup_start_health);
    SetResource(this, RES_ARMOR, warmup_start_armorvalue);
    STAT(WEAPONS, this) = WARMUP_START_WEAPONS;
}

References entity(), RES_ARMOR, SetResource(), STAT, warmup_start_ammo_cells, warmup_start_ammo_fuel, warmup_start_ammo_nails, warmup_start_ammo_rockets, warmup_start_ammo_shells, warmup_start_armorvalue, warmup_start_health, and WARMUP_START_WEAPONS.

Referenced by PutPlayerInServer(), and ReadyCount().

◆ Join()

void Join	(	entity	this,
		bool	queued_join )

it's assumed this isn't called for bots (campaign_bots_may_start, centreprints)

Definition at line 2074 of file client.qc.

{
    entity player_with_dibs = NULL;
 
    if (autocvar_g_campaign)
    {
        if (!campaign_bots_may_start && !game_stopped && time >= game_starttime)
            ReadyRestart(true);
        campaign_bots_may_start = true;
    }
 
    // If teams aren't equal and a player is queued then they chose a biggest team so they can't join yet.
    if (queued_join && TeamBalance_AreEqual(this, true))
    {
        int clients_remaining = AVAILABLE_TEAMS;
        // First we must join player(s) queued for specific team(s) (they chose first)
        // so TeamBalance_JoinBestTeam() won't select the same team(s).
        // Assumes `this` was already assigned a team via ClientCommand_selectteam() or is using autoselect.
        FOREACH_CLIENT(it != this && it.wants_join > 0,
        {
            // detect any conflict between `this` and a queued player (queuePlayer() handles other conflicts)
            if (this.team < 0 && this.team_selected > 0 // `this` can't have their preference
            && it.wants_join == this.team_selected) // `it` is the player who already chose the team `this` wanted
                player_with_dibs = it;
 
            Join(it, false);
            --clients_remaining;
        });
 
        // Second pass: queued players whose team will be autoselected
        // in order of strongest to weakest for optimal balance.
        for (; clients_remaining; --clients_remaining)
        {
            entity strongest_autoselect_client = NULL;
            float strongest_autoselect_client_skill = 0;
            FOREACH_CLIENT(it.wants_join < 0 || (it == this && it.team <= 0),
            {
                float it_skill = it.m_skill_mu ? it.m_skill_mu : server_skill_average; // average was set by TeamBalance_AreEqual()
                if (it_skill > strongest_autoselect_client_skill)
                {
                    strongest_autoselect_client = it;
                    strongest_autoselect_client_skill = it_skill;
                }
            });
            if (strongest_autoselect_client == this) // can't just Join(); return; due to player_with_dibs
            {
                entity balance = TeamBalance_CheckAllowedTeams(this);
                int best_team_index = TeamBalance_FindBestTeam(balance, this, true);
                TeamBalance_Destroy(balance);
                SetPlayerTeam(this, best_team_index, TEAM_CHANGE_AUTO);
            }
            else if (strongest_autoselect_client)
                Join(strongest_autoselect_client, false);
        }
    }
 
    Kill_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CPID_PREVENT_JOIN);
 
    TRANSMUTE(Player, this);
    PutClientInServer(this);
 
    if(IS_PLAYER(this)) // could be false due to PutClientInServer() mutator hook
    {
        if (!teamplay)
            Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_JOIN_PLAY, this.netname);
        else if (player_with_dibs)
            // limitation: notifications support only 1 translated team name
            // so the team `this` preferred can't be mentioned, only the team they got assigned to.
            Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, APP_TEAM_NUM(this.team, CENTER_JOIN_PLAY_TEAM_QUEUECONFLICT), player_with_dibs.netname);
        else
        {
            if (this.wants_join && game_starttime < time && !warmup_stage) // No countdown running && not returning to warmup via ReadyRestart_force
                Send_Notification(NOTIF_ONE_ONLY, this, MSG_ANNCE, ANNCE_BEGIN); // Get queued player's attention
            Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, APP_TEAM_NUM(this.team, CENTER_JOIN_PLAY_TEAM));
        }
    }
 
    this.team_selected = 0;
    this.wants_join = 0;
}

References autocvar_g_campaign, AVAILABLE_TEAMS, campaign_bots_may_start, entity(), FOREACH_CLIENT, game_starttime, game_stopped, Join(), NULL, ReadyRestart(), SetPlayerTeam(), TEAM_CHANGE_AUTO, TeamBalance_AreEqual(), TeamBalance_CheckAllowedTeams(), TeamBalance_Destroy(), TeamBalance_FindBestTeam(), and time.

Referenced by ClientCommand_join(), Join(), ObserverOrSpectatorThink(), PlayerPreThink(), ReadyRestart_force(), and TeamBalance_QueuedPlayersTagIn().

◆ joinAllowed()

bool joinAllowed	(	entity	this,
		int	team_index )

Definition at line 2258 of file client.qc.

{
    if (CS(this).version_mismatch)
    {
        Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_JOIN_PREVENT_VERSIONMISMATCH);
        return false;
    }
    if (time < CS(this).jointime + MIN_SPEC_TIME) return false;
    if (teamplay && lockteams)
    {
        Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_TEAMCHANGE_LOCKED);
        return false;
    }
 
    if (Player_GetForcedTeamIndex(this) == TEAM_FORCE_SPECTATOR) return false;
 
    if (!INGAME(this) && PlayerInList(this, autocvar_g_playban_list))
    {
        Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_JOIN_PLAYBAN);
        return false;
    }
 
    // IS_PLAYER for most gametypes, INGAME for ca, lms, surv
    if (autocvar_g_maxping && !(IS_PLAYER(this) || INGAME(this)) && !this.wants_join)
    {
        if (this.ping <= 0) return false; // too soon
        if (this.ping > autocvar_g_maxping)
        {
            Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_JOIN_PREVENT_PING);
            return false;
        }
    }
 
    if (QueueNeeded(this, team_index))
    {
        if (team_index == 0) // so ClientCommand_selectteam() can check joinAllowed() before calling SetPlayerTeam() without chicken/egg problem
            if (ShowTeamSelection(this)) return false; // only needed by callsites other than selectteam
        // queuePlayer called here so that only conditions above block queuing (g_maxplayers shouldn't)
        if (queuePlayer(this, team_index)) return false;
        if (!nJoinAllowed(this)) return false;
    }
    else
    {
        if (!nJoinAllowed(this)) return false;
        if (team_index == 0) // so ClientCommand_selectteam() can check joinAllowed() before calling SetPlayerTeam() without chicken/egg problem
            if (ShowTeamSelection(this)) return false; // only needed by callsites other than selectteam
    }
 
    return true;
}

References autocvar_g_maxping, autocvar_g_playban_list, CS(), entity(), INGAME, IS_PLAYER, jointime, lockteams, MIN_SPEC_TIME, nJoinAllowed(), ping, Player_GetForcedTeamIndex(), PlayerInList(), QueueNeeded(), queuePlayer(), Send_Notification(), ShowTeamSelection(), TEAM_FORCE_SPECTATOR, teamplay, time, and wants_join.

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

◆ NET_HANDLE()

NET_HANDLE	(	fpsreport	,
		bool	)

Definition at line 3129 of file client.qc.

{
    int fps = ReadShort();
    PlayerScore_Set(sender, SP_FPS, fps);
    return true;
}

References PlayerScore_Set().

◆ nJoinAllowed()

int nJoinAllowed ( entity this )

Determines how many player slots are free.

This depends on cvar g_maxplayers and other limits that apply to all clients which aren't specifically excepted.

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

Definition at line 2171 of file client.qc.

{
    if(!this)
    // 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"
        || autocvar_g_forced_team_otherwise == "spectator"
        || (teamplay && lockteams))
            return 0;
    }
 
    int totalClients = 0;
    int currentlyPlaying = 0;
    FOREACH_CLIENT(it != this,
    {
        ++totalClients;
        if(IS_PLAYER(it) || INGAME(it))
            ++currentlyPlaying;
    });
 
    int player_limit = GetPlayerLimit();
 
    int free_slots = max(0, (player_limit ? player_limit : maxclients) - currentlyPlaying);
    if (this || maxclients - totalClients) // don't add bot slots in the getstatus case if nobody can connect
        free_slots += bots_would_leave;
    if (!this) // getstatus case
        free_slots = min(free_slots, maxclients - totalClients);
 
    if(this && !free_slots)
        Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_JOIN_PREVENT, player_limit);
 
    return free_slots;
}

References autocvar_g_forced_team_otherwise, bots_would_leave, entity(), FOREACH_CLIENT, GetPlayerLimit(), INGAME, IS_PLAYER, lockteams, max(), maxclients, min(), Send_Notification(), and teamplay.

Referenced by joinAllowed(), and WinningConditionHelper().

◆ ObserverOrSpectatorThink()

void ObserverOrSpectatorThink ( entity this )

Definition at line 2493 of file client.qc.

{
    bool is_spec = IS_SPEC(this);
    if ( CS(this).impulse )
    {
        int r = MinigameImpulse(this, CS(this).impulse);
        if (!is_spec || r)
            CS(this).impulse = 0;
 
        if (is_spec && CS(this).impulse == IMP_weapon_drop.impulse)
        {
            STAT(CAMERA_SPECTATOR, this) = (STAT(CAMERA_SPECTATOR, this) + 1) % 3;
            CS(this).impulse = 0;
            return;
        }
    }
 
    if (frametime && autocvar_sv_show_entnum) show_entnum(this);
 
    if (IS_BOT_CLIENT(this) && !CS(this).autojoin_checked)
    {
        CS(this).autojoin_checked = 1;
        TRANSMUTE(Player, this);
        PutClientInServer(this);
 
        .entity weaponentity = weaponentities[0];
        if(this.(weaponentity).m_weapon == WEP_Null)
            W_NextWeapon(this, 0, weaponentity);
 
        return;
    }
 
    if (this.flags & FL_JUMPRELEASED)
    {
        if (PHYS_INPUT_BUTTON_JUMP(this) && (joinAllowed(this, this.wants_join) || time < CS(this).jointime + MIN_SPEC_TIME))
        {
            this.flags &= ~FL_JUMPRELEASED;
            this.flags |= FL_SPAWNING;
        }
        else if((is_spec && (PHYS_INPUT_BUTTON_ATCK(this) || CS(this).impulse == 10 || CS(this).impulse == 15 || CS(this).impulse == 18 || (CS(this).impulse >= 200 && CS(this).impulse <= 209)))
        || (!is_spec && ((PHYS_INPUT_BUTTON_ATCK(this) && !CS(this).version_mismatch) || this.would_spectate)))
        {
            this.flags &= ~FL_JUMPRELEASED;
            if (autocvar_sv_spectate == 2 && !warmup_stage && !this.vote_master)
                Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_SPECTATE_SPEC_NOTALLOWED);
            else if(SpectateNext(this))
                { }
            else if (is_spec)
            {
                TRANSMUTE(Observer, this);
                PutClientInServer(this);
            }
            else
                this.would_spectate = false; // unable to spectate anyone
 
            if (is_spec)
                CS(this).impulse = 0;
        }
        else if (is_spec)
        {
            if(CS(this).impulse == 12 || CS(this).impulse == 16  || CS(this).impulse == 19 || (CS(this).impulse >= 220 && CS(this).impulse <= 229))
            {
                this.flags &= ~FL_JUMPRELEASED;
                if (!SpectatePrev(this))
                {
                    TRANSMUTE(Observer, this);
                    PutClientInServer(this);
                }
                CS(this).impulse = 0;
            }
            else if(PHYS_INPUT_BUTTON_ATCK2(this))
            {
                if(!observe_blocked_if_eliminated || !INGAME(this))
                {
                    this.would_spectate = false;
                    this.flags &= ~FL_JUMPRELEASED;
                    TRANSMUTE(Observer, this);
                    PutClientInServer(this);
                }
            }
            else if(!SpectateUpdate(this) && !SpectateNext(this))
            {
                PutObserverInServer(this, false, true);
                this.would_spectate = true;
            }
        }
        else
        {
            bool wouldclip = CS_CVAR(this).cvar_cl_clippedspectating;
            if (PHYS_INPUT_BUTTON_USE(this))
                wouldclip = !wouldclip;
            int preferred_movetype = (wouldclip ? MOVETYPE_FLY_WORLDONLY : MOVETYPE_NOCLIP);
            set_movetype(this, preferred_movetype);
        }
    }
    else
    { // jump pressed
        if ((is_spec && !(PHYS_INPUT_BUTTON_ATCK(this) || PHYS_INPUT_BUTTON_ATCK2(this)))
        || (!is_spec && !(PHYS_INPUT_BUTTON_ATCK(this) || PHYS_INPUT_BUTTON_JUMP(this))))
        {
            this.flags |= FL_JUMPRELEASED;
            // primary attack pressed
            if(this.flags & FL_SPAWNING)
            {
                this.flags &= ~FL_SPAWNING;
                if(joinAllowed(this, this.wants_join))
                    Join(this, teamplay);
                else if(time < CS(this).jointime + MIN_SPEC_TIME)
                    CS(this).autojoin_checked = -1;
                return;
            }
        }
        if(is_spec && !SpectateUpdate(this))
            PutObserverInServer(this, false, true);
    }
    if (is_spec)
        this.flags |= FL_CLIENT | FL_NOTARGET;
}

References autocvar_sv_show_entnum, autocvar_sv_spectate, CS(), CS_CVAR, entity(), FL_CLIENT, FL_JUMPRELEASED, FL_NOTARGET, FL_SPAWNING, flags, frametime, impulse, INGAME, IS_BOT_CLIENT, IS_SPEC, Join(), joinAllowed(), jointime, m_weapon, MIN_SPEC_TIME, MinigameImpulse(), MOVETYPE_FLY_WORLDONLY, MOVETYPE_NOCLIP, observe_blocked_if_eliminated, PHYS_INPUT_BUTTON_ATCK, PHYS_INPUT_BUTTON_ATCK2, PHYS_INPUT_BUTTON_JUMP, PHYS_INPUT_BUTTON_USE, PutClientInServer, PutObserverInServer(), Send_Notification(), set_movetype(), show_entnum(), SpectateNext(), SpectatePrev(), SpectateUpdate(), STAT, teamplay, time, TRANSMUTE, vote_master, W_NextWeapon(), wants_join, warmup_stage, weaponentities, and would_spectate.

Referenced by PlayerPreThink().

◆ play_countdown()

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

Definition at line 1532 of file client.qc.

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

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

Referenced by player_powerups().

◆ player_getspecies()

int player_getspecies ( entity this )

Definition at line 444 of file client.qc.

{
    get_model_parameters(this.model, this.skin);
    int s = get_model_parameters_species;
    get_model_parameters(string_null, 0);
    if (s < 0) return SPECIES_HUMAN;
    return s;
}

References entity(), get_model_parameters(), get_model_parameters_species, model, skin, SPECIES_HUMAN, and string_null.

Referenced by FixPlayermodel().

◆ Player_Physics()

void Player_Physics ( entity this )

Definition at line 2790 of file client.qc.

{
    this.movetype = (this.move_qcphysics) ? MOVETYPE_QCPLAYER : this.move_movetype;
 
    if(!this.move_qcphysics)
        return;
 
    if(!frametime && !CS(this).pm_frametime)
        return;
 
    Movetype_Physics_NoMatchTicrate(this, CS(this).pm_frametime, true);
}

References CS(), entity(), frametime, move_movetype, move_qcphysics, movetype, Movetype_Physics_NoMatchTicrate(), and MOVETYPE_QCPLAYER.

Referenced by PlayerPostThink().

◆ player_powerups()

void player_powerups ( entity this )

Definition at line 1557 of file client.qc.

{
    if((this.items & IT_USING_JETPACK) && !IS_DEAD(this) && !game_stopped)
        this.modelflags |= MF_ROCKET;
    else
        this.modelflags &= ~MF_ROCKET;
 
    this.effects &= ~EF_NODEPTHTEST;
 
    if (IS_DEAD(this))
        player_powerups_remove_all(this, true);
 
    if((this.alpha < 0 || IS_DEAD(this)) && !this.vehicle) // don't apply the flags if the player is gibbed
        return;
 
    // add a way to see what the items were BEFORE all of these checks for the mutator hook
    int items_prev = this.items;
 
    if (!MUTATOR_IS_ENABLED(mutator_instagib))
    {
        // NOTE: superweapons are a special case and as such are handled here instead of the status effects system
        if (this.items & IT_SUPERWEAPON)
        {
            if (!(STAT(WEAPONS, this) & WEPSET_SUPERWEAPONS))
            {
                StatusEffects_remove(STATUSEFFECT_Superweapon, this, STATUSEFFECT_REMOVE_NORMAL);
                this.items &= ~IT_SUPERWEAPON;
                //Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_SUPERWEAPON_LOST, this.netname);
                Send_Notification(NOTIF_ONE, this, MSG_CENTER, CENTER_SUPERWEAPON_LOST);
            }
            else if (this.items & IT_UNLIMITED_SUPERWEAPONS)
            {
                // don't let them run out
            }
            else
            {
                play_countdown(this, StatusEffects_gettime(STATUSEFFECT_Superweapon, this), SND_POWEROFF);
                if (time >= StatusEffects_gettime(STATUSEFFECT_Superweapon, this))
                {
                    this.items &= ~IT_SUPERWEAPON;
                    STAT(WEAPONS, this) &= ~WEPSET_SUPERWEAPONS;
                    //Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_SUPERWEAPON_BROKEN, this.netname);
                    Send_Notification(NOTIF_ONE, this, MSG_CENTER, CENTER_SUPERWEAPON_BROKEN);
                }
            }
        }
        else if(STAT(WEAPONS, this) & WEPSET_SUPERWEAPONS)
        {
            if (time < StatusEffects_gettime(STATUSEFFECT_Superweapon, this) || (this.items & IT_UNLIMITED_SUPERWEAPONS))
            {
                this.items |= IT_SUPERWEAPON;
                if(!(this.items & IT_UNLIMITED_SUPERWEAPONS))
                {
                    if(!g_cts)
                        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_SUPERWEAPON_PICKUP, this.netname);
                    Send_Notification(NOTIF_ONE, this, MSG_CENTER, CENTER_SUPERWEAPON_PICKUP);
                }
            }
            else
            {
                if(StatusEffects_active(STATUSEFFECT_Superweapon, this))
                    StatusEffects_remove(STATUSEFFECT_Superweapon, this, STATUSEFFECT_REMOVE_TIMEOUT);
                STAT(WEAPONS, this) &= ~WEPSET_SUPERWEAPONS;
            }
        }
        else if(StatusEffects_active(STATUSEFFECT_Superweapon, this)) // cheaper to check than to update each frame!
        {
            StatusEffects_remove(STATUSEFFECT_Superweapon, this, STATUSEFFECT_REMOVE_CLEAR);
        }
    }
 
    if(autocvar_g_nodepthtestplayers)
        this.effects |= EF_NODEPTHTEST;
 
    if(autocvar_g_fullbrightplayers)
        this.effects |= EF_FULLBRIGHT;
 
    MUTATOR_CALLHOOK(PlayerPowerups, this, items_prev);
}

References alpha, autocvar_g_fullbrightplayers, autocvar_g_nodepthtestplayers, EF_FULLBRIGHT, EF_NODEPTHTEST, effects, entity(), g_cts, game_stopped, IS_DEAD, IT_SUPERWEAPON, IT_UNLIMITED_SUPERWEAPONS, IT_USING_JETPACK, items, MF_ROCKET, modelflags, MUTATOR_CALLHOOK, MUTATOR_IS_ENABLED, netname, NULL, play_countdown(), player_powerups_remove_all(), Send_Notification(), STAT, STATUSEFFECT_REMOVE_CLEAR, STATUSEFFECT_REMOVE_NORMAL, STATUSEFFECT_REMOVE_TIMEOUT, StatusEffects_active(), StatusEffects_gettime(), StatusEffects_remove(), time, vehicle, and WEPSET_SUPERWEAPONS.

Referenced by PlayerThink().

◆ player_powerups_remove_all()

void player_powerups_remove_all	(	entity	this,
		bool	allow_poweroff_sound )

Definition at line 1541 of file client.qc.

{
    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 (allow_poweroff_sound && time > game_starttime + 1 && IS_CLIENT(this)
        && !(start_items & (IT_UNLIMITED_AMMO | IT_UNLIMITED_SUPERWEAPONS)))
            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));
    }
}

References ATTEN_NORM, CH_INFO, CH_TRIGGER_SINGLE, entity(), game_starttime, IS_CLIENT, IT_SUPERWEAPON, IT_UNLIMITED_AMMO, IT_UNLIMITED_SUPERWEAPONS, items, sound, start_items, stopsound(), time, and VOL_BASE.

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

◆ player_regen()

void player_regen ( entity this )

Definition at line 1688 of file client.qc.

{
    float max_mod, regen_mod, rot_mod, limit_mod;
    max_mod = regen_mod = rot_mod = limit_mod = 1;
 
    float regen_health = autocvar_g_balance_health_regen;
    float regen_health_linear = autocvar_g_balance_health_regenlinear;
    float regen_health_rot = autocvar_g_balance_health_rot;
    float regen_health_rotlinear = autocvar_g_balance_health_rotlinear;
    float regen_health_stable = autocvar_g_balance_health_regenstable;
    float regen_health_rotstable = autocvar_g_balance_health_rotstable;
    bool mutator_returnvalue = MUTATOR_CALLHOOK(PlayerRegen, this, max_mod, regen_mod, rot_mod, limit_mod, regen_health, regen_health_linear, regen_health_rot,
                                                regen_health_rotlinear, regen_health_stable, regen_health_rotstable);
    max_mod = M_ARGV(1, float);
    regen_mod = M_ARGV(2, float);
    rot_mod = M_ARGV(3, float);
    limit_mod = M_ARGV(4, float);
    regen_health = M_ARGV(5, float);
    regen_health_linear = M_ARGV(6, float);
    regen_health_rot = M_ARGV(7, float);
    regen_health_rotlinear = M_ARGV(8, float);
    regen_health_stable = M_ARGV(9, float);
    regen_health_rotstable = M_ARGV(10, float);
 
    float rotstable, regenstable, rotframetime, regenframetime;
 
    if(!mutator_returnvalue)
    {
        regenstable = autocvar_g_balance_armor_regenstable;
        rotstable = autocvar_g_balance_armor_rotstable;
        regenframetime = (time > this.pauseregen_finished) ? (regen_mod * frametime) : 0;
        rotframetime = (time > this.pauserotarmor_finished) ? (rot_mod * frametime) : 0;
        RotRegen(this, RES_ARMOR, limit_mod,
                 regenstable, autocvar_g_balance_armor_regen, autocvar_g_balance_armor_regenlinear, regenframetime,
                 rotstable, autocvar_g_balance_armor_rot, autocvar_g_balance_armor_rotlinear, rotframetime);
 
        // NOTE: max_mod is only applied to health
        regenstable = regen_health_stable * max_mod;
        rotstable = regen_health_rotstable * max_mod;
        regenframetime = (time > this.pauseregen_finished) ? (regen_mod * frametime) : 0;
        rotframetime = (time > this.pauserothealth_finished) ? (rot_mod * frametime) : 0;
        RotRegen(this, RES_HEALTH, limit_mod,
                 regenstable, regen_health, regen_health_linear, regenframetime,
                 rotstable, regen_health_rot, regen_health_rotlinear, rotframetime);
    }
 
    // if player rotted to death...  die!
    // check this outside above checks, as player may still be able to rot to death
    if(GetResource(this, RES_HEALTH) < 1)
    {
        if(this.vehicle)
            vehicles_exit(this.vehicle, VHEF_RELEASE);
        if(this.event_damage)
            this.event_damage(this, this, this, 1, DEATH_ROT.m_id, DMG_NOWEP, this.origin, '0 0 0');
    }
 
    if (!(this.items & IT_UNLIMITED_AMMO))
    {
        regenstable = autocvar_g_balance_fuel_regenstable;
        rotstable = autocvar_g_balance_fuel_rotstable;
        regenframetime = ((time > this.pauseregen_finished) && (this.items & ITEM_FuelRegen.m_itemid)) ? frametime : 0;
        rotframetime = (time > this.pauserotfuel_finished) ? frametime : 0;
        RotRegen(this, RES_FUEL, 1,
                 regenstable, autocvar_g_balance_fuel_regen, autocvar_g_balance_fuel_regenlinear, regenframetime,
                 rotstable, autocvar_g_balance_fuel_rot, autocvar_g_balance_fuel_rotlinear, rotframetime);
    }
}

Referenced by PlayerThink().

◆ PlayerFrame()

void PlayerFrame ( entity this )

Definition at line 2844 of file client.qc.

{
    Physics_UpdateStats(this);
 
    // Don't accumulate alivetime whilst afk as xonstat skill ratings are based on score per second.
    // Time accumulated so far (including the 30s) is retained in the event of a move to spec, disconnect, etc.
    if (this.alivetime_start && time - CS(this).parm_idlesince >= 30)
        this.alivetime_start += frametime;
 
// formerly PreThink code
 
    if (this.score_frame_dmg)
    {
        this.handicap_avg_given_sum += this.score_frame_dmg * Handicap_GetTotalHandicap(this, false);
        GameRules_scoring_add(this, DMG, this.score_frame_dmg);
        this.score_frame_dmg = 0;
    }
    if (this.score_frame_dmgtaken)
    {
        this.handicap_avg_taken_sum += this.score_frame_dmgtaken * Handicap_GetTotalHandicap(this, true);
        GameRules_scoring_add(this, DMGTAKEN, this.score_frame_dmgtaken);
        this.score_frame_dmgtaken = 0;
    }
 
    STAT(GUNALIGN, this) = CS_CVAR(this).cvar_cl_gunalign; // TODO
    STAT(MOVEVARS_CL_TRACK_CANJUMP, this) = CS_CVAR(this).cvar_cl_movement_track_canjump;
 
    // physics frames: update anticheat stuff
    anticheat_prethink(this);
 
    // Check if spectating is allowed
    // cvar hook/callback TODO: make this event-driven
    if (!autocvar_sv_spectate && IS_REAL_CLIENT(this)
    && (IS_SPEC(this) || IS_OBSERVER(this)) && !INGAME(this))
    {
        float cutoff = CS(this).spectatortime + autocvar_g_maxplayers_spectator_blocktime;
        if (time > cutoff + MIN_SPEC_TIME * 0.5 // sv_spectate was disabled recently (or the server was stalled far too long)
        || CS(this).autojoin_checked == 0) // or too soon to have tried to autojoin
        {
            CS(this).spectatortime = time; // reset the grace period
            if (CS(this).autojoin_checked) // only notify when sv_spectate was disabled recently, to prevent spam
                Send_Notification(NOTIF_ONE_ONLY, this, MSG_MULTI, SPECTATE_WARNING, autocvar_g_maxplayers_spectator_blocktime);
        }
        else if (time > cutoff)
            if (dropclient_schedule(this))
                Send_Notification(NOTIF_ONE_ONLY, this, MSG_INFO, INFO_QUIT_KICK_SPECTATING);
    }
 
    // Check for nameless players
    if (this.netname == "" || this.netname != CS(this).netname_previous)
    {
        bool assume_unchanged = (CS(this).netname_previous == "");
        if (autocvar_sv_name_maxlength > 0 && strlennocol(this.netname) > autocvar_sv_name_maxlength)
        {
            int new_length = textLengthUpToLength(this.netname, autocvar_sv_name_maxlength, strlennocol);
            this.netname = strzone(strcat(substring(this.netname, 0, new_length), "^7"));
            sprint(this, sprintf("Warning: your name is longer than %d characters, it has been truncated.\n", autocvar_sv_name_maxlength));
            assume_unchanged = false;
            // stuffcmd(this, strcat("name ", this.netname, "\n")); // maybe?
        }
        if (isInvisibleString(this.netname))
        {
            this.netname = strzone(sprintf("Player#%d", this.playerid));
            sprint(this, "Warning: invisible names are not allowed.\n");
            assume_unchanged = false;
            // stuffcmd(this, strcat("name ", this.netname, "\n")); // maybe?
        }
        if (!assume_unchanged && autocvar_sv_eventlog)
            GameLogEcho(strcat(":name:", ftos(this.playerid), ":", playername(this.netname, this.team, false)));
        strcpy(CS(this).netname_previous, this.netname);
    }
 
    // version nagging
    if (CS(this).version_nagtime && CS_CVAR(this).cvar_g_xonoticversion && time > CS(this).version_nagtime)
    {
        CS(this).version_nagtime = 0;
        if (strstrofs(CS_CVAR(this).cvar_g_xonoticversion, "git", 0) >= 0 || strstrofs(CS_CVAR(this).cvar_g_xonoticversion, "autobuild", 0) >= 0)
        {
            // git client
        }
        else if (strstrofs(autocvar_g_xonoticversion, "git", 0) >= 0 || strstrofs(autocvar_g_xonoticversion, "autobuild", 0) >= 0)
        {
            // git server
            Send_Notification(NOTIF_ONE_ONLY, this, MSG_INFO, INFO_VERSION_BETA, autocvar_g_xonoticversion, CS_CVAR(this).cvar_g_xonoticversion);
        }
        else
        {
            int r = vercmp(CS_CVAR(this).cvar_g_xonoticversion, autocvar_g_xonoticversion);
            if (r < 0) // old client
                Send_Notification(NOTIF_ONE_ONLY, this, MSG_INFO, INFO_VERSION_OUTDATED, autocvar_g_xonoticversion, CS_CVAR(this).cvar_g_xonoticversion);
            else if (r > 0) // old server
                Send_Notification(NOTIF_ONE_ONLY, this, MSG_INFO, INFO_VERSION_OLD, autocvar_g_xonoticversion, CS_CVAR(this).cvar_g_xonoticversion);
        }
    }
 
    if (this.ignore_list_send_time > 0 && time > this.ignore_list_send_time)
        ignore_list_send(this);
 
    // GOD MODE info
    if (!(this.flags & FL_GODMODE) && this.max_armorvalue)
    {
        Send_Notification(NOTIF_ONE_ONLY, this, MSG_INFO, INFO_GODMODE_OFF, this.max_armorvalue);
        this.max_armorvalue = 0;
    }
 
    // Vehicles
    if(autocvar_g_vehicles_enter && (time > this.last_vehiclecheck) && !game_stopped && !this.vehicle)
    if(IS_PLAYER(this) && !STAT(FROZEN, this) && !StatusEffects_active(STATUSEFFECT_Frozen, this) && !IS_DEAD(this) && !IS_INDEPENDENT_PLAYER(this))
    {
        FOREACH_ENTITY_RADIUS(this.origin, autocvar_g_vehicles_enter_radius, IS_VEHICLE(it) && !IS_DEAD(it) && it.takedamage != DAMAGE_NO,
        {
            if(!it.owner)
            {
                if(!it.team || SAME_TEAM(this, it))
                    Send_Notification(NOTIF_ONE, this, MSG_CENTER, CENTER_VEHICLE_ENTER);
                else if(autocvar_g_vehicles_steal)
                    Send_Notification(NOTIF_ONE, this, MSG_CENTER, CENTER_VEHICLE_ENTER_STEAL);
            }
            else if((it.vehicle_flags & VHF_MULTISLOT) && SAME_TEAM(it.owner, this))
            {
                Send_Notification(NOTIF_ONE, this, MSG_CENTER, CENTER_VEHICLE_ENTER_GUNNER);
            }
        });
 
        this.last_vehiclecheck = time + 1;
    }
 
 
 
// formerly PostThink code
    if (autocvar_sv_maxidle > 0 || ((IS_PLAYER(this) || this.wants_join) && autocvar_sv_maxidle_playertospectator > 0))
    if (IS_REAL_CLIENT(this))
    if (IS_PLAYER(this) || this.wants_join || autocvar_sv_maxidle_alsokickspectators)
    if (!intermission_running) // NextLevel() kills all centerprints after setting this true
    {
        int totalClients = 0;
        if(autocvar_sv_maxidle > 0 && autocvar_sv_maxidle_slots > 0)
        {
            // maxidle disabled in local matches by not counting clients (totalClients 0)
            if (autocvar_sv_dedicated)
            {
                FOREACH_CLIENT(IS_REAL_CLIENT(it) || autocvar_sv_maxidle_slots_countbots,
                {
                    ++totalClients;
                });
                if (maxclients - totalClients > autocvar_sv_maxidle_slots)
                    totalClients = 0;
            }
        }
        else if ((IS_PLAYER(this) || this.wants_join) && autocvar_sv_maxidle_playertospectator > 0)
        {
            FOREACH_CLIENT(IS_REAL_CLIENT(it),
            {
                ++totalClients;
            });
        }
 
        if (totalClients < autocvar_sv_maxidle_minplayers)
        {
            // idle kick disabled
            CS(this).parm_idlesince = time;
        }
        else if (time - CS(this).parm_idlesince < 1) // instead of (time == this.parm_idlesince) to support sv_maxidle <= 10
        {
            if (CS(this).idlekick_lasttimeleft)
            {
                CS(this).idlekick_lasttimeleft = 0;
                Kill_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CPID_IDLING);
            }
        }
        else
        {
            float maxidle_time = autocvar_sv_maxidle;
            if ((IS_PLAYER(this) || this.wants_join)
            && autocvar_sv_maxidle_playertospectator > 0)
                maxidle_time = autocvar_sv_maxidle_playertospectator;
            float timeleft = ceil(maxidle_time - (time - CS(this).parm_idlesince));
            float countdown_time = max(min(10, maxidle_time - 1), ceil(maxidle_time * 0.33)); // - 1 to support maxidle_time <= 10
            if (timeleft == countdown_time && !CS(this).idlekick_lasttimeleft)
            {
                if ((IS_PLAYER(this) || this.wants_join) && autocvar_sv_maxidle_playertospectator > 0)
                {
                    if (!this.wants_join) // no countdown centreprint when getting kicked off the join queue
                        Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_MOVETOSPEC_IDLING, timeleft);
                }
                else
                    Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_DISCONNECT_IDLING, timeleft);
            }
            if (timeleft <= 0)
            {
                if ((IS_PLAYER(this) || this.wants_join)
                && autocvar_sv_maxidle_playertospectator > 0)
                {
                    if (this.wants_join)
                        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_MOVETOSPEC_IDLING_QUEUE, this.netname, maxidle_time);
                    else
                        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_MOVETOSPEC_IDLING, this.netname, maxidle_time);
                    PutObserverInServer(this, true, true);
                    // Can't do this in PutObserverInServer() or SetPlayerTeam() cos it causes
                    // mouse2 (change spectate mode) to kick the player off the join queue.
                    this.wants_join = 0;
                    this.team_selected = 0;
                    // when the player is kicked off the server, these are called in ClientDisconnect()
                    if (!TeamBalance_QueuedPlayersTagIn(this))
                    if (autocvar_g_balance_teams_remove)
                        TeamBalance_RemoveExcessPlayers(this);
                }
                else
                {
                    if (dropclient_schedule(this))
                        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_QUIT_KICK_IDLING, this.netname, maxidle_time);
                }
                return;
            }
            else if (timeleft <= countdown_time
            && !this.wants_join) // no countdown bangs when getting kicked off the join queue
            {
                if (timeleft != CS(this).idlekick_lasttimeleft)
                    play2(this, SND(TALK2));
                CS(this).idlekick_lasttimeleft = timeleft;
            }
        }
    }
 
    CheatFrame(this);
 
    if (game_stopped)
    {
        this.solid = SOLID_NOT;
        this.takedamage = DAMAGE_NO;
        set_movetype(this, MOVETYPE_NONE);
        CS(this).teamkill_complain = 0;
        CS(this).teamkill_soundtime = 0;
        CS(this).teamkill_soundsource = NULL;
    }
 
    if (this.waypointsprite_attachedforcarrier) {
        float hp = healtharmor_maxdamage(GetResource(this, RES_HEALTH), GetResource(this, RES_ARMOR), autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id).x;
        WaypointSprite_UpdateHealth(this.waypointsprite_attachedforcarrier, hp);
    }
}

References alivetime_start, anticheat_prethink(), autocvar_g_maxplayers_spectator_blocktime, autocvar_g_vehicles_enter_radius, autocvar_g_xonoticversion, autocvar_sv_eventlog, autocvar_sv_name_maxlength, autocvar_sv_spectate, CS(), CS_CVAR, DAMAGE_NO, dropclient_schedule(), entity(), FL_GODMODE, flags, FOREACH_ENTITY_RADIUS, frametime, ftos(), game_stopped, GameLogEcho(), GameRules_scoring_add, handicap_avg_given_sum, handicap_avg_taken_sum, Handicap_GetTotalHandicap(), ignore_list_send(), ignore_list_send_time, INGAME, IS_DEAD, IS_INDEPENDENT_PLAYER, IS_OBSERVER, IS_PLAYER, IS_REAL_CLIENT, IS_SPEC, IS_VEHICLE, isInvisibleString(), last_vehiclecheck, max_armorvalue, MIN_SPEC_TIME, netname, origin, Physics_UpdateStats(), playerid, playername(), SAME_TEAM, score_frame_dmg, score_frame_dmgtaken, Send_Notification(), sprint(), STAT, StatusEffects_active(), strcat(), strcpy, strstrofs, strzone(), substring(), team, textLengthUpToLength(), time, vehicle, vercmp(), and VHF_MULTISLOT.

Referenced by StartFrame().

◆ PlayerInIDList()

bool PlayerInIDList	(	entity	p,
		string	idlist )

Definition at line 1038 of file client.qc.

{
    // NOTE: we do NOT check crypto_idfp_signed here, an unsigned ID is fine too for this
    if(!p.crypto_idfp)
        return false;
 
    return findinlist_abbrev(p.crypto_idfp, idlist);
}

References entity(), and findinlist_abbrev().

Referenced by BanCommand_mute(), BanCommand_playban(), BanCommand_voteban(), MUTATOR_HOOKFUNCTION(), and PlayerInList().

◆ PlayerInIPList()

bool PlayerInIPList	(	entity	p,
		string	iplist )

Definition at line 1029 of file client.qc.

{
    // some safety checks (never allow local?)
    if(p.netaddress == "local" || p.netaddress == "" || !IS_REAL_CLIENT(p))
        return false;
 
    return findinlist_abbrev(p.netaddress, iplist);
}

References entity(), findinlist_abbrev(), and IS_REAL_CLIENT.

Referenced by BanCommand_mute(), BanCommand_playban(), BanCommand_voteban(), MUTATOR_HOOKFUNCTION(), and PlayerInList().

◆ PlayerInList()

bool PlayerInList	(	entity	player,
		string	list )

Definition at line 1047 of file client.qc.

{
    if (list == "")
        return false;
    return boolean(PlayerInIDList(player, list) || PlayerInIPList(player, list));
}

References boolean, entity(), PlayerInIDList(), and PlayerInIPList().

Referenced by ClientCommand_minigame(), ClientConnect(), ignore_playerindb(), invite_minigame(), joinAllowed(), MUTATOR_HOOKFUNCTION(), Player_DetermineForcedTeam(), VoteCommand_abstain(), VoteCommand_call(), VoteCommand_no(), and VoteCommand_yes().

◆ PlayerPostThink()

void PlayerPostThink ( entity this )

Definition at line 2813 of file client.qc.

{
    Player_Physics(this);
 
    if (IS_PLAYER(this))
    {
        DrownPlayer(this);
        UpdateChatBubble(this);
        if (CS(this).impulse)
            ImpulseCommands(this);
        GetPressedKeys(this);
    }
    else if (IS_OBSERVER(this) && STAT(PRESSED_KEYS, this))
    {
        CS(this).pressedkeys = 0;
        STAT(PRESSED_KEYS, this) = 0;
    }
 
    CSQCMODEL_AUTOUPDATE(this);
    CS(this).pm_frametime = 0; // CSQCModel_CheckUpdate() and Player_Physics() both read it
}

References CS(), CSQCMODEL_AUTOUPDATE, DrownPlayer(), entity(), GetPressedKeys(), impulse, ImpulseCommands(), IS_OBSERVER, IS_PLAYER, Player_Physics(), STAT, and UpdateChatBubble().

◆ PlayerPreThink()

void PlayerPreThink ( entity this )

Definition at line 2675 of file client.qc.

{
    WarpZone_PlayerPhysics_FixVAngle(this);
 
    zoomstate_set = false;
 
    MUTATOR_CALLHOOK(PlayerPreThink, this);
 
    if(PHYS_INPUT_BUTTON_USE(this) && !CS(this).usekeypressed)
        PlayerUseKey(this);
    CS(this).usekeypressed = PHYS_INPUT_BUTTON_USE(this);
 
    if (IS_PLAYER(this))
    {
        if (IS_REAL_CLIENT(this) && time < CS(this).jointime + MIN_SPEC_TIME)
            error("Client can't be spawned as player on connection!");
        if(!PlayerThink(this))
            return;
    }
    else if (game_stopped || intermission_running)
    {
        if(intermission_running)
            IntermissionThink(this);
        return;
    }
    else if (IS_REAL_CLIENT(this) && CS(this).autojoin_checked <= 0 && time >= CS(this).jointime + MIN_SPEC_TIME
    && this.ping > 0) // delay until centreprints could work (still on loading screen but timers start when it disappears)
    {
        bool early_join_requested = (CS(this).autojoin_checked < 0);
        CS(this).autojoin_checked = 1;
        // don't do this in ClientConnect
        // many things can go wrong if a client is spawned as player on connection
        if (early_join_requested || MUTATOR_CALLHOOK(AutoJoinOnConnection, this)
        || (!(autocvar_sv_spectate || autocvar_g_campaign || (Player_GetForcedTeamIndex(this) == TEAM_FORCE_SPECTATOR))
            && (!teamplay || autocvar_g_balance_teams)))
        {
            if(joinAllowed(this, this.wants_join))
                Join(this, teamplay);
            else if (!autocvar_sv_spectate) // we really want to join and some blockers may be brief (g_maxping)
                if (time < CS(this).spectatortime + MIN_SPEC_TIME) // centreprints don't appear while spamming
                    CS(this).autojoin_checked = -1; // keep trying for MIN_SPEC_TIME
            return;
        }
    }
    else if (IS_OBSERVER(this) || IS_SPEC(this))
        ObserverOrSpectatorThink(this);
 
    // WEAPONTODO: Add weapon request for this
    if (!zoomstate_set)
    {
        bool wep_zoomed = false;
        for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
        {
            .entity weaponentity = weaponentities[slot];
            Weapon thiswep = this.(weaponentity).m_weapon;
            if(thiswep != WEP_Null && thiswep.wr_zoom)
                wep_zoomed += thiswep.wr_zoom(thiswep, this);
        }
        SetZoomState(this, PHYS_INPUT_BUTTON_ZOOM(this) || PHYS_INPUT_BUTTON_ZOOMSCRIPT(this) || wep_zoomed);
    }
 
    // Voice sound effects
    if (CS(this).teamkill_soundtime && time > CS(this).teamkill_soundtime)
    {
        CS(this).teamkill_soundtime = 0;
 
        entity e = CS(this).teamkill_soundsource;
        entity oldpusher = e.pusher;
        e.pusher = this;
        PlayerSound(e, playersound_teamshoot, CH_VOICE, VOL_BASEVOICE, VOICETYPE_LASTATTACKER_ONLY, 1);
        e.pusher = oldpusher;
    }
 
    if (CS(this).taunt_soundtime && time > CS(this).taunt_soundtime)
    {
        CS(this).taunt_soundtime = 0;
        PlayerSound(this, playersound_taunt, CH_VOICE, VOL_BASEVOICE, VOICETYPE_AUTOTAUNT, 1);
    }
 
    target_voicescript_next(this);
}

References autocvar_g_balance_teams, autocvar_g_campaign, autocvar_sv_spectate, CH_VOICE, CS(), entity(), error, game_stopped, intermission_running, IntermissionThink(), IS_OBSERVER, IS_PLAYER, IS_REAL_CLIENT, IS_SPEC, Join(), joinAllowed(), jointime, m_weapon, MAX_WEAPONSLOTS, MIN_SPEC_TIME, MUTATOR_CALLHOOK, ObserverOrSpectatorThink(), PHYS_INPUT_BUTTON_USE, PHYS_INPUT_BUTTON_ZOOM, PHYS_INPUT_BUTTON_ZOOMSCRIPT, ping, Player_GetForcedTeamIndex(), PlayerPreThink, PlayerSound, PlayerThink(), PlayerUseKey(), SetZoomState(), spectatortime, target_voicescript_next(), taunt_soundtime, TEAM_FORCE_SPECTATOR, teamkill_soundtime, teamplay, time, VOICETYPE_AUTOTAUNT, VOICETYPE_LASTATTACKER_ONLY, VOL_BASEVOICE, wants_join, WarpZone_PlayerPhysics_FixVAngle(), weaponentities, Weapon::wr_zoom(), and zoomstate_set.

◆ PlayerThink()

bool PlayerThink ( entity this )

Definition at line 2336 of file client.qc.

{
    if (game_stopped || intermission_running)
    {
        this.modelflags &= ~MF_ROCKET;
        if(intermission_running)
            IntermissionThink(this);
        return false;
    }
 
    if (timeout_status == TIMEOUT_ACTIVE)
    {
        // don't allow the player to turn around while game is paused
        // FIXME turn this into CSQC stuff
        this.v_angle = this.lastV_angle;
        this.angles = this.lastV_angle;
        this.fixangle = true;
    }
 
    if (frametime) player_powerups(this);
 
    if (frametime && autocvar_sv_show_entnum) show_entnum(this);
 
    if (IS_DEAD(this))
    {
        if (this.personal && g_race_qualifying
        && (autocvar_g_allow_checkpoints || CheatsAllowed(this, CHIMPULSE_SPEEDRUN.impulse, 0, 0, false, true)))
        {
            if (time > this.respawn_time)
            {
                STAT(RESPAWN_TIME, this) = this.respawn_time = time + 1; // only retry once a second
                respawn(this);
                CS(this).impulse = CHIMPULSE_SPEEDRUN.impulse;
            }
        }
        else
        {
            if (frametime) player_anim(this);
 
            if (this.respawn_flags & RESPAWN_DENY)
            {
                STAT(RESPAWN_TIME, this) = 0;
                return false;
            }
 
            bool button_pressed = (PHYS_INPUT_BUTTON_ATCK(this) || PHYS_INPUT_BUTTON_JUMP(this) || PHYS_INPUT_BUTTON_ATCK2(this) || PHYS_INPUT_BUTTON_HOOK(this) || PHYS_INPUT_BUTTON_USE(this));
 
            switch(this.deadflag)
            {
                case DEAD_DYING:
                {
                    if ((this.respawn_flags & RESPAWN_FORCE) && !(this.respawn_time < this.respawn_time_max))
                        this.deadflag = DEAD_RESPAWNING;
                    else if (!button_pressed || (time >= this.respawn_time_max && (this.respawn_flags & RESPAWN_FORCE)))
                        this.deadflag = DEAD_DEAD;
                    break;
                }
                case DEAD_DEAD:
                {
                    if (button_pressed)
                        this.deadflag = DEAD_RESPAWNABLE;
                    else if (time >= this.respawn_time_max && (this.respawn_flags & RESPAWN_FORCE))
                        this.deadflag = DEAD_RESPAWNING;
                    break;
                }
                case DEAD_RESPAWNABLE:
                {
                    if (!button_pressed || (this.respawn_flags & RESPAWN_FORCE))
                        this.deadflag = DEAD_RESPAWNING;
                    break;
                }
                case DEAD_RESPAWNING:
                {
                    if (time > this.respawn_time)
                    {
                        this.respawn_time = time + 1; // only retry once a second
                        this.respawn_time_max = this.respawn_time;
                        respawn(this);
                    }
                    break;
                }
            }
 
            ShowRespawnCountdown(this);
 
            if (this.respawn_flags & RESPAWN_SILENT)
                STAT(RESPAWN_TIME, this) = 0;
            else if ((this.respawn_flags & RESPAWN_FORCE) && this.respawn_time < this.respawn_time_max)
            {
                if (time < this.respawn_time)
                    STAT(RESPAWN_TIME, this) = this.respawn_time;
                else if (this.deadflag != DEAD_RESPAWNING)
                    STAT(RESPAWN_TIME, this) = -this.respawn_time_max;
            }
            else
                STAT(RESPAWN_TIME, this) = this.respawn_time;
        }
 
        // if respawning, invert stat_respawn_time to indicate this, the client translates it
        if (this.deadflag == DEAD_RESPAWNING && STAT(RESPAWN_TIME, this) > 0)
            STAT(RESPAWN_TIME, this) *= -1;
 
        return false;
    }
 
    FixPlayermodel(this);
 
    if (this.shootfromfixedorigin != autocvar_g_shootfromfixedorigin)
    {
        strcpy(this.shootfromfixedorigin, autocvar_g_shootfromfixedorigin);
        stuffcmd(this, sprintf("\ncl_shootfromfixedorigin \"%s\"\n", autocvar_g_shootfromfixedorigin));
    }
 
    // reset gun alignment when dual wielding status changes
    // to ensure guns are always aligned right and left
    bool dualwielding = W_DualWielding(this);
    if(this.dualwielding_prev != dualwielding)
    {
        W_ResetGunAlign(this, CS_CVAR(this).cvar_cl_gunalign);
        this.dualwielding_prev = dualwielding;
    }
 
    // LordHavoc: allow firing on move frames (sub-ticrate), this gives better timing on slow servers
    //if(frametime)
    {
        for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
        {
            .entity weaponentity = weaponentities[slot];
            if(WEP_CVAR(WEP_VORTEX, charge_always))
                W_Vortex_Charge(this, weaponentity, frametime);
            W_WeaponFrame(this, weaponentity);
        }
    }
 
    if (frametime)
    {
        // WEAPONTODO: Add a weapon request for this
        // rot vortex charge to the charge limit
        for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
        {
            .entity weaponentity = weaponentities[slot];
            if (WEP_CVAR(WEP_VORTEX, charge_rot_rate) && this.(weaponentity).vortex_charge > WEP_CVAR(WEP_VORTEX, charge_limit) && this.(weaponentity).vortex_charge_rottime < time)
                this.(weaponentity).vortex_charge = bound(WEP_CVAR(WEP_VORTEX, charge_limit), this.(weaponentity).vortex_charge - WEP_CVAR(WEP_VORTEX, charge_rot_rate) * frametime / W_TICSPERFRAME, 1);
        }
 
        player_regen(this);
        player_anim(this);
        this.dmg_team = max(0, this.dmg_team - autocvar_g_teamdamage_resetspeed * frametime);
    }
 
    monsters_setstatus(this);
 
    return true;
}

References angles, autocvar_g_allow_checkpoints, autocvar_g_shootfromfixedorigin, autocvar_g_teamdamage_resetspeed, autocvar_sv_show_entnum, bound(), CheatsAllowed(), CS(), CS_CVAR, DEAD_DEAD, DEAD_DYING, DEAD_RESPAWNABLE, DEAD_RESPAWNING, deadflag, dmg_team, dualwielding_prev, entity(), fixangle, FixPlayermodel(), frametime, g_race_qualifying, game_stopped, intermission_running, IntermissionThink(), IS_DEAD, lastV_angle, max(), MAX_WEAPONSLOTS, MF_ROCKET, modelflags, monsters_setstatus(), personal, PHYS_INPUT_BUTTON_ATCK, PHYS_INPUT_BUTTON_ATCK2, PHYS_INPUT_BUTTON_HOOK, PHYS_INPUT_BUTTON_JUMP, PHYS_INPUT_BUTTON_USE, player_anim(), player_powerups(), player_regen(), respawn(), RESPAWN_DENY, respawn_flags, RESPAWN_FORCE, RESPAWN_SILENT, respawn_time, respawn_time_max, shootfromfixedorigin, show_entnum(), ShowRespawnCountdown(), STAT, strcpy, stuffcmd, time, TIMEOUT_ACTIVE, timeout_status, v_angle, vortex_charge, vortex_charge_rottime, W_DualWielding(), W_ResetGunAlign(), W_TICSPERFRAME, W_Vortex_Charge(), W_WeaponFrame(), weaponentities, and WEP_CVAR.

Referenced by PlayerPreThink().

◆ PlayerUseKey()

void PlayerUseKey ( entity this )

Definition at line 2612 of file client.qc.

{
    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) && !StatusEffects_active(STATUSEFFECT_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);
}

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

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

◆ PM_UpdateButtons()

void PM_UpdateButtons	(	entity	this,
		entity	store )

Definition at line 3087 of file client.qc.

{
    if(this.impulse)
        store.impulse = this.impulse;
    this.impulse = 0;
 
    bool typing = this.buttonchat || this.button12;
 
    store.button0 = (typing) ? 0 : this.button0;
    //button1?!
    store.button2 = (typing) ? 0 : this.button2;
    store.button3 = (typing) ? 0 : this.button3;
    store.button4 = this.button4;
    store.button5 = (typing) ? 0 : this.button5;
    store.button6 = this.button6;
    store.button7 = this.button7;
    store.button8 = this.button8;
    store.button9 = this.button9;
    store.button10 = this.button10;
    store.button11 = this.button11;
    store.button12 = this.button12;
    store.button13 = this.button13;
    store.button14 = this.button14;
    store.button15 = this.button15;
    store.button16 = this.button16;
    store.buttonuse = this.buttonuse;
    store.buttonchat = this.buttonchat;
 
    store.cursor_active = this.cursor_active;
    store.cursor_screen = this.cursor_screen;
    store.cursor_trace_start = this.cursor_trace_start;
    store.cursor_trace_endpos = this.cursor_trace_endpos;
    store.cursor_trace_ent = this.cursor_trace_ent;
 
    store.ping = this.ping;
    store.ping_packetloss = this.ping_packetloss;
    store.ping_movementloss = this.ping_movementloss;
 
    store.v_angle = this.v_angle;
    store.movement = this.movement;
}

References button0, button10, button11, button12, button13, button14, button15, button16, button2, button3, button4, button5, button6, button7, button8, button9, buttonchat, buttonuse, cursor_active, cursor_screen, cursor_trace_endpos, cursor_trace_ent, cursor_trace_start, entity(), impulse, movement, ping, ping_movementloss, ping_packetloss, and v_angle.

Referenced by SV_PlayerPhysics().

◆ PutClientInServer() [1/2]

void PutClientInServer ( entity this )

Called when a client spawns in the server.

Definition at line 865 of file client.qc.

{
    if (IS_REAL_CLIENT(this))
    {
        msg_entity = this;
        WriteByte(MSG_ONE, SVC_SETVIEW);
        WriteEntity(MSG_ONE, this);
    }
    if (game_stopped)
        TRANSMUTE(Observer, this);
 
    bool use_spawnpoint = (!this.enemy); // check this.enemy here since SetSpectatee will clear it
    SetSpectatee(this, NULL);
 
    // reset player keys
    if(PS(this))
        PS(this).itemkeys = 0;
 
    MUTATOR_CALLHOOK(PutClientInServer, this);
 
    if (IS_OBSERVER(this))
        PutObserverInServer(this, false, use_spawnpoint);
    else if (IS_PLAYER(this))
        PutPlayerInServer(this);
 
    bot_relinkplayerlist();
}

References bot_relinkplayerlist(), enemy, entity(), game_stopped, IS_OBSERVER, IS_PLAYER, IS_REAL_CLIENT, msg_entity, MSG_ONE, MUTATOR_CALLHOOK, NULL, PS, PutClientInServer, PutObserverInServer(), PutPlayerInServer(), SetSpectatee(), SVC_SETVIEW, TRANSMUTE, WriteByte(), and WriteEntity().

◆ PutClientInServer() [2/2]

PutClientInServer ( this )

Initial value:

{

TRANSMUTE(Observer, this)

◆ PutObserverInServer()

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

putting a client as observer in the server

Definition at line 261 of file client.qc.

{
    bool mutator_returnvalue = MUTATOR_CALLHOOK(MakePlayerObserver, this, is_forced);
    bool recount_ready = false;
    PlayerState_detach(this);
 
    bool was_player = false;
    if (IS_PLAYER(this))
    {
        if(GetResource(this, RES_HEALTH) >= 1)
        {
            // despawn effect
            Send_Effect(EFFECT_SPAWN, 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;
            if (warmup_stage || game_starttime > time) /* warmup OR countdown */ recount_ready = true;
        }
        entcs_update_players(this);
        was_player = true;
    }
 
    if (use_spawnpoint)
    {
        // first try to find a random "nice" location to view from
        entity spot = SelectObservePoint(this);
        bool is_observepoint = (spot != NULL);
        if(!spot) // otherwise just use the player spawn points
            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 + (is_observepoint ? '0 0 0' : autocvar_sv_player_viewoffset));
    }
    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);
    SetSpectatee(this, NULL);
 
    if (this.alivetime_start)
    {
        if (!warmup_stage)
            PlayerStats_GameReport_Event_Player(this, PLAYERSTATS_ALIVETIME, max(0, time - this.alivetime_start));
        this.alivetime_start = 0;
    }
 
    if (this.vehicle) vehicles_exit(this.vehicle, VHEF_RELEASE);
 
    TRANSMUTE(Observer, this);
 
    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 (!autocvar_sv_spectate && CS(this).autojoin_checked) // unnecessary if autojoin succeeds, on failure it notifies
        Send_Notification(NOTIF_ONE_ONLY, this, MSG_MULTI, SPECTATE_WARNING, autocvar_g_maxplayers_spectator_blocktime);
 
    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);
    this.draggable = drag_undraggable;
 
    player_powerups_remove_all(this, was_player);
    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); // clears scores too in gametypes without teams
        this.frags = FRAGS_SPECTATOR;
    }
 
    bot_relinkplayerlist();
 
    if (CS(this).just_joined)
        CS(this).just_joined = false;
 
    if (recount_ready)
        ReadyCount(); // must be called after SetPlayerTeam() and TRANSMUTE(Observer
}

References accuracy_resend(), alivetime_start, alpha, angles, autocvar_g_balance_armor_start, autocvar_g_debug_globalsounds, autocvar_g_maxplayers_spectator_blocktime, autocvar_g_playerclip_collisions, autocvar_sv_player_viewoffset, autocvar_sv_spectate, 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, entcs_update_players(), entity(), etof, exteriorweaponentity, fade_time, fixangle, FixPlayermodel(), FL_CLIENT, FL_NOTARGET, flags, frags, FRAGS_SPECTATOR, func_null(), g_bot_targets, g_damagedbycontents, g_monster_targets, game_starttime, game_stopped, GetResource(), HUD_NORMAL, IL_REMOVE(), IS_PLAYER, IS_REAL_CLIENT, iscreature, istypefrag, items, just_joined, killcount, LOG_FATAL, max(), 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(), PLAYERSTATS_ALIVETIME, PlayerStats_GameReport_Event_Player, Portal_ClearAll(), punchangle, punchvector, pushltime, ready, ReadyCount(), RemoveGrapplingHooks(), RES_ARMOR, respawn_flags, respawn_time, scale, SelectObservePoint(), SelectSpawnPoint(), Send_Effect(), Send_Notification(), set_movetype(), setmodel, SetPlayerTeam(), SetResourceExplicit(), SetSpectatee(), SetSpectatee_status(), setthink, solid, SOLID_NOT, STAT, SVC_SETVIEW, takedamage, TEAM_CHANGE_SPECTATOR, TELEPORT_SIMPLE, teleportable, time, TRANSMUTE, UNSET_DUCKED, vec2, vehicle, vehicles_exit(), velocity, VHEF_RELEASE, view_ofs, viewloc, vote_called, VoteCount(), warmup_stage, WaypointSprite_PlayerDead(), weaponentities, weaponmodel, WriteByte(), and WriteEntity().

Referenced by BanCommand_playban(), ClientKill_Now_TeamChange(), GameCommand_allspec(), GameCommand_moveplayer(), MatchEnd_RestoreSpectatorAndTeamStatus(), minigame_addplayer(), MUTATOR_HOOKFUNCTION(), ObserverOrSpectatorThink(), PutClientInServer(), Remove_Countdown(), SpectateSet(), and TeamBalance_RemoveExcessPlayers().

◆ PutPlayerInServer()

void PutPlayerInServer ( entity this )

Definition at line 580 of file client.qc.

{
    if (MUTATOR_CALLHOOK(ForbidSpawn, this))
        return;
 
    if (this.vehicle) vehicles_exit(this.vehicle, VHEF_RELEASE);
 
    PlayerState_attach(this);
    accuracy_resend(this);
 
    if (teamplay)
    {
        if (this.bot_forced_team)
            SetPlayerTeam(this, this.bot_forced_team, TEAM_CHANGE_MANUAL);
        else if (this.team <= 0)
        {
            if (this.wants_join > 0)
                SetPlayerTeam(this, this.wants_join, TEAM_CHANGE_MANUAL);
            else
                TeamBalance_JoinBestTeam(this);
        }
    }
 
    entity spot = SelectSpawnPoint(this, false);
    if (!spot)
    {
        Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_JOIN_NOSPAWNS);
        return; // spawn failed
    }
 
    TRANSMUTE(Player, this);
 
    this.iscreature = true;
    this.teleportable = TELEPORT_NORMAL;
    if(!this.damagedbycontents)
        IL_PUSH(g_damagedbycontents, this);
    this.damagedbycontents = true;
    set_movetype(this, MOVETYPE_WALK);
    this.solid = SOLID_SLIDEBOX;
    this.dphitcontentsmask = DPCONTENTS_BODY | DPCONTENTS_SOLID;
    if (autocvar_g_playerclip_collisions)
        this.dphitcontentsmask |= DPCONTENTS_PLAYERCLIP;
    if (IS_BOT_CLIENT(this) && autocvar_g_botclip_collisions)
        this.dphitcontentsmask |= DPCONTENTS_BOTCLIP;
    this.frags = FRAGS_PLAYER;
    if (INDEPENDENT_PLAYERS) MAKE_INDEPENDENT_PLAYER(this);
    this.flags = FL_CLIENT | FL_PICKUPITEMS;
    if (autocvar__notarget)
        this.flags |= FL_NOTARGET;
    this.takedamage = DAMAGE_AIM;
    this.effects = EF_TELEPORT_BIT | EF_RESTARTANIM_BIT;
 
    if (warmup_stage)
        GiveWarmupResources(this);
    else
    {
        SetResource(this, RES_SHELLS, start_ammo_shells);
        SetResource(this, RES_BULLETS, start_ammo_nails);
        SetResource(this, RES_ROCKETS, start_ammo_rockets);
        SetResource(this, RES_CELLS, start_ammo_cells);
        SetResource(this, RES_FUEL, start_ammo_fuel);
        SetResource(this, RES_HEALTH, start_health);
        SetResource(this, RES_ARMOR, start_armorvalue);
        STAT(WEAPONS, this) = start_weapons;
        if (MUTATOR_CALLHOOK(ForbidRandomStartWeapons, this) == false)
        {
            GiveRandomWeapons(this, random_start_weapons_count,
                autocvar_g_random_start_weapons, random_start_ammo);
        }
    }
    SetSpectatee_status(this, 0);
 
    PS(this).dual_weapons = '0 0 0';
 
    if(STAT(WEAPONS, this) & WEPSET_SUPERWEAPONS)
        StatusEffects_apply(STATUSEFFECT_Superweapon, this, time + autocvar_g_balance_superweapons_time, 0);
 
    this.items = start_items;
 
    float shieldtime = time + autocvar_g_spawnshieldtime;
 
    this.pauserotarmor_finished = time + autocvar_g_balance_pause_armor_rot_spawn;
    this.pauserothealth_finished = time + autocvar_g_balance_pause_health_rot_spawn;
    this.pauserotfuel_finished = time + autocvar_g_balance_pause_fuel_rot_spawn;
    this.pauseregen_finished = time + autocvar_g_balance_pause_health_regen_spawn;
    if (!sv_ready_restart_after_countdown && time < game_starttime)
    {
        float f = game_starttime - time;
        shieldtime += f;
        this.pauserotarmor_finished += f;
        this.pauserothealth_finished += f;
        this.pauseregen_finished += f;
    }
 
    StatusEffects_apply(STATUSEFFECT_SpawnShield, this, shieldtime, 0);
 
    this.damageforcescale = autocvar_g_player_damageforcescale;
    this.death_time = 0;
    this.respawn_flags = 0;
    this.respawn_time = 0;
    STAT(RESPAWN_TIME, this) = 0;
    this.scale = ((q3compat && autocvar_sv_q3compat_changehitbox) || !autocvar_sv_mapformat_is_quake3)
                 ? 0.8125 // DP model scaling uses 1/16 accuracy and 13/16 is closest to 56/69
                 : autocvar_sv_player_scale;
    this.fade_time = 0;
    this.pain_finished = 0;
    this.pushltime = 0;
    setthink(this, func_null); // players have no think function
    this.nextthink = 0;
    this.dmg_team = 0;
    this.spawn_time = time;
 
    PS(this).ballistics_density = autocvar_g_ballistics_density_player;
 
    this.deadflag = DEAD_NO;
 
    this.angles = spot.angles;
    this.angles_z = 0; // never spawn tilted even if the spot says to
    if (IS_BOT_CLIENT(this))
    {
        this.v_angle = this.angles;
        bot_aim_reset(this);
    }
    this.fixangle = true; // turn this way immediately
    this.oldvelocity = this.velocity = '0 0 0';
    this.avelocity = '0 0 0';
    this.punchangle = '0 0 0';
    this.punchvector = '0 0 0';
 
    STAT(AIR_FINISHED, this) = 0;
    this.waterlevel = WATERLEVEL_NONE;
    this.watertype = CONTENT_EMPTY;
 
    entity spawnevent = new_pure(spawnevent);
    spawnevent.owner = this;
    Net_LinkEntity(spawnevent, false, 0.5, SpawnEvent_Send);
 
    // Cut off any still running player sounds.
    stopsound(this, CH_PLAYER_SINGLE);
 
    this.model = "";
    FixPlayermodel(this);
    this.drawonlytoclient = NULL;
 
    this.viewloc = 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);
    }
 
    this.spawnpoint_targ = NULL;
 
    UNSET_DUCKED(this);
    this.view_ofs = STAT(PL_VIEW_OFS, this);
    setsize(this, STAT(PL_MIN, this), STAT(PL_MAX, this));
    this.spawnorigin = spot.origin;
    setorigin(this, spot.origin + '0 0 1' * (1 - this.mins.z - 24));
    // don't reset back to last position, even if new position is stuck in solid
    this.oldorigin = this.origin;
    if(this.conveyor)
        IL_REMOVE(g_conveyed, this);
    this.conveyor = NULL; // prevent conveyors at the previous location from moving a freshly spawned player
    if(this.swampslug)
        IL_REMOVE(g_swamped, this);
    this.swampslug = NULL;
    this.swamp_interval = 0;
    if(this.ladder_entity)
        IL_REMOVE(g_ladderents, this);
    this.ladder_entity = NULL;
    IL_EACH(g_counters, it.realowner == this,
    {
        delete(it);
    });
    STAT(HUD, this) = HUD_NORMAL;
 
    this.event_damage = PlayerDamage;
    this.event_heal = PlayerHeal;
 
    this.draggable = func_null;
 
    if(!this.bot_attack)
        IL_PUSH(g_bot_targets, this);
    this.bot_attack = true;
    if(!this.monster_attack)
        IL_PUSH(g_monster_targets, this);
    this.monster_attack = true;
    navigation_dynamicgoal_init(this, false);
 
    PHYS_INPUT_BUTTON_ATCK(this) = PHYS_INPUT_BUTTON_JUMP(this) = PHYS_INPUT_BUTTON_ATCK2(this) = false;
 
    // player was spectator
    if (CS(this).killcount == FRAGS_SPECTATOR)
    {
        PlayerScore_Clear(this);
        CS(this).killcount = 0;
        CS(this).startplaytime = time;
    }
 
    for (int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
    {
        .entity weaponentity = weaponentities[slot];
        CL_SpawnWeaponentity(this, weaponentity);
    }
    this.alpha = default_player_alpha;
    this.colormod = '1 1 1' * autocvar_g_player_brightness;
    this.exteriorweaponentity.alpha = default_weapon_alpha;
 
    this.speedrunning = false;
 
    this.counter_cnt = 0;
    this.fragsfilter_cnt = 0;
 
    target_voicescript_clear(this);
 
    // reset fields the weapons may use
    FOREACH(Weapons, true,
    {
        it.wr_resetplayer(it, this);
            // reload all reloadable weapons
        if (it.spawnflags & WEP_FLAG_RELOADABLE)
        {
            for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
            {
                .entity weaponentity = weaponentities[slot];
                this.(weaponentity).weapon_load[it.m_id] = it.reloading_ammo;
            }
        }
    });
 
    MUTATOR_CALLHOOK(PlayerSpawn, this, spot);
    {
        string s = spot.target;
        if(g_assault || g_race) // TODO: make targeting work in assault & race without this hack
            spot.target = string_null;
        SUB_UseTargets(spot, this, NULL);
        if(g_assault || g_race)
            spot.target = s;
    }
 
    if (autocvar_spawn_debug)
    {
        sprint(this, strcat("spawnpoint origin:  ", vtos(spot.origin), "\n"));
        delete(spot); // usefull for checking if there are spawnpoints, that let drop through the floor
    }
 
    for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
    {
        .entity weaponentity = weaponentities[slot];
        entity w_ent = this.(weaponentity);
        if(slot == 0 || autocvar_g_weaponswitch_debug == 1)
            w_ent.m_switchweapon = w_getbestweapon(this, weaponentity);
        else
            w_ent.m_switchweapon = WEP_Null;
        w_ent.m_weapon = WEP_Null;
        w_ent.weaponname = "";
        w_ent.m_switchingweapon = WEP_Null;
        w_ent.cnt = -1;
    }
 
    MUTATOR_CALLHOOK(PlayerWeaponSelect, this);
 
    if (CS(this).impulse) ImpulseCommands(this);
 
    W_ResetGunAlign(this, CS_CVAR(this).cvar_cl_gunalign);
    for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
    {
        .entity weaponentity = weaponentities[slot];
        W_WeaponFrame(this, weaponentity);
    }
 
    if (!warmup_stage && !this.alivetime_start)
        this.alivetime_start = max(time, game_starttime);
 
    antilag_clear(this, CS(this));
 
    if (warmup_stage)
        ReadyCount();
}

References accuracy_resend(), alivetime_start, alpha, angles, antilag_clear(), autocvar__notarget, autocvar_g_balance_pause_armor_rot_spawn, autocvar_g_balance_pause_fuel_rot_spawn, autocvar_g_balance_pause_health_regen_spawn, autocvar_g_balance_pause_health_rot_spawn, autocvar_g_balance_superweapons_time, autocvar_g_ballistics_density_player, autocvar_g_botclip_collisions, autocvar_g_player_brightness, autocvar_g_player_damageforcescale, autocvar_g_playerclip_collisions, autocvar_g_random_start_weapons, autocvar_g_spawnshieldtime, autocvar_g_weaponswitch_debug, autocvar_spawn_debug, autocvar_sv_mapformat_is_quake3, autocvar_sv_player_scale, autocvar_sv_q3compat_changehitbox, AuxiliaryXhair, avelocity, bot_aim_reset(), bot_attack, bot_forced_team, CH_PLAYER_SINGLE, CL_SpawnWeaponentity(), colormod, CONTENT_EMPTY, conveyor, counter_cnt, CS(), CS_CVAR, DAMAGE_AIM, damagedbycontents, damageforcescale, DEAD_NO, deadflag, death_time, default_player_alpha, default_weapon_alpha, dmg_team, DPCONTENTS_BODY, DPCONTENTS_BOTCLIP, DPCONTENTS_PLAYERCLIP, DPCONTENTS_SOLID, dphitcontentsmask, drawonlytoclient, EF_RESTARTANIM_BIT, EF_TELEPORT_BIT, effects, entity(), exteriorweaponentity, fade_time, fixangle, FixPlayermodel(), FL_CLIENT, FL_NOTARGET, FL_PICKUPITEMS, flags, FOREACH, frags, FRAGS_PLAYER, FRAGS_SPECTATOR, fragsfilter_cnt, func_null(), g_assault, g_bot_targets, g_conveyed, g_counters, g_damagedbycontents, g_ladderents, g_monster_targets, g_race, g_swamped, game_starttime, GiveRandomWeapons(), GiveWarmupResources(), HUD_NORMAL, IL_EACH, IL_PUSH(), IL_REMOVE(), impulse, ImpulseCommands(), INDEPENDENT_PLAYERS, IS_BOT_CLIENT, iscreature, items, killcount, ladder_entity, MAKE_INDEPENDENT_PLAYER, max(), MAX_AXH, MAX_WEAPONSLOTS, model, monster_attack, MOVETYPE_WALK, MUTATOR_CALLHOOK, navigation_dynamicgoal_init(), Net_LinkEntity(), new_pure, nextthink, NULL, oldorigin, oldvelocity, origin, pain_finished, pauseregen_finished, pauserotarmor_finished, pauserotfuel_finished, pauserothealth_finished, PHYS_INPUT_BUTTON_ATCK, PHYS_INPUT_BUTTON_ATCK2, PHYS_INPUT_BUTTON_JUMP, PlayerDamage(), PlayerHeal(), PlayerScore_Clear(), PlayerState_attach(), PS, punchangle, punchvector, pushltime, q3compat, random_start_ammo, random_start_weapons_count, ReadyCount(), RES_ARMOR, respawn_flags, respawn_time, scale, SelectSpawnPoint(), Send_Notification(), set_movetype(), SetPlayerTeam(), SetResource(), SetSpectatee_status(), setthink, solid, SOLID_SLIDEBOX, spawn_time, SpawnEvent_Send(), spawnorigin, spawnpoint_targ, speedrunning, sprint(), start_ammo_cells, start_ammo_fuel, start_ammo_nails, start_ammo_rockets, start_ammo_shells, start_armorvalue, start_health, start_items, start_weapons, STAT, StatusEffects_apply(), stopsound(), strcat(), string_null, SUB_UseTargets(), sv_ready_restart_after_countdown, swamp_interval, swampslug, takedamage, target_voicescript_clear(), team, TEAM_CHANGE_MANUAL, TeamBalance_JoinBestTeam(), teamplay, TELEPORT_NORMAL, teleportable, time, TRANSMUTE, UNSET_DUCKED, v_angle, vehicle, vehicles_exit(), velocity, VHEF_RELEASE, view_ofs, viewloc, vtos(), w_getbestweapon, W_ResetGunAlign(), W_WeaponFrame(), wants_join, warmup_stage, waterlevel, WATERLEVEL_NONE, watertype, weapon_load, weaponentities, Weapons, WEP_FLAG_RELOADABLE, and WEPSET_SUPERWEAPONS.

Referenced by PutClientInServer().

◆ queuePlayer()

bool queuePlayer	(	entity	this,
		int	team_index )

Definition at line 2209 of file client.qc.

{
    // check if a queued player already chose the selected team
    if (team_index > 0)
    {
        FOREACH_CLIENT(it != this && it.wants_join == team_index,
        {
            if (QueuedPlayersReady(this, false))
            {
                // Join() will handle the notification so it can mention the team `player` will actually get
                this.team = -1; // force autoselect in Join() (last player skips queue)
                this.team_selected = team_index; // tell it which team to check for to find the conflict
            }
            else // > 2 teams
            {
                Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, APP_TEAM_NUM(Team_IndexToTeam(team_index), CENTER_JOIN_PREVENT_QUEUE_TEAM_CONFLICT), it.netname);
                this.wants_join = -1; // force autoselect in Join()
                this.team_selected = -1; // prevents clobbering by CENTER_JOIN_PREVENT_QUEUE
            }
            return true;
        });
    }
 
    if (QueuedPlayersReady(this, false))
        return false;
 
    if (team_index <= 0) // team auto select deferred until Join()
    {
        if (team_index != this.wants_join || !this.wants_join) // prevents chatcon spam
            Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_JOIN_WANTS, this.netname);
        if (this.team_selected >= 0) // prevents CENTER_JOIN_PREVENT_QUEUE_TEAM_CONFLICT getting clobbered
            Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_JOIN_PREVENT_QUEUE);
        this.wants_join = -1;
        this.team_selected = 0;
    }
    else
    {
        int team_num = Team_IndexToTeam(team_index);
        if (team_index != this.wants_join) // prevents chatcon spam
            Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(team_num, INFO_JOIN_WANTS_TEAM), this.netname);
        Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, APP_TEAM_NUM(team_num, CENTER_JOIN_PREVENT_QUEUE_TEAM));
        this.wants_join = team_index; // Player queued to join
        this.team_selected = team_index;
    }
 
    return true;
}

References entity(), and FOREACH_CLIENT.

Referenced by joinAllowed().

◆ respawn()

void respawn ( entity this )

Definition at line 1502 of file client.qc.

{
    bool damagedbycontents_prev = this.damagedbycontents;
    if(this.alpha >= 0)
    {
        if(autocvar_g_respawn_ghosts)
        {
            this.solid = SOLID_NOT;
            this.takedamage = DAMAGE_NO;
            this.damagedbycontents = false;
            set_movetype(this, MOVETYPE_FLY);
            this.velocity = '0 0 1' * autocvar_g_respawn_ghosts_speed;
            this.avelocity = randomvec() * autocvar_g_respawn_ghosts_speed * 3 - randomvec() * autocvar_g_respawn_ghosts_speed * 3;
            this.effects |= CSQCMODEL_EF_RESPAWNGHOST;
            this.alpha = min(this.alpha, autocvar_g_respawn_ghosts_alpha);
            Send_Effect(EFFECT_RESPAWN_GHOST, this.origin, '0 0 0', 1);
            if(autocvar_g_respawn_ghosts_time > 0)
                SUB_SetFade(this, time + autocvar_g_respawn_ghosts_time, autocvar_g_respawn_ghosts_fadetime);
        }
        else
            SUB_SetFade (this, time, 1); // fade out the corpse immediately
    }
 
    CopyBody(this, 1);
    this.damagedbycontents = damagedbycontents_prev;
 
    this.effects |= EF_NODRAW; // prevent another CopyBody
    PutClientInServer(this);
}

References alpha, autocvar_g_respawn_ghosts, autocvar_g_respawn_ghosts_alpha, autocvar_g_respawn_ghosts_fadetime, autocvar_g_respawn_ghosts_speed, autocvar_g_respawn_ghosts_time, avelocity, CopyBody(), CSQCMODEL_EF_RESPAWNGHOST, DAMAGE_NO, damagedbycontents, EF_NODRAW, effects, entity(), min(), MOVETYPE_FLY, origin, PutClientInServer, randomvec(), Send_Effect(), set_movetype(), solid, SOLID_NOT, SUB_SetFade(), takedamage, time, and velocity.

Referenced by PlayerThink().

◆ RotRegen()

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

Definition at line 1657 of file client.qc.

{
    float old = GetResource(this, res);
    float current = old;
    if(current > rotstable)
    {
        if(rotframetime > 0)
        {
            current = CalcRot(current, rotstable, rotfactor, rotframetime);
            current = max(rotstable, current - rotlinear * rotframetime);
        }
    }
    else if(current < regenstable)
    {
        if(regenframetime > 0)
        {
            current = CalcRegen(current, regenstable, regenfactor, regenframetime);
            current = min(regenstable, current + regenlinear * regenframetime);
        }
    }
 
    float limit = GetResourceLimit(this, res) * limit_mod;
    if(current > limit)
        current = limit;
 
    if (current != old)
        SetResource(this, res, current);
}

References CalcRegen(), CalcRot(), entity(), GetResource(), GetResourceLimit(), max(), min(), and SetResource().

Referenced by player_regen().

◆ SelectObservePoint()

entity SelectObservePoint ( entity this )

Definition at line 250 of file client.qc.

{
    RandomSelection_Init();
    IL_EACH(g_observepoints, true,
    {
        RandomSelection_AddEnt(it, 1, 1);
    });
    return RandomSelection_chosen_ent;
}

References entity(), g_observepoints, IL_EACH, RandomSelection_AddEnt, RandomSelection_chosen_ent, and RandomSelection_Init().

Referenced by PutObserverInServer().

◆ SendWelcomeMessage()

void SendWelcomeMessage	(	entity	this,
		int	msg_type )

Definition at line 1077 of file client.qc.

{
    if (boolean(autocvar_g_campaign))
    {
        WriteByte(msg_type, 1);
        WriteByte(msg_type, Campaign_GetLevelNum());
        return;
    }
 
    int flags = 0;
    if (CS(this).version_mismatch)
        flags |= 2;
    if (CS(this).version < autocvar_gameversion)
        flags |= 4;
    MapInfo_Get_ByName(mi_shortname, 0, NULL);
    if (MapInfo_Map_author != "")
        flags |= 8;
    WriteByte(msg_type, flags);
 
    WriteString(msg_type, autocvar_hostname);
    WriteString(msg_type, autocvar_g_xonoticversion);
 
    WriteString(msg_type, MapInfo_Map_titlestring);
    if (flags & 8)
        WriteString(msg_type, MapInfo_Map_author);
    MapInfo_ClearTemps();
 
    WriteByte(msg_type, autocvar_g_warmup > 1 ? autocvar_g_warmup : map_minplayers);
    WriteByte(msg_type, GetPlayerLimit());
 
    MUTATOR_CALLHOOK(BuildMutatorsPrettyString, "");
    string modifications = M_ARGV(0, string);
 
    if (!g_weaponarena && cvar("g_balance_blaster_weaponstartoverride") == 0)
        modifications = strcat(modifications, ", No start weapons");
    if(cvar("sv_gravity") < stof(cvar_defstring("sv_gravity")))
        modifications = strcat(modifications, ", Low gravity");
    if(g_weapon_stay && !g_cts)
        modifications = strcat(modifications, ", Weapons stay");
    if(autocvar_g_jetpack)
        modifications = strcat(modifications, ", Jetpack");
    modifications = substring(modifications, 2, strlen(modifications) - 2);
 
    WriteString(msg_type, modifications);
 
    WriteString(msg_type, g_weaponarena_list);
 
    if(cache_lastmutatormsg != autocvar_g_mutatormsg)
    {
        strcpy(cache_lastmutatormsg, autocvar_g_mutatormsg);
        strcpy(cache_mutatormsg, cache_lastmutatormsg);
    }
 
    WriteString(msg_type, cache_mutatormsg);
 
    WriteString(msg_type, strreplace("\\n", "\n", autocvar_sv_motd));
}

References autocvar_g_campaign, autocvar_g_jetpack, autocvar_g_mutatormsg, autocvar_g_warmup, autocvar_g_xonoticversion, autocvar_gameversion, autocvar_hostname, autocvar_sv_motd, cache_lastmutatormsg, cache_mutatormsg, Campaign_GetLevelNum(), CS(), cvar(), cvar_defstring(), entity(), flags, g_cts, g_weapon_stay, g_weaponarena, g_weaponarena_list, GetPlayerLimit(), M_ARGV, map_minplayers, MapInfo_ClearTemps(), MapInfo_Get_ByName(), MapInfo_Map_author, MapInfo_Map_titlestring, mi_shortname, MUTATOR_CALLHOOK, NULL, stof(), strcat(), strcpy, strlen, substring(), WriteByte(), and WriteString().

Referenced by ScoreInfo_SendEntity().

◆ SetChangeParms()

void SetChangeParms ( entity this )

Definition at line 973 of file client.qc.

{
    // save parms for level change
    parm1 = CS(this).parm_idlesince - time;
 
    MUTATOR_CALLHOOK(SetChangeParms);
}

References CS(), entity(), MUTATOR_CALLHOOK, parm1, SetChangeParms, and time.

◆ SetNewParms()

void SetNewParms ( )

Definition at line 960 of file client.qc.

{
    // initialize parms for a new player
    parm1 = -(86400 * 366);
 
    MUTATOR_CALLHOOK(SetNewParms);
}

References MUTATOR_CALLHOOK, parm1, and SetNewParms.

◆ setplayermodel()

void setplayermodel	(	entity	e,
		string	modelname )

Definition at line 241 of file client.qc.

{
    precache_model(modelname);
    _setmodel(e, modelname);
    player_setupanimsformodel(e);
    if(!autocvar_g_debug_globalsounds)
        UpdatePlayerSounds(e);
}

References autocvar_g_debug_globalsounds, entity(), player_setupanimsformodel(), and UpdatePlayerSounds().

Referenced by FixPlayermodel().

◆ SetSpectatee()

void SetSpectatee	(	entity	this,
		entity	spectatee )

Definition at line 1939 of file client.qc.

{
    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_UPDATE;
        }
    }
    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_UPDATE;
        }
    }
 
    if (spectatee)
        SetSpectatee_status(this, etof(spectatee));
 
    // needed to update spectator list
    if(old_spectatee)
        ClientData_Touch(old_spectatee, true);
}

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

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

◆ SetSpectatee_status()

void SetSpectatee_status	(	entity	this,
		int	spectatee_num )

Definition at line 1904 of file client.qc.

{
    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, true);
 
        // init or clear race data
        if ((g_race || g_cts) && g_race_qualifying && IS_REAL_CLIENT(this))
        {
            msg_entity = this;
 
            if (this.enemy && this.enemy.race_laptime)
            {
                // init
                race_SendNextCheckpoint(this.enemy, 1);
            }
            else
            {
                // send reset to this spectator
                WriteHeader(MSG_ONE, TE_CSQC_RACE);
                WriteByte(MSG_ONE, RACE_NET_CHECKPOINT_CLEAR);
            }
        }
    }
}

References ClientData_Touch(), CS(), enemy, entity(), g_cts, g_race, g_race_qualifying, IS_REAL_CLIENT, msg_entity, MSG_ONE, RACE_NET_CHECKPOINT_CLEAR, race_SendNextCheckpoint(), spectatee_status, STAT, WriteByte(), and WriteHeader.

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

◆ SetZoomState()

void SetZoomState	(	entity	this,
		float	newzoom )

Definition at line 1757 of file client.qc.

{
    if(newzoom != CS(this).zoomstate)
    {
        CS(this).zoomstate = newzoom;
        ClientData_Touch(this, true);
    }
    zoomstate_set = true;
}

References ClientData_Touch(), CS(), entity(), zoomstate, and zoomstate_set.

Referenced by PlayerPreThink(), and SpectateCopy().

◆ show_entnum()

void show_entnum ( entity this )

Definition at line 2309 of file client.qc.

{
    // waypoint editor implements a similar feature for waypoints
    if (waypointeditor_enabled)
        return;
 
    if (wasfreed(this.wp_aimed))
        this.wp_aimed = NULL;
 
    WarpZone_crosshair_trace_plusvisibletriggers(this);
    entity ent = NULL;
    if (trace_ent)
    {
        ent = trace_ent;
        if (ent != this.wp_aimed)
        {
            string str = sprintf(
                "^7ent #%d\n^8 netname: ^3%s\n^8 classname: ^5%s\n^8 origin: ^2'%s'",
                etof(ent), ent.netname, ent.classname, vtos(ent.origin));
            debug_text_3d((ent.absmin + ent.absmax) * 0.5, str, 0, 7, '0 0 0');
        }
    }
    if (this.wp_aimed != ent)
        this.wp_aimed = ent;
}

References debug_text_3d, entity(), etof, NULL, trace_ent, vtos(), WarpZone_crosshair_trace_plusvisibletriggers(), waypointeditor_enabled, and wp_aimed.

Referenced by ObserverOrSpectatorThink(), and PlayerThink().

◆ ShowRespawnCountdown()

void ShowRespawnCountdown ( entity this )

Definition at line 2043 of file client.qc.

{
    float number;
    if(!IS_DEAD(this)) // just respawned?
        return;
    else
    {
        number = ceil(this.respawn_time - time);
        if(number <= 0)
            return;
        if(number <= this.respawn_countdown)
        {
            this.respawn_countdown = number - 1;
            if(ceil(this.respawn_time - (time + 0.5)) == number) // only say it if it is the same number even in 0.5s; to prevent overlapping sounds
                Send_Notification(NOTIF_ONE, this, MSG_ANNCE, Announcer_PickNumber(CNT_RESPAWN, number));
        }
    }
}

References Announcer_PickNumber(), ceil(), CNT_RESPAWN, entity(), IS_DEAD, number, respawn_countdown, respawn_time, Send_Notification(), and time.

Referenced by PlayerThink().

◆ ShowTeamSelection()

bool ShowTeamSelection ( entity this )

Definition at line 2062 of file client.qc.

{
    if (!teamplay || autocvar_g_campaign || autocvar_g_balance_teams || this.team_selected || Player_HasRealForcedTeam(this))
        return false;
    if (QueuedPlayersReady(this, true))
        return false;
    if (frametime) // once per frame is more than enough
        stuffcmd(this, "_scoreboard_team_selection 1\n");
    return true;
}

References autocvar_g_balance_teams, autocvar_g_campaign, entity(), frametime, Player_HasRealForcedTeam(), QueuedPlayersReady(), stuffcmd, team_selected, and teamplay.

Referenced by joinAllowed().

◆ Spectate()

bool Spectate	(	entity	this,
		entity	pl )

Definition at line 1977 of file client.qc.

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

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

Referenced by ClientCommand_spectate(), and superspec_Spectate().

◆ SpectateCopy()

void SpectateCopy	(	entity	this,
		entity	spectatee )

Definition at line 1799 of file client.qc.

{
    TC(Client, this); TC(Client, spectatee);
 
    MUTATOR_CALLHOOK(SpectateCopy, spectatee, this);
    PS(this) = PS(spectatee);
    this.armortype = spectatee.armortype;
    SetResourceExplicit(this, RES_ARMOR, GetResource(spectatee, RES_ARMOR));
    SetResourceExplicit(this, RES_CELLS, GetResource(spectatee, RES_CELLS));
    SetResourceExplicit(this, RES_SHELLS, GetResource(spectatee, RES_SHELLS));
    SetResourceExplicit(this, RES_BULLETS, GetResource(spectatee, RES_BULLETS));
    SetResourceExplicit(this, RES_ROCKETS, GetResource(spectatee, RES_ROCKETS));
    SetResourceExplicit(this, RES_FUEL, GetResource(spectatee, RES_FUEL));
    this.effects = spectatee.effects & EFMASK_CHEAP; // eat performance
    SetResourceExplicit(this, RES_HEALTH, GetResource(spectatee, RES_HEALTH));
    CS(this).impulse = 0;
    this.disableclientprediction = 1; // no need to run prediction on a spectator
    this.items = spectatee.items;
    STAT(LAST_PICKUP, this) = STAT(LAST_PICKUP, spectatee);
    STAT(HIT_TIME, this) = STAT(HIT_TIME, spectatee);
    STAT(AIR_FINISHED, this) = STAT(AIR_FINISHED, spectatee);
    STAT(PRESSED_KEYS, this) = STAT(PRESSED_KEYS, spectatee);
    STAT(WEAPONS, this) = STAT(WEAPONS, spectatee);
    this.punchangle = spectatee.punchangle;
    this.view_ofs = spectatee.view_ofs;
    this.velocity = spectatee.velocity;
    this.dmg_take = spectatee.dmg_take;
    this.dmg_save = spectatee.dmg_save;
    this.dmg_inflictor = spectatee.dmg_inflictor;
    this.v_angle = spectatee.v_angle;
    this.angles = spectatee.v_angle;
    this.viewloc = spectatee.viewloc;
    if(!PHYS_INPUT_BUTTON_USE(this) && STAT(CAMERA_SPECTATOR, this) != 2)
        this.fixangle = true;
    setorigin(this, spectatee.origin);
    setsize(this, spectatee.mins, spectatee.maxs);
    SetZoomState(this, CS(spectatee).zoomstate);
 
    anticheat_spectatecopy(this, spectatee);
    STAT(HUD, this) = STAT(HUD, spectatee);
    if(spectatee.vehicle)
    {
        this.angles = spectatee.v_angle;
 
        //this.fixangle = false;
        //this.velocity = spectatee.vehicle.velocity;
        this.vehicle_health = spectatee.vehicle_health;
        this.vehicle_shield = spectatee.vehicle_shield;
        this.vehicle_energy = spectatee.vehicle_energy;
        this.vehicle_ammo1 = spectatee.vehicle_ammo1;
        this.vehicle_ammo2 = spectatee.vehicle_ammo2;
        this.vehicle_reload1 = spectatee.vehicle_reload1;
        this.vehicle_reload2 = spectatee.vehicle_reload2;
 
        //msg_entity = this;
 
        // WriteByte (MSG_ONE, SVC_SETVIEWANGLES);
            //WriteAngle(MSG_ONE,  spectatee.v_angle.x);
        // WriteAngle(MSG_ONE,  spectatee.v_angle.y);
        // WriteAngle(MSG_ONE,  spectatee.v_angle.z);
 
        //WriteByte (MSG_ONE, SVC_SETVIEW);
        //    WriteEntity(MSG_ONE, this);
        //makevectors(spectatee.v_angle);
        //setorigin(this, spectatee.origin - v_forward * 400 + v_up * 300);*/
    }
}

References angles, anticheat_spectatecopy(), armortype, CS(), disableclientprediction, dmg_inflictor, dmg_save, dmg_take, effects, EFMASK_CHEAP, entity(), fixangle, GetResource(), items, MUTATOR_CALLHOOK, PHYS_INPUT_BUTTON_USE, PS, punchangle, RES_ARMOR, SetResourceExplicit(), SetZoomState(), SpectateCopy(), STAT, TC, v_angle, vehicle_ammo1, vehicle_ammo2, vehicle_energy, vehicle_health, vehicle_reload1, vehicle_reload2, vehicle_shield, velocity, view_ofs, viewloc, and zoomstate.

Referenced by MUTATOR_HOOKABLE(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), SpectateCopy(), and SpectateUpdate().

◆ SpectateNext()

bool SpectateNext ( entity this )

Definition at line 1987 of file client.qc.

{
    entity ent = find(this.enemy, classname, STR_PLAYER);
 
    if (MUTATOR_CALLHOOK(SpectateNext, this, ent))
        ent = M_ARGV(1, entity);
    else if (!ent)
        ent = find(ent, classname, STR_PLAYER);
 
    if(ent) SetSpectatee(this, ent);
 
    return SpectateSet(this);
}

References classname, enemy, entity(), find(), M_ARGV, MUTATOR_CALLHOOK, SetSpectatee(), SpectateNext(), SpectateSet(), and STR_PLAYER.

Referenced by MUTATOR_HOOKABLE(), MUTATOR_HOOKFUNCTION(), ObserverOrSpectatorThink(), and SpectateNext().

◆ SpectatePrev()

bool SpectatePrev ( entity this )

Definition at line 2001 of file client.qc.

{
    // NOTE: chain order is from the highest to the lower entnum (unlike find)
    entity ent = findchain(classname, STR_PLAYER);
    if (!ent) // no player
        return false;
 
    entity first = ent;
    // skip players until current spectated player
    if(this.enemy)
        while(ent && ent != this.enemy)
            ent = ent.chain;
 
    switch (MUTATOR_CALLHOOK(SpectatePrev, this, ent, first))
    {
        case MUT_SPECPREV_FOUND:
            ent = M_ARGV(1, entity);
            break;
        case MUT_SPECPREV_RETURN:
            return true;
        case MUT_SPECPREV_CONTINUE:
        default:
        {
            if(ent.chain)
                ent = ent.chain;
            else
                ent = first;
            break;
        }
    }
 
    SetSpectatee(this, ent);
    return SpectateSet(this);
}

References classname, enemy, entity(), M_ARGV, MUT_SPECPREV_CONTINUE, MUT_SPECPREV_FOUND, MUT_SPECPREV_RETURN, MUTATOR_CALLHOOK, SetSpectatee(), SpectatePrev(), SpectateSet(), and STR_PLAYER.

Referenced by MUTATOR_HOOKABLE(), MUTATOR_HOOKFUNCTION(), ObserverOrSpectatorThink(), and SpectatePrev().

◆ SpectateSet()

bool SpectateSet ( entity this )

Definition at line 1885 of file client.qc.

{
    if(!IS_PLAYER(this.enemy))
        return false;
 
    ClientData_Touch(this.enemy, true);
 
    msg_entity = this;
    WriteByte(MSG_ONE, SVC_SETVIEW);
    WriteEntity(MSG_ONE, this.enemy);
    set_movetype(this, MOVETYPE_NONE);
    accuracy_resend(this);
 
    if(!SpectateUpdate(this))
        PutObserverInServer(this, false, true);
 
    return true;
}

References accuracy_resend(), ClientData_Touch(), enemy, entity(), IS_PLAYER, MOVETYPE_NONE, msg_entity, MSG_ONE, PutObserverInServer(), set_movetype(), SpectateUpdate(), SVC_SETVIEW, WriteByte(), and WriteEntity().

Referenced by MUTATOR_HOOKABLE(), MUTATOR_HOOKFUNCTION(), Spectate(), SpectateNext(), and SpectatePrev().

◆ SpectateUpdate()

bool SpectateUpdate ( entity this )

Definition at line 1867 of file client.qc.

{
    if(!this.enemy)
        return false;
 
    if(!IS_PLAYER(this.enemy) || this == this.enemy)
    {
        SetSpectatee(this, NULL);
        return false;
    }
 
    SpectateCopy(this, this.enemy);
    if (IS_OBSERVER(this))
        TRANSMUTE(Spectator, this);
 
    return true;
}

References enemy, entity(), IS_OBSERVER, IS_PLAYER, NULL, SetSpectatee(), SpectateCopy(), and TRANSMUTE.

Referenced by ObserverOrSpectatorThink(), and SpectateSet().

◆ TRANSMUTE()

TRANSMUTE	(	Player	,
		this	)

◆ UpdateChatBubble()

void UpdateChatBubble ( entity this )

Definition at line 1377 of file client.qc.

{
    if (this.alpha < 0)
        return;
    // spawn a chatbubble entity if needed
    if (!this.chatbubbleentity)
    {
        this.chatbubbleentity = new(chatbubbleentity);
        this.chatbubbleentity.owner = this;
        this.chatbubbleentity.exteriormodeltoclient = this;
        setthink(this.chatbubbleentity, ChatBubbleThink);
        this.chatbubbleentity.nextthink = time;
        setmodel(this.chatbubbleentity, MDL_CHAT); // precision set below
        //setorigin(this.chatbubbleentity, this.origin + '0 0 15' + this.maxs_z * '0 0 1');
        setorigin(this.chatbubbleentity, '0 0 15' + this.maxs_z * '0 0 1');
        setattachment(this.chatbubbleentity, this, "");  // sticks to moving player better, also conserves bandwidth
        this.chatbubbleentity.mdl = this.chatbubbleentity.model;
        //this.chatbubbleentity.model = "";
        this.chatbubbleentity.effects = EF_LOWPRECISION;
    }
}

References alpha, chatbubbleentity, ChatBubbleThink(), EF_LOWPRECISION, entity(), setmodel, setthink, and time.

Referenced by PlayerPostThink().

◆ WriteSpectators()

void WriteSpectators	(	entity	player,
		entity	to )

Definition at line 114 of file client.qc.

{
    if(!player) return; // not sure how, but best to be safe
 
    int spec_count = 0;
    FOREACH_CLIENT(IS_REAL_CLIENT(it) && IS_SPEC(it) && it != to && it.enemy == player,
    {
        if(spec_count >= MAX_SPECTATORS)
            break;
        WriteByte(MSG_ENTITY, num_for_edict(it));
        ++spec_count;
    });
}

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

Referenced by ClientData_Send().

Variable Documentation

◆ autocvar_g_maxping

float autocvar_g_maxping

Definition at line 2257 of file client.qc.

Referenced by joinAllowed().

◆ chatbubbleentity

entity chatbubbleentity

Definition at line 1268 of file client.qc.

Referenced by ClientDisconnect(), and UpdateChatBubble().

◆ dualwielding_prev

bool dualwielding_prev

Definition at line 2335 of file client.qc.

Referenced by PlayerThink().

◆ FallbackPlayerModel

string FallbackPlayerModel

Definition at line 207 of file client.qc.

Referenced by CheckPlayerModel().

◆ frame

this frame = 12

Definition at line 88 of file client.qc.

◆ last_vehiclecheck

float last_vehiclecheck

Definition at line 2674 of file client.qc.

Referenced by PlayerFrame().

◆ model_randomizer

float model_randomizer

Definition at line 453 of file client.qc.

Referenced by FixPlayermodel().

◆ move_qcphysics

bool move_qcphysics

Definition at line 2788 of file client.qc.

◆ shootfromfixedorigin

string shootfromfixedorigin

Definition at line 1267 of file client.qc.

Referenced by ClientDisconnect(), and PlayerThink().

◆ team

this team = _team

Definition at line 89 of file client.qc.

◆ would_spectate

bool would_spectate

Definition at line 2491 of file client.qc.

Referenced by ObserverOrSpectatorThink().

◆ zoomstate_set

bool zoomstate_set

Definition at line 1756 of file client.qc.

Referenced by PlayerPreThink(), and SetZoomState().

Functions

Variables

Function Documentation

◆ CalcRegen()

◆ CalcRot()

◆ calculate_player_respawn_time()

◆ ChatBubbleThink()

◆ CheckPlayerModel()

◆ ClientConnect()

Do not send temp entity headers directly here, they may arrive before CSQC is ready.

◆ ClientData_Attach()

◆ ClientData_Detach()

◆ ClientData_Send()

◆ ClientData_Touch()

◆ ClientDisconnect() [1/2]

◆ ClientDisconnect() [2/2]

◆ ClientInit_CheckUpdate()

◆ ClientInit_misc()

◆ ClientInit_SendEntity()

◆ ClientInit_Spawn()

◆ CountSpectators()

◆ DecodeLevelParms()

◆ DrownPlayer()

◆ findinlist_abbrev()

◆ FixClientCvars()

◆ FixPlayermodel()

◆ GetPlayerLimit()

◆ GetPressedKeys()

◆ GiveWarmupResources()

◆ Join()

◆ joinAllowed()

◆ NET_HANDLE()

◆ nJoinAllowed()

◆ ObserverOrSpectatorThink()

◆ play_countdown()

◆ player_getspecies()

◆ Player_Physics()

◆ player_powerups()

◆ player_powerups_remove_all()

◆ player_regen()

◆ PlayerFrame()

◆ PlayerInIDList()

◆ PlayerInIPList()

◆ PlayerInList()

◆ PlayerPostThink()

◆ PlayerPreThink()

◆ PlayerThink()

◆ PlayerUseKey()

◆ PM_UpdateButtons()

◆ PutClientInServer() [1/2]

◆ PutClientInServer() [2/2]

◆ PutObserverInServer()

◆ PutPlayerInServer()

◆ queuePlayer()

◆ respawn()

◆ RotRegen()

◆ SelectObservePoint()

◆ SendWelcomeMessage()

◆ SetChangeParms()

◆ SetNewParms()

◆ setplayermodel()

◆ SetSpectatee()

◆ SetSpectatee_status()

◆ SetZoomState()

◆ show_entnum()

◆ ShowRespawnCountdown()

◆ ShowTeamSelection()

◆ Spectate()

◆ SpectateCopy()

◆ SpectateNext()

◆ SpectatePrev()

◆ SpectateSet()

◆ SpectateUpdate()

◆ TRANSMUTE()

◆ UpdateChatBubble()

◆ WriteSpectators()

Variable Documentation

◆ autocvar_g_maxping

◆ chatbubbleentity

◆ dualwielding_prev