/*
==============
ClientEndFrame
Called at the end of each server frame for each connected client
A fast client will have multiple ClientThink for each ClientEdFrame,
while a slow client may have multiple ClientEndFrame between ClientThink.
==============
*/
void ClientEndFrame( gentity_t *ent )
{
if ( G_IsClientSpectating ( ent->client ) )
{
SpectatorClientEndFrame( ent );
return;
}
clientPersistant_t *pers = &ent->client->pers;
//
// If the end of unit layout is displayed, don't give
// the player any normal movement attributes
//
if ( level.intermissiontime )
{
return;
}
// burn from lava, etc
P_WorldEffects (ent);
// apply all the damage taken this frame
P_DamageFeedback (ent);
// add the EF_CONNECTION flag if we haven't gotten commands recently
if ( level.time - ent->client->lastCmdTime > 1000 )
{
ent->s.eFlags |= EF_CONNECTION;
}
else
{
ent->s.eFlags &= ~EF_CONNECTION;
}
// FIXME: get rid of ent->health...
ent->client->ps.stats[STAT_HEALTH] = ent->health;
G_SetClientSound (ent);
// set the latest infor
if (g_smoothClients.integer)
{
BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, true );
}
else
{
BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, true );
}
SendPendingPredictableEvents( &ent->client->ps );
// set the bit for the reachability area the client is currently in
// i = trap_AAS_PointReachabilityAreaIndex( ent->client->ps.origin );
// ent->client->areabits[i >> 3] |= 1 << (i & 7);
}
/*
==============
ClientEndFrame
Called at the end of each server frame for each connected client
A fast client will have multiple ClientThink for each ClientEdFrame,
while a slow client may have multiple ClientEndFrame between ClientThink.
==============
*/
void ClientEndFrame( gentity_t *ent )
{
clientPersistant_t *pers;
if( ent->client->sess.sessionTeam == TEAM_SPECTATOR )
{
SpectatorClientEndFrame( ent );
return;
}
pers = &ent->client->pers;
//
// If the end of unit layout is displayed, don't give
// the player any normal movement attributes
//
if( level.intermissiontime )
return;
// burn from lava, etc
P_WorldEffects( ent );
// apply all the damage taken this frame
P_DamageFeedback( ent );
// add the EF_CONNECTION flag if we haven't gotten commands recently
if( level.time - ent->client->lastCmdTime > 1000 )
ent->s.eFlags |= EF_CONNECTION;
else
ent->s.eFlags &= ~EF_CONNECTION;
ent->client->ps.stats[ STAT_HEALTH ] = ent->health; // FIXME: get rid of ent->health...
G_SetClientSound( ent );
// set the latest infor
if( g_smoothClients.integer )
BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qtrue );
else
BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
SendPendingPredictableEvents( &ent->client->ps );
}
/*
==============
ClientEndFrame
Called at the end of each server frame for each connected client
A fast client will have multiple ClientThink for each ClientEdFrame,
while a slow client may have multiple ClientEndFrame between ClientThink.
==============
*/
void ClientEndFrame(gentity_t * ent)
{
int i, frames;
// clientPersistant_t *pers;
if (ent->client->sess.sessionTeam == TEAM_SPECTATOR) {
SpectatorClientEndFrame(ent);
return;
}
// pers = &ent->client->pers;
// turn off any expired powerups
for (i = 0; i < MAX_POWERUPS; i++) {
if (ent->client->ps.powerups[i] < level.time) {
ent->client->ps.powerups[i] = 0;
}
}
// save network bandwidth
#if 0
if (!g_synchronousClients->integer && ent->client->ps.pm_type == PM_NORMAL) {
// FIXME: this must change eventually for non-sync demo recording
VectorClear(ent->client->ps.viewangles);
}
#endif
//
// If the end of unit layout is displayed, don't give
// the player any normal movement attributes
//
if (level.intermissiontime) {
return;
}
if (ent->client->bleeding)
CheckBleeding(ent); // perform once-a-second actions
// burn from lava, etc
P_WorldEffects(ent);
// apply all the damage taken this frame
P_DamageFeedback(ent);
// Update the clips Amount in weapon for the client
ent->client->ps.stats[STAT_CLIPS] = ent->client->numClips[ent->client->ps.weapon];
ent->client->ps.stats[STAT_HEALTH] = ent->health; // FIXME: get rid of ent->health...
//Elder: bleeding notification
if (ent->client->bleeding || (ent->client->ps.stats[STAT_RQ3] & RQ3_LEGDAMAGE) == RQ3_LEGDAMAGE) {
ent->client->ps.stats[STAT_RQ3] |= RQ3_BANDAGE_NEED;
} else {
ent->client->ps.stats[STAT_RQ3] &= ~RQ3_BANDAGE_NEED;
}
//Moved to pmove.c
//Elder: M4 ride-up/kick -- condition for non-burst and ammo only
if (ent->client->consecutiveShots &&
(ent->client->ps.ammo[WP_M4] <= 0 || ent->client->ps.weaponstate != WEAPON_FIRING)) {
//Restore view after shots if not firing
ent->client->ps.delta_angles[0] =
ANGLE2SHORT(SHORT2ANGLE(ent->client->ps.delta_angles[0]) - ent->client->consecutiveShots * -0.8);//-0.7f);
ent->client->consecutiveShots = 0;
}
// Check to reset our openDoor boolean
if (ent->client->openDoorTime && level.time - ent->client->openDoorTime > MAXDOORTIME) {
ent->client->openDoor = qfalse;
ent->client->openDoorTime = 0;
}
// JBravo: multiple items
if (ent->client->ps.stats[STAT_HOLDABLE_ITEM] & (1 << HI_LASER)) {
//Try to turn the laser on if it's off
if (ent->client->lasersight == NULL)
Laser_Gen(ent, qtrue);
}
//Slicer
if (ent->client->weapon_attempts > 0)
Cmd_Weapon(ent);
G_SetClientSound(ent);
BG_PlayerStateToEntityState(&ent->client->ps, &ent->s, qtrue);
SendPendingPredictableEvents(&ent->client->ps);
// JBravo: unlagged
ent->client->ps.eFlags &= ~EF_CONNECTION;
frames = level.framenum - ent->client->lastUpdateFrame - 1;
if (frames > 2) {
frames = 2;
ent->client->ps.eFlags |= EF_CONNECTION;
ent->s.eFlags |= EF_CONNECTION;
}
if (frames > 0 && g_smoothClients.integer) {
G_PredictPlayerMove(ent, (float)frames / sv_fps.integer);
SnapVector(ent->s.pos.trBase);
}
}
/*
==============
ClientThink
This will be called once for each client frame, which will
usually be a couple times for each server frame on fast clients.
If "g_synchronousClients 1" is set, this will be called exactly
once for each server frame, which makes for smooth demo recording.
==============
*/
void ClientThink_real(gentity_t * ent)
{
gclient_t *client;
pmove_t pm;
int oldEventSequence;
int msec;
usercmd_t *ucmd;
int bJumping = 0;
client = ent->client;
// don't think if the client is not yet connected (and thus not yet spawned in)
if (client->pers.connected != CON_CONNECTED) {
return;
}
// mark the time, so the connection sprite can be removed
ucmd = &ent->client->pers.cmd;
// sanity check the command time to prevent speedup cheating
if (ucmd->serverTime > level.time + 200) {
ucmd->serverTime = level.time + 200;
}
if (ucmd->serverTime < level.time - 1000) {
ucmd->serverTime = level.time - 1000;
}
client->lastUpdateFrame = level.framenum;
msec = ucmd->serverTime - client->ps.commandTime;
// following others may result in bad times, but we still want
// to check for follow toggles
if (msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW) {
return;
}
if (msec > 200) {
msec = 200;
}
if (pmove_msec.integer < 8) {
trap_Cvar_Set("pmove_msec", "8");
} else if (pmove_msec.integer > 33) {
trap_Cvar_Set("pmove_msec", "33");
}
if (pmove_fixed.integer || client->pers.pmoveFixed) {
ucmd->serverTime =
((ucmd->serverTime + pmove_msec.integer - 1) / pmove_msec.integer) * pmove_msec.integer;
}
//
// check for exiting intermission
//
if (level.intermissiontime) {
ClientIntermissionThink(client);
return;
}
// spectators don't do much
if (client->sess.sessionTeam == TEAM_SPECTATOR) {
if (client->sess.spectatorState == SPECTATOR_SCOREBOARD) {
return;
}
SpectatorThink(ent, ucmd);
return;
}
// check for inactivity timer, but never drop the local client of a non-dedicated server
if (!ClientInactivityTimer(client)) {
return;
}
// clear the rewards if time
if (level.time > client->rewardTime) {
client->ps.eFlags &=
~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND |
EF_AWARD_CAP);
}
if (client->noclip) {
client->ps.pm_type = PM_NOCLIP;
} else if (client->ps.stats[STAT_HEALTH] <= 0) {
client->ps.pm_type = PM_DEAD;
} else {
client->ps.pm_type = PM_NORMAL;
}
client->ps.gravity = g_gravity.value;
// set speed
client->ps.speed = g_speed.value;
// set up for pmove
oldEventSequence = client->ps.eventSequence;
memset(&pm, 0, sizeof(pm));
if (ent->flags & FL_FORCE_GESTURE) {
ent->flags &= ~FL_FORCE_GESTURE;
ent->client->pers.cmd.buttons |= BUTTON_GESTURE;
}
//Elder: 3rb Code moved to bg_pmove.c (resides in PM_Weapon)
pm.ps = &client->ps;
pm.cmd = *ucmd;
if (pm.ps->pm_type == PM_DEAD) {
pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
} else if (ent->r.svFlags & SVF_BOT) {
pm.tracemask = MASK_PLAYERSOLID | CONTENTS_BOTCLIP;
} else {
pm.tracemask = MASK_PLAYERSOLID;
}
// JBravo: fixing telefragging and shit during spawnig. (Thanks NiceAss! :)
if ((g_gametype.integer == GT_TEAMPLAY || g_gametype.integer == GT_TEAM) &&
((ent->client->ps.stats[STAT_RQ3] & RQ3_PLAYERSOLID) != RQ3_PLAYERSOLID) && !level.lights_camera_action) {
UnstickPlayer(ent);
}
if ((g_gametype.integer == GT_TEAMPLAY || g_gametype.integer == GT_TEAM) &&
((ent->client->ps.stats[STAT_RQ3] & RQ3_PLAYERSOLID) != RQ3_PLAYERSOLID)) {
pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
}
pm.trace = trap_Trace;
pm.pointcontents = trap_PointContents;
pm.debugLevel = g_debugMove.integer;
pm.noFootsteps = (g_dmflags.integer & DF_NO_FOOTSTEPS) > 0;
pm.pmove_fixed = pmove_fixed.integer | client->pers.pmoveFixed;
pm.pmove_msec = pmove_msec.integer;
VectorCopy(client->ps.origin, client->oldOrigin);
// JBravo: setting lca in pm if appropriate
if (g_RQ3_lca.integer == 1)
pm.lca = qtrue;
else
pm.lca = qfalse;
pm.predict = qtrue;
Pmove(&pm);
if ((pm.cmd.upmove > 10) &&
(pm.waterlevel == 0) &&
ent->s.groundEntityNum != ENTITYNUM_NONE && pm.ps->groundEntityNum == ENTITYNUM_NONE)
bJumping = 1;
// save results of pmove
if (ent->client->ps.eventSequence != oldEventSequence) {
ent->eventTime = level.time;
}
BG_PlayerStateToEntityState(&ent->client->ps, &ent->s, qtrue);
SendPendingPredictableEvents(&ent->client->ps);
if (!(ent->client->ps.eFlags & EF_FIRING)) {
client->fireHeld = qfalse; // for grapple
}
// use the snapped origin for linking so it matches client predicted versions
VectorCopy(ent->s.pos.trBase, ent->r.currentOrigin);
VectorCopy(pm.mins, ent->r.mins);
VectorCopy(pm.maxs, ent->r.maxs);
ent->waterlevel = pm.waterlevel;
ent->watertype = pm.watertype;
// execute client events
ClientEvents(ent, oldEventSequence);
// link entity now, after any personal teleporters have been used
// JBravo: this call reactivates gibbed players.
if (!ent->client->gibbed)
trap_LinkEntity(ent);
if (!ent->client->noclip) {
G_TouchTriggers(ent);
}
// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
VectorCopy(ent->client->ps.origin, ent->r.currentOrigin);
//test for solid areas in the AAS file
BotTestAAS(ent->r.currentOrigin);
// touch other objects
ClientImpacts(ent, &pm);
//Elder: someone added
if (bJumping)
JumpKick(ent);
// save results of triggers and client events
if (ent->client->ps.eventSequence != oldEventSequence) {
ent->eventTime = level.time;
}
// swap and latch button actions
client->oldbuttons = client->buttons;
client->buttons = ucmd->buttons;
client->latched_buttons |= client->buttons & ~client->oldbuttons;
// check for respawning
// JBravo: Lets make dead players into spectators.
if (client->ps.stats[STAT_HEALTH] <= 0) {
// wait for the attack button to be pressed
if (level.time > client->respawnTime) {
// forcerespawn is to prevent users from waiting out powerups
if (g_forcerespawn.integer > 0 &&
(level.time - client->respawnTime) > g_forcerespawn.integer * 1000 &&
g_gametype.integer != GT_TEAMPLAY && g_gametype.integer != GT_CTF) {
respawn(ent);
return;
}
if ((g_gametype.integer == GT_TEAMPLAY || g_gametype.integer == GT_CTF) && level.time > client->respawnTime) {
MakeSpectator(ent);
}
// pressing attack or use is the normal respawn method
// JBravo: make'em spactate
if (ucmd->buttons & (BUTTON_ATTACK | BUTTON_USE_HOLDABLE)) {
if (g_gametype.integer == GT_TEAMPLAY || g_gametype.integer == GT_CTF) {
MakeSpectator(ent);
} else {
respawn(ent);
}
}
}
return;
}
// JBravo: Idle sounds
if (g_RQ3_ppl_idletime.integer) {
if (ucmd->forwardmove == 0 && ucmd->rightmove == 0) {
if (client->idletime) {
if (level.time >= client->idletime + (g_RQ3_ppl_idletime.integer * 1000)) {
if (g_gametype.integer >= GT_TEAM && g_RQ3_idleaction.integer == 1 &&
(ent->client->sess.sessionTeam == TEAM_RED || ent->client->sess.sessionTeam == TEAM_BLUE)) {
trap_SendServerCommand( -1, va("print \"Removing %s^7 from his team for excessive Idling\n\"",
ent->client->pers.netname));
trap_SendServerCommand(ent - g_entities, "stuff team none\n");
} else if (g_gametype.integer >= GT_TEAM && g_RQ3_idleaction.integer == 2 &&
(ent->client->sess.sessionTeam == TEAM_RED || ent->client->sess.sessionTeam == TEAM_BLUE)) {
trap_SendServerCommand( -1, va("print \"Kicking %s^7 for excessive Idling\n\"",
ent->client->pers.netname));
trap_DropClient(ent - g_entities, "Dropped due to excessive Idling");
} else
G_TempEntity(ent->r.currentOrigin, EV_INSANESOUND);
client->idletime = 0;
}
} else {
client->idletime = level.time;
}
} else {
client->idletime = 0;
}
}
// perform once-a-second actions
ClientTimerActions(ent, msec);
}
/*
==============
ClientThink
This will be called once for each client frame, which will
usually be a couple times for each server frame on fast clients.
If "g_synchronousClients 1" is set, this will be called exactly
once for each server frame, which makes for smooth demo recording.
==============
*/
void ClientThink_real( gentity_t *ent )
{
gclient_t *client;
pmove_t pm;
int oldEventSequence;
int msec;
usercmd_t *ucmd;
client = ent->client;
// don't think if the client is not yet connected (and thus not yet spawned in)
if (client->pers.connected != CON_CONNECTED)
{
return;
}
// mark the time, so the connection sprite can be removed
ucmd = &ent->client->pers.cmd;
// sanity check the command time to prevent speedup cheating
if ( ucmd->serverTime > level.time + 200 )
{
ucmd->serverTime = level.time + 200;
}
if ( ucmd->serverTime < level.time - 1000 )
{
ucmd->serverTime = level.time - 1000;
}
msec = ucmd->serverTime - client->ps.commandTime;
// following others may result in bad times, but we still want
// to check for follow toggles
if ( msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW )
{
return;
}
if ( msec > 200 )
{
msec = 200;
}
if ( pmove_msec.integer < 8 )
{
trap_Cvar_Set("pmove_msec", "8");
}
else if (pmove_msec.integer > 33)
{
trap_Cvar_Set("pmove_msec", "33");
}
if ( pmove_fixed.integer || client->pers.pmoveFixed )
{
ucmd->serverTime = ((ucmd->serverTime + pmove_msec.integer-1) / pmove_msec.integer) * pmove_msec.integer;
}
//
// check for exiting intermission
//
if ( level.intermissiontime )
{
ClientIntermissionThink( client );
return;
}
// spectators don't do much
if ( G_IsClientSpectating ( client ) )
{
if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD )
{
return;
}
SpectatorThink( ent, ucmd );
return;
}
// check for inactivity timer, but never drop the local client of a non-dedicated server
if ( !ClientInactivityTimer( client ) )
{
return;
}
if ( client->noclip )
{
client->ps.pm_type = PM_NOCLIP;
}
else if ( client->ps.stats[STAT_HEALTH] <= 0 )
{
client->ps.pm_type = PM_DEAD;
}
else
{
client->ps.pm_type = PM_NORMAL;
}
client->ps.gravity = g_gravity.value;
// set speed
client->ps.speed = g_speed.value;
// set up for pmove
oldEventSequence = client->ps.eventSequence;
memset (&pm, 0, sizeof(pm));
pm.ps = &client->ps;
pm.cmd = *ucmd;
if ( pm.ps->pm_type == PM_DEAD )
{
pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
}
else if ( client->siameseTwin )
{
// Make sure we are still stuck, if so, clip through players.
if ( G_IsClientSiameseTwin ( ent, client->siameseTwin ) )
{
pm.tracemask = MASK_PLAYERSOLID & ~(CONTENTS_BODY);
}
else
{
// Ok, we arent stuck anymore so we can clear the stuck flag.
client->siameseTwin->client->siameseTwin = NULL;
client->siameseTwin = NULL;
pm.tracemask = MASK_PLAYERSOLID;
}
}
else if ( ent->r.svFlags & SVF_BOT )
{
pm.tracemask = MASK_PLAYERSOLID | CONTENTS_BOTCLIP;
}
else
{
pm.tracemask = MASK_PLAYERSOLID;
}
pm.trace = trap_Trace;
pm.pointcontents = trap_PointContents;
pm.debugLevel = g_debugMove.integer;
pm.noFootsteps = ( g_dmflags.integer & DF_NO_FOOTSTEPS ) > 0;
pm.pmove_fixed = (bool)pmove_fixed.integer | client->pers.pmoveFixed;
pm.pmove_msec = pmove_msec.integer;
pm.animations = NULL;
VectorCopy( client->ps.origin, client->oldOrigin );
Pmove (&pm);
G_UpdatePlayerStateScores ( ent );
// save results of pmove
if ( ent->client->ps.eventSequence != oldEventSequence )
{
ent->eventTime = level.time;
}
// See if the invulnerable flag should be removed for this client
if ( ent->client->ps.eFlags & EF_INVULNERABLE )
{
if ( level.time - ent->client->invulnerableTime >= g_respawnInvulnerability.integer * 1000 )
{
ent->client->ps.eFlags &= ~EF_INVULNERABLE;
}
}
if (g_smoothClients.integer)
{
BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, true );
}
else
{
BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, true );
}
SendPendingPredictableEvents( &ent->client->ps );
if ( !( ent->client->ps.eFlags & EF_FIRING ) )
{
client->fireHeld = false; // for grapple
}
// use the snapped origin for linking so it matches client predicted versions
VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
VectorCopy (pm.mins, ent->r.mins);
VectorCopy (pm.maxs, ent->r.maxs);
ent->waterlevel = pm.waterlevel;
ent->watertype = pm.watertype;
// Need to cache off the firemodes to the persitant data segment so they
// are maintained across spectating and respawning
memcpy ( ent->client->pers.firemode, ent->client->ps.firemode, sizeof(ent->client->ps.firemode ) );
// execute client events
ClientEvents( ent, oldEventSequence );
// Update the client animation info
G_UpdateClientAnimations ( ent );
// link entity now, after any personal teleporters have been used
trap_LinkEntity (ent);
if ( !ent->client->noclip )
{
G_TouchTriggers( ent );
}
// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
// Update the clients anti-lag history
G_UpdateClientAntiLag ( ent );
// touch other objects
ClientImpacts( ent, &pm );
// save results of triggers and client events
if (ent->client->ps.eventSequence != oldEventSequence)
{
ent->eventTime = level.time;
}
// swap and latch button actions
client->oldbuttons = client->buttons;
client->buttons = ucmd->buttons;
client->latched_buttons |= client->buttons & ~client->oldbuttons;
// check for respawning
if ( client->ps.stats[STAT_HEALTH] <= 0 )
{
// wait for the attack button to be pressed
if ( level.time > client->respawnTime )
{
if ( g_forcerespawn.integer > 0 &&
( level.time - client->respawnTime ) > g_forcerespawn.integer * 1000 )
{
respawn( ent );
return;
}
// pressing attack or use is the normal respawn method
if ( ucmd->buttons & BUTTON_ATTACK )
{
respawn( ent );
}
}
return;
}
// perform once-a-second actions
ClientTimerActions( ent, msec );
}
/*
==============
ClientThink
This will be called once for each client frame, which will
usually be a couple times for each server frame on fast clients.
If "g_synchronousClients 1" is set, this will be called exactly
once for each server frame, which makes for smooth demo recording.
==============
*/
void ClientThink_real( gentity_t *ent ) {
gclient_t *client;
pmove_t pm;
int oldEventSequence;
int msec;
int i;
usercmd_t *ucmd;
client = ent->client;
// don't think if the client is not yet connected (and thus not yet spawned in)
if (client->pers.connected != CON_CONNECTED) {
return;
}
// mark the time, so the connection sprite can be removed
ucmd = &ent->client->pers.cmd;
// sanity check the command time to prevent speedup cheating
if ( ucmd->serverTime > level.time + 200 ) {
ucmd->serverTime = level.time + 200;
// G_Printf("serverTime <<<<<\n" );
}
if ( ucmd->serverTime < level.time - 1000 ) {
ucmd->serverTime = level.time - 1000;
// G_Printf("serverTime >>>>>\n" );
}
msec = ucmd->serverTime - client->ps.commandTime;
// following others may result in bad times, but we still want
// to check for follow toggles
if ( msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW ) {
return;
}
if ( msec > 200 ) {
msec = 200;
}
if ( pmove_msec.integer < 8 ) {
trap_Cvar_Set("pmove_msec", "8");
}
else if (pmove_msec.integer > 33) {
trap_Cvar_Set("pmove_msec", "33");
}
if ( pmove_fixed.integer || client->pers.pmoveFixed ) {
ucmd->serverTime = ((ucmd->serverTime + pmove_msec.integer-1) / pmove_msec.integer) * pmove_msec.integer;
//if (ucmd->serverTime - client->ps.commandTime <= 0)
// return;
}
//
// check for exiting intermission
//
if ( level.intermissiontime ) {
ClientIntermissionThink( client );
return;
}
// spectators don't do much
if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
return;
}
SpectatorThink( ent, ucmd );
return;
}
if (ent && ent->client && (ent->client->ps.eFlags & EF_INVULNERABLE))
{
if (ent->client->invulnerableTimer <= level.time)
{
ent->client->ps.eFlags &= ~EF_INVULNERABLE;
}
}
// check for inactivity timer, but never drop the local client of a non-dedicated server
if ( !ClientInactivityTimer( client ) ) {
return;
}
// clear the rewards if time
if ( level.time > client->rewardTime ) {
client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
}
if ( client->noclip ) {
client->ps.pm_type = PM_NOCLIP;
} else if ( client->ps.eFlags & EF_DISINTEGRATION ) {
client->ps.pm_type = PM_NOCLIP;
} else if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
client->ps.pm_type = PM_DEAD;
} else {
if (client->ps.forceGripChangeMovetype)
{
client->ps.pm_type = client->ps.forceGripChangeMovetype;
}
else
{
client->ps.pm_type = PM_NORMAL;
}
}
client->ps.gravity = g_gravity.value;
// set speed
client->ps.speed = g_speed.value;
client->ps.basespeed = g_speed.value;
if (ent->client->ps.duelInProgress)
{
gentity_t *duelAgainst = &g_entities[ent->client->ps.duelIndex];
//Keep the time updated, so once this duel ends this player can't engage in a duel for another
//10 seconds. This will give other people a chance to engage in duels in case this player wants
//to engage again right after he's done fighting and someone else is waiting.
ent->client->ps.fd.privateDuelTime = level.time + 10000;
if (ent->client->ps.duelTime < level.time)
{
//Bring out the sabers
if (ent->client->ps.weapon == WP_SABER && ent->client->ps.saberHolstered &&
ent->client->ps.duelTime)
{
if (!saberOffSound || !saberOnSound)
{
saberOffSound = G_SoundIndex("sound/weapons/saber/saberoffquick.wav");
saberOnSound = G_SoundIndex("sound/weapons/saber/saberon.wav");
}
ent->client->ps.saberHolstered = qfalse;
G_Sound(ent, CHAN_AUTO, saberOnSound);
G_AddEvent(ent, EV_PRIVATE_DUEL, 2);
ent->client->ps.duelTime = 0;
}
if (duelAgainst && duelAgainst->client && duelAgainst->inuse &&
duelAgainst->client->ps.weapon == WP_SABER && duelAgainst->client->ps.saberHolstered &&
duelAgainst->client->ps.duelTime)
{
if (!saberOffSound || !saberOnSound)
{
saberOffSound = G_SoundIndex("sound/weapons/saber/saberoffquick.wav");
saberOnSound = G_SoundIndex("sound/weapons/saber/saberon.wav");
}
duelAgainst->client->ps.saberHolstered = qfalse;
G_Sound(duelAgainst, CHAN_AUTO, saberOnSound);
G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 2);
duelAgainst->client->ps.duelTime = 0;
}
}
else
{
client->ps.speed = 0;
client->ps.basespeed = 0;
ucmd->forwardmove = 0;
ucmd->rightmove = 0;
ucmd->upmove = 0;
}
if (!duelAgainst || !duelAgainst->client || !duelAgainst->inuse ||
duelAgainst->client->ps.duelIndex != ent->s.number)
{
ent->client->ps.duelInProgress = 0;
G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
}
else if (duelAgainst->health < 1 || duelAgainst->client->ps.stats[STAT_HEALTH] < 1)
{
ent->client->ps.duelInProgress = 0;
duelAgainst->client->ps.duelInProgress = 0;
G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 0);
//Winner gets full health.. providing he's still alive
if (ent->health > 0 && ent->client->ps.stats[STAT_HEALTH] > 0)
{
if (ent->health < ent->client->ps.stats[STAT_MAX_HEALTH])
{
ent->client->ps.stats[STAT_HEALTH] = ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
}
if (g_spawnInvulnerability.integer)
{
ent->client->ps.eFlags |= EF_INVULNERABLE;
ent->client->invulnerableTimer = level.time + g_spawnInvulnerability.integer;
}
}
/*
trap_SendServerCommand( ent-g_entities, va("print \"%s %s\n\"", ent->client->pers.netname, G_GetStripEdString("SVINGAME", "PLDUELWINNER")) );
trap_SendServerCommand( duelAgainst-g_entities, va("print \"%s %s\n\"", ent->client->pers.netname, G_GetStripEdString("SVINGAME", "PLDUELWINNER")) );
*/
//Private duel announcements are now made globally because we only want one duel at a time.
if (ent->health > 0 && ent->client->ps.stats[STAT_HEALTH] > 0)
{
trap_SendServerCommand( -1, va("cp \"%s %s %s!\n\"", ent->client->pers.netname, G_GetStripEdString("SVINGAME", "PLDUELWINNER"), duelAgainst->client->pers.netname) );
}
else
{ //it was a draw, because we both managed to die in the same frame
trap_SendServerCommand( -1, va("cp \"%s\n\"", G_GetStripEdString("SVINGAME", "PLDUELTIE")) );
}
}
else
{
vec3_t vSub;
float subLen = 0;
VectorSubtract(ent->client->ps.origin, duelAgainst->client->ps.origin, vSub);
subLen = VectorLength(vSub);
if (subLen >= 1024)
{
ent->client->ps.duelInProgress = 0;
duelAgainst->client->ps.duelInProgress = 0;
G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 0);
trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStripEdString("SVINGAME", "PLDUELSTOP")) );
}
}
}
/*
if ( client->ps.powerups[PW_HASTE] ) {
client->ps.speed *= 1.3;
}
*/
if (client->ps.usingATST && ent->health > 0)
{ //we have special shot clip boxes as an ATST
ent->r.contents |= CONTENTS_NOSHOT;
ATST_ManageDamageBoxes(ent);
}
else
{
ent->r.contents &= ~CONTENTS_NOSHOT;
client->damageBoxHandle_Head = 0;
client->damageBoxHandle_RLeg = 0;
client->damageBoxHandle_LLeg = 0;
}
//rww - moved this stuff into the pmove code so that it's predicted properly
//BG_AdjustClientSpeed(&client->ps, &client->pers.cmd, level.time);
// set up for pmove
oldEventSequence = client->ps.eventSequence;
memset (&pm, 0, sizeof(pm));
if ( ent->flags & FL_FORCE_GESTURE ) {
ent->flags &= ~FL_FORCE_GESTURE;
ent->client->pers.cmd.buttons |= BUTTON_GESTURE;
}
if (ent->client && ent->client->ps.fallingToDeath &&
(level.time - FALL_FADE_TIME) > ent->client->ps.fallingToDeath)
{ //die!
player_die(ent, ent, ent, 100000, MOD_FALLING);
respawn(ent);
ent->client->ps.fallingToDeath = 0;
G_MuteSound(ent->s.number, CHAN_VOICE); //stop screaming, because you are dead!
}
if (ent->client->ps.otherKillerTime > level.time &&
ent->client->ps.groundEntityNum != ENTITYNUM_NONE &&
ent->client->ps.otherKillerDebounceTime < level.time)
{
ent->client->ps.otherKillerTime = 0;
ent->client->ps.otherKiller = ENTITYNUM_NONE;
}
else if (ent->client->ps.otherKillerTime > level.time &&
ent->client->ps.groundEntityNum == ENTITYNUM_NONE)
{
if (ent->client->ps.otherKillerDebounceTime < (level.time + 100))
{
ent->client->ps.otherKillerDebounceTime = level.time + 100;
}
}
// WP_ForcePowersUpdate( ent, msec, ucmd); //update any active force powers
// WP_SaberPositionUpdate(ent, ucmd); //check the server-side saber point, do apprioriate server-side actions (effects are cs-only)
if ((ent->client->pers.cmd.buttons & BUTTON_USE) && ent->client->ps.useDelay < level.time)
{
TryUse(ent);
ent->client->ps.useDelay = level.time + 100;
}
pm.ps = &client->ps;
pm.cmd = *ucmd;
if ( pm.ps->pm_type == PM_DEAD ) {
pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
}
else if ( ent->r.svFlags & SVF_BOT ) {
pm.tracemask = MASK_PLAYERSOLID | CONTENTS_MONSTERCLIP;
}
else {
pm.tracemask = MASK_PLAYERSOLID;
}
pm.trace = trap_Trace;
pm.pointcontents = trap_PointContents;
pm.debugLevel = g_debugMove.integer;
pm.noFootsteps = ( g_dmflags.integer & DF_NO_FOOTSTEPS ) > 0;
pm.pmove_fixed = pmove_fixed.integer | client->pers.pmoveFixed;
pm.pmove_msec = pmove_msec.integer;
pm.animations = bgGlobalAnimations;//NULL;
pm.gametype = g_gametype.integer;
VectorCopy( client->ps.origin, client->oldOrigin );
if (level.intermissionQueued != 0 && g_singlePlayer.integer) {
if ( level.time - level.intermissionQueued >= 1000 ) {
pm.cmd.buttons = 0;
pm.cmd.forwardmove = 0;
pm.cmd.rightmove = 0;
pm.cmd.upmove = 0;
if ( level.time - level.intermissionQueued >= 2000 && level.time - level.intermissionQueued <= 2500 ) {
trap_SendConsoleCommand( EXEC_APPEND, "centerview\n");
}
ent->client->ps.pm_type = PM_SPINTERMISSION;
}
}
for ( i = 0 ; i < MAX_CLIENTS ; i++ )
{
if (g_entities[i].inuse && g_entities[i].client)
{
pm.bgClients[i] = &g_entities[i].client->ps;
}
}
if (ent->client->ps.saberLockTime > level.time)
{
gentity_t *blockOpp = &g_entities[ent->client->ps.saberLockEnemy];
if (blockOpp && blockOpp->inuse && blockOpp->client)
{
vec3_t lockDir, lockAng;
//VectorClear( ent->client->ps.velocity );
VectorSubtract( blockOpp->r.currentOrigin, ent->r.currentOrigin, lockDir );
//lockAng[YAW] = vectoyaw( defDir );
vectoangles(lockDir, lockAng);
SetClientViewAngle( ent, lockAng );
}
if ( ( ent->client->buttons & BUTTON_ATTACK ) && ! ( ent->client->oldbuttons & BUTTON_ATTACK ) )
{
ent->client->ps.saberLockHits++;
}
if (ent->client->ps.saberLockHits > 2)
{
if (!ent->client->ps.saberLockAdvance)
{
ent->client->ps.saberLockHits -= 3;
}
ent->client->ps.saberLockAdvance = qtrue;
}
}
else
{
ent->client->ps.saberLockFrame = 0;
//check for taunt
if ( (pm.cmd.generic_cmd == GENCMD_ENGAGE_DUEL) && (g_gametype.integer == GT_TOURNAMENT) )
{//already in a duel, make it a taunt command
pm.cmd.buttons |= BUTTON_GESTURE;
}
}
Pmove (&pm);
if (pm.checkDuelLoss)
{
if (pm.checkDuelLoss > 0 && pm.checkDuelLoss <= MAX_CLIENTS)
{
gentity_t *clientLost = &g_entities[pm.checkDuelLoss-1];
if (clientLost && clientLost->inuse && clientLost->client && Q_irand(0, 40) > clientLost->health)
{
vec3_t attDir;
VectorSubtract(ent->client->ps.origin, clientLost->client->ps.origin, attDir);
VectorNormalize(attDir);
VectorClear(clientLost->client->ps.velocity);
clientLost->client->ps.forceHandExtend = HANDEXTEND_NONE;
clientLost->client->ps.forceHandExtendTime = 0;
gGAvoidDismember = 1;
G_Damage(clientLost, ent, ent, attDir, clientLost->client->ps.origin, 9999, DAMAGE_NO_PROTECTION, MOD_SABER);
if (clientLost->health < 1)
{
gGAvoidDismember = 2;
G_CheckForDismemberment(clientLost, clientLost->client->ps.origin, 999, (clientLost->client->ps.legsAnim&~ANIM_TOGGLEBIT));
}
gGAvoidDismember = 0;
}
}
pm.checkDuelLoss = 0;
}
switch(pm.cmd.generic_cmd)
{
case 0:
break;
case GENCMD_SABERSWITCH:
Cmd_ToggleSaber_f(ent);
break;
case GENCMD_ENGAGE_DUEL:
if ( g_gametype.integer == GT_TOURNAMENT )
{//already in a duel, made it a taunt command
}
else
{
Cmd_EngageDuel_f(ent);
}
break;
case GENCMD_FORCE_HEAL:
ForceHeal(ent);
break;
case GENCMD_FORCE_SPEED:
ForceSpeed(ent, 0);
break;
case GENCMD_FORCE_THROW:
ForceThrow(ent, qfalse);
break;
case GENCMD_FORCE_PULL:
ForceThrow(ent, qtrue);
break;
case GENCMD_FORCE_DISTRACT:
ForceTelepathy(ent);
break;
case GENCMD_FORCE_RAGE:
ForceRage(ent);
break;
case GENCMD_FORCE_PROTECT:
ForceProtect(ent);
break;
case GENCMD_FORCE_ABSORB:
ForceAbsorb(ent);
break;
case GENCMD_FORCE_HEALOTHER:
ForceTeamHeal(ent);
break;
case GENCMD_FORCE_FORCEPOWEROTHER:
ForceTeamForceReplenish(ent);
break;
case GENCMD_FORCE_SEEING:
ForceSeeing(ent);
break;
case GENCMD_USE_SEEKER:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SEEKER)) &&
G_ItemUsable(&ent->client->ps, HI_SEEKER) )
{
ItemUse_Seeker(ent);
G_AddEvent(ent, EV_USE_ITEM0+HI_SEEKER, 0);
ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SEEKER);
}
break;
case GENCMD_USE_FIELD:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SHIELD)) &&
G_ItemUsable(&ent->client->ps, HI_SHIELD) )
{
ItemUse_Shield(ent);
G_AddEvent(ent, EV_USE_ITEM0+HI_SHIELD, 0);
ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SHIELD);
}
break;
case GENCMD_USE_BACTA:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_MEDPAC)) &&
G_ItemUsable(&ent->client->ps, HI_MEDPAC) )
{
ItemUse_MedPack(ent);
G_AddEvent(ent, EV_USE_ITEM0+HI_MEDPAC, 0);
ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_MEDPAC);
}
break;
case GENCMD_USE_ELECTROBINOCULARS:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_BINOCULARS)) &&
G_ItemUsable(&ent->client->ps, HI_BINOCULARS) )
{
ItemUse_Binoculars(ent);
if (ent->client->ps.zoomMode == 0)
{
G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 1);
}
else
{
G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 2);
}
}
break;
case GENCMD_ZOOM:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_BINOCULARS)) &&
G_ItemUsable(&ent->client->ps, HI_BINOCULARS) )
{
ItemUse_Binoculars(ent);
if (ent->client->ps.zoomMode == 0)
{
G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 1);
}
else
{
G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 2);
}
}
break;
case GENCMD_USE_SENTRY:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SENTRY_GUN)) &&
G_ItemUsable(&ent->client->ps, HI_SENTRY_GUN) )
{
ItemUse_Sentry(ent);
G_AddEvent(ent, EV_USE_ITEM0+HI_SENTRY_GUN, 0);
ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SENTRY_GUN);
}
break;
case GENCMD_SABERATTACKCYCLE:
Cmd_SaberAttackCycle_f(ent);
break;
default:
break;
}
// save results of pmove
if ( ent->client->ps.eventSequence != oldEventSequence ) {
ent->eventTime = level.time;
}
if (g_smoothClients.integer) {
BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qtrue );
}
else {
BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
}
SendPendingPredictableEvents( &ent->client->ps );
if ( !( ent->client->ps.eFlags & EF_FIRING ) ) {
client->fireHeld = qfalse; // for grapple
}
// use the snapped origin for linking so it matches client predicted versions
VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
VectorCopy (pm.mins, ent->r.mins);
VectorCopy (pm.maxs, ent->r.maxs);
ent->waterlevel = pm.waterlevel;
ent->watertype = pm.watertype;
// execute client events
ClientEvents( ent, oldEventSequence );
if ( pm.useEvent )
{
//TODO: Use
// TryUse( ent );
}
// link entity now, after any personal teleporters have been used
trap_LinkEntity (ent);
if ( !ent->client->noclip ) {
G_TouchTriggers( ent );
}
// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
//test for solid areas in the AAS file
// BotTestAAS(ent->r.currentOrigin);
// touch other objects
ClientImpacts( ent, &pm );
// save results of triggers and client events
if (ent->client->ps.eventSequence != oldEventSequence) {
ent->eventTime = level.time;
}
// swap and latch button actions
client->oldbuttons = client->buttons;
client->buttons = ucmd->buttons;
client->latched_buttons |= client->buttons & ~client->oldbuttons;
// Did we kick someone in our pmove sequence?
if (client->ps.forceKickFlip)
{
gentity_t *faceKicked = &g_entities[client->ps.forceKickFlip-1];
if (faceKicked && faceKicked->client && (!OnSameTeam(ent, faceKicked) || g_friendlyFire.integer) &&
(!faceKicked->client->ps.duelInProgress || faceKicked->client->ps.duelIndex == ent->s.number) &&
(!ent->client->ps.duelInProgress || ent->client->ps.duelIndex == faceKicked->s.number))
{
if ( faceKicked && faceKicked->client && faceKicked->health && faceKicked->takedamage )
{//push them away and do pain
vec3_t oppDir;
int strength = (int)VectorNormalize2( client->ps.velocity, oppDir );
strength *= 0.05;
VectorScale( oppDir, -1, oppDir );
G_Damage( faceKicked, ent, ent, oppDir, client->ps.origin, strength, DAMAGE_NO_ARMOR, MOD_MELEE );
if ( faceKicked->client->ps.weapon != WP_SABER ||
faceKicked->client->ps.fd.saberAnimLevel < FORCE_LEVEL_3 ||
(!BG_SaberInAttack(faceKicked->client->ps.saberMove) && !PM_SaberInStart(faceKicked->client->ps.saberMove) && !PM_SaberInReturn(faceKicked->client->ps.saberMove) && !PM_SaberInTransition(faceKicked->client->ps.saberMove)) )
{
if (faceKicked->health > 0 &&
faceKicked->client->ps.stats[STAT_HEALTH] > 0 &&
faceKicked->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN)
{
if (Q_irand(1, 10) <= 3)
{ //only actually knock over sometimes, but always do velocity hit
faceKicked->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
faceKicked->client->ps.forceHandExtendTime = level.time + 1100;
faceKicked->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
}
faceKicked->client->ps.otherKiller = ent->s.number;
faceKicked->client->ps.otherKillerTime = level.time + 5000;
faceKicked->client->ps.otherKillerDebounceTime = level.time + 100;
faceKicked->client->ps.velocity[0] = oppDir[0]*(strength*40);
faceKicked->client->ps.velocity[1] = oppDir[1]*(strength*40);
faceKicked->client->ps.velocity[2] = 200;
}
}
G_Sound( faceKicked, CHAN_AUTO, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
}
}
client->ps.forceKickFlip = 0;
}
// check for respawning
if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
// wait for the attack button to be pressed
if ( level.time > client->respawnTime && !gDoSlowMoDuel ) {
// forcerespawn is to prevent users from waiting out powerups
if ( g_forcerespawn.integer > 0 &&
( level.time - client->respawnTime ) > g_forcerespawn.integer * 1000 ) {
respawn( ent );
return;
}
// pressing attack or use is the normal respawn method
if ( ucmd->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) ) {
respawn( ent );
}
}
else if (gDoSlowMoDuel)
{
client->respawnTime = level.time + 1000;
}
return;
}
// perform once-a-second actions
ClientTimerActions( ent, msec );
G_UpdateClientBroadcasts ( ent );
}
/*
==============
ClientEndFrame
Called at the end of each server frame for each connected client
A fast client will have multiple ClientThink for each ClientEdFrame,
while a slow client may have multiple ClientEndFrame between ClientThink.
==============
*/
void ClientEndFrame( gentity_t *ent ) {
int i;
clientPersistant_t *pers;
if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
SpectatorClientEndFrame( ent );
return;
}
pers = &ent->client->pers;
// turn off any expired powerups
for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
if ( ent->client->ps.powerups[ i ] < level.time ) {
ent->client->ps.powerups[ i ] = 0;
}
}
// save network bandwidth
#if 0
if ( !g_synchronousClients->integer && (ent->client->ps.pm_type == PM_NORMAL || ent->client->ps.pm_type == PM_FLOAT) ) {
// FIXME: this must change eventually for non-sync demo recording
VectorClear( ent->client->ps.viewangles );
}
#endif
//
// If the end of unit layout is displayed, don't give
// the player any normal movement attributes
//
if ( level.intermissiontime ) {
return;
}
// burn from lava, etc
P_WorldEffects (ent);
// apply all the damage taken this frame
P_DamageFeedback (ent);
// add the EF_CONNECTION flag if we haven't gotten commands recently
if ( level.time - ent->client->lastCmdTime > 1000 ) {
ent->s.eFlags |= EF_CONNECTION;
} else {
ent->s.eFlags &= ~EF_CONNECTION;
}
ent->client->ps.stats[STAT_HEALTH] = ent->health; // FIXME: get rid of ent->health...
G_SetClientSound (ent);
// set the latest infor
if (g_smoothClients.integer) {
BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qtrue );
}
else {
BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
}
SendPendingPredictableEvents( &ent->client->ps );
// set the bit for the reachability area the client is currently in
// i = trap_AAS_PointReachabilityAreaIndex( ent->client->ps.origin );
// ent->client->areabits[i >> 3] |= 1 << (i & 7);
}
/*
==============
ClientThink
This will be called once for each client frame, which will
usually be a couple times for each server frame on fast clients.
If "g_synchronousClients 1" is set, this will be called exactly
once for each server frame, which makes for smooth demo recording.
==============
*/
void ClientThink_real( gentity_t *ent )
{
gclient_t *client;
pmove_t pm;
int oldEventSequence;
int msec;
usercmd_t *ucmd;
client = ent->client;
// don't think if the client is not yet connected (and thus not yet spawned in)
if( client->pers.connected != CON_CONNECTED )
return;
// mark the time, so the connection sprite can be removed
ucmd = &ent->client->pers.cmd;
// sanity check the command time to prevent speedup cheating
if( ucmd->serverTime > level.time + 200 )
{
ucmd->serverTime = level.time + 200;
// G_Printf("serverTime <<<<<\n" );
}
if( ucmd->serverTime < level.time - 1000 )
{
ucmd->serverTime = level.time - 1000;
// G_Printf("serverTime >>>>>\n" );
}
msec = ucmd->serverTime - client->ps.commandTime;
// following others may result in bad times, but we still want
// to check for follow toggles
if( msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW )
return;
if( msec > 200 )
msec = 200;
if( pmove_msec.integer < 8 )
trap_Cvar_Set( "pmove_msec", "8" );
else if( pmove_msec.integer > 33 )
trap_Cvar_Set( "pmove_msec", "33" );
if( pmove_fixed.integer || client->pers.pmoveFixed )
{
ucmd->serverTime = ( ( ucmd->serverTime + pmove_msec.integer - 1 ) / pmove_msec.integer ) * pmove_msec.integer;
//if (ucmd->serverTime - client->ps.commandTime <= 0)
// return;
}
//
// check for exiting intermission
//
if( level.intermissiontime )
{
ClientIntermissionThink( client );
return;
}
// spectators don't do much
if( client->sess.sessionTeam == TEAM_SPECTATOR )
{
if( client->sess.spectatorState == SPECTATOR_SCOREBOARD )
return;
SpectatorThink( ent, ucmd );
return;
}
G_UpdatePTRConnection( client );
// check for inactivity timer, but never drop the local client of a non-dedicated server
if( !ClientInactivityTimer( client ) )
return;
if( client->noclip )
client->ps.pm_type = PM_NOCLIP;
else if( client->ps.stats[ STAT_HEALTH ] <= 0 )
client->ps.pm_type = PM_DEAD;
else if( client->ps.stats[ STAT_STATE ] & SS_INFESTING ||
client->ps.stats[ STAT_STATE ] & SS_HOVELING )
client->ps.pm_type = PM_FREEZE;
else if( client->ps.stats[ STAT_STATE ] & SS_BLOBLOCKED ||
client->ps.stats[ STAT_STATE ] & SS_GRABBED )
client->ps.pm_type = PM_GRABBED;
else if( BG_InventoryContainsUpgrade( UP_JETPACK, client->ps.stats ) && BG_UpgradeIsActive( UP_JETPACK, client->ps.stats ) )
client->ps.pm_type = PM_JETPACK;
else
client->ps.pm_type = PM_NORMAL;
if( client->ps.stats[ STAT_STATE ] & SS_GRABBED &&
client->grabExpiryTime < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_GRABBED;
if( client->ps.stats[ STAT_STATE ] & SS_BLOBLOCKED &&
client->lastLockTime + 5000 < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_BLOBLOCKED;
if( client->ps.stats[ STAT_STATE ] & SS_SLOWLOCKED &&
client->lastLockTime + ABUILDER_BLOB_TIME < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_SLOWLOCKED;
client->ps.stats[ STAT_BOOSTTIME ] = level.time - client->lastBoostedTime;
if( client->ps.stats[ STAT_STATE ] & SS_BOOSTED &&
client->lastBoostedTime + BOOST_TIME < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_BOOSTED;
if( client->ps.stats[ STAT_STATE ] & SS_POISONCLOUDED &&
client->lastPoisonCloudedTime + LEVEL1_PCLOUD_TIME < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_POISONCLOUDED;
if( client->ps.stats[ STAT_STATE ] & SS_POISONED &&
client->lastPoisonTime + ALIEN_POISON_TIME < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_POISONED;
client->ps.gravity = g_gravity.value;
if( BG_InventoryContainsUpgrade( UP_MEDKIT, client->ps.stats ) &&
BG_UpgradeIsActive( UP_MEDKIT, client->ps.stats ) )
{
//if currently using a medkit or have no need for a medkit now
if( client->ps.stats[ STAT_STATE ] & SS_MEDKIT_ACTIVE ||
( client->ps.stats[ STAT_HEALTH ] == client->ps.stats[ STAT_MAX_HEALTH ] &&
!( client->ps.stats[ STAT_STATE ] & SS_POISONED ) ) )
{
BG_DeactivateUpgrade( UP_MEDKIT, client->ps.stats );
}
else if( client->ps.stats[ STAT_HEALTH ] > 0 )
{
//remove anti toxin
BG_DeactivateUpgrade( UP_MEDKIT, client->ps.stats );
BG_RemoveUpgradeFromInventory( UP_MEDKIT, client->ps.stats );
client->ps.stats[ STAT_STATE ] &= ~SS_POISONED;
client->poisonImmunityTime = level.time + MEDKIT_POISON_IMMUNITY_TIME;
client->ps.stats[ STAT_STATE ] |= SS_MEDKIT_ACTIVE;
client->lastMedKitTime = level.time;
client->medKitHealthToRestore =
client->ps.stats[ STAT_MAX_HEALTH ] - client->ps.stats[ STAT_HEALTH ];
client->medKitIncrementTime = level.time +
( MEDKIT_STARTUP_TIME / MEDKIT_STARTUP_SPEED );
G_AddEvent( ent, EV_MEDKIT_USED, 0 );
}
}
if( BG_InventoryContainsUpgrade( UP_GRENADE, client->ps.stats ) &&
BG_UpgradeIsActive( UP_GRENADE, client->ps.stats ) )
{
int lastWeapon = ent->s.weapon;
//remove grenade
BG_DeactivateUpgrade( UP_GRENADE, client->ps.stats );
BG_RemoveUpgradeFromInventory( UP_GRENADE, client->ps.stats );
//M-M-M-M-MONSTER HACK
ent->s.weapon = WP_GRENADE;
FireWeapon( ent );
ent->s.weapon = lastWeapon;
}
// set speed
client->ps.speed = g_speed.value * BG_FindSpeedForClass( client->ps.stats[ STAT_PCLASS ] );
if( client->lastCreepSlowTime + CREEP_TIMEOUT < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_CREEPSLOWED;
//randomly disable the jet pack if damaged
if( BG_InventoryContainsUpgrade( UP_JETPACK, client->ps.stats ) &&
BG_UpgradeIsActive( UP_JETPACK, client->ps.stats ) )
{
if( ent->lastDamageTime + JETPACK_DISABLE_TIME > level.time )
{
if( random( ) > JETPACK_DISABLE_CHANCE )
client->ps.pm_type = PM_NORMAL;
}
//switch jetpack off if no reactor
if( !level.reactorPresent )
BG_DeactivateUpgrade( UP_JETPACK, client->ps.stats );
}
// set up for pmove
oldEventSequence = client->ps.eventSequence;
memset( &pm, 0, sizeof( pm ) );
if( !( ucmd->buttons & BUTTON_TALK ) ) //&& client->ps.weaponTime <= 0 ) //TA: erk more server load
{
switch( client->ps.weapon )
{
case WP_ALEVEL0:
if( client->ps.weaponTime <= 0 )
pm.autoWeaponHit[ client->ps.weapon ] = CheckVenomAttack( ent );
break;
case WP_ALEVEL1:
case WP_ALEVEL1_UPG:
CheckGrabAttack( ent );
break;
case WP_ALEVEL3:
case WP_ALEVEL3_UPG:
if( client->ps.weaponTime <= 0 )
pm.autoWeaponHit[ client->ps.weapon ] = CheckPounceAttack( ent );
break;
default:
break;
}
}
if( ent->flags & FL_FORCE_GESTURE )
{
ent->flags &= ~FL_FORCE_GESTURE;
ent->client->pers.cmd.buttons |= BUTTON_GESTURE;
}
pm.ps = &client->ps;
pm.cmd = *ucmd;
if( pm.ps->pm_type == PM_DEAD )
pm.tracemask = MASK_PLAYERSOLID; // & ~CONTENTS_BODY;
if( pm.ps->stats[ STAT_STATE ] & SS_INFESTING ||
pm.ps->stats[ STAT_STATE ] & SS_HOVELING )
pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
else
pm.tracemask = MASK_PLAYERSOLID;
pm.trace = trap_Trace;
pm.pointcontents = trap_PointContents;
pm.debugLevel = g_debugMove.integer;
pm.noFootsteps = (qboolean)0;
pm.pmove_fixed = pmove_fixed.integer | client->pers.pmoveFixed;
pm.pmove_msec = pmove_msec.integer;
VectorCopy( client->ps.origin, client->oldOrigin );
// moved from after Pmove -- potentially the cause of
// future triggering bugs
if( !ent->client->noclip )
G_TouchTriggers( ent );
Pmove( &pm );
// save results of pmove
if( ent->client->ps.eventSequence != oldEventSequence )
ent->eventTime = level.time;
if( g_smoothClients.integer )
BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qtrue );
else
BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
SendPendingPredictableEvents( &ent->client->ps );
if( !( ent->client->ps.eFlags & EF_FIRING ) )
client->fireHeld = qfalse; // for grapple
if( !( ent->client->ps.eFlags & EF_FIRING2 ) )
client->fire2Held = qfalse;
// use the snapped origin for linking so it matches client predicted versions
VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
VectorCopy( pm.mins, ent->r.mins );
VectorCopy( pm.maxs, ent->r.maxs );
ent->waterlevel = pm.waterlevel;
ent->watertype = pm.watertype;
// execute client events
ClientEvents( ent, oldEventSequence );
// link entity now, after any personal teleporters have been used
trap_LinkEntity( ent );
// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
VectorCopy( ent->client->ps.origin, ent->s.origin );
// touch other objects
ClientImpacts( ent, &pm );
// save results of triggers and client events
if( ent->client->ps.eventSequence != oldEventSequence )
ent->eventTime = level.time;
// swap and latch button actions
client->oldbuttons = client->buttons;
client->buttons = ucmd->buttons;
client->latched_buttons |= client->buttons & ~client->oldbuttons;
if( ( client->buttons & BUTTON_GETFLAG ) && !( client->oldbuttons & BUTTON_GETFLAG ) &&
client->ps.stats[ STAT_HEALTH ] > 0 )
{
trace_t trace;
vec3_t view, point;
gentity_t *traceEnt;
if( client->ps.stats[ STAT_STATE ] & SS_HOVELING )
{
gentity_t *hovel = client->hovel;
//only let the player out if there is room
if( !AHovel_Blocked( hovel, ent, qtrue ) )
{
//prevent lerping
client->ps.eFlags ^= EF_TELEPORT_BIT;
client->ps.eFlags &= ~EF_NODRAW;
//client leaves hovel
client->ps.stats[ STAT_STATE ] &= ~SS_HOVELING;
//hovel is empty
G_setBuildableAnim( hovel, BANIM_ATTACK2, qfalse );
hovel->active = qfalse;
}
else
{
//exit is blocked
G_TriggerMenu( ent->client->ps.clientNum, MN_A_HOVEL_BLOCKED );
}
}
else
{
#define USE_OBJECT_RANGE 64
int entityList[ MAX_GENTITIES ];
vec3_t range = { USE_OBJECT_RANGE, USE_OBJECT_RANGE, USE_OBJECT_RANGE };
vec3_t mins, maxs;
int i, num;
//TA: look for object infront of player
AngleVectors( client->ps.viewangles, view, NULL, NULL );
VectorMA( client->ps.origin, USE_OBJECT_RANGE, view, point );
trap_Trace( &trace, client->ps.origin, NULL, NULL, point, ent->s.number, MASK_SHOT );
traceEnt = &g_entities[ trace.entityNum ];
if( traceEnt && traceEnt->biteam == client->ps.stats[ STAT_PTEAM ] && traceEnt->use )
traceEnt->use( traceEnt, ent, ent ); //other and activator are the same in this context
else
{
//no entity in front of player - do a small area search
VectorAdd( client->ps.origin, range, maxs );
VectorSubtract( client->ps.origin, range, mins );
num = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
for( i = 0; i < num; i++ )
{
traceEnt = &g_entities[ entityList[ i ] ];
if( traceEnt && traceEnt->biteam == client->ps.stats[ STAT_PTEAM ] && traceEnt->use )
{
traceEnt->use( traceEnt, ent, ent ); //other and activator are the same in this context
break;
}
}
if( i == num && client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
{
if( BG_UpgradeClassAvailable( &client->ps ) )
{
//no nearby objects and alien - show class menu
G_TriggerMenu( ent->client->ps.clientNum, MN_A_INFEST );
}
else
{
//flash frags
G_AddEvent( ent, EV_ALIEN_EVOLVE_FAILED, 0 );
}
}
}
}
}
// check for respawning
if( client->ps.stats[ STAT_HEALTH ] <= 0 )
{
// wait for the attack button to be pressed
if( level.time > client->respawnTime )
{
// forcerespawn is to prevent users from waiting out powerups
if( g_forcerespawn.integer > 0 &&
( level.time - client->respawnTime ) > 0 )
{
respawn( ent );
return;
}
// pressing attack or use is the normal respawn method
if( ucmd->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) )
{
respawn( ent );
}
}
return;
}
if( level.framenum > client->retriggerArmouryMenu && client->retriggerArmouryMenu )
{
G_TriggerMenu( client->ps.clientNum, MN_H_ARMOURY );
client->retriggerArmouryMenu = 0;
}
// Give clients some credit periodically
if( ent->client->lastKillTime + FREEKILL_PERIOD < level.time )
{
if( g_suddenDeathTime.integer &&
( level.time - level.startTime >= g_suddenDeathTime.integer * 60000 ) )
{
//gotta love logic like this eh?
}
else if( ent->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
G_AddCreditToClient( ent->client, FREEKILL_ALIEN, qtrue );
else if( ent->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )
G_AddCreditToClient( ent->client, FREEKILL_HUMAN, qtrue );
ent->client->lastKillTime = level.time;
}
// perform once-a-second actions
ClientTimerActions( ent, msec );
if( ent->suicideTime > 0 && ent->suicideTime < level.time )
{
ent->flags &= ~FL_GODMODE;
ent->client->ps.stats[ STAT_HEALTH ] = ent->health = 0;
player_die( ent, ent, ent, 100000, MOD_SUICIDE );
ent->suicideTime = 0;
}
}
