qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-02-17 01:11:45 +00:00
Code Issues Projects Releases Packages Wiki Activity

[qw] Use entity_state_t as a base for player_state_t

Browse source 
This will, in the long run, help clean up a lot of the differences in
the handling of entities in the clients.
This commit is contained in:
Bill Currie 2021-03-11 14:27:36 +09:00
parent c9bbc2971a
commit ca38f9b616
11 changed files with 225 additions and 238 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
include/client/entities.h
View file

@ -40,9 +40,11 @@ typedef struct entity_state_s {
unsigned flags; // nolerp, etc unsigned flags; // nolerp, etc
vec3_t origin; vec3_t origin;
vec3_t velocity;
vec3_t angles; vec3_t angles;
unsigned short modelindex; uint16_t modelindex;
unsigned short frame; uint16_t frame;
int weaponframe;
int effects; int effects;
byte colormap; byte colormap;
byte skinnum; byte skinnum;

19
include/qw/protocol.h
View file

@ -320,26 +320,9 @@ typedef struct usercmd_s {
} usercmd_t; } usercmd_t;
typedef struct plent_state_s { typedef struct plent_state_s {
int number; entity_state_t es;
unsigned int flags;
vec3_t origin;
usercmd_t cmd; usercmd_t cmd;
vec3_t velocity;
int modelindex;
int frame;
int skinnum;
int effects;
int weaponframe;
byte msec; byte msec;
// QSG 2
byte alpha;
byte scale;
byte glow_size;
byte glow_color;
byte colormod;
} plent_state_t; } plent_state_t;
typedef struct { typedef struct {

60
qtv/source/client.c
View file

@ -446,9 +446,9 @@ spectator_move (client_t *cl, usercmd_t *ucmd)
AngleVectors (cl->state.cmd.angles, forward, right, up); AngleVectors (cl->state.cmd.angles, forward, right, up);
speed = DotProduct (cl->state.velocity, cl->state.velocity); speed = DotProduct (cl->state.es.velocity, cl->state.es.velocity);
if (speed < 1) { if (speed < 1) {
VectorZero (cl->state.velocity); VectorZero (cl->state.es.velocity);
} else { } else {
speed = sqrt (speed); speed = sqrt (speed);
drop = 0; drop = 0;
@ -462,7 +462,7 @@ spectator_move (client_t *cl, usercmd_t *ucmd)
newspeed = 0; newspeed = 0;
newspeed /= speed; newspeed /= speed;
VectorScale (cl->state.velocity, newspeed, cl->state.velocity); VectorScale (cl->state.es.velocity, newspeed, cl->state.es.velocity);
} }
fmove = ucmd->forwardmove; fmove = ucmd->forwardmove;
@ -484,7 +484,7 @@ spectator_move (client_t *cl, usercmd_t *ucmd)
wishspeed = sv->movevars.spectatormaxspeed; wishspeed = sv->movevars.spectatormaxspeed;
} }
currentspeed = DotProduct (cl->state.velocity, wishdir); currentspeed = DotProduct (cl->state.es.velocity, wishdir);
addspeed = wishspeed - currentspeed; addspeed = wishspeed - currentspeed;
if (addspeed <= 0) if (addspeed <= 0)
return; return;
@ -492,10 +492,10 @@ spectator_move (client_t *cl, usercmd_t *ucmd)
if (accelspeed > addspeed) if (accelspeed > addspeed)
accelspeed = addspeed; accelspeed = addspeed;
VectorMultAdd (cl->state.velocity, accelspeed, wishdir, VectorMultAdd (cl->state.es.velocity, accelspeed, wishdir,
cl->state.velocity); cl->state.es.velocity);
VectorMultAdd (cl->state.origin, frametime, cl->state.velocity, VectorMultAdd (cl->state.es.origin, frametime, cl->state.es.velocity,
cl->state.origin); cl->state.es.origin);
} }
static void static void
@ -612,7 +612,7 @@ client_parse_message (client_t *cl)
break; break;
case clc_tmove: case clc_tmove:
MSG_ReadCoordV (net_message, o); MSG_ReadCoordV (net_message, o);
VectorCopy (o, cl->state.origin); VectorCopy (o, cl->state.es.origin);
break; break;
case clc_upload: case clc_upload:
size = MSG_ReadShort (net_message); size = MSG_ReadShort (net_message);
@ -627,18 +627,18 @@ static void
write_player (int num, plent_state_t *pl, server_t *sv, sizebuf_t *msg) write_player (int num, plent_state_t *pl, server_t *sv, sizebuf_t *msg)
{ {
int i; int i;
int pflags = (pl->flags & (PF_GIB | PF_DEAD)) int pflags = (pl->es.flags & (PF_GIB | PF_DEAD))
| PF_MSEC | PF_COMMAND; | PF_MSEC | PF_COMMAND;
int qf_bits = 0; int qf_bits = 0;
if (pl->modelindex != sv->playermodel) if (pl->es.modelindex != sv->playermodel)
pflags |= PF_MODEL; pflags |= PF_MODEL;
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
if (pl->velocity[i]) if (pl->es.velocity[i])
pflags |= PF_VELOCITY1 << i; pflags |= PF_VELOCITY1 << i;
if (pl->effects & 0xff) if (pl->es.effects & 0xff)
pflags |= PF_EFFECTS; pflags |= PF_EFFECTS;
if (pl->skinnum) if (pl->es.skinnum)
pflags |= PF_SKINNUM; pflags |= PF_SKINNUM;
qf_bits = 0; qf_bits = 0;
@ -670,21 +670,21 @@ write_player (int num, plent_state_t *pl, server_t *sv, sizebuf_t *msg)
// } else if (ent == clent) { // } else if (ent == clent) {
// // don't send a lot of data on personal entity // // don't send a lot of data on personal entity
// pflags &= ~(PF_MSEC | PF_COMMAND); // pflags &= ~(PF_MSEC | PF_COMMAND);
// if (pl->weaponframe) // if (pl->es.weaponframe)
// pflags |= PF_WEAPONFRAME; // pflags |= PF_WEAPONFRAME;
// } // }
// if (client->spec_track && client->spec_track - 1 == j // if (client->spec_track && client->spec_track - 1 == j
// && pl->weaponframe) // && pl->es.weaponframe)
// pflags |= PF_WEAPONFRAME; // pflags |= PF_WEAPONFRAME;
MSG_WriteByte (msg, svc_playerinfo); MSG_WriteByte (msg, svc_playerinfo);
MSG_WriteByte (msg, num); MSG_WriteByte (msg, num);
MSG_WriteShort (msg, pflags); MSG_WriteShort (msg, pflags);
MSG_WriteCoordV (msg, pl->origin); MSG_WriteCoordV (msg, pl->es.origin);
MSG_WriteByte (msg, pl->frame); MSG_WriteByte (msg, pl->es.frame);
if (pflags & PF_MSEC) { if (pflags & PF_MSEC) {
//msec = 1000 * (sv.time - cl->localtime); //msec = 1000 * (sv.time - cl->localtime);
@ -699,36 +699,36 @@ write_player (int num, plent_state_t *pl, server_t *sv, sizebuf_t *msg)
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
if (pflags & (PF_VELOCITY1 << i)) if (pflags & (PF_VELOCITY1 << i))
MSG_WriteShort (msg, pl->velocity[i]); MSG_WriteShort (msg, pl->es.velocity[i]);
if (pflags & PF_MODEL) if (pflags & PF_MODEL)
MSG_WriteByte (msg, pl->modelindex); MSG_WriteByte (msg, pl->es.modelindex);
if (pflags & PF_SKINNUM) if (pflags & PF_SKINNUM)
MSG_WriteByte (msg, pl->skinnum); MSG_WriteByte (msg, pl->es.skinnum);
if (pflags & PF_EFFECTS) if (pflags & PF_EFFECTS)
MSG_WriteByte (msg, pl->effects); MSG_WriteByte (msg, pl->es.effects);
if (pflags & PF_WEAPONFRAME) if (pflags & PF_WEAPONFRAME)
MSG_WriteByte (msg, pl->weaponframe); MSG_WriteByte (msg, pl->es.weaponframe);
if (pflags & PF_QF) { if (pflags & PF_QF) {
MSG_WriteByte (msg, qf_bits); MSG_WriteByte (msg, qf_bits);
if (qf_bits & PF_ALPHA) if (qf_bits & PF_ALPHA)
MSG_WriteByte (msg, pl->alpha); MSG_WriteByte (msg, pl->es.alpha);
if (qf_bits & PF_SCALE) if (qf_bits & PF_SCALE)
MSG_WriteByte (msg, pl->scale); MSG_WriteByte (msg, pl->es.scale);
if (qf_bits & PF_EFFECTS2) if (qf_bits & PF_EFFECTS2)
MSG_WriteByte (msg, pl->effects >> 8); MSG_WriteByte (msg, pl->es.effects >> 8);
if (qf_bits & PF_GLOWSIZE) if (qf_bits & PF_GLOWSIZE)
MSG_WriteByte (msg, pl->scale); MSG_WriteByte (msg, pl->es.glow_size);
if (qf_bits & PF_GLOWCOLOR) if (qf_bits & PF_GLOWCOLOR)
MSG_WriteByte (msg, pl->glow_color); MSG_WriteByte (msg, pl->es.glow_color);
if (qf_bits & PF_COLORMOD) if (qf_bits & PF_COLORMOD)
MSG_WriteByte (msg, pl->colormod); MSG_WriteByte (msg, pl->es.colormod);
if (qf_bits & PF_FRAME2) if (qf_bits & PF_FRAME2)
MSG_WriteByte (msg, pl->frame >> 8); MSG_WriteByte (msg, pl->es.frame >> 8);
} }
} }
#if 0 #if 0

46
qtv/source/sv_parse.c
View file

@ -514,9 +514,9 @@ parse_player_delta (qmsg_t *msg, plent_state_t *from, plent_state_t *to)
int i; int i;
int flags; int flags;
flags = to->flags = MSG_ReadShort (msg); flags = to->es.flags = MSG_ReadShort (msg);
MSG_ReadCoordV (msg, to->origin); MSG_ReadCoordV (msg, to->es.origin);
to->frame = (to->frame & 0xff00) | MSG_ReadByte (msg); to->es.frame = (to->es.frame & 0xff00) | MSG_ReadByte (msg);
if (flags & PF_MSEC) if (flags & PF_MSEC)
to->msec = MSG_ReadByte (msg); to->msec = MSG_ReadByte (msg);
// qtv_printf ("%02x\n", msg->message->data[msg->readcount]); // qtv_printf ("%02x\n", msg->message->data[msg->readcount]);
@ -524,36 +524,36 @@ parse_player_delta (qmsg_t *msg, plent_state_t *from, plent_state_t *to)
MSG_ReadDeltaUsercmd (msg, &from->cmd, &to->cmd); MSG_ReadDeltaUsercmd (msg, &from->cmd, &to->cmd);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
if (flags & (PF_VELOCITY1 << i)) if (flags & (PF_VELOCITY1 << i))
to->velocity[i] = (short) MSG_ReadShort (msg); to->es.velocity[i] = (short) MSG_ReadShort (msg);
} }
if (flags & PF_MODEL) if (flags & PF_MODEL)
to->modelindex = MSG_ReadByte (msg); to->es.modelindex = MSG_ReadByte (msg);
if (flags & PF_SKINNUM) if (flags & PF_SKINNUM)
to->skinnum = MSG_ReadByte (msg); to->es.skinnum = MSG_ReadByte (msg);
if (flags & PF_EFFECTS) if (flags & PF_EFFECTS)
to->effects = (to->effects & 0xff00) | MSG_ReadByte (msg); to->es.effects = (to->es.effects & 0xff00) | MSG_ReadByte (msg);
if (flags & PF_WEAPONFRAME) if (flags & PF_WEAPONFRAME)
to->weaponframe = MSG_ReadByte (msg); to->es.weaponframe = MSG_ReadByte (msg);
if (flags & PF_QF) { if (flags & PF_QF) {
int bits; int bits;
bits = MSG_ReadByte (msg); bits = MSG_ReadByte (msg);
if (bits & PF_ALPHA) if (bits & PF_ALPHA)
to->alpha = MSG_ReadByte (msg); to->es.alpha = MSG_ReadByte (msg);
if (bits & PF_SCALE) if (bits & PF_SCALE)
to->scale = MSG_ReadByte (msg); to->es.scale = MSG_ReadByte (msg);
if (bits & PF_EFFECTS2) if (bits & PF_EFFECTS2)
to->effects = (to->effects & 0x00ff) to->es.effects = (to->es.effects & 0x00ff)
| (MSG_ReadByte (msg) << 8); | (MSG_ReadByte (msg) << 8);
if (bits & PF_GLOWSIZE) if (bits & PF_GLOWSIZE)
to->glow_size = MSG_ReadByte (msg); to->es.glow_size = MSG_ReadByte (msg);
if (bits & PF_GLOWCOLOR) if (bits & PF_GLOWCOLOR)
to->glow_color = MSG_ReadByte (msg); to->es.glow_color = MSG_ReadByte (msg);
if (bits & PF_COLORMOD) if (bits & PF_COLORMOD)
to->colormod = MSG_ReadByte (msg); to->es.colormod = MSG_ReadByte (msg);
if (bits & PF_FRAME2) if (bits & PF_FRAME2)
to->frame = (to->frame & 0xff) to->es.frame = (to->es.frame & 0xff)
| (MSG_ReadByte (msg) << 8); | (MSG_ReadByte (msg) << 8);
} }
} }
@ -567,12 +567,12 @@ sv_playerinfo (server_t *sv, qmsg_t *msg)
int fromind, toind; int fromind, toind;
static plent_state_t null_player_state; static plent_state_t null_player_state;
if (!null_player_state.alpha) { if (!null_player_state.es.alpha) {
null_player_state.alpha = 255; null_player_state.es.alpha = 255;
null_player_state.scale = 16; null_player_state.es.scale = 16;
null_player_state.glow_size = 0; null_player_state.es.glow_size = 0;
null_player_state.glow_color = 254; null_player_state.es.glow_color = 254;
null_player_state.colormod = 255; null_player_state.es.colormod = 255;
} }
fromind = MSG_ReadByte (msg); fromind = MSG_ReadByte (msg);
toind = sv->netchan.incoming_sequence & UPDATE_MASK; toind = sv->netchan.incoming_sequence & UPDATE_MASK;

