nzp-team/fteqw
0
0
Fork 0
mirror of https://github.com/nzp-team/fteqw.git synced 2024-11-24 21:02:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
fteqw/engine/server/svq2_ents.c
Shpoike d781018df3 Add all the junk for network compat with Q2E. 
Defaults to using Q2E's protocol 2023 (but not netchan).
FTEQ2 servers can host both vanilla and Q2E clients simultaneously, but its recommend to use the vanilla gamecode to avoid localisation issues.
2024-07-14 19:58:24 +01:00

1178 lines
29 KiB
C
Raw Permalink Blame History

#include "quakedef.h"
#ifndef CLIENTONLY
#define Q2EDICT_NUM(i) (q2edict_t*)((char *)ge->edicts+i*ge->edict_size)
#ifndef Q2SERVER
void SV_WriteFrameToClient (client_t *client, sizebuf_t *msg)
{
}
void SV_BuildClientFrame (client_t *client)
{
}
#else
q2entity_state_t *svs_client_entities;//[Q2UPDATE_BACKUP*MAX_PACKET_ENTITIES];
int svs_num_client_entities;
int svs_next_client_entities;
q2entity_state_t sv_baselines[Q2MAX_EDICTS];
/*
=============================================================================
Encode a client frame onto the network channel
=============================================================================
*/
static void MSG_WriteSizeQ2E(sizebuf_t *sb, int solid)
{ //urgh...
if (solid != ES_SOLID_BSP && solid != ES_SOLID_NOT)
solid = ((solid & 255)<<0) //recode fte's sizes to q2ex's...
| ((solid & 255)<<8)
| (((solid>>8) & 255)<<16)
| ((((solid>>16) & 65535) - 32768+32)<<24);
MSG_WriteLong(sb, solid);
}
/*
==================
MSG_WriteDeltaEntity
Writes part of a packetentities message.
Can delta from either a baseline or a previous packet_entity
==================
*/
void MSGQ2_WriteDeltaEntity (q2entity_state_t *from, q2entity_state_t *to, sizebuf_t *msg, qboolean force, qboolean newentity, qboolean q2ex)
{
quint64_t bits;
if (!to->number)
Sys_Error ("Unset entity number");
if (to->number >= Q2MAX_EDICTS)
Sys_Error ("Entity number >= MAX_EDICTS");
// send an update
bits = 0;
if (to->number >= 256)
bits |= Q2U_NUMBER16; // number8 is implicit otherwise
if (to->origin[0] != from->origin[0])
bits |= Q2U_ORIGIN1;
if (to->origin[1] != from->origin[1])
bits |= Q2U_ORIGIN2;
if (to->origin[2] != from->origin[2])
bits |= Q2U_ORIGIN3;
if ( to->angles[0] != from->angles[0] )
bits |= Q2U_ANGLE1;
if ( to->angles[1] != from->angles[1] )
bits |= Q2U_ANGLE2;
if ( to->angles[2] != from->angles[2] )
bits |= Q2U_ANGLE3;
if ( to->skinnum != from->skinnum )
{
if ((unsigned)to->skinnum < 256)
bits |= Q2U_SKIN8;
else if ((unsigned)to->skinnum < 0x10000)
bits |= Q2U_SKIN16;
else
bits |= (Q2U_SKIN8|Q2U_SKIN16);
}
if ( to->frame != from->frame )
{
if (to->frame < 256)
bits |= Q2U_FRAME8;
else
bits |= Q2U_FRAME16;
}
if ( to->effects != from->effects )
{
if ((uint64_t)to->effects > 0xffffffffu)
{ //this encoding is weird, Q2UEX_EFFECTS64 without any of the other flags is equivelent to the 8|16==32bit flags, so is pointless without the extra ones.
if (to->effects < (uint64_t)256<<32)
bits |= Q2U_EFFECTS8|Q2UEX_EFFECTS64;
else if (to->effects < (uint64_t)0x8000<<32)
bits |= Q2U_EFFECTS16|Q2UEX_EFFECTS64;
else
bits |= Q2U_EFFECTS8|Q2U_EFFECTS16|Q2UEX_EFFECTS64;
}
else if (to->effects < 256)
bits |= Q2U_EFFECTS8;
else if (to->effects < 0x8000)
bits |= Q2U_EFFECTS16;
else
bits |= Q2U_EFFECTS8|Q2U_EFFECTS16;
}
if ( to->renderfx != from->renderfx )
{
if (to->renderfx < 256)
bits |= Q2U_RENDERFX8;
else if (to->renderfx < 0x8000)
bits |= Q2U_RENDERFX16;
else
bits |= Q2U_RENDERFX8|Q2U_RENDERFX16;
}
if ( to->solid != from->solid )
bits |= Q2U_SOLID;
// event is not delta compressed, just 0 compressed
if ( to->event )
bits |= Q2U_EVENT;
if ( to->modelindex != from->modelindex )
{
bits |= Q2U_MODEL;
if (to->modelindex > 0xff)
bits |= Q2UX_INDEX16;
}
if ( to->modelindex2 != from->modelindex2 )
{
bits |= Q2U_MODEL2;
if (to->modelindex2 > 0xff)
bits |= Q2UX_INDEX16;
}
if ( to->modelindex3 != from->modelindex3 )
{
bits |= Q2U_MODEL3;
if (to->modelindex3 > 0xff)
bits |= Q2UX_INDEX16;
}
if ( to->modelindex4 != from->modelindex4 )
{
bits |= Q2U_MODEL4;
if (to->modelindex4 > 0xff)
bits |= Q2UX_INDEX16;
}
if ( to->sound != from->sound /*||vol or attn*/)
{
bits |= Q2U_SOUND;
if (to->sound > 0xff && !q2ex)
bits |= Q2UX_INDEX16;
}
// if (to->alpha != from->alpha) bits |= Q2UEX_ALPHA;
// if (to->scale != from->scale)bits |= Q2UEX_SCALE;
// if (to->instance != from->instance) bits |= Q2UEX_INSTANCE;
// if (to->owner != from->owner) bits |= Q2UEX_OWNER;
// if (to->oldframe != from->oldframe) bits |= Q2UEX_OLDFRAME;
if (newentity || (to->renderfx & Q2RF_BEAM))
bits |= Q2U_OLDORIGIN;
//
// write the message
//
if (!bits && !force)
return; // nothing to send!
//----------
if (bits & 0xff00000000)
bits |= Q2UEX_MOREBITS4 | Q2U_MOREBITS3 | Q2U_MOREBITS2 | Q2U_MOREBITS1;
else if (bits & 0xff000000)
bits |= Q2U_MOREBITS3 | Q2U_MOREBITS2 | Q2U_MOREBITS1;
else if (bits & 0x00ff0000)
bits |= Q2U_MOREBITS2 | Q2U_MOREBITS1;
else if (bits & 0x0000ff00)
bits |= Q2U_MOREBITS1;
MSG_WriteByte (msg, bits&255 );
if (bits & 0xff00000000)
{
MSG_WriteByte (msg, (bits>>8)&255 );
MSG_WriteByte (msg, (bits>>16)&255 );
MSG_WriteByte (msg, (bits>>24)&255 );
MSG_WriteByte (msg, (bits>>32)&255 );
}
else if (bits & 0xff000000)
{
MSG_WriteByte (msg, (bits>>8)&255 );
MSG_WriteByte (msg, (bits>>16)&255 );
MSG_WriteByte (msg, (bits>>24)&255 );
}
else if (bits & 0x00ff0000)
{
MSG_WriteByte (msg, (bits>>8)&255 );
MSG_WriteByte (msg, (bits>>16)&255 );
}
else if (bits & 0x0000ff00)
{
MSG_WriteByte (msg, (bits>>8)&255 );
}
//----------
if (bits & Q2U_NUMBER16)
MSG_WriteShort (msg, to->number);
else
MSG_WriteByte (msg, to->number);
if (bits & Q2U_MODEL)
{
if (bits & Q2UX_INDEX16)
MSG_WriteShort (msg, to->modelindex);
else
MSG_WriteByte (msg, to->modelindex);
}
if (bits & Q2U_MODEL2)
{
if (bits & Q2UX_INDEX16)
MSG_WriteShort (msg, to->modelindex2);
else
MSG_WriteByte (msg, to->modelindex2);
}
if (bits & Q2U_MODEL3)
{
if (bits & Q2UX_INDEX16)
MSG_WriteShort (msg, to->modelindex3);
else
MSG_WriteByte (msg, to->modelindex3);
}
if (bits & Q2U_MODEL4)
{
if (bits & Q2UX_INDEX16)
MSG_WriteShort (msg, to->modelindex4);
else
MSG_WriteByte (msg, to->modelindex4);
}
if (bits & Q2U_FRAME8)
MSG_WriteByte (msg, to->frame);
if (bits & Q2U_FRAME16)
MSG_WriteShort (msg, to->frame);
if ((bits & Q2U_SKIN8) && (bits & Q2U_SKIN16)) //used for laser colors
MSG_WriteLong (msg, to->skinnum);
else if (bits & Q2U_SKIN8)
MSG_WriteByte (msg, to->skinnum);
else if (bits & Q2U_SKIN16)
MSG_WriteShort (msg, to->skinnum);
if (bits & Q2UEX_EFFECTS64)
{
MSG_WriteLong (msg, to->effects);
if ( (bits & (Q2U_EFFECTS8|Q2U_EFFECTS16)) == (Q2U_EFFECTS8|Q2U_EFFECTS16) )
MSG_WriteLong (msg, (quint64_t)to->effects>>32);
else if (bits & Q2U_EFFECTS8)
MSG_WriteByte (msg, (quint64_t)to->effects>>32);
else if (bits & Q2U_EFFECTS16)
MSG_WriteShort (msg, (quint64_t)to->effects>>32);
}
else
{
if ( (bits & (Q2U_EFFECTS8|Q2U_EFFECTS16)) == (Q2U_EFFECTS8|Q2U_EFFECTS16) )
MSG_WriteLong (msg, to->effects);
else if (bits & Q2U_EFFECTS8)
MSG_WriteByte (msg, to->effects);
else if (bits & Q2U_EFFECTS16)
MSG_WriteShort (msg, to->effects);
}
if ( (bits & (Q2U_RENDERFX8|Q2U_RENDERFX16)) == (Q2U_RENDERFX8|Q2U_RENDERFX16) )
MSG_WriteLong (msg, to->renderfx);
else if (bits & Q2U_RENDERFX8)
MSG_WriteByte (msg, to->renderfx);
else if (bits & Q2U_RENDERFX16)
MSG_WriteShort (msg, to->renderfx);
if (q2ex)
{
if (bits & Q2U_SOLID)
MSG_WriteSizeQ2E(msg, to->solid);
if (!to->solid)
{ //demos reportedly compress these... not that it makes a difference.
if (bits & Q2U_ORIGIN1)
MSG_WriteCoord (msg, to->origin[0]);
if (bits & Q2U_ORIGIN2)
MSG_WriteCoord (msg, to->origin[1]);
if (bits & Q2U_ORIGIN3)
MSG_WriteCoord (msg, to->origin[2]);
if (bits & Q2U_OLDORIGIN)
{
MSG_WriteCoord (msg, to->old_origin[0]);
MSG_WriteCoord (msg, to->old_origin[1]);
MSG_WriteCoord (msg, to->old_origin[2]);
}
}
else
{
if (bits & Q2U_ORIGIN1)
MSG_WriteFloat (msg, to->origin[0]);
if (bits & Q2U_ORIGIN2)
MSG_WriteFloat (msg, to->origin[1]);
if (bits & Q2U_ORIGIN3)
MSG_WriteFloat (msg, to->origin[2]);
if (bits & Q2U_OLDORIGIN)
{
MSG_WriteFloat (msg, to->old_origin[0]);
MSG_WriteFloat (msg, to->old_origin[1]);
MSG_WriteFloat (msg, to->old_origin[2]);
}
}
if (bits & Q2U_ANGLE1)
MSG_WriteFloat(msg, to->angles[0]); //blatent overkill.
if (bits & Q2U_ANGLE2)
MSG_WriteFloat(msg, to->angles[1]);
if (bits & Q2U_ANGLE3)
MSG_WriteFloat(msg, to->angles[2]);
}
else
{
if (bits & Q2U_ORIGIN1)
MSG_WriteCoord (msg, to->origin[0]);
if (bits & Q2U_ORIGIN2)
MSG_WriteCoord (msg, to->origin[1]);
if (bits & Q2U_ORIGIN3)
MSG_WriteCoord (msg, to->origin[2]);
if (bits & Q2U_ANGLE1)
MSG_WriteAngle(msg, to->angles[0]);
if (bits & Q2U_ANGLE2)
MSG_WriteAngle(msg, to->angles[1]);
if (bits & Q2U_ANGLE3)
MSG_WriteAngle(msg, to->angles[2]);
if (bits & Q2U_OLDORIGIN)
{
MSG_WriteCoord (msg, to->old_origin[0]);
MSG_WriteCoord (msg, to->old_origin[1]);
MSG_WriteCoord (msg, to->old_origin[2]);
}
}
if (bits & Q2U_SOUND)
{
if (q2ex)
{
#if 1
MSG_WriteShort (msg, to->sound&0x3fff);
#else
MSG_WriteShort (msg, to->sound&0x3fff | ((to->soundvol!=1)?0x4000:0)) | ((to->soundattn!=3)?0x8000:0));
MSG_WriteByte (msg, to->soundvol*255);
MSG_WriteByte (msg, to->soundattn); //this is normally a /64, but oh well...
#endif
}
else
{
if (bits & Q2UX_INDEX16)
MSG_WriteShort (msg, to->sound);
else
MSG_WriteByte (msg, to->sound);
}
}
if (bits & Q2U_EVENT)
MSG_WriteByte (msg, to->event);
if (!q2ex)
if (bits & Q2U_SOLID)
{
if (msg->prim.flags & NPQ2_SOLID32)
MSG_WriteLong(msg, to->solid);
else
MSG_WriteSize16(msg, to->solid);
}
if (bits & Q2UEX_ALPHA) MSG_WriteByte(msg, 0);
if (bits & Q2UEX_SCALE) MSG_WriteByte(msg, 0);
if (bits & Q2UEX_INSTANCE) MSG_WriteByte(msg, 0);
if (bits & Q2UEX_OWNER) MSG_WriteShort(msg, 0);
if (bits & Q2UEX_OLDFRAME) MSG_WriteShort(msg, 0);
}
/*
=============
SV_EmitPacketEntities
Writes a delta update of an entity_state_t list to the message.
=============
*/
void SVQ2_EmitPacketEntities (q2client_frame_t *from, q2client_frame_t *to, sizebuf_t *msg, qboolean q2ex)
{
q2entity_state_t *oldent, *newent;
int oldindex, newindex;
int oldnum, newnum;
int from_num_entities;
int bits;
MSG_WriteByte (msg, svcq2_packetentities);
if (!from)
from_num_entities = 0;
else
from_num_entities = from->num_entities;
newindex = 0;
oldindex = 0;
while (newindex < to->num_entities || oldindex < from_num_entities)
{
if (newindex >= to->num_entities)
{
newent = NULL; //shh compiler, shh...
newnum = 9999;
}
else
{
newent = &svs_client_entities[(to->first_entity+newindex)%svs_num_client_entities];
newnum = newent->number;
}
if (oldindex >= from_num_entities)
{
oldent = NULL; //shh compiler, shh...
oldnum = 9999;
}
else
{
oldent = &svs_client_entities[(from->first_entity+oldindex)%svs_num_client_entities];
oldnum = oldent->number;
}
if (newnum == oldnum)
{ // delta update from old position
// because the force parm is false, this will not result
// in any bytes being emited if the entity has not changed at all
// note that players are always 'newentities', this updates their oldorigin always
// and prevents warping
if (msg->cursize+128 > msg->maxsize)
memcpy(newent, oldent, sizeof(*newent)); //too much data, so set the ent up as the same as the old, so it's sent next frame
else
MSGQ2_WriteDeltaEntity (oldent, newent, msg, false, newent->number <= svs.allocated_client_slots, q2ex);
oldindex++;
newindex++;
continue;
}
if (newnum < oldnum)
{ // this is a new entity, send it from the baseline
if (msg->cursize+128 > msg->maxsize)
{ //might cause the packet to overflow
//so strip out this ent, we can add it next frame if it's still relevent
to->num_entities--;
memmove(newent, newent+1, sizeof(*newent) * (to->num_entities-newindex));
}
else
{
MSGQ2_WriteDeltaEntity (&sv_baselines[newnum], newent, msg, true, true, q2ex);
newindex++;
}
continue;
}
if (newnum > oldnum)
{ // the old entity isn't present in the new message
bits = Q2U_REMOVE;
if (oldnum >= 256)
bits |= Q2U_NUMBER16 | Q2U_MOREBITS1;
MSG_WriteByte (msg, bits&255 );
if (bits & 0x0000ff00)
MSG_WriteByte (msg, (bits>>8)&255 );
if (bits & Q2U_NUMBER16)
MSG_WriteShort (msg, oldnum);
else
MSG_WriteByte (msg, oldnum);
oldindex++;
continue;
}
}
MSG_WriteShort (msg, 0); // end of packetentities
#if 0
if (numprojs)
SV_EmitProjectileUpdate(msg);
#endif
}
/*
=============
SV_WritePlayerstateToClient
=============
*/
void SVQ2_WritePlayerstateToClient (client_t *client, int seat, int extflags, q2client_frame_t *from, q2client_frame_t *to, sizebuf_t *msg)
{
int i;
int pflags;
q2player_state_t *ps, *ops;
q2player_state_t dummy;
int statbits;
unsigned int pext = client->fteprotocolextensions;
unsigned int q2e = client->protocol == SCP_QUAKE2EX;
ps = &to->ps[seat];
if (!from)
{
memset (&dummy, 0, sizeof(dummy));
ops = &dummy;
}
else
ops = &from->ps[seat];
//
// determine what needs to be sent
//
pflags = 0;
if (pext & PEXT_SPLITSCREEN)
if (!from || from->clientnum[seat] != to->clientnum[seat])
pflags |= Q2FTEPS_CLIENTNUM;
if (ps->pmove.pm_type != ops->pmove.pm_type)
pflags |= Q2PS_M_TYPE;
if (ps->pmove.origin[0] != ops->pmove.origin[0]
|| ps->pmove.origin[1] != ops->pmove.origin[1]
|| ps->pmove.origin[2] != ops->pmove.origin[2] )
pflags |= Q2PS_M_ORIGIN;
if (ps->pmove.velocity[0] != ops->pmove.velocity[0]
|| ps->pmove.velocity[1] != ops->pmove.velocity[1]
|| ps->pmove.velocity[2] != ops->pmove.velocity[2] )
pflags |= Q2PS_M_VELOCITY;
if (ps->pmove.pm_time != ops->pmove.pm_time)
pflags |= Q2PS_M_TIME;
if (ps->pmove.pm_flags != ops->pmove.pm_flags)
pflags |= Q2PS_M_FLAGS;
if (ps->pmove.gravity != ops->pmove.gravity)
pflags |= Q2PS_M_GRAVITY;
if (ps->pmove.delta_angles[0] != ops->pmove.delta_angles[0]
|| ps->pmove.delta_angles[1] != ops->pmove.delta_angles[1]
|| ps->pmove.delta_angles[2] != ops->pmove.delta_angles[2] )
pflags |= Q2PS_M_DELTA_ANGLES;
if (ps->viewoffset[0] != ops->viewoffset[0]
|| ps->viewoffset[1] != ops->viewoffset[1]
|| ps->viewoffset[2] != ops->viewoffset[2] )
pflags |= Q2PS_VIEWOFFSET;
if (ps->viewangles[0] != ops->viewangles[0]
|| ps->viewangles[1] != ops->viewangles[1]
|| ps->viewangles[2] != ops->viewangles[2] )
pflags |= Q2PS_VIEWANGLES;
if (ps->kick_angles[0] != ops->kick_angles[0]
|| ps->kick_angles[1] != ops->kick_angles[1]
|| ps->kick_angles[2] != ops->kick_angles[2] )
pflags |= Q2PS_KICKANGLES;
if (ps->blend[0] != ops->blend[0]
|| ps->blend[1] != ops->blend[1]
|| ps->blend[2] != ops->blend[2]
|| ps->blend[3] != ops->blend[3] )
pflags |= Q2PS_BLEND;
if (ps->fov != ops->fov)
pflags |= Q2PS_FOV;
if (ps->rdflags != ops->rdflags)
pflags |= Q2PS_RDFLAGS;
if (ps->gunframe != ops->gunframe)
pflags |= Q2PS_WEAPONFRAME;
if (ps->gunindex != ops->gunindex)
pflags |= Q2PS_WEAPONINDEX;
if (pext & PEXT_MODELDBL)
{
if ((pflags & Q2PS_WEAPONINDEX) && ps->gunindex > 0xff)
pflags |= Q2FTEPS_INDEX16;
if ((pflags & Q2PS_WEAPONFRAME) && ps->gunframe > 0xff)
pflags |= Q2FTEPS_INDEX16;
}
if (pflags > 0xffff)
pflags |= Q2PS_EXTRABITS;
//
// write it
//
MSG_WriteByte (msg, svcq2_playerinfo);
MSG_WriteShort (msg, pflags&0xffff);
if (pflags & Q2PS_EXTRABITS)
{
if (q2e)
MSG_WriteShort (msg, pflags>>16);
else
MSG_WriteByte (msg, pflags>>16);
}
//
// write the pmove_state_t
//
if (pflags & Q2PS_M_TYPE)
{
i = ps->pmove.pm_type;
if (q2e)
{ //sigh... q2e added some extra pmove types that we don't support, and not on the end. :(
switch((q2pmtype_t)i)
{
case Q2PM_NORMAL: i = Q2EPM_NORMAL; break;
//case Q2PM_GRAPPLE: i = Q2EPM_GRAPPLE; break;
case Q2PM_SPECTATOR: i = Q2EPM_SPECTATOR; break;
//case Q2PM_SPECTATOR2: i = Q2EPM_SPECTATOR2; break;
case Q2PM_DEAD: i = Q2EPM_DEAD; break;
case Q2PM_GIB: i = Q2EPM_GIB; break;
case Q2PM_FREEZE: i = Q2EPM_FREEZE; break;
}
}
MSG_WriteByte (msg, i);
}
if (q2e)
{
if (pflags & Q2PS_M_ORIGIN)
{
MSG_WriteFloat (msg, ps->pmove.origin[0]/8.0);
MSG_WriteFloat (msg, ps->pmove.origin[1]/8.0);
MSG_WriteFloat (msg, ps->pmove.origin[2]/8.0);
}
if (pflags & Q2PS_M_VELOCITY)
{
MSG_WriteFloat (msg, ps->pmove.velocity[0]/8.0);
MSG_WriteFloat (msg, ps->pmove.velocity[1]/8.0);
MSG_WriteFloat (msg, ps->pmove.velocity[2]/8.0);
}
}
else
{
if (pflags & Q2PS_M_ORIGIN)
{
MSG_WriteShort (msg, ps->pmove.origin[0]);
MSG_WriteShort (msg, ps->pmove.origin[1]);
MSG_WriteShort (msg, ps->pmove.origin[2]);
}
if (pflags & Q2PS_M_VELOCITY)
{
MSG_WriteShort (msg, ps->pmove.velocity[0]);
MSG_WriteShort (msg, ps->pmove.velocity[1]);
MSG_WriteShort (msg, ps->pmove.velocity[2]);
}
}
if (pflags & Q2PS_M_TIME)
{
if (q2e)
MSG_WriteShort (msg, ps->pmove.pm_time);
else
MSG_WriteByte (msg, ps->pmove.pm_time);
}
if (pflags & Q2PS_M_FLAGS)
{
if (q2e)
MSG_WriteShort (msg, ps->pmove.pm_flags);
else
MSG_WriteByte (msg, ps->pmove.pm_flags);
}
if (pflags & Q2PS_M_GRAVITY)
MSG_WriteShort (msg, ps->pmove.gravity);
if (pflags & Q2PS_M_DELTA_ANGLES)
{
if (q2e)
{
MSG_WriteFloat (msg, SHORT2ANGLE(ps->pmove.delta_angles[0]));
MSG_WriteFloat (msg, SHORT2ANGLE(ps->pmove.delta_angles[1]));
MSG_WriteFloat (msg, SHORT2ANGLE(ps->pmove.delta_angles[2]));
}
else
{
MSG_WriteShort (msg, ps->pmove.delta_angles[0]);
MSG_WriteShort (msg, ps->pmove.delta_angles[1]);
MSG_WriteShort (msg, ps->pmove.delta_angles[2]);
}
}
//
// write the rest of the player_state_t
//
if (pflags & Q2PS_VIEWOFFSET)
{
if (q2e)
{
MSG_WriteShort (msg, ps->viewoffset[0]*16);
MSG_WriteShort (msg, ps->viewoffset[1]*16);
MSG_WriteShort (msg, (ps->viewoffset[2]-DEFAULT_VIEWHEIGHT)*16);
MSG_WriteChar (msg, DEFAULT_VIEWHEIGHT/*ps->pmove.viewheight*/);
}
else
{
MSG_WriteChar (msg, ps->viewoffset[0]*4);
MSG_WriteChar (msg, ps->viewoffset[1]*4);
MSG_WriteChar (msg, ps->viewoffset[2]*4);
}
}
if (pflags & Q2PS_VIEWANGLES)
{
if (q2e)
{
MSG_WriteFloat (msg, ps->viewangles[0]);
MSG_WriteFloat (msg, ps->viewangles[1]);
MSG_WriteFloat (msg, ps->viewangles[2]);
}
else
{
MSG_WriteAngle16 (msg, ps->viewangles[0]);
MSG_WriteAngle16 (msg, ps->viewangles[1]);
MSG_WriteAngle16 (msg, ps->viewangles[2]);
}
}
if (pflags & Q2PS_KICKANGLES)
{
if (q2e)
{
MSG_WriteShort (msg, ps->kick_angles[0]*1024);
MSG_WriteShort (msg, ps->kick_angles[1]*1024);
MSG_WriteShort (msg, ps->kick_angles[2]*1024);
}
else
{
MSG_WriteChar (msg, ps->kick_angles[0]*4);
MSG_WriteChar (msg, ps->kick_angles[1]*4);
MSG_WriteChar (msg, ps->kick_angles[2]*4);
}
}
if (pflags & Q2PS_WEAPONINDEX)
{
if (q2e)
MSG_WriteShort(msg, (0/*gunskin*/<<13) | ps->gunindex);
else
{
if (pflags & Q2FTEPS_INDEX16)
MSG_WriteShort(msg, ps->gunindex);
else
MSG_WriteByte (msg, ps->gunindex);
}
}
if (pflags & Q2PS_WEAPONFRAME)
{
if (q2e)
{
unsigned short fl = ps->gunframe&0x1ff;
if (ps->gunoffset[0]) fl |= 1<<9;
if (ps->gunoffset[1]) fl |= 1<<10;
if (ps->gunoffset[2]) fl |= 1<<11;
if (ps->gunangles[0]) fl |= 1<<12;
if (ps->gunangles[1]) fl |= 1<<13;
if (ps->gunangles[2]) fl |= 1<<14;
//if (ps->gunrate[2]) fl |= 1<<15;
MSG_WriteShort (msg, fl);
if (fl & (1<<9)) MSG_WriteFloat(msg, ps->gunoffset[0]);
if (fl & (1<<10)) MSG_WriteFloat(msg, ps->gunoffset[1]);
if (fl & (1<<11)) MSG_WriteFloat(msg, ps->gunoffset[2]);
if (fl & (1<<12)) MSG_WriteFloat(msg, ps->gunangles[0]);
if (fl & (1<<13)) MSG_WriteFloat(msg, ps->gunangles[1]);
if (fl & (1<<14)) MSG_WriteFloat(msg, ps->gunangles[2]);
//if (fl & (1<<15)) MSG_WriteByte(msg, ps->gunrate);
}
else
{
if (pflags & Q2FTEPS_INDEX16)
MSG_WriteShort (msg, ps->gunframe);
else
MSG_WriteByte (msg, ps->gunframe);
MSG_WriteChar (msg, ps->gunoffset[0]*4);
MSG_WriteChar (msg, ps->gunoffset[1]*4);
MSG_WriteChar (msg, ps->gunoffset[2]*4);
MSG_WriteChar (msg, ps->gunangles[0]*4);
MSG_WriteChar (msg, ps->gunangles[1]*4);
MSG_WriteChar (msg, ps->gunangles[2]*4);
}
}
if (pflags & Q2PS_BLEND)
{
MSG_WriteByte (msg, ps->blend[0]*255);
MSG_WriteByte (msg, ps->blend[1]*255);
MSG_WriteByte (msg, ps->blend[2]*255);
MSG_WriteByte (msg, ps->blend[3]*255);
}
if (pflags & Q2PS_FOV)
MSG_WriteByte (msg, ps->fov);
if (pflags & Q2PS_RDFLAGS)
MSG_WriteByte (msg, ps->rdflags);
// send stats
statbits = 0;
for (i=0 ; i<min(32,Q2MAX_STATS); i++)
if (ps->stats[i] != ops->stats[i])
statbits |= 1<<i;
MSG_WriteLong (msg, statbits);
for (i=0 ; i<min(32,Q2MAX_STATS) ; i++)
if (statbits & (1<<i) )
MSG_WriteShort (msg, ps->stats[i]);
if (q2e)
{
statbits = 0;
for (i=0 ; i<Q2MAX_STATS-32 ; i++)
if (ps->stats[32+i] != ops->stats[32+i])
statbits |= 1<<i;
MSG_WriteLong (msg, statbits);
for (i=0 ; i<Q2MAX_STATS-32 ; i++)
if (statbits & (1<<i) )
MSG_WriteShort (msg, ps->stats[32+i]);
if (pflags & Q2EXPS_DAMAGEBLEND)
{
MSG_WriteByte(msg, 0*255);
MSG_WriteByte(msg, 0*255);
MSG_WriteByte(msg, 0*255);
MSG_WriteByte(msg, 0*255);
}
if (pflags & Q2EXPS_TEAMID)
MSG_WriteByte(msg, 0);
}
else
{
if ((extflags & Q2PSX_CLIENTNUM) || (pflags & Q2FTEPS_CLIENTNUM))
MSG_WriteByte(msg, to->clientnum[seat]);
}
}
/*
==================
SV_WriteFrameToClient
==================
*/
void SVQ2_WriteFrameToClient (client_t *client, sizebuf_t *msg)
{
q2client_frame_t *frame, *oldframe;
int lastframe;
client_t *split;
int seat;
int extflags = 0;
//Com_Printf ("%i -> %i\n", client->lastframe, sv.framenum);
// this is the frame we are creating
frame = &client->frameunion.q2frames[sv.framenum & Q2UPDATE_MASK];
if (client->delta_sequence <= 0)
{ // client is asking for a retransmit
oldframe = NULL;
lastframe = -1;
}
else if (sv.framenum - client->delta_sequence >= (Q2UPDATE_BACKUP - 3) )
{ // client hasn't gotten a good message through in a long time
// Com_Printf ("%s: Delta request from out-of-date packet.\n", client->name);
oldframe = NULL;
lastframe = -1;
}
else
{ // we have a valid message to delta from
oldframe = &client->frameunion.q2frames[client->delta_sequence & Q2UPDATE_MASK];
lastframe = client->delta_sequence;
}
MSG_WriteByte (msg, svcq2_frame);
MSG_WriteLong (msg, sv.framenum);
MSG_WriteLong (msg, lastframe); // what we are delta'ing from
MSG_WriteByte (msg, client->chokecount&0xff); // rate dropped packets
extflags |= Q2PSX_OLD;
client->chokecount = 0;
if (client->protocol == SCP_QUAKE2EX)
{
for (split = client, seat = 0; split; split = split->controlled, seat++)
{
// send over the areabits, private per-seat
MSG_WriteByte (msg, frame->areabytes);
SZ_Write (msg, frame->areabits, frame->areabytes);
// delta encode the playerstate
SVQ2_WritePlayerstateToClient (client, seat, extflags, oldframe, frame, msg);
}
}
else
{
// send over the areabits, shared between all seats
MSG_WriteByte (msg, frame->areabytes);
SZ_Write (msg, frame->areabits, frame->areabytes);
// delta encode the playerstate
for (split = client, seat = 0; split; split = split->controlled, seat++)
SVQ2_WritePlayerstateToClient (client, seat, extflags, oldframe, frame, msg);
}
// delta encode the entities
SVQ2_EmitPacketEntities (oldframe, frame, msg, client->protocol==SCP_QUAKE2EX);
}
/*
=============================================================================
Build a client frame structure
=============================================================================
*/
/*
=============
SV_BuildClientFrame
Decides which entities are going to be visible to the client, and
copies off the playerstat and areabits.
=============
*/
void SVQ2_Ents_Init(void);
void SVQ2_BuildClientFrame (client_t *client)
{
int e, i;
vec3_t org[MAX_SPLITS];
int clientarea[MAX_SPLITS];
q2edict_t *clent[MAX_SPLITS];
client_t *split;
q2edict_t *ent;
q2client_frame_t *frame;
q2entity_state_t *state;
int l;
int seat;
int c_fullsend;
pvsbuffer_t clientpvs;
qbyte *clientphs = NULL;
int seats;
if (client->state < cs_spawned)
return;
SVQ2_Ents_Init();
clientpvs.buffer = alloca(clientpvs.buffersize=sv.world.worldmodel->pvsbytes);
#if 0
numprojs = 0; // no projectiles yet
#endif
// this is the frame the client will be acking (EVIL HACKS!)
frame = &client->frameunion.q2frames[client->netchan.outgoing_sequence & Q2UPDATE_MASK];
frame->senttime = realtime*1000; // save it for ping calc later
// this is the frame we are creating
frame = &client->frameunion.q2frames[sv.framenum & Q2UPDATE_MASK];
// grab the current player_state_t
for (seat = 0, split = client; split; split = split->controlled, seat++)
{
int clientcluster;
clent[seat] = split->q2edict;
frame->clientnum[seat] = split - svs.clients;
if (!split->q2edict->client)
{ //shouldn't happen
VectorClear(org[seat]);
clientarea[seat] = 0;
memset(&frame->ps[seat], 0, sizeof(frame->ps[seat]));
frame->ps[seat].pmove.pm_type = Q2PM_FREEZE;
continue;
}
// find the client's PVS
for (i=0 ; i<3 ; i++)
org[seat][i] = clent[seat]->client->ps.pmove.origin[i]*0.125 + clent[seat]->client->ps.viewoffset[i];
clientcluster = sv.world.worldmodel->funcs.ClusterForPoint (sv.world.worldmodel, org[seat], &clientarea[seat]);
// calculate the visible areas
frame->areabytes = sv.world.worldmodel->funcs.WriteAreaBits (sv.world.worldmodel, frame->areabits, sizeof(frame->areabits), clientarea[seat], seat != 0);
sv.world.worldmodel->funcs.FatPVS(sv.world.worldmodel, org[seat], &clientpvs, seat!=0);
if (seat==0) //FIXME
clientphs = sv.world.worldmodel->funcs.ClusterPHS (sv.world.worldmodel, clientcluster, NULL);
frame->ps[seat] = clent[seat]->client->ps;
if (sv.paused)
frame->ps[seat].pmove.pm_type = Q2PM_FREEZE;
}
seats = seat;
for (; seat < MAX_SPLITS; seat++)
{
memset(&frame->ps[seat], 0, sizeof(frame->ps[seat]));
frame->clientnum[seat] = 0xff; //invalid
}
// build up the list of visible entities
frame->num_entities = 0;
frame->first_entity = svs_next_client_entities;
c_fullsend = 0;
for (e=1 ; e<ge->num_edicts ; e++)
{
ent = Q2EDICT_NUM(e);
// ignore ents without visible models
if (ent->svflags & SVF_NOCLIENT)
continue;
// ignore ents without visible models unless they have an effect
if (!ent->s.modelindex && !ent->s.effects && !ent->s.sound
&& !ent->s.event)
continue;
for (seat = 0; seat < seats; seat++)
{
// ignore if not touching a PV leaf
if (ent != clent[seat])
{
// check area
if (!sv.world.worldmodel->funcs.AreasConnected (sv.world.worldmodel, clientarea[seat], ent->areanum))
{ // doors can legally straddle two areas, so
// we may need to check another one
if (!ent->areanum2
|| !sv.world.worldmodel->funcs.AreasConnected (sv.world.worldmodel, clientarea[seat], ent->areanum2))
continue; // blocked by a door
}
// beams just check one point for PHS
if (ent->s.renderfx & Q2RF_BEAM)
{
l = ent->clusternums[0];
if ( !(clientphs[l >> 3] & (1 << (l&7) )) )
continue;
}
else
{
// FIXME: if an ent has a model and a sound, but isn't
// in the PVS, only the PHS, clear the model
if (ent->num_clusters == -1)
{ // too many leafs for individual check, go by headnode
pvscache_t cache;
cache.num_leafs = -1;
cache.headnode = ent->headnode;
if (!sv.world.worldmodel->funcs.EdictInFatPVS(sv.world.worldmodel, &cache, clientpvs.buffer, NULL))
continue;
c_fullsend++;
}
else
{ // check individual leafs
for (i=0 ; i < ent->num_clusters ; i++)
{
l = ent->clusternums[i];
if (clientpvs.buffer[l >> 3] & (1 << (l&7) ))
break;
}
if (i == ent->num_clusters)
continue; // not visible
}
if (!ent->s.modelindex)
{ // don't send sounds if they will be attenuated away
vec3_t delta;
float len;
VectorSubtract (org[seat], ent->s.origin, delta);
len = Length (delta);
if (len > 400)
continue;
}
}
}
break;
}
if (seat == seats)
continue; //not visible to any seat
seat = 0; //FIXME
// add it to the circular client_entities array
state = &svs_client_entities[svs_next_client_entities%svs_num_client_entities];
if (ent->s.number != e)
{
Con_DPrintf ("FIXING ENT->S.NUMBER!!!\n");
ent->s.number = e;
}
*state = ent->s;
// don't mark players missiles as solid
if (ent->owner == clent[seat])
state->solid = 0;
svs_next_client_entities++;
frame->num_entities++;
}
}
void SVQ2_BuildBaselines(void)
{
unsigned int e;
q2edict_t *ent;
q2entity_state_t *base;
if (!ge)
return;
for (e=1 ; e<ge->num_edicts ; e++)
{
ent = Q2EDICT_NUM(e);
base = &ent->s;
if (base->modelindex || base->sound || base->effects)
sv_baselines[e] = *base;
}
}
void SVQ2_Ents_Init(void)
{
extern cvar_t maxclients;
if (!svs_client_entities)
{
svs_num_client_entities = maxclients.value*Q2UPDATE_BACKUP*64;
svs_client_entities = Z_Malloc (sizeof(entity_state_t)*svs_num_client_entities);
}
}
void SVQ2_Ents_Shutdown(void)
{
if (svs_client_entities)
{
Z_Free(svs_client_entities);
svs_client_entities = NULL;
svs_num_client_entities = 0;
}
}
#endif
#endif
Reference in a new issue View git blame Copy permalink