p_client.c File Reference

#include "g_local.h"
#include "m_player.h"

Go to the source code of this file.

Functions
void	ClientUserinfoChanged (edict_t *ent, char *userinfo)
void	SP_misc_teleporter_dest (edict_t *ent)
static void	SP_FixCoopSpots (edict_t *self)
static void	SP_CreateCoopSpots (edict_t *self)
void	SP_info_player_start (edict_t *self)
void	SP_info_player_deathmatch (edict_t *self)
void	SP_info_player_coop (edict_t *self)
void	SP_info_player_intermission (void)
void	player_pain (edict_t *self, edict_t *other, float kick, int damage)
qboolean	IsFemale (edict_t *ent)
qboolean	IsNeutral (edict_t *ent)
void	ClientObituary (edict_t *self, edict_t *inflictor, edict_t *attacker)
void	Touch_Item (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
void	TossClientWeapon (edict_t *self)
void	LookAtKiller (edict_t *self, edict_t *inflictor, edict_t *attacker)
void	player_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
void	InitClientPersistant (gclient_t *client)
void	InitClientResp (gclient_t *client)
void	SaveClientData (void)
void	FetchClientEntData (edict_t *ent)
float	PlayersRangeFromSpot (edict_t *spot)
edict_t *	SelectRandomDeathmatchSpawnPoint (void)
edict_t *	SelectFarthestDeathmatchSpawnPoint (void)
edict_t *	SelectDeathmatchSpawnPoint (void)
edict_t *	SelectCoopSpawnPoint (edict_t *ent)
void	SelectSpawnPoint (edict_t *ent, vec3_t origin, vec3_t angles)
void	InitBodyQue (void)
void	body_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
void	CopyToBodyQue (edict_t *ent)
void	respawn (edict_t *self)
void	spectator_respawn (edict_t *ent)
void	PutClientInServer (edict_t *ent)
void	ClientBeginDeathmatch (edict_t *ent)
void	ClientBegin (edict_t *ent)
qboolean	ClientConnect (edict_t *ent, char *userinfo)
void	ClientDisconnect (edict_t *ent)
trace_t	PM_trace (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end)
unsigned	CheckBlock (void *b, int c)
void	PrintPmove (pmove_t *pm)
void	ClientThink (edict_t *ent, usercmd_t *ucmd)
void	ClientBeginServerFrame (edict_t *ent)

Variables
edict_t *	pm_passent

Function Documentation

body_die()

void body_die	(	edict_t *	self,
		edict_t *	inflictor,
		edict_t *	attacker,
		int	damage,
		vec3_t	point
	)

Definition at line 931 of file p_client.c.

{
    int n;
 
    if (self->health < -40)
    {
        gi.sound (self, CHAN_BODY, gi.soundindex ("misc/udeath.wav"), 1, ATTN_NORM, 0);
        for (n= 0; n < 4; n++)
            ThrowGib (self, "models/objects/gibs/sm_meat/tris.md2", damage, GIB_ORGANIC);
        self->s.origin[2] -= 48;
        ThrowClientHead (self, damage);
        self->takedamage = DAMAGE_NO;
    }
}

Referenced by CopyToBodyQue().

CheckBlock()

unsigned CheckBlock	(	void *	b,
		int	c
	)

Definition at line 1555 of file p_client.c.

{
    int v,i;
    v = 0;
    for (i=0 ; i<c ; i++)
        v+= ((byte *)b)[i];
    return v;
}

Referenced by PrintPmove().

ClientBegin()

void ClientBegin

(

edict_t *

ent

)

Definition at line 1305 of file p_client.c.

{
    int     i;
 
    ent->client = game.clients + (ent - g_edicts - 1);
 
    if (deathmatch->value)
    {
        ClientBeginDeathmatch (ent);
        return;
    }
 
    // if there is already a body waiting for us (a loadgame), just
    // take it, otherwise spawn one from scratch
    if (ent->inuse == true)
    {
        // the client has cleared the client side viewangles upon
        // connecting to the server, which is different than the
        // state when the game is saved, so we need to compensate
        // with deltaangles
        for (i=0 ; i<3 ; i++)
            ent->client->ps.pmove.delta_angles[i] = ANGLE2SHORT(ent->client->ps.viewangles[i]);
    }
    else
    {
        // a spawn point will completely reinitialize the entity
        // except for the persistant data that was initialized at
        // ClientConnect() time
        G_InitEdict (ent);
        ent->classname = "player";
        InitClientResp (ent->client);
        PutClientInServer (ent);
    }
 
    if (level.intermissiontime)
    {
        MoveClientToIntermission (ent);
    }
    else
    {
        // send effect if in a multiplayer game
        if (game.maxclients > 1)
        {
            gi.WriteByte (svc_muzzleflash);
            gi.WriteShort (ent-g_edicts);
            gi.WriteByte (MZ_LOGIN);
            gi.multicast (ent->s.origin, MULTICAST_PVS);
 
            gi.bprintf (PRINT_HIGH, "%s entered the game\n", ent->client->pers.netname);
        }
    }
 
    // make sure all view stuff is valid
    ClientEndServerFrame (ent);
}

Referenced by GetGameAPI().

ClientBeginDeathmatch()

void ClientBeginDeathmatch

(

edict_t *

ent

)

Definition at line 1268 of file p_client.c.

{
    G_InitEdict (ent);
 
    InitClientResp (ent->client);
 
    // locate ent at a spawn point
    PutClientInServer (ent);
 
    if (level.intermissiontime)
    {
        MoveClientToIntermission (ent);
    }
    else
    {
        // send effect
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_LOGIN);
        gi.multicast (ent->s.origin, MULTICAST_PVS);
    }
 
    gi.bprintf (PRINT_HIGH, "%s entered the game\n", ent->client->pers.netname);
 
    // make sure all view stuff is valid
    ClientEndServerFrame (ent);
}

Referenced by ClientBegin().

ClientBeginServerFrame()

void ClientBeginServerFrame

(

edict_t *

ent

)

Definition at line 1765 of file p_client.c.

{
    gclient_t   *client;
    int         buttonMask;
 
    if (level.intermissiontime)
        return;
 
    client = ent->client;
 
    if (deathmatch->value &&
        client->pers.spectator != client->resp.spectator &&
        (level.time - client->respawn_time) >= 5) {
        spectator_respawn(ent);
        return;
    }
 
    // run weapon animations if it hasn't been done by a ucmd_t
    if (!client->weapon_thunk && !client->resp.spectator)
        Think_Weapon (ent);
    else
        client->weapon_thunk = false;
 
    if (ent->deadflag)
    {
        // wait for any button just going down
        if ( level.time > client->respawn_time)
        {
            // in deathmatch, only wait for attack button
            if (deathmatch->value)
                buttonMask = BUTTON_ATTACK;
            else
                buttonMask = -1;
 
            if ( ( client->latched_buttons & buttonMask ) ||
                (deathmatch->value && ((int)dmflags->value & DF_FORCE_RESPAWN) ) )
            {
                respawn(ent);
                client->latched_buttons = 0;
            }
        }
        return;
    }
 
    // add player trail so monsters can follow
    if (!deathmatch->value)
        if (!visible (ent, PlayerTrail_LastSpot() ) )
            PlayerTrail_Add (ent->s.old_origin);
 
    client->latched_buttons = 0;
}

