/*
Copyright (C) 1996-1997 Id Software, Inc.

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 2
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.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// cl_ents.c -- entity parsing and management

#include "quakedef.h"

extern  cvar_t  cl_predict_players;
extern  cvar_t  cl_predict_players2;
extern  cvar_t  cl_solid_players;

static struct predicted_player {
  int flags;
  qboolean active;
  vec3_t origin;  // predicted origin
} predicted_players[MAX_CLIENTS];

//============================================================

/*
===============
CL_AllocDlight

===============
*/
dlight_t *CL_AllocDlight (int key)
{
  int   i;
  dlight_t  *dl;

// first look for an exact key match
  if (key)
  {
    dl = cl_dlights;
    for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
    {
      if (dl->key == key)
      {
        memset (dl, 0, sizeof(*dl));
        dl->key = key;
        return dl;
      }
    }
  }

// then look for anything else
  dl = cl_dlights;
  for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
  {
    if (dl->die < cl.time)
    {
      memset (dl, 0, sizeof(*dl));
      dl->key = key;
      return dl;
    }
  }

  dl = &cl_dlights[0];
  memset (dl, 0, sizeof(*dl));
  dl->key = key;
  return dl;
}

/*
===============
CL_NewDlight
===============
*/
void CL_NewDlight (int key, float x, float y, float z, float radius, float time,
           int type)
{
  dlight_t  *dl;

  dl = CL_AllocDlight (key);
  dl->origin[0] = x;
  dl->origin[1] = y;
  dl->origin[2] = z;
  dl->radius = radius;
  dl->die = cl.time + time;
  if (type == 0) {
    dl->color[0] = 0.2;
    dl->color[1] = 0.1;
    dl->color[2] = 0.05;
    dl->color[3] = 0.7;
  } else if (type == 1) {
    dl->color[0] = 0.05;
    dl->color[1] = 0.05;
    dl->color[2] = 0.3;
    dl->color[3] = 0.7;
  } else if (type == 2) {
    dl->color[0] = 0.5;
    dl->color[1] = 0.05;
    dl->color[2] = 0.05;
    dl->color[3] = 0.7;
  } else if (type == 3) {
    dl->color[0]=0.5;
    dl->color[1] = 0.05;
    dl->color[2] = 0.4;
    dl->color[3] = 0.7;
  }
}


/*
===============
CL_DecayLights

===============
*/
void CL_DecayLights (void)
{
  int     i;
  dlight_t  *dl;

  dl = cl_dlights;
  for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
  {
    if (dl->die < cl.time || !dl->radius)
      continue;
    
    dl->radius -= host_frametime*dl->decay;
    if (dl->radius < 0)
      dl->radius = 0;
  }
}


/*
=========================================================================

PACKET ENTITY PARSING / LINKING

=========================================================================
*/

/*
==================
CL_ParseDelta

Can go from either a baseline or a previous packet_entity
==================
*/
int bitcounts[32];  /// just for protocol profiling
void CL_ParseDelta (entity_state_t *from, entity_state_t *to, int bits)
{
  int     i;

  // set everything to the state we are delta'ing from
  *to = *from;

  to->number = bits & 511;
  bits &= ~511;

  if (bits & U_MOREBITS)
  { // read in the low order bits
    i = MSG_ReadByte ();
    bits |= i;
  }

  // count the bits for net profiling
  for (i=0 ; i<16 ; i++)
    if (bits&(1<<i))
      bitcounts[i]++;

  to->flags = bits;
  
  if (bits & U_MODEL)
    to->modelindex = MSG_ReadByte ();
    
  if (bits & U_FRAME)
    to->frame = MSG_ReadByte ();

  if (bits & U_COLORMAP)
    to->colormap = MSG_ReadByte();

  if (bits & U_SKIN)
    to->skinnum = MSG_ReadByte();

  if (bits & U_EFFECTS)
    to->effects = MSG_ReadByte();

  if (bits & U_ORIGIN1)
    to->origin[0] = MSG_ReadCoord ();
    
  if (bits & U_ANGLE1)
    to->angles[0] = MSG_ReadAngle();

  if (bits & U_ORIGIN2)
    to->origin[1] = MSG_ReadCoord ();
    
  if (bits & U_ANGLE2)
    to->angles[1] = MSG_ReadAngle();

  if (bits & U_ORIGIN3)
    to->origin[2] = MSG_ReadCoord ();
    
  if (bits & U_ANGLE3)
    to->angles[2] = MSG_ReadAngle();

  if (bits & U_SOLID)
  {
    // FIXME
  }
}