32
qw/source/cl_cam.c
View file

@ -218,23 +218,23 @@ Cam_TryFlyby (player_state_t * self, player_state_t * player, vec3_t vec,
vectoangles (vec, v); vectoangles (vec, v);
VectorCopy (v, pmove.angles); VectorCopy (v, pmove.angles);
VectorNormalize (vec); VectorNormalize (vec);
VectorMultAdd (player->pls.origin, 800, vec, v); VectorMultAdd (player->pls.es.origin, 800, vec, v);
// v is endpos // v is endpos
// fake a player move // fake a player move
trace = Cam_DoTrace (player->pls.origin, v); trace = Cam_DoTrace (player->pls.es.origin, v);
if ( /* trace.inopen || */ trace.inwater) if ( /* trace.inopen || */ trace.inwater)
return 9999; return 9999;
VectorCopy (trace.endpos, vec); VectorCopy (trace.endpos, vec);
len = VectorDistance (trace.endpos, player->pls.origin); len = VectorDistance (trace.endpos, player->pls.es.origin);
if (len < 32 || len > 800) if (len < 32 || len > 800)
return 9999; return 9999;
if (checkvis) { if (checkvis) {
trace = Cam_DoTrace (self->pls.origin, vec); trace = Cam_DoTrace (self->pls.es.origin, vec);
if (trace.fraction != 1 || trace.inwater) if (trace.fraction != 1 || trace.inwater)
return 9999; return 9999;
len = VectorDistance (trace.endpos, self->pls.origin); len = VectorDistance (trace.endpos, self->pls.es.origin);
} }
return len; return len;
@ -248,11 +248,11 @@ Cam_IsVisible (player_state_t * player, vec3_t vec)
trace_t trace; trace_t trace;
vec3_t v; vec3_t v;
trace = Cam_DoTrace (player->pls.origin, vec); trace = Cam_DoTrace (player->pls.es.origin, vec);
if (trace.fraction != 1 || /* trace.inopen || */ trace.inwater) if (trace.fraction != 1 || /* trace.inopen || */ trace.inwater)
return false; return false;
// check distance, don't let the player get too far away or too close // check distance, don't let the player get too far away or too close
VectorSubtract (player->pls.origin, vec, v); VectorSubtract (player->pls.es.origin, vec, v);
d = VectorLength (v); d = VectorLength (v);
return (d > 16.0); return (d > 16.0);
@ -440,22 +440,22 @@ Cam_Track (usercmd_t *cmd)
cmd->forwardmove = cmd->sidemove = cmd->upmove = 0; cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
VectorCopy (player->viewangles, cl.viewangles); VectorCopy (player->viewangles, cl.viewangles);
VectorCopy (player->pls.origin, desired_position); VectorCopy (player->pls.es.origin, desired_position);
if (memcmp (&desired_position, &self->pls.origin, if (memcmp (&desired_position, &self->pls.es.origin,
sizeof (desired_position)) != 0) { sizeof (desired_position)) != 0) {
if (!cls.demoplayback) { if (!cls.demoplayback) {
MSG_WriteByte (&cls.netchan.message, clc_tmove); MSG_WriteByte (&cls.netchan.message, clc_tmove);
MSG_WriteCoordV (&cls.netchan.message, desired_position); MSG_WriteCoordV (&cls.netchan.message, desired_position);
} }
// move there locally immediately // move there locally immediately
VectorCopy (desired_position, self->pls.origin); VectorCopy (desired_position, self->pls.es.origin);
} }
self->pls.weaponframe = player->pls.weaponframe; self->pls.es.weaponframe = player->pls.es.weaponframe;
} else { } else {
// Ok, move to our desired position and set our angles to view // Ok, move to our desired position and set our angles to view
// the player // the player
VectorSubtract (desired_position, self->pls.origin, vec); VectorSubtract (desired_position, self->pls.es.origin, vec);
len = VectorLength (vec); len = VectorLength (vec);
cmd->forwardmove = cmd->sidemove = cmd->upmove = 0; cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
if (len > 16) { // close enough? if (len > 16) { // close enough?
@ -465,9 +465,9 @@ Cam_Track (usercmd_t *cmd)
} }
} }
// move there locally immediately // move there locally immediately
VectorCopy (desired_position, self->pls.origin); VectorCopy (desired_position, self->pls.es.origin);
VectorSubtract (player->pls.origin, desired_position, vec); VectorSubtract (player->pls.es.origin, desired_position, vec);
vectoangles (vec, cl.viewangles); vectoangles (vec, cl.viewangles);
cl.viewangles[0] = -cl.viewangles[0]; cl.viewangles[0] = -cl.viewangles[0];
} }
@ -520,7 +520,7 @@ Cam_SetView (void)
player = frame->playerstate + spec_track; player = frame->playerstate + spec_track;
self = frame->playerstate + cl.playernum; self = frame->playerstate + cl.playernum;
VectorSubtract (player->pls.origin, cl.simorg, vec); VectorSubtract (player->pls.es.origin, cl.simorg, vec);
if (cam_forceview) { if (cam_forceview) {
cam_forceview = false; cam_forceview = false;
vectoangles (vec, cam_viewangles); vectoangles (vec, cam_viewangles);
@ -560,7 +560,7 @@ Cam_FinishMove (usercmd_t *cmd)
player = frame->playerstate + spec_track; player = frame->playerstate + spec_track;
self = frame->playerstate + cl.playernum; self = frame->playerstate + cl.playernum;
VectorSubtract (player->pls.origin, self->pls.origin, vec); VectorSubtract (player->pls.es.origin, self->pls.es.origin, vec);
if (cam_forceview) { if (cam_forceview) {
cam_forceview = false; cam_forceview = false;
vectoangles (vec, cam_viewangles); vectoangles (vec, cam_viewangles);

61
qw/source/cl_entparse.c
View file

@ -360,7 +360,7 @@ CL_ParseDemoPlayerinfo (int num)
info = &cl.players[num]; info = &cl.players[num];
state = &cl.frames[parsecountmod].playerstate[num]; state = &cl.frames[parsecountmod].playerstate[num];
state->pls.number = num; state->pls.es.number = num;
if (info->prevcount > cl.parsecount || !cl.parsecount) { if (info->prevcount > cl.parsecount || !cl.parsecount) {
prevstate = &dummy; prevstate = &dummy;
@ -383,25 +383,25 @@ CL_ParseDemoPlayerinfo (int num)
memcpy (state, prevstate, sizeof (player_state_t)); memcpy (state, prevstate, sizeof (player_state_t));
flags = MSG_ReadShort (net_message); flags = MSG_ReadShort (net_message);
state->pls.flags = TranslateFlags (flags); state->pls.es.flags = TranslateFlags (flags);
state->messagenum = cl.parsecount; state->messagenum = cl.parsecount;
state->pls.cmd.msec = 0; state->pls.cmd.msec = 0;
state->pls.frame = MSG_ReadByte (net_message); state->pls.es.frame = MSG_ReadByte (net_message);
state->state_time = parsecounttime; state->state_time = parsecounttime;
for (i=0; i <3; i++) for (i=0; i <3; i++)
if (flags & (DF_ORIGIN << i)) if (flags & (DF_ORIGIN << i))
state->pls.origin[i] = MSG_ReadCoord (net_message); state->pls.es.origin[i] = MSG_ReadCoord (net_message);
for (i=0; i <3; i++) for (i=0; i <3; i++)
if (flags & (DF_ANGLES << i)) if (flags & (DF_ANGLES << i))
state->pls.cmd.angles[i] = MSG_ReadAngle16 (net_message); state->pls.cmd.angles[i] = MSG_ReadAngle16 (net_message);
if (flags & DF_MODEL) if (flags & DF_MODEL)
state->pls.modelindex = MSG_ReadByte (net_message); state->pls.es.modelindex = MSG_ReadByte (net_message);
if (flags & DF_SKINNUM) if (flags & DF_SKINNUM)
state->pls.skinnum = MSG_ReadByte (net_message); state->pls.es.skinnum = MSG_ReadByte (net_message);
if (flags & DF_EFFECTS) if (flags & DF_EFFECTS)
state->pls.effects = MSG_ReadByte (net_message); state->pls.es.effects = MSG_ReadByte (net_message);
if (flags & DF_WEAPONFRAME) if (flags & DF_WEAPONFRAME)
state->pls.weaponframe = MSG_ReadByte (net_message); state->pls.es.weaponframe = MSG_ReadByte (net_message);
VectorCopy (state->pls.cmd.angles, state->viewangles); VectorCopy (state->pls.cmd.angles, state->viewangles);
} }
@ -422,14 +422,14 @@ CL_ParsePlayerinfo (void)
state = &cl.frames[parsecountmod].playerstate[num]; state = &cl.frames[parsecountmod].playerstate[num];
state->pls.number = num; state->pls.es.number = num;
flags = state->pls.flags = MSG_ReadShort (net_message); flags = state->pls.es.flags = MSG_ReadShort (net_message);
state->messagenum = cl.parsecount; state->messagenum = cl.parsecount;
MSG_ReadCoordV (net_message, state->pls.origin); MSG_ReadCoordV (net_message, state->pls.es.origin);
state->pls.frame = MSG_ReadByte (net_message); state->pls.es.frame = MSG_ReadByte (net_message);
// the other player's last move was likely some time // the other player's last move was likely some time
// before the packet was sent out, so accurately track // before the packet was sent out, so accurately track
@ -445,30 +445,30 @@ CL_ParsePlayerinfo (void)
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
if (flags & (PF_VELOCITY1 << i)) if (flags & (PF_VELOCITY1 << i))
state->pls.velocity[i] = (short) MSG_ReadShort (net_message); state->pls.es.velocity[i] = (short) MSG_ReadShort (net_message);
else else
state->pls.velocity[i] = 0; state->pls.es.velocity[i] = 0;
} }
if (flags & PF_MODEL) if (flags & PF_MODEL)
i = MSG_ReadByte (net_message); i = MSG_ReadByte (net_message);
else else
i = cl_playerindex; i = cl_playerindex;
state->pls.modelindex = i; state->pls.es.modelindex = i;
if (flags & PF_SKINNUM) if (flags & PF_SKINNUM)
state->pls.skinnum = MSG_ReadByte (net_message); state->pls.es.skinnum = MSG_ReadByte (net_message);
else else
state->pls.skinnum = 0; state->pls.es.skinnum = 0;
if (flags & PF_EFFECTS) if (flags & PF_EFFECTS)
state->pls.effects = MSG_ReadByte (net_message); state->pls.es.effects = MSG_ReadByte (net_message);
else else
state->pls.effects = 0; state->pls.es.effects = 0;
if (flags & PF_WEAPONFRAME) if (flags & PF_WEAPONFRAME)
state->pls.weaponframe = MSG_ReadByte (net_message); state->pls.es.weaponframe = MSG_ReadByte (net_message);
else else
state->pls.weaponframe = 0; state->pls.es.weaponframe = 0;
VectorCopy (state->pls.cmd.angles, state->viewangles); VectorCopy (state->pls.cmd.angles, state->viewangles);
@ -489,13 +489,13 @@ CL_ParsePlayerinfo (void)
ent->scale = val / 16.0; ent->scale = val / 16.0;
} }
if (bits & PF_EFFECTS2) { if (bits & PF_EFFECTS2) {
state->pls.effects |= MSG_ReadByte (net_message) << 8; state->pls.es.effects |= MSG_ReadByte (net_message) << 8;
} }
if (bits & PF_GLOWSIZE) { if (bits & PF_GLOWSIZE) {
state->pls.glow_size = MSG_ReadByte (net_message); state->pls.es.glow_size = MSG_ReadByte (net_message);
} }
if (bits & PF_GLOWCOLOR) { if (bits & PF_GLOWCOLOR) {
state->pls.glow_color = MSG_ReadByte (net_message); state->pls.es.glow_color = MSG_ReadByte (net_message);
} }
if (bits & PF_COLORMOD) { if (bits & PF_COLORMOD) {
float r = 1.0, g = 1.0, b = 1.0; float r = 1.0, g = 1.0, b = 1.0;
@ -508,7 +508,7 @@ CL_ParsePlayerinfo (void)
VectorSet (r, g, b, ent->renderer.colormod); VectorSet (r, g, b, ent->renderer.colormod);
} }
if (bits & PF_FRAME2) { if (bits & PF_FRAME2) {
state->pls.frame |= MSG_ReadByte (net_message) << 8; state->pls.es.frame |= MSG_ReadByte (net_message) << 8;
} }
} }
} }
@ -599,22 +599,23 @@ CL_SetUpPlayerPrediction (qboolean dopred)
if (state->messagenum != cl.parsecount) if (state->messagenum != cl.parsecount)
continue; // not present this frame continue; // not present this frame
if (!state->pls.modelindex) if (!state->pls.es.modelindex)
continue; continue;
pplayer->active = true; pplayer->active = true;
pplayer->flags = state->pls.flags; pplayer->flags = state->pls.es.flags;
// note that the local player is special, since he moves locally // note that the local player is special, since he moves locally
// we use his last predicted postition // we use his last predicted postition
if (j == cl.playernum) { if (j == cl.playernum) {
VectorCopy (cl.frames[cls.netchan.outgoing_sequence & UPDATE_MASK]. VectorCopy (cl.frames[cls.netchan.outgoing_sequence & UPDATE_MASK].
playerstate[cl.playernum].pls.origin, pplayer->origin); playerstate[cl.playernum].pls.es.origin,
pplayer->origin);
} else { } else {
// predict only half the move to minimize overruns // predict only half the move to minimize overruns
msec = 500 * (playertime - state->state_time); msec = 500 * (playertime - state->state_time);
if (msec <= 0 || !dopred) { if (msec <= 0 || !dopred) {
VectorCopy (state->pls.origin, pplayer->origin); VectorCopy (state->pls.es.origin, pplayer->origin);
// Sys_MaskPrintf (SYS_DEV, "nopredict\n"); // Sys_MaskPrintf (SYS_DEV, "nopredict\n");
} else { } else {
// predict players movement // predict players movement
@ -622,7 +623,7 @@ CL_SetUpPlayerPrediction (qboolean dopred)
// Sys_MaskPrintf (SYS_DEV, "predict: %i\n", msec); // Sys_MaskPrintf (SYS_DEV, "predict: %i\n", msec);
CL_PredictUsercmd (state, &exact, &state->pls.cmd, false); CL_PredictUsercmd (state, &exact, &state->pls.cmd, false);
VectorCopy (exact.pls.origin, pplayer->origin); VectorCopy (exact.pls.es.origin, pplayer->origin);
} }
} }
} }