Referenced by G_RunFrame().

ClientConnect()

qboolean ClientConnect	(	edict_t *	ent,
		char *	userinfo
	)

Definition at line 1440 of file p_client.c.

{
    char    *value;
 
    // check to see if they are on the banned IP list
    value = Info_ValueForKey (userinfo, "ip");
    if (SV_FilterPacket(value)) {
        Info_SetValueForKey(userinfo, "rejmsg", "Banned.");
        return false;
    }
 
    // check for a spectator
    value = Info_ValueForKey (userinfo, "spectator");
    if (deathmatch->value && *value && strcmp(value, "0")) {
        int i, numspec;
 
        if (*spectator_password->string && 
            strcmp(spectator_password->string, "none") && 
            strcmp(spectator_password->string, value)) {
            Info_SetValueForKey(userinfo, "rejmsg", "Spectator password required or incorrect.");
            return false;
        }
 
        // count spectators
        for (i = numspec = 0; i < maxclients->value; i++)
            if (g_edicts[i+1].inuse && g_edicts[i+1].client->pers.spectator)
                numspec++;
 
        if (numspec >= maxspectators->value) {
            Info_SetValueForKey(userinfo, "rejmsg", "Server spectator limit is full.");
            return false;
        }
    } else {
        // check for a password
        value = Info_ValueForKey (userinfo, "password");
        if (*password->string && strcmp(password->string, "none") && 
            strcmp(password->string, value)) {
            Info_SetValueForKey(userinfo, "rejmsg", "Password required or incorrect.");
            return false;
        }
    }
 
 
    // they can connect
    ent->client = game.clients + (ent - g_edicts - 1);
 
    // if there is already a body waiting for us (a loadgame), just
    // take it, otherwise spawn one from scratch
    if (ent->inuse == false)
    {
        // clear the respawning variables
        InitClientResp (ent->client);
        if (!game.autosaved || !ent->client->pers.weapon)
            InitClientPersistant (ent->client);
    }
 
    ClientUserinfoChanged (ent, userinfo);
 
    if (game.maxclients > 1)
        gi.dprintf ("%s connected\n", ent->client->pers.netname);
 
    ent->svflags = 0; // make sure we start with known default
    ent->client->pers.connected = true;
    return true;
}

Referenced by GetGameAPI().

ClientDisconnect()

void ClientDisconnect

(

edict_t *

ent

)

Definition at line 1514 of file p_client.c.

{
    int     playernum;
 
    if (!ent->client)
        return;
 
    gi.bprintf (PRINT_HIGH, "%s disconnected\n", ent->client->pers.netname);
 
    // send effect
    gi.WriteByte (svc_muzzleflash);
    gi.WriteShort (ent-g_edicts);
    gi.WriteByte (MZ_LOGOUT);
    gi.multicast (ent->s.origin, MULTICAST_PVS);
 
    gi.unlinkentity (ent);
    ent->s.modelindex = 0;
    ent->solid = SOLID_NOT;
    ent->inuse = false;
    ent->classname = "disconnected";
    ent->client->pers.connected = false;
 
    playernum = ent-g_edicts-1;
    gi.configstring (CS_PLAYERSKINS+playernum, "");
}

Referenced by GetGameAPI().

ClientObituary()

void ClientObituary	(	edict_t *	self,
		edict_t *	inflictor,
		edict_t *	attacker
	)

Definition at line 211 of file p_client.c.

{
    int         mod;
    char        *message;
    char        *message2;
    qboolean    ff;
 
    if (coop->value && attacker->client)
        meansOfDeath |= MOD_FRIENDLY_FIRE;
 
    if (deathmatch->value || coop->value)
    {
        ff = meansOfDeath & MOD_FRIENDLY_FIRE;
        mod = meansOfDeath & ~MOD_FRIENDLY_FIRE;
        message = NULL;
        message2 = "";
 
        switch (mod)
        {
        case MOD_SUICIDE:
            message = "suicides";
            break;
        case MOD_FALLING:
            message = "cratered";
            break;
        case MOD_CRUSH:
            message = "was squished";
            break;
        case MOD_WATER:
            message = "sank like a rock";
            break;
        case MOD_SLIME:
            message = "melted";
            break;
        case MOD_LAVA:
            message = "does a back flip into the lava";
            break;
        case MOD_EXPLOSIVE:
        case MOD_BARREL:
            message = "blew up";
            break;
        case MOD_EXIT:
            message = "found a way out";
            break;
        case MOD_TARGET_LASER:
            message = "saw the light";
            break;
        case MOD_TARGET_BLASTER:
            message = "got blasted";
            break;
        case MOD_BOMB:
        case MOD_SPLASH:
        case MOD_TRIGGER_HURT:
            message = "was in the wrong place";
            break;
        }
        if (attacker == self)
        {
            switch (mod)
            {
            case MOD_HELD_GRENADE:
                message = "tried to put the pin back in";
                break;
            case MOD_HG_SPLASH:
            case MOD_G_SPLASH:
                if (IsNeutral(self))
                    message = "tripped on its own grenade";
                else if (IsFemale(self))
                    message = "tripped on her own grenade";
                else
                    message = "tripped on his own grenade";
                break;
            case MOD_R_SPLASH:
                if (IsNeutral(self))
                    message = "blew itself up";
                else if (IsFemale(self))
                    message = "blew herself up";
                else
                    message = "blew himself up";
                break;
            case MOD_BFG_BLAST:
                message = "should have used a smaller gun";
                break;
            default:
                if (IsNeutral(self))
                    message = "killed itself";
                else if (IsFemale(self))
                    message = "killed herself";
                else
                    message = "killed himself";
                break;
            }
        }
        if (message)
        {
            gi.bprintf (PRINT_MEDIUM, "%s %s.\n", self->client->pers.netname, message);
            if (deathmatch->value)
                self->client->resp.score--;
            self->enemy = NULL;
            return;
        }
 
        self->enemy = attacker;
        if (attacker && attacker->client)
        {
            switch (mod)
            {
            case MOD_BLASTER:
                message = "was blasted by";
                break;
            case MOD_SHOTGUN:
                message = "was gunned down by";
                break;
            case MOD_SSHOTGUN:
                message = "was blown away by";
                message2 = "'s super shotgun";
                break;
            case MOD_MACHINEGUN:
                message = "was machinegunned by";
                break;
            case MOD_CHAINGUN:
                message = "was cut in half by";
                message2 = "'s chaingun";
                break;
            case MOD_GRENADE:
                message = "was popped by";
                message2 = "'s grenade";
                break;
            case MOD_G_SPLASH:
                message = "was shredded by";
                message2 = "'s shrapnel";
                break;
            case MOD_ROCKET:
                message = "ate";
                message2 = "'s rocket";
                break;
            case MOD_R_SPLASH:
                message = "almost dodged";
                message2 = "'s rocket";
                break;
            case MOD_HYPERBLASTER:
                message = "was melted by";
                message2 = "'s hyperblaster";
                break;
            case MOD_RAILGUN:
                message = "was railed by";
                break;
            case MOD_BFG_LASER:
                message = "saw the pretty lights from";
                message2 = "'s BFG";
                break;
            case MOD_BFG_BLAST:
                message = "was disintegrated by";
                message2 = "'s BFG blast";
                break;
            case MOD_BFG_EFFECT:
                message = "couldn't hide from";
                message2 = "'s BFG";
                break;
            case MOD_HANDGRENADE:
                message = "caught";
                message2 = "'s handgrenade";
                break;
            case MOD_HG_SPLASH:
                message = "didn't see";
                message2 = "'s handgrenade";
                break;
            case MOD_HELD_GRENADE:
                message = "feels";
                message2 = "'s pain";
                break;
            case MOD_TELEFRAG:
                message = "tried to invade";
                message2 = "'s personal space";
                break;
            }
            if (message)
            {
                gi.bprintf (PRINT_MEDIUM,"%s %s %s%s\n", self->client->pers.netname, message, attacker->client->pers.netname, message2);
                if (deathmatch->value)
                {
                    if (ff)
                        attacker->client->resp.score--;
                    else
                        attacker->client->resp.score++;
                }
                return;
            }
        }
    }
 
    gi.bprintf (PRINT_MEDIUM,"%s died.\n", self->client->pers.netname);
    if (deathmatch->value)
        self->client->resp.score--;
}

