b380421e42
Clarify the 'too many alternate clients' messages. Gamepad movement should respond to +speed. favour fte's nq protocols over dp ones when both are supported by the client, to boost compat with qss. try to generate proper utf-8 filenames from player/team names when recording mvds, instead of bad char encodings. Fix loading saved games with splitscreen enabled. pr_dumpplatform can now optionally filter symbols via some specific external files, adding deprecated tags for any symbol not also supported by DP and QSS. Rework CSQC globals to use macros, to ensure completeness and consistency. rework sv_csqcdebug to use special svcs. This should make it more robust. Fix some scary warnings when vid_reloading the vulkan renderer. Fix a possible segfault from opengl+rtlights. Mousewheel will now interact better with engine menus. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5757 fc73d0e0-1445-4013-8a0c-d673dee63da5
4237 lines
118 KiB
C
4237 lines
118 KiB
C
/*
|
|
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.
|
|
|
|
*/
|
|
|
|
#include "quakedef.h"
|
|
#include "pr_common.h"
|
|
#ifndef CLIENTONLY
|
|
|
|
extern cvar_t sv_nailhack;
|
|
extern cvar_t sv_cullentities_trace;
|
|
extern cvar_t sv_cullplayers_trace;
|
|
extern cvar_t sv_nopvs;
|
|
|
|
#define SV_PVS_CAMERAS 16
|
|
typedef struct
|
|
{
|
|
int numents;
|
|
edict_t *ent[SV_PVS_CAMERAS]; //ents in this list are always sent, even if the server thinks that they are invisible.
|
|
vec3_t org[SV_PVS_CAMERAS];
|
|
int area[1+SV_PVS_CAMERAS];
|
|
|
|
pvsbuffer_t pvs;
|
|
} pvscamera_t;
|
|
|
|
static void *AllocateBoneSpace(packet_entities_t *pack, unsigned char bonecount, unsigned int *allocationpos)
|
|
{
|
|
size_t space = bonecount * sizeof(short)*7;
|
|
void *r;
|
|
if (pack->bonedatacur + space > pack->bonedatamax)
|
|
{ //expand the storage as needed. messy, but whatever.
|
|
pack->bonedatamax = pack->bonedatacur + space;
|
|
pack->bonedata = BZ_Realloc(pack->bonedata, pack->bonedatamax);
|
|
}
|
|
r = pack->bonedata + pack->bonedatacur;
|
|
*allocationpos = pack->bonedatacur;
|
|
pack->bonedatacur += space;
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
The PVS must include a small area around the client to allow head bobbing
|
|
or other small motion on the client side. Otherwise, a bob might cause an
|
|
entity that should be visible to not show up, especially when the bob
|
|
crosses a waterline.
|
|
|
|
=============================================================================
|
|
*/
|
|
|
|
static int needcleanup;
|
|
|
|
//int fatbytes;
|
|
|
|
void SV_ExpandNackFrames(client_t *client, int require, client_frame_t **currentframeptr)
|
|
{
|
|
client_frame_t *newframes;
|
|
char *ptr;
|
|
int i;
|
|
int maxlog = require * 2; /*this is the max number of ents updated per frame. we can't track more, so...*/
|
|
if (maxlog > client->max_net_ents)
|
|
maxlog = client->max_net_ents;
|
|
ptr = Z_Malloc( sizeof(client_frame_t)*UPDATE_BACKUP+
|
|
sizeof(*client->pendingdeltabits)*client->max_net_ents+
|
|
sizeof(*client->pendingcsqcbits)*client->max_net_ents+
|
|
sizeof(newframes[i].resend)*maxlog*UPDATE_BACKUP);
|
|
newframes = (void*)ptr;
|
|
memcpy(newframes, client->frameunion.frames, sizeof(client_frame_t)*UPDATE_BACKUP);
|
|
ptr += sizeof(client_frame_t)*UPDATE_BACKUP;
|
|
memcpy(ptr, client->pendingdeltabits, sizeof(*client->pendingdeltabits)*client->max_net_ents);
|
|
client->pendingdeltabits = (void*)ptr;
|
|
ptr += sizeof(*client->pendingdeltabits)*client->max_net_ents;
|
|
memcpy(ptr, client->pendingcsqcbits, sizeof(*client->pendingcsqcbits)*client->max_net_ents);
|
|
client->pendingcsqcbits = (void*)ptr;
|
|
ptr += sizeof(*client->pendingcsqcbits)*client->max_net_ents;
|
|
for (i = 0; i < UPDATE_BACKUP; i++)
|
|
{
|
|
newframes[i].maxresend = maxlog;
|
|
newframes[i].qwentities.max_entities = 0;
|
|
newframes[i].resend = (void*)ptr;
|
|
newframes[i].numresend = client->frameunion.frames[i].numresend;
|
|
memcpy(newframes[i].resend, client->frameunion.frames[i].resend, sizeof(newframes[i].resend)*newframes[i].numresend);
|
|
newframes[i].senttime = realtime;
|
|
}
|
|
Z_Free(client->frameunion.frames);
|
|
|
|
//if you're calling this then its because you're currently generating new frame data, and its a problem if that changes from under you. fix it up for the caller (so they can't forget to do so)
|
|
*currentframeptr = newframes+(*currentframeptr-client->frameunion.frames);
|
|
|
|
client->frameunion.frames = newframes;
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
// because there can be a lot of nails, there is a special
|
|
// network protocol for them
|
|
#define MAX_NAILS 32
|
|
static edict_t *nails[MAX_NAILS];
|
|
static int numnails;
|
|
static int nailcount = 0;
|
|
extern int sv_nailmodel, sv_supernailmodel, sv_playermodel;
|
|
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
qboolean demonails;
|
|
#endif
|
|
|
|
static edict_t **csqcent/*[csqcmaxents]*/;
|
|
static size_t csqcmaxents;
|
|
static size_t csqcnuments;
|
|
|
|
qboolean SV_AddNailUpdate (edict_t *ent)
|
|
{
|
|
if (ent->v->modelindex != sv_nailmodel
|
|
&& ent->v->modelindex != sv_supernailmodel)
|
|
return false; //must be a nail
|
|
if (sv_nailhack.value || (host_client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS))
|
|
return false; //'nailhack' is named because of a qizmo-publicised binary hack to disable svc_nails. replacementdeltas also trims much of the state so we may as well use it.
|
|
//should probably also detect qizmo specifically - its trajectory stuff beats svc_nails.
|
|
if (ent->v->origin[0] <= -4096 || ent->v->origin[0] >= 4096 ||
|
|
ent->v->origin[1] <= -4096 || ent->v->origin[1] >= 4096 ||
|
|
ent->v->origin[2] <= -4096 || ent->v->origin[2] >= 4096)
|
|
return !(host_client->fteprotocolextensions & PEXT_FLOATCOORDS); //outside the bounds of the nails protocol. just swallow it if it can't be sent anyway.
|
|
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
demonails = false;
|
|
#endif
|
|
|
|
if (numnails == MAX_NAILS)
|
|
return true;
|
|
|
|
nails[numnails] = ent;
|
|
numnails++;
|
|
return true;
|
|
}
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
qboolean SV_DemoNailUpdate (int i)
|
|
{
|
|
demonails = true;
|
|
|
|
if (numnails == MAX_NAILS)
|
|
return true;
|
|
nails[numnails] = (edict_t *)i;
|
|
numnails++;
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
void SV_EmitNailUpdate (sizebuf_t *msg, qboolean recorder)
|
|
{
|
|
qbyte bits[6]; // [48 bits] xyzpy 12 12 12 4 8
|
|
int n, i;
|
|
edict_t *ent;
|
|
int x, y, z, p, yaw;
|
|
|
|
if (!numnails)
|
|
return;
|
|
|
|
if (recorder)
|
|
MSG_WriteByte (msg, svc_nails2);
|
|
else
|
|
MSG_WriteByte (msg, svc_nails);
|
|
|
|
MSG_WriteByte (msg, numnails);
|
|
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
if (demonails)
|
|
{
|
|
for (n=0 ; n<numnails ; n++)
|
|
{
|
|
i = (int)(nails[n]);
|
|
if (recorder) {
|
|
if (!sv.demospikes[i].id) {
|
|
if (!((++nailcount)&255)) nailcount++;
|
|
sv.demospikes[i].id = nailcount&255;
|
|
}
|
|
|
|
MSG_WriteByte (msg, (qbyte)sv.demospikes[i].id);
|
|
}
|
|
x = (int)(sv.demospikes[i].org[0]+4096)>>1;
|
|
y = (int)(sv.demospikes[i].org[1]+4096)>>1;
|
|
z = (int)(sv.demospikes[i].org[2]+4096)>>1;
|
|
p = (int)(sv.demospikes[i].pitch)&15;
|
|
yaw = (int)(sv.demospikes[i].yaw)&255;
|
|
|
|
bits[0] = x;
|
|
bits[1] = (x>>8) | (y<<4);
|
|
bits[2] = (y>>4);
|
|
bits[3] = z;
|
|
bits[4] = (z>>8) | (p<<4);
|
|
bits[5] = yaw;
|
|
|
|
for (i=0 ; i<6 ; i++)
|
|
MSG_WriteByte (msg, bits[i]);
|
|
}
|
|
|
|
return;
|
|
}
|
|
#endif
|
|
for (n=0 ; n<numnails ; n++)
|
|
{
|
|
ent = nails[n];
|
|
if (recorder) {
|
|
if (!ent->v->colormap) {
|
|
if (!((++nailcount)&255)) nailcount++;
|
|
ent->v->colormap = nailcount&255;
|
|
}
|
|
|
|
MSG_WriteByte (msg, (qbyte)ent->v->colormap);
|
|
}
|
|
x = (int)(ent->v->origin[0]+4096)>>1;
|
|
y = (int)(ent->v->origin[1]+4096)>>1;
|
|
z = (int)(ent->v->origin[2]+4096)>>1;
|
|
p = (int)(16*ent->v->angles[0]/360)&15;
|
|
yaw = (int)(256*ent->v->angles[1]/360)&255;
|
|
|
|
bits[0] = x & 0xff;
|
|
bits[1] = ((x>>8) | (y<<4)) & 0xff;
|
|
bits[2] = (y>>4) & 0xff;
|
|
bits[3] = z & 0xff;
|
|
bits[4] = ((z>>8) | (p<<4)) & 0xff;
|
|
bits[5] = yaw & 0xff;
|
|
|
|
for (i=0 ; i<6 ; i++)
|
|
MSG_WriteByte (msg, bits[i]);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//=============================================================================
|
|
|
|
//this is the bit of the code that sends the csqc entity deltas out.
|
|
//whenever the entity in question has a newer version than we sent to the client, we need to resend.
|
|
|
|
//So, we track the outgoing sequence that an entity was sent in, and the version.
|
|
//Upon detection of a dropped packet, we resend all entities who were last sent in that packet.
|
|
//When an entities' last sent version doesn't match the current version, we send.
|
|
static qboolean SV_AddCSQCUpdate (client_t *client, edict_t *ent)
|
|
{
|
|
#ifndef PEXT_CSQC
|
|
return false;
|
|
#else
|
|
if (!ent->xv->SendEntity)
|
|
return false;
|
|
|
|
if (!(client->csqcactive))
|
|
return false;
|
|
|
|
if (csqcnuments >= csqcmaxents)
|
|
Z_ReallocElements((void**)&csqcent, &csqcmaxents, csqcnuments + 1024, sizeof(*csqcent));
|
|
csqcent[csqcnuments++] = ent;
|
|
|
|
return true;
|
|
#endif
|
|
}
|
|
sizebuf_t csqcmsgbuffer;
|
|
|
|
static void SV_EmitDeltaEntIndex(sizebuf_t *msg, unsigned int entnum, qboolean remove, qboolean big)
|
|
{
|
|
unsigned int rflag = remove?0x8000:0;
|
|
if (big)
|
|
{
|
|
if (entnum >= 0x4000)
|
|
{
|
|
MSG_WriteShort(msg, (entnum&0x3fff) | 0x4000 | rflag);
|
|
MSG_WriteByte(msg, entnum >> 14);
|
|
}
|
|
else
|
|
MSG_WriteShort(msg, entnum | rflag);
|
|
}
|
|
else
|
|
MSG_WriteShort(msg, entnum | rflag);
|
|
}
|
|
void SV_EmitCSQCUpdate(client_t *client, sizebuf_t *msg, qbyte svcnumber)
|
|
{
|
|
#ifdef PEXT_CSQC
|
|
static float throttle;
|
|
qbyte messagebuffer[MAX_OVERALLMSGLEN];
|
|
int en;
|
|
int currentsequence = client->netchan.outgoing_sequence;
|
|
globalvars_t *pr_globals;
|
|
edict_t *ent;
|
|
qboolean writtenheader = false;
|
|
int viewerent;
|
|
int entnum;
|
|
client_frame_t *frame = &client->frameunion.frames[currentsequence & UPDATE_MASK];
|
|
int lognum = frame->numresend;
|
|
|
|
struct resendinfo_s *resend = frame->resend;
|
|
int maxlog = frame->maxresend;
|
|
|
|
//we don't check that we got some already - because this is delta compressed!
|
|
|
|
if (!client->csqcactive || !svprogfuncs || !client->pendingcsqcbits)
|
|
return;
|
|
|
|
pr_globals = PR_globals(svprogfuncs, PR_CURRENT);
|
|
|
|
if (client->edict)
|
|
viewerent = EDICT_TO_PROG(svprogfuncs, client->edict);
|
|
else
|
|
viewerent = 0; /*for mvds, its as if world is looking*/
|
|
|
|
//FIXME: prioritise the list of csqc ents somehow
|
|
|
|
csqcmsgbuffer.data = messagebuffer;
|
|
csqcmsgbuffer.maxsize = sizeof(messagebuffer);
|
|
csqcmsgbuffer.packing = msg->packing;
|
|
csqcmsgbuffer.prim = msg->prim;
|
|
|
|
if (sv_csqcdebug.ival)
|
|
svcnumber = svcfte_csqcentities_sized;
|
|
|
|
for (en = 0, entnum = 0; en < csqcnuments; en++, entnum++)
|
|
{
|
|
ent = csqcent[en];
|
|
|
|
//add any entity removes on ents leading up to this entity
|
|
for (; entnum < ent->entnum; entnum++)
|
|
{
|
|
if (client->pendingcsqcbits[entnum] & (SENDFLAGS_PRESENT|SENDFLAGS_REMOVED))
|
|
{
|
|
if (!(client->pendingcsqcbits[entnum] & SENDFLAGS_REMOVED))
|
|
{ //while the entity has NOREMOVE, only remove it if the remove is a resend
|
|
if ((int)EDICT_NUM_PB(svprogfuncs, entnum)->xv->pvsflags & PVSF_NOREMOVE)
|
|
continue;
|
|
}
|
|
if (msg->cursize + 5 >= msg->maxsize)
|
|
break; //we're overflowing, try removing next frame instead.
|
|
|
|
if (lognum > maxlog)
|
|
{
|
|
if (maxlog == client->max_net_ents)
|
|
break;
|
|
SV_ExpandNackFrames(client, lognum+1, &frame);
|
|
resend = frame->resend;
|
|
maxlog = frame->maxresend;
|
|
}
|
|
resend[lognum].entnum = entnum;
|
|
resend[lognum].bits = 0;
|
|
resend[lognum].flags = SENDFLAGS_REMOVED;
|
|
lognum++;
|
|
|
|
if (!writtenheader)
|
|
{
|
|
writtenheader=true;
|
|
MSG_WriteByte(msg, svcnumber);
|
|
}
|
|
|
|
SV_EmitDeltaEntIndex(msg, entnum, true, client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS);
|
|
// Con_Printf("Sending remove 2 packet\n");
|
|
|
|
client->pendingcsqcbits[entnum] = 0;
|
|
}
|
|
}
|
|
|
|
if (client->pendingcsqcbits[entnum] == SENDFLAGS_PRESENT)
|
|
continue; //nothing changed
|
|
|
|
if (client->pendingcsqcbits[entnum] & SENDFLAGS_REMOVED)
|
|
{
|
|
//we lost a remove, but it got readded since.
|
|
//make sure all is resent
|
|
client->pendingcsqcbits[entnum] = SENDFLAGS_USABLE;
|
|
}
|
|
|
|
if (!(client->pendingcsqcbits[entnum] & SENDFLAGS_PRESENT))
|
|
client->pendingcsqcbits[entnum] = SENDFLAGS_USABLE; //this entity appears new. make sure its fully transmitted.
|
|
|
|
csqcmsgbuffer.cursize = 0;
|
|
csqcmsgbuffer.currentbit = 0;
|
|
//Ask CSQC to write a buffer for it.
|
|
G_INT(OFS_PARM0) = viewerent;
|
|
G_FLOAT(OFS_PARM1) = (int)(client->pendingcsqcbits[entnum] & 0xffffff);
|
|
|
|
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, ent);
|
|
PR_ExecuteProgram(svprogfuncs, ent->xv->SendEntity);
|
|
if (G_INT(OFS_RETURN)) //0 means not to tell the client about it.
|
|
{
|
|
//FIXME: don't overflow MAX_DATAGRAM... unless its too big anyway...
|
|
if (msg->cursize + csqcmsgbuffer.cursize+5 >= msg->maxsize)
|
|
{
|
|
//warn when the message is larger than the user's max size..
|
|
if (csqcmsgbuffer.cursize+5 > msg->maxsize)
|
|
Con_ThrottlePrintf(&throttle, 0, "CSQC update of entity %i(%s) is larger than user %s's maximum datagram size (%u > %u).\n", entnum, PR_GetString(svprogfuncs, ent->v->classname), client->name, csqcmsgbuffer.cursize, msg->maxsize-5);
|
|
if (csqcmsgbuffer.cursize < 32)
|
|
break;
|
|
continue;
|
|
}
|
|
|
|
if (lognum > maxlog)
|
|
{
|
|
if (maxlog == client->max_net_ents)
|
|
break;
|
|
SV_ExpandNackFrames(client, lognum+1, &frame);
|
|
resend = frame->resend;
|
|
maxlog = frame->maxresend;
|
|
}
|
|
resend[lognum].entnum = entnum;
|
|
resend[lognum].bits = 0;
|
|
resend[lognum].flags = SENDFLAGS_PRESENT|client->pendingcsqcbits[entnum];
|
|
lognum++;
|
|
|
|
if (!writtenheader)
|
|
{
|
|
writtenheader=true;
|
|
MSG_WriteByte(msg, svcnumber);
|
|
}
|
|
SV_EmitDeltaEntIndex(msg, entnum, false, client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS);
|
|
if (svcnumber == svcfte_csqcentities_sized) //optional extra length prefix.
|
|
{
|
|
if (!csqcmsgbuffer.cursize)
|
|
Con_Printf("Warning: empty csqc packet on %s\n", PR_GetString(svprogfuncs, ent->v->classname));
|
|
MSG_WriteShort(msg, csqcmsgbuffer.cursize);
|
|
}
|
|
SZ_Write(msg, csqcmsgbuffer.data, csqcmsgbuffer.cursize);
|
|
|
|
client->pendingcsqcbits[entnum] = SENDFLAGS_PRESENT;
|
|
// Con_Printf("Sending update packet %i\n", ent->entnum);
|
|
}
|
|
else if ((client->pendingcsqcbits[entnum] & SENDFLAGS_PRESENT) && !((int)ent->xv->pvsflags & PVSF_NOREMOVE))
|
|
{ //Don't want to send, but they have it already
|
|
|
|
|
|
if (msg->cursize + 5 >= msg->maxsize)
|
|
break; //we're overflowing, try removing next frame instead.
|
|
|
|
if (lognum > maxlog)
|
|
{
|
|
if (maxlog == client->max_net_ents)
|
|
break;
|
|
SV_ExpandNackFrames(client, lognum+1, &frame);
|
|
resend = frame->resend;
|
|
maxlog = frame->maxresend;
|
|
}
|
|
resend[lognum].entnum = entnum;
|
|
resend[lognum].bits = 0;
|
|
resend[lognum].flags = SENDFLAGS_REMOVED;
|
|
lognum++;
|
|
|
|
if (!writtenheader)
|
|
{
|
|
writtenheader=true;
|
|
MSG_WriteByte(msg, svcnumber);
|
|
}
|
|
|
|
SV_EmitDeltaEntIndex(msg, entnum, true, client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS);
|
|
// Con_Printf("Sending remove 2 packet\n");
|
|
|
|
client->pendingcsqcbits[entnum] = 0;
|
|
}
|
|
}
|
|
|
|
//and now tail entities
|
|
for(; entnum < client->max_net_ents && entnum < sv.world.num_edicts; entnum++)
|
|
{
|
|
if (client->pendingcsqcbits[entnum] & (SENDFLAGS_PRESENT|SENDFLAGS_REMOVED))
|
|
{
|
|
if (!(client->pendingcsqcbits[entnum] & SENDFLAGS_REMOVED))
|
|
{ //while the original entity has NOREMOVE, only remove it if the remove is a resend
|
|
if ((int)EDICT_NUM_PB(svprogfuncs, entnum)->xv->pvsflags & PVSF_NOREMOVE)
|
|
continue;
|
|
}
|
|
if (msg->cursize + 5 >= msg->maxsize)
|
|
break; //we're overflowing, try removing next frame instead.
|
|
|
|
if (lognum > maxlog)
|
|
{
|
|
if (maxlog == client->max_net_ents)
|
|
break;
|
|
SV_ExpandNackFrames(client, lognum+1, &frame);
|
|
resend = frame->resend;
|
|
maxlog = frame->maxresend;
|
|
}
|
|
resend[lognum].entnum = entnum;
|
|
resend[lognum].bits = 0;
|
|
resend[lognum].flags = SENDFLAGS_REMOVED;
|
|
lognum++;
|
|
|
|
if (!writtenheader)
|
|
{
|
|
writtenheader=true;
|
|
MSG_WriteByte(msg, svcnumber);
|
|
}
|
|
|
|
SV_EmitDeltaEntIndex(msg, entnum, true, client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS);
|
|
// Con_Printf("Sending remove 2 packet\n");
|
|
|
|
client->pendingcsqcbits[entnum] = 0;
|
|
}
|
|
}
|
|
|
|
if (writtenheader)
|
|
MSG_WriteShort(msg, 0); //a 0 means no more.
|
|
|
|
csqcnuments = 0;
|
|
|
|
frame->numresend = lognum;
|
|
|
|
//prevent the qc from trying to use it at inopertune times.
|
|
csqcmsgbuffer.maxsize = 0;
|
|
csqcmsgbuffer.data = NULL;
|
|
#endif
|
|
}
|
|
|
|
void SV_CSQC_DroppedPacket(client_t *client, int sequence)
|
|
{
|
|
int i;
|
|
client_frame_t *frame;
|
|
if (!ISQWCLIENT(client) && !ISNQCLIENT(client))
|
|
return;
|
|
|
|
if (!client->frameunion.frames)
|
|
{
|
|
Con_Printf("Server bug: No frames!\n");
|
|
return;
|
|
}
|
|
frame = &client->frameunion.frames[sequence & UPDATE_MASK];
|
|
|
|
//skip it if we never generated that frame, to avoid pulling in stale data
|
|
if (frame->sequence != sequence)
|
|
{
|
|
// Con_Printf("SV: Stale %i\n", sequence);
|
|
return;
|
|
}
|
|
|
|
//lost entities need flagging for a resend
|
|
if (frame->numresend)
|
|
{
|
|
struct resendinfo_s *resend = frame->resend;
|
|
// Con_Printf("SV: Resend %i\n", sequence);
|
|
i = frame->numresend;
|
|
while (i > 0)
|
|
{
|
|
i--;
|
|
client->pendingdeltabits[resend[i].entnum] |= resend[i].bits;
|
|
client->pendingcsqcbits[resend[i].entnum] |= resend[i].flags;
|
|
}
|
|
frame->numresend = 0; //don't resend the same info twice!
|
|
}
|
|
//lost stats do too
|
|
if (frame->numresendstats)
|
|
{
|
|
client_t *sp;
|
|
unsigned short *n = frame->resendstats;
|
|
i = frame->numresendstats;
|
|
while(i-->0)
|
|
{
|
|
unsigned short s = n[i];
|
|
if (s & 0xf000)
|
|
{
|
|
sp = client;
|
|
while (s & 0xf000)
|
|
{
|
|
s -= 0x1000;
|
|
sp = sp->controlled;
|
|
}
|
|
sp->pendingstats[s>>5u] |= 1u << (s & 0x1fu);
|
|
}
|
|
else
|
|
client->pendingstats[s>>5u] |= 1u << (s & 0x1fu);
|
|
}
|
|
frame->numresendstats = 0;
|
|
}
|
|
}
|
|
|
|
void SV_AckEntityFrame(client_t *cl, int framenum)
|
|
{
|
|
//any not acked yet are assumed to be lost.
|
|
//this may result in packetloss if the client received multiple packets between sending two outgoing packets.
|
|
int frame = cl->lastsequence_acknowledged+1;
|
|
if (framenum > cl->lastsequence_acknowledged)
|
|
cl->lastsequence_acknowledged = framenum;
|
|
if (framenum > frame + UPDATE_BACKUP)
|
|
framenum = frame + UPDATE_BACKUP;
|
|
|
|
#ifdef PEXT_CSQC
|
|
for (; frame < framenum; frame++)
|
|
SV_CSQC_DroppedPacket(cl, frame);
|
|
#endif
|
|
}
|
|
|
|
void SV_ReplaceEntityFrame(client_t *cl, int framenum)
|
|
{
|
|
//this packet is about to be overwritten, we can't track more.
|
|
//we might as well pretend that it got acked, we can't track pings that far back anyway, just make sure it gets flagged as dropped.
|
|
//due to how qw sequences are controlled by the client, the server may have skipped some frames. try to handle those too.
|
|
int frame = cl->lastsequence_acknowledged+1;
|
|
framenum -= UPDATE_BACKUP;
|
|
if (framenum > cl->lastsequence_acknowledged)
|
|
cl->lastsequence_acknowledged = framenum;
|
|
if (framenum > frame + UPDATE_BACKUP)
|
|
framenum = frame + UPDATE_BACKUP;
|
|
|
|
#ifdef PEXT_CSQC
|
|
for (; frame <= framenum; frame++)
|
|
SV_CSQC_DroppedPacket(cl, frame);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
void SV_CSQC_DropAll(client_t *client)
|
|
{
|
|
int i;
|
|
|
|
if (client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS)
|
|
{
|
|
// Con_Printf("Reset all\n");
|
|
client->pendingdeltabits[0] = UF_REMOVE;
|
|
}
|
|
|
|
if (client->csqcactive) //we don't need this, but it might be a little faster.
|
|
{
|
|
//FIXME: handle any needed removes
|
|
for (i = 0; i < sv.world.num_edicts; i++)
|
|
client->pendingcsqcbits[i] |= SENDFLAGS_USABLE; //resend all
|
|
}
|
|
|
|
//we don't know which stats were on the wire, resend all. :(
|
|
memset(client->pendingstats, 0xff, sizeof(client->pendingstats));
|
|
}
|
|
*/
|
|
//=============================================================================
|
|
|
|
|
|
/*
|
|
==================
|
|
SV_WriteDelta
|
|
|
|
Writes part of a packetentities message.
|
|
Can delta from either a baseline or a previous packet_entity
|
|
==================
|
|
*/
|
|
void SVQW_WriteDelta (entity_state_t *from, entity_state_t *to, sizebuf_t *msg, qboolean force, unsigned int protext)
|
|
{
|
|
#ifdef PROTOCOLEXTENSIONS
|
|
int evenmorebits=0;
|
|
#endif
|
|
int bits;
|
|
int i;
|
|
int fromeffects;
|
|
coorddata coordd[3];
|
|
coorddata angled[3];
|
|
|
|
if (from == &((edict_t*)NULL)->baseline)
|
|
from = &nullentitystate;
|
|
|
|
// send an update
|
|
bits = 0;
|
|
|
|
if (msg->prim.coordtype != COORDTYPE_FLOAT_32)
|
|
{
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
coordd[i] = MSG_ToCoord(to->origin[i], msg->prim.coordtype);
|
|
if (MSG_ToCoord(from->origin[i], msg->prim.coordtype).b4 != coordd[i].b4)
|
|
bits |= U_ORIGIN1<<i;
|
|
else
|
|
to->origin[i] = from->origin[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
coordd[i] = MSG_ToCoord(to->origin[i], msg->prim.coordtype);
|
|
if (to->origin[i] != from->origin[i])
|
|
bits |= U_ORIGIN1<<i;
|
|
}
|
|
}
|
|
|
|
angled[0] = MSG_ToAngle(to->angles[0], msg->prim.anglesize);
|
|
if (MSG_ToAngle(from->angles[0], msg->prim.anglesize).b4 != angled[0].b4)
|
|
bits |= U_ANGLE1;
|
|
else
|
|
to->angles[0] = from->angles[0];
|
|
|
|
angled[1] = MSG_ToAngle(to->angles[1], msg->prim.anglesize);
|
|
if (MSG_ToAngle(from->angles[1], msg->prim.anglesize).b4 != angled[1].b4)
|
|
bits |= U_ANGLE2;
|
|
else
|
|
to->angles[1] = from->angles[1];
|
|
|
|
angled[2] = MSG_ToAngle(to->angles[2], msg->prim.anglesize);
|
|
if (MSG_ToAngle(from->angles[2], msg->prim.anglesize).b4 != angled[2].b4)
|
|
bits |= U_ANGLE3;
|
|
else
|
|
to->angles[2] = from->angles[2];
|
|
|
|
if ( to->colormap != from->colormap )
|
|
bits |= U_COLORMAP;
|
|
|
|
if ( to->skinnum != from->skinnum )
|
|
bits |= U_SKIN;
|
|
|
|
if ( to->frame != from->frame )
|
|
bits |= U_FRAME;
|
|
|
|
|
|
if (force && !(protext & PEXT_SPAWNSTATIC2))
|
|
fromeffects = 0; //force is true if we're going from baseline
|
|
else //old quakeworld protocols do not include effects in the baseline
|
|
fromeffects = from->effects; //so old clients will see the effects baseline as 0
|
|
if ((to->effects&0x00ff) != (fromeffects&0x00ff))
|
|
bits |= U_EFFECTS;
|
|
if ((to->effects&0xff00) != (fromeffects&0xff00) && (protext & PEXT_DPFLAGS))
|
|
evenmorebits |= U_EFFECTS16;
|
|
|
|
if (to->modelindex != from->modelindex)
|
|
{
|
|
bits |= U_MODEL;
|
|
if (to->modelindex > 255)
|
|
{
|
|
if (protext & PEXT_MODELDBL)
|
|
{
|
|
if (to->modelindex > 512)
|
|
bits &= ~U_MODEL;
|
|
evenmorebits |= U_MODELDBL;
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
}
|
|
|
|
#ifdef PROTOCOLEXTENSIONS
|
|
#ifdef U_SCALE
|
|
if ( to->scale != from->scale && (protext & PEXT_SCALE))
|
|
evenmorebits |= U_SCALE;
|
|
#endif
|
|
#ifdef U_TRANS
|
|
if ( to->trans != from->trans && (protext & PEXT_TRANS))
|
|
evenmorebits |= U_TRANS;
|
|
#endif
|
|
#ifdef U_FATNESS
|
|
if ( to->fatness != from->fatness && (protext & PEXT_FATNESS))
|
|
evenmorebits |= U_FATNESS;
|
|
#endif
|
|
|
|
if ( to->hexen2flags != from->hexen2flags && (protext & PEXT_HEXEN2))
|
|
evenmorebits |= U_DRAWFLAGS;
|
|
if ( to->abslight != from->abslight && (protext & PEXT_HEXEN2))
|
|
evenmorebits |= U_ABSLIGHT;
|
|
|
|
if ((to->colormod[0]!=from->colormod[0]||to->colormod[1]!=from->colormod[1]||to->colormod[2]!=from->colormod[2]) && (protext & PEXT_COLOURMOD))
|
|
evenmorebits |= U_COLOURMOD;
|
|
|
|
if (to->glowsize != from->glowsize)
|
|
to->dpflags |= RENDER_GLOWTRAIL;
|
|
|
|
if (to->dpflags != from->dpflags && (protext & PEXT_DPFLAGS))
|
|
evenmorebits |= U_DPFLAGS;
|
|
|
|
if ((to->tagentity != from->tagentity || to->tagindex != from->tagindex) && (protext & PEXT_SETATTACHMENT))
|
|
evenmorebits |= U_TAGINFO;
|
|
|
|
if ((to->light[0] != from->light[0] || to->light[1] != from->light[1] || to->light[2] != from->light[2] || to->light[3] != from->light[3] || to->lightstyle != from->lightstyle || to->lightpflags != from->lightstyle) && (protext & PEXT_DPFLAGS))
|
|
evenmorebits |= U_LIGHT;
|
|
#endif
|
|
|
|
// if (to->solid)
|
|
// bits |= U_SOLID;
|
|
|
|
if (msg->cursize + 40 > msg->maxsize)
|
|
{ //not enough space in the buffer, don't send the entity this frame. (not sending means nothing changes, and it takes no bytes!!)
|
|
*to = *from;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// write the message
|
|
//
|
|
if (!to->number)
|
|
SV_Error ("Unset entity number");
|
|
|
|
if (!bits && !evenmorebits && !force)
|
|
return; // nothing to send!
|
|
|
|
#ifdef PROTOCOLEXTENSIONS
|
|
if (to->number >= 512)
|
|
{
|
|
if (to->number >= 1024)
|
|
{
|
|
if (to->number >= 1024+512)
|
|
evenmorebits |= U_ENTITYDBL;
|
|
|
|
evenmorebits |= U_ENTITYDBL2;
|
|
if (to->number >= 2048)
|
|
return;
|
|
}
|
|
else
|
|
evenmorebits |= U_ENTITYDBL;
|
|
}
|
|
|
|
if (evenmorebits&0xff00)
|
|
evenmorebits |= U_YETMORE;
|
|
if (evenmorebits&0x00ff)
|
|
bits |= U_EVENMORE;
|
|
if (bits & 511)
|
|
bits |= U_MOREBITS;
|
|
#endif
|
|
|
|
i = (to->number&511) | (bits&~511);
|
|
if (i & U_REMOVE)
|
|
Sys_Error ("U_REMOVE");
|
|
MSG_WriteShort (msg, i);
|
|
|
|
if (bits & U_MOREBITS)
|
|
MSG_WriteByte (msg, bits&255);
|
|
#ifdef PROTOCOLEXTENSIONS
|
|
if (bits & U_EVENMORE)
|
|
MSG_WriteByte (msg, evenmorebits&255);
|
|
if (evenmorebits & U_YETMORE)
|
|
MSG_WriteByte (msg, (evenmorebits>>8)&255);
|
|
#endif
|
|
|
|
if (bits & U_MODEL)
|
|
MSG_WriteByte (msg, to->modelindex&255);
|
|
else if (evenmorebits & U_MODELDBL)
|
|
MSG_WriteShort(msg, to->modelindex);
|
|
|
|
if (bits & U_FRAME)
|
|
MSG_WriteByte (msg, to->frame);
|
|
if (bits & U_COLORMAP)
|
|
MSG_WriteByte (msg, to->colormap);
|
|
if (bits & U_SKIN)
|
|
MSG_WriteByte (msg, to->skinnum&0xff);
|
|
if (bits & U_EFFECTS)
|
|
MSG_WriteByte (msg, to->effects&0x00ff);
|
|
if (bits & U_ORIGIN1)
|
|
SZ_Write(msg, &coordd[0], msg->prim.coordtype&0xf);
|
|
if (bits & U_ANGLE1)
|
|
SZ_Write(msg, &angled[0], msg->prim.anglesize);
|
|
if (bits & U_ORIGIN2)
|
|
SZ_Write(msg, &coordd[1], msg->prim.coordtype&0xf);
|
|
if (bits & U_ANGLE2)
|
|
SZ_Write(msg, &angled[1], msg->prim.anglesize);
|
|
if (bits & U_ORIGIN3)
|
|
SZ_Write(msg, &coordd[2], msg->prim.coordtype&0xf);
|
|
if (bits & U_ANGLE3)
|
|
SZ_Write(msg, &angled[2], msg->prim.anglesize);
|
|
|
|
#ifdef U_SCALE
|
|
if (evenmorebits & U_SCALE)
|
|
MSG_WriteByte (msg, (qbyte)(to->scale));
|
|
#endif
|
|
#ifdef U_TRANS
|
|
if (evenmorebits & U_TRANS)
|
|
MSG_WriteByte (msg, (qbyte)(to->trans));
|
|
#endif
|
|
#ifdef U_FATNESS
|
|
if (evenmorebits & U_FATNESS)
|
|
MSG_WriteChar (msg, to->fatness);
|
|
#endif
|
|
|
|
if (evenmorebits & U_DRAWFLAGS)
|
|
MSG_WriteByte (msg, to->hexen2flags);
|
|
if (evenmorebits & U_ABSLIGHT)
|
|
MSG_WriteByte (msg, to->abslight);
|
|
|
|
if (evenmorebits & U_COLOURMOD)
|
|
{
|
|
MSG_WriteByte (msg, to->colormod[0]);
|
|
MSG_WriteByte (msg, to->colormod[1]);
|
|
MSG_WriteByte (msg, to->colormod[2]);
|
|
}
|
|
|
|
if (evenmorebits & U_DPFLAGS)
|
|
MSG_WriteByte (msg, to->dpflags);
|
|
|
|
if (evenmorebits & U_TAGINFO)
|
|
{
|
|
MSG_WriteEntity (msg, to->tagentity);
|
|
MSG_WriteShort (msg, to->tagindex);
|
|
}
|
|
|
|
if (evenmorebits & U_LIGHT)
|
|
{
|
|
MSG_WriteShort (msg, to->light[0]);
|
|
MSG_WriteShort (msg, to->light[1]);
|
|
MSG_WriteShort (msg, to->light[2]);
|
|
MSG_WriteShort (msg, to->light[3]);
|
|
MSG_WriteByte (msg, to->lightstyle);
|
|
MSG_WriteByte (msg, to->lightpflags);
|
|
}
|
|
|
|
if (evenmorebits & U_EFFECTS16)
|
|
MSG_WriteByte (msg, (to->effects&0xff00)>>8);
|
|
}
|
|
|
|
/*special flags which are slightly more compact. these are 'wasted' as part of the delta itself*/
|
|
#define UF_REMOVE UF_16BIT /*says we removed the entity in this frame*/
|
|
#define UF_MOVETYPE UF_EFFECTS2 /*this flag isn't present in the header itself*/
|
|
#define UF_RESET2 UF_EXTEND1 /*so new ents are reset 3 times to avoid weird baselines*/
|
|
//#define UF_UNUSED UF_EXTEND2 /**/
|
|
#define UF_WEAPONFRAME_OLD UF_EXTEND2
|
|
#define UF_VIEWANGLES UF_EXTEND3 /**/
|
|
|
|
static unsigned int SVFTE_DeltaPredCalcBits(entity_state_t *from, entity_state_t *to)
|
|
{
|
|
unsigned int bits = 0;
|
|
if (from && from->u.q1.pmovetype != to->u.q1.pmovetype)
|
|
bits |= UFP_MOVETYPE;
|
|
|
|
if (to->u.q1.movement[0])
|
|
bits |= UFP_FORWARD;
|
|
if (to->u.q1.movement[1])
|
|
bits |= UFP_SIDE;
|
|
if (to->u.q1.movement[2])
|
|
bits |= UFP_UP;
|
|
if (to->u.q1.velocity[0])
|
|
bits |= UFP_VELOCITYXY;
|
|
if (to->u.q1.velocity[1])
|
|
bits |= UFP_VELOCITYXY;
|
|
if (to->u.q1.velocity[2])
|
|
bits |= UFP_VELOCITYZ;
|
|
if (to->u.q1.msec)
|
|
bits |= UFP_MSEC;
|
|
|
|
return bits;
|
|
}
|
|
|
|
static unsigned int SVFTE_DeltaCalcBits(entity_state_t *from, qbyte *frombonedata, entity_state_t *to, qbyte *tobonedata)
|
|
{
|
|
unsigned int bits = 0;
|
|
|
|
if (from->u.q1.pmovetype != to->u.q1.pmovetype)
|
|
bits |= UF_PREDINFO|UF_MOVETYPE;
|
|
if (from->u.q1.weaponframe != to->u.q1.weaponframe)
|
|
bits |= UF_PREDINFO|UF_WEAPONFRAME_OLD;
|
|
if (to->u.q1.pmovetype)
|
|
{
|
|
if (SVFTE_DeltaPredCalcBits(from, to))
|
|
bits |= UF_PREDINFO;
|
|
|
|
/*moving players get extra data forced upon them which is not deltatracked*/
|
|
if ((bits & UF_PREDINFO) && (from->u.q1.velocity[0] || from->u.q1.velocity[1] || from->u.q1.velocity[2]))
|
|
{
|
|
/*if we've got player movement then write the origin anyway*/
|
|
bits |= UF_ORIGINXY | UF_ORIGINZ;
|
|
/*and force angles too, if its not us*/
|
|
if (host_client != svs.clients + to->number-1)
|
|
bits |= UF_ANGLESXZ | UF_ANGLESY;
|
|
}
|
|
}
|
|
|
|
if (to->origin[0] != from->origin[0])
|
|
bits |= UF_ORIGINXY;
|
|
if (to->origin[1] != from->origin[1])
|
|
bits |= UF_ORIGINXY;
|
|
if (to->origin[2] != from->origin[2])
|
|
bits |= UF_ORIGINZ;
|
|
|
|
if (to->angles[0] != from->angles[0])
|
|
bits |= UF_ANGLESXZ;
|
|
if (to->angles[1] != from->angles[1])
|
|
bits |= UF_ANGLESY;
|
|
if (to->angles[2] != from->angles[2])
|
|
bits |= UF_ANGLESXZ;
|
|
|
|
|
|
if (to->modelindex != from->modelindex)
|
|
bits |= UF_MODEL;
|
|
if (to->frame != from->frame)
|
|
bits |= UF_FRAME;
|
|
if (to->skinnum != from->skinnum)
|
|
bits |= UF_SKIN;
|
|
if (to->colormap != from->colormap)
|
|
bits |= UF_COLORMAP;
|
|
if (to->effects != from->effects)
|
|
bits |= UF_EFFECTS;
|
|
if (to->dpflags != from->dpflags)
|
|
bits |= UF_FLAGS;
|
|
if (to->solidsize != from->solidsize)
|
|
bits |= UF_SOLID;
|
|
|
|
if (to->scale != from->scale)
|
|
bits |= UF_SCALE;
|
|
if (to->trans != from->trans)
|
|
bits |= UF_ALPHA;
|
|
if (to->fatness != from->fatness)
|
|
bits |= UF_FATNESS;
|
|
|
|
if (to->hexen2flags != from->hexen2flags || to->abslight != from->abslight)
|
|
bits |= UF_DRAWFLAGS;
|
|
|
|
if (to->bonecount != from->bonecount || (to->bonecount && memcmp(frombonedata+from->boneoffset, tobonedata+to->boneoffset, to->bonecount*sizeof(short)*7)))
|
|
bits |= UF_BONEDATA;
|
|
if (!to->bonecount && (to->basebone != from->basebone || to->baseframe != from->baseframe))
|
|
bits |= UF_BONEDATA;
|
|
|
|
if (to->colormod[0]!=from->colormod[0]||to->colormod[1]!=from->colormod[1]||to->colormod[2]!=from->colormod[2])
|
|
bits |= UF_COLORMOD;
|
|
|
|
if (to->glowsize!=from->glowsize||to->glowcolour!=from->glowcolour||to->glowmod[0]!=from->glowmod[0]||to->glowmod[1]!=from->glowmod[1]||to->glowmod[2]!=from->glowmod[2])
|
|
bits |= UF_GLOW;
|
|
|
|
if (to->tagentity != from->tagentity || to->tagindex != from->tagindex)
|
|
bits |= UF_TAGINFO;
|
|
|
|
if (to->light[0] != from->light[0] || to->light[1] != from->light[1] || to->light[2] != from->light[2] || to->light[3] != from->light[3] || to->lightstyle != from->lightstyle || to->lightpflags != from->lightpflags)
|
|
bits |= UF_LIGHT;
|
|
|
|
if (to->u.q1.traileffectnum != from->u.q1.traileffectnum || to->u.q1.emiteffectnum != from->u.q1.emiteffectnum)
|
|
bits |= UF_TRAILEFFECT;
|
|
|
|
if (to->modelindex2 != from->modelindex2)
|
|
bits |= UF_MODELINDEX2;
|
|
|
|
if (to->u.q1.gravitydir[0] != from->u.q1.gravitydir[0] || to->u.q1.gravitydir[1] != from->u.q1.gravitydir[1])
|
|
bits |= UF_GRAVITYDIR;
|
|
|
|
return bits;
|
|
}
|
|
|
|
static void SVFTE_WriteUpdate(unsigned int bits, entity_state_t *state, sizebuf_t *msg, unsigned int pext2, qbyte *boneptr)
|
|
{
|
|
unsigned int predbits = 0;
|
|
if (bits & UF_MOVETYPE)
|
|
{
|
|
bits &= ~UF_MOVETYPE;
|
|
predbits |= UFP_MOVETYPE;
|
|
}
|
|
if (pext2 & PEXT2_PREDINFO)
|
|
{
|
|
if (bits & UF_VIEWANGLES)
|
|
{
|
|
bits &= ~UF_VIEWANGLES;
|
|
bits |= UF_PREDINFO;
|
|
predbits |= UFP_VIEWANGLE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bits & UF_VIEWANGLES)
|
|
{
|
|
bits &= ~UF_VIEWANGLES;
|
|
bits |= UF_PREDINFO;
|
|
}
|
|
if (bits & UF_WEAPONFRAME_OLD)
|
|
{
|
|
bits &= ~UF_WEAPONFRAME_OLD;
|
|
predbits |= UFP_WEAPONFRAME_OLD;
|
|
}
|
|
}
|
|
|
|
if (!(pext2 & PEXT2_NEWSIZEENCODING)) //was added at the same time
|
|
bits &= ~UF_BONEDATA;
|
|
|
|
/*check if we need more precision*/
|
|
if ((bits & UF_MODEL) && state->modelindex > 255)
|
|
bits |= UF_16BIT;
|
|
if ((bits & UF_SKIN) && state->skinnum > 255)
|
|
bits |= UF_16BIT;
|
|
if ((bits & UF_FRAME) && state->frame > 255)
|
|
bits |= UF_16BIT;
|
|
|
|
/*convert effects bits to higher lengths if needed*/
|
|
if (bits & UF_EFFECTS)
|
|
{
|
|
if (state->effects & 0xffff0000) /*both*/
|
|
bits |= UF_EFFECTS | UF_EFFECTS2;
|
|
else if (state->effects & 0x0000ff00) /*2 only*/
|
|
bits = (bits & ~UF_EFFECTS) | UF_EFFECTS2;
|
|
}
|
|
if (bits & 0xff000000)
|
|
bits |= UF_EXTEND3;
|
|
if (bits & 0x00ff0000)
|
|
bits |= UF_EXTEND2;
|
|
if (bits & 0x0000ff00)
|
|
bits |= UF_EXTEND1;
|
|
|
|
MSG_WriteByte(msg, (bits>>0) & 0xff);
|
|
if (bits & UF_EXTEND1)
|
|
MSG_WriteByte(msg, (bits>>8) & 0xff);
|
|
if (bits & UF_EXTEND2)
|
|
MSG_WriteByte(msg, (bits>>16) & 0xff);
|
|
if (bits & UF_EXTEND3)
|
|
MSG_WriteByte(msg, (bits>>24) & 0xff);
|
|
|
|
if (bits & UF_FRAME)
|
|
{
|
|
if (bits & UF_16BIT)
|
|
MSG_WriteShort(msg, state->frame);
|
|
else
|
|
MSG_WriteByte(msg, state->frame);
|
|
}
|
|
if (bits & UF_ORIGINXY)
|
|
{
|
|
MSG_WriteCoord(msg, state->origin[0]);
|
|
MSG_WriteCoord(msg, state->origin[1]);
|
|
}
|
|
if (bits & UF_ORIGINZ)
|
|
MSG_WriteCoord(msg, state->origin[2]);
|
|
|
|
if ((bits & UF_PREDINFO) && !(pext2 & PEXT2_PREDINFO))
|
|
{ /*if we have pred info, use more precise angles*/
|
|
if (bits & UF_ANGLESXZ)
|
|
{
|
|
MSG_WriteAngle16(msg, state->angles[0]);
|
|
MSG_WriteAngle16(msg, state->angles[2]);
|
|
}
|
|
if (bits & UF_ANGLESY)
|
|
MSG_WriteAngle16(msg, state->angles[1]);
|
|
}
|
|
else
|
|
{
|
|
if (bits & UF_ANGLESXZ)
|
|
{
|
|
MSG_WriteAngle(msg, state->angles[0]);
|
|
MSG_WriteAngle(msg, state->angles[2]);
|
|
}
|
|
if (bits & UF_ANGLESY)
|
|
MSG_WriteAngle(msg, state->angles[1]);
|
|
}
|
|
|
|
if ((bits & (UF_EFFECTS|UF_EFFECTS2)) == (UF_EFFECTS|UF_EFFECTS2))
|
|
MSG_WriteLong(msg, state->effects);
|
|
else if (bits & UF_EFFECTS2)
|
|
MSG_WriteShort(msg, state->effects);
|
|
else if (bits & UF_EFFECTS)
|
|
MSG_WriteByte(msg, state->effects);
|
|
|
|
if (bits & UF_PREDINFO)
|
|
{
|
|
/*movetype is set above somewhere*/
|
|
predbits |= SVFTE_DeltaPredCalcBits(NULL, state);
|
|
|
|
MSG_WriteByte(msg, predbits);
|
|
if (predbits & UFP_FORWARD)
|
|
MSG_WriteShort(msg, state->u.q1.movement[0]);
|
|
if (predbits & UFP_SIDE)
|
|
MSG_WriteShort(msg, state->u.q1.movement[1]);
|
|
if (predbits & UFP_UP)
|
|
MSG_WriteShort(msg, state->u.q1.movement[2]);
|
|
if (predbits & UFP_MOVETYPE)
|
|
MSG_WriteByte(msg, state->u.q1.pmovetype);
|
|
if (predbits & UFP_VELOCITYXY)
|
|
{
|
|
MSG_WriteShort(msg, state->u.q1.velocity[0]);
|
|
MSG_WriteShort(msg, state->u.q1.velocity[1]);
|
|
}
|
|
if (predbits & UFP_VELOCITYZ)
|
|
MSG_WriteShort(msg, state->u.q1.velocity[2]);
|
|
if (predbits & UFP_MSEC)
|
|
MSG_WriteByte(msg, state->u.q1.msec);
|
|
if (pext2 & PEXT2_PREDINFO)
|
|
{
|
|
if (predbits & UFP_VIEWANGLE)
|
|
{ /*if we have pred info, use more precise angles*/
|
|
if (bits & UF_ANGLESXZ)
|
|
{
|
|
MSG_WriteShort(msg, state->u.q1.vangle[0]);
|
|
MSG_WriteShort(msg, state->u.q1.vangle[2]);
|
|
}
|
|
if (bits & UF_ANGLESY)
|
|
MSG_WriteShort(msg, state->u.q1.vangle[1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (predbits & UFP_WEAPONFRAME_OLD)
|
|
{
|
|
if (state->u.q1.weaponframe > 127)
|
|
{
|
|
MSG_WriteByte(msg, 128 | (state->u.q1.weaponframe & 127));
|
|
MSG_WriteByte(msg, state->u.q1.weaponframe>>7);
|
|
}
|
|
else
|
|
MSG_WriteByte(msg, state->u.q1.weaponframe);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bits & UF_MODEL)
|
|
{
|
|
if (bits & UF_16BIT)
|
|
MSG_WriteShort(msg, state->modelindex);
|
|
else
|
|
MSG_WriteByte(msg, state->modelindex);
|
|
}
|
|
if (bits & UF_SKIN)
|
|
{
|
|
if (bits & UF_16BIT)
|
|
MSG_WriteShort(msg, state->skinnum);
|
|
else
|
|
MSG_WriteByte(msg, state->skinnum);
|
|
}
|
|
if (bits & UF_COLORMAP)
|
|
MSG_WriteByte(msg, state->colormap & 0xff);
|
|
|
|
if (bits & UF_SOLID)
|
|
{
|
|
if (pext2 & PEXT2_NEWSIZEENCODING)
|
|
{
|
|
if (!state->solidsize)
|
|
MSG_WriteByte(msg, 0);
|
|
else if (state->solidsize == ES_SOLID_BSP)
|
|
MSG_WriteByte(msg, 1);
|
|
else if (state->solidsize == ES_SOLID_HULL1)
|
|
MSG_WriteByte(msg, 2);
|
|
else if (state->solidsize == ES_SOLID_HULL2)
|
|
MSG_WriteByte(msg, 3);
|
|
else if (!ES_SOLID_HAS_EXTRA_BITS(state->solidsize))
|
|
{
|
|
MSG_WriteByte(msg, 16);
|
|
MSG_WriteSize16(msg, state->solidsize);
|
|
}
|
|
else
|
|
{
|
|
MSG_WriteByte(msg, 32);
|
|
MSG_WriteLong(msg, state->solidsize);
|
|
}
|
|
}
|
|
else
|
|
MSG_WriteSize16(msg, state->solidsize);
|
|
}
|
|
|
|
if (bits & UF_FLAGS)
|
|
MSG_WriteByte(msg, state->dpflags);
|
|
|
|
if (bits & UF_ALPHA)
|
|
MSG_WriteByte(msg, state->trans);
|
|
if (bits & UF_SCALE)
|
|
MSG_WriteByte(msg, state->scale);
|
|
if (bits & UF_BONEDATA)
|
|
{
|
|
short *bonedata;
|
|
int i;
|
|
qbyte bfl = 0;
|
|
if (state->bonecount && boneptr)
|
|
bfl |= 0x80;
|
|
if (state->basebone || state->baseframe)
|
|
bfl |= 0x40;
|
|
MSG_WriteByte(msg, bfl);
|
|
if (bfl & 0x80)
|
|
{
|
|
//this is NOT finalized
|
|
MSG_WriteByte(msg, state->bonecount);
|
|
bonedata = (short*)(boneptr + state->boneoffset);
|
|
for (i = 0; i < state->bonecount*7; i++)
|
|
MSG_WriteShort(msg, bonedata[i]);
|
|
}
|
|
if (bfl & 0x40)
|
|
{
|
|
MSG_WriteByte(msg, state->basebone);
|
|
MSG_WriteShort(msg, state->baseframe);
|
|
}
|
|
}
|
|
if (bits & UF_DRAWFLAGS)
|
|
{
|
|
MSG_WriteByte(msg, state->hexen2flags);
|
|
if ((state->hexen2flags & MLS_MASK) == MLS_ABSLIGHT)
|
|
MSG_WriteByte(msg, state->abslight);
|
|
}
|
|
if (bits & UF_TAGINFO)
|
|
{
|
|
MSG_WriteEntity(msg, state->tagentity);
|
|
MSG_WriteByte(msg, state->tagindex&0xff);
|
|
}
|
|
if (bits & UF_LIGHT)
|
|
{
|
|
MSG_WriteShort (msg, state->light[0]);
|
|
MSG_WriteShort (msg, state->light[1]);
|
|
MSG_WriteShort (msg, state->light[2]);
|
|
MSG_WriteShort (msg, state->light[3]);
|
|
MSG_WriteByte (msg, state->lightstyle);
|
|
MSG_WriteByte (msg, state->lightpflags);
|
|
}
|
|
if (bits & UF_TRAILEFFECT)
|
|
{
|
|
if (state->u.q1.emiteffectnum)
|
|
{
|
|
MSG_WriteShort(msg, (state->u.q1.traileffectnum & 0x3fff) | 0x8000);
|
|
MSG_WriteShort(msg, (state->u.q1.emiteffectnum & 0x3fff));
|
|
}
|
|
else
|
|
MSG_WriteShort(msg, (state->u.q1.traileffectnum & 0x3fff));
|
|
}
|
|
|
|
if (bits & UF_COLORMOD)
|
|
{
|
|
MSG_WriteByte(msg, state->colormod[0]);
|
|
MSG_WriteByte(msg, state->colormod[1]);
|
|
MSG_WriteByte(msg, state->colormod[2]);
|
|
}
|
|
if (bits & UF_GLOW)
|
|
{
|
|
MSG_WriteByte(msg, state->glowsize);
|
|
MSG_WriteByte(msg, state->glowcolour);
|
|
MSG_WriteByte(msg, state->glowmod[0]);
|
|
MSG_WriteByte(msg, state->glowmod[1]);
|
|
MSG_WriteByte(msg, state->glowmod[2]);
|
|
}
|
|
if (bits & UF_FATNESS)
|
|
MSG_WriteByte(msg, state->fatness);
|
|
if (bits & UF_MODELINDEX2)
|
|
{
|
|
if (bits & UF_16BIT)
|
|
MSG_WriteShort(msg, state->modelindex2);
|
|
else
|
|
MSG_WriteByte(msg, state->modelindex2);
|
|
}
|
|
|
|
if (bits & UF_GRAVITYDIR)
|
|
{
|
|
MSG_WriteByte(msg, state->u.q1.gravitydir[0]);
|
|
MSG_WriteByte(msg, state->u.q1.gravitydir[1]);
|
|
}
|
|
}
|
|
|
|
/*dump out the delta from baseline (used for baselines and statics, so has no svc)*/
|
|
void SVFTE_EmitBaseline(entity_state_t *to, qboolean numberisimportant, sizebuf_t *msg, unsigned int pext2)
|
|
{
|
|
unsigned int bits;
|
|
if (numberisimportant)
|
|
MSG_WriteEntity(msg, to->number);
|
|
bits = UF_RESET | SVFTE_DeltaCalcBits(&nullentitystate, NULL, to, NULL);
|
|
SVFTE_WriteUpdate(bits, to, msg, pext2, NULL);
|
|
}
|
|
|
|
/*SVFTE_EmitPacketEntities
|
|
Writes changed entities to the client.
|
|
Changed ent states will be tracked, even if they're not sent just yet, dropped packets will also re-flag dropped delta bits
|
|
Only what changed is tracked, via bitmask, its previous value is never tracked.
|
|
*/
|
|
qboolean SVFTE_EmitPacketEntities(client_t *client, packet_entities_t *to, sizebuf_t *msg)
|
|
{
|
|
edict_t *e;
|
|
entity_state_t *o, *n;
|
|
unsigned int i;
|
|
unsigned int j;
|
|
unsigned int bits;
|
|
struct resendinfo_s *resend;
|
|
unsigned int outno, outmax;
|
|
int sequence;
|
|
qbyte *oldbonedata;
|
|
unsigned int maxbonedatasize;
|
|
qboolean overflow = false;
|
|
client_t *cl;
|
|
float age;
|
|
client_frame_t *frame;
|
|
|
|
if (!client->pendingdeltabits)
|
|
return false;
|
|
|
|
if (client->delta_sequence < 0)
|
|
client->pendingdeltabits[0] = UF_REMOVE;
|
|
|
|
//if we're clearing the list and starting from scratch, just wipe all lingering state
|
|
if (client->pendingdeltabits[0] & UF_REMOVE)
|
|
{
|
|
for (j = 0; j < client->sentents.num_entities; j++)
|
|
{
|
|
client->sentents.entities[j].number = 0;
|
|
client->pendingdeltabits[j] = 0;
|
|
}
|
|
client->pendingdeltabits[0] = UF_REMOVE;
|
|
}
|
|
|
|
//expand client's entstate list
|
|
if (to->num_entities)
|
|
{
|
|
j = to->entities[to->num_entities-1].number+1;
|
|
if (j > client->sentents.max_entities)
|
|
{
|
|
client->sentents.entities = BZ_Realloc(client->sentents.entities, sizeof(*client->sentents.entities) * j);
|
|
memset(&client->sentents.entities[client->sentents.max_entities], 0, sizeof(client->sentents.entities[0]) * (j - client->sentents.max_entities));
|
|
client->sentents.max_entities = j;
|
|
}
|
|
while(j > client->sentents.num_entities)
|
|
{
|
|
client->sentents.entities[client->sentents.num_entities].number = 0;
|
|
client->sentents.num_entities++;
|
|
}
|
|
}
|
|
|
|
//orphan and regenerate
|
|
oldbonedata = client->sentents.bonedata;
|
|
maxbonedatasize = client->sentents.bonedatamax;
|
|
if (client->sentents.bonedatacur)
|
|
{
|
|
client->sentents.bonedata = BZ_Malloc(maxbonedatasize);
|
|
client->sentents.bonedatacur = 0;
|
|
client->sentents.bonedatamax = maxbonedatasize;
|
|
}
|
|
else
|
|
{
|
|
client->sentents.bonedata = NULL;
|
|
client->sentents.bonedatacur = 0;
|
|
client->sentents.bonedatamax = 0;
|
|
}
|
|
|
|
/*figure out the entitys+bits that changed (removed and active)*/
|
|
for (i = 0, j = 0; i < to->num_entities; i++)
|
|
{
|
|
n = &to->entities[i];
|
|
/*gaps are dead entities*/
|
|
for (; j < n->number; j++)
|
|
{
|
|
o = &client->sentents.entities[j];
|
|
if (o->number)
|
|
{
|
|
e = EDICT_NUM_PB(svprogfuncs, o->number);
|
|
if (!((int)e->xv->pvsflags & PVSF_NOREMOVE))
|
|
{
|
|
client->pendingdeltabits[j] = UF_REMOVE;
|
|
o->number = 0; /*dead*/
|
|
o->bonecount = 0; /*don't waste cycles*/
|
|
}
|
|
else if (o->bonecount)
|
|
{
|
|
short *srcbdata = (short*)(oldbonedata + o->boneoffset);
|
|
short *bonedata = AllocateBoneSpace(&client->sentents, o->bonecount, &o->boneoffset);
|
|
memcpy(bonedata, srcbdata, sizeof(short)*7*o->bonecount);
|
|
}
|
|
}
|
|
}
|
|
|
|
o = &client->sentents.entities[j];
|
|
if (!o->number)
|
|
{
|
|
/*flag it for reset, we can add the extra bits later once we get around to sending it*/
|
|
client->pendingdeltabits[j] = UF_RESET | UF_RESET2;
|
|
}
|
|
else
|
|
{
|
|
//its valid, make sure we don't have a stale/resent remove, and do a cheap reset due to uncertainty.
|
|
if (client->pendingdeltabits[j] & UF_REMOVE)
|
|
client->pendingdeltabits[j] = (client->pendingdeltabits[j] & ~UF_REMOVE) | UF_RESET2;
|
|
client->pendingdeltabits[j] |= SVFTE_DeltaCalcBits(o, oldbonedata, n, to->bonedata);
|
|
//even if prediction is disabled, we want to force velocity info to be sent for the local player. This is used by view bob and things.
|
|
if (client->edict && j == client->edict->entnum && (n->u.q1.velocity[0] || n->u.q1.velocity[1] || n->u.q1.velocity[2]))
|
|
client->pendingdeltabits[j] |= UF_PREDINFO;
|
|
|
|
//spectators(and mvds) should be told the actual view angles of the person they're trying to track
|
|
if (j <= sv.allocated_client_slots && (!client->edict || j == client->spec_track))
|
|
// if (client->pendingentbits[j])
|
|
{
|
|
if (o->u.q1.vangle[0] != n->u.q1.vangle[0] || o->u.q1.vangle[2] != n->u.q1.vangle[2])
|
|
client->pendingdeltabits[j] |= UF_ANGLESXZ;
|
|
if (o->u.q1.vangle[1] != n->u.q1.vangle[1])
|
|
client->pendingdeltabits[j] |= UF_ANGLESY;
|
|
client->pendingdeltabits[j] |= UF_VIEWANGLES;
|
|
}
|
|
}
|
|
*o = *n;
|
|
if (o->bonecount)
|
|
{
|
|
short *bonedata = AllocateBoneSpace(&client->sentents, o->bonecount, &o->boneoffset);
|
|
short *srcbdata = (short*)(to->bonedata + n->boneoffset);
|
|
memcpy(bonedata, srcbdata, sizeof(short)*7*o->bonecount);
|
|
}
|
|
j++;
|
|
}
|
|
|
|
/*gaps are dead entities*/
|
|
for (; j < client->sentents.num_entities; j++)
|
|
{
|
|
o = &client->sentents.entities[j];
|
|
if (o->number)
|
|
{
|
|
e = EDICT_NUM_PB(svprogfuncs, o->number);
|
|
if (!((int)e->xv->pvsflags & PVSF_NOREMOVE))
|
|
{
|
|
client->pendingdeltabits[j] = UF_REMOVE;
|
|
o->number = 0; /*dead*/
|
|
o->bonecount = 0; /*don't waste cycles*/
|
|
}
|
|
else if (o->bonecount)
|
|
{
|
|
short *srcbdata = (short*)(oldbonedata + o->boneoffset);
|
|
short *bonedata = AllocateBoneSpace(&client->sentents, o->bonecount, &o->boneoffset);
|
|
memcpy(bonedata, srcbdata, sizeof(short)*7*o->bonecount);
|
|
}
|
|
}
|
|
}
|
|
|
|
Z_Free(oldbonedata);
|
|
|
|
|
|
|
|
if (ISNQCLIENT(client))
|
|
sequence = client->netchan.outgoing_unreliable;
|
|
else
|
|
sequence = client->netchan.incoming_sequence;
|
|
frame = &client->frameunion.frames[sequence & UPDATE_MASK];
|
|
|
|
/*cache frame info*/
|
|
resend = frame->resend;
|
|
outno = 0;
|
|
outmax = frame->maxresend;
|
|
|
|
if (msg->cursize + 52 <= msg->maxsize)
|
|
{
|
|
/*start writing the packet*/
|
|
MSG_WriteByte (msg, svcfte_updateentities);
|
|
if (ISNQCLIENT(client) && (client->fteprotocolextensions2 & PEXT2_PREDINFO))
|
|
{
|
|
MSG_WriteShort(msg, client->last_sequence&0xffff);
|
|
}
|
|
// Con_Printf("Gen sequence %i\n", sequence);
|
|
MSG_WriteFloat(msg, sv.world.physicstime);
|
|
|
|
if (client->pendingdeltabits[0] & UF_REMOVE)
|
|
{
|
|
SV_EmitDeltaEntIndex(msg, 0, true, true);
|
|
resend[outno].bits = UF_REMOVE;
|
|
resend[outno].flags = 0;
|
|
resend[outno++].entnum = 0;
|
|
|
|
client->pendingdeltabits[0] &= ~UF_REMOVE;
|
|
}
|
|
for(j = 1; j < client->sentents.num_entities; j++)
|
|
{
|
|
bits = client->pendingdeltabits[j];
|
|
if (!(bits & ~UF_RESET2)) //skip while there's nothing to send (skip reset2 if there's no other changes, its only to reduce chances of the client getting 'new' entities containing just an origin)*/
|
|
continue;
|
|
if (msg->cursize + 52 > msg->maxsize)
|
|
{
|
|
overflow = true;
|
|
break; /*give up if it gets full. FIXME: bone data is HUGE.*/
|
|
}
|
|
if (outno >= outmax)
|
|
{ //expand the frames. may need some copying...
|
|
if (outmax == client->max_net_ents)
|
|
break;
|
|
SV_ExpandNackFrames(client, outno+1, &frame);
|
|
resend = frame->resend;
|
|
outmax = frame->maxresend;
|
|
}
|
|
|
|
if (bits & UF_REMOVE)
|
|
{ //if reset is set, then reset was set eroneously.
|
|
SV_EmitDeltaEntIndex(msg, j, true, true);
|
|
resend[outno].bits = UF_REMOVE;
|
|
// Con_Printf("REMOVE %i @ %i\n", j, sequence);
|
|
}
|
|
else if (client->sentents.entities[j].number) /*only send a new copy of the ent if they actually have one already*/
|
|
{
|
|
//if we didn't reach the end in the last packet, start at that point to avoid spam
|
|
//player slots are exempt from this, so they are in every packet (strictly speaking only the local player 'needs' this, but its nice to have it for high-priority targets too)
|
|
if (j < client->nextdeltaindex && j > svs.allocated_client_slots)
|
|
continue;
|
|
|
|
if (bits & UF_RESET2)
|
|
{
|
|
/*if reset2, then this is the second packet sent to the client and should have a forced reset (but which isn't tracked)*/
|
|
resend[outno].bits = bits & ~UF_RESET2;
|
|
bits = UF_RESET | SVFTE_DeltaCalcBits(&EDICT_NUM_PB(svprogfuncs, j)->baseline, NULL, &client->sentents.entities[j], client->sentents.bonedata);
|
|
// Con_Printf("RESET2 %i @ %i\n", j, sequence);
|
|
}
|
|
else if (bits & UF_RESET)
|
|
{
|
|
/*flag the entity for the next packet, so we always get two resets when it appears, to reduce the effects of packetloss on seeing rockets etc*/
|
|
client->pendingdeltabits[j] = UF_RESET2;
|
|
bits = UF_RESET | SVFTE_DeltaCalcBits(&EDICT_NUM_PB(svprogfuncs, j)->baseline, NULL, &client->sentents.entities[j], client->sentents.bonedata);
|
|
resend[outno].bits = UF_RESET;
|
|
// Con_Printf("RESET %i @ %i\n", j, sequence);
|
|
}
|
|
else
|
|
resend[outno].bits = bits;
|
|
|
|
SV_EmitDeltaEntIndex(msg, j, false, true);
|
|
SVFTE_WriteUpdate(bits, &client->sentents.entities[j], msg, client->fteprotocolextensions2, client->sentents.bonedata);
|
|
}
|
|
|
|
client->pendingdeltabits[j] = 0;
|
|
|
|
resend[outno].flags = 0;
|
|
resend[outno++].entnum = j;
|
|
}
|
|
MSG_WriteShort(msg, 0);
|
|
}
|
|
|
|
if (j == client->sentents.num_entities) //looks like we sent them all
|
|
client->nextdeltaindex = 0; //start afresh with the next packet.
|
|
else
|
|
client->nextdeltaindex = j; //we overflowed or something, start going round-robin
|
|
|
|
frame->numresend = outno;
|
|
frame->sequence = sequence;
|
|
|
|
frame->laggedtime = sv.time;
|
|
for (i = 0; i < to->num_entities; i++)
|
|
{
|
|
n = &to->entities[i];
|
|
j = n->number-1;
|
|
if (j >= sv.allocated_client_slots)
|
|
break; //don't track non-player slots.
|
|
|
|
cl = &svs.clients[j];
|
|
|
|
//states of other players are actually old.
|
|
//by the time we receive the other player's move, this stuff will be outdated and we don't know when that will actually be.
|
|
//so (cheaply) guess where they're really meant to be if they're running at a lower framerate.
|
|
if (!cl->name[0] || cl->protocol == SCP_BAD) //is bot
|
|
age = 0;//= sv.time - sv.world.physicstime; //FIXME
|
|
else
|
|
age = sv.time - sv.world.physicstime;
|
|
age = bound(0, age, 0.1);
|
|
|
|
VectorMA(n->origin, (sv.time - cl->localtime)/8.0, n->u.q1.velocity, frame->laggedplayer[j].origin);
|
|
VectorCopy(n->angles, frame->laggedplayer[j].angles);
|
|
//FIXME: add framestate_t info.
|
|
frame->laggedplayer[j].present = true;
|
|
}
|
|
|
|
return overflow;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
SVQW_EmitPacketEntities
|
|
|
|
Writes a delta update of a packet_entities_t to the message.
|
|
|
|
deltaing is performed from one set of entity states directly to the next
|
|
=============
|
|
*/
|
|
void SVQW_EmitPacketEntities (client_t *client, packet_entities_t *to, sizebuf_t *msg)
|
|
{
|
|
edict_t *ent;
|
|
client_frame_t *fromframe;
|
|
packet_entities_t *from;
|
|
int oldindex, newindex;
|
|
int oldnum, newnum;
|
|
int oldmax;
|
|
|
|
// this is the frame that we are going to delta update from
|
|
if (client->delta_sequence != -1)
|
|
{
|
|
fromframe = &client->frameunion.frames[client->delta_sequence & UPDATE_MASK];
|
|
from = &fromframe->qwentities;
|
|
oldmax = from->num_entities;
|
|
|
|
MSG_WriteByte (msg, svc_deltapacketentities);
|
|
MSG_WriteByte (msg, client->delta_sequence);
|
|
}
|
|
else
|
|
{
|
|
oldmax = 0; // no delta update
|
|
from = NULL;
|
|
|
|
MSG_WriteByte (msg, svc_packetentities);
|
|
}
|
|
|
|
newindex = 0;
|
|
oldindex = 0;
|
|
//Con_Printf ("---%i to %i ----\n", client->delta_sequence & UPDATE_MASK
|
|
// , client->netchan.outgoing_sequence & UPDATE_MASK);
|
|
while (newindex < to->num_entities || oldindex < oldmax)
|
|
{
|
|
newnum = newindex >= to->num_entities ? 9999 : to->entities[newindex].number;
|
|
oldnum = oldindex >= oldmax ? 9999 : from->entities[oldindex].number;
|
|
|
|
if (newnum == oldnum)
|
|
{ // delta update from old position
|
|
//Con_Printf ("delta %i\n", newnum);
|
|
#ifdef PROTOCOLEXTENSIONS
|
|
SVQW_WriteDelta (&from->entities[oldindex], &to->entities[newindex], msg, false, client->fteprotocolextensions);
|
|
#else
|
|
SVQW_WriteDelta (&from->entities[oldindex], &to->entities[newindex], msg, false);
|
|
#endif
|
|
oldindex++;
|
|
newindex++;
|
|
continue;
|
|
}
|
|
|
|
if (newnum < oldnum)
|
|
{ // this is a new entity, send it from the baseline
|
|
if (svprogfuncs)
|
|
ent = EDICT_NUM_UB(svprogfuncs, newnum);
|
|
else
|
|
ent = NULL;
|
|
//Con_Printf ("baseline %i\n", newnum);
|
|
#ifdef PROTOCOLEXTENSIONS
|
|
SVQW_WriteDelta (&ent->baseline, &to->entities[newindex], msg, true, client->fteprotocolextensions);
|
|
#else
|
|
SVQW_WriteDelta (&ent->baseline, &to->entities[newindex], msg, true);
|
|
#endif
|
|
newindex++;
|
|
continue;
|
|
}
|
|
|
|
if (newnum > oldnum)
|
|
{ // the old entity isn't present in the new message
|
|
//Con_Printf ("remove %i\n", oldnum);
|
|
if (oldnum >= 512)
|
|
{
|
|
//yup, this is expensive.
|
|
MSG_WriteShort (msg, (oldnum&511) | U_REMOVE|U_MOREBITS);
|
|
MSG_WriteByte (msg, U_EVENMORE);
|
|
if (oldnum >= 1024)
|
|
{
|
|
if (oldnum >= 1024+512)
|
|
MSG_WriteByte (msg, U_ENTITYDBL|U_ENTITYDBL2);
|
|
else
|
|
MSG_WriteByte (msg, U_ENTITYDBL2);
|
|
}
|
|
else
|
|
MSG_WriteByte (msg, U_ENTITYDBL);
|
|
}
|
|
else
|
|
MSG_WriteShort (msg, (oldnum&511) | U_REMOVE);
|
|
|
|
oldindex++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (newindex > to->max_entities)
|
|
Con_Printf("Exceeded max entities\n");
|
|
|
|
MSG_WriteShort (msg, 0); // end of packetentities
|
|
}
|
|
#ifdef NQPROT
|
|
unsigned int SVDP_CalcDelta(entity_state_t *from, qbyte *frombonedatabase, entity_state_t *to, qbyte *tobonedatabase)
|
|
{
|
|
unsigned int bits = 0;
|
|
//E5_FULLUPDATE is handled elsewhere
|
|
//E5_EXTEND* is handled elsewhere
|
|
if (!VectorEquals(from->origin, to->origin))
|
|
bits |= E5_ORIGIN;
|
|
if (!VectorEquals(from->angles, to->angles))
|
|
bits |= E5_ANGLES;
|
|
if (from->modelindex != to->modelindex)
|
|
bits |= E5_MODEL;
|
|
if (from->frame != to->frame)
|
|
bits |= E5_FRAME;
|
|
if (from->skinnum != to->skinnum)
|
|
bits |= E5_SKIN;
|
|
if (from->effects != to->effects)
|
|
bits |= E5_EFFECTS;
|
|
if (from->dpflags != to->dpflags)
|
|
bits |= E5_FLAGS;
|
|
if (from->trans != to->trans)
|
|
bits |= E5_ALPHA;
|
|
if (from->scale != to->scale)
|
|
bits |= E5_SCALE;
|
|
if (from->colormap != to->colormap)
|
|
bits |= E5_COLORMAP;
|
|
if (from->tagentity != to->tagentity || from->tagindex != to->tagindex)
|
|
bits |= E5_ATTACHMENT;
|
|
if (from->light[0] != to->light[0] || from->light[1] != to->light[1] || from->light[2] != to->light[2] || from->light[3] != to->light[3] || from->lightstyle != to->lightstyle || from->lightpflags != to->lightpflags)
|
|
bits |= E5_LIGHT;
|
|
if (from->glowsize != to->glowsize || from->glowcolour != to->glowcolour)
|
|
bits |= E5_GLOW;
|
|
if (from->colormod[0] != to->colormod[0] || from->colormod[1] != to->colormod[1] || from->colormod[2] != to->colormod[2])
|
|
bits |= E5_COLORMOD;
|
|
if (from->glowmod[0] != to->glowmod[0] || from->glowmod[1] != to->glowmod[1] || from->glowmod[2] != to->glowmod[2])
|
|
bits |= E5_GLOWMOD;
|
|
if (to->bonecount != from->bonecount || (to->bonecount && (!frombonedatabase || memcmp(frombonedatabase+from->boneoffset, tobonedatabase+to->boneoffset, to->bonecount*sizeof(short)*7))))
|
|
if (to->bonecount)
|
|
bits |= E5_COMPLEXANIMATION;
|
|
if (to->u.q1.traileffectnum != from->u.q1.traileffectnum)
|
|
bits |= E5_TRAILEFFECTNUM;
|
|
|
|
if ((bits & E5_ORIGIN) && (!(to->dpflags & RENDER_LOWPRECISION) || to->origin[0] < -4096 || to->origin[0] >= 4096 || to->origin[1] < -4096 || to->origin[1] >= 4096 || to->origin[2] < -4096 || to->origin[2] >= 4096))
|
|
bits |= E5_ORIGIN32;
|
|
if ((bits & E5_ANGLES) && !(to->dpflags & RENDER_LOWPRECISION))
|
|
bits |= E5_ANGLES16;
|
|
if ((bits & E5_MODEL) && to->modelindex >= 256)
|
|
bits |= E5_MODEL16;
|
|
if ((bits & E5_FRAME) && to->frame >= 256)
|
|
bits |= E5_FRAME16;
|
|
if (bits & E5_EFFECTS)
|
|
{
|
|
if (to->effects >= 65536)
|
|
bits |= E5_EFFECTS32;
|
|
else if (to->effects >= 256)
|
|
bits |= E5_EFFECTS16;
|
|
}
|
|
|
|
return bits;
|
|
}
|
|
|
|
void SVDP_EmitEntityDelta(unsigned int bits, entity_state_t *to, sizebuf_t *msg, qbyte *bonedatabase)
|
|
{
|
|
bits &= ~E5_SERVERPRIVATE;
|
|
|
|
if (!bits)
|
|
return;
|
|
|
|
if (bits >= 256)
|
|
bits |= E5_EXTEND1;
|
|
if (bits >= 65536)
|
|
bits |= E5_EXTEND2;
|
|
if (bits >= 16777216)
|
|
bits |= E5_EXTEND3;
|
|
|
|
MSG_WriteShort(msg, to->number);
|
|
MSG_WriteByte(msg, bits & 0xFF);
|
|
if (bits & E5_EXTEND1)
|
|
MSG_WriteByte(msg, (bits >> 8) & 0xFF);
|
|
if (bits & E5_EXTEND2)
|
|
MSG_WriteByte(msg, (bits >> 16) & 0xFF);
|
|
if (bits & E5_EXTEND3)
|
|
MSG_WriteByte(msg, (bits >> 24) & 0xFF);
|
|
if (bits & E5_FLAGS)
|
|
MSG_WriteByte(msg, to->dpflags);
|
|
if (bits & E5_ORIGIN)
|
|
{
|
|
if (bits & E5_ORIGIN32)
|
|
{
|
|
MSG_WriteFloat(msg, to->origin[0]);
|
|
MSG_WriteFloat(msg, to->origin[1]);
|
|
MSG_WriteFloat(msg, to->origin[2]);
|
|
}
|
|
else
|
|
{
|
|
MSG_WriteShort(msg, to->origin[0]*8);
|
|
MSG_WriteShort(msg, to->origin[1]*8);
|
|
MSG_WriteShort(msg, to->origin[2]*8);
|
|
}
|
|
}
|
|
if (bits & E5_ANGLES)
|
|
{
|
|
if (bits & E5_ANGLES16)
|
|
{
|
|
MSG_WriteAngle16(msg, to->angles[0]);
|
|
MSG_WriteAngle16(msg, to->angles[1]);
|
|
MSG_WriteAngle16(msg, to->angles[2]);
|
|
}
|
|
else
|
|
{
|
|
MSG_WriteAngle8(msg, to->angles[0]);
|
|
MSG_WriteAngle8(msg, to->angles[1]);
|
|
MSG_WriteAngle8(msg, to->angles[2]);
|
|
}
|
|
}
|
|
if (bits & E5_MODEL)
|
|
{
|
|
if (bits & E5_MODEL16)
|
|
MSG_WriteShort(msg, to->modelindex);
|
|
else
|
|
MSG_WriteByte(msg, to->modelindex);
|
|
}
|
|
if (bits & E5_FRAME)
|
|
{
|
|
if (bits & E5_FRAME16)
|
|
MSG_WriteShort(msg, to->frame);
|
|
else
|
|
MSG_WriteByte(msg, to->frame);
|
|
}
|
|
if (bits & E5_SKIN)
|
|
MSG_WriteByte(msg, to->skinnum);
|
|
if (bits & E5_EFFECTS)
|
|
{
|
|
if (bits & E5_EFFECTS32)
|
|
MSG_WriteLong(msg, to->effects);
|
|
else if (bits & E5_EFFECTS16)
|
|
MSG_WriteShort(msg, to->effects);
|
|
else
|
|
MSG_WriteByte(msg, to->effects);
|
|
}
|
|
if (bits & E5_ALPHA)
|
|
MSG_WriteByte(msg, to->trans);
|
|
if (bits & E5_SCALE)
|
|
MSG_WriteByte(msg, to->scale);
|
|
if (bits & E5_COLORMAP)
|
|
MSG_WriteByte(msg, to->colormap&0xff);
|
|
if (bits & E5_ATTACHMENT)
|
|
{
|
|
MSG_WriteEntity(msg, to->tagentity);
|
|
MSG_WriteByte(msg, to->tagindex);
|
|
}
|
|
if (bits & E5_LIGHT)
|
|
{
|
|
MSG_WriteShort(msg, to->light[0]);
|
|
MSG_WriteShort(msg, to->light[1]);
|
|
MSG_WriteShort(msg, to->light[2]);
|
|
MSG_WriteShort(msg, to->light[3]);
|
|
MSG_WriteByte(msg, to->lightstyle);
|
|
MSG_WriteByte(msg, to->lightpflags);
|
|
}
|
|
if (bits & E5_GLOW)
|
|
{
|
|
MSG_WriteByte(msg, to->glowsize);
|
|
MSG_WriteByte(msg, to->glowcolour);
|
|
}
|
|
if (bits & E5_COLORMOD)
|
|
{
|
|
MSG_WriteByte(msg, to->colormod[0]);
|
|
MSG_WriteByte(msg, to->colormod[1]);
|
|
MSG_WriteByte(msg, to->colormod[2]);
|
|
}
|
|
if (bits & E5_GLOWMOD)
|
|
{
|
|
MSG_WriteByte(msg, to->glowmod[0]);
|
|
MSG_WriteByte(msg, to->glowmod[1]);
|
|
MSG_WriteByte(msg, to->glowmod[2]);
|
|
}
|
|
if (bits & E5_COMPLEXANIMATION)
|
|
{
|
|
short *bonedata = (short*)(bonedatabase+to->boneoffset);
|
|
int i;
|
|
MSG_WriteByte(msg, 4);
|
|
MSG_WriteShort(msg, to->modelindex);
|
|
MSG_WriteByte(msg, to->bonecount);
|
|
for (i = 0; i < to->bonecount*7; i++)
|
|
MSG_WriteShort(msg, bonedata[i]);
|
|
}
|
|
if (bits & E5_TRAILEFFECTNUM)
|
|
MSG_WriteShort(msg, to->u.q1.traileffectnum);
|
|
}
|
|
|
|
void SVDP_EmitEntitiesUpdate (client_t *client, client_frame_t *frame, packet_entities_t *to, sizebuf_t *msg)
|
|
{
|
|
packet_entities_t *cur;
|
|
int newindex;
|
|
int curnum, newnum;
|
|
int j;
|
|
int sequence = client->netchan.incoming_sequence;
|
|
|
|
// this is the frame that we are going to delta update from
|
|
cur = &client->sentents;
|
|
if (!client->netchan.incoming_sequence)
|
|
{ //first packet deltas from nothing.
|
|
//so make sure we start with nothing
|
|
cur->num_entities = 0;
|
|
}
|
|
|
|
if (to->num_entities)
|
|
{
|
|
j = to->entities[to->num_entities-1].number+1;
|
|
if (j > cur->max_entities)
|
|
{
|
|
cur->entities = BZ_Realloc(cur->entities, sizeof(*cur->entities) * j);
|
|
memset(&cur->entities[cur->max_entities], 0, sizeof(cur->entities[0]) * (j - cur->max_entities));
|
|
cur->max_entities = j;
|
|
}
|
|
while(j > cur->num_entities)
|
|
{
|
|
cur->entities[cur->num_entities].number = 0;
|
|
cur->num_entities++;
|
|
}
|
|
}
|
|
|
|
//diff the from+to states, flagging any changed state (which is combined with any state from previous packet loss
|
|
newindex = 0;
|
|
curnum = 0;
|
|
while (newindex < to->num_entities || curnum < cur->num_entities)
|
|
{
|
|
newnum = newindex >= to->num_entities ? 0x8000 : to->entities[newindex].number;
|
|
|
|
if (newnum == curnum)
|
|
{
|
|
if (cur->entities[curnum].number)
|
|
{ //regular update
|
|
client->pendingdeltabits[newnum] |= SVDP_CalcDelta(&cur->entities[curnum], NULL/*cur->bonedata*/, &to->entities[newindex], to->bonedata);
|
|
if (client->pendingdeltabits[newnum] & E5_SERVERREMOVE)
|
|
{ //if it got flagged for removal, but its actually a valid entity, then assume that its an outdated remove and just flag it for a full update in case stuff got lost.
|
|
client->pendingdeltabits[newnum] &= ~E5_SERVERREMOVE;
|
|
client->pendingdeltabits[newnum] |= E5_FULLUPDATE;
|
|
}
|
|
}
|
|
else
|
|
{ //this ent is new
|
|
//dpp5+ does not use baselines. it just resets from default state.
|
|
client->pendingdeltabits[newnum] = E5_FULLUPDATE | SVDP_CalcDelta(&nullentitystate, NULL, &to->entities[newindex], to->bonedata);
|
|
}
|
|
cur->entities[curnum] = to->entities[newindex];
|
|
newindex++;
|
|
}
|
|
else if (cur->entities[curnum].number)
|
|
{ //this entity was apparently removed since last time.
|
|
cur->entities[curnum].number = 0;
|
|
client->pendingdeltabits[curnum] = E5_SERVERREMOVE;
|
|
}
|
|
curnum++;
|
|
}
|
|
|
|
to = cur;
|
|
|
|
//loop through all ents and send them as required
|
|
|
|
// Con_Printf ("frame %i\n", client->netchan.incoming_sequence);
|
|
|
|
{
|
|
unsigned int bits;
|
|
int outno, outmax = frame->maxresend;
|
|
struct resendinfo_s *resend = frame->resend;
|
|
|
|
MSG_WriteByte(msg, svcdp_entities);
|
|
MSG_WriteLong(msg, sequence); //sequence for the client to ack (any bits sent in unacked frames will be re-queued)
|
|
if (client->protocol == SCP_DARKPLACES7)
|
|
MSG_WriteLong(msg, client->last_sequence); //movement sequence that we are acking.
|
|
|
|
client->netchan.incoming_sequence++;
|
|
|
|
//add in the bitmasks of dropped packets.
|
|
for(outno = 0, j = 1; j < to->num_entities; j++)
|
|
{
|
|
bits = client->pendingdeltabits[j];
|
|
if (!bits)
|
|
continue;
|
|
if (msg->cursize + 50 > msg->maxsize)
|
|
break; /*give up if it gets full. FIXME: bone data is HUGE.*/
|
|
if (outno >= outmax)
|
|
{ //expand the frames. may need some copying...
|
|
if (outmax == client->max_net_ents)
|
|
break;
|
|
SV_ExpandNackFrames(client, outno+1, &frame);
|
|
resend = frame->resend;
|
|
outmax = frame->maxresend;
|
|
}
|
|
|
|
if (bits & E5_SERVERREMOVE)
|
|
{ //if reset is set, then reset was set eroneously.
|
|
MSG_WriteShort(msg, j | 0x8000);
|
|
resend[outno].bits = E5_SERVERREMOVE;
|
|
// Con_Printf("REMOVE %i @ %i\n", j, sequence);
|
|
}
|
|
else if (to->entities[j].number) /*only send a new copy of the ent if they actually have one already*/
|
|
{
|
|
//if we didn't reach the end in the last packet, start at that point to avoid spam
|
|
//player slots are exempt from this, so they are in every packet (strictly speaking only the local player 'needs' this, but its nice to have it for high-priority targets too)
|
|
if (j < client->nextdeltaindex && j > svs.allocated_client_slots)
|
|
continue;
|
|
|
|
if (bits & E5_FULLUPDATE)
|
|
{
|
|
/*flag the entity for the next packet, so we always get two resets when it appears, to reduce the effects of packetloss on seeing rockets etc*/
|
|
bits = E5_FULLUPDATE | SVDP_CalcDelta(&nullentitystate, NULL, &to->entities[j], to->bonedata);
|
|
resend[outno].bits = E5_FULLUPDATE;
|
|
// Con_Printf("RESET %i @ %i\n", j, sequence);
|
|
}
|
|
else
|
|
resend[outno].bits = bits;
|
|
|
|
SVDP_EmitEntityDelta (bits, &to->entities[j], msg, to->bonedata);
|
|
}
|
|
|
|
client->pendingdeltabits[j] = 0;
|
|
|
|
resend[outno].flags = 0;
|
|
resend[outno++].entnum = j;
|
|
}
|
|
MSG_WriteShort(msg, 0x8000); //dp5+ uses 'remove world' as a terminator.
|
|
frame->numresend = outno;
|
|
frame->sequence = sequence;
|
|
|
|
if (j == to->num_entities) //looks like we sent them all
|
|
client->nextdeltaindex = 0; //start afresh with the next packet.
|
|
else
|
|
client->nextdeltaindex = j; //we overflowed or something, start going round-robin
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
int SV_HullNumForPlayer(int h2hull, float *mins, float *maxs)
|
|
{
|
|
int diff;
|
|
int best;
|
|
int hullnum, i;
|
|
|
|
if (sv.world.worldmodel->fromgame != fg_quake)
|
|
{
|
|
return -mins[2] + 32; //clients are expected to decide themselves.
|
|
}
|
|
|
|
if (h2hull)
|
|
return (h2hull-1) | (mins[2]?0:128);
|
|
|
|
|
|
hullnum = 0;
|
|
best = 8192;
|
|
//x/y pos/neg are assumed to be the same magnitute.
|
|
//y pos/height are assumed to be different from all the others.
|
|
for (i = 0; i < MAX_MAP_HULLSM; i++)
|
|
{
|
|
#define sq(x) ((x)*(x))
|
|
diff = sq(sv.world.worldmodel->hulls[i].clip_maxs[2] - maxs[2]) +
|
|
sq(sv.world.worldmodel->hulls[i].clip_mins[2] - mins[2]) +
|
|
sq(sv.world.worldmodel->hulls[i].clip_maxs[0] - maxs[0]) +
|
|
sq(sv.world.worldmodel->hulls[i].clip_mins[0] - mins[0]);
|
|
if (diff < best)
|
|
{
|
|
best = diff;
|
|
hullnum=i;
|
|
}
|
|
}
|
|
return hullnum;
|
|
}
|
|
|
|
#if 1
|
|
typedef struct {
|
|
int playernum;
|
|
qboolean onladder;
|
|
usercmd_t *lastcmd;
|
|
int modelindex;
|
|
int frame;
|
|
int weaponframe;
|
|
int vw_index;
|
|
float *angles;
|
|
float *origin;
|
|
float *velocity;
|
|
int effects;
|
|
int skin;
|
|
float *mins;
|
|
float *maxs;
|
|
float scale;
|
|
float transparency;
|
|
float fatness;
|
|
float localtime;
|
|
int health;
|
|
int spectator; //0=send to a player. 1=non-tracked player, to a spec. 2=tracked player, to a spec(or self)
|
|
qboolean isself;
|
|
qboolean onground;
|
|
qboolean solid;
|
|
int fteext;
|
|
int zext;
|
|
int hull;
|
|
client_t *cl;
|
|
} clstate_t;
|
|
void SV_WritePlayerToClient(sizebuf_t *msg, clstate_t *ent)
|
|
{
|
|
usercmd_t cmd;
|
|
int msec;
|
|
int hullnumber;
|
|
int i;
|
|
int pflags;
|
|
int pm_type, pm_code;
|
|
int zext = ent->zext;
|
|
|
|
pflags = PF_MSEC | PF_COMMAND;
|
|
|
|
if (ent->modelindex != sv_playermodel)
|
|
pflags |= PF_MODEL;
|
|
|
|
if (ent->velocity)
|
|
for (i=0 ; i<3 ; i++)
|
|
if (ent->velocity[i])
|
|
pflags |= PF_VELOCITY1<<i;
|
|
if (ent->effects)
|
|
pflags |= PF_EFFECTS;
|
|
if (ent->skin || ent->modelindex>=256)
|
|
pflags |= PF_SKINNUM;
|
|
if (ent->health <= 0)
|
|
pflags |= PF_DEAD;
|
|
if (progstype == PROG_QW)
|
|
{
|
|
if (ent->mins[2] != -24)
|
|
pflags |= PF_GIB;
|
|
}
|
|
else if (progstype == PROG_H2)
|
|
{
|
|
// if (ent->maxs[2] != 56)
|
|
// pflags |= PF_GIB;
|
|
}
|
|
else
|
|
{
|
|
if (ent->mins[2] != -24)
|
|
pflags |= PF_GIB;
|
|
}
|
|
|
|
if (ent->isself)
|
|
{
|
|
if (ent->spectator)
|
|
pflags &= PF_VELOCITY1 | PF_VELOCITY2 | PF_VELOCITY3 | PF_DEAD | PF_GIB;
|
|
else
|
|
{ // don't send a lot of data on personal entity
|
|
pflags &= ~(PF_MSEC|PF_COMMAND);
|
|
if (ent->weaponframe)
|
|
pflags |= PF_WEAPONFRAME;
|
|
}
|
|
}
|
|
|
|
if (ent->spectator == 2 && ent->weaponframe) //it's not us, but we are spectating, so we need the correct weaponframe
|
|
pflags |= PF_WEAPONFRAME;
|
|
|
|
if (!ent->isself || (ent->fteext & PEXT_SPLITSCREEN))
|
|
{
|
|
#ifdef PEXT_SCALE //this is graphics, not physics
|
|
if (ent->fteext & PEXT_SCALE)
|
|
{
|
|
if (ent->scale && ent->scale != 1) pflags |= PF_SCALE;
|
|
}
|
|
#endif
|
|
#ifdef PEXT_TRANS
|
|
if (ent->fteext & PEXT_TRANS)
|
|
{
|
|
if (ent->transparency) pflags |= PF_TRANS;
|
|
}
|
|
#endif
|
|
#ifdef PEXT_FATNESS
|
|
if (ent->fteext & PEXT_FATNESS)
|
|
{
|
|
if (ent->fatness) pflags |= PF_FATNESS;
|
|
}
|
|
#endif
|
|
}
|
|
#ifdef PEXT_HULLSIZE
|
|
if (ent->fteext & PEXT_HULLSIZE)
|
|
{
|
|
hullnumber = SV_HullNumForPlayer(ent->hull, ent->mins, ent->maxs);
|
|
if (hullnumber != 1)
|
|
pflags |= PF_HULLSIZE_Z;
|
|
}
|
|
else
|
|
hullnumber=1;
|
|
#endif
|
|
|
|
if (zext&Z_EXT_PM_TYPE)
|
|
{
|
|
if (ent->cl)
|
|
{
|
|
if (ent->cl->viewent)
|
|
pm_type = PMC_NONE;
|
|
else
|
|
pm_type = SV_PMTypeForClient (ent->cl, ent->cl->edict);
|
|
switch (pm_type)
|
|
{
|
|
case PM_NORMAL: // Z_EXT_PM_TYPE protocol extension
|
|
if (ent->cl->jump_held)
|
|
pm_code = PMC_NORMAL_JUMP_HELD; // encode pm_type and jump_held into pm_code
|
|
else
|
|
pm_code = PMC_NORMAL;
|
|
break;
|
|
case PM_OLD_SPECTATOR:
|
|
pm_code = PMC_OLD_SPECTATOR;
|
|
break;
|
|
case PM_SPECTATOR: // Z_EXT_PM_TYPE_NEW protocol extension
|
|
pm_code = PMC_SPECTATOR;
|
|
break;
|
|
case PM_FLY:
|
|
pm_code = PMC_FLY;
|
|
break;
|
|
case PM_DEAD:
|
|
pm_code = PMC_NORMAL;
|
|
break;
|
|
case PM_NONE:
|
|
pm_code = PMC_NONE;
|
|
break;
|
|
case PM_WALLWALK:
|
|
pm_code = PMC_WALLWALK;
|
|
break;
|
|
default:
|
|
// Sys_Error("SV_WritePlayersToClient: unexpected pm_type");
|
|
pm_code=PMC_NORMAL;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
pm_code = (ent->zext & Z_EXT_PM_TYPE_NEW)?PMC_SPECTATOR:PMC_OLD_SPECTATOR;//(ent->spectator && ent->isself) ? PMC_OLD_SPECTATOR : PMC_NORMAL;
|
|
pflags |= pm_code << PF_PMC_SHIFT;
|
|
}
|
|
|
|
if ((zext & Z_EXT_PF_ONGROUND) && ent->onground)
|
|
pflags |= PF_ONGROUND;
|
|
if ((zext & Z_EXT_PF_SOLID) && ent->solid)
|
|
pflags |= PF_SOLID;
|
|
|
|
MSG_WriteByte (msg, svc_playerinfo);
|
|
MSG_WriteByte (msg, ent->playernum);
|
|
|
|
if (ent->fteext & (PEXT_HULLSIZE|PEXT_TRANS|PEXT_SCALE|PEXT_FATNESS))
|
|
{
|
|
if (pflags & 0xff0000)
|
|
pflags |= PF_EXTRA_PFS;
|
|
MSG_WriteShort (msg, pflags&0xffff);
|
|
if (pflags & PF_EXTRA_PFS)
|
|
MSG_WriteByte(msg, (pflags&0xff0000)>>16);
|
|
}
|
|
else
|
|
MSG_WriteShort (msg, (pflags&0x3fff) | ((pflags&0xc00000)>>8));
|
|
//we need to tell the client that it's moved, as it's own origin might not be natural
|
|
|
|
for (i=0 ; i<3 ; i++)
|
|
MSG_WriteCoord (msg, ent->origin[i]);
|
|
|
|
MSG_WriteByte (msg, ent->frame);
|
|
|
|
if (pflags & PF_MSEC)
|
|
{
|
|
msec = 1000*(sv.time - ent->localtime);
|
|
if (msec < 0)
|
|
msec = 0;
|
|
if (msec > 255)
|
|
msec = 255;
|
|
MSG_WriteByte (msg, msec);
|
|
}
|
|
|
|
if (pflags & PF_COMMAND)
|
|
{
|
|
if (ent->lastcmd)
|
|
cmd = *ent->lastcmd;
|
|
else
|
|
{
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
cmd.angles[0] = (short)(ent->angles[0] * 65535/360.0f);
|
|
cmd.angles[1] = (short)(ent->angles[1] * 65535/360.0f);
|
|
cmd.angles[2] = (short)(ent->angles[2] * 65535/360.0f);
|
|
}
|
|
|
|
if (ent->health <= 0)
|
|
{ // don't show the corpse looking around...
|
|
cmd.angles[0] = 0;
|
|
cmd.angles[1] = (int)(ent->angles[1]*65535/360);
|
|
cmd.angles[2] = 0;
|
|
}
|
|
|
|
cmd.buttons = 0; // never send buttons
|
|
if (ent->zext & Z_EXT_VWEP)
|
|
cmd.impulse = ent->vw_index; // never send impulses
|
|
else
|
|
cmd.impulse = 0;
|
|
|
|
MSG_WriteDeltaUsercmd (msg, &nullcmd, &cmd);
|
|
}
|
|
|
|
if (ent->velocity)
|
|
{
|
|
for (i=0 ; i<3 ; i++)
|
|
if (pflags & (PF_VELOCITY1<<i) )
|
|
MSG_WriteShort (msg, (short)(ent->velocity[i]));
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; i<3 ; i++)
|
|
if (pflags & (PF_VELOCITY1<<i) )
|
|
MSG_WriteShort (msg, 0);
|
|
}
|
|
|
|
if (pflags & PF_MODEL)
|
|
MSG_WriteByte (msg, ent->modelindex);
|
|
|
|
if (pflags & PF_SKINNUM)
|
|
MSG_WriteByte (msg, ent->skin | (((pflags & PF_MODEL)&&(ent->modelindex>=256))<<7));
|
|
|
|
if (pflags & PF_EFFECTS)
|
|
MSG_WriteByte (msg, ent->effects);
|
|
|
|
if (pflags & PF_WEAPONFRAME)
|
|
MSG_WriteByte (msg, ent->weaponframe);
|
|
|
|
#ifdef PEXT_SCALE
|
|
if (pflags & PF_SCALE)
|
|
MSG_WriteByte (msg, ent->scale*50);
|
|
#endif
|
|
#ifdef PEXT_TRANS
|
|
if (pflags & PF_TRANS)
|
|
MSG_WriteByte (msg, (qbyte)(ent->transparency*255));
|
|
#endif
|
|
#ifdef PEXT_FATNESS
|
|
if (pflags & PF_FATNESS)
|
|
MSG_WriteChar (msg, ent->fatness);
|
|
#endif
|
|
#ifdef PEXT_HULLSIZE //shrunken or crouching in halflife levels. (possibly enlarged)
|
|
if (pflags & PF_HULLSIZE_Z)
|
|
MSG_WriteChar (msg, hullnumber + (ent->onladder?128:0)); //physics.
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
|
|
qboolean Cull_Traceline(float *timestamp, pvscamera_t *cameras, edict_t *seen)
|
|
{
|
|
int i;
|
|
trace_t tr;
|
|
vec3_t end, amin, size;
|
|
int c;
|
|
|
|
if (seen->v->solid == SOLID_BSP)
|
|
return false; //bsp ents are never culled this way (typically far too large to care, often with large parts inside walls)
|
|
|
|
if (timestamp)
|
|
{
|
|
int tests;
|
|
float delay;
|
|
|
|
//temporal cache
|
|
//we still need to fire some traces every frame (monte-carlo style), but we don't need to be so desperate as it'll stay visible for a while anyway.
|
|
|
|
if (seen->entnum <= sv.allocated_client_slots)
|
|
tests = 8, delay = 0.2;
|
|
else
|
|
tests = 2, delay = 1.0;
|
|
|
|
VectorAdd(seen->v->origin, seen->v->mins, amin);
|
|
VectorSubtract(seen->v->maxs, seen->v->mins, size);
|
|
|
|
for (c = 0; c < cameras->numents; c++)
|
|
{
|
|
for (i = 0; i < tests; i++)
|
|
{
|
|
end[0] = amin[0] + frandom()*size[0];
|
|
end[1] = amin[1] + frandom()*size[1];
|
|
end[2] = amin[2] + frandom()*size[2];
|
|
|
|
if (!sv.world.worldmodel->funcs.NativeTrace (sv.world.worldmodel, 1, NULLFRAMESTATE, NULL, cameras->org[c], end, vec3_origin, vec3_origin, false, FTECONTENTS_SOLID, &tr))
|
|
{
|
|
*timestamp = sv.time + delay;
|
|
return false; //this trace went through, so don't cull
|
|
}
|
|
}
|
|
}
|
|
|
|
if (*timestamp >= sv.time)
|
|
return false;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
//stage 1: check against their origin
|
|
for (c = 0; c < cameras->numents; c++)
|
|
{
|
|
tr.fraction = 1;
|
|
if (!sv.world.worldmodel->funcs.NativeTrace (sv.world.worldmodel, 1, NULLFRAMESTATE, NULL, cameras->org[c], seen->v->origin, vec3_origin, vec3_origin, false, FTECONTENTS_SOLID, &tr))
|
|
return false; //wasn't blocked
|
|
}
|
|
|
|
//stage 2: check against their bbox
|
|
for (c = 0; c < cameras->numents; c++)
|
|
{
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
end[0] = seen->v->origin[0] + ((i&1)?seen->v->mins[0]:seen->v->maxs[0]);
|
|
end[1] = seen->v->origin[1] + ((i&2)?seen->v->mins[1]:seen->v->maxs[1]);
|
|
end[2] = seen->v->origin[2] + ((i&4)?seen->v->mins[2]+0.1:seen->v->maxs[2]);
|
|
|
|
tr.fraction = 1;
|
|
if (!sv.world.worldmodel->funcs.NativeTrace (sv.world.worldmodel, 1, NULLFRAMESTATE, NULL, cameras->org[c], end, vec3_origin, vec3_origin, false, FTECONTENTS_SOLID, &tr))
|
|
return false; //this trace went through, so don't cull
|
|
}
|
|
}
|
|
}
|
|
|
|
//not visible
|
|
return true;
|
|
}
|
|
|
|
#ifdef MVD_RECORDING
|
|
void SV_WritePlayersToMVD (client_t *client, client_frame_t *frame, sizebuf_t *msg)
|
|
{
|
|
int j;
|
|
client_t *cl;
|
|
edict_t *ent, *vent;
|
|
// int pflags;
|
|
|
|
demo_frame_t *demo_frame;
|
|
demo_client_t *dcl;
|
|
|
|
demo_frame = &demo.frames[demo.parsecount&DEMO_FRAMES_MASK];
|
|
for (j=0,cl=svs.clients, dcl = demo_frame->clients; j < svs.allocated_client_slots ; j++,cl++, dcl++)
|
|
{
|
|
if (cl->state != cs_spawned)
|
|
continue;
|
|
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
if (sv.demostatevalid)
|
|
{
|
|
if (client != cl)
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
ent = cl->edict;
|
|
vent = ent;
|
|
|
|
#ifdef NQPROT
|
|
if (progstype != PROG_QW)
|
|
{
|
|
if ((int)ent->v->effects & EF_MUZZLEFLASH)
|
|
{
|
|
ent->v->effects = (int)ent->v->effects & ~EF_MUZZLEFLASH;
|
|
ent->muzzletime = sv.world.physicstime;
|
|
MSG_WriteByte (&sv.multicast, svc_muzzleflash);
|
|
MSG_WriteEntity (&sv.multicast, NUM_FOR_EDICT(svprogfuncs, ent));
|
|
SV_MulticastProtExt (ent->v->origin, MULTICAST_PHS, pr_global_struct->dimension_send, 0, 0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (SV_AddCSQCUpdate(client, ent))
|
|
continue;
|
|
|
|
if (cl->spectator)
|
|
continue;
|
|
|
|
dcl->parsecount = demo.parsecount;
|
|
|
|
VectorCopy(vent->v->origin, dcl->info.origin);
|
|
VectorCopy(vent->v->angles, dcl->info.angles);
|
|
dcl->info.angles[0] *= -3;
|
|
dcl->info.angles[2] = 0; // no roll angle
|
|
|
|
if (ent->v->health <= 0)
|
|
{ // don't show the corpse looking around...
|
|
dcl->info.angles[0] = 0;
|
|
dcl->info.angles[1] = vent->v->angles[1];
|
|
dcl->info.angles[2] = 0;
|
|
}
|
|
|
|
if (ent != vent)
|
|
{
|
|
dcl->info.model = 0; //invisible.
|
|
dcl->info.effects = 0;
|
|
}
|
|
else
|
|
{
|
|
dcl->info.skinnum = ent->v->skin;
|
|
dcl->info.effects = ent->v->effects;
|
|
dcl->info.weaponframe = ent->v->weaponframe;
|
|
dcl->info.model = ent->v->modelindex;
|
|
}
|
|
dcl->sec = sv.time - cl->localtime;
|
|
dcl->frame = ent->v->frame;
|
|
dcl->flags = 0;
|
|
dcl->cmdtime = cl->localtime;
|
|
dcl->fixangle = demo.fixangle[j];
|
|
demo.fixangle[j] = 0;
|
|
|
|
if (ent->v->health <= 0)
|
|
dcl->flags |= DF_DEAD;
|
|
if (ent->v->mins[2] != -24)
|
|
dcl->flags |= DF_GIB;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
=============
|
|
SV_WritePlayersToClient
|
|
|
|
=============
|
|
*/
|
|
void SV_WritePlayersToClient (client_t *client, client_frame_t *frame, edict_t *clent, pvscamera_t *cameras, sizebuf_t *msg)
|
|
{
|
|
qboolean isbot;
|
|
int j;
|
|
client_t *cl;
|
|
edict_t *ent, *vent;
|
|
// int pflags;
|
|
|
|
if (client->state < cs_spawned)
|
|
{
|
|
Con_Printf("SV_WritePlayersToClient: not spawned yet\n");
|
|
return;
|
|
}
|
|
|
|
#ifdef NQPROT
|
|
if (!ISQWCLIENT(client))
|
|
return;
|
|
#endif
|
|
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
if (sv.demostatevalid) //this is a demo
|
|
{
|
|
usercmd_t cmd;
|
|
vec3_t ang;
|
|
vec3_t org;
|
|
vec3_t vel;
|
|
float lerp;
|
|
float a1, a2;
|
|
int i;
|
|
extern vec3_t player_mins, player_maxs;
|
|
clstate_t clst;
|
|
extern float olddemotime, nextdemotime;
|
|
|
|
for (i=0 ; i<svs.allocated_client_slots ; i++)
|
|
{
|
|
//FIXME: Add PVS stuff.
|
|
|
|
if (*sv.recordedplayer[i].userinfo) //if the client was active
|
|
{
|
|
clst.playernum = i;
|
|
clst.onladder = 0;
|
|
clst.lastcmd = &cmd;
|
|
clst.modelindex = sv.demostate[i+1].modelindex;
|
|
if (!clst.modelindex)
|
|
continue;
|
|
clst.frame = sv.demostate[i+1].frame;
|
|
clst.weaponframe = sv.recordedplayer[i].weaponframe;
|
|
clst.angles = ang;
|
|
clst.origin = org;
|
|
clst.hull = 1;
|
|
clst.velocity = vel;
|
|
clst.effects = sv.demostate[i+1].effects;
|
|
clst.skin = sv.demostate[i+1].skinnum;
|
|
clst.mins = player_mins;
|
|
clst.maxs = player_maxs;
|
|
clst.scale = sv.demostate[i+1].scale;
|
|
clst.transparency = sv.demostate[i+1].trans;
|
|
clst.fatness = sv.demostate[i+1].fatness;
|
|
clst.localtime = sv.time;//sv.recordedplayer[j].updatetime;
|
|
clst.health = sv.recordedplayer[i].stats[STAT_HEALTH];
|
|
clst.spectator = 2; //so that weaponframes work properly.
|
|
clst.isself = false;
|
|
clst.fteext = 0;//client->fteprotocolextensions;
|
|
clst.zext = 0;//client->zquake_extensions;
|
|
clst.cl = NULL;
|
|
clst.vw_index = 0;
|
|
clst.solid = true;
|
|
clst.onground = true;
|
|
|
|
lerp = (realtime - olddemotime) / (nextdemotime - olddemotime);
|
|
if (lerp < 0)
|
|
lerp = 0;
|
|
if (lerp > 1)
|
|
lerp = 1;
|
|
for (j = 0; j < 3; j++)
|
|
{
|
|
a1 = (360.0f/256)*sv.recordedplayer[i].oldang[j];
|
|
a2 = (360.0f/256)*sv.demostate[i+1].angles[j];
|
|
a2 = a2 - a1;
|
|
if (a2 > 180)
|
|
a2-=360;
|
|
if (a2 < -180)
|
|
a2+=360;
|
|
ang[j] = (a1 + (a2)*lerp);
|
|
|
|
org[j] = sv.recordedplayer[i].oldorg[j] + (sv.demostate[i+1].origin[j] - sv.recordedplayer[i].oldorg[j])*lerp;
|
|
|
|
vel[j] = (-sv.recordedplayer[i].oldorg[j] + sv.demostate[i+1].origin[j])*(nextdemotime - olddemotime);
|
|
}
|
|
|
|
ang[0] *= -3;
|
|
|
|
// ang[0] = ang[1] = ang[2] = 0;
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
cmd.angles[0] = ang[0]*65535/360.0f;
|
|
cmd.angles[1] = ang[1]*65535/360.0f;
|
|
cmd.angles[2] = ang[2]*65535/360.0f;
|
|
cmd.msec = 50;
|
|
{vec3_t f, r, u, v;
|
|
AngleVectors(ang, f, r, u);
|
|
VectorCopy(vel, v);
|
|
cmd.forwardmove = DotProduct(f, v);
|
|
cmd.sidemove = DotProduct(r, v);
|
|
cmd.upmove = DotProduct(u, v);
|
|
}
|
|
clst.lastcmd=NULL;
|
|
|
|
SV_WritePlayerToClient(msg, &clst);
|
|
}
|
|
}
|
|
|
|
//now build the spectator's thingie
|
|
|
|
memset(&clst, 0, sizeof(clst));
|
|
|
|
clst.fteext = 0;//client->fteprotocolextensions;
|
|
clst.zext = 0;//client->zquake_extensions;
|
|
clst.vw_index = 0;
|
|
clst.playernum = svs.allocated_client_slots-1;
|
|
clst.isself = true;
|
|
clst.modelindex = 0;
|
|
clst.hull = 1;
|
|
clst.frame = 0;
|
|
clst.localtime = sv.time;
|
|
clst.mins = player_mins;
|
|
clst.maxs = player_maxs;
|
|
|
|
clst.angles = vec3_origin; //not needed, as the client knows better than us anyway.
|
|
clst.origin = client->specorigin;
|
|
clst.velocity = client->specvelocity;
|
|
|
|
for (client = client; client; client = client->controller)
|
|
{
|
|
clst.health = 100;
|
|
|
|
if (client->spec_track)
|
|
{
|
|
clst.weaponframe = sv.recordedplayer[client->spec_track-1].weaponframe;
|
|
clst.spectator = 2;
|
|
}
|
|
else
|
|
{
|
|
clst.weaponframe = 0;
|
|
clst.spectator = 1;
|
|
}
|
|
|
|
SV_WritePlayerToClient(msg, &clst);
|
|
|
|
clst.playernum--;
|
|
}
|
|
return;
|
|
}
|
|
#endif
|
|
for (j=0,cl=svs.clients ; j<sv.allocated_client_slots && j < client->max_net_clients; j++,cl++)
|
|
{
|
|
if (cl->state != cs_spawned && !(cl->state == cs_free && cl->name[0])) //this includes bots, and nq bots
|
|
continue;
|
|
|
|
if ((client->penalties & BAN_BLIND) && client != cl)
|
|
continue;
|
|
|
|
|
|
isbot = (!cl->name[0] || cl->protocol == SCP_BAD);
|
|
ent = cl->edict;
|
|
if (cl->viewent && ent == clent)
|
|
{
|
|
vent = EDICT_NUM_UB(svprogfuncs, cl->viewent);
|
|
if (!vent)
|
|
vent = ent;
|
|
}
|
|
else
|
|
vent = ent;
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef NQPROT
|
|
if (progstype != PROG_QW)
|
|
{
|
|
if (progstype == PROG_H2 && (int)ent->v->effects & H2EF_NODRAW && ent != clent)
|
|
continue;
|
|
|
|
if ((int)ent->v->effects & EF_MUZZLEFLASH)
|
|
{
|
|
ent->v->effects = (int)ent->v->effects & ~EF_MUZZLEFLASH;
|
|
ent->muzzletime = sv.world.physicstime;
|
|
MSG_WriteByte (&sv.multicast, svc_muzzleflash);
|
|
MSG_WriteEntity (&sv.multicast, NUM_FOR_EDICT(svprogfuncs, ent));
|
|
SV_MulticastProtExt (ent->v->origin, MULTICAST_PHS, pr_global_struct->dimension_send, 0, 0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// ZOID visibility tracking
|
|
if (ent != clent &&
|
|
!(client->spec_track && client->spec_track - 1 == j))
|
|
{
|
|
if (cl->spectator)
|
|
continue;
|
|
|
|
// ignore if not touching a PV leaf
|
|
if (cameras && !sv.world.worldmodel->funcs.EdictInFatPVS(sv.world.worldmodel, &ent->pvsinfo, cameras->pvs.buffer, &cameras->numents))
|
|
continue;
|
|
|
|
if (!((int)clent->xv->dimension_see & ((int)ent->xv->dimension_seen | (int)ent->xv->dimension_ghost)))
|
|
continue; //not in this dimension - sorry...
|
|
if (cameras && (sv_cullplayers_trace.value || sv_cullentities_trace.value))
|
|
if (Cull_Traceline(NULL, cameras, ent))
|
|
continue;
|
|
}
|
|
|
|
if (SV_AddCSQCUpdate(client, ent))
|
|
continue;
|
|
|
|
{
|
|
clstate_t clst;
|
|
clst.playernum = j;
|
|
clst.onladder = (int)ent->xv->pmove_flags&PMF_LADDER;
|
|
clst.lastcmd = &cl->lastcmd;
|
|
clst.modelindex = vent->v->modelindex;
|
|
clst.frame = vent->v->frame;
|
|
clst.weaponframe = ent->v->weaponframe;
|
|
clst.angles = ent->v->angles;
|
|
clst.origin = vent->v->origin;
|
|
clst.velocity = vent->v->velocity;
|
|
clst.effects = ent->v->effects;
|
|
clst.vw_index = ent->xv->vw_index;
|
|
clst.onground = (int)ent->v->flags & FL_ONGROUND;
|
|
clst.solid = ent->v->solid && ent->v->solid != SOLID_CORPSE && ent->v->solid != SOLID_TRIGGER;
|
|
|
|
if (progstype == PROG_H2 && ((int)vent->v->effects & H2EF_NODRAW))
|
|
{
|
|
clst.effects = 0;
|
|
clst.modelindex = 0;
|
|
}
|
|
|
|
clst.skin = vent->v->skin;
|
|
clst.mins = vent->v->mins;
|
|
clst.hull = vent->xv->hull;
|
|
clst.maxs = vent->v->maxs;
|
|
clst.scale = vent->xv->scale;
|
|
clst.transparency = vent->xv->alpha;
|
|
|
|
//QSG_DIMENSION_PLANES - if the only shared dimensions are ghost dimensions, Set half alpha.
|
|
if (((int)clent->xv->dimension_see & (int)ent->xv->dimension_ghost))
|
|
if (!((int)clent->xv->dimension_see & ((int)ent->xv->dimension_seen & ~(int)ent->xv->dimension_ghost)) )
|
|
{
|
|
if (ent->xv->dimension_ghost_alpha)
|
|
clst.transparency *= ent->xv->dimension_ghost_alpha;
|
|
else
|
|
clst.transparency *= 0.5;
|
|
}
|
|
|
|
clst.fatness = vent->xv->fatness;
|
|
clst.localtime = cl->localtime;
|
|
clst.health = ent->v->health;
|
|
clst.spectator = 0;
|
|
clst.fteext = client->fteprotocolextensions;
|
|
clst.zext = client->zquake_extensions;
|
|
clst.cl = cl;
|
|
|
|
if (ent != vent || host_client->viewent == j+1)
|
|
clst.modelindex = 0;
|
|
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
if (sv.demostatevalid)
|
|
clst.health = 100;
|
|
#endif
|
|
|
|
clst.isself = false;
|
|
if ((cl == client || cl->controller == client))
|
|
{
|
|
clst.isself = true;
|
|
clst.spectator = 0;
|
|
if (client->spectator)
|
|
{
|
|
if (client->spec_track > 0)
|
|
{
|
|
edict_t *s = EDICT_NUM_UB(svprogfuncs, client->spec_track);
|
|
|
|
clst.spectator = 2;
|
|
clst.mins = s->v->mins;
|
|
clst.maxs = s->v->maxs;
|
|
clst.health = s->v->health;
|
|
clst.weaponframe = s->v->weaponframe;
|
|
}
|
|
else
|
|
{
|
|
clst.spectator = 1;
|
|
clst.health = 1;
|
|
}
|
|
}
|
|
}
|
|
else if (client->spectator)
|
|
{
|
|
clst.health=100;
|
|
if (client->spec_track == j+1)
|
|
clst.spectator = 2;
|
|
else
|
|
clst.spectator = 1;
|
|
}
|
|
if (isbot)
|
|
{
|
|
clst.lastcmd = NULL;
|
|
clst.velocity = NULL;
|
|
clst.localtime = sv.time;
|
|
VectorCopy(clst.origin, frame->laggedplayer[j].origin);
|
|
}
|
|
else
|
|
{
|
|
VectorMA(clst.origin, (sv.time - clst.localtime), clst.velocity, frame->laggedplayer[j].origin);
|
|
}
|
|
VectorCopy(clst.angles, frame->laggedplayer[j].angles);
|
|
frame->laggedplayer[j].present = true;
|
|
SV_WritePlayerToClient(msg, &clst);
|
|
}
|
|
|
|
//FIXME: Name flags
|
|
//player is visible, now would be a good time to update what the player is like.
|
|
/* pflags = 0;
|
|
#ifdef PEXT_VWEAP
|
|
if (client->fteprotocolextensions & PEXT_VWEAP && client->otherclientsknown[j].vweap != ent->xv->vweapmodelindex)
|
|
{
|
|
pflags |= 1;
|
|
client->otherclientsknown[j].vweap = ent->xv->vweapmodelindex;
|
|
}
|
|
#endif
|
|
if (pflags)
|
|
{
|
|
ClientReliableWrite_Begin(client, svc_ftesetclientpersist, 10);
|
|
ClientReliableWrite_Short(client, pflags);
|
|
if (pflags & 1)
|
|
ClientReliableWrite_Short(client, client->otherclientsknown[j].vweap);
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
|
|
#ifdef NQPROT
|
|
void SVNQ_EmitEntityState(sizebuf_t *msg, entity_state_t *ent)
|
|
{
|
|
edict_t *ed = EDICT_NUM_PB(svprogfuncs, ent->number);
|
|
entity_state_t *baseline = &ed->baseline;
|
|
|
|
int i, eff;
|
|
float miss;
|
|
unsigned int bits=0;
|
|
|
|
int glowsize=0, glowcolour=0, colourmod=0;
|
|
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
miss = ent->origin[i] - baseline->origin[i];
|
|
if ( miss < -0.1 || miss > 0.1 )
|
|
bits |= NQU_ORIGIN1<<i;
|
|
}
|
|
|
|
if (ent->angles[0] != baseline->angles[0] )
|
|
bits |= NQU_ANGLE1;
|
|
|
|
if (ent->angles[1] != baseline->angles[1] )
|
|
bits |= NQU_ANGLE2;
|
|
|
|
if (ent->angles[2] != baseline->angles[2] )
|
|
bits |= NQU_ANGLE3;
|
|
|
|
if (ent->dpflags & RENDER_STEP)
|
|
bits |= NQU_NOLERP; // don't mess up the step animation
|
|
|
|
if (baseline->colormap != ent->colormap)
|
|
bits |= NQU_COLORMAP;
|
|
|
|
if (baseline->skinnum != ent->skinnum)
|
|
bits |= NQU_SKIN;
|
|
|
|
if (baseline->frame != ent->frame)
|
|
bits |= NQU_FRAME;
|
|
|
|
eff = ent->effects;
|
|
|
|
if ((baseline->effects & 0x00ff) != ((int)eff & 0x00ff))
|
|
bits |= NQU_EFFECTS;
|
|
|
|
if (baseline->modelindex != ent->modelindex)
|
|
bits |= NQU_MODEL;
|
|
|
|
if (ent->number >= 256)
|
|
bits |= NQU_LONGENTITY;
|
|
|
|
|
|
if (host_client->protocol == SCP_FITZ666)
|
|
{
|
|
if (baseline->trans != ent->trans)
|
|
bits |= FITZU_ALPHA;
|
|
|
|
if (baseline->scale != ent->scale)
|
|
bits |= RMQU_SCALE;
|
|
|
|
if ((baseline->frame&0xff00) != (ent->frame&0xff00))
|
|
bits |= FITZU_FRAME2;
|
|
|
|
if ((baseline->modelindex&0xff00) != (ent->modelindex&0xff00))
|
|
bits |= FITZU_MODEL2;
|
|
|
|
if (baseline->dpflags & RENDER_STEP)
|
|
bits |= FITZU_LERPFINISH;
|
|
}
|
|
else if (host_client->protocol == SCP_BJP3)
|
|
{
|
|
//should be nehahra here, but that'll screw up DP, so don't generate anything.
|
|
}
|
|
#if 0
|
|
else if (host_client->protocol == SCP_DARKPLACES6 || host_client->protocol == SCP_DARKPLACES7)
|
|
{
|
|
if (baseline->trans != ent->trans)
|
|
bits |= DPU_ALPHA;
|
|
if (baseline->scale != ent->scale)
|
|
{
|
|
if (ent->scale != 0 || baseline->scale != 1)
|
|
bits |= DPU_SCALE;
|
|
}
|
|
|
|
if (ent->modelindex >= 256) //as much as protocols can handle
|
|
bits |= DPU_MODEL2;
|
|
|
|
if ((baseline->effects&0xff00) != ((int)eff & 0xff00))
|
|
bits |= DPU_EFFECTS2;
|
|
|
|
if (ent->dpflags & RENDER_EXTERIORMODEL)
|
|
bits |= DPU_EXTERIORMODEL;
|
|
if (ent->dpflags & RENDER_VIEWMODEL)
|
|
bits |= DPU_VIEWMODEL;
|
|
|
|
|
|
glowsize = ent->glowsize;
|
|
glowcolour = ent->glowcolour;
|
|
|
|
colourmod = ((int)bound(0, ent->colormod[0] * (7.0f / 32.0f), 7) << 5) | ((int)bound(0, ent->colormod[1] * (7.0f / 32.0f), 7) << 2) | ((int)bound(0, ent->colormod[2] * (3.0f / 32.0f), 3) << 0);
|
|
|
|
if (0 != glowsize)
|
|
bits |= DPU_GLOWSIZE;
|
|
if (0 != glowcolor)
|
|
bits |= DPU_GLOWCOLOR;
|
|
|
|
if (0 != colourmod)
|
|
bits |= DPU_COLORMOD;
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
if (ent->modelindex >= 256) //as much as protocols can handle
|
|
return;
|
|
if (ent->number >= 600) //too many for a conventional nq client.
|
|
return;
|
|
}
|
|
|
|
|
|
if (bits & 0xFF000000)
|
|
bits |= DPU_EXTEND2;
|
|
if (bits & 0xFF0000)
|
|
bits |= DPU_EXTEND1;
|
|
if (bits & 0xFF00)
|
|
bits |= NQU_MOREBITS;
|
|
|
|
|
|
//
|
|
// write the message
|
|
//
|
|
MSG_WriteByte (msg,(bits | NQU_SIGNAL) & 0xff); //gets caught on 'range error'
|
|
|
|
if (bits & NQU_MOREBITS) MSG_WriteByte (msg, (bits>>8)&0xff);
|
|
if (bits & DPU_EXTEND1) MSG_WriteByte (msg, (bits>>16)&0xff);
|
|
if (bits & DPU_EXTEND2) MSG_WriteByte (msg, (bits>>24)&0xff);
|
|
|
|
if (bits & NQU_LONGENTITY)
|
|
MSG_WriteShort (msg,ent->number);
|
|
else
|
|
MSG_WriteByte (msg,ent->number);
|
|
|
|
if (bits & NQU_MODEL)
|
|
{
|
|
if (host_client->protocol == SCP_BJP3)
|
|
MSG_WriteShort(msg, ent->modelindex & 0xffff);
|
|
else
|
|
MSG_WriteByte (msg, ent->modelindex & 0xff);
|
|
}
|
|
if (bits & NQU_FRAME) MSG_WriteByte (msg, ent->frame & 0xff);
|
|
if (bits & NQU_COLORMAP) MSG_WriteByte (msg, ent->colormap & 0xff);
|
|
if (bits & NQU_SKIN) MSG_WriteByte (msg, ent->skinnum & 0xff);
|
|
if (bits & NQU_EFFECTS) MSG_WriteByte (msg, eff & 0x00ff);
|
|
if (bits & NQU_ORIGIN1) MSG_WriteCoord (msg, ent->origin[0]);
|
|
if (bits & NQU_ANGLE1) MSG_WriteAngle(msg, ent->angles[0]);
|
|
if (bits & NQU_ORIGIN2) MSG_WriteCoord (msg, ent->origin[1]);
|
|
if (bits & NQU_ANGLE2) MSG_WriteAngle(msg, ent->angles[1]);
|
|
if (bits & NQU_ORIGIN3) MSG_WriteCoord (msg, ent->origin[2]);
|
|
if (bits & NQU_ANGLE3) MSG_WriteAngle(msg, ent->angles[2]);
|
|
|
|
if (host_client->protocol == SCP_FITZ666)
|
|
{
|
|
if (bits & FITZU_ALPHA) MSG_WriteByte(msg, (ent->trans+1)&0xff);
|
|
if (bits & RMQU_SCALE) MSG_WriteByte(msg, ent->scale);
|
|
if (bits & FITZU_FRAME2) MSG_WriteByte(msg, ent->frame>>8);
|
|
if (bits & FITZU_MODEL2) MSG_WriteByte(msg, ent->modelindex>>8);
|
|
if (bits & FITZU_LERPFINISH)MSG_WriteByte(msg, bound(0, (int)((ed->v->nextthink - sv.world.physicstime) * 255), 255));
|
|
}
|
|
else if (host_client->protocol == SCP_BJP3)
|
|
{
|
|
}
|
|
else if (host_client->protocol == SCP_DARKPLACES6 || host_client->protocol == SCP_DARKPLACES7)
|
|
{
|
|
if (bits & DPU_ALPHA) MSG_WriteByte(msg, ent->trans);
|
|
if (bits & DPU_SCALE) MSG_WriteByte(msg, ent->scale);
|
|
if (bits & DPU_EFFECTS2) MSG_WriteByte(msg, eff >> 8);
|
|
if (bits & DPU_GLOWSIZE) MSG_WriteByte(msg, glowsize);
|
|
if (bits & DPU_GLOWCOLOR) MSG_WriteByte(msg, glowcolour);
|
|
if (bits & DPU_COLORMOD) MSG_WriteByte(msg, colourmod);
|
|
if (bits & DPU_FRAME2) MSG_WriteByte(msg, ent->frame >> 8);
|
|
if (bits & DPU_MODEL2) MSG_WriteByte(msg, ent->modelindex >> 8);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
typedef struct gibfilter_s {
|
|
struct gibfilter_s *next;
|
|
int modelindex;
|
|
int minframe;
|
|
int maxframe;
|
|
} gibfilter_t;
|
|
static gibfilter_t *gibfilter;
|
|
void SV_GibFilterPurge(void)
|
|
{
|
|
gibfilter_t *gf;
|
|
while(gibfilter)
|
|
{
|
|
gf = gibfilter;
|
|
gibfilter = gibfilter->next;
|
|
|
|
Z_Free(gf);
|
|
}
|
|
}
|
|
|
|
void SV_GibFilterAdd(char *modelname, int min, int max, qboolean allowwarn)
|
|
{
|
|
int i;
|
|
gibfilter_t *gf;
|
|
|
|
for (i=1; sv.strings.model_precache[i] ; i++)
|
|
if (!strcmp(sv.strings.model_precache[i], modelname))
|
|
break;
|
|
if (!sv.strings.model_precache[i])
|
|
{
|
|
if (allowwarn)
|
|
Con_Printf("Filtered model \"%s\" was not precached\n", modelname);
|
|
return; //model not in use.
|
|
}
|
|
|
|
gf = Z_Malloc(sizeof(gibfilter_t));
|
|
gf->modelindex = i;
|
|
gf->minframe = ((min==-1)?0:min);
|
|
gf->maxframe = ((max==-1)?0x80000000:max);
|
|
gf->next = gibfilter;
|
|
gibfilter = gf;
|
|
}
|
|
void SV_GibFilterInit(void)
|
|
{
|
|
char buffer[2048];
|
|
char *file;
|
|
int min, max;
|
|
|
|
SV_GibFilterPurge();
|
|
|
|
if (svs.gametype != GT_PROGS && svs.gametype != GT_Q1QVM)
|
|
return;
|
|
|
|
file = COM_LoadStackFile("gibfiltr.cfg", buffer, sizeof(buffer), NULL);
|
|
if (!file)
|
|
{
|
|
Con_DPrintf("gibfiltr.cfg file was not found. Using defaults\n");
|
|
SV_GibFilterAdd("progs/gib1.mdl", -1, -1, false);
|
|
SV_GibFilterAdd("progs/gib2.mdl", -1, -1, false);
|
|
SV_GibFilterAdd("progs/gib3.mdl", -1, -1, false);
|
|
SV_GibFilterAdd("progs/h_player.mdl", -1, -1, false);
|
|
// SV_GibFilterAdd("progs/player.mdl", 49, 49, false);
|
|
// SV_GibFilterAdd("progs/player.mdl", 60, 60, false);
|
|
// SV_GibFilterAdd("progs/player.mdl", 69, 69, false);
|
|
// SV_GibFilterAdd("progs/player.mdl", 84, 84, false);
|
|
// SV_GibFilterAdd("progs/player.mdl", 93, 93, false);
|
|
// SV_GibFilterAdd("progs/player.mdl", 102, 102, false);
|
|
return;
|
|
}
|
|
while(file)
|
|
{
|
|
file = COM_Parse(file);
|
|
if (!file)
|
|
{
|
|
return;
|
|
}
|
|
min = atoi(com_token);
|
|
file = COM_Parse(file); //handles nulls nicly
|
|
max = atoi(com_token);
|
|
file = COM_Parse(file);
|
|
if (!file)
|
|
{
|
|
Con_Printf("Sudden ending to gibfiltr.cfg\n");
|
|
return;
|
|
}
|
|
SV_GibFilterAdd(com_token, min, max, true);
|
|
}
|
|
}
|
|
qboolean SV_GibFilter(edict_t *ent)
|
|
{
|
|
int indx = ent->v->modelindex;
|
|
int frame = ent->v->frame;
|
|
gibfilter_t *gf;
|
|
|
|
for (gf = gibfilter; gf; gf=gf->next)
|
|
{
|
|
if (gf->modelindex == indx)
|
|
if (frame >= gf->minframe && frame <= gf->maxframe)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
static void SV_Snapshot_Build_Playback(client_t *client, packet_entities_t *pack)
|
|
{
|
|
int e;
|
|
entity_state_t *state;
|
|
mvdentity_state_t *dement;
|
|
for (e=1, dement=&sv.demostate[e] ; e<=sv.demomaxents ; e++, dement++)
|
|
{
|
|
if (!dement->modelindex)
|
|
continue;
|
|
|
|
if (e >= 1 && e <= svs.allocated_client_slots)
|
|
continue;
|
|
|
|
if (pack->num_entities == pack->max_entities)
|
|
continue; // all full
|
|
|
|
//the entity would mess up the client and possibly disconnect them.
|
|
//FIXME: add an option to drop clients... entity fog could be killed in this way.
|
|
if (e >= 512 && !(client->fteprotocolextensions & PEXT_ENTITYDBL))
|
|
continue;
|
|
if (e >= 1024 && !(client->fteprotocolextensions & PEXT_ENTITYDBL2))
|
|
continue;
|
|
// if (dement->modelindex >= 256 && !(client->fteprotocolextensions & PEXT_MODELDBL))
|
|
// continue;
|
|
|
|
state = &pack->entities[pack->num_entities];
|
|
pack->num_entities++;
|
|
|
|
state->number = e;
|
|
state->flags = EF_DIMLIGHT;
|
|
VectorCopy (dement->origin, state->origin);
|
|
state->angles[0] = dement->angles[0]*360.0f/256;
|
|
state->angles[1] = dement->angles[1]*360.0f/256;
|
|
state->angles[2] = dement->angles[2]*360.0f/256;
|
|
state->modelindex = dement->modelindex;
|
|
state->frame = dement->frame;
|
|
state->colormap = dement->colormap;
|
|
state->skinnum = dement->skinnum;
|
|
state->effects = dement->effects;
|
|
|
|
#ifdef PEXT_SCALE
|
|
state->scale = dement->scale;
|
|
#endif
|
|
#ifdef PEXT_TRANS
|
|
state->trans = dement->trans;
|
|
#endif
|
|
#ifdef PEXT_FATNESS
|
|
state->fatness = dement->fatness;
|
|
#endif
|
|
}
|
|
|
|
for (e = 0; e < sv.numdemospikes; e++)
|
|
{
|
|
if (SV_DemoNailUpdate (e))
|
|
continue;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void SV_Snapshot_BuildStateQ1(entity_state_t *state, edict_t *ent, client_t *client, packet_entities_t *pack)
|
|
{
|
|
//builds an entity_state from an entity
|
|
//note that client can be null, for building baselines.
|
|
|
|
int i;
|
|
state->number = NUM_FOR_EDICT(svprogfuncs, ent);
|
|
|
|
state->u.q1.msec = 0;
|
|
state->u.q1.pmovetype = 0;
|
|
state->u.q1.movement[0] = 0;
|
|
state->u.q1.movement[1] = 0;
|
|
state->u.q1.movement[2] = 0;
|
|
state->u.q1.velocity[0] = 0;
|
|
state->u.q1.velocity[1] = 0;
|
|
state->u.q1.velocity[2] = 0;
|
|
|
|
VectorCopy (ent->v->origin, state->origin);
|
|
VectorCopy (ent->v->angles, state->angles);
|
|
|
|
state->u.q1.weaponframe = 0;
|
|
if ((state->number-1) < (unsigned int)sv.allocated_client_slots && (client == &svs.clients[state->number-1] || client == svs.clients[state->number-1].controller || (client && (!client->edict || client->spec_track == state->number))))
|
|
if (!client || !(client->fteprotocolextensions2 & PEXT2_PREDINFO))
|
|
state->u.q1.weaponframe = ent->v->weaponframe;
|
|
if ((state->number-1) < (unsigned int)sv.allocated_client_slots && ent->v->movetype && client)
|
|
{
|
|
client_t *cl = &svs.clients[state->number-1];
|
|
if (cl->isindependant)
|
|
{
|
|
state->u.q1.pmovetype = ent->v->movetype;
|
|
if (state->u.q1.pmovetype && ((int)ent->v->flags & FL_ONGROUND) && (client->zquake_extensions&Z_EXT_PF_ONGROUND))
|
|
state->u.q1.pmovetype |= 0x80;
|
|
if (state->u.q1.pmovetype && ((int)cl->jump_held) && (client->zquake_extensions&Z_EXT_PM_TYPE))
|
|
state->u.q1.pmovetype |= 0x40;
|
|
if (cl != client && client)
|
|
{ /*only generate movement values if the client doesn't already know them...*/
|
|
state->u.q1.movement[0] = ent->xv->movement[0];
|
|
state->u.q1.movement[1] = ent->xv->movement[1];
|
|
state->u.q1.movement[2] = ent->xv->movement[2];
|
|
state->u.q1.msec = bound(0, 1000*(sv.time - cl->localtime), 255);
|
|
}
|
|
|
|
state->u.q1.velocity[0] = ent->v->velocity[0] * 8;
|
|
state->u.q1.velocity[1] = ent->v->velocity[1] * 8;
|
|
state->u.q1.velocity[2] = ent->v->velocity[2] * 8;
|
|
}
|
|
else if (ent == cl->edict)
|
|
{
|
|
state->u.q1.velocity[0] = ent->v->velocity[0] * 8;
|
|
state->u.q1.velocity[1] = ent->v->velocity[1] * 8;
|
|
state->u.q1.velocity[2] = ent->v->velocity[2] * 8;
|
|
}
|
|
|
|
//fixme: deal with fixangles
|
|
if (client->fteprotocolextensions2 & PEXT2_PREDINFO)
|
|
{
|
|
state->u.q1.vangle[0] = ANGLE2SHORT(ent->v->v_angle[0]);
|
|
state->u.q1.vangle[1] = ANGLE2SHORT(ent->v->v_angle[1]);
|
|
state->u.q1.vangle[2] = ANGLE2SHORT(ent->v->v_angle[2]);
|
|
}
|
|
else
|
|
{
|
|
if (client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS)
|
|
if (state->u.q1.pmovetype && ((state->u.q1.pmovetype&0x7f) != MOVETYPE_TOSS && (state->u.q1.pmovetype&0x7f) != MOVETYPE_BOUNCE))
|
|
{
|
|
state->angles[0] = ent->v->v_angle[0]/-3.0;
|
|
state->angles[1] = ent->v->v_angle[1];
|
|
state->angles[2] = ent->v->v_angle[2];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (client && client->edict && (ent->v->owner == client->edict->entnum))
|
|
state->solidsize = 0;
|
|
else if (ent->v->solid == SOLID_BSP || (ent->v->skin < 0 && ent->v->modelindex))
|
|
state->solidsize = ES_SOLID_BSP;
|
|
else if (ent->v->solid == SOLID_BBOX || ent->v->solid == SOLID_SLIDEBOX || ent->v->skin < 0)
|
|
state->solidsize = ent->solidsize;
|
|
else
|
|
state->solidsize = 0;
|
|
|
|
state->dpflags = 0;
|
|
if (ent->xv->viewmodelforclient)
|
|
{ //this ent would have been filtered out by now if its not ours
|
|
//if ent->viewmodelforclient == client then:
|
|
state->dpflags |= RENDER_VIEWMODEL;
|
|
}
|
|
state->colormap = ent->v->colormap;
|
|
if (state->colormap >= 1024)
|
|
state->dpflags |= RENDER_COLORMAPPED;
|
|
else if (client && state->colormap > client->max_net_clients)
|
|
state->colormap = 0;
|
|
|
|
if (ent->xv->exteriormodeltoclient && client)
|
|
{
|
|
if (ent->xv->exteriormodeltoclient == EDICT_TO_PROG(svprogfuncs, client->edict))
|
|
state->dpflags |= RENDER_EXTERIORMODEL;
|
|
//everyone else sees it normally.
|
|
}
|
|
|
|
if (ent->xv->basebone < 0)
|
|
{
|
|
#ifdef SKELETALMODELS
|
|
if (ent->xv->skeletonindex && pack)
|
|
{
|
|
framestate_t fs;
|
|
fs.skeltype = SKEL_IDENTITY;
|
|
fs.bonecount = 0;
|
|
skel_lookup(&sv.world, ent->xv->skeletonindex, &fs);
|
|
if (fs.skeltype == SKEL_RELATIVE && fs.bonecount)
|
|
{
|
|
Bones_To_PosQuat4(fs.bonecount, fs.bonestate, AllocateBoneSpace(pack, state->bonecount = fs.bonecount, &state->boneoffset));
|
|
//state->dpflags |= RENDER_COMPLEXANIMATION;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
state->basebone = ent->xv->basebone;
|
|
state->baseframe = ent->xv->baseframe;
|
|
}
|
|
|
|
if (!ent->v->movetype || ent->v->movetype == MOVETYPE_STEP)
|
|
state->dpflags |= RENDER_STEP;
|
|
|
|
state->modelindex = ent->v->modelindex;
|
|
state->modelindex2 = ent->xv->vw_index;
|
|
state->frame = ent->v->frame;
|
|
state->skinnum = ent->v->skin;
|
|
state->effects = ent->v->effects;
|
|
state->effects |= (int)ent->xv->modelflags<<24;
|
|
#ifdef HEXEN2
|
|
state->hexen2flags = ent->xv->drawflags;
|
|
state->abslight = (int)(ent->xv->abslight*255) & 255;
|
|
#endif
|
|
state->tagentity = ent->xv->tag_entity;
|
|
state->tagindex = ent->xv->tag_index;
|
|
|
|
state->light[0] = ent->xv->color[0]*1024;
|
|
state->light[1] = ent->xv->color[1]*1024;
|
|
state->light[2] = ent->xv->color[2]*1024;
|
|
state->light[3] = ent->xv->light_lev;
|
|
state->lightstyle = ent->xv->style;
|
|
state->lightpflags = ent->xv->pflags;
|
|
state->u.q1.traileffectnum = ent->xv->traileffectnum;
|
|
state->u.q1.emiteffectnum = ent->xv->emiteffectnum;
|
|
|
|
if (ent->xv->gravitydir[2] == -1)
|
|
{
|
|
state->u.q1.gravitydir[0] = 0;
|
|
state->u.q1.gravitydir[1] = 0;
|
|
}
|
|
else if ((!ent->xv->gravitydir[0] && !ent->xv->gravitydir[1] && !ent->xv->gravitydir[2]))// || (ent->xv->gravitydir[2] == -1))
|
|
{
|
|
vec3_t ang;
|
|
if (sv.world.g.defaultgravitydir[2] == -1)
|
|
{
|
|
state->u.q1.gravitydir[0] = 0;
|
|
state->u.q1.gravitydir[1] = 0;
|
|
}
|
|
else
|
|
{
|
|
VectorAngles(sv.world.g.defaultgravitydir, NULL, ang, false);
|
|
state->u.q1.gravitydir[0] = ((ang[0]/360) * 256) - 192;
|
|
state->u.q1.gravitydir[1] = (ang[1]/360) * 256;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vec3_t ang;
|
|
VectorAngles(ent->xv->gravitydir, NULL, ang, false);
|
|
state->u.q1.gravitydir[0] = ((ang[0]/360) * 256) - 192;
|
|
state->u.q1.gravitydir[1] = (ang[1]/360) * 256;
|
|
}
|
|
|
|
if (((int)ent->v->flags & FL_CLASS_DEPENDENT) && client && client->playerclass) //hexen2 wierdness.
|
|
{
|
|
char modname[MAX_QPATH];
|
|
Q_strncpyz(modname, sv.strings.model_precache[state->modelindex], sizeof(modname));
|
|
if (strlen(modname)>5)
|
|
{
|
|
modname[strlen(modname)-5] = client->playerclass+'0';
|
|
state->modelindex = SV_ModelIndex(modname);
|
|
}
|
|
}
|
|
|
|
if (state->effects & DPEF_LOWPRECISION)
|
|
state->effects &= ~DPEF_LOWPRECISION; //we don't support it, nor does dp any more. strip it.
|
|
|
|
if (state->effects & EF_FULLBRIGHT) //wrap the field for fte clients (this is horrible)
|
|
state->hexen2flags |= MLS_FULLBRIGHT;
|
|
|
|
#ifdef NQPROT
|
|
if (client && !ISQWCLIENT(client))
|
|
{
|
|
if (ent->muzzletime > client->lastoutgoingphysicstime && ent->muzzletime <= (float)sv.world.physicstime)
|
|
state->effects |= EF_MUZZLEFLASH;
|
|
|
|
if (client->spectator && !client->spec_track && ent == client->edict)
|
|
state->modelindex = sv_playermodel;
|
|
}
|
|
|
|
if (progstype != PROG_QW)
|
|
{
|
|
if (progstype == PROG_TENEBRAE)
|
|
{
|
|
//tenebrae has some hideous hacks
|
|
if (!strcmp(sv.strings.model_precache[state->modelindex], "progs/w_light.spr") ||
|
|
!strcmp(sv.strings.model_precache[state->modelindex], "progs/b_light.spr") ||
|
|
!strcmp(sv.strings.model_precache[state->modelindex], "progs/s_light.spr") ||
|
|
!strcmp(sv.strings.model_precache[state->modelindex], "progs/flame.mdl") ||
|
|
!strcmp(sv.strings.model_precache[state->modelindex], "progs/flame2.mdl"))
|
|
{
|
|
//fixme: add some default colours
|
|
state->lightpflags |= PFLAGS_FULLDYNAMIC;
|
|
if (!state->light[3])
|
|
state->light[3] = 350;
|
|
}
|
|
|
|
if (!strcmp (sv.strings.model_precache[state->modelindex], "progs/lavaball.mdl"))
|
|
{
|
|
state->lightpflags |= PFLAGS_FULLDYNAMIC;
|
|
state->skinnum = 17;
|
|
state->light[3] = 270;
|
|
}
|
|
}
|
|
if (state->effects && client && ISQWCLIENT(client)) //don't send extra nq effects to a qw client.
|
|
{
|
|
//EF_NODRAW doesn't draw the model.
|
|
//The client still needs to know about it though, as it might have other effects on it.
|
|
if (progstype == PROG_H2)
|
|
{
|
|
if (state->effects == H2EF_NODRAW)
|
|
{
|
|
//actually, H2 is pretty lame about this
|
|
state->effects = 0;
|
|
state->modelindex = 0;
|
|
state->frame = 0;
|
|
state->colormap = 0;
|
|
state->abslight = 0;
|
|
state->skinnum = 0;
|
|
state->hexen2flags = 0;
|
|
}
|
|
}
|
|
else if (progstype == PROG_TENEBRAE)
|
|
{
|
|
if (state->effects & 16) //tenebrae's EF_FULLDYNAMIC
|
|
{
|
|
state->effects &= ~16;
|
|
state->lightpflags |= PFLAGS_FULLDYNAMIC;
|
|
}
|
|
if (state->effects & 32) //tenebrae's EF_GREEN
|
|
{
|
|
state->effects &= ~32;
|
|
state->effects |= EF_GREEN;
|
|
}
|
|
}
|
|
|
|
if (state->number <= sv.allocated_client_slots) // clear only client ents
|
|
{
|
|
if (state->effects & NQEF_NODRAW)
|
|
state->modelindex = 0;
|
|
state->effects &= ~ (QWEF_FLAG1|QWEF_FLAG2);
|
|
}
|
|
|
|
if ((state->effects & EF_DIMLIGHT) && !(state->effects & (EF_RED|EF_BLUE)))
|
|
{
|
|
int it = ent->v->items;
|
|
state->effects &= ~EF_DIMLIGHT;
|
|
if ((it & (IT_INVULNERABILITY|IT_QUAD)) == (IT_INVULNERABILITY|IT_QUAD))
|
|
state->effects |= EF_RED|EF_BLUE;
|
|
else if (it & IT_INVULNERABILITY)
|
|
state->effects |= EF_RED;
|
|
else if (it & IT_QUAD)
|
|
state->effects |= EF_BLUE;
|
|
else
|
|
state->effects |= EF_DIMLIGHT;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!ent->xv->colormod[0] && !ent->xv->colormod[1] && !ent->xv->colormod[2])
|
|
{
|
|
state->colormod[0] = (256)/8;
|
|
state->colormod[1] = (256)/8;
|
|
state->colormod[2] = (256)/8;
|
|
}
|
|
else
|
|
{
|
|
i = ent->xv->colormod[0]*(256/8); state->colormod[0] = bound(0, i, 255);
|
|
i = ent->xv->colormod[1]*(256/8); state->colormod[1] = bound(0, i, 255);
|
|
i = ent->xv->colormod[2]*(256/8); state->colormod[2] = bound(0, i, 255);
|
|
}
|
|
if (!ent->xv->glowmod[0] && !ent->xv->glowmod[1] && !ent->xv->glowmod[2])
|
|
{
|
|
state->glowmod[0] = (256/8);
|
|
state->glowmod[1] = (256/8);
|
|
state->glowmod[2] = (256/8);
|
|
}
|
|
else
|
|
{
|
|
state->glowmod[0] = ent->xv->glowmod[0]*(256/8);
|
|
state->glowmod[1] = ent->xv->glowmod[1]*(256/8);
|
|
state->glowmod[2] = ent->xv->glowmod[2]*(256/8);
|
|
}
|
|
state->glowsize = ent->xv->glow_size*0.25;
|
|
state->glowcolour = ent->xv->glow_color;
|
|
if (ent->xv->glow_trail)
|
|
state->dpflags |= RENDER_GLOWTRAIL;
|
|
|
|
|
|
#ifdef PEXT_SCALE
|
|
if (!ent->xv->scale)
|
|
state->scale = 1*16;
|
|
else
|
|
state->scale = bound(1, ent->xv->scale*16, 255);
|
|
|
|
#endif
|
|
#ifdef PEXT_TRANS
|
|
if (!ent->xv->alpha)
|
|
state->trans = 255;
|
|
else
|
|
state->trans = bound(1, ent->xv->alpha*254, 254);
|
|
|
|
//QSG_DIMENSION_PLANES - if the only shared dimensions are ghost dimensions, Set half alpha.
|
|
if (client && client->edict)
|
|
{
|
|
if (((int)client->edict->xv->dimension_see & (int)ent->xv->dimension_ghost))
|
|
if (!((int)client->edict->xv->dimension_see & ((int)ent->xv->dimension_seen & ~(int)ent->xv->dimension_ghost)) )
|
|
{
|
|
if (ent->xv->dimension_ghost_alpha)
|
|
state->trans *= ent->xv->dimension_ghost_alpha;
|
|
else
|
|
state->trans *= 0.5;
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef PEXT_FATNESS
|
|
state->fatness = ent->xv->fatness;
|
|
#endif
|
|
|
|
#pragma warningmsg("TODO: Fix attachments for more vanilla clients")
|
|
}
|
|
|
|
void SV_Snapshot_BuildQ1(client_t *client, packet_entities_t *pack, pvscamera_t *cameras, edict_t *clent)
|
|
{
|
|
//pvs and clent can be null, but only if the other is also null
|
|
int e, i;
|
|
edict_t *ent, *tracecullent; //tracecullent is different from ent because attached models cull the parent instead. also, null for entities which are not culled.
|
|
entity_state_t *state;
|
|
#define DEPTHOPTIMISE
|
|
#ifdef DEPTHOPTIMISE
|
|
vec3_t org;
|
|
static float distances[32768];
|
|
float dist;
|
|
#endif
|
|
globalvars_t *pr_globals = PR_globals(svprogfuncs, PR_CURRENT);
|
|
int pvsflags;
|
|
int limit;
|
|
int c, maxc = cameras?cameras->numents:0;
|
|
client_t *seat;
|
|
|
|
//this entity is watching from outside themselves. The client is tricked into thinking that they themselves are in the view ent, and a new dummy ent (the old them) must be spawned.
|
|
if (clent && ISQWCLIENT(client))
|
|
{
|
|
for (seat = client; seat; seat = seat->controlled)
|
|
{
|
|
edict_t *clent = seat->edict;
|
|
if (!client->viewent)
|
|
continue;
|
|
//FIXME: this hack needs cleaning up
|
|
#ifdef DEPTHOPTIMISE
|
|
distances[pack->num_entities] = 0;
|
|
#endif
|
|
state = &pack->entities[pack->num_entities];
|
|
pack->num_entities++;
|
|
|
|
SV_Snapshot_BuildStateQ1(state, clent, seat, pack);
|
|
|
|
state->number = seat - svs.clients + 1;
|
|
|
|
//yeah, I doubt anyone will need this
|
|
if (progstype == PROG_QW)
|
|
{
|
|
if ((int)clent->v->effects & QWEF_FLAG1)
|
|
{
|
|
memcpy(&pack->entities[pack->num_entities], state, sizeof(*state));
|
|
state = &pack->entities[pack->num_entities];
|
|
pack->num_entities++;
|
|
state->modelindex = SV_ModelIndex("progs/flag.mdl");
|
|
state->frame = 0;
|
|
state->number++; //yeek
|
|
state->skinnum = 0;
|
|
}
|
|
else if ((int)clent->v->effects & QWEF_FLAG2)
|
|
{
|
|
memcpy(&pack->entities[pack->num_entities], state, sizeof(*state));
|
|
state = &pack->entities[pack->num_entities];
|
|
pack->num_entities++;
|
|
state->modelindex = SV_ModelIndex("progs/flag.mdl");
|
|
state->frame = 0;
|
|
state->number++; //yeek
|
|
state->skinnum = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*legacy qw clients get their players separately*/
|
|
if (ISQWCLIENT(client) && !(client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS))
|
|
e = min(sv.allocated_client_slots+1, client->max_net_clients);
|
|
else
|
|
e = 1;
|
|
|
|
limit = sv.world.num_edicts;
|
|
if (client->max_net_ents < limit)
|
|
{
|
|
limit = client->max_net_ents;
|
|
if (!(client->plimitwarned & PLIMIT_ENTITIES))
|
|
{
|
|
client->plimitwarned |= PLIMIT_ENTITIES;
|
|
SV_ClientPrintf(client, PRINT_HIGH, "WARNING: Your client's network protocol only supports %i entities. Please upgrade or enable extensions.\n", client->max_net_ents);
|
|
}
|
|
}
|
|
|
|
if (client->penalties & BAN_BLIND)
|
|
{
|
|
e = client->edict->entnum;
|
|
limit = e+1;
|
|
}
|
|
|
|
if (sv_cullentities_trace.ival && client->lastseen_count < limit)
|
|
Z_ReallocElements((void**)&client->lastseen_time, &client->lastseen_count, limit, sizeof(client->lastseen_time));
|
|
|
|
for ( ; e<limit ; e++)
|
|
{
|
|
ent = EDICT_NUM_PB(svprogfuncs, e);
|
|
if (ED_ISFREE(ent))
|
|
continue;
|
|
|
|
if (ent->xv->customizeentityforclient)
|
|
{
|
|
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, ent);
|
|
pr_global_struct->other = (clent?EDICT_TO_PROG(svprogfuncs, clent):0);
|
|
PR_ExecuteProgram(svprogfuncs, ent->xv->customizeentityforclient);
|
|
if(!G_FLOAT(OFS_RETURN))
|
|
continue;
|
|
}
|
|
|
|
#ifdef NQPROT
|
|
if (progstype != PROG_QW)
|
|
{
|
|
if ((int)ent->v->effects & EF_MUZZLEFLASH)
|
|
{
|
|
ent->v->effects = (int)ent->v->effects & ~EF_MUZZLEFLASH;
|
|
ent->muzzletime = sv.world.physicstime;
|
|
MSG_WriteByte (&sv.multicast, svc_muzzleflash);
|
|
MSG_WriteEntity (&sv.multicast, NUM_FOR_EDICT(svprogfuncs, ent));
|
|
SV_MulticastProtExt (ent->v->origin, MULTICAST_PHS, pr_global_struct->dimension_send, 0, 0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
pvsflags = ent->xv->pvsflags;
|
|
for (c = 0; c < maxc; c++)
|
|
{
|
|
if (ent == cameras->ent[c])
|
|
break;
|
|
}
|
|
if (c < maxc)
|
|
tracecullent = NULL;
|
|
else if (ent->xv->viewmodelforclient)
|
|
{
|
|
if (ent->xv->viewmodelforclient != (clent?EDICT_TO_PROG(svprogfuncs, clent):0))
|
|
continue;
|
|
tracecullent = NULL;
|
|
}
|
|
else
|
|
{
|
|
// many ents are not intended to be networked.
|
|
if (!(ent->xv->SendEntity && client->csqcactive) && //if SendEntity is set then its definitely important, even if not visible.
|
|
(!ent->v->modelindex || !*PR_GetString(svprogfuncs, ent->v->model)) && // also definitely valid if it has a model
|
|
!((int)ent->xv->pflags & PFLAGS_FULLDYNAMIC) && //needs to be networked if its giving off realtime lights, even when it has no model.
|
|
ent->v->skin >= 0) //ents with negative skins are networked too. eg ladder volumes.
|
|
continue;
|
|
|
|
if (cameras) //self doesn't get a pvs test, to cover teleporters
|
|
{
|
|
if ((int)ent->v->effects & EF_NODEPTHTEST)
|
|
tracecullent = NULL;
|
|
else if ((pvsflags & PVSF_MODE_MASK) < PVSF_USEPHS)
|
|
{
|
|
//branch out to the pvs testing.
|
|
if (ent->xv->tag_entity)
|
|
{
|
|
int c = 10;
|
|
tracecullent = ent;
|
|
while(tracecullent->xv->tag_entity&&c-->0)
|
|
{
|
|
tracecullent = EDICT_NUM_UB(svprogfuncs, tracecullent->xv->tag_entity);
|
|
}
|
|
if (tracecullent == clent)
|
|
tracecullent = NULL;
|
|
else if (tracecullent->xv->viewmodelforclient)
|
|
{
|
|
//special hack so viewmodelforclient on the root of the tagged entity overrides pvs
|
|
if (tracecullent->xv->viewmodelforclient != (clent?EDICT_TO_PROG(svprogfuncs, clent):0))
|
|
continue;
|
|
tracecullent = NULL; //don't tracecull
|
|
}
|
|
else
|
|
{
|
|
if (!sv.world.worldmodel->funcs.EdictInFatPVS(sv.world.worldmodel, &((wedict_t*)tracecullent)->pvsinfo, cameras->pvs.buffer, cameras->area))
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!sv.world.worldmodel->funcs.EdictInFatPVS(sv.world.worldmodel, &((wedict_t*)ent)->pvsinfo, cameras->pvs.buffer, cameras->area))
|
|
continue;
|
|
tracecullent = ent;
|
|
}
|
|
}
|
|
else if ((pvsflags & PVSF_MODE_MASK) == PVSF_USEPHS && sv.world.worldmodel->fromgame == fg_quake)
|
|
{
|
|
int cluster;
|
|
unsigned char *mask;
|
|
qbyte *phs = sv.world.worldmodel->phs;
|
|
if (phs)
|
|
{
|
|
//FIXME: this lookup should be cachable or something.
|
|
if (client->edict)
|
|
cluster = sv.world.worldmodel->funcs.ClusterForPoint(sv.world.worldmodel, client->edict->v->origin, NULL); //ignore areas, can hear through doors.
|
|
else
|
|
cluster = -1; //mvd
|
|
if (cluster >= 0)
|
|
{
|
|
mask = phs + cluster * 4*((sv.world.worldmodel->numclusters+31)>>5);
|
|
|
|
cluster = sv.world.worldmodel->funcs.ClusterForPoint (sv.world.worldmodel, ent->v->origin, NULL);
|
|
if (cluster >= 0 && !(mask[cluster>>3] & (1<<(cluster&7)) ) )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
tracecullent = NULL;
|
|
}
|
|
else
|
|
tracecullent = NULL;
|
|
|
|
if (client->gibfilter && SV_GibFilter(ent))
|
|
continue;
|
|
|
|
#ifdef VM_Q1
|
|
//mvdsv compat
|
|
if (client->hideentity && EDICT_TO_PROG(svprogfuncs, ent) == client->hideentity)
|
|
continue;
|
|
if (client->hideplayers && e <= sv.allocated_client_slots)
|
|
continue;
|
|
#endif
|
|
}
|
|
else
|
|
tracecullent = NULL;
|
|
}
|
|
|
|
//DP_SV_NODRAWONLYTOCLIENT
|
|
if (ent->xv->nodrawtoclient) //DP extension.
|
|
if (client->edict && ent->xv->nodrawtoclient == EDICT_TO_PROG(svprogfuncs, client->edict))
|
|
continue;
|
|
//DP_SV_DRAWONLYTOCLIENT
|
|
if (ent->xv->drawonlytoclient)
|
|
if (!client->edict || ent->xv->drawonlytoclient != EDICT_TO_PROG(svprogfuncs, client->edict))
|
|
{
|
|
client_t *split;
|
|
for (split = client->controlled; split; split=split->controlled)
|
|
{
|
|
if (split->edict->xv->view2 == EDICT_TO_PROG(svprogfuncs, ent))
|
|
break;
|
|
}
|
|
if (!split)
|
|
continue;
|
|
}
|
|
|
|
//QSG_DIMENSION_PLANES
|
|
if (clent) //don't crash
|
|
if (!((int)clent->xv->dimension_see & ((int)ent->xv->dimension_seen | (int)ent->xv->dimension_ghost))) //not able to see it.
|
|
if (c >= maxc) //always network the player entity though
|
|
continue;
|
|
|
|
|
|
if (cameras && tracecullent && !((unsigned int)ent->v->effects & (EF_DIMLIGHT|EF_BLUE|EF_RED|EF_BRIGHTLIGHT|EF_BRIGHTFIELD|EF_NODEPTHTEST)))
|
|
{ //more expensive culling
|
|
if ((e <= sv.allocated_client_slots && sv_cullplayers_trace.value) || sv_cullentities_trace.value)
|
|
if (Cull_Traceline(e < client->lastseen_count?&client->lastseen_time[e]:NULL, cameras, tracecullent))
|
|
continue;
|
|
}
|
|
|
|
//EXT_CSQC
|
|
if (SV_AddCSQCUpdate(client, ent)) //csqc took it.
|
|
continue;
|
|
|
|
if (ISQWCLIENT(client))
|
|
{
|
|
if (SV_AddNailUpdate (ent))
|
|
continue; // added to the special update list
|
|
}
|
|
|
|
//the entity would mess up the client and possibly disconnect them.
|
|
//FIXME: add an option to drop clients... entity fog could be killed in this way.
|
|
if (e >= client->max_net_ents)
|
|
continue;
|
|
if (ent->v->modelindex >= client->maxmodels)
|
|
continue;
|
|
#ifdef DEPTHOPTIMISE
|
|
if (clent)
|
|
{
|
|
//find distance based upon absolute mins/maxs so bsps are treated fairly.
|
|
//org = clentorg + -0.5*(max+min)
|
|
VectorAdd(ent->v->absmin, ent->v->absmax, org);
|
|
VectorMA(clent->v->origin, -0.5, org, org);
|
|
dist = DotProduct(org, org); //Length
|
|
|
|
// if (dist > 1024*1024)
|
|
// continue;
|
|
|
|
// add to the packetentities
|
|
if (pack->num_entities == pack->max_entities)
|
|
{
|
|
float furthestdist = -1;
|
|
int best=-1;
|
|
for (i = 0; i < pack->max_entities; i++)
|
|
if (furthestdist < distances[i])
|
|
{
|
|
furthestdist = distances[i];
|
|
best = i;
|
|
}
|
|
|
|
if (furthestdist > dist && best != -1)
|
|
{
|
|
state = &pack->entities[best];
|
|
// Con_Printf("Dropping ent %s\n", sv.model_precache[state->modelindex]);
|
|
memmove(&distances[best], &distances[best+1], sizeof(*distances)*(pack->num_entities-best-1));
|
|
memmove(state, state+1, sizeof(*state)*(pack->num_entities-best-1));
|
|
|
|
best = pack->num_entities-1;
|
|
|
|
distances[best] = dist;
|
|
state = &pack->entities[best];
|
|
}
|
|
else
|
|
continue; // all full
|
|
}
|
|
else
|
|
{
|
|
state = &pack->entities[pack->num_entities];
|
|
distances[pack->num_entities] = dist;
|
|
pack->num_entities++;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
// add to the packetentities
|
|
if (pack->num_entities == pack->max_entities)
|
|
continue; // all full
|
|
else
|
|
{
|
|
state = &pack->entities[pack->num_entities];
|
|
pack->num_entities++;
|
|
}
|
|
}
|
|
|
|
//its not a nail or anything, pack it up and ship it on
|
|
SV_Snapshot_BuildStateQ1(state, ent, client, pack);
|
|
}
|
|
}
|
|
|
|
void SV_AddCameraEntity(pvscamera_t *cameras, edict_t *ent, pvec3_t viewofs)
|
|
{
|
|
int i;
|
|
vec3_t org;
|
|
int area;
|
|
|
|
for (i = 0; i < cameras->numents; i++)
|
|
{
|
|
if (cameras->ent[i] == ent)
|
|
return; //don't add the same ent multiple times (.view2 or portals that can see themselves through other portals).
|
|
}
|
|
|
|
if (ent)
|
|
{
|
|
if (viewofs)
|
|
VectorAdd (ent->v->origin, viewofs, org);
|
|
else
|
|
VectorCopy (ent->v->origin, org);
|
|
}
|
|
else
|
|
VectorCopy (viewofs, org);
|
|
|
|
sv.world.worldmodel->funcs.ClusterForPoint(sv.world.worldmodel, org, &area);
|
|
for (i = 1; ; i++)
|
|
{
|
|
if (i > cameras->area[0])
|
|
{ //reached the end of the known count. add it now.
|
|
cameras->area[++cameras->area[0]] = area;
|
|
break;
|
|
}
|
|
if (cameras->area[i] == area)
|
|
break; //already have a camera in this area, don't make stuff slow with dupes.
|
|
}
|
|
sv.world.worldmodel->funcs.FatPVS(sv.world.worldmodel, org, &cameras->pvs, cameras->numents!=0);
|
|
if (cameras->numents < SV_PVS_CAMERAS)
|
|
{
|
|
cameras->ent[cameras->numents] = ent;
|
|
VectorCopy(org, cameras->org[cameras->numents]);
|
|
cameras->numents++;
|
|
}
|
|
}
|
|
|
|
void SV_Snapshot_SetupPVS(client_t *client, pvscamera_t *camera)
|
|
{
|
|
camera->area[0] = 0;
|
|
camera->numents = 0;
|
|
for (; client; client = client->controlled)
|
|
{
|
|
if (client->viewent) //svc_viewentity hack
|
|
SV_AddCameraEntity(camera, EDICT_NUM_UB(svprogfuncs, client->viewent), client->edict->v->view_ofs);
|
|
else
|
|
SV_AddCameraEntity(camera, client->edict, client->edict->v->view_ofs);
|
|
|
|
//spectators should always see their targetted player
|
|
if (client->spec_track)
|
|
SV_AddCameraEntity(camera, EDICT_NUM_UB(svprogfuncs, client->spec_track), client->edict->v->view_ofs);
|
|
|
|
//view2 support should always see the extra entity
|
|
if (client->edict->xv->view2)
|
|
SV_AddCameraEntity(camera, PROG_TO_EDICT(svprogfuncs, client->edict->xv->view2), NULL);
|
|
}
|
|
|
|
//hack for skyrooms, open up the pvs.
|
|
if (sv.skyroom_pos_known)
|
|
SV_AddCameraEntity(camera, NULL, sv.skyroom_pos);
|
|
}
|
|
|
|
void SV_Snapshot_Clear(packet_entities_t *pack)
|
|
{
|
|
pack->num_entities = 0;
|
|
|
|
csqcnuments = 0;
|
|
numnails = 0;
|
|
}
|
|
|
|
#ifdef QWOVERQ3
|
|
/*
|
|
=============
|
|
SVQ3Q1_BuildEntityPacket
|
|
|
|
Builds a temporary q1 style entity packet for a q3 client
|
|
=============
|
|
*/
|
|
void SVQ3Q1_BuildEntityPacket(client_t *client, packet_entities_t *pack)
|
|
{
|
|
pvscamera_t cameras;
|
|
SV_Snapshot_Clear(pack);
|
|
SV_Snapshot_SetupPVS(client, &cameras);
|
|
SV_Snapshot_BuildQ1(client, pack, &cameras, client->edict);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
=============
|
|
SV_WriteEntitiesToClient
|
|
|
|
Encodes the current state of the world as
|
|
a svc_packetentities messages and possibly
|
|
a svc_nails message and
|
|
svc_playerinfo messages
|
|
=============
|
|
*/
|
|
void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignorepvs)
|
|
{
|
|
int i;
|
|
packet_entities_t *pack;
|
|
edict_t *clent;
|
|
client_frame_t *frame;
|
|
pvscamera_t camerasbuf;
|
|
pvscamera_t *cameras = &camerasbuf;
|
|
cameras->pvs.buffer = alloca(cameras->pvs.buffersize=sv.world.worldmodel->pvsbytes);
|
|
|
|
// this is the frame we are creating
|
|
frame = &client->frameunion.frames[client->netchan.incoming_sequence & UPDATE_MASK];
|
|
for (i = 0; i < sv.allocated_client_slots; i++)
|
|
frame->laggedplayer[i].present = 0;
|
|
|
|
// find the client's PVS
|
|
if (ignorepvs)
|
|
{ //mvd...
|
|
clent = NULL;
|
|
cameras = NULL;
|
|
}
|
|
else
|
|
{
|
|
clent = client->edict;
|
|
if (sv_nopvs.ival)
|
|
cameras = NULL;
|
|
#ifdef HLSERVER
|
|
else if (svs.gametype == GT_HALFLIFE)
|
|
SVHL_Snapshot_SetupPVS(client, cameras->pvs, sizeof(cameras->pvs));
|
|
#endif
|
|
else
|
|
SV_Snapshot_SetupPVS(client, cameras);
|
|
}
|
|
|
|
host_client = client;
|
|
if ((client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS) || !frame->qwentities.entities || ISNQCLIENT(client))
|
|
{
|
|
pack = &svs.entstatebuffer;
|
|
if (pack->max_entities < client->max_net_ents)
|
|
{
|
|
pack->max_entities = client->max_net_ents;
|
|
pack->entities = BZ_Realloc(pack->entities, sizeof(*pack->entities) * pack->max_entities);
|
|
memset(pack->entities, 0, sizeof(entity_state_t) * pack->max_entities);
|
|
}
|
|
}
|
|
else
|
|
pack = &frame->qwentities;
|
|
SV_Snapshot_Clear(pack);
|
|
|
|
if (!pack->entities)
|
|
return;
|
|
|
|
// put other visible entities into either a packet_entities or a nails message
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
if (sv.demostatevalid) //generate info from demo stats
|
|
{
|
|
SV_Snapshot_Build_Playback(client, pack);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
#ifdef HLSERVER
|
|
if (svs.gametype == GT_HALFLIFE)
|
|
SVHL_Snapshot_Build(client, pack, cameras->pvs, clent, ignorepvs);
|
|
else
|
|
#endif
|
|
SV_Snapshot_BuildQ1(client, pack, cameras, clent);
|
|
}
|
|
|
|
#ifdef NQPROT
|
|
if (ISNQCLIENT(client))
|
|
{
|
|
if (client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS)
|
|
{
|
|
qboolean overflow;
|
|
for (;;)
|
|
{
|
|
overflow = SVFTE_EmitPacketEntities(client, pack, msg);
|
|
client->netchan.incoming_sequence++;
|
|
|
|
if (overflow && pack == &svs.entstatebuffer)
|
|
{
|
|
if (!Netchan_CanPacket(&client->netchan, SV_RateForClient(client)/2))
|
|
break;
|
|
Netchan_Transmit (&client->netchan, msg->cursize, msg->data, SV_RateForClient(client));
|
|
SZ_Clear(msg);
|
|
if (!Netchan_CanPacket(&client->netchan, SV_RateForClient(client)/2))
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
else if (client->protocol == SCP_DARKPLACES6 || client->protocol == SCP_DARKPLACES7)
|
|
SVDP_EmitEntitiesUpdate(client, frame, pack, msg);
|
|
else
|
|
{
|
|
int e;
|
|
for (e = 0; e < pack->num_entities; e++)
|
|
{
|
|
if (pack->entities[e].number > sv.allocated_client_slots)
|
|
break;
|
|
if (msg->cursize + 32 > msg->maxsize)
|
|
break;
|
|
SVNQ_EmitEntityState(msg, &pack->entities[e]);
|
|
}
|
|
for (; e < pack->num_entities; e++)
|
|
{
|
|
if (msg->cursize + 32 + client->datagram.cursize > msg->maxsize)
|
|
break;
|
|
SVNQ_EmitEntityState(msg, &pack->entities[e]);
|
|
}
|
|
client->netchan.incoming_sequence++;
|
|
}
|
|
SV_EmitCSQCUpdate(client, msg, svcdp_csqcentities);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
// encode the packet entities as a delta from the
|
|
// last packetentities acknowledged by the client
|
|
|
|
if (client->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS)
|
|
{
|
|
SVFTE_EmitPacketEntities(client, pack, msg);
|
|
}
|
|
else
|
|
{
|
|
#ifdef QUAKESTATS
|
|
// Z_EXT_TIME protocol extension
|
|
// every now and then, send an update so that extrapolation
|
|
// on client side doesn't stray too far off
|
|
if (ISQWCLIENT(client))
|
|
{
|
|
if ((client->fteprotocolextensions & PEXT_ACCURATETIMINGS )&& sv.world.physicstime - client->nextservertimeupdate > 0)
|
|
{ //the fte pext causes the server to send out accurate timings, allowing for perfect interpolation.
|
|
MSG_WriteByte (msg, svcqw_updatestatlong);
|
|
MSG_WriteByte (msg, STAT_TIME);
|
|
MSG_WriteLong (msg, (int)(sv.world.physicstime * 1000));
|
|
|
|
client->nextservertimeupdate = sv.world.physicstime;
|
|
}
|
|
else if ((client->zquake_extensions & Z_EXT_SERVERTIME) && sv.world.physicstime - client->nextservertimeupdate > 0)
|
|
{ //the zquake ext causes the server to send out peridoic timings, allowing for moderatly accurate game time.
|
|
MSG_WriteByte (msg, svcqw_updatestatlong);
|
|
MSG_WriteByte (msg, STAT_TIME);
|
|
MSG_WriteLong (msg, (int)(sv.world.physicstime * 1000));
|
|
|
|
client->nextservertimeupdate = sv.world.physicstime+10;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// send over the players in the PVS
|
|
if (svs.gametype != GT_HALFLIFE)
|
|
{
|
|
#ifdef MVD_RECORDING
|
|
if (client == &demo.recorder)
|
|
SV_WritePlayersToMVD(client, frame, msg);
|
|
else
|
|
#endif
|
|
SV_WritePlayersToClient (client, frame, clent, cameras, msg);
|
|
}
|
|
|
|
SVQW_EmitPacketEntities (client, pack, msg);
|
|
}
|
|
|
|
SV_EmitCSQCUpdate(client, msg, svcfte_csqcentities);
|
|
|
|
// now add the specialized nail update
|
|
SV_EmitNailUpdate (msg, ignorepvs);
|
|
}
|
|
}
|
|
|
|
//just goes and makes sure each client tracks all the right SendFlags.
|
|
void SV_ProcessSendFlags(client_t *c)
|
|
{
|
|
edict_t *ent;
|
|
unsigned int e, h = 0;
|
|
if (!c->csqcactive || !c->pendingcsqcbits)
|
|
return;
|
|
for (e=1 ; e<sv.world.num_edicts && e < c->max_net_ents; e++)
|
|
{
|
|
ent = EDICT_NUM_PB(svprogfuncs, e);
|
|
if (ED_ISFREE(ent))
|
|
continue;
|
|
if (ent->xv->SendFlags)
|
|
{
|
|
c->pendingcsqcbits[e] |= (int)ent->xv->SendFlags & SENDFLAGS_USABLE;
|
|
h = e;
|
|
}
|
|
}
|
|
needcleanup = max(needcleanup, h);
|
|
}
|
|
void SV_CleanupEnts(void)
|
|
{
|
|
int e;
|
|
edict_t *ent;
|
|
|
|
if (!needcleanup)
|
|
return;
|
|
|
|
for (e=1 ; e<=needcleanup ; e++)
|
|
{
|
|
ent = EDICT_NUM_PB(svprogfuncs, e);
|
|
ent->xv->SendFlags = 0;
|
|
|
|
#ifdef HAVE_LEGACY
|
|
//this is legacy code. we'll just have to live with the slight delay.
|
|
//FIXME: check if Version exists and do it earlier.
|
|
if ((int)ent->xv->Version != sv.csqcentversion[ent->entnum])
|
|
{
|
|
ent->xv->SendFlags = SENDFLAGS_USABLE;
|
|
sv.csqcentversion[ent->entnum] = (int)ent->xv->Version;
|
|
}
|
|
#endif
|
|
}
|
|
needcleanup=0;
|
|
}
|
|
#endif
|
|
|