34
qw/source/cl_ents.c
View file

@ -349,7 +349,7 @@ static void
CL_LinkPlayers (void) CL_LinkPlayers (void)
{ {
double playertime; double playertime;
int msec, oldphysent, i, j; int msec, oldphysent, j;
entity_t *ent; entity_t *ent;
frame_t *frame; frame_t *frame;
player_info_t *info; player_info_t *info;
@ -381,7 +381,7 @@ CL_LinkPlayers (void)
r_data->player_entity = &cl_player_ents[j]; r_data->player_entity = &cl_player_ents[j];
clientplayer = true; clientplayer = true;
} else { } else {
VectorCopy (state->pls.origin, org); VectorCopy (state->pls.es.origin, org);
clientplayer = false; clientplayer = false;
} }
if (info->chat && info->chat->value[0] != '0') { if (info->chat && info->chat->value[0] != '0') {
@ -391,28 +391,28 @@ CL_LinkPlayers (void)
dl->die = cl.time + 0.1; dl->die = cl.time + 0.1;
QuatSet (0.0, 1.0, 0.0, 1.0, dl->color); QuatSet (0.0, 1.0, 0.0, 1.0, dl->color);
} else { } else {
CL_NewDlight (j + 1, org, state->pls.effects, state->pls.glow_size, CL_NewDlight (j + 1, org, state->pls.es.effects,
state->pls.glow_color, cl.time); state->pls.es.glow_size, state->pls.es.glow_color,
cl.time);
} }
// Draw player? // Draw player?
if (!Cam_DrawPlayer (j)) if (!Cam_DrawPlayer (j))
continue; continue;
if (!state->pls.modelindex) if (!state->pls.es.modelindex)
continue; continue;
// Hack hack hack // Hack hack hack
if (cl_deadbodyfilter->int_val if (cl_deadbodyfilter->int_val
&& state->pls.modelindex == cl_playerindex && state->pls.es.modelindex == cl_playerindex
&& ((i = state->pls.frame) == 49 || i == 60 || i == 69 || i == 84 && is_dead_body (&state->pls.es))
|| i == 93 || i == 102))
continue; continue;
// predict only half the move to minimize overruns // predict only half the move to minimize overruns
msec = 500 * (playertime - state->state_time); msec = 500 * (playertime - state->state_time);
if (msec <= 0 || (!cl_predict_players->int_val) || cls.demoplayback2) { if (msec <= 0 || (!cl_predict_players->int_val) || cls.demoplayback2) {
VectorCopy (state->pls.origin, ent->origin); VectorCopy (state->pls.es.origin, ent->origin);
} else { // predict players movement } else { // predict players movement
state->pls.cmd.msec = msec = min (msec, 255); state->pls.cmd.msec = msec = min (msec, 255);
@ -420,7 +420,7 @@ CL_LinkPlayers (void)
CL_SetSolidPlayers (j); CL_SetSolidPlayers (j);
CL_PredictUsercmd (state, &exact, &state->pls.cmd, clientplayer); CL_PredictUsercmd (state, &exact, &state->pls.cmd, clientplayer);
pmove.numphysent = oldphysent; pmove.numphysent = oldphysent;
VectorCopy (exact.pls.origin, ent->origin); VectorCopy (exact.pls.es.origin, ent->origin);
} }
// angles // angles
@ -432,18 +432,18 @@ CL_LinkPlayers (void)
ang[PITCH] = -state->viewangles[PITCH] / 3.0; ang[PITCH] = -state->viewangles[PITCH] / 3.0;
ang[YAW] = state->viewangles[YAW]; ang[YAW] = state->viewangles[YAW];
} }
ang[ROLL] = V_CalcRoll (ang, state->pls.velocity) * 4.0; ang[ROLL] = V_CalcRoll (ang, state->pls.es.velocity) * 4.0;
ent->renderer.model = cl.model_precache[state->pls.modelindex]; ent->renderer.model = cl.model_precache[state->pls.es.modelindex];
ent->animation.frame = state->pls.frame; ent->animation.frame = state->pls.es.frame;
ent->renderer.skinnum = state->pls.skinnum; ent->renderer.skinnum = state->pls.es.skinnum;
CL_TransformEntity (ent, ang); CL_TransformEntity (ent, ang);
ent->renderer.min_light = 0; ent->renderer.min_light = 0;
ent->renderer.fullbright = 0; ent->renderer.fullbright = 0;
if (state->pls.modelindex == cl_playerindex) { //XXX if (state->pls.es.modelindex == cl_playerindex) { //XXX
// use custom skin // use custom skin
ent->renderer.skin = info->skin; ent->renderer.skin = info->skin;
@ -460,9 +460,9 @@ CL_LinkPlayers (void)
// stuff entity in map // stuff entity in map
r_funcs->R_AddEfrags (&cl.worldmodel->brush, ent); r_funcs->R_AddEfrags (&cl.worldmodel->brush, ent);
if (state->pls.effects & EF_FLAG1) if (state->pls.es.effects & EF_FLAG1)
CL_AddFlagModels (ent, 0, j); CL_AddFlagModels (ent, 0, j);
else if (state->pls.effects & EF_FLAG2) else if (state->pls.es.effects & EF_FLAG2)
CL_AddFlagModels (ent, 1, j); CL_AddFlagModels (ent, 1, j);
} }
} }