Referenced by player_die().

ClientThink()

void ClientThink	(	edict_t *	ent,
		usercmd_t *	ucmd
	)

Definition at line 1580 of file p_client.c.

{
    gclient_t   *client;
    edict_t *other;
    int     i, j;
    pmove_t pm;
 
    level.current_entity = ent;
    client = ent->client;
 
    if (level.intermissiontime)
    {
        client->ps.pmove.pm_type = PM_FREEZE;
        // can exit intermission after five seconds
        if (level.time > level.intermissiontime + 5.0 
            && (ucmd->buttons & BUTTON_ANY) )
            level.exitintermission = true;
        return;
    }
 
    pm_passent = ent;
 
    if (ent->client->chase_target) {
 
        client->resp.cmd_angles[0] = SHORT2ANGLE(ucmd->angles[0]);
        client->resp.cmd_angles[1] = SHORT2ANGLE(ucmd->angles[1]);
        client->resp.cmd_angles[2] = SHORT2ANGLE(ucmd->angles[2]);
 
    } else {
 
        // set up for pmove
        memset (&pm, 0, sizeof(pm));
 
        if (ent->movetype == MOVETYPE_NOCLIP)
            client->ps.pmove.pm_type = PM_SPECTATOR;
        else if (ent->s.modelindex != 255)
            client->ps.pmove.pm_type = PM_GIB;
        else if (ent->deadflag)
            client->ps.pmove.pm_type = PM_DEAD;
        else
            client->ps.pmove.pm_type = PM_NORMAL;
 
        client->ps.pmove.gravity = sv_gravity->value;
        pm.s = client->ps.pmove;
 
        for (i=0 ; i<3 ; i++)
        {
            pm.s.origin[i] = ent->s.origin[i]*8;
            pm.s.velocity[i] = ent->velocity[i]*8;
        }
 
        if (memcmp(&client->old_pmove, &pm.s, sizeof(pm.s)))
        {
            pm.snapinitial = true;
    //      gi.dprintf ("pmove changed!\n");
        }
 
        pm.cmd = *ucmd;
 
        pm.trace = PM_trace;    // adds default parms
        pm.pointcontents = gi.pointcontents;
 
        // perform a pmove
        gi.Pmove (&pm);
 
        // save results of pmove
        client->ps.pmove = pm.s;
        client->old_pmove = pm.s;
 
        for (i=0 ; i<3 ; i++)
        {
            ent->s.origin[i] = pm.s.origin[i]*0.125;
            ent->velocity[i] = pm.s.velocity[i]*0.125;
        }
 
        VectorCopy (pm.mins, ent->mins);
        VectorCopy (pm.maxs, ent->maxs);
 
        client->resp.cmd_angles[0] = SHORT2ANGLE(ucmd->angles[0]);
        client->resp.cmd_angles[1] = SHORT2ANGLE(ucmd->angles[1]);
        client->resp.cmd_angles[2] = SHORT2ANGLE(ucmd->angles[2]);
 
        if (ent->groundentity && !pm.groundentity && (pm.cmd.upmove >= 10) && (pm.waterlevel == 0))
        {
            gi.sound(ent, CHAN_VOICE, gi.soundindex("*jump1.wav"), 1, ATTN_NORM, 0);
            PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
        }
 
        ent->viewheight = pm.viewheight;
        ent->waterlevel = pm.waterlevel;
        ent->watertype = pm.watertype;
        ent->groundentity = pm.groundentity;
        if (pm.groundentity)
            ent->groundentity_linkcount = pm.groundentity->linkcount;
 
        if (ent->deadflag)
        {
            client->ps.viewangles[ROLL] = 40;
            client->ps.viewangles[PITCH] = -15;
            client->ps.viewangles[YAW] = client->killer_yaw;
        }
        else
        {
            VectorCopy (pm.viewangles, client->v_angle);
            VectorCopy (pm.viewangles, client->ps.viewangles);
        }
 
        gi.linkentity (ent);
 
        if (ent->movetype != MOVETYPE_NOCLIP)
            G_TouchTriggers (ent);
 
        // touch other objects
        for (i=0 ; i<pm.numtouch ; i++)
        {
            other = pm.touchents[i];
            for (j=0 ; j<i ; j++)
                if (pm.touchents[j] == other)
                    break;
            if (j != i)
                continue;   // duplicated
            if (!other->touch)
                continue;
            other->touch (other, ent, NULL, NULL);
        }
 
    }
 
    client->oldbuttons = client->buttons;
    client->buttons = ucmd->buttons;
    client->latched_buttons |= client->buttons & ~client->oldbuttons;
 
    // save light level the player is standing on for
    // monster sighting AI
    ent->light_level = ucmd->lightlevel;
 
    // fire weapon from final position if needed
    if (client->latched_buttons & BUTTON_ATTACK)
    {
        if (client->resp.spectator) {
 
            client->latched_buttons = 0;
 
            if (client->chase_target) {
                client->chase_target = NULL;
                client->ps.pmove.pm_flags &= ~PMF_NO_PREDICTION;
            } else
                GetChaseTarget(ent);
 
        } else if (!client->weapon_thunk) {
            client->weapon_thunk = true;
            Think_Weapon (ent);
        }
    }
 
    if (client->resp.spectator) {
        if (ucmd->upmove >= 10) {
            if (!(client->ps.pmove.pm_flags & PMF_JUMP_HELD)) {
                client->ps.pmove.pm_flags |= PMF_JUMP_HELD;
                if (client->chase_target)
                    ChaseNext(ent);
                else
                    GetChaseTarget(ent);
            }
        } else
            client->ps.pmove.pm_flags &= ~PMF_JUMP_HELD;
    }
 
    // update chase cam if being followed
    for (i = 1; i <= maxclients->value; i++) {
        other = g_edicts + i;
        if (other->inuse && other->client->chase_target == ent)
            UpdateChaseCam(other);
    }
}

Referenced by GetGameAPI().

ClientUserinfoChanged()

