/*

=========================

HUD_ProcessPlayerState

We have received entity_state_t for this player over the network.  We need to copy appropriate fields to the

playerstate structure

=========================

*/

void DLLEXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct entity_state_s *src )

{

  // Copy in network data

  dst->origin	= src->origin;

  dst->angles	= src->angles;

  dst->velocity	= src->velocity;

  dst->basevelocity	= src->basevelocity;

  dst->frame	= src->frame;

  dst->modelindex	= src->modelindex;

  dst->skin		= src->skin;

  dst->effects	= src->effects;

  dst->weaponmodel	= src->weaponmodel;

  dst->movetype	= src->movetype;

  dst->sequence	= src->sequence;

  dst->animtime	= src->animtime;

  dst->solid	= src->solid;

  dst->rendermode	= src->rendermode;

  dst->renderamt	= src->renderamt;

  dst->rendercolor.r	= src->rendercolor.r;

  dst->rendercolor.g	= src->rendercolor.g;

  dst->rendercolor.b	= src->rendercolor.b;

  dst->renderfx	= src->renderfx;

  dst->framerate	= src->framerate;

  dst->body		= src->body;

  dst->friction	= src->friction;

  dst->gravity	= src->gravity;

  dst->gaitsequence	= src->gaitsequence; .................................................................................................................

  dst->usehull	= src->usehull;

  dst->playerclass	= src->playerclass;

  dst->team		= src->team;

  dst->colormap	= src->colormap;

  memcpy( &dst->controller[0], &src->controller[0], 4 * sizeof( byte ));

  memcpy( &dst->blending[0], &src->blending[0], 2 * sizeof( byte ));

  // Save off some data so other areas of the Client DLL can get to it

  cl_entity_t *player = GET_LOCAL_PLAYER(); // Get the local player's index

  if( dst->number == player->index )

  {

    // always have valid PVS message

    r_currentMessageNum = src->messagenum;

  }

}

/*

AddToFullPack

Return 1 if the entity state has been filled in for the ent and the entity will be propagated to the client, 0 otherwise

state is the server maintained copy of the state info that is transmitted to the client

a MOD could alter values copied into state to send the "host" a different look for a particular entity update, etc.

e and ent are the entity that is being added to the update, if 1 is returned

host is the player's edict of the player whom we are sending the update to

player is 1 if the ent/e is a player and 0 otherwise

pSet is either the PAS or PVS that we previous set up.  We can use it to ask the engine to filter the entity against the PAS or PVS.

we could also use the pas/ pvs that we set in SetupVisibility, if we wanted to.  Caching the value is valid in that case, but still only for the current frame

*/

int AddToFullPack( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet )

{

  ...

  state->rendermode    = ent->v.rendermode;

  state->renderamt     = ent->v.renderamt;

  state->renderfx      = ent->v.renderfx;

  state->rendercolor.r = ent->v.rendercolor.x;

  state->rendercolor.g = ent->v.rendercolor.y;

  state->rendercolor.b = ent->v.rendercolor.z;

  state->fuser2	 = ent->v.fuser2; // FOV

  state->iuser1	 = ent->v.iuser1; // flags

  state->iuser2	 = ent->v.iuser2; // flags

  state->vuser2	 = ent->v.vuser2;

  state->aiment = 0;

  if ( ent->v.aiment )

  {

    state->aiment = ENTINDEX( ent->v.aiment );

  }

  state->owner = 0;

  if ( ent->v.owner )

  {

    int owner = ENTINDEX( ent->v.owner );

    // Only care if owned by a player

    if ( owner >= 1 && owner <= gpGlobals->maxClients )

    {

      state->owner = owner;

    }

  }

  // HACK:  Somewhat...

  // Class is overridden for non-players to signify a breakable glass object ( sort of a class? )

  if ( !player )

  {

    state->playerclass  = ent->v.playerclass;

  }

  // Special stuff for players only

  if ( player )

  {

    memcpy( state->basevelocity, ent->v.basevelocity, 3 * sizeof( float ) );

    state->weaponmodel  = MODEL_INDEX( STRING( ent->v.weaponmodel ) );

    state->gaitsequence = ent->v.gaitsequence;......................................................................................................................

    state->spectator = ent->v.flags & FL_SPECTATOR;

    state->friction     = ent->v.friction;

    state->gravity      = ent->v.gravity;

    //		state->team			= ent->v.team;

    //

    state->usehull      = ( ent->v.flags & FL_DUCKING ) ? 1 : 0;

    state->health		= ent->v.health;

  }

  state->weaponmodel  = MODEL_INDEX( STRING( ent->v.weaponmodel ) );

  state->team	= ent->v.team;

  return 1;

}

if ( m_pPlayerInfo )

{

  if ( m_pPlayerInfo->iPrevGaitSeq != m_pPlayerInfo->gaitsequence )

  {

    /*if ( m_pPlayerInfo->iPrevGaitSeq < 0 || m_pPlayerInfo->iPrevGaitSeq >= m_pStudioHeader->numseq )

    			{

    				m_pPlayerInfo->iPrevGaitSeq = 0;

    			}*/

    ALERT ( at_console, "Prevoius %d %f, Current %d %f\n", m_pPlayerInfo->iPrevGaitSeq, m_pPlayerInfo->flPrevGaitFrame, m_pPlayerInfo->gaitsequence, m_pPlayerInfo->gaitframe );

    m_pPlayerInfo->gaitframe = 0;

  }

  m_pPlayerInfo->flPrevGaitFrame =	m_pPlayerInfo->gaitframe;

  m_pPlayerInfo->iPrevGaitSeq =		m_pPlayerInfo->gaitsequence;

}

typedef struct player_info_s

{

  ....

  // Gait frame estimation

  int		gaitsequence;

  int		iPrevGaitSeq;

  float		gaitframe;

  float		flPrevGaitFrame;

  float		gaityaw;

  vec3_t		prevgaitorigin;

} player_info_t;

typedef struct player_info_s

{

  ....

  // Gait frame estimation

  int    gaitsequence;

  int    iPrevGaitSeq;

  float    gaitframe;

  float    flPrevGaitFrame;

  float    gaityaw;

  vec3_t    prevgaitorigin;

} player_info_t;