4
qw/source/cl_main.c
View file

@ -1631,8 +1631,8 @@ Host_Frame (float time)
oldself = &cl.frames[(cls.netchan.outgoing_sequence - 1) oldself = &cl.frames[(cls.netchan.outgoing_sequence - 1)
& UPDATE_MASK].playerstate[cl.playernum]; & UPDATE_MASK].playerstate[cl.playernum];
self->messagenum = cl.parsecount; self->messagenum = cl.parsecount;
VectorCopy (oldself->pls.origin, self->pls.origin); VectorCopy (oldself->pls.es.origin, self->pls.es.origin);
VectorCopy (oldself->pls.velocity, self->pls.velocity); VectorCopy (oldself->pls.es.velocity, self->pls.es.velocity);
VectorCopy (oldself->viewangles, self->viewangles); VectorCopy (oldself->viewangles, self->viewangles);
CL_ParseClientdata (); CL_ParseClientdata ();

41
qw/source/cl_pred.c
View file

@ -51,10 +51,10 @@ CL_PredictUsercmd (player_state_t * from, player_state_t * to, usercmd_t *u,
qboolean clientplayer) qboolean clientplayer)
{ {
if (!clientplayer) { if (!clientplayer) {
if (VectorIsZero (from->pls.velocity)) { if (VectorIsZero (from->pls.es.velocity)) {
VectorCopy (from->pls.origin, to->pls.origin); VectorCopy (from->pls.es.origin, to->pls.es.origin);
VectorCopy (u->angles, to->viewangles); VectorCopy (u->angles, to->viewangles);
VectorCopy (from->pls.velocity, to->pls.velocity); VectorCopy (from->pls.es.velocity, to->pls.es.velocity);
return; return;
} }
} }
@ -72,9 +72,9 @@ CL_PredictUsercmd (player_state_t * from, player_state_t * to, usercmd_t *u,
return; return;
} }
VectorCopy (from->pls.origin, pmove.origin); VectorCopy (from->pls.es.origin, pmove.origin);
VectorCopy (u->angles, pmove.angles); VectorCopy (u->angles, pmove.angles);
VectorCopy (from->pls.velocity, pmove.velocity); VectorCopy (from->pls.es.velocity, pmove.velocity);
pmove.oldbuttons = from->oldbuttons; pmove.oldbuttons = from->oldbuttons;
pmove.oldonground = from->oldonground; pmove.oldonground = from->oldonground;
@ -92,11 +92,11 @@ CL_PredictUsercmd (player_state_t * from, player_state_t * to, usercmd_t *u,
to->waterjumptime = pmove.waterjumptime; to->waterjumptime = pmove.waterjumptime;
to->oldbuttons = pmove.oldbuttons; // Tonik to->oldbuttons = pmove.oldbuttons; // Tonik
to->oldonground = pmove.oldonground; to->oldonground = pmove.oldonground;
VectorCopy (pmove.origin, to->pls.origin); VectorCopy (pmove.origin, to->pls.es.origin);
VectorCopy (pmove.angles, to->viewangles); VectorCopy (pmove.angles, to->viewangles);
VectorCopy (pmove.velocity, to->pls.velocity); VectorCopy (pmove.velocity, to->pls.es.velocity);
to->onground = onground; to->onground = onground;
to->pls.weaponframe = from->pls.weaponframe; to->pls.es.weaponframe = from->pls.es.weaponframe;
} }
void void
@ -137,8 +137,8 @@ CL_PredictMove (void)
from = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK]; from = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
if (!cl_predict->int_val) { if (!cl_predict->int_val) {
VectorCopy (from->playerstate[cl.playernum].pls.velocity, cl.simvel); VectorCopy (from->playerstate[cl.playernum].pls.es.velocity, cl.simvel);
VectorCopy (from->playerstate[cl.playernum].pls.origin, cl.simorg); VectorCopy (from->playerstate[cl.playernum].pls.es.origin, cl.simorg);
return; return;
} }
@ -175,21 +175,22 @@ CL_PredictMove (void)
} }
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
if (fabs (from->playerstate[cl.playernum].pls.origin[i] - if (fabs (from->playerstate[cl.playernum].pls.es.origin[i] -
to->playerstate[cl.playernum].pls.origin[i]) > 128) { to->playerstate[cl.playernum].pls.es.origin[i]) > 128) {
// teleported, so don't lerp // teleported, so don't lerp
VectorCopy (to->playerstate[cl.playernum].pls.velocity, cl.simvel); VectorCopy (to->playerstate[cl.playernum].pls.es.velocity,
VectorCopy (to->playerstate[cl.playernum].pls.origin, cl.simorg); cl.simvel);
VectorCopy (to->playerstate[cl.playernum].pls.es.origin, cl.simorg);
return; return;
} }
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
cl.simorg[i] = from->playerstate[cl.playernum].pls.origin[i] + cl.simorg[i] = from->playerstate[cl.playernum].pls.es.origin[i] +
f * (to->playerstate[cl.playernum].pls.origin[i] - f * (to->playerstate[cl.playernum].pls.es.origin[i] -
from->playerstate[cl.playernum].pls.origin[i]); from->playerstate[cl.playernum].pls.es.origin[i]);
cl.simvel[i] = from->playerstate[cl.playernum].pls.velocity[i] + cl.simvel[i] = from->playerstate[cl.playernum].pls.es.velocity[i] +
f * (to->playerstate[cl.playernum].pls.velocity[i] - f * (to->playerstate[cl.playernum].pls.es.velocity[i] -
from->playerstate[cl.playernum].pls.velocity[i]); from->playerstate[cl.playernum].pls.es.velocity[i]);
} }
} }