void ClientUserinfoChanged	(	edict_t *	ent,
		char *	userinfo
	)

Definition at line 1371 of file p_client.c.

{
    char    *s;
    int     playernum;
 
    // check for malformed or illegal info strings
    if (!Info_Validate(userinfo))
    {
        strcpy (userinfo, "\\name\\badinfo\\skin\\male/grunt");
    }
 
    // set name
    s = Info_ValueForKey (userinfo, "name");
    strncpy (ent->client->pers.netname, s, sizeof(ent->client->pers.netname)-1);
 
    // set spectator
    s = Info_ValueForKey (userinfo, "spectator");
    // spectators are only supported in deathmatch
    if (deathmatch->value && *s && strcmp(s, "0"))
        ent->client->pers.spectator = true;
    else
        ent->client->pers.spectator = false;
 
    // set skin
    s = Info_ValueForKey (userinfo, "skin");
 
    playernum = ent-g_edicts-1;
 
    // combine name and skin into a configstring
    gi.configstring (CS_PLAYERSKINS+playernum, va("%s\\%s", ent->client->pers.netname, s) );
 
    // fov
    if (deathmatch->value && ((int)dmflags->value & DF_FIXED_FOV))
    {
        ent->client->ps.fov = 90;
    }
    else
    {
        ent->client->ps.fov = atoi(Info_ValueForKey(userinfo, "fov"));
        if (ent->client->ps.fov < 1)
            ent->client->ps.fov = 90;
        else if (ent->client->ps.fov > 160)
            ent->client->ps.fov = 160;
    }
 
    // handedness
    s = Info_ValueForKey (userinfo, "hand");
    if (strlen(s))
    {
        ent->client->pers.hand = atoi(s);
    }
 
    // save off the userinfo in case we want to check something later
    strncpy (ent->client->pers.userinfo, userinfo, sizeof(ent->client->pers.userinfo)-1);
}

Referenced by ClientConnect(), GetGameAPI(), and PutClientInServer().

CopyToBodyQue()

void CopyToBodyQue

(

edict_t *

ent

)

Definition at line 946 of file p_client.c.

{
    edict_t     *body;
 
    // grab a body que and cycle to the next one
    body = &g_edicts[(int)maxclients->value + level.body_que + 1];
    level.body_que = (level.body_que + 1) % BODY_QUEUE_SIZE;
 
    // FIXME: send an effect on the removed body
 
    gi.unlinkentity (ent);
 
    gi.unlinkentity (body);
    body->s = ent->s;
    body->s.number = body - g_edicts;
 
    body->svflags = ent->svflags;
    VectorCopy (ent->mins, body->mins);
    VectorCopy (ent->maxs, body->maxs);
    VectorCopy (ent->absmin, body->absmin);
    VectorCopy (ent->absmax, body->absmax);
    VectorCopy (ent->size, body->size);
    body->solid = ent->solid;
    body->clipmask = ent->clipmask;
    body->owner = ent->owner;
    body->movetype = ent->movetype;
 
    body->die = body_die;
    body->takedamage = DAMAGE_YES;
 
    gi.linkentity (body);
}

Referenced by respawn().

FetchClientEntData()

void FetchClientEntData

(

edict_t *

ent

)

Definition at line 668 of file p_client.c.

{
    ent->health = ent->client->pers.health;
    ent->max_health = ent->client->pers.max_health;
    ent->flags |= ent->client->pers.savedFlags;
    if (coop->value)
        ent->client->resp.score = ent->client->pers.score;
}

Referenced by PutClientInServer().

InitBodyQue()

void InitBodyQue

(

void

)

Definition at line 918 of file p_client.c.

{
    int     i;
    edict_t *ent;
 
    level.body_que = 0;
    for (i=0; i<BODY_QUEUE_SIZE ; i++)
    {
        ent = G_Spawn();
        ent->classname = "bodyque";
    }
}

Referenced by SP_worldspawn().

InitClientPersistant()

void InitClientPersistant

(

gclient_t *

client

)

Definition at line 607 of file p_client.c.

{
    gitem_t     *item;
 
    memset (&client->pers, 0, sizeof(client->pers));
 
    item = FindItem("Blaster");
    client->pers.selected_item = ITEM_INDEX(item);
    client->pers.inventory[client->pers.selected_item] = 1;
 
    client->pers.weapon = item;
 
    client->pers.health         = 100;
    client->pers.max_health     = 100;
 
    client->pers.max_bullets    = 200;
    client->pers.max_shells     = 100;
    client->pers.max_rockets    = 50;
    client->pers.max_grenades   = 50;
    client->pers.max_cells      = 200;
    client->pers.max_slugs      = 50;
 
    client->pers.connected = true;
}

Referenced by ClientConnect(), and PutClientInServer().

InitClientResp()

void InitClientResp

(

gclient_t *

client

)

Definition at line 633 of file p_client.c.

{
    memset (&client->resp, 0, sizeof(client->resp));
    client->resp.enterframe = level.framenum;
    client->resp.coop_respawn = client->pers;
}

Referenced by ClientBegin(), ClientBeginDeathmatch(), and ClientConnect().

IsFemale()

qboolean IsFemale

(

edict_t *

ent

)

Definition at line 185 of file p_client.c.

{
    char        *info;
 
    if (!ent->client)
        return false;
 
    info = Info_ValueForKey (ent->client->pers.userinfo, "gender");
    if (info[0] == 'f' || info[0] == 'F')
        return true;
    return false;
}

Referenced by ClientObituary().

IsNeutral()

qboolean IsNeutral

(

edict_t *

ent

)

Definition at line 198 of file p_client.c.

{
    char        *info;
 
    if (!ent->client)
        return false;
 
    info = Info_ValueForKey (ent->client->pers.userinfo, "gender");
    if (info[0] != 'f' && info[0] != 'F' && info[0] != 'm' && info[0] != 'M')
        return true;
    return false;
}

Referenced by ClientObituary().

LookAtKiller()

void LookAtKiller	(	edict_t *	self,
		edict_t *	inflictor,
		edict_t *	attacker
	)

Definition at line 463 of file p_client.c.

{
    vec3_t      dir;
 
    if (attacker && attacker != world && attacker != self)
    {
        VectorSubtract (attacker->s.origin, self->s.origin, dir);
    }
    else if (inflictor && inflictor != world && inflictor != self)
    {
        VectorSubtract (inflictor->s.origin, self->s.origin, dir);
    }
    else
    {
        self->client->killer_yaw = self->s.angles[YAW];
        return;
    }
 
    if (dir[0])
        self->client->killer_yaw = 180/M_PI*atan2(dir[1], dir[0]);
    else {
        self->client->killer_yaw = 0;
        if (dir[1] > 0)
            self->client->killer_yaw = 90;
        else if (dir[1] < 0)
            self->client->killer_yaw = -90;
    }
    if (self->client->killer_yaw < 0)
        self->client->killer_yaw += 360;
    
 
}

Referenced by player_die().

player_die()

void player_die	(	edict_t *	self,
		edict_t *	inflictor,
		edict_t *	attacker,
		int	damage,
		vec3_t	point
	)

Definition at line 501 of file p_client.c.

