/*
==================
CL_ParseUpdate
Parse an entity update message from the server
If an entities model or origin changes from frame to frame, it must be
relinked. Other attributes can change without relinking.
==================
*/
void CL_ParseUpdate (int bits)
{
int i;
qmodel_t *model;
int modnum;
qboolean forcelink;
entity_t *ent;
int num;
int skin;
if (cls.signon == SIGNONS - 1)
{ // first update is the final signon stage
cls.signon = SIGNONS;
CL_SignonReply ();
}
if (bits & U_MOREBITS)
{
i = MSG_ReadByte ();
bits |= (i<<8);
}
//johnfitz -- PROTOCOL_FITZQUAKE
if (cl.protocol == PROTOCOL_FITZQUAKE)
{
if (bits & U_EXTEND1)
bits |= MSG_ReadByte() << 16;
if (bits & U_EXTEND2)
bits |= MSG_ReadByte() << 24;
}
//johnfitz
if (bits & U_LONGENTITY)
num = MSG_ReadShort ();
else
num = MSG_ReadByte ();
ent = CL_EntityNum (num);
if (ent->msgtime != cl.mtime[1])
forcelink = true; // no previous frame to lerp from
else
forcelink = false;
//johnfitz -- lerping
if (ent->msgtime + 0.2 < cl.mtime[0]) //more than 0.2 seconds since the last message (most entities think every 0.1 sec)
ent->lerpflags |= LERP_RESETANIM; //if we missed a think, we'd be lerping from the wrong frame
//johnfitz
ent->msgtime = cl.mtime[0];
if (bits & U_MODEL)
{
modnum = MSG_ReadByte ();
if (modnum >= MAX_MODELS)
Host_Error ("CL_ParseModel: bad modnum");
}
else
modnum = ent->baseline.modelindex;
if (bits & U_FRAME)
ent->frame = MSG_ReadByte ();
else
ent->frame = ent->baseline.frame;
if (bits & U_COLORMAP)
i = MSG_ReadByte();
else
i = ent->baseline.colormap;
if (!i)
ent->colormap = vid.colormap;
else
{
if (i > cl.maxclients)
Sys_Error ("i >= cl.maxclients");
ent->colormap = cl.scores[i-1].translations;
}
if (bits & U_SKIN)
skin = MSG_ReadByte();
else
skin = ent->baseline.skin;
if (skin != ent->skinnum)
{
ent->skinnum = skin;
if (num > 0 && num <= cl.maxclients)
R_TranslateNewPlayerSkin (num - 1); //johnfitz -- was R_TranslatePlayerSkin
}
if (bits & U_EFFECTS)
ent->effects = MSG_ReadByte();
else
ent->effects = ent->baseline.effects;
// shift the known values for interpolation
VectorCopy (ent->msg_origins[0], ent->msg_origins[1]);
VectorCopy (ent->msg_angles[0], ent->msg_angles[1]);
if (bits & U_ORIGIN1)
ent->msg_origins[0][0] = MSG_ReadCoord ();
else
ent->msg_origins[0][0] = ent->baseline.origin[0];
if (bits & U_ANGLE1)
ent->msg_angles[0][0] = MSG_ReadAngle();
else
ent->msg_angles[0][0] = ent->baseline.angles[0];
if (bits & U_ORIGIN2)
ent->msg_origins[0][1] = MSG_ReadCoord ();
else
ent->msg_origins[0][1] = ent->baseline.origin[1];
if (bits & U_ANGLE2)
ent->msg_angles[0][1] = MSG_ReadAngle();
else
ent->msg_angles[0][1] = ent->baseline.angles[1];
if (bits & U_ORIGIN3)
ent->msg_origins[0][2] = MSG_ReadCoord ();
else
ent->msg_origins[0][2] = ent->baseline.origin[2];
if (bits & U_ANGLE3)
ent->msg_angles[0][2] = MSG_ReadAngle();
else
ent->msg_angles[0][2] = ent->baseline.angles[2];
//johnfitz -- lerping for movetype_step entities
if (bits & U_STEP)
{
ent->lerpflags |= LERP_MOVESTEP;
ent->forcelink = true;
}
else
ent->lerpflags &= ~LERP_MOVESTEP;
//johnfitz
//johnfitz -- PROTOCOL_FITZQUAKE and PROTOCOL_NEHAHRA
if (cl.protocol == PROTOCOL_FITZQUAKE)
{
if (bits & U_ALPHA)
ent->alpha = MSG_ReadByte();
else
ent->alpha = ent->baseline.alpha;
if (bits & U_FRAME2)
ent->frame = (ent->frame & 0x00FF) | (MSG_ReadByte() << 8);
if (bits & U_MODEL2)
modnum = (modnum & 0x00FF) | (MSG_ReadByte() << 8);
if (bits & U_LERPFINISH)
{
ent->lerpfinish = ent->msgtime + ((float)(MSG_ReadByte()) / 255);
ent->lerpflags |= LERP_FINISH;
}
else
ent->lerpflags &= ~LERP_FINISH;
}
else if (cl.protocol == PROTOCOL_NETQUAKE)
{
//HACK: if this bit is set, assume this is PROTOCOL_NEHAHRA
if (bits & U_TRANS)
{
float a, b;
if (warn_about_nehahra_protocol)
{
Con_Warning ("nonstandard update bit, assuming Nehahra protocol\n");
warn_about_nehahra_protocol = false;
}
a = MSG_ReadFloat();
b = MSG_ReadFloat(); //alpha
if (a == 2)
MSG_ReadFloat(); //fullbright (not using this yet)
ent->alpha = ENTALPHA_ENCODE(b);
}
else
ent->alpha = ent->baseline.alpha;
}
//johnfitz
//johnfitz -- moved here from above
model = cl.model_precache[modnum];
if (model != ent->model)
{
ent->model = model;
// automatic animation (torches, etc) can be either all together
// or randomized
if (model)
{
if (model->synctype == ST_RAND)
ent->syncbase = (float)(rand()&0x7fff) / 0x7fff;
else
ent->syncbase = 0.0;
}
else
forcelink = true; // hack to make null model players work
if (num > 0 && num <= cl.maxclients)
R_TranslateNewPlayerSkin (num - 1); //johnfitz -- was R_TranslatePlayerSkin
ent->lerpflags |= LERP_RESETANIM; //johnfitz -- don't lerp animation across model changes
}
//johnfitz
if ( forcelink )
{ // didn't have an update last message
VectorCopy (ent->msg_origins[0], ent->msg_origins[1]);
VectorCopy (ent->msg_origins[0], ent->origin);
VectorCopy (ent->msg_angles[0], ent->msg_angles[1]);
VectorCopy (ent->msg_angles[0], ent->angles);
ent->forcelink = true;
}
}
/*
====================
ED_ParseEdict
Parses an edict out of the given string, returning the new position
ed should be a properly initialized empty edict.
Used for initial level load and for savegames.
====================
*/
const char *ED_ParseEdict (const char *data, edict_t *ent)
{
ddef_t *key;
char keyname[256];
qboolean anglehack, init;
int n;
init = false;
// clear it
if (ent != sv.edicts) // hack
memset (&ent->v, 0, progs->entityfields * 4);
// go through all the dictionary pairs
while (1)
{
// parse key
data = COM_Parse (data);
if (com_token[0] == '}')
break;
if (!data)
Host_Error ("ED_ParseEntity: EOF without closing brace");
// anglehack is to allow QuakeEd to write single scalar angles
// and allow them to be turned into vectors. (FIXME...)
if (!strcmp(com_token, "angle"))
{
strcpy (com_token, "angles");
anglehack = true;
}
else
anglehack = false;
// FIXME: change light to _light to get rid of this hack
if (!strcmp(com_token, "light"))
strcpy (com_token, "light_lev"); // hack for single light def
strcpy (keyname, com_token);
// another hack to fix keynames with trailing spaces
n = strlen(keyname);
while (n && keyname[n-1] == ' ')
{
keyname[n-1] = 0;
n--;
}
// parse value
data = COM_Parse (data);
if (!data)
Host_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
Host_Error ("ED_ParseEntity: closing brace without data");
init = true;
// keynames with a leading underscore are used for utility comments,
// and are immediately discarded by quake
if (keyname[0] == '_')
continue;
//johnfitz -- hack to support .alpha even when progs.dat doesn't know about it
if (!strcmp(keyname, "alpha"))
ent->alpha = ENTALPHA_ENCODE(atof(com_token));
//johnfitz
key = ED_FindField (keyname);
if (!key)
{
//johnfitz -- HACK -- suppress error becuase fog/sky/alpha fields might not be mentioned in defs.qc
if (strncmp(keyname, "sky", 3) && strcmp(keyname, "fog") && strcmp(keyname, "alpha"))
Con_DPrintf ("\"%s\" is not a field\n", keyname); //johnfitz -- was Con_Printf
continue;
}
if (anglehack)
{
char temp[32];
strcpy (temp, com_token);
sprintf (com_token, "0 %s 0", temp);
}
if (!ED_ParseEpair ((void *)&ent->v, key, com_token))
Host_Error ("ED_ParseEdict: parse error");
}
if (!init)
ent->free = true;
return data;
}