/*
=================
FlushEntityPacket
=================
*/
void FlushEntityPacket (void)
{
  int     word;
  entity_state_t  olde, newe;

  Con_DPrintf ("FlushEntityPacket\n");

  memset (&olde, 0, sizeof(olde));

  cl.validsequence = 0;   // can't render a frame
  cl.frames[cls.netchan.incoming_sequence&UPDATE_MASK].invalid = true;

  // read it all, but ignore it
  while (1)
  {
    word = (unsigned short)MSG_ReadShort ();
    if (msg_badread)
    { // something didn't parse right...
      Host_EndGame ("msg_badread in packetentities");
      return;
    }

    if (!word)
      break;  // done

    CL_ParseDelta (&olde, &newe, word);
  }
}

/*
==================
CL_ParsePacketEntities

An svc_packetentities has just been parsed, deal with the
rest of the data stream.
==================
*/
void CL_ParsePacketEntities (qboolean delta)
{
  int     oldpacket, newpacket;
  packet_entities_t *oldp, *newp, dummy;
  int     oldindex, newindex;
  int     word, newnum, oldnum;
  qboolean  full;
  byte    from;

  newpacket = cls.netchan.incoming_sequence&UPDATE_MASK;
  newp = &cl.frames[newpacket].packet_entities;
  cl.frames[newpacket].invalid = false;

  if (delta)
  {
    from = MSG_ReadByte ();

    oldpacket = cl.frames[newpacket].delta_sequence;

    if ( (from&UPDATE_MASK) != (oldpacket&UPDATE_MASK) )
      Con_DPrintf ("WARNING: from mismatch\n");
  }
  else
    oldpacket = -1;

  full = false;
  if (oldpacket != -1)
  {
    if (cls.netchan.outgoing_sequence - oldpacket >= UPDATE_BACKUP-1)
    { // we can't use this, it is too old
      FlushEntityPacket ();
      return;
    }
    cl.validsequence = cls.netchan.incoming_sequence;
    oldp = &cl.frames[oldpacket&UPDATE_MASK].packet_entities;
  }
  else
  { // this is a full update that we can start delta compressing from now
    oldp = &dummy;
    dummy.num_entities = 0;
    cl.validsequence = cls.netchan.incoming_sequence;
    full = true;
  }

  oldindex = 0;
  newindex = 0;
  newp->num_entities = 0;

  while (1)
  {
    word = (unsigned short)MSG_ReadShort ();
    if (msg_badread)
    { // something didn't parse right...
      Host_EndGame ("msg_badread in packetentities");
      return;
    }

    if (!word)
    {
      while (oldindex < oldp->num_entities)
      { // copy all the rest of the entities from the old packet
//Con_Printf ("copy %i\n", oldp->entities[oldindex].number);
        if (newindex >= MAX_PACKET_ENTITIES)
          Host_EndGame ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");
        newp->entities[newindex] = oldp->entities[oldindex];
        newindex++;
        oldindex++;
      }
      break;
    }
    newnum = word&511;
    oldnum = oldindex >= oldp->num_entities ? 9999 : oldp->entities[oldindex].number;

    while (newnum > oldnum)
    {
      if (full)
      {
        Con_Printf ("WARNING: oldcopy on full update");
        FlushEntityPacket ();
        return;
      }

//Con_Printf ("copy %i\n", oldnum);
      // copy one of the old entities over to the new packet unchanged
      if (newindex >= MAX_PACKET_ENTITIES)
        Host_EndGame ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");
      newp->entities[newindex] = oldp->entities[oldindex];
      newindex++;
      oldindex++;
      oldnum = oldindex >= oldp->num_entities ? 9999 : oldp->entities[oldindex].number;
    }

    if (newnum < oldnum)
    { // new from baseline
//Con_Printf ("baseline %i\n", newnum);
      if (word & U_REMOVE)
      {
        if (full)
        {
          cl.validsequence = 0;
          Con_Printf ("WARNING: U_REMOVE on full update\n");
          FlushEntityPacket ();
          return;
        }
        continue;
      }
      if (newindex >= MAX_PACKET_ENTITIES)
        Host_EndGame ("CL_ParsePacketEntities: newindex == MAX_PACKET_ENTITIES");
      CL_ParseDelta (&cl_baselines[newnum], &newp->entities[newindex], word);
      newindex++;
      continue;
    }

    if (newnum == oldnum)
    { // delta from previous
      if (full)
      {
        cl.validsequence = 0;
        Con_Printf ("WARNING: delta on full update");
      }
      if (word & U_REMOVE)
      {
        oldindex++;
        continue;
      }
//Con_Printf ("delta %i\n",newnum);
      CL_ParseDelta (&oldp->entities[oldindex], &newp->entities[newindex], word);
      newindex++;
      oldindex++;
    }

  }

  newp->num_entities = newindex;
}