{
    int     n;
 
    VectorClear (self->avelocity);
 
    self->takedamage = DAMAGE_YES;
    self->movetype = MOVETYPE_TOSS;
 
    self->s.modelindex2 = 0;    // remove linked weapon model
 
    self->s.angles[0] = 0;
    self->s.angles[2] = 0;
 
    self->s.sound = 0;
    self->client->weapon_sound = 0;
 
    self->maxs[2] = -8;
 
//  self->solid = SOLID_NOT;
    self->svflags |= SVF_DEADMONSTER;
 
    if (!self->deadflag)
    {
        self->client->respawn_time = level.time + 1.0;
        LookAtKiller (self, inflictor, attacker);
        self->client->ps.pmove.pm_type = PM_DEAD;
        ClientObituary (self, inflictor, attacker);
        TossClientWeapon (self);
        if (deathmatch->value)
            Cmd_Help_f (self);      // show scores
 
        // clear inventory
        // this is kind of ugly, but it's how we want to handle keys in coop
        for (n = 0; n < game.num_items; n++)
        {
            if (coop->value && itemlist[n].flags & IT_KEY)
                self->client->resp.coop_respawn.inventory[n] = self->client->pers.inventory[n];
            self->client->pers.inventory[n] = 0;
        }
    }
 
    // remove powerups
    self->client->quad_framenum = 0;
    self->client->invincible_framenum = 0;
    self->client->breather_framenum = 0;
    self->client->enviro_framenum = 0;
    self->flags &= ~FL_POWER_ARMOR;
 
    if (self->health < -40)
    {   // gib
        gi.sound (self, CHAN_BODY, gi.soundindex ("misc/udeath.wav"), 1, ATTN_NORM, 0);
        for (n= 0; n < 4; n++)
            ThrowGib (self, "models/objects/gibs/sm_meat/tris.md2", damage, GIB_ORGANIC);
        ThrowClientHead (self, damage);
 
        self->takedamage = DAMAGE_NO;
    }
    else
    {   // normal death
        if (!self->deadflag)
        {
            static int i;
 
            i = (i+1)%3;
            // start a death animation
            self->client->anim_priority = ANIM_DEATH;
            if (self->client->ps.pmove.pm_flags & PMF_DUCKED)
            {
                self->s.frame = FRAME_crdeath1-1;
                self->client->anim_end = FRAME_crdeath5;
            }
            else switch (i)
            {
            case 0:
                self->s.frame = FRAME_death101-1;
                self->client->anim_end = FRAME_death106;
                break;
            case 1:
                self->s.frame = FRAME_death201-1;
                self->client->anim_end = FRAME_death206;
                break;
            case 2:
                self->s.frame = FRAME_death301-1;
                self->client->anim_end = FRAME_death308;
                break;
            }
            gi.sound (self, CHAN_VOICE, gi.soundindex(va("*death%i.wav", (rand()%4)+1)), 1, ATTN_NORM, 0);
        }
    }
 
    self->deadflag = DEAD_DEAD;
 
    gi.linkentity (self);
}

Referenced by Cmd_Kill_f(), and PutClientInServer().

player_pain()

void player_pain	(	edict_t *	self,
		edict_t *	other,
		float	kick,
		int	damage
	)

Definition at line 179 of file p_client.c.

{
    // player pain is handled at the end of the frame in P_DamageFeedback
}

Referenced by PutClientInServer().

PlayersRangeFromSpot()

float PlayersRangeFromSpot

(

edict_t *

spot

)

Definition at line 694 of file p_client.c.

{
    edict_t *player;
    float   bestplayerdistance;
    vec3_t  v;
    int     n;
    float   playerdistance;
 
 
    bestplayerdistance = 9999999;
 
    for (n = 1; n <= maxclients->value; n++)
    {
        player = &g_edicts[n];
 
        if (!player->inuse)
            continue;
 
        if (player->health <= 0)
            continue;
 
        VectorSubtract (spot->s.origin, player->s.origin, v);
        playerdistance = VectorLength (v);
 
        if (playerdistance < bestplayerdistance)
            bestplayerdistance = playerdistance;
    }
 
    return bestplayerdistance;
}

Referenced by SelectFarthestDeathmatchSpawnPoint(), and SelectRandomDeathmatchSpawnPoint().

PM_trace()

trace_t PM_trace	(	vec3_t	start,
		vec3_t	mins,
		vec3_t	maxs,
		vec3_t	end
	)

Definition at line 1547 of file p_client.c.

{
    if (pm_passent->health > 0)
        return gi.trace (start, mins, maxs, end, pm_passent, MASK_PLAYERSOLID);
    else
        return gi.trace (start, mins, maxs, end, pm_passent, MASK_DEADSOLID);
}

Referenced by ClientThink().

PrintPmove()

void PrintPmove

(

pmove_t *

pm

)

Definition at line 1563 of file p_client.c.

{
    unsigned    c1, c2;
 
    c1 = CheckBlock (&pm->s, sizeof(pm->s));
    c2 = CheckBlock (&pm->cmd, sizeof(pm->cmd));
    Com_Printf ("sv %3i:%i %i\n", pm->cmd.impulse, c1, c2);
}

PutClientInServer()

void PutClientInServer

(

edict_t *

ent

)

Definition at line 1097 of file p_client.c.

