mirror of
https://github.com/w23/xash3d-fwgs
synced 2024-12-16 14:10:11 +01:00
1424 lines
37 KiB
C
1424 lines
37 KiB
C
/*
|
|
cl_pmove.c - client-side player physic
|
|
Copyright (C) 2010 Uncle Mike
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "common.h"
|
|
#include "client.h"
|
|
#include "const.h"
|
|
#include "cl_tent.h"
|
|
#include "pm_local.h"
|
|
#include "particledef.h"
|
|
#include "studio.h"
|
|
|
|
#define MAX_FORWARD 6 // forward probes for set idealpitch
|
|
#define MIN_CORRECTION_DISTANCE 0.25f // use smoothing if error is > this
|
|
#define MIN_PREDICTION_EPSILON 0.5f // complain if error is > this and we have cl_showerror set
|
|
#define MAX_PREDICTION_ERROR 64.0f // above this is assumed to be a teleport, don't smooth, etc.
|
|
|
|
/*
|
|
=============
|
|
CL_ClearPhysEnts
|
|
|
|
=============
|
|
*/
|
|
void CL_ClearPhysEnts( void )
|
|
{
|
|
clgame.pmove->numtouch = 0;
|
|
clgame.pmove->numvisent = 0;
|
|
clgame.pmove->nummoveent = 0;
|
|
clgame.pmove->numphysent = 0;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_PushPMStates
|
|
|
|
=============
|
|
*/
|
|
void CL_PushPMStates( void )
|
|
{
|
|
if( clgame.pushed ) return;
|
|
clgame.oldphyscount = clgame.pmove->numphysent;
|
|
clgame.oldviscount = clgame.pmove->numvisent;
|
|
clgame.pushed = true;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_PopPMStates
|
|
|
|
=============
|
|
*/
|
|
void CL_PopPMStates( void )
|
|
{
|
|
if( !clgame.pushed ) return;
|
|
clgame.pmove->numphysent = clgame.oldphyscount;
|
|
clgame.pmove->numvisent = clgame.oldviscount;
|
|
clgame.pushed = false;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_PushTraceBounds
|
|
|
|
=============
|
|
*/
|
|
void CL_PushTraceBounds( int hullnum, const float *mins, const float *maxs )
|
|
{
|
|
hullnum = bound( 0, hullnum, 3 );
|
|
VectorCopy( mins, clgame.pmove->player_mins[hullnum] );
|
|
VectorCopy( maxs, clgame.pmove->player_maxs[hullnum] );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_PopTraceBounds
|
|
|
|
=============
|
|
*/
|
|
void CL_PopTraceBounds( void )
|
|
{
|
|
memcpy( clgame.pmove->player_mins, host.player_mins, sizeof( host.player_mins ));
|
|
memcpy( clgame.pmove->player_maxs, host.player_maxs, sizeof( host.player_maxs ));
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CL_IsPredicted
|
|
===============
|
|
*/
|
|
qboolean CL_IsPredicted( void )
|
|
{
|
|
if( cl_nopred->value || cl.intermission )
|
|
return false;
|
|
|
|
// never predict the quake demos
|
|
if( cls.demoplayback == DEMO_QUAKE1 )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CL_SetLastUpdate
|
|
===============
|
|
*/
|
|
void CL_SetLastUpdate( void )
|
|
{
|
|
cls.lastupdate_sequence = cls.netchan.incoming_sequence;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CL_RedoPrediction
|
|
===============
|
|
*/
|
|
void CL_RedoPrediction( void )
|
|
{
|
|
if ( cls.netchan.incoming_sequence != cls.lastupdate_sequence )
|
|
{
|
|
CL_PredictMovement( true );
|
|
CL_CheckPredictionError();
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CL_SetIdealPitch
|
|
===============
|
|
*/
|
|
void CL_SetIdealPitch( void )
|
|
{
|
|
float angleval, sinval, cosval;
|
|
int i, j, step, dir, steps;
|
|
float z[MAX_FORWARD];
|
|
vec3_t top, bottom;
|
|
pmtrace_t tr;
|
|
|
|
if( cl.local.onground == -1 )
|
|
return;
|
|
|
|
angleval = cl.viewangles[YAW] * M_PI2 / 360.0f;
|
|
SinCos( angleval, &sinval, &cosval );
|
|
|
|
// Now move forward by 36, 48, 60, etc. units from the eye position and drop lines straight down
|
|
// 160 or so units to see what's below
|
|
for( i = 0; i < MAX_FORWARD; i++ )
|
|
{
|
|
top[0] = cl.simorg[0] + cosval * (i + 3.0f) * 12.0f;
|
|
top[1] = cl.simorg[1] + sinval * (i + 3.0f) * 12.0f;
|
|
top[2] = cl.simorg[2] + cl.viewheight[2];
|
|
|
|
bottom[0] = top[0];
|
|
bottom[1] = top[1];
|
|
bottom[2] = top[2] - 160.0f;
|
|
|
|
// skip any monsters (only world and brush models)
|
|
tr = CL_TraceLine( top, bottom, PM_STUDIO_BOX );
|
|
if( tr.allsolid ) return; // looking at a wall, leave ideal the way is was
|
|
|
|
if( tr.fraction == 1.0f )
|
|
return; // near a dropoff
|
|
|
|
z[i] = top[2] + tr.fraction * (bottom[2] - top[2]);
|
|
}
|
|
|
|
dir = 0;
|
|
steps = 0;
|
|
|
|
for( j = 1; j < i; j++ )
|
|
{
|
|
step = z[j] - z[j-1];
|
|
if( step > -ON_EPSILON && step < ON_EPSILON )
|
|
continue;
|
|
|
|
if( dir && ( step-dir > ON_EPSILON || step-dir < -ON_EPSILON ))
|
|
return; // mixed changes
|
|
|
|
steps++;
|
|
dir = step;
|
|
}
|
|
|
|
if( !dir )
|
|
{
|
|
cl.local.idealpitch = 0.0f;
|
|
return;
|
|
}
|
|
|
|
if( steps < 2 ) return;
|
|
cl.local.idealpitch = -dir * cl_idealpitchscale->value;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
CL_PlayerTeleported
|
|
|
|
check for instant movement in case
|
|
we don't want interpolate this
|
|
==================
|
|
*/
|
|
qboolean CL_PlayerTeleported( local_state_t *from, local_state_t *to )
|
|
{
|
|
int len, maxlen;
|
|
vec3_t delta;
|
|
|
|
VectorSubtract( to->playerstate.origin, from->playerstate.origin, delta );
|
|
|
|
// compute potential max movement in units per frame and compare with entity movement
|
|
maxlen = ( clgame.movevars.maxvelocity * ( 1.0 / GAME_FPS ));
|
|
len = VectorLength( delta );
|
|
|
|
return (len > maxlen);
|
|
}
|
|
|
|
/*
|
|
===================
|
|
CL_CheckPredictionError
|
|
===================
|
|
*/
|
|
void CL_CheckPredictionError( void )
|
|
{
|
|
int frame, cmd;
|
|
static int pos = 0;
|
|
vec3_t delta;
|
|
float dist;
|
|
|
|
if( !CL_IsPredicted( ))
|
|
return;
|
|
|
|
// calculate the last usercmd_t we sent that the server has processed
|
|
frame = ( cls.netchan.incoming_acknowledged ) & CL_UPDATE_MASK;
|
|
cmd = cl.parsecountmod;
|
|
|
|
// compare what the server returned with what we had predicted it to be
|
|
VectorSubtract( cl.frames[cmd].playerstate[cl.playernum].origin, cl.local.predicted_origins[frame], delta );
|
|
dist = VectorLength( delta );
|
|
|
|
// save the prediction error for interpolation
|
|
if( dist > MAX_PREDICTION_ERROR )
|
|
{
|
|
if( cl_showerror->value && host_developer.value )
|
|
Con_NPrintf( 10 + ( ++pos & 3 ), "^3player teleported:^7 %.3f units\n", dist );
|
|
|
|
// a teleport or something or gamepaused
|
|
VectorClear( cl.local.prediction_error );
|
|
}
|
|
else
|
|
{
|
|
if( cl_showerror->value && dist > MIN_PREDICTION_EPSILON && host_developer.value )
|
|
Con_NPrintf( 10 + ( ++pos & 3 ), "^1prediction error:^7 %.3f units\n", dist );
|
|
|
|
VectorCopy( cl.frames[cmd].playerstate[cl.playernum].origin, cl.local.predicted_origins[frame] );
|
|
|
|
// save for error interpolation
|
|
VectorCopy( delta, cl.local.prediction_error );
|
|
|
|
if( dist > MIN_CORRECTION_DISTANCE )
|
|
cls.correction_time = cl_smoothtime->value;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_SetUpPlayerPrediction
|
|
|
|
Calculate the new position of players, without other player clipping
|
|
We do this to set up real player prediction.
|
|
Players are predicted twice, first without clipping other players,
|
|
then with clipping against them.
|
|
This sets up the first phase.
|
|
=============
|
|
*/
|
|
void CL_SetUpPlayerPrediction( int dopred, int bIncludeLocalClient )
|
|
{
|
|
entity_state_t *state;
|
|
predicted_player_t *player;
|
|
cl_entity_t *ent;
|
|
int i;
|
|
|
|
for( i = 0; i < MAX_CLIENTS; i++ )
|
|
{
|
|
state = &cl.frames[cl.parsecountmod].playerstate[i];
|
|
player = &cls.predicted_players[i];
|
|
|
|
player->active = false;
|
|
|
|
if( state->messagenum != cl.parsecount )
|
|
continue; // not present this frame
|
|
|
|
if( !state->modelindex )
|
|
continue;
|
|
|
|
player->active = true;
|
|
player->movetype = state->movetype;
|
|
player->solid = state->solid;
|
|
player->usehull = state->usehull;
|
|
|
|
if( FBitSet( state->effects, EF_NODRAW ) && !bIncludeLocalClient && ( cl.playernum == i ))
|
|
continue;
|
|
|
|
// note that the local player is special, since he moves locally
|
|
// we use his last predicted postition
|
|
if( cl.playernum == i )
|
|
{
|
|
VectorCopy( state->origin, player->origin );
|
|
VectorCopy( state->angles, player->angles );
|
|
}
|
|
else
|
|
{
|
|
ent = CL_GetEntityByIndex( i + 1 );
|
|
|
|
CL_ComputePlayerOrigin( ent );
|
|
|
|
VectorCopy( ent->origin, player->origin );
|
|
VectorCopy( ent->angles, player->angles );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CL_ClipPMoveToEntity( physent_t *pe, const vec3_t start, vec3_t mins, vec3_t maxs, const vec3_t end, pmtrace_t *tr )
|
|
{
|
|
Assert( tr != NULL );
|
|
|
|
if( clgame.dllFuncs.pfnClipMoveToEntity != NULL )
|
|
{
|
|
// do custom sweep test
|
|
clgame.dllFuncs.pfnClipMoveToEntity( pe, start, mins, maxs, end, tr );
|
|
}
|
|
else
|
|
{
|
|
// function is missed, so we didn't hit anything
|
|
tr->allsolid = false;
|
|
}
|
|
}
|
|
|
|
static void CL_CopyEntityToPhysEnt( physent_t *pe, entity_state_t *state, qboolean visent )
|
|
{
|
|
model_t *mod = CL_ModelHandle( state->modelindex );
|
|
|
|
pe->player = 0;
|
|
|
|
if( state->number >= 1 && state->number <= cl.maxclients )
|
|
pe->player = state->number;
|
|
|
|
if( pe->player )
|
|
{
|
|
// client or bot
|
|
Q_snprintf( pe->name, sizeof( pe->name ), "player %i", pe->player - 1 );
|
|
}
|
|
else
|
|
{
|
|
// otherwise copy the modelname
|
|
Q_strncpy( pe->name, mod->name, sizeof( pe->name ));
|
|
}
|
|
|
|
pe->model = pe->studiomodel = NULL;
|
|
|
|
VectorCopy( state->mins, pe->mins );
|
|
VectorCopy( state->maxs, pe->maxs );
|
|
|
|
if( state->solid == SOLID_BBOX )
|
|
{
|
|
if( FBitSet( mod->flags, STUDIO_TRACE_HITBOX ))
|
|
pe->studiomodel = mod;
|
|
}
|
|
else
|
|
{
|
|
if( pe->solid != SOLID_BSP && ( mod != NULL ) && ( mod->type == mod_studio ))
|
|
pe->studiomodel = mod;
|
|
else pe->model = mod;
|
|
}
|
|
|
|
// rare case: not solid entities in vistrace
|
|
if( visent && VectorIsNull( pe->mins ))
|
|
{
|
|
VectorCopy( mod->mins, pe->mins );
|
|
VectorCopy( mod->maxs, pe->maxs );
|
|
}
|
|
|
|
pe->info = state->number;
|
|
VectorCopy( state->origin, pe->origin );
|
|
VectorCopy( state->angles, pe->angles );
|
|
|
|
pe->solid = state->solid;
|
|
pe->rendermode = state->rendermode;
|
|
pe->skin = state->skin;
|
|
pe->frame = state->frame;
|
|
pe->sequence = state->sequence;
|
|
|
|
memcpy( &pe->controller[0], &state->controller[0], sizeof( pe->controller ));
|
|
memcpy( &pe->blending[0], &state->blending[0], sizeof( pe->blending ));
|
|
|
|
pe->movetype = state->movetype;
|
|
pe->takedamage = (pe->player) ? DAMAGE_YES : DAMAGE_NO;
|
|
pe->team = state->team;
|
|
pe->classnumber = state->playerclass;
|
|
pe->blooddecal = 0; // unused in GoldSrc
|
|
|
|
// for mods
|
|
pe->iuser1 = state->iuser1;
|
|
pe->iuser2 = state->iuser2;
|
|
pe->iuser3 = state->iuser3;
|
|
pe->iuser4 = state->iuser4;
|
|
pe->fuser1 = state->fuser1;
|
|
pe->fuser2 = state->fuser2;
|
|
pe->fuser3 = state->fuser3;
|
|
pe->fuser4 = state->fuser4;
|
|
|
|
VectorCopy( state->vuser1, pe->vuser1 );
|
|
VectorCopy( state->vuser2, pe->vuser2 );
|
|
VectorCopy( state->vuser3, pe->vuser3 );
|
|
VectorCopy( state->vuser4, pe->vuser4 );
|
|
}
|
|
|
|
/*
|
|
====================
|
|
CL_AddLinksToPmove
|
|
|
|
collect solid entities
|
|
====================
|
|
*/
|
|
void CL_AddLinksToPmove( frame_t *frame )
|
|
{
|
|
entity_state_t *state;
|
|
model_t *model;
|
|
physent_t *pe;
|
|
int i;
|
|
|
|
if( !frame->valid ) return;
|
|
|
|
for( i = 0; i < frame->num_entities; i++ )
|
|
{
|
|
state = &cls.packet_entities[(frame->first_entity + i) % cls.num_client_entities];
|
|
|
|
if( state->number >= 1 && state->number <= cl.maxclients )
|
|
continue;
|
|
|
|
if( !state->modelindex )
|
|
continue;
|
|
|
|
model = CL_ModelHandle( state->modelindex );
|
|
if( !model ) continue;
|
|
|
|
if(( state->owner != 0 ) && ( state->owner == cl.playernum + 1 ))
|
|
continue;
|
|
|
|
if(( model->hulls[1].lastclipnode || model->type == mod_studio ) && clgame.pmove->numvisent < MAX_PHYSENTS )
|
|
{
|
|
pe = &clgame.pmove->visents[clgame.pmove->numvisent];
|
|
CL_CopyEntityToPhysEnt( pe, state, true );
|
|
clgame.pmove->numvisent++;
|
|
}
|
|
|
|
if( state->solid == SOLID_TRIGGER || ( state->solid == SOLID_NOT && state->skin >= CONTENTS_EMPTY ))
|
|
continue;
|
|
|
|
// dead body
|
|
if( state->mins[2] == 0.0f && state->maxs[2] == 1.0f )
|
|
continue;
|
|
|
|
// can't collide with zeroed hull
|
|
if( VectorIsNull( state->mins ) && VectorIsNull( state->maxs ))
|
|
continue;
|
|
|
|
if( state->solid == SOLID_NOT && state->skin < CONTENTS_EMPTY )
|
|
{
|
|
if( clgame.pmove->nummoveent >= MAX_MOVEENTS )
|
|
continue;
|
|
|
|
pe = &clgame.pmove->moveents[clgame.pmove->nummoveent];
|
|
CL_CopyEntityToPhysEnt( pe, state, false );
|
|
clgame.pmove->nummoveent++;
|
|
}
|
|
else
|
|
{
|
|
if( !model->hulls[1].lastclipnode && model->type != mod_studio )
|
|
continue;
|
|
|
|
// reserve slots for all the clients
|
|
if( clgame.pmove->numphysent >= ( MAX_PHYSENTS - cl.maxclients ))
|
|
continue;
|
|
|
|
pe = &clgame.pmove->physents[clgame.pmove->numphysent];
|
|
CL_CopyEntityToPhysEnt( pe, state, false );
|
|
clgame.pmove->numphysent++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CL_SetSolidEntities
|
|
|
|
Builds all the pmove physents for the current frame
|
|
===============
|
|
*/
|
|
void CL_SetSolidEntities( void )
|
|
{
|
|
physent_t *pe = clgame.pmove->physents;
|
|
|
|
// setup physents
|
|
clgame.pmove->numvisent = 1;
|
|
clgame.pmove->numphysent = 1;
|
|
clgame.pmove->nummoveent = 0;
|
|
|
|
memset( clgame.pmove->physents, 0, sizeof( physent_t ));
|
|
memset( clgame.pmove->visents, 0, sizeof( physent_t ));
|
|
|
|
pe->model = cl.worldmodel;
|
|
if( pe->model ) Q_strncpy( pe->name, pe->model->name, sizeof( pe->name ));
|
|
pe->takedamage = DAMAGE_YES;
|
|
pe->solid = SOLID_BSP;
|
|
|
|
// share to visents
|
|
clgame.pmove->visents[0] = clgame.pmove->physents[0];
|
|
|
|
// add all other entities exlucde players
|
|
CL_AddLinksToPmove( &cl.frames[cl.parsecountmod] );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CL_SetSolidPlayers
|
|
|
|
Builds all the pmove physents for the current frame
|
|
Note that CL_SetUpPlayerPrediction() must be called first!
|
|
pmove must be setup with world and solid entity hulls before calling
|
|
(via CL_PredictMove)
|
|
===============
|
|
*/
|
|
void CL_SetSolidPlayers( int playernum )
|
|
{
|
|
entity_state_t *state;
|
|
predicted_player_t *player;
|
|
physent_t *pe;
|
|
int i;
|
|
|
|
if( !cl_solid_players->value )
|
|
return;
|
|
|
|
for( i = 0; i < MAX_CLIENTS; i++ )
|
|
{
|
|
state = &cl.frames[cl.parsecountmod].playerstate[i];
|
|
player = &cls.predicted_players[i];
|
|
|
|
if( playernum == -1 )
|
|
{
|
|
if( i != cl.playernum && !player->active )
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if( !player->active )
|
|
continue; // not present this frame
|
|
|
|
// the player object never gets added
|
|
if( playernum == i )
|
|
continue;
|
|
}
|
|
|
|
if( player->solid == SOLID_NOT )
|
|
continue; // dead body
|
|
|
|
if( clgame.pmove->numphysent >= MAX_PHYSENTS )
|
|
break;
|
|
|
|
pe = &clgame.pmove->physents[clgame.pmove->numphysent];
|
|
CL_CopyEntityToPhysEnt( pe, state, false );
|
|
clgame.pmove->numphysent++;
|
|
|
|
// some fields needs to be override from cls.predicted_players
|
|
VectorCopy( player->origin, pe->origin );
|
|
VectorCopy( player->angles, pe->angles );
|
|
VectorCopy( clgame.pmove->player_mins[player->usehull], pe->mins );
|
|
VectorCopy( clgame.pmove->player_maxs[player->usehull], pe->maxs );
|
|
pe->movetype = player->movetype;
|
|
pe->solid = player->solid;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_TruePointContents
|
|
|
|
=============
|
|
*/
|
|
int CL_TruePointContents( const vec3_t p )
|
|
{
|
|
int i, contents;
|
|
int oldhull;
|
|
hull_t *hull;
|
|
vec3_t test, offset;
|
|
physent_t *pe;
|
|
|
|
// sanity check
|
|
if( !p ) return CONTENTS_NONE;
|
|
|
|
oldhull = clgame.pmove->usehull;
|
|
|
|
// get base contents from world
|
|
contents = PM_HullPointContents( &cl.worldmodel->hulls[0], 0, p );
|
|
|
|
for( i = 0; i < clgame.pmove->nummoveent; i++ )
|
|
{
|
|
pe = &clgame.pmove->moveents[i];
|
|
|
|
if( pe->solid != SOLID_NOT ) // disabled ?
|
|
continue;
|
|
|
|
// only brushes can have special contents
|
|
if( !pe->model || pe->model->type != mod_brush )
|
|
continue;
|
|
|
|
// check water brushes accuracy
|
|
clgame.pmove->usehull = 2;
|
|
hull = PM_HullForBsp( pe, clgame.pmove, offset );
|
|
clgame.pmove->usehull = oldhull;
|
|
|
|
// offset the test point appropriately for this hull.
|
|
VectorSubtract( p, offset, test );
|
|
|
|
if( FBitSet( pe->model->flags, MODEL_HAS_ORIGIN ) && !VectorIsNull( pe->angles ))
|
|
{
|
|
matrix4x4 matrix;
|
|
|
|
Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
|
|
Matrix4x4_VectorITransform( matrix, p, test );
|
|
}
|
|
|
|
// test hull for intersection with this model
|
|
if( PM_HullPointContents( hull, hull->firstclipnode, test ) == CONTENTS_EMPTY )
|
|
continue;
|
|
|
|
// compare contents ranking
|
|
if( RankForContents( pe->skin ) > RankForContents( contents ))
|
|
contents = pe->skin; // new content has more priority
|
|
}
|
|
|
|
return contents;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_WaterEntity
|
|
|
|
=============
|
|
*/
|
|
int CL_WaterEntity( const float *rgflPos )
|
|
{
|
|
physent_t *pe;
|
|
hull_t *hull;
|
|
vec3_t test, offset;
|
|
int i, oldhull;
|
|
|
|
if( !rgflPos ) return -1;
|
|
|
|
oldhull = clgame.pmove->usehull;
|
|
|
|
for( i = 0; i < clgame.pmove->nummoveent; i++ )
|
|
{
|
|
pe = &clgame.pmove->moveents[i];
|
|
|
|
if( pe->solid != SOLID_NOT ) // disabled ?
|
|
continue;
|
|
|
|
// only brushes can have special contents
|
|
if( !pe->model || pe->model->type != mod_brush )
|
|
continue;
|
|
|
|
// check water brushes accuracy
|
|
clgame.pmove->usehull = 2;
|
|
hull = PM_HullForBsp( pe, clgame.pmove, offset );
|
|
clgame.pmove->usehull = oldhull;
|
|
|
|
// offset the test point appropriately for this hull.
|
|
VectorSubtract( rgflPos, offset, test );
|
|
|
|
if( FBitSet( pe->model->flags, MODEL_HAS_ORIGIN ) && !VectorIsNull( pe->angles ))
|
|
{
|
|
matrix4x4 matrix;
|
|
|
|
Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
|
|
Matrix4x4_VectorITransform( matrix, rgflPos, test );
|
|
}
|
|
|
|
// test hull for intersection with this model
|
|
if( PM_HullPointContents( hull, hull->firstclipnode, test ) == CONTENTS_EMPTY )
|
|
continue;
|
|
|
|
// found water entity
|
|
return pe->info;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_TraceLine
|
|
|
|
a simple engine traceline
|
|
=============
|
|
*/
|
|
pmtrace_t CL_TraceLine( vec3_t start, vec3_t end, int flags )
|
|
{
|
|
int old_usehull;
|
|
pmtrace_t tr;
|
|
|
|
old_usehull = clgame.pmove->usehull;
|
|
clgame.pmove->usehull = 2;
|
|
tr = PM_PlayerTraceExt( clgame.pmove, start, end, flags, clgame.pmove->numphysent, clgame.pmove->physents, -1, NULL );
|
|
clgame.pmove->usehull = old_usehull;
|
|
|
|
return tr;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_VisTraceLine
|
|
|
|
trace by visible objects (thats can be non-solid)
|
|
=============
|
|
*/
|
|
pmtrace_t *CL_VisTraceLine( vec3_t start, vec3_t end, int flags )
|
|
{
|
|
int old_usehull;
|
|
static pmtrace_t tr;
|
|
|
|
old_usehull = clgame.pmove->usehull;
|
|
clgame.pmove->usehull = 2;
|
|
tr = PM_PlayerTraceExt( clgame.pmove, start, end, flags, clgame.pmove->numvisent, clgame.pmove->visents, -1, NULL );
|
|
clgame.pmove->usehull = old_usehull;
|
|
|
|
return &tr;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CL_GetWaterEntity
|
|
|
|
returns water brush where inside pos
|
|
=============
|
|
*/
|
|
cl_entity_t *CL_GetWaterEntity( const float *rgflPos )
|
|
{
|
|
int entnum;
|
|
|
|
entnum = CL_WaterEntity( rgflPos );
|
|
if( entnum <= 0 ) return NULL; // world or not water
|
|
|
|
return CL_GetEntityByIndex( entnum );
|
|
}
|
|
|
|
int CL_TestLine( const vec3_t start, const vec3_t end, int flags )
|
|
{
|
|
return PM_TestLineExt( clgame.pmove, clgame.pmove->physents, clgame.pmove->numphysent, start, end, flags );
|
|
}
|
|
|
|
static int pfnTestPlayerPosition( float *pos, pmtrace_t *ptrace )
|
|
{
|
|
return PM_TestPlayerPosition( clgame.pmove, pos, ptrace, NULL );
|
|
}
|
|
|
|
static void pfnStuckTouch( int hitent, pmtrace_t *tr )
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < clgame.pmove->numtouch; i++ )
|
|
{
|
|
if( clgame.pmove->touchindex[i].ent == hitent )
|
|
return;
|
|
}
|
|
|
|
if( clgame.pmove->numtouch >= MAX_PHYSENTS )
|
|
return;
|
|
|
|
VectorCopy( clgame.pmove->velocity, tr->deltavelocity );
|
|
tr->ent = hitent;
|
|
|
|
clgame.pmove->touchindex[clgame.pmove->numtouch++] = *tr;
|
|
}
|
|
|
|
static int pfnPointContents( float *p, int *truecontents )
|
|
{
|
|
int cont, truecont;
|
|
|
|
truecont = cont = CL_TruePointContents( p );
|
|
if( truecontents ) *truecontents = truecont;
|
|
|
|
if( cont <= CONTENTS_CURRENT_0 && cont >= CONTENTS_CURRENT_DOWN )
|
|
cont = CONTENTS_WATER;
|
|
return cont;
|
|
}
|
|
|
|
static int pfnTruePointContents( float *p )
|
|
{
|
|
return CL_TruePointContents( p );
|
|
}
|
|
|
|
static int pfnHullPointContents( struct hull_s *hull, int num, float *p )
|
|
{
|
|
return PM_HullPointContents( hull, num, p );
|
|
}
|
|
|
|
static pmtrace_t pfnPlayerTrace( float *start, float *end, int traceFlags, int ignore_pe )
|
|
{
|
|
return PM_PlayerTraceExt( clgame.pmove, start, end, traceFlags, clgame.pmove->numphysent, clgame.pmove->physents, ignore_pe, NULL );
|
|
}
|
|
|
|
static pmtrace_t *pfnTraceLine( float *start, float *end, int flags, int usehull, int ignore_pe )
|
|
{
|
|
static pmtrace_t tr;
|
|
int old_usehull;
|
|
|
|
old_usehull = clgame.pmove->usehull;
|
|
clgame.pmove->usehull = usehull;
|
|
|
|
switch( flags )
|
|
{
|
|
case PM_TRACELINE_PHYSENTSONLY:
|
|
tr = PM_PlayerTraceExt( clgame.pmove, start, end, 0, clgame.pmove->numphysent, clgame.pmove->physents, ignore_pe, NULL );
|
|
break;
|
|
case PM_TRACELINE_ANYVISIBLE:
|
|
tr = PM_PlayerTraceExt( clgame.pmove, start, end, 0, clgame.pmove->numvisent, clgame.pmove->visents, ignore_pe, NULL );
|
|
break;
|
|
}
|
|
|
|
clgame.pmove->usehull = old_usehull;
|
|
|
|
return &tr;
|
|
}
|
|
|
|
static hull_t *pfnHullForBsp( physent_t *pe, float *offset )
|
|
{
|
|
return PM_HullForBsp( pe, clgame.pmove, offset );
|
|
}
|
|
|
|
static float pfnTraceModel( physent_t *pe, float *start, float *end, trace_t *trace )
|
|
{
|
|
int old_usehull;
|
|
vec3_t start_l, end_l;
|
|
vec3_t offset, temp;
|
|
qboolean rotated;
|
|
matrix4x4 matrix;
|
|
hull_t *hull;
|
|
|
|
old_usehull = clgame.pmove->usehull;
|
|
clgame.pmove->usehull = 2;
|
|
|
|
hull = PM_HullForBsp( pe, clgame.pmove, offset );
|
|
|
|
clgame.pmove->usehull = old_usehull;
|
|
|
|
if( pe->solid == SOLID_BSP && !VectorIsNull( pe->angles ))
|
|
rotated = true;
|
|
else rotated = false;
|
|
|
|
if( rotated )
|
|
{
|
|
Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
|
|
Matrix4x4_VectorITransform( matrix, start, start_l );
|
|
Matrix4x4_VectorITransform( matrix, end, end_l );
|
|
}
|
|
else
|
|
{
|
|
VectorSubtract( start, offset, start_l );
|
|
VectorSubtract( end, offset, end_l );
|
|
}
|
|
|
|
PM_RecursiveHullCheck( hull, hull->firstclipnode, 0, 1, start_l, end_l, (pmtrace_t *)trace );
|
|
trace->ent = NULL;
|
|
|
|
if( rotated )
|
|
{
|
|
VectorCopy( trace->plane.normal, temp );
|
|
Matrix4x4_TransformPositivePlane( matrix, temp, trace->plane.dist, trace->plane.normal, &trace->plane.dist );
|
|
}
|
|
|
|
VectorLerp( start, trace->fraction, end, trace->endpos );
|
|
|
|
return trace->fraction;
|
|
}
|
|
|
|
static const char *pfnTraceTexture( int ground, float *vstart, float *vend )
|
|
{
|
|
physent_t *pe;
|
|
|
|
if( ground < 0 || ground >= clgame.pmove->numphysent )
|
|
return NULL; // bad ground
|
|
|
|
pe = &clgame.pmove->physents[ground];
|
|
return PM_TraceTexture( pe, vstart, vend );
|
|
}
|
|
|
|
static void pfnPlaySound( int channel, const char *sample, float volume, float attenuation, int fFlags, int pitch )
|
|
{
|
|
if( !clgame.pmove->runfuncs )
|
|
return;
|
|
|
|
S_StartSound( NULL, clgame.pmove->player_index + 1, channel, S_RegisterSound( sample ), volume, attenuation, pitch, fFlags );
|
|
}
|
|
|
|
static void pfnPlaybackEventFull( int flags, int clientindex, word eventindex, float delay, float *origin,
|
|
float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 )
|
|
{
|
|
CL_PlaybackEvent( flags, NULL, eventindex, delay, origin, angles, fparam1, fparam2, iparam1, iparam2, bparam1, bparam2 );
|
|
}
|
|
|
|
static pmtrace_t pfnPlayerTraceEx( float *start, float *end, int traceFlags, pfnIgnore pmFilter )
|
|
{
|
|
return PM_PlayerTraceExt( clgame.pmove, start, end, traceFlags, clgame.pmove->numphysent, clgame.pmove->physents, -1, pmFilter );
|
|
}
|
|
|
|
static int pfnTestPlayerPositionEx( float *pos, pmtrace_t *ptrace, pfnIgnore pmFilter )
|
|
{
|
|
return PM_TestPlayerPosition( clgame.pmove, pos, ptrace, pmFilter );
|
|
}
|
|
|
|
static pmtrace_t *pfnTraceLineEx( float *start, float *end, int flags, int usehull, pfnIgnore pmFilter )
|
|
{
|
|
static pmtrace_t tr;
|
|
int old_usehull;
|
|
|
|
old_usehull = clgame.pmove->usehull;
|
|
clgame.pmove->usehull = usehull;
|
|
|
|
switch( flags )
|
|
{
|
|
case PM_TRACELINE_PHYSENTSONLY:
|
|
tr = PM_PlayerTraceExt( clgame.pmove, start, end, 0, clgame.pmove->numphysent, clgame.pmove->physents, -1, pmFilter );
|
|
break;
|
|
case PM_TRACELINE_ANYVISIBLE:
|
|
tr = PM_PlayerTraceExt( clgame.pmove, start, end, 0, clgame.pmove->numvisent, clgame.pmove->visents, -1, pmFilter );
|
|
break;
|
|
}
|
|
|
|
clgame.pmove->usehull = old_usehull;
|
|
|
|
return &tr;
|
|
}
|
|
|
|
static struct msurface_s *pfnTraceSurface( int ground, float *vstart, float *vend )
|
|
{
|
|
physent_t *pe;
|
|
|
|
if( ground < 0 || ground >= clgame.pmove->numphysent )
|
|
return NULL; // bad ground
|
|
|
|
pe = &clgame.pmove->physents[ground];
|
|
return PM_TraceSurface( pe, vstart, vend );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CL_InitClientMove
|
|
|
|
===============
|
|
*/
|
|
void CL_InitClientMove( void )
|
|
{
|
|
int i;
|
|
|
|
Pmove_Init ();
|
|
|
|
clgame.pmove->server = false; // running at client
|
|
clgame.pmove->movevars = &clgame.movevars;
|
|
clgame.pmove->runfuncs = false;
|
|
|
|
// enumerate client hulls
|
|
for( i = 0; i < MAX_MAP_HULLS; i++ )
|
|
{
|
|
if( clgame.dllFuncs.pfnGetHullBounds( i, host.player_mins[i], host.player_maxs[i] ))
|
|
Con_Reportf( "CL: hull%i, player_mins: %g %g %g, player_maxs: %g %g %g\n", i,
|
|
host.player_mins[i][0], host.player_mins[i][1], host.player_mins[i][2],
|
|
host.player_maxs[i][0], host.player_maxs[i][1], host.player_maxs[i][2] );
|
|
}
|
|
|
|
memcpy( clgame.pmove->player_mins, host.player_mins, sizeof( host.player_mins ));
|
|
memcpy( clgame.pmove->player_maxs, host.player_maxs, sizeof( host.player_maxs ));
|
|
|
|
// common utilities
|
|
clgame.pmove->PM_Info_ValueForKey = Info_ValueForKey;
|
|
clgame.pmove->PM_Particle = CL_Particle;
|
|
clgame.pmove->PM_TestPlayerPosition = pfnTestPlayerPosition;
|
|
clgame.pmove->Con_NPrintf = Con_NPrintf;
|
|
clgame.pmove->Con_DPrintf = Con_DPrintf;
|
|
clgame.pmove->Con_Printf = Con_Printf;
|
|
clgame.pmove->Sys_FloatTime = Sys_DoubleTime;
|
|
clgame.pmove->PM_StuckTouch = pfnStuckTouch;
|
|
clgame.pmove->PM_PointContents = pfnPointContents;
|
|
clgame.pmove->PM_TruePointContents = pfnTruePointContents;
|
|
clgame.pmove->PM_HullPointContents = pfnHullPointContents;
|
|
clgame.pmove->PM_PlayerTrace = pfnPlayerTrace;
|
|
clgame.pmove->PM_TraceLine = pfnTraceLine;
|
|
clgame.pmove->RandomLong = COM_RandomLong;
|
|
clgame.pmove->RandomFloat = COM_RandomFloat;
|
|
clgame.pmove->PM_GetModelType = pfnGetModelType;
|
|
clgame.pmove->PM_GetModelBounds = pfnGetModelBounds;
|
|
clgame.pmove->PM_HullForBsp = (void*)pfnHullForBsp;
|
|
clgame.pmove->PM_TraceModel = pfnTraceModel;
|
|
clgame.pmove->COM_FileSize = COM_FileSize;
|
|
clgame.pmove->COM_LoadFile = COM_LoadFile;
|
|
clgame.pmove->COM_FreeFile = COM_FreeFile;
|
|
clgame.pmove->memfgets = COM_MemFgets;
|
|
clgame.pmove->PM_PlaySound = pfnPlaySound;
|
|
clgame.pmove->PM_TraceTexture = pfnTraceTexture;
|
|
clgame.pmove->PM_PlaybackEventFull = pfnPlaybackEventFull;
|
|
clgame.pmove->PM_PlayerTraceEx = pfnPlayerTraceEx;
|
|
clgame.pmove->PM_TestPlayerPositionEx = pfnTestPlayerPositionEx;
|
|
clgame.pmove->PM_TraceLineEx = pfnTraceLineEx;
|
|
clgame.pmove->PM_TraceSurface = pfnTraceSurface;
|
|
|
|
// initalize pmove
|
|
clgame.dllFuncs.pfnPlayerMoveInit( clgame.pmove );
|
|
}
|
|
|
|
static void PM_CheckMovingGround( clientdata_t *cd, entity_state_t *state, float frametime )
|
|
{
|
|
if(!( cd->flags & FL_BASEVELOCITY ))
|
|
{
|
|
// apply momentum (add in half of the previous frame of velocity first)
|
|
VectorMA( cd->velocity, 1.0f + (frametime * 0.5f), state->basevelocity, cd->velocity );
|
|
VectorClear( state->basevelocity );
|
|
}
|
|
cd->flags &= ~FL_BASEVELOCITY;
|
|
}
|
|
|
|
void CL_SetupPMove( playermove_t *pmove, local_state_t *from, usercmd_t *ucmd, qboolean runfuncs, double time )
|
|
{
|
|
entity_state_t *ps;
|
|
clientdata_t *cd;
|
|
|
|
ps = &from->playerstate;
|
|
cd = &from->client;
|
|
|
|
pmove->player_index = ps->number - 1;
|
|
pmove->multiplayer = (cl.maxclients > 1);
|
|
pmove->runfuncs = runfuncs;
|
|
pmove->time = time * 1000.0f;
|
|
pmove->frametime = ucmd->msec / 1000.0f;
|
|
VectorCopy( ps->origin, pmove->origin );
|
|
VectorCopy( ps->angles, pmove->angles );
|
|
VectorCopy( pmove->angles, pmove->oldangles );
|
|
VectorCopy( cd->velocity, pmove->velocity );
|
|
VectorCopy( ps->basevelocity, pmove->basevelocity );
|
|
VectorCopy( cd->view_ofs, pmove->view_ofs );
|
|
VectorClear( pmove->movedir );
|
|
pmove->flDuckTime = cd->flDuckTime;
|
|
pmove->bInDuck = cd->bInDuck;
|
|
pmove->usehull = ps->usehull;
|
|
pmove->flTimeStepSound = cd->flTimeStepSound;
|
|
pmove->iStepLeft = ps->iStepLeft;
|
|
pmove->flFallVelocity = ps->flFallVelocity;
|
|
pmove->flSwimTime = cd->flSwimTime;
|
|
VectorCopy( cd->punchangle, pmove->punchangle );
|
|
pmove->flSwimTime = cd->flSwimTime;
|
|
pmove->flNextPrimaryAttack = 0.0f; // not used by PM_ code
|
|
pmove->effects = ps->effects;
|
|
pmove->flags = cd->flags;
|
|
pmove->gravity = ps->gravity;
|
|
pmove->friction = ps->friction;
|
|
pmove->oldbuttons = ps->oldbuttons;
|
|
pmove->waterjumptime = cd->waterjumptime;
|
|
pmove->dead = (cl.local.health <= 0);
|
|
pmove->deadflag = cd->deadflag;
|
|
pmove->spectator = (cls.spectator != 0);
|
|
pmove->movetype = ps->movetype;
|
|
pmove->onground = ps->onground;
|
|
pmove->waterlevel = cd->waterlevel;
|
|
pmove->watertype = cd->watertype;
|
|
pmove->maxspeed = clgame.movevars.maxspeed;
|
|
pmove->clientmaxspeed = cd->maxspeed;
|
|
pmove->iuser1 = cd->iuser1;
|
|
pmove->iuser2 = cd->iuser2;
|
|
pmove->iuser3 = cd->iuser3;
|
|
pmove->iuser4 = cd->iuser4;
|
|
pmove->fuser1 = cd->fuser1;
|
|
pmove->fuser2 = cd->fuser2;
|
|
pmove->fuser3 = cd->fuser3;
|
|
pmove->fuser4 = cd->fuser4;
|
|
VectorCopy( cd->vuser1, pmove->vuser1 );
|
|
VectorCopy( cd->vuser2, pmove->vuser2 );
|
|
VectorCopy( cd->vuser3, pmove->vuser3 );
|
|
VectorCopy( cd->vuser4, pmove->vuser4 );
|
|
pmove->cmd = *ucmd; // copy current cmds
|
|
|
|
Q_strncpy( pmove->physinfo, cls.physinfo, MAX_INFO_STRING );
|
|
}
|
|
|
|
void CL_FinishPMove( playermove_t *pmove, local_state_t *to )
|
|
{
|
|
entity_state_t *ps;
|
|
clientdata_t *cd;
|
|
|
|
ps = &to->playerstate;
|
|
cd = &to->client;
|
|
|
|
cd->flags = pmove->flags;
|
|
cd->bInDuck = pmove->bInDuck;
|
|
cd->flTimeStepSound = pmove->flTimeStepSound;
|
|
cd->flDuckTime = pmove->flDuckTime;
|
|
cd->flSwimTime = (int)pmove->flSwimTime;
|
|
cd->waterjumptime = (int)pmove->waterjumptime;
|
|
cd->watertype = pmove->watertype;
|
|
cd->waterlevel = pmove->waterlevel;
|
|
cd->maxspeed = pmove->clientmaxspeed;
|
|
cd->deadflag = pmove->deadflag;
|
|
VectorCopy( pmove->velocity, cd->velocity );
|
|
VectorCopy( pmove->view_ofs, cd->view_ofs );
|
|
VectorCopy( pmove->origin, ps->origin );
|
|
VectorCopy( pmove->angles, ps->angles );
|
|
VectorCopy( pmove->basevelocity, ps->basevelocity );
|
|
VectorCopy( pmove->punchangle, cd->punchangle );
|
|
ps->oldbuttons = pmove->oldbuttons;
|
|
ps->friction = pmove->friction;
|
|
ps->movetype = pmove->movetype;
|
|
ps->onground = pmove->onground;
|
|
ps->effects = pmove->effects;
|
|
ps->usehull = pmove->usehull;
|
|
ps->iStepLeft = pmove->iStepLeft;
|
|
ps->flFallVelocity = pmove->flFallVelocity;
|
|
cd->iuser1 = pmove->iuser1;
|
|
cd->iuser2 = pmove->iuser2;
|
|
cd->iuser3 = pmove->iuser3;
|
|
cd->iuser4 = pmove->iuser4;
|
|
cd->fuser1 = pmove->fuser1;
|
|
cd->fuser2 = pmove->fuser2;
|
|
cd->fuser3 = pmove->fuser3;
|
|
cd->fuser4 = pmove->fuser4;
|
|
VectorCopy( pmove->vuser1, cd->vuser1 );
|
|
VectorCopy( pmove->vuser2, cd->vuser2 );
|
|
VectorCopy( pmove->vuser3, cd->vuser3 );
|
|
VectorCopy( pmove->vuser4, cd->vuser4 );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CL_RunUsercmd
|
|
|
|
Runs prediction code for user cmd
|
|
=================
|
|
*/
|
|
void CL_RunUsercmd( local_state_t *from, local_state_t *to, usercmd_t *u, qboolean runfuncs, double *time, unsigned int random_seed )
|
|
{
|
|
usercmd_t cmd;
|
|
local_state_t temp;
|
|
usercmd_t split;
|
|
|
|
memset( &temp, 0, sizeof( temp ));
|
|
|
|
if( u->msec > 50 )
|
|
{
|
|
split = *u;
|
|
split.msec /= 2;
|
|
CL_RunUsercmd( from, &temp, &split, runfuncs, time, random_seed );
|
|
split.impulse = split.weaponselect = 0;
|
|
CL_RunUsercmd( &temp, to, &split, runfuncs, time, random_seed );
|
|
return;
|
|
}
|
|
|
|
cmd = *u; // deal with local copy
|
|
*to = *from;
|
|
|
|
if( CL_IsPredicted( ))
|
|
{
|
|
// setup playermove state
|
|
CL_SetupPMove( clgame.pmove, from, &cmd, runfuncs, *time );
|
|
|
|
// motor!
|
|
clgame.dllFuncs.pfnPlayerMove( clgame.pmove, false );
|
|
|
|
// copy results back to client
|
|
CL_FinishPMove( clgame.pmove, to );
|
|
|
|
if( clgame.pmove->onground > 0 && clgame.pmove->onground < clgame.pmove->numphysent )
|
|
cl.local.lastground = clgame.pmove->physents[clgame.pmove->onground].info;
|
|
else cl.local.lastground = clgame.pmove->onground; // world(0) or in air(-1)
|
|
}
|
|
|
|
clgame.dllFuncs.pfnPostRunCmd( from, to, &cmd, runfuncs, *time, random_seed );
|
|
|
|
*time += (double)cmd.msec / 1000.0;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
CL_MoveSpectatorCamera
|
|
|
|
spectator movement code
|
|
=================
|
|
*/
|
|
void CL_MoveSpectatorCamera( void )
|
|
{
|
|
double time = cl.time;
|
|
|
|
if( !cls.spectator )
|
|
return;
|
|
|
|
CL_SetUpPlayerPrediction( false, true );
|
|
CL_SetSolidPlayers( cl.playernum );
|
|
CL_RunUsercmd( &cls.spectator_state, &cls.spectator_state, cl.cmd, true, &time, (uint)( time * 100.0 ));
|
|
|
|
VectorCopy( cls.spectator_state.client.velocity, cl.simvel );
|
|
VectorCopy( cls.spectator_state.client.origin, cl.simorg );
|
|
VectorCopy( cls.spectator_state.client.punchangle, cl.punchangle );
|
|
VectorCopy( cls.spectator_state.client.view_ofs, cl.viewheight );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CL_PredictMovement
|
|
|
|
Sets cl.predicted.origin and cl.predicted.angles
|
|
=================
|
|
*/
|
|
void CL_PredictMovement( qboolean repredicting )
|
|
{
|
|
runcmd_t *to_cmd, *from_cmd;
|
|
local_state_t *from = NULL, *to = NULL;
|
|
int current_command;
|
|
int current_command_mod;
|
|
frame_t *frame = NULL;
|
|
int i, stoppoint;
|
|
qboolean runfuncs;
|
|
double f = 1.0;
|
|
cl_entity_t *ent;
|
|
double time;
|
|
|
|
if( cls.state != ca_active || cls.spectator )
|
|
return;
|
|
|
|
if( cls.demoplayback && !repredicting )
|
|
CL_DemoInterpolateAngles();
|
|
|
|
CL_SetUpPlayerPrediction( false, false );
|
|
|
|
if( cls.state != ca_active || !cl.validsequence )
|
|
return;
|
|
|
|
if(( cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged ) >= CL_UPDATE_MASK )
|
|
return;
|
|
|
|
// this is the last frame received from the server
|
|
frame = &cl.frames[cl.parsecountmod];
|
|
|
|
if( !CL_IsPredicted( ))
|
|
{
|
|
VectorCopy( frame->clientdata.velocity, cl.simvel );
|
|
VectorCopy( frame->clientdata.origin, cl.simorg );
|
|
VectorCopy( frame->clientdata.punchangle, cl.punchangle );
|
|
VectorCopy( frame->clientdata.view_ofs, cl.viewheight );
|
|
cl.local.usehull = frame->playerstate[cl.playernum].usehull;
|
|
cl.local.waterlevel = frame->clientdata.waterlevel;
|
|
|
|
if( FBitSet( frame->clientdata.flags, FL_ONGROUND ))
|
|
cl.local.onground = frame->playerstate[cl.playernum].onground;
|
|
else cl.local.onground = -1;
|
|
}
|
|
|
|
from = &cl.predicted_frames[cl.parsecountmod];
|
|
from_cmd = &cl.commands[cls.netchan.incoming_acknowledged & CL_UPDATE_MASK];
|
|
memcpy( from->weapondata, frame->weapondata, sizeof( from->weapondata ));
|
|
from->playerstate = frame->playerstate[cl.playernum];
|
|
from->client = frame->clientdata;
|
|
if( !frame->valid ) return;
|
|
|
|
time = frame->time;
|
|
stoppoint = ( repredicting ) ? 0 : 1;
|
|
cl.local.repredicting = repredicting;
|
|
cl.local.onground = -1;
|
|
|
|
// predict forward until cl.time <= to->senttime
|
|
CL_PushPMStates();
|
|
CL_SetSolidPlayers( cl.playernum );
|
|
|
|
for( i = 1; i < CL_UPDATE_MASK && cls.netchan.incoming_acknowledged + i < cls.netchan.outgoing_sequence + stoppoint; i++ )
|
|
{
|
|
current_command = cls.netchan.incoming_acknowledged + i;
|
|
current_command_mod = current_command & CL_UPDATE_MASK;
|
|
|
|
to = &cl.predicted_frames[(cl.parsecountmod + i) & CL_UPDATE_MASK];
|
|
to_cmd = &cl.commands[current_command_mod];
|
|
runfuncs = ( !repredicting && !to_cmd->processedfuncs );
|
|
|
|
CL_RunUsercmd( from, to, &to_cmd->cmd, runfuncs, &time, current_command );
|
|
VectorCopy( to->playerstate.origin, cl.local.predicted_origins[current_command_mod] );
|
|
to_cmd->processedfuncs = true;
|
|
|
|
if( to_cmd->senttime >= host.realtime )
|
|
break;
|
|
|
|
// now interpolate some fraction of the final frame
|
|
if( to_cmd->senttime != from_cmd->senttime )
|
|
f = (host.realtime - from_cmd->senttime) / (to_cmd->senttime - from_cmd->senttime) * 0.1;
|
|
|
|
from = to;
|
|
from_cmd = to_cmd;
|
|
}
|
|
|
|
CL_PopPMStates();
|
|
|
|
if(( i == CL_UPDATE_MASK ) || ( !to && !repredicting ))
|
|
{
|
|
cl.local.repredicting = false;
|
|
return; // net hasn't deliver packets in a long time...
|
|
}
|
|
|
|
if( !to )
|
|
{
|
|
to = from;
|
|
to_cmd = from_cmd;
|
|
}
|
|
|
|
if( !CL_IsPredicted( ))
|
|
{
|
|
// keep onground actual
|
|
if( FBitSet( frame->clientdata.flags, FL_ONGROUND ))
|
|
cl.local.onground = frame->playerstate[cl.playernum].onground;
|
|
else cl.local.onground = -1;
|
|
|
|
if( !repredicting || !CVAR_TO_BOOL( cl_lw ))
|
|
cl.local.viewmodel = to->client.viewmodel;
|
|
cl.local.repredicting = false;
|
|
cl.local.moving = false;
|
|
return;
|
|
}
|
|
|
|
f = bound( 0.0f, f, 1.0f );
|
|
f = 0.0; // FIXME: make work, do revision
|
|
|
|
if( CL_PlayerTeleported( from, to ))
|
|
{
|
|
VectorCopy( to->client.velocity, cl.simvel );
|
|
VectorCopy( to->playerstate.origin, cl.simorg );
|
|
VectorCopy( to->client.punchangle, cl.punchangle );
|
|
VectorCopy( to->client.view_ofs, cl.viewheight );
|
|
}
|
|
else
|
|
{
|
|
VectorLerp( from->playerstate.origin, f, to->playerstate.origin, cl.simorg );
|
|
VectorLerp( from->client.velocity, f, to->client.velocity, cl.simvel );
|
|
VectorLerp( from->client.punchangle, f, to->client.punchangle, cl.punchangle );
|
|
|
|
if( from->playerstate.usehull == to->playerstate.usehull )
|
|
VectorLerp( from->client.view_ofs, f, to->client.view_ofs, cl.viewheight );
|
|
else VectorCopy( to->client.view_ofs, cl.viewheight );
|
|
}
|
|
|
|
cl.local.waterlevel = to->client.waterlevel;
|
|
cl.local.usehull = to->playerstate.usehull;
|
|
if( !repredicting || !CVAR_TO_BOOL( cl_lw ))
|
|
cl.local.viewmodel = to->client.viewmodel;
|
|
|
|
if( FBitSet( to->client.flags, FL_ONGROUND ))
|
|
{
|
|
ent = CL_GetEntityByIndex( cl.local.lastground );
|
|
cl.local.onground = cl.local.lastground;
|
|
cl.local.moving = false;
|
|
|
|
if( ent )
|
|
{
|
|
vec3_t delta;
|
|
|
|
delta[0] = ent->curstate.origin[0] - ent->prevstate.origin[0];
|
|
delta[1] = ent->curstate.origin[1] - ent->prevstate.origin[1];
|
|
delta[2] = 0.0f;
|
|
|
|
if( VectorLength( delta ) > 0.0f )
|
|
{
|
|
cls.correction_time = 0;
|
|
cl.local.moving = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cl.local.onground = -1;
|
|
cl.local.moving = 0;
|
|
}
|
|
|
|
if( cls.correction_time > 0 && !cl_nosmooth->value && cl_smoothtime->value )
|
|
{
|
|
vec3_t delta;
|
|
float frac;
|
|
|
|
// only decay timer once per frame
|
|
if( !repredicting )
|
|
cls.correction_time -= host.frametime;
|
|
|
|
// Make sure smoothtime is postive
|
|
if( cl_smoothtime->value <= 0.0 )
|
|
Cvar_DirectSet( cl_smoothtime, "0.1" );
|
|
|
|
// Clamp from 0 to cl_smoothtime.value
|
|
cls.correction_time = bound( 0.0, cls.correction_time, cl_smoothtime->value );
|
|
|
|
// Compute backward interpolation fraction along full correction
|
|
frac = 1.0 - cls.correction_time / cl_smoothtime->value;
|
|
|
|
// Determine how much error we still have to make up for
|
|
VectorSubtract( cl.simorg, cl.local.lastorigin, delta );
|
|
|
|
// Scale the error by the backlerp fraction
|
|
VectorScale( delta, frac, delta );
|
|
|
|
// Go some fraction of the way
|
|
// FIXME, Probably can't do this any more
|
|
VectorAdd( cl.local.lastorigin, delta, cl.simorg );
|
|
}
|
|
|
|
VectorCopy( cl.simorg, cl.local.lastorigin );
|
|
cl.local.repredicting = false;
|
|
}
|