/*
===============
CL_LinkPacketEntities

===============
*/
void CL_LinkPacketEntities (void)
{
  entity_t      *ent;
  packet_entities_t *pack;
  entity_state_t    *s1, *s2;
  float       f;
  model_t       *model;
  vec3_t        old_origin;
  float       autorotate;
  int         i;
  int         pnum;
  dlight_t      *dl;

  pack = &cl.frames[cls.netchan.incoming_sequence&UPDATE_MASK].packet_entities;

  autorotate = anglemod(100*cl.time);

  f = 0;    // FIXME: no interpolation right now

  for (pnum=0 ; pnum<pack->num_entities ; pnum++)
  {
    s1 = &pack->entities[pnum];
    s2 = s1;  // FIXME: no interpolation right now

    // spawn light flashes, even ones coming from invisible objects
    if ((s1->effects & (EF_BLUE | EF_RED)) == (EF_BLUE | EF_RED))
      CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2], 200 + (rand()&31), 0.1, 3);
    else if (s1->effects & EF_BLUE)
      CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2], 200 + (rand()&31), 0.1, 1);
    else if (s1->effects & EF_RED)
      CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2], 200 + (rand()&31), 0.1, 2);
    else if (s1->effects & EF_BRIGHTLIGHT)
      CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2] + 16, 400 + (rand()&31), 0.1, 0);
    else if (s1->effects & EF_DIMLIGHT)
      CL_NewDlight (s1->number, s1->origin[0], s1->origin[1], s1->origin[2], 200 + (rand()&31), 0.1, 0);

    // if set to invisible, skip
    if (!s1->modelindex)
      continue;

    // create a new entity
    if (cl_numvisedicts == MAX_VISEDICTS)
      break;    // object list is full

    ent = &cl_visedicts[cl_numvisedicts];
    cl_numvisedicts++;

    ent->keynum = s1->number;
    ent->model = model = cl.model_precache[s1->modelindex];
  
    // set colormap
    if (s1->colormap && (s1->colormap < MAX_CLIENTS) 
      && !strcmp(ent->model->name,"progs/player.mdl") )
    {
      ent->colormap = cl.players[s1->colormap-1].translations;
      ent->scoreboard = &cl.players[s1->colormap-1];
    }
    else
    {
      ent->colormap = vid.colormap;
      ent->scoreboard = NULL;
    }

    // set skin
    ent->skinnum = s1->skinnum;
    
    // set frame
    ent->frame = s1->frame;

    // rotate binary objects locally
    if (model->flags & EF_ROTATE)
    {
      ent->angles[0] = 0;
      ent->angles[1] = autorotate;
      ent->angles[2] = 0;
    }
    else
    {
      float a1, a2;

      for (i=0 ; i<3 ; i++)
      {
        a1 = s1->angles[i];
        a2 = s2->angles[i];
        if (a1 - a2 > 180)
          a1 -= 360;
        if (a1 - a2 < -180)
          a1 += 360;
        ent->angles[i] = a2 + f * (a1 - a2);
      }
    }

    // calculate origin
    for (i=0 ; i<3 ; i++)
      ent->origin[i] = s2->origin[i] + 
      f * (s1->origin[i] - s2->origin[i]);

    // add automatic particle trails
    if (!model->flags)
      continue;

    // scan the old entity display list for a matching
    for (i=0 ; i<cl_oldnumvisedicts ; i++)
    {
      if (cl_oldvisedicts[i].keynum == ent->keynum)
      {
        VectorCopy (cl_oldvisedicts[i].origin, old_origin);
        break;
      }
    }
    if (i == cl_oldnumvisedicts)
      continue;   // not in last message

    for (i=0 ; i<3 ; i++)
      if ( abs(old_origin[i] - ent->origin[i]) > 128)
      { // no trail if too far
        VectorCopy (ent->origin, old_origin);
        break;
      }
    if (model->flags & EF_ROCKET)
    {
      R_RocketTrail (old_origin, ent->origin, 0);
      dl = CL_AllocDlight (s1->number);
      VectorCopy (ent->origin, dl->origin);
      dl->radius = 200;
      dl->die = cl.time + 0.1;
    }
    else if (model->flags & EF_GRENADE)
      R_RocketTrail (old_origin, ent->origin, 1);
    else if (model->flags & EF_GIB)
      R_RocketTrail (old_origin, ent->origin, 2);
    else if (model->flags & EF_ZOMGIB)
      R_RocketTrail (old_origin, ent->origin, 4);
    else if (model->flags & EF_TRACER)
      R_RocketTrail (old_origin, ent->origin, 3);
    else if (model->flags & EF_TRACER2)
      R_RocketTrail (old_origin, ent->origin, 5);
    else if (model->flags & EF_TRACER3)
      R_RocketTrail (old_origin, ent->origin, 6);
  }
}