{
    vec3_t  mins = {-16, -16, -24};
    vec3_t  maxs = {16, 16, 32};
    int     index;
    vec3_t  spawn_origin, spawn_angles;
    gclient_t   *client;
    int     i;
    client_persistant_t saved;
    client_respawn_t    resp;
 
    // find a spawn point
    // do it before setting health back up, so farthest
    // ranging doesn't count this client
    SelectSpawnPoint (ent, spawn_origin, spawn_angles);
 
    index = ent-g_edicts-1;
    client = ent->client;
 
    // deathmatch wipes most client data every spawn
    if (deathmatch->value)
    {
        char        userinfo[MAX_INFO_STRING];
 
        resp = client->resp;
        memcpy (userinfo, client->pers.userinfo, sizeof(userinfo));
        InitClientPersistant (client);
        ClientUserinfoChanged (ent, userinfo);
    }
    else if (coop->value)
    {
//      int         n;
        char        userinfo[MAX_INFO_STRING];
 
        resp = client->resp;
        memcpy (userinfo, client->pers.userinfo, sizeof(userinfo));
        // this is kind of ugly, but it's how we want to handle keys in coop
//      for (n = 0; n < game.num_items; n++)
//      {
//          if (itemlist[n].flags & IT_KEY)
//              resp.coop_respawn.inventory[n] = client->pers.inventory[n];
//      }
        resp.coop_respawn.game_helpchanged = client->pers.game_helpchanged;
        resp.coop_respawn.helpchanged = client->pers.helpchanged;
        client->pers = resp.coop_respawn;
        ClientUserinfoChanged (ent, userinfo);
        if (resp.score > client->pers.score)
            client->pers.score = resp.score;
    }
    else
    {
        memset (&resp, 0, sizeof(resp));
    }
 
    // clear everything but the persistant data
    saved = client->pers;
    memset (client, 0, sizeof(*client));
    client->pers = saved;
    if (client->pers.health <= 0)
        InitClientPersistant(client);
    client->resp = resp;
 
    // copy some data from the client to the entity
    FetchClientEntData (ent);
 
    // clear entity values
    ent->groundentity = NULL;
    ent->client = &game.clients[index];
    ent->takedamage = DAMAGE_AIM;
    ent->movetype = MOVETYPE_WALK;
    ent->viewheight = 22;
    ent->inuse = true;
    ent->classname = "player";
    ent->mass = 200;
    ent->solid = SOLID_BBOX;
    ent->deadflag = DEAD_NO;
    ent->air_finished = level.time + 12;
    ent->clipmask = MASK_PLAYERSOLID;
    ent->model = "players/male/tris.md2";
    ent->pain = player_pain;
    ent->die = player_die;
    ent->waterlevel = 0;
    ent->watertype = 0;
    ent->flags &= ~FL_NO_KNOCKBACK;
    ent->svflags &= ~SVF_DEADMONSTER;
 
    VectorCopy (mins, ent->mins);
    VectorCopy (maxs, ent->maxs);
    VectorClear (ent->velocity);
 
    // clear playerstate values
    memset (&ent->client->ps, 0, sizeof(client->ps));
 
    client->ps.pmove.origin[0] = spawn_origin[0]*8;
    client->ps.pmove.origin[1] = spawn_origin[1]*8;
    client->ps.pmove.origin[2] = spawn_origin[2]*8;
 
    if (deathmatch->value && ((int)dmflags->value & DF_FIXED_FOV))
    {
        client->ps.fov = 90;
    }
    else
    {
        client->ps.fov = atoi(Info_ValueForKey(client->pers.userinfo, "fov"));
        if (client->ps.fov < 1)
            client->ps.fov = 90;
        else if (client->ps.fov > 160)
            client->ps.fov = 160;
    }
 
    client->ps.gunindex = gi.modelindex(client->pers.weapon->view_model);
 
    // clear entity state values
    ent->s.effects = 0;
    ent->s.modelindex = 255;        // will use the skin specified model
    ent->s.modelindex2 = 255;       // custom gun model
    // sknum is player num and weapon number
    // weapon number will be added in changeweapon
    ent->s.skinnum = ent - g_edicts - 1;
 
    ent->s.frame = 0;
    VectorCopy (spawn_origin, ent->s.origin);
    ent->s.origin[2] += 1;  // make sure off ground
    VectorCopy (ent->s.origin, ent->s.old_origin);
 
    // set the delta angle
    for (i=0 ; i<3 ; i++)
    {
        client->ps.pmove.delta_angles[i] = ANGLE2SHORT(spawn_angles[i] - client->resp.cmd_angles[i]);
    }
 
    ent->s.angles[PITCH] = 0;
    ent->s.angles[YAW] = spawn_angles[YAW];
    ent->s.angles[ROLL] = 0;
    VectorCopy (ent->s.angles, client->ps.viewangles);
    VectorCopy (ent->s.angles, client->v_angle);
 
    // spawn a spectator
    if (client->pers.spectator) {
        client->chase_target = NULL;
 
        client->resp.spectator = true;
 
        ent->movetype = MOVETYPE_NOCLIP;
        ent->solid = SOLID_NOT;
        ent->svflags |= SVF_NOCLIENT;
        ent->client->ps.gunindex = 0;
        gi.linkentity (ent);
        return;
    } else
        client->resp.spectator = false;
 
    if (!KillBox (ent))
    {   // could't spawn in?
    }
 
    gi.linkentity (ent);
 
    // force the current weapon up
    client->newweapon = client->pers.weapon;
    ChangeWeapon (ent);
}

Referenced by ClientBegin(), ClientBeginDeathmatch(), respawn(), and spectator_respawn().

respawn()

void respawn

(

edict_t *

self

)

Definition at line 980 of file p_client.c.

{
    if (deathmatch->value || coop->value)
    {
        // spectator's don't leave bodies
        if (self->movetype != MOVETYPE_NOCLIP)
            CopyToBodyQue (self);
        self->svflags &= ~SVF_NOCLIENT;
        PutClientInServer (self);
 
        // add a teleportation effect
        self->s.event = EV_PLAYER_TELEPORT;
 
        // hold in place briefly
        self->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
        self->client->ps.pmove.pm_time = 14;
 
        self->client->respawn_time = level.time;
 
        return;
    }
 
    // restart the entire server
    gi.AddCommandString ("menu_loadgame\n");
}

Referenced by BeginIntermission(), and ClientBeginServerFrame().

SaveClientData()

void SaveClientData

(

void

)

Definition at line 650 of file p_client.c.

{
    int     i;
    edict_t *ent;
 
    for (i=0 ; i<game.maxclients ; i++)
    {
        ent = &g_edicts[1+i];
        if (!ent->inuse)
            continue;
        game.clients[i].pers.health = ent->health;
        game.clients[i].pers.max_health = ent->max_health;
        game.clients[i].pers.savedFlags = (ent->flags & (FL_GODMODE|FL_NOTARGET|FL_POWER_ARMOR));
        if (coop->value)
            game.clients[i].pers.score = ent->client->resp.score;
    }
}

Referenced by SpawnEntities(), and WriteGame().

SelectCoopSpawnPoint()

edict_t* SelectCoopSpawnPoint

(

edict_t *

ent

)

Definition at line 831 of file p_client.c.

{
    int     index;
    edict_t *spot = NULL;
    char    *target;
 
    index = ent->client - game.clients;
 
    // player 0 starts in normal player spawn point
    if (!index)
        return NULL;
 
    spot = NULL;
 
    // assume there are four coop spots at each spawnpoint
    while (1)
    {
        spot = G_Find (spot, FOFS(classname), "info_player_coop");
        if (!spot)
            return NULL;    // we didn't have enough...
 
        target = spot->targetname;
        if (!target)
            target = "";
        if ( Q_stricmp(game.spawnpoint, target) == 0 )
        {   // this is a coop spawn point for one of the clients here
            index--;
            if (!index)
                return spot;        // this is it
        }
    }
 
 
    return spot;
}

Referenced by SelectSpawnPoint().

SelectDeathmatchSpawnPoint()

edict_t* SelectDeathmatchSpawnPoint

(

void

)

Definition at line 822 of file p_client.c.

{
    if ( (int)(dmflags->value) & DF_SPAWN_FARTHEST)
        return SelectFarthestDeathmatchSpawnPoint ();
    else
        return SelectRandomDeathmatchSpawnPoint ();
}

Referenced by SelectSpawnPoint().

SelectFarthestDeathmatchSpawnPoint()

edict_t* SelectFarthestDeathmatchSpawnPoint

(

void

)

Definition at line 789 of file p_client.c.

{
    edict_t *bestspot;
    float   bestdistance, bestplayerdistance;
    edict_t *spot;
 
 
    spot = NULL;
    bestspot = NULL;
    bestdistance = 0;
    while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL)
    {
        bestplayerdistance = PlayersRangeFromSpot (spot);
 
        if (bestplayerdistance > bestdistance)
        {
            bestspot = spot;
            bestdistance = bestplayerdistance;
        }
    }
 
    if (bestspot)
    {
        return bestspot;
    }
 
    // if there is a player just spawned on each and every start spot
    // we have no choice to turn one into a telefrag meltdown
    spot = G_Find (NULL, FOFS(classname), "info_player_deathmatch");
 
    return spot;
}