10
qw/source/cl_view.c
View file

@ -600,7 +600,7 @@ V_CalcViewRoll (void)
v_dmg_time -= host_frametime; v_dmg_time -= host_frametime;
} }
if (view_state->pls.flags & PF_DEAD) // PF_GIB will also set PF_DEAD if (view_state->pls.es.flags & PF_DEAD) // PF_GIB will also set PF_DEAD
r_data->refdef->viewangles[ROLL] = 80; // dead view angle r_data->refdef->viewangles[ROLL] = 80; // dead view angle
} }
@ -700,12 +700,12 @@ V_CalcRefdef (void)
else if (r_data->scr_viewsize->int_val == 80) else if (r_data->scr_viewsize->int_val == 80)
view->origin[2] += 0.5; view->origin[2] += 0.5;
if (view_state->pls.flags & (PF_GIB | PF_DEAD)) { if (view_state->pls.es.flags & (PF_GIB | PF_DEAD)) {
view->renderer.model = NULL; view->renderer.model = NULL;
} else { } else {
view->renderer.model = cl.model_precache[cl.stats[STAT_WEAPON]]; view->renderer.model = cl.model_precache[cl.stats[STAT_WEAPON]];
} }
view->animation.frame = view_state->pls.weaponframe; view->animation.frame = view_state->pls.es.weaponframe;
view->renderer.skin = 0; view->renderer.skin = 0;
// set up the refresh position // set up the refresh position
@ -757,9 +757,9 @@ V_RenderView (void)
view_frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK]; view_frame = &cl.frames[cls.netchan.incoming_sequence & UPDATE_MASK];
view_state = &view_frame->playerstate[cl.playernum]; view_state = &view_frame->playerstate[cl.playernum];
if (view_state->pls.flags & PF_GIB) if (view_state->pls.es.flags & PF_GIB)
cl.viewheight = 8; // gib view height cl.viewheight = 8; // gib view height
else if (view_state->pls.flags & PF_DEAD) else if (view_state->pls.es.flags & PF_DEAD)
cl.viewheight = -16; // corpse view height cl.viewheight = -16; // corpse view height
else { else {
cl.viewheight = DEFAULT_VIEWHEIGHT; // view height cl.viewheight = DEFAULT_VIEWHEIGHT; // view height

150
qw/source/sv_ents.c
View file

@ -400,7 +400,7 @@ write_demoplayer (delta_t *delta, plent_state_t *from, plent_state_t *to,
int flags; int flags;
int j; int j;
flags = to->flags >> 1; // convert PF_(GIB|DEAD) to DF_(GIB|DEAD) flags = to->es.flags >> 1; // convert PF_(GIB|DEAD) to DF_(GIB|DEAD)
flags &= DF_GIB | DF_DEAD; // PF_MSEC and PF_COMMAND aren't wanted flags &= DF_GIB | DF_DEAD; // PF_MSEC and PF_COMMAND aren't wanted
if (full) { if (full) {
flags |= DF_ORIGIN | (DF_ORIGIN << 1) | (DF_ORIGIN << 2) flags |= DF_ORIGIN | (DF_ORIGIN << 1) | (DF_ORIGIN << 2)
@ -408,55 +408,55 @@ write_demoplayer (delta_t *delta, plent_state_t *from, plent_state_t *to,
| DF_EFFECTS | DF_SKINNUM | DF_WEAPONFRAME | DF_MODEL; | DF_EFFECTS | DF_SKINNUM | DF_WEAPONFRAME | DF_MODEL;
} else { } else {
for (j = 0; j < 3; j++) for (j = 0; j < 3; j++)
if (from->origin[j] != to->origin[j]) if (from->es.origin[j] != to->es.origin[j])
flags |= DF_ORIGIN << j; flags |= DF_ORIGIN << j;
for (j = 0; j < 3; j++) for (j = 0; j < 3; j++)
if (from->cmd.angles[j] != to->cmd.angles[j]) if (from->cmd.angles[j] != to->cmd.angles[j])
flags |= DF_ANGLES << j; flags |= DF_ANGLES << j;
if (from->modelindex != to->modelindex) if (from->es.modelindex != to->es.modelindex)
flags |= DF_MODEL; flags |= DF_MODEL;
if ((from->effects & 0xff) != (to->effects & 0xff)) if ((from->es.effects & 0xff) != (to->es.effects & 0xff))
flags |= DF_EFFECTS; flags |= DF_EFFECTS;
if (from->skinnum != to->skinnum) if (from->es.skinnum != to->es.skinnum)
flags |= DF_SKINNUM; flags |= DF_SKINNUM;
if (from->weaponframe != to->weaponframe) if (from->es.weaponframe != to->es.weaponframe)
flags |= DF_WEAPONFRAME; flags |= DF_WEAPONFRAME;
} }
MSG_WriteByte (msg, svc_playerinfo); MSG_WriteByte (msg, svc_playerinfo);
MSG_WriteByte (msg, to->number); MSG_WriteByte (msg, to->es.number);
MSG_WriteShort (msg, flags); MSG_WriteShort (msg, flags);
MSG_WriteByte (msg, to->frame); MSG_WriteByte (msg, to->es.frame);
for (j = 0; j < 3; j++) for (j = 0; j < 3; j++)
if (flags & (DF_ORIGIN << j)) if (flags & (DF_ORIGIN << j))
MSG_WriteCoord (msg, to->origin[j]); MSG_WriteCoord (msg, to->es.origin[j]);
for (j = 0; j < 3; j++) for (j = 0; j < 3; j++)
if (flags & (DF_ANGLES << j)) if (flags & (DF_ANGLES << j))
MSG_WriteAngle16 (msg, to->cmd.angles[j]); MSG_WriteAngle16 (msg, to->cmd.angles[j]);
if (flags & DF_MODEL) if (flags & DF_MODEL)
MSG_WriteByte (msg, to->modelindex); MSG_WriteByte (msg, to->es.modelindex);
if (flags & DF_SKINNUM) if (flags & DF_SKINNUM)
MSG_WriteByte (msg, to->skinnum); MSG_WriteByte (msg, to->es.skinnum);
if (flags & DF_EFFECTS) if (flags & DF_EFFECTS)
MSG_WriteByte (msg, to->effects); MSG_WriteByte (msg, to->es.effects);
if (flags & DF_WEAPONFRAME) if (flags & DF_WEAPONFRAME)
MSG_WriteByte (msg, to->weaponframe); MSG_WriteByte (msg, to->es.weaponframe);
} }
static void static void
write_player (delta_t *delta, plent_state_t *from, plent_state_t *to, write_player (delta_t *delta, plent_state_t *from, plent_state_t *to,
sizebuf_t *msg, int mask, int full) sizebuf_t *msg, int mask, int full)
{ {
int flags = to->flags; int flags = to->es.flags;
int qf_bits = 0; int qf_bits = 0;
int i; int i;
int ds = delta->delta_sequence & 0x7f; int ds = delta->delta_sequence & 0x7f;
@ -472,30 +472,30 @@ write_player (delta_t *delta, plent_state_t *from, plent_state_t *to,
ds = -1; ds = -1;
} else { } else {
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
if (from->velocity[i] != to->velocity[i]) if (from->es.velocity[i] != to->es.velocity[i])
flags |= PF_VELOCITY1 << i; flags |= PF_VELOCITY1 << i;
if (from->modelindex != to->modelindex) if (from->es.modelindex != to->es.modelindex)
flags |= PF_MODEL; flags |= PF_MODEL;
if (from->skinnum != to->skinnum) if (from->es.skinnum != to->es.skinnum)
flags |= PF_SKINNUM; flags |= PF_SKINNUM;
if ((from->effects & 0xff) != (to->effects &0xff)) if ((from->es.effects & 0xff) != (to->es.effects &0xff))
flags |= PF_EFFECTS; flags |= PF_EFFECTS;
if (from->weaponframe != to->weaponframe) if (from->es.weaponframe != to->es.weaponframe)
flags |= PF_WEAPONFRAME; flags |= PF_WEAPONFRAME;
if (from->alpha != to->alpha) if (from->es.alpha != to->es.alpha)
qf_bits |= PF_ALPHA; qf_bits |= PF_ALPHA;
if (from->scale != to->scale) if (from->es.scale != to->es.scale)
qf_bits |= PF_SCALE; qf_bits |= PF_SCALE;
if ((from->effects & 0xff00) != (to->effects & 0xff00)) if ((from->es.effects & 0xff00) != (to->es.effects & 0xff00))
qf_bits |= PF_EFFECTS2; qf_bits |= PF_EFFECTS2;
if (from->glow_size != to->glow_size) if (from->es.glow_size != to->es.glow_size)
qf_bits |= PF_GLOWSIZE; qf_bits |= PF_GLOWSIZE;
if (from->glow_color != to->glow_color) if (from->es.glow_color != to->es.glow_color)
qf_bits |= PF_GLOWCOLOR; qf_bits |= PF_GLOWCOLOR;
if (from->colormod != to->colormod) if (from->es.colormod != to->es.colormod)
qf_bits |= PF_COLORMOD; qf_bits |= PF_COLORMOD;
if ((from->frame & 0xff00) != (to->frame & 0xff00)) if ((from->es.frame & 0xff00) != (to->es.frame & 0xff00))
qf_bits |= PF_FRAME2; qf_bits |= PF_FRAME2;
if (qf_bits) if (qf_bits)
flags |= PF_QF; flags |= PF_QF;
@ -506,12 +506,12 @@ write_player (delta_t *delta, plent_state_t *from, plent_state_t *to,
MSG_WriteByte (msg, svc_playerinfo); MSG_WriteByte (msg, svc_playerinfo);
if (delta->type == dt_tp_qtv) if (delta->type == dt_tp_qtv)
MSG_WriteByte (msg, ds); MSG_WriteByte (msg, ds);
MSG_WriteByte (msg, to->number); MSG_WriteByte (msg, to->es.number);
MSG_WriteShort (msg, flags); MSG_WriteShort (msg, flags);
MSG_WriteCoordV (msg, to->origin); MSG_WriteCoordV (msg, to->es.origin);
MSG_WriteByte (msg, to->frame); MSG_WriteByte (msg, to->es.frame);
if (flags & PF_MSEC) if (flags & PF_MSEC)
MSG_WriteByte (msg, to->msec); MSG_WriteByte (msg, to->msec);
@ -519,32 +519,32 @@ write_player (delta_t *delta, plent_state_t *from, plent_state_t *to,
MSG_WriteDeltaUsercmd (msg, &from->cmd, &to->cmd); MSG_WriteDeltaUsercmd (msg, &from->cmd, &to->cmd);
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
if (flags & (PF_VELOCITY1 << i)) if (flags & (PF_VELOCITY1 << i))
MSG_WriteShort (msg, to->velocity[i]); MSG_WriteShort (msg, to->es.velocity[i]);
if (flags & PF_MODEL) if (flags & PF_MODEL)
MSG_WriteByte (msg, to->modelindex); MSG_WriteByte (msg, to->es.modelindex);
if (flags & PF_SKINNUM) if (flags & PF_SKINNUM)
MSG_WriteByte (msg, to->skinnum); MSG_WriteByte (msg, to->es.skinnum);
if (flags & PF_EFFECTS) if (flags & PF_EFFECTS)
MSG_WriteByte (msg, to->effects); MSG_WriteByte (msg, to->es.effects);
if (flags & PF_WEAPONFRAME) if (flags & PF_WEAPONFRAME)
MSG_WriteByte (msg, to->weaponframe); MSG_WriteByte (msg, to->es.weaponframe);
if (flags & PF_QF) { if (flags & PF_QF) {
MSG_WriteByte (msg, qf_bits); MSG_WriteByte (msg, qf_bits);
if (qf_bits & PF_ALPHA) if (qf_bits & PF_ALPHA)
MSG_WriteByte (msg, to->alpha); MSG_WriteByte (msg, to->es.alpha);
if (qf_bits & PF_SCALE) if (qf_bits & PF_SCALE)
MSG_WriteByte (msg, to->scale); MSG_WriteByte (msg, to->es.scale);
if (qf_bits & PF_EFFECTS2) if (qf_bits & PF_EFFECTS2)
MSG_WriteByte (msg, to->effects >> 8); MSG_WriteByte (msg, to->es.effects >> 8);
if (qf_bits & PF_GLOWSIZE) if (qf_bits & PF_GLOWSIZE)
MSG_WriteByte (msg, to->glow_size); MSG_WriteByte (msg, to->es.glow_size);
if (qf_bits & PF_GLOWCOLOR) if (qf_bits & PF_GLOWCOLOR)
MSG_WriteByte (msg, to->glow_color); MSG_WriteByte (msg, to->es.glow_color);
if (qf_bits & PF_COLORMOD) if (qf_bits & PF_COLORMOD)
MSG_WriteByte (msg, to->colormod); MSG_WriteByte (msg, to->es.colormod);
if (qf_bits & PF_FRAME2) if (qf_bits & PF_FRAME2)
MSG_WriteByte (msg, to->frame); MSG_WriteByte (msg, to->es.frame);
} }
} }
@ -566,19 +566,19 @@ SV_WritePlayersToClient (delta_t *delta, byte *pvs, sizebuf_t *msg)
void (*write) (delta_t *, plent_state_t *, plent_state_t *, sizebuf_t *, void (*write) (delta_t *, plent_state_t *, plent_state_t *, sizebuf_t *,
int, int); int, int);
if (!null_player_state.alpha) { if (!null_player_state.es.alpha) {
null_player_state.alpha = 255; null_player_state.es.alpha = 255;
null_player_state.scale = 16; null_player_state.es.scale = 16;
null_player_state.glow_size = 0; null_player_state.es.glow_size = 0;
null_player_state.glow_color = 254; null_player_state.es.glow_color = 254;
null_player_state.colormod = 255; null_player_state.es.colormod = 255;
} }
null_player_state.modelindex = 0; null_player_state.es.modelindex = 0;
if (delta->client) { if (delta->client) {
clent = delta->client->edict; clent = delta->client->edict;
spec_track = delta->client->spec_track; spec_track = delta->client->spec_track;
null_player_state.modelindex = sv_playermodel; null_player_state.es.modelindex = sv_playermodel;
full = 0; // normal qw clients don't get real deltas on players full = 0; // normal qw clients don't get real deltas on players
} }
@ -625,9 +625,9 @@ SV_WritePlayersToClient (delta_t *delta, byte *pvs, sizebuf_t *msg)
state = &pack->players[pack->num_players]; state = &pack->players[pack->num_players];
pack->num_players++; pack->num_players++;
state->number = j; state->es.number = j;
state->flags = 0; state->es.flags = 0;
VectorCopy (SVvector (ent, origin), state->origin); VectorCopy (SVvector (ent, origin), state->es.origin);
state->msec = min (255, 1000 * (sv.time - cl->localtime)); state->msec = min (255, 1000 * (sv.time - cl->localtime));
@ -639,44 +639,44 @@ SV_WritePlayersToClient (delta_t *delta, byte *pvs, sizebuf_t *msg)
state->cmd.angles[0] = 0; state->cmd.angles[0] = 0;
} }
VectorCopy (SVvector (ent, velocity), state->velocity); VectorCopy (SVvector (ent, velocity), state->es.velocity);
state->modelindex = SVfloat (ent, modelindex); state->es.modelindex = SVfloat (ent, modelindex);
state->frame = SVfloat (ent, frame); state->es.frame = SVfloat (ent, frame);
state->skinnum = SVfloat (ent, skin); state->es.skinnum = SVfloat (ent, skin);
state->effects = SVfloat (ent, effects); state->es.effects = SVfloat (ent, effects);
state->weaponframe = SVfloat (ent, weaponframe); state->es.weaponframe = SVfloat (ent, weaponframe);
if (SVfloat (ent, health) <= 0) if (SVfloat (ent, health) <= 0)
state->flags |= PF_DEAD; state->es.flags |= PF_DEAD;
if (SVvector (ent, mins)[2] != -24) if (SVvector (ent, mins)[2] != -24)
state->flags |= PF_GIB; state->es.flags |= PF_GIB;
state->flags |= PF_MSEC | PF_COMMAND; state->es.flags |= PF_MSEC | PF_COMMAND;
state->alpha = 255; state->es.alpha = 255;
state->scale = 16; state->es.scale = 16;
state->glow_size = 0; state->es.glow_size = 0;
state->glow_color = 254; state->es.glow_color = 254;
state->colormod = 255; state->es.colormod = 255;
if (sv_fields.alpha != -1 && SVfloat (ent, alpha)) { if (sv_fields.alpha != -1 && SVfloat (ent, alpha)) {
float alpha = SVfloat (ent, alpha); float alpha = SVfloat (ent, alpha);
state->alpha = bound (0, alpha, 1) * 255.0; state->es.alpha = bound (0, alpha, 1) * 255.0;
} }
if (sv_fields.scale != -1 && SVfloat (ent, scale)) { if (sv_fields.scale != -1 && SVfloat (ent, scale)) {
float scale = SVfloat (ent, scale); float scale = SVfloat (ent, scale);
state->scale = bound (0, scale, 15.9375) * 16; state->es.scale = bound (0, scale, 15.9375) * 16;
} }
if (sv_fields.glow_size != -1 && SVfloat (ent, glow_size)) { if (sv_fields.glow_size != -1 && SVfloat (ent, glow_size)) {
int glow_size = SVfloat (ent, glow_size); int glow_size = SVfloat (ent, glow_size);
state->glow_size = bound (-1024, glow_size, 1016) >> 3; state->es.glow_size = bound (-1024, glow_size, 1016) >> 3;
} }
if (sv_fields.glow_color != -1 && SVfloat (ent, glow_color)) if (sv_fields.glow_color != -1 && SVfloat (ent, glow_color))
state->glow_color = SVfloat (ent, glow_color); state->es.glow_color = SVfloat (ent, glow_color);
if (sv_fields.colormod != -1 if (sv_fields.colormod != -1
&& !VectorIsZero (SVvector (ent, colormod))) { && !VectorIsZero (SVvector (ent, colormod))) {
float *colormod= SVvector (ent, colormod); float *colormod= SVvector (ent, colormod);
state->colormod = ((int) (bound (0, colormod[0], 1) * 7) << 5) | state->es.colormod = ((int) (bound (0, colormod[0], 1) * 7) << 5) |
((int) (bound (0, colormod[1], 1) * 7) << 2) | ((int) (bound (0, colormod[1], 1) * 7) << 2) |
(int) (bound (0, colormod[2], 1) * 3); (int) (bound (0, colormod[2], 1) * 3);
} }
if (cl->spectator) { if (cl->spectator) {
@ -693,10 +693,10 @@ SV_WritePlayersToClient (delta_t *delta, byte *pvs, sizebuf_t *msg)
if (from_pack && from_pack->players) { if (from_pack && from_pack->players) {
while (k < from_pack->num_players while (k < from_pack->num_players
&& from_pack->players[k].number < state->number) && from_pack->players[k].es.number < state->es.number)
k++; k++;
if (k < from_pack->num_players if (k < from_pack->num_players
&& from_pack->players[k].number == state->number) { && from_pack->players[k].es.number == state->es.number) {
write (delta, &from_pack->players[k], state, msg, mask, full); write (delta, &from_pack->players[k], state, msg, mask, full);
continue; continue;
} }