/*
=========================================================================

PROJECTILE PARSING / LINKING

=========================================================================
*/

typedef struct
{
  int   modelindex;
  vec3_t  origin;
  vec3_t  angles;
} projectile_t;

#define MAX_PROJECTILES 32
projectile_t  cl_projectiles[MAX_PROJECTILES];
int       cl_num_projectiles;

extern int cl_spikeindex;

void CL_ClearProjectiles (void)
{
  cl_num_projectiles = 0;
}

/*
=====================
CL_ParseProjectiles

Nails are passed as efficient temporary entities
=====================
*/
void CL_ParseProjectiles (void)
{
  int   i, c, j;
  byte  bits[6];
  projectile_t  *pr;

  c = MSG_ReadByte ();
  for (i=0 ; i<c ; i++)
  {
    for (j=0 ; j<6 ; j++)
      bits[j] = MSG_ReadByte ();

    if (cl_num_projectiles == MAX_PROJECTILES)
      continue;

    pr = &cl_projectiles[cl_num_projectiles];
    cl_num_projectiles++;

    pr->modelindex = cl_spikeindex;
    pr->origin[0] = ( ( bits[0] + ((bits[1]&15)<<8) ) <<1) - 4096;
    pr->origin[1] = ( ( (bits[1]>>4) + (bits[2]<<4) ) <<1) - 4096;
    pr->origin[2] = ( ( bits[3] + ((bits[4]&15)<<8) ) <<1) - 4096;
    pr->angles[0] = 360*(bits[4]>>4)/16;
    pr->angles[1] = 360*bits[5]/256;
  }
}

/*
=============
CL_LinkProjectiles

=============
*/
void CL_LinkProjectiles (void)
{
  int   i;
  projectile_t  *pr;
  entity_t    *ent;

  for (i=0, pr=cl_projectiles ; i<cl_num_projectiles ; i++, pr++)
  {
    // grab an entity to fill in
    if (cl_numvisedicts == MAX_VISEDICTS)
      break;    // object list is full
    ent = &cl_visedicts[cl_numvisedicts];
    cl_numvisedicts++;
    ent->keynum = 0;

    if (pr->modelindex < 1)
      continue;
    ent->model = cl.model_precache[pr->modelindex];
    ent->skinnum = 0;
    ent->frame = 0;
    ent->colormap = vid.colormap;
    ent->scoreboard = NULL;
    VectorCopy (pr->origin, ent->origin);
    VectorCopy (pr->angles, ent->angles);
  }
}

//========================================

extern  int   cl_spikeindex, cl_playerindex, cl_flagindex;

entity_t *CL_NewTempEntity (void);

/*
===================
CL_ParsePlayerinfo
===================
*/
extern int parsecountmod;
extern double parsecounttime;
void CL_ParsePlayerinfo (void)
{
  int     msec;
  int     flags;
  player_info_t *info;
  player_state_t  *state;
  int     num;
  int     i;

  num = MSG_ReadByte ();
  if (num > MAX_CLIENTS)
    Sys_Error ("CL_ParsePlayerinfo: bad num");

  info = &cl.players[num];

  state = &cl.frames[parsecountmod].playerstate[num];

  flags = state->flags = MSG_ReadShort ();

  state->messagenum = cl.parsecount;
  state->origin[0] = MSG_ReadCoord ();
  state->origin[1] = MSG_ReadCoord ();
  state->origin[2] = MSG_ReadCoord ();

  state->frame = MSG_ReadByte ();

  // the other player's last move was likely some time
  // before the packet was sent out, so accurately track
  // the exact time it was valid at
  if (flags & PF_MSEC)
  {
    msec = MSG_ReadByte ();
    state->state_time = parsecounttime - msec*0.001;
  }
  else
    state->state_time = parsecounttime;

  if (flags & PF_COMMAND)
    MSG_ReadDeltaUsercmd (&nullcmd, &state->command);

  for (i=0 ; i<3 ; i++)
  {
    if (flags & (PF_VELOCITY1<<i) )
      state->velocity[i] = MSG_ReadShort();
    else
      state->velocity[i] = 0;
  }
  if (flags & PF_MODEL)
    state->modelindex = MSG_ReadByte ();
  else
    state->modelindex = cl_playerindex;

  if (flags & PF_SKINNUM)
    state->skinnum = MSG_ReadByte ();
  else
    state->skinnum = 0;

  if (flags & PF_EFFECTS)
    state->effects = MSG_ReadByte ();
  else
    state->effects = 0;

  if (flags & PF_WEAPONFRAME)
    state->weaponframe = MSG_ReadByte ();
  else
    state->weaponframe = 0;

  VectorCopy (state->command.angles, state->viewangles);
}


/*
================
CL_AddFlagModels

Called when the CTF flags are set
================
*/
void CL_AddFlagModels (entity_t *ent, int team)
{
  int   i;
  float f;
  vec3_t  v_forward, v_right, v_up;
  entity_t  *newent;

  if (cl_flagindex == -1)
    return;

  f = 14;
  if (ent->frame >= 29 && ent->frame <= 40) {
    if (ent->frame >= 29 && ent->frame <= 34) { //axpain
      if      (ent->frame == 29) f = f + 2; 
      else if (ent->frame == 30) f = f + 8;
      else if (ent->frame == 31) f = f + 12;
      else if (ent->frame == 32) f = f + 11;
      else if (ent->frame == 33) f = f + 10;
      else if (ent->frame == 34) f = f + 4;
    } else if (ent->frame >= 35 && ent->frame <= 40) { // pain
      if      (ent->frame == 35) f = f + 2; 
      else if (ent->frame == 36) f = f + 10;
      else if (ent->frame == 37) f = f + 10;
      else if (ent->frame == 38) f = f + 8;
      else if (ent->frame == 39) f = f + 4;
      else if (ent->frame == 40) f = f + 2;
    }
  } else if (ent->frame >= 103 && ent->frame <= 118) {
    if      (ent->frame >= 103 && ent->frame <= 104) f = f + 6;  //nailattack
    else if (ent->frame >= 105 && ent->frame <= 106) f = f + 6;  //light 
    else if (ent->frame >= 107 && ent->frame <= 112) f = f + 7;  //rocketattack
    else if (ent->frame >= 112 && ent->frame <= 118) f = f + 7;  //shotattack
  }

  newent = CL_NewTempEntity ();
  newent->model = cl.model_precache[cl_flagindex];
  newent->skinnum = team;

  AngleVectors (ent->angles, v_forward, v_right, v_up);
  v_forward[2] = -v_forward[2]; // reverse z component
  for (i=0 ; i<3 ; i++)
    newent->origin[i] = ent->origin[i] - f*v_forward[i] + 22*v_right[i];
  newent->origin[2] -= 16;

  VectorCopy (ent->angles, newent->angles)
  newent->angles[2] -= 45;
}

/*
=============
CL_LinkPlayers

Create visible entities in the correct position
for all current players
=============
*/
void CL_LinkPlayers (void)
{
  int       j;
  player_info_t *info;
  player_state_t  *state;
  player_state_t  exact;
  double      playertime;
  entity_t    *ent;
  int       msec;
  frame_t     *frame;
  int       oldphysent;

  playertime = realtime - cls.latency + 0.02;
  if (playertime > realtime)
    playertime = realtime;

  frame = &cl.frames[cl.parsecount&UPDATE_MASK];

  for (j=0, info=cl.players, state=frame->playerstate ; j < MAX_CLIENTS 
    ; j++, info++, state++)
  {
    if (state->messagenum != cl.parsecount)
      continue; // not present this frame

    // spawn light flashes, even ones coming from invisible objects
#ifdef GLQUAKE
    if (!gl_flashblend.value || j != cl.playernum) {
#endif
      if ((state->effects & (EF_BLUE | EF_RED)) == (EF_BLUE | EF_RED))
        CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 3);
      else if (state->effects & EF_BLUE)
        CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 1);
      else if (state->effects & EF_RED)
        CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 2);
      else if (state->effects & EF_BRIGHTLIGHT)
        CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2] + 16, 400 + (rand()&31), 0.1, 0);
      else if (state->effects & EF_DIMLIGHT)
        CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 0);
#ifdef GLQUAKE
    }
#endif

    // the player object never gets added
    if (j == cl.playernum)
      continue;

    if (!state->modelindex)
      continue;

    if (!Cam_DrawPlayer(j))
      continue;

    // grab an entity to fill in
    if (cl_numvisedicts == MAX_VISEDICTS)
      break;    // object list is full
    ent = &cl_visedicts[cl_numvisedicts];
    cl_numvisedicts++;
    ent->keynum = 0;

    ent->model = cl.model_precache[state->modelindex];
    ent->skinnum = state->skinnum;
    ent->frame = state->frame;
    ent->colormap = info->translations;
    if (state->modelindex == cl_playerindex)
      ent->scoreboard = info;   // use custom skin
    else
      ent->scoreboard = NULL;

    //
    // angles
    //
    ent->angles[PITCH] = -state->viewangles[PITCH]/3;
    ent->angles[YAW] = state->viewangles[YAW];
    ent->angles[ROLL] = 0;
    ent->angles[ROLL] = V_CalcRoll (ent->angles, state->velocity)*4;

    // only predict half the move to minimize overruns
    msec = 500*(playertime - state->state_time);
    if (msec <= 0 || (!cl_predict_players.value && !cl_predict_players2.value))
    {
      VectorCopy (state->origin, ent->origin);
//Con_DPrintf ("nopredict\n");
    }
    else
    {
      // predict players movement
      if (msec > 255)
        msec = 255;
      state->command.msec = msec;
//Con_DPrintf ("predict: %i\n", msec);

      oldphysent = pmove.numphysent;
      CL_SetSolidPlayers (j);
      CL_PredictUsercmd (state, &exact, &state->command, false);
      pmove.numphysent = oldphysent;
      VectorCopy (exact.origin, ent->origin);
    }

    if (state->effects & EF_FLAG1)
      CL_AddFlagModels (ent, 0);
    else if (state->effects & EF_FLAG2)
      CL_AddFlagModels (ent, 1);

  }
}

//======================================================================

/*
===============
CL_SetSolid

Builds all the pmove physents for the current frame
===============
*/
void CL_SetSolidEntities (void)
{
  int   i;
  frame_t *frame;
  packet_entities_t *pak;
  entity_state_t    *state;

  pmove.physents[0].model = cl.worldmodel;
  VectorCopy (vec3_origin, pmove.physents[0].origin);
  pmove.physents[0].info = 0;
  pmove.numphysent = 1;

  frame = &cl.frames[parsecountmod];
  pak = &frame->packet_entities;

  for (i=0 ; i<pak->num_entities ; i++)
  {
    state = &pak->entities[i];

    if (!state->modelindex)
      continue;
    if (!cl.model_precache[state->modelindex])
      continue;
    if ( cl.model_precache[state->modelindex]->hulls[1].firstclipnode 
      || cl.model_precache[state->modelindex]->clipbox )
    {
      pmove.physents[pmove.numphysent].model = cl.model_precache[state->modelindex];
      VectorCopy (state->origin, pmove.physents[pmove.numphysent].origin);
      pmove.numphysent++;
    }
  }

}

/*
===
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(qboolean dopred)
{
  int       j;
  player_state_t  *state;
  player_state_t  exact;
  double      playertime;
  int       msec;
  frame_t     *frame;
  struct predicted_player *pplayer;

  playertime = realtime - cls.latency + 0.02;
  if (playertime > realtime)
    playertime = realtime;

  frame = &cl.frames[cl.parsecount&UPDATE_MASK];

  for (j=0, pplayer = predicted_players, state=frame->playerstate; 
    j < MAX_CLIENTS;
    j++, pplayer++, state++) {

    pplayer->active = false;

    if (state->messagenum != cl.parsecount)
      continue; // not present this frame

    if (!state->modelindex)
      continue;

    pplayer->active = true;
    pplayer->flags = state->flags;

    // note that the local player is special, since he moves locally
    // we use his last predicted postition
    if (j == cl.playernum) {
      VectorCopy(cl.frames[cls.netchan.outgoing_sequence&UPDATE_MASK].playerstate[cl.playernum].origin,
        pplayer->origin);
    } else {
      // only predict half the move to minimize overruns
      msec = 500*(playertime - state->state_time);
      if (msec <= 0 ||
        (!cl_predict_players.value && !cl_predict_players2.value) ||
        !dopred)
      {
        VectorCopy (state->origin, pplayer->origin);
  //Con_DPrintf ("nopredict\n");
      }
      else
      {
        // predict players movement
        if (msec > 255)
          msec = 255;
        state->command.msec = msec;
  //Con_DPrintf ("predict: %i\n", msec);

        CL_PredictUsercmd (state, &exact, &state->command, false);
        VectorCopy (exact.origin, pplayer->origin);
      }
    }
  }
}

/*
===============
CL_SetSolid

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)
{
  int   j;
  extern  vec3_t  player_mins;
  extern  vec3_t  player_maxs;
  struct predicted_player *pplayer;
  physent_t *pent;

  if (!cl_solid_players.value)
    return;

  pent = pmove.physents + pmove.numphysent;

  for (j=0, pplayer = predicted_players; j < MAX_CLIENTS; j++, pplayer++) {

    if (!pplayer->active)
      continue; // not present this frame

    // the player object never gets added
    if (j == playernum)
      continue;

    if (pplayer->flags & PF_DEAD)
      continue; // dead players aren't solid

    pent->model = 0;
    VectorCopy(pplayer->origin, pent->origin);
    VectorCopy(player_mins, pent->mins);
    VectorCopy(player_maxs, pent->maxs);
    pmove.numphysent++;
    pent++;
  }
}


/*
===============
CL_EmitEntities

Builds the visedicts array for cl.time

Made up of: clients, packet_entities, nails, and tents
===============
*/
void CL_EmitEntities (void)
{
  if (cls.state != ca_active)
    return;
  if (!cl.validsequence)
    return;

  cl_oldnumvisedicts = cl_numvisedicts;
  cl_oldvisedicts = cl_visedicts_list[(cls.netchan.incoming_sequence-1)&1];
  cl_visedicts = cl_visedicts_list[cls.netchan.incoming_sequence&1];

  cl_numvisedicts = 0;

  CL_LinkPlayers ();
  CL_LinkPacketEntities ();
  CL_LinkProjectiles ();
  CL_UpdateTEnts ();
}