Referenced by SelectDeathmatchSpawnPoint().

SelectRandomDeathmatchSpawnPoint()

edict_t* SelectRandomDeathmatchSpawnPoint

(

void

)

Definition at line 733 of file p_client.c.

{
    edict_t *spot, *spot1, *spot2;
    int     count = 0;
    int     selection;
    float   range, range1, range2;
 
    spot = NULL;
    range1 = range2 = 99999;
    spot1 = spot2 = NULL;
 
    while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL)
    {
        count++;
        range = PlayersRangeFromSpot(spot);
        if (range < range1)
        {
            range1 = range;
            spot1 = spot;
        }
        else if (range < range2)
        {
            range2 = range;
            spot2 = spot;
        }
    }
 
    if (!count)
        return NULL;
 
    if (count <= 2)
    {
        spot1 = spot2 = NULL;
    }
    else
        count -= 2;
 
    selection = rand() % count;
 
    spot = NULL;
    do
    {
        spot = G_Find (spot, FOFS(classname), "info_player_deathmatch");
        if (spot == spot1 || spot == spot2)
            selection++;
    } while(selection--);
 
    return spot;
}

Referenced by SelectDeathmatchSpawnPoint().

SelectSpawnPoint()

void SelectSpawnPoint	(	edict_t *	ent,
		vec3_t	origin,
		vec3_t	angles
	)

Definition at line 875 of file p_client.c.

{
    edict_t *spot = NULL;
 
    if (deathmatch->value)
        spot = SelectDeathmatchSpawnPoint ();
    else if (coop->value)
        spot = SelectCoopSpawnPoint (ent);
 
    // find a single player start spot
    if (!spot)
    {
        while ((spot = G_Find (spot, FOFS(classname), "info_player_start")) != NULL)
        {
            if (!game.spawnpoint[0] && !spot->targetname)
                break;
 
            if (!game.spawnpoint[0] || !spot->targetname)
                continue;
 
            if (Q_stricmp(game.spawnpoint, spot->targetname) == 0)
                break;
        }
 
        if (!spot)
        {
            if (!game.spawnpoint[0])
            {   // there wasn't a spawnpoint without a target, so use any
                spot = G_Find (spot, FOFS(classname), "info_player_start");
            }
            if (!spot)
                gi.error ("Couldn't find spawn point %s\n", game.spawnpoint);
        }
    }
 
    VectorCopy (spot->s.origin, origin);
    origin[2] += 9;
    VectorCopy (spot->s.angles, angles);
}

Referenced by PutClientInServer().

SP_CreateCoopSpots()

static void SP_CreateCoopSpots ( edict_t *  self )

static

Definition at line 70 of file p_client.c.

{
    edict_t *spot;
 
    if(Q_stricmp(level.mapname, "security") == 0)
    {
        spot = G_Spawn();
        spot->classname = "info_player_coop";
        spot->s.origin[0] = 188 - 64;
        spot->s.origin[1] = -164;
        spot->s.origin[2] = 80;
        spot->targetname = "jail3";
        spot->s.angles[1] = 90;
 
        spot = G_Spawn();
        spot->classname = "info_player_coop";
        spot->s.origin[0] = 188 + 64;
        spot->s.origin[1] = -164;
        spot->s.origin[2] = 80;
        spot->targetname = "jail3";
        spot->s.angles[1] = 90;
 
        spot = G_Spawn();
        spot->classname = "info_player_coop";
        spot->s.origin[0] = 188 + 128;
        spot->s.origin[1] = -164;
        spot->s.origin[2] = 80;
        spot->targetname = "jail3";
        spot->s.angles[1] = 90;
 
        return;
    }
}

Referenced by SP_info_player_start().

SP_FixCoopSpots()

static void SP_FixCoopSpots ( edict_t *  self )

static

Definition at line 39 of file p_client.c.

{
    edict_t *spot;
    vec3_t  d;
 
    spot = NULL;
 
    while(1)
    {
        spot = G_Find(spot, FOFS(classname), "info_player_start");
        if (!spot)
            return;
        if (!spot->targetname)
            continue;
        VectorSubtract(self->s.origin, spot->s.origin, d);
        if (VectorLength(d) < 384)
        {
            if ((!self->targetname) || Q_stricmp(self->targetname, spot->targetname) != 0)
            {
//              gi.dprintf("FixCoopSpots changed %s at %s targetname from %s to %s\n", self->classname, vtos(self->s.origin), self->targetname, spot->targetname);
                self->targetname = spot->targetname;
            }
            return;
        }
    }
}

Referenced by SP_info_player_coop().

SP_info_player_coop()

void SP_info_player_coop

(

edict_t *

self

)

Definition at line 137 of file p_client.c.

{
    if (!coop->value)
    {
        G_FreeEdict (self);
        return;
    }
 
    if((Q_stricmp(level.mapname, "jail2") == 0)   ||
       (Q_stricmp(level.mapname, "jail4") == 0)   ||
       (Q_stricmp(level.mapname, "mine1") == 0)   ||
       (Q_stricmp(level.mapname, "mine2") == 0)   ||
       (Q_stricmp(level.mapname, "mine3") == 0)   ||
       (Q_stricmp(level.mapname, "mine4") == 0)   ||
       (Q_stricmp(level.mapname, "lab") == 0)     ||
       (Q_stricmp(level.mapname, "boss1") == 0)   ||
       (Q_stricmp(level.mapname, "fact3") == 0)   ||
       (Q_stricmp(level.mapname, "biggun") == 0)  ||
       (Q_stricmp(level.mapname, "space") == 0)   ||
       (Q_stricmp(level.mapname, "command") == 0) ||
       (Q_stricmp(level.mapname, "power2") == 0) ||
       (Q_stricmp(level.mapname, "strike") == 0))
    {
        // invoke one of our gross, ugly, disgusting hacks
        self->think = SP_FixCoopSpots;
        self->nextthink = level.time + FRAMETIME;
    }
}

SP_info_player_deathmatch()

void SP_info_player_deathmatch

(

edict_t *

self

)

Definition at line 123 of file p_client.c.

{
    if (!deathmatch->value)
    {
        G_FreeEdict (self);
        return;
    }
    SP_misc_teleporter_dest (self);
}

SP_info_player_intermission()

void SP_info_player_intermission

(

void

)

Definition at line 171 of file p_client.c.

{
}

SP_info_player_start()

void SP_info_player_start

(

edict_t *

self

)

Definition at line 108 of file p_client.c.

{
    if (!coop->value)
        return;
    if(Q_stricmp(level.mapname, "security") == 0)
    {
        // invoke one of our gross, ugly, disgusting hacks
        self->think = SP_CreateCoopSpots;
        self->nextthink = level.time + FRAMETIME;
    }
}

SP_misc_teleporter_dest()

void SP_misc_teleporter_dest

(

edict_t *

ent

)

Definition at line 1868 of file g_misc.c.

{
    gi.setmodel (ent, "models/objects/dmspot/tris.md2");
    ent->s.skinnum = 0;
    ent->solid = SOLID_BBOX;
//  ent->s.effects |= EF_FLIES;
    VectorSet (ent->mins, -32, -32, -24);
    VectorSet (ent->maxs, 32, 32, -16);
    gi.linkentity (ent);
}

Referenced by SP_info_player_deathmatch().

spectator_respawn()

void spectator_respawn

(

edict_t *

ent

)

Definition at line 1010 of file p_client.c.

{
    int i, numspec;
 
    // if the user wants to become a spectator, make sure he doesn't
    // exceed max_spectators
 
    if (ent->client->pers.spectator) {
        char *value = Info_ValueForKey (ent->client->pers.userinfo, "spectator");
        if (*spectator_password->string && 
            strcmp(spectator_password->string, "none") && 
            strcmp(spectator_password->string, value)) {
            gi.cprintf(ent, PRINT_HIGH, "Spectator password incorrect.\n");
            ent->client->pers.spectator = false;
            gi.WriteByte (svc_stufftext);
            gi.WriteString ("spectator 0\n");
            gi.unicast(ent, true);
            return;
        }
 
        // count spectators
        for (i = 1, numspec = 0; i <= maxclients->value; i++)
            if (g_edicts[i].inuse && g_edicts[i].client->pers.spectator)
                numspec++;
 
        if (numspec >= maxspectators->value) {
            gi.cprintf(ent, PRINT_HIGH, "Server spectator limit is full.");
            ent->client->pers.spectator = false;
            // reset his spectator var
            gi.WriteByte (svc_stufftext);
            gi.WriteString ("spectator 0\n");
            gi.unicast(ent, true);
            return;
        }
    } else {
        // he was a spectator and wants to join the game
        // he must have the right password
        char *value = Info_ValueForKey (ent->client->pers.userinfo, "password");
        if (*password->string && strcmp(password->string, "none") && 
            strcmp(password->string, value)) {
            gi.cprintf(ent, PRINT_HIGH, "Password incorrect.\n");
            ent->client->pers.spectator = true;
            gi.WriteByte (svc_stufftext);
            gi.WriteString ("spectator 1\n");
            gi.unicast(ent, true);
            return;
        }
    }
 
    // clear client on respawn
    ent->client->resp.score = ent->client->pers.score = 0;
 
    ent->svflags &= ~SVF_NOCLIENT;
    PutClientInServer (ent);
 
    // add a teleportation effect
    if (!ent->client->pers.spectator)  {
        // send effect
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_LOGIN);
        gi.multicast (ent->s.origin, MULTICAST_PVS);
 
        // hold in place briefly
        ent->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
        ent->client->ps.pmove.pm_time = 14;
    }
 
    ent->client->respawn_time = level.time;
 
    if (ent->client->pers.spectator) 
        gi.bprintf (PRINT_HIGH, "%s has moved to the sidelines\n", ent->client->pers.netname);
    else
        gi.bprintf (PRINT_HIGH, "%s joined the game\n", ent->client->pers.netname);
}

Referenced by ClientBeginServerFrame().

TossClientWeapon()

void TossClientWeapon

(

edict_t *

self

)

Definition at line 410 of file p_client.c.

{
    gitem_t     *item;
    edict_t     *drop;
    qboolean    quad;
    float       spread;
 
    if (!deathmatch->value)
        return;
 
    item = self->client->pers.weapon;
    if (! self->client->pers.inventory[self->client->ammo_index] )
        item = NULL;
    if (item && (strcmp (item->pickup_name, "Blaster") == 0))
        item = NULL;
 
    if (!((int)(dmflags->value) & DF_QUAD_DROP))
        quad = false;
    else
        quad = (self->client->quad_framenum > (level.framenum + 10));
 
    if (item && quad)
        spread = 22.5;
    else
        spread = 0.0;
 
    if (item)
    {
        self->client->v_angle[YAW] -= spread;
        drop = Drop_Item (self, item);
        self->client->v_angle[YAW] += spread;
        drop->spawnflags = DROPPED_PLAYER_ITEM;
    }
 
    if (quad)
    {
        self->client->v_angle[YAW] += spread;
        drop = Drop_Item (self, FindItemByClassname ("item_quad"));
        self->client->v_angle[YAW] -= spread;
        drop->spawnflags |= DROPPED_PLAYER_ITEM;
 
        drop->touch = Touch_Item;
        drop->nextthink = level.time + (self->client->quad_framenum - level.framenum) * FRAMETIME;
        drop->think = G_FreeEdict;
    }
}

Referenced by player_die().

Touch_Item()

void Touch_Item	(	edict_t *	ent,
		edict_t *	other,
		cplane_t *	plane,
		csurface_t *	surf
	)

Definition at line 761 of file g_items.c.

{
    qboolean    taken;
 
    if (!other->client)
        return;
    if (other->health < 1)
        return;     // dead people can't pickup
    if (!ent->item->pickup)
        return;     // not a grabbable item?
 
    taken = ent->item->pickup(ent, other);
 
    if (taken)
    {
        // flash the screen
        other->client->bonus_alpha = 0.25;  
 
        // show icon and name on status bar
        other->client->ps.stats[STAT_PICKUP_ICON] = gi.imageindex(ent->item->icon);
        other->client->ps.stats[STAT_PICKUP_STRING] = CS_ITEMS+ITEM_INDEX(ent->item);
        other->client->pickup_msg_time = level.time + 3.0;
 
        // change selected item
        if (ent->item->use)
            other->client->pers.selected_item = other->client->ps.stats[STAT_SELECTED_ITEM] = ITEM_INDEX(ent->item);
 
        if (ent->item->pickup == Pickup_Health)
        {
            if (ent->count == 2)
                gi.sound(other, CHAN_ITEM, gi.soundindex("items/s_health.wav"), 1, ATTN_NORM, 0);
            else if (ent->count == 10)
                gi.sound(other, CHAN_ITEM, gi.soundindex("items/n_health.wav"), 1, ATTN_NORM, 0);
            else if (ent->count == 25)
                gi.sound(other, CHAN_ITEM, gi.soundindex("items/l_health.wav"), 1, ATTN_NORM, 0);
            else // (ent->count == 100)
                gi.sound(other, CHAN_ITEM, gi.soundindex("items/m_health.wav"), 1, ATTN_NORM, 0);
        }
        else if (ent->item->pickup_sound)
        {
            gi.sound(other, CHAN_ITEM, gi.soundindex(ent->item->pickup_sound), 1, ATTN_NORM, 0);
        }
    }
 
    if (!(ent->spawnflags & ITEM_TARGETS_USED))
    {
        G_UseTargets (ent, other);
        ent->spawnflags |= ITEM_TARGETS_USED;
    }
 
    if (!taken)
        return;
 
    if (!((coop->value) &&  (ent->item->flags & IT_STAY_COOP)) || (ent->spawnflags & (DROPPED_ITEM | DROPPED_PLAYER_ITEM)))
    {
        if (ent->flags & FL_RESPAWN)
            ent->flags &= ~FL_RESPAWN;
        else
            G_FreeEdict (ent);
    }
}

Referenced by Cmd_Give_f(), drop_make_touchable(), drop_temp_touch(), droptofloor(), TossClientWeapon(), and Use_Item().

Variable Documentation

pm_passent

edict_t* pm_passent

Definition at line 1544 of file p_client.c.

Referenced by ClientThink(), and PM_trace().