sv_send.c File Reference

#include "quakedef.h"
#include "sv_demo.h"

Include dependency graph for sv_send.c:

Go to the source code of this file.

Macros
#define	MAX_LINEOFSIGHTTRACES   64

Functions
void	SV_AddCameraEyes (void)
void	SV_BroadcastPrint (const char *msg)
void	SV_BroadcastPrintf (const char *fmt,...)
qbool	SV_CanSeeBox (int numtraces, vec_t eyejitter, vec_t enlarge, vec_t entboxexpand, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
static void	SV_CleanupEnts (void)
void	SV_ClientCommands (const char *fmt,...)
void	SV_ClientPrint (const char *msg)
void	SV_ClientPrintf (const char *fmt,...)
void	SV_FlushBroadcastMessages (void)
void	SV_MarkWriteEntityStateToClient (entity_state_t *s, client_t *client)
static void	SV_PrepareEntitiesForSending (void)
static qbool	SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int enumber)
static void	SV_SendClientDatagram (client_t *client)
void	SV_SendClientMessages (void)
void	SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
void	SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
void	SV_StartPointSound (vec3_t origin, const char *sample, int nvolume, float attenuation, float speed)
void	SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int nvolume, float attenuation, qbool reliable, float speed)
static void	SV_UpdateToReliableMessages (void)
void	SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
static void	SV_WriteUnreliableMessages (client_t *client, sizebuf_t *msg, int maxsize, int maxsize2)

Variables
cvar_t	sv_airaccel_qw_stretchfactor
cvar_t	sv_cullentities_trace_delay_players
cvar_t	sv_cullentities_trace_entityocclusion
cvar_t	sv_cullentities_trace_expand
cvar_t	sv_cullentities_trace_eyejitter
cvar_t	sv_cullentities_trace_samples_players
cvar_t	sv_cullentities_trace_spectators
cvar_t	sv_onlycsqcnetworking
cvar_t	sv_qcstats
cvar_t	sv_warsowbunny_accel
cvar_t	sv_warsowbunny_airforwardaccel
cvar_t	sv_warsowbunny_backtosideratio
cvar_t	sv_warsowbunny_topspeed
cvar_t	sv_warsowbunny_turnaccel

Macro Definition Documentation

MAX_LINEOFSIGHTTRACES

#define MAX_LINEOFSIGHTTRACES   64

Definition at line 721 of file sv_send.c.

Referenced by SV_CanSeeBox().

Function Documentation

SV_AddCameraEyes()

void SV_AddCameraEyes

(

void

)

Definition at line 1063 of file sv_send.c.

{
}

Referenced by SV_WriteEntitiesToClient().

SV_BroadcastPrint()

void SV_BroadcastPrint

(

const char *

msg

)

Definition at line 91 of file sv_send.c.

{
    int i;
    client_t *client;
 
    for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
    {
        if (client->active && client->netconnection)
        {
            MSG_WriteByte(&client->netconnection->message, svc_print);
            MSG_WriteString(&client->netconnection->message, msg);
        }
    }
 
    if (sv_echobprint.integer && !host_isclient.integer)
        Con_Print(msg);
}

References client_t::active, server_static_t::clients, Con_Print(), host_isclient, i, cvar_t::integer, server_static_t::maxclients, netconn_t::message, MSG_WriteByte(), MSG_WriteString(), client_t::netconnection, sv_echobprint, svc_print, and svs.

Referenced by SV_BroadcastPrintf(), and VM_bprint().

SV_BroadcastPrintf()

void SV_BroadcastPrintf	(	const char *	fmt,
			... )

Definition at line 116 of file sv_send.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    SV_BroadcastPrint(msg);
}

References dpvsnprintf(), MAX_INPUTLINE, and SV_BroadcastPrint().

Referenced by Cvar_SetQuick_Internal(), SV_DropClient(), SV_Frame(), SV_Name(), and SV_Pause_f().

SV_CanSeeBox()

qbool SV_CanSeeBox	(	int	numtraces,
		vec_t	eyejitter,
		vec_t	enlarge,
		vec_t	entboxexpand,
		vec3_t	eye,
		vec3_t	entboxmins,
		vec3_t	entboxmaxs )

Definition at line 723 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    float pitchsign;
    float alpha;
    float starttransformed[3], endtransformed[3];
    float boxminstransformed[3], boxmaxstransformed[3];
    float localboxcenter[3], localboxextents[3], localboxmins[3], localboxmaxs[3];
    int blocked = 0;
    int traceindex;
    int originalnumtouchedicts;
    int numtouchedicts = 0;
    int touchindex;
    matrix4x4_t matrix, imatrix;
    model_t *model;
    prvm_edict_t *touch;
    static prvm_edict_t *touchedicts[MAX_EDICTS];
    vec3_t eyemins, eyemaxs, start;
    vec3_t boxmins, boxmaxs;
    vec3_t clipboxmins, clipboxmaxs;
    vec3_t endpoints[MAX_LINEOFSIGHTTRACES];
 
    numtraces = min(numtraces, MAX_LINEOFSIGHTTRACES);
 
    // jitter the eye location within this box
    eyemins[0] = eye[0] - eyejitter;
    eyemaxs[0] = eye[0] + eyejitter;
    eyemins[1] = eye[1] - eyejitter;
    eyemaxs[1] = eye[1] + eyejitter;
    eyemins[2] = eye[2] - eyejitter;
    eyemaxs[2] = eye[2] + eyejitter;
    // expand the box a little
    boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0] - entboxexpand;
    boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0] + entboxexpand;
    boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1] - entboxexpand;
    boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1] + entboxexpand;
    boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2] - entboxexpand;
    boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2] + entboxexpand;
 
    VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, endpoints[0]);
    for (traceindex = 1;traceindex < numtraces;traceindex++)
        VectorSet(endpoints[traceindex], lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
 
    // calculate sweep box for the entire swarm of traces
    VectorCopy(eyemins, clipboxmins);
    VectorCopy(eyemaxs, clipboxmaxs);
    for (traceindex = 0;traceindex < numtraces;traceindex++)
    {
        clipboxmins[0] = min(clipboxmins[0], endpoints[traceindex][0]);
        clipboxmins[1] = min(clipboxmins[1], endpoints[traceindex][1]);
        clipboxmins[2] = min(clipboxmins[2], endpoints[traceindex][2]);
        clipboxmaxs[0] = max(clipboxmaxs[0], endpoints[traceindex][0]);
        clipboxmaxs[1] = max(clipboxmaxs[1], endpoints[traceindex][1]);
        clipboxmaxs[2] = max(clipboxmaxs[2], endpoints[traceindex][2]);
    }
 
    // get the list of entities in the sweep box
    if (sv_cullentities_trace_entityocclusion.integer)
        numtouchedicts = SV_EntitiesInBox(clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
    if (numtouchedicts > MAX_EDICTS)
    {
        // this never happens
        Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
        numtouchedicts = MAX_EDICTS;
    }
    // iterate the entities found in the sweep box and filter them
    originalnumtouchedicts = numtouchedicts;
    numtouchedicts = 0;
    for (touchindex = 0;touchindex < originalnumtouchedicts;touchindex++)
    {
        touch = touchedicts[touchindex];
        if (PRVM_serveredictfloat(touch, solid) != SOLID_BSP)
            continue;
        model = SV_GetModelFromEdict(touch);
        if (!model || !model->brush.TraceLineOfSight)
            continue;
        // skip obviously transparent entities
        alpha = PRVM_serveredictfloat(touch, alpha);
        if (alpha && alpha < 1)
            continue;
        if ((int)PRVM_serveredictfloat(touch, effects) & EF_ADDITIVE)
            continue;
        touchedicts[numtouchedicts++] = touch;
    }
 
    // now that we have a filtered list of "interesting" entities, fire each
    // ray against all of them, this gives us an early-out case when something
    // is visible (which it often is)
 
    for (traceindex = 0;traceindex < numtraces;traceindex++)
    {
        VectorSet(start, lhrandom(eyemins[0], eyemaxs[0]), lhrandom(eyemins[1], eyemaxs[1]), lhrandom(eyemins[2], eyemaxs[2]));
        // check world occlusion
        if (sv.worldmodel && sv.worldmodel->brush.TraceLineOfSight)
            if (!sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, start, endpoints[traceindex], boxmins, boxmaxs))
                continue;
        for (touchindex = 0;touchindex < numtouchedicts;touchindex++)
        {
            touch = touchedicts[touchindex];
            model = SV_GetModelFromEdict(touch);
            if(model && model->brush.TraceLineOfSight)
            {
                // get the entity matrix
                pitchsign = SV_GetPitchSign(prog, touch);
                Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                // see if the ray hits this entity
                Matrix4x4_Transform(&imatrix, start, starttransformed);
                Matrix4x4_Transform(&imatrix, endpoints[traceindex], endtransformed);
                Matrix4x4_Transform(&imatrix, boxmins, boxminstransformed);
                Matrix4x4_Transform(&imatrix, boxmaxs, boxmaxstransformed);
                // transform the AABB to local space
                VectorMAM(0.5f, boxminstransformed, 0.5f, boxmaxstransformed, localboxcenter);
                localboxextents[0] = fabs(boxmaxstransformed[0] - localboxcenter[0]);
                localboxextents[1] = fabs(boxmaxstransformed[1] - localboxcenter[1]);
                localboxextents[2] = fabs(boxmaxstransformed[2] - localboxcenter[2]);
                localboxmins[0] = localboxcenter[0] - localboxextents[0];
                localboxmins[1] = localboxcenter[1] - localboxextents[1];
                localboxmins[2] = localboxcenter[2] - localboxextents[2];
                localboxmaxs[0] = localboxcenter[0] + localboxextents[0];
                localboxmaxs[1] = localboxcenter[1] + localboxextents[1];
                localboxmaxs[2] = localboxcenter[2] + localboxextents[2];
                if (!model->brush.TraceLineOfSight(model, starttransformed, endtransformed, localboxmins, localboxmaxs))
                {
                    blocked++;
                    break;
                }
            }
        }
        // check if the ray was blocked
        if (touchindex < numtouchedicts)
            continue;
        // return if the ray was not blocked
        return true;
    }
 
    // no rays survived
    return false;
}

References alpha, angles, Con_Printf(), EF_ADDITIVE, effects, fabs(), cvar_t::integer, lhrandom, Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_Invert_Simple(), Matrix4x4_Transform(), max, MAX_EDICTS, MAX_LINEOFSIGHTTRACES, min, model, origin, PRVM_serveredictfloat, PRVM_serveredictvector, solid, SOLID_BSP, sv, sv_cullentities_trace_entityocclusion, SV_EntitiesInBox(), SV_GetModelFromEdict(), SV_GetPitchSign(), SVVM_prog, VectorCopy, VectorMAM, VectorSet, and server_t::worldmodel.

Referenced by SV_MarkWriteEntityStateToClient(), and SV_WriteEntitiesToClient().

SV_CleanupEnts()

static void SV_CleanupEnts ( void )

static

Definition at line 1074 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int     e;
    prvm_edict_t    *ent;
 
    ent = PRVM_NEXT_EDICT(prog->edicts);
    for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
        PRVM_serveredictfloat(ent, effects) = (int)PRVM_serveredictfloat(ent, effects) & ~EF_MUZZLEFLASH;
}

References prvm_prog_t::edicts, effects, int(), prvm_prog_t::num_edicts, PRVM_NEXT_EDICT, PRVM_serveredictfloat, and SVVM_prog.

Referenced by SV_SendClientMessages().

SV_ClientCommands()

void SV_ClientCommands	(	const char *	fmt,
			... )

Definition at line 135 of file sv_send.c.

{
    va_list argptr;
    char string[MAX_INPUTLINE];
 
    if (!host_client->netconnection)
        return;
 
    va_start(argptr,fmt);
    dpvsnprintf(string, sizeof(string), fmt, argptr);
    va_end(argptr);
 
    MSG_WriteByte(&host_client->netconnection->message, svc_stufftext);
    MSG_WriteString(&host_client->netconnection->message, string);
}

References dpvsnprintf(), host_client, MAX_INPUTLINE, netconn_t::message, MSG_WriteByte(), MSG_WriteString(), client_t::netconnection, and svc_stufftext.

Referenced by Curl_SendRequirements(), SV_Download_f(), SV_ReadClientMessage(), SV_SendCvar_f(), and VM_SV_stuffcmd().

SV_ClientPrint()

void SV_ClientPrint

(

const char *

msg

)

Definition at line 55 of file sv_send.c.

{
    if (host_client->netconnection)
    {
        MSG_WriteByte(&host_client->netconnection->message, svc_print);
        MSG_WriteString(&host_client->netconnection->message, msg);
    }
}

References host_client, netconn_t::message, MSG_WriteByte(), MSG_WriteString(), client_t::netconnection, and svc_print.

Referenced by SV_ClientPrintf(), SV_Fly_f(), SV_God_f(), SV_Kill_f(), SV_Noclip_f(), SV_Notarget_f(), SV_Say(), and SV_Tell_f().

SV_ClientPrintf()

void SV_ClientPrintf	(	const char *	fmt,
			... )

Definition at line 72 of file sv_send.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    SV_ClientPrint(msg);
}

References dpvsnprintf(), MAX_INPUTLINE, and SV_ClientPrint().

Referenced by Cmd_SV_Callback(), SV_Download_f(), SV_DropClient(), SV_Ent_Create_f(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), SV_Name_f(), SV_Pause_f(), SV_Ping_f(), and SV_Status_f().

SV_FlushBroadcastMessages()

void SV_FlushBroadcastMessages

(

void

)

Definition at line 1371 of file sv_send.c.

{
    int i;
    client_t *client;
    if (sv.datagram.cursize <= 0)
        return;
    for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
    {
        if (!client->begun || !client->netconnection || client->unreliablemsg.cursize + sv.datagram.cursize > client->unreliablemsg.maxsize || client->unreliablemsg_splitpoints >= (int)(sizeof(client->unreliablemsg_splitpoint)/sizeof(client->unreliablemsg_splitpoint[0])))
            continue;
        SZ_Write(&client->unreliablemsg, sv.datagram.data, sv.datagram.cursize);
        client->unreliablemsg_splitpoint[client->unreliablemsg_splitpoints++] = client->unreliablemsg.cursize;
    }
    SZ_Clear(&sv.datagram);
}

References client_t::begun, server_static_t::clients, sizebuf_t::cursize, sizebuf_t::data, server_t::datagram, i, server_static_t::maxclients, sizebuf_t::maxsize, client_t::netconnection, sv, svs, SZ_Clear(), SZ_Write(), client_t::unreliablemsg, client_t::unreliablemsg_splitpoint, and client_t::unreliablemsg_splitpoints.

Referenced by CLVM_ExecuteProgram(), SV_SendClientMessages(), SV_StartEffect(), SV_StartParticle(), SV_StartPointSound(), SV_StartSound(), SVVM_ExecuteProgram(), VM_SV_pointparticles(), VM_SV_te_beam(), VM_SV_te_blood(), VM_SV_te_bloodshower(), VM_SV_te_customflash(), VM_SV_te_explosion(), VM_SV_te_explosion2(), VM_SV_te_explosionquad(), VM_SV_te_explosionrgb(), VM_SV_te_flamejet(), VM_SV_te_gunshot(), VM_SV_te_gunshotquad(), VM_SV_te_knightspike(), VM_SV_te_lavasplash(), VM_SV_te_lightning1(), VM_SV_te_lightning2(), VM_SV_te_lightning3(), VM_SV_te_particlecube(), VM_SV_te_particlerain(), VM_SV_te_particlesnow(), VM_SV_te_plasmaburn(), VM_SV_te_smallflash(), VM_SV_te_spark(), VM_SV_te_spike(), VM_SV_te_spikequad(), VM_SV_te_superspike(), VM_SV_te_superspikequad(), VM_SV_te_tarexplosion(), VM_SV_te_teleport(), VM_SV_te_wizspike(), and VM_SV_trailparticles().

SV_MarkWriteEntityStateToClient()

void SV_MarkWriteEntityStateToClient	(	entity_state_t *	s,
		client_t *	client )

Definition at line 863 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int isbmodel;
    model_t *model;
    prvm_edict_t *ed;
    if (sv.sententitiesconsideration[s->number] == sv.sententitiesmark)
        return;
    sv.sententitiesconsideration[s->number] = sv.sententitiesmark;
    sv.writeentitiestoclient_stats_totalentities++;
 
    if (s->customizeentityforclient)
    {
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = s->number;
        PRVM_serverglobaledict(other) = sv.writeentitiestoclient_cliententitynumber;
        prog->ExecuteProgram(prog, s->customizeentityforclient, "customizeentityforclient: NULL function");
        if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
            return;
    }
 
    // never reject player
    if (s->number != sv.writeentitiestoclient_cliententitynumber)
    {
        // check various rejection conditions
        if (s->nodrawtoclient == sv.writeentitiestoclient_cliententitynumber)
            return;
        if (s->drawonlytoclient && s->drawonlytoclient != sv.writeentitiestoclient_cliententitynumber)
            return;
        if (s->effects & EF_NODRAW)
            return;
        // LadyHavoc: only send entities with a model or important effects
        if (!s->modelindex && s->specialvisibilityradius == 0)
            return;
 
        isbmodel = (model = SV_GetModelByIndex(s->modelindex)) != NULL && model->name[0] == '*';
        // viewmodels don't have visibility checking
        if (s->viewmodelforclient)
        {
            if (s->viewmodelforclient != sv.writeentitiestoclient_cliententitynumber)
                return;
        }
        else if (s->tagentity)
        {
            // tag attached entities simply check their parent
            if (!sv.sendentitiesindex[s->tagentity])
                return;
            SV_MarkWriteEntityStateToClient(sv.sendentitiesindex[s->tagentity], client);
            if (sv.sententities[s->tagentity] != sv.sententitiesmark)
                return;
        }
        // always send world submodels in newer protocols because they don't
        // generate much traffic (in old protocols they hog bandwidth)
        // but only if sv_cullentities_nevercullbmodels is off
        else if (!(s->effects & EF_NODEPTHTEST) && (!isbmodel || !sv_cullentities_nevercullbmodels.integer || sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE))
        {
            // entity has survived every check so far, check if visible
            ed = PRVM_EDICT_NUM(s->number);
 
            // if not touching a visible leaf
            if (sv_cullentities_pvs.integer && !r_novis.integer && !r_trippy.integer && sv.writeentitiestoclient_pvs)
            {
                if (ed->priv.server->pvs_numclusters < 0)
                {
                    // entity too big for clusters list
                    if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv.writeentitiestoclient_pvs, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
                    {
                        sv.writeentitiestoclient_stats_culled_pvs++;
                        return;
                    }
                }
                else
                {
                    int i;
                    // check cached clusters list
                    for (i = 0;i < ed->priv.server->pvs_numclusters;i++)
                        if (CHECKPVSBIT(sv.writeentitiestoclient_pvs, ed->priv.server->pvs_clusterlist[i]))
                            break;
                    if (i == ed->priv.server->pvs_numclusters)
                    {
                        sv.writeentitiestoclient_stats_culled_pvs++;
                        return;
                    }
                }
            }
 
            // or not seen by random tracelines
            if (sv_cullentities_trace.integer && !isbmodel && sv.worldmodel && sv.worldmodel->brush.TraceLineOfSight && !r_trippy.integer && (client->frags != -666 || sv_cullentities_trace_spectators.integer))
            {
                int samples =
                    s->number <= svs.maxclients
                        ? sv_cullentities_trace_samples_players.integer
                        :
                    s->specialvisibilityradius
                        ? sv_cullentities_trace_samples_extra.integer
                        : sv_cullentities_trace_samples.integer;
 
                if(samples > 0)
                {
                    int eyeindex;
                    for (eyeindex = 0;eyeindex < sv.writeentitiestoclient_numeyes;eyeindex++)
                        if(SV_CanSeeBox(samples, sv_cullentities_trace_eyejitter.value, sv_cullentities_trace_enlarge.value, sv_cullentities_trace_expand.value, sv.writeentitiestoclient_eyes[eyeindex], ed->priv.server->cullmins, ed->priv.server->cullmaxs))
                            break;
                    if(eyeindex < sv.writeentitiestoclient_numeyes)
                        svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number] =
                            host.realtime + (
                                s->number <= svs.maxclients
                                    ? sv_cullentities_trace_delay_players.value
                                    : sv_cullentities_trace_delay.value
                            );
                    else if ((float)host.realtime > svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number])
                    {
                        sv.writeentitiestoclient_stats_culled_trace++;
                        return;
                    }
                }
            }
        }
    }
 
    // this just marks it for sending
    // FIXME: it would be more efficient to send here, but the entity
    // compressor isn't that flexible
    sv.writeentitiestoclient_stats_visibleentities++;
    sv.sententities[s->number] = sv.sententitiesmark;
}

References CHECKPVSBIT, server_static_t::clients, entity_state_t::customizeentityforclient, entity_state_t::drawonlytoclient, EF_NODEPTHTEST, EF_NODRAW, entity_state_t::effects, prvm_prog_t::ExecuteProgram, client_t::frags, host, i, cvar_t::integer, server_static_t::maxclients, model, entity_state_t::modelindex, entity_state_t::nodrawtoclient, NULL, entity_state_t::number, OFS_RETURN, other, prvm_edict_t::priv, server_t::protocol, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PRVM_EDICT_NUM, PRVM_G_FLOAT, PRVM_serverglobaledict, PRVM_serverglobalfloat, r_novis, r_trippy, host_static_t::realtime, samples, self, server_t::sendentitiesindex, server_t::sententities, server_t::sententitiesconsideration, server_t::sententitiesmark, prvm_edict_t::server, entity_state_t::specialvisibilityradius, sv, SV_CanSeeBox(), sv_cullentities_nevercullbmodels, sv_cullentities_pvs, sv_cullentities_trace, sv_cullentities_trace_delay, sv_cullentities_trace_delay_players, sv_cullentities_trace_enlarge, sv_cullentities_trace_expand, sv_cullentities_trace_eyejitter, sv_cullentities_trace_samples, sv_cullentities_trace_samples_extra, sv_cullentities_trace_samples_players, sv_cullentities_trace_spectators, SV_GetModelByIndex(), SV_MarkWriteEntityStateToClient(), SV_PrepareEntityForSending(), svs, SVVM_prog, entity_state_t::tagentity, server_t::time, time, cvar_t::value, entity_state_t::viewmodelforclient, server_t::worldmodel, server_t::writeentitiestoclient_cliententitynumber, server_t::writeentitiestoclient_clientnumber, server_t::writeentitiestoclient_eyes, server_t::writeentitiestoclient_numeyes, server_t::writeentitiestoclient_pvs, server_t::writeentitiestoclient_stats_culled_pvs, server_t::writeentitiestoclient_stats_culled_trace, server_t::writeentitiestoclient_stats_totalentities, and server_t::writeentitiestoclient_stats_visibleentities.

Referenced by SV_MarkWriteEntityStateToClient(), and SV_WriteEntitiesToClient().

SV_PrepareEntitiesForSending()

static void SV_PrepareEntitiesForSending ( void )

static

Definition at line 702 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int e;
    prvm_edict_t *ent;
    // send all entities that touch the pvs
    sv.numsendentities = 0;
    sv.sendentitiesindex[0] = NULL;
    memset(sv.sendentitiesindex, 0, prog->num_edicts * sizeof(*sv.sendentitiesindex));
    for (e = 1, ent = PRVM_NEXT_EDICT(prog->edicts);e < prog->num_edicts;e++, ent = PRVM_NEXT_EDICT(ent))
    {
        if (!ent->free && SV_PrepareEntityForSending(ent, sv.sendentities + sv.numsendentities, e))
        {
            sv.sendentitiesindex[e] = sv.sendentities + sv.numsendentities;
            sv.numsendentities++;
        }
    }
}

References prvm_prog_t::edicts, prvm_edict_t::free, NULL, prvm_prog_t::num_edicts, server_t::numsendentities, PRVM_NEXT_EDICT, server_t::sendentities, server_t::sendentitiesindex, sv, SV_PrepareEntityForSending(), and SVVM_prog.

Referenced by SV_SendClientMessages().

SV_PrepareEntityForSending()

static qbool SV_PrepareEntityForSending ( prvm_edict_t * ent, entity_state_t * cs, int enumber )

static

Definition at line 394 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i;
    unsigned int sendflags;
    unsigned int version;
    unsigned int modelindex, effects, flags, glowsize, lightstyle, lightpflags, light[4], specialvisibilityradius;
    unsigned int customizeentityforclient;
    unsigned int sendentity;
    float f;
    prvm_vec_t *v;
    vec3_t cullmins, cullmaxs;
    model_t *model;
 
    // fast path for games that do not use legacy entity networking
    // note: still networks clients even if they are legacy
    sendentity = PRVM_serveredictfunction(ent, SendEntity);
    if (sv_onlycsqcnetworking.integer && !sendentity && enumber > svs.maxclients)
        return false;
 
    // this 2 billion unit check is actually to detect NAN origins
    // (we really don't want to send those)
    if (!(VectorLength2(PRVM_serveredictvector(ent, origin)) < 2000000000.0*2000000000.0))
        return false;
 
    // EF_NODRAW prevents sending for any reason except for your own
    // client, so we must keep all clients in this superset
    effects = (unsigned)PRVM_serveredictfloat(ent, effects);
 
    // we can omit invisible entities with no effects that are not clients
    // LadyHavoc: this could kill tags attached to an invisible entity, I
    // just hope we never have to support that case
    i = (int)PRVM_serveredictfloat(ent, modelindex);
    modelindex = (i >= 1 && i < MAX_MODELS && PRVM_serveredictstring(ent, model) && *PRVM_GetString(prog, PRVM_serveredictstring(ent, model)) && sv.models[i]) ? i : 0;
 
    flags = 0;
    i = (int)(PRVM_serveredictfloat(ent, glow_size) * 0.25f);
    glowsize = (unsigned char)bound(0, i, 255);
    if (PRVM_serveredictfloat(ent, glow_trail))
        flags |= RENDER_GLOWTRAIL;
    if (PRVM_serveredictedict(ent, viewmodelforclient))
        flags |= RENDER_VIEWMODEL;
 
    v = PRVM_serveredictvector(ent, color);
    f = v[0]*256;
    light[0] = (unsigned short)bound(0, f, 65535);
    f = v[1]*256;
    light[1] = (unsigned short)bound(0, f, 65535);
    f = v[2]*256;
    light[2] = (unsigned short)bound(0, f, 65535);
    f = PRVM_serveredictfloat(ent, light_lev);
    light[3] = (unsigned short)bound(0, f, 65535);
    lightstyle = (unsigned char)PRVM_serveredictfloat(ent, style);
    lightpflags = (unsigned char)PRVM_serveredictfloat(ent, pflags);
 
    if (gamemode == GAME_TENEBRAE)
    {
        // tenebrae's EF_FULLDYNAMIC conflicts with Q2's EF_NODRAW
        if (effects & 16)
        {
            effects &= ~16;
            lightpflags |= PFLAGS_FULLDYNAMIC;
        }
        // tenebrae's EF_GREEN conflicts with DP's EF_ADDITIVE
        if (effects & 32)
        {
            effects &= ~32;
            light[0] = (int)(0.2*256);
            light[1] = (int)(1.0*256);
            light[2] = (int)(0.2*256);
            light[3] = 200;
            lightpflags |= PFLAGS_FULLDYNAMIC;
        }
    }
 
    specialvisibilityradius = 0;
    if (lightpflags & PFLAGS_FULLDYNAMIC)
        specialvisibilityradius = max(specialvisibilityradius, light[3]);
    if (glowsize)
        specialvisibilityradius = max(specialvisibilityradius, glowsize * 4);
    if (flags & RENDER_GLOWTRAIL)
        specialvisibilityradius = max(specialvisibilityradius, 100);
    if (effects & (EF_BRIGHTFIELD | EF_MUZZLEFLASH | EF_BRIGHTLIGHT | EF_DIMLIGHT | EF_RED | EF_BLUE | EF_FLAME | EF_STARDUST))
    {
        if (effects & EF_BRIGHTFIELD)
            specialvisibilityradius = max(specialvisibilityradius, 80);
        if (effects & EF_MUZZLEFLASH)
            specialvisibilityradius = max(specialvisibilityradius, 100);
        if (effects & EF_BRIGHTLIGHT)
            specialvisibilityradius = max(specialvisibilityradius, 400);
        if (effects & EF_DIMLIGHT)
            specialvisibilityradius = max(specialvisibilityradius, 200);
        if (effects & EF_RED)
            specialvisibilityradius = max(specialvisibilityradius, 200);
        if (effects & EF_BLUE)
            specialvisibilityradius = max(specialvisibilityradius, 200);
        if (effects & EF_FLAME)
            specialvisibilityradius = max(specialvisibilityradius, 250);
        if (effects & EF_STARDUST)
            specialvisibilityradius = max(specialvisibilityradius, 100);
    }
 
    // early culling checks
    // (final culling is done by SV_MarkWriteEntityStateToClient)
    customizeentityforclient = PRVM_serveredictfunction(ent, customizeentityforclient);
    if (!customizeentityforclient && enumber > svs.maxclients && (!modelindex && !specialvisibilityradius))
        return false;
 
    *cs = defaultstate;
    cs->active = ACTIVE_NETWORK;
    cs->number = enumber;
    VectorCopy(PRVM_serveredictvector(ent, origin), cs->origin);
    VectorCopy(PRVM_serveredictvector(ent, angles), cs->angles);
    cs->flags = flags;
    cs->effects = effects;
    cs->colormap = (unsigned)PRVM_serveredictfloat(ent, colormap);
    cs->modelindex = modelindex;
    cs->skin = (unsigned)PRVM_serveredictfloat(ent, skin);
    cs->frame = (unsigned)PRVM_serveredictfloat(ent, frame);
    cs->viewmodelforclient = PRVM_serveredictedict(ent, viewmodelforclient);
    cs->exteriormodelforclient = PRVM_serveredictedict(ent, exteriormodeltoclient);
    cs->nodrawtoclient = PRVM_serveredictedict(ent, nodrawtoclient);
    cs->drawonlytoclient = PRVM_serveredictedict(ent, drawonlytoclient);
    cs->customizeentityforclient = customizeentityforclient;
    cs->tagentity = PRVM_serveredictedict(ent, tag_entity);
    cs->tagindex = (unsigned char)PRVM_serveredictfloat(ent, tag_index);
    cs->glowsize = glowsize;
    cs->traileffectnum = PRVM_serveredictfloat(ent, traileffectnum);
 
    // don't need to init cs->colormod because the defaultstate did that for us
    //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
    v = PRVM_serveredictvector(ent, colormod);
    if (VectorLength2(v))
    {
        i = (int)(v[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
        i = (int)(v[1] * 32.0f);cs->colormod[1] = bound(0, i, 255);
        i = (int)(v[2] * 32.0f);cs->colormod[2] = bound(0, i, 255);
    }
 
    // don't need to init cs->glowmod because the defaultstate did that for us
    //cs->glowmod[0] = cs->glowmod[1] = cs->glowmod[2] = 32;
    v = PRVM_serveredictvector(ent, glowmod);
    if (VectorLength2(v))
    {
        i = (int)(v[0] * 32.0f);cs->glowmod[0] = bound(0, i, 255);
        i = (int)(v[1] * 32.0f);cs->glowmod[1] = bound(0, i, 255);
        i = (int)(v[2] * 32.0f);cs->glowmod[2] = bound(0, i, 255);
    }
 
    cs->modelindex = modelindex;
 
    cs->alpha = 255;
    f = (PRVM_serveredictfloat(ent, alpha) * 255.0f);
    if (f)
    {
        i = (int)f;
        cs->alpha = (unsigned char)bound(0, i, 255);
    }
    // halflife
    f = (PRVM_serveredictfloat(ent, renderamt));
    if (f)
    {
        i = (int)f;
        cs->alpha = (unsigned char)bound(0, i, 255);
    }
 
    cs->scale = 16;
    f = (PRVM_serveredictfloat(ent, scale) * 16.0f);
    if (f)
    {
        i = (int)f;
        cs->scale = (unsigned char)bound(0, i, 255);
    }
 
    cs->glowcolor = 254;
    f = PRVM_serveredictfloat(ent, glow_color);
    if (f)
        cs->glowcolor = (int)f;
 
    if (PRVM_serveredictfloat(ent, fullbright))
        cs->effects |= EF_FULLBRIGHT;
 
    f = PRVM_serveredictfloat(ent, modelflags);
    if (f)
        cs->effects |= ((unsigned int)f & 0xff) << 24;
 
    if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_STEP || ((int)PRVM_serveredictfloat(ent, flags) & FL_MONSTER))
        cs->flags |= RENDER_STEP;
    if (cs->number != sv.writeentitiestoclient_cliententitynumber && (cs->effects & EF_LOWPRECISION) && cs->origin[0] >= -32768 && cs->origin[1] >= -32768 && cs->origin[2] >= -32768 && cs->origin[0] <= 32767 && cs->origin[1] <= 32767 && cs->origin[2] <= 32767)
        cs->flags |= RENDER_LOWPRECISION;
    if (PRVM_serveredictfloat(ent, colormap) >= 1024)
        cs->flags |= RENDER_COLORMAPPED;
    if (cs->viewmodelforclient)
        cs->flags |= RENDER_VIEWMODEL; // show relative to the view
 
    if (PRVM_serveredictfloat(ent, sendcomplexanimation))
    {
        cs->flags |= RENDER_COMPLEXANIMATION;
        if (PRVM_serveredictfloat(ent, skeletonindex) >= 1)
            cs->skeletonobject = ent->priv.server->skeleton;
        cs->framegroupblend[0].frame = PRVM_serveredictfloat(ent, frame);
        cs->framegroupblend[1].frame = PRVM_serveredictfloat(ent, frame2);
        cs->framegroupblend[2].frame = PRVM_serveredictfloat(ent, frame3);
        cs->framegroupblend[3].frame = PRVM_serveredictfloat(ent, frame4);
        cs->framegroupblend[0].start = PRVM_serveredictfloat(ent, frame1time);
        cs->framegroupblend[1].start = PRVM_serveredictfloat(ent, frame2time);
        cs->framegroupblend[2].start = PRVM_serveredictfloat(ent, frame3time);
        cs->framegroupblend[3].start = PRVM_serveredictfloat(ent, frame4time);
        cs->framegroupblend[1].lerp = PRVM_serveredictfloat(ent, lerpfrac);
        cs->framegroupblend[2].lerp = PRVM_serveredictfloat(ent, lerpfrac3);
        cs->framegroupblend[3].lerp = PRVM_serveredictfloat(ent, lerpfrac4);
        cs->framegroupblend[0].lerp = 1.0f - cs->framegroupblend[1].lerp - cs->framegroupblend[2].lerp - cs->framegroupblend[3].lerp;
        cs->frame = 0; // don't need the legacy frame
    }
 
    cs->light[0] = light[0];
    cs->light[1] = light[1];
    cs->light[2] = light[2];
    cs->light[3] = light[3];
    cs->lightstyle = lightstyle;
    cs->lightpflags = lightpflags;
 
    cs->specialvisibilityradius = specialvisibilityradius;
 
    // calculate the visible box of this entity (don't use the physics box
    // as that is often smaller than a model, and would not count
    // specialvisibilityradius)
    if ((model = SV_GetModelByIndex(modelindex)) && (model->type != mod_null))
    {
        float scale = cs->scale * (1.0f / 16.0f);
        if (cs->angles[0] || cs->angles[2]) // pitch and roll
        {
            VectorMA(cs->origin, scale, model->rotatedmins, cullmins);
            VectorMA(cs->origin, scale, model->rotatedmaxs, cullmaxs);
        }
        else if (cs->angles[1] || ((effects | model->effects) & EF_ROTATE))
        {
            VectorMA(cs->origin, scale, model->yawmins, cullmins);
            VectorMA(cs->origin, scale, model->yawmaxs, cullmaxs);
        }
        else
        {
            VectorMA(cs->origin, scale, model->normalmins, cullmins);
            VectorMA(cs->origin, scale, model->normalmaxs, cullmaxs);
        }
    }
    else
    {
        // if there is no model (or it could not be loaded), use the physics box
        VectorAdd(cs->origin, PRVM_serveredictvector(ent, mins), cullmins);
        VectorAdd(cs->origin, PRVM_serveredictvector(ent, maxs), cullmaxs);
    }
    if (specialvisibilityradius)
    {
        cullmins[0] = min(cullmins[0], cs->origin[0] - specialvisibilityradius);
        cullmins[1] = min(cullmins[1], cs->origin[1] - specialvisibilityradius);
        cullmins[2] = min(cullmins[2], cs->origin[2] - specialvisibilityradius);
        cullmaxs[0] = max(cullmaxs[0], cs->origin[0] + specialvisibilityradius);
        cullmaxs[1] = max(cullmaxs[1], cs->origin[1] + specialvisibilityradius);
        cullmaxs[2] = max(cullmaxs[2], cs->origin[2] + specialvisibilityradius);
    }
 
    // calculate center of bbox for network prioritization purposes
    VectorMAM(0.5f, cullmins, 0.5f, cullmaxs, cs->netcenter);
 
    // if culling box has moved, update pvs cluster links
    if (!VectorCompare(cullmins, ent->priv.server->cullmins) || !VectorCompare(cullmaxs, ent->priv.server->cullmaxs))
    {
        VectorCopy(cullmins, ent->priv.server->cullmins);
        VectorCopy(cullmaxs, ent->priv.server->cullmaxs);
        // a value of -1 for pvs_numclusters indicates that the links are not
        // cached, and should be re-tested each time, this is the case if the
        // culling box touches too many pvs clusters to store, or if the world
        // model does not support FindBoxClusters
        ent->priv.server->pvs_numclusters = -1;
        if (sv.worldmodel && sv.worldmodel->brush.FindBoxClusters)
        {
            i = sv.worldmodel->brush.FindBoxClusters(sv.worldmodel, cullmins, cullmaxs, MAX_ENTITYCLUSTERS, ent->priv.server->pvs_clusterlist);
            if (i <= MAX_ENTITYCLUSTERS)
                ent->priv.server->pvs_numclusters = i;
        }
    }
 
    // we need to do some csqc entity upkeep here
    // get self.SendFlags and clear them
    // (to let the QC know that they've been read)
    if (sendentity)
    {
        sendflags = (unsigned int)PRVM_serveredictfloat(ent, SendFlags);
        PRVM_serveredictfloat(ent, SendFlags) = 0;
        // legacy self.Version system
        if ((version = (unsigned int)PRVM_serveredictfloat(ent, Version)))
        {
            if (sv.csqcentityversion[enumber] != version)
                sendflags = 0xFFFFFF;
            sv.csqcentityversion[enumber] = version;
        }
        // move sendflags into the per-client sendflags
        if (sendflags)
            for (i = 0;i < svs.maxclients;i++)
                svs.clients[i].csqcentitysendflags[enumber] |= sendflags;
        // mark it as inactive for non-csqc networking
        cs->active = ACTIVE_SHARED;
    }
 
    return true;
}

References entity_state_t::active, ACTIVE_NETWORK, ACTIVE_SHARED, alpha, entity_state_t::alpha, angles, entity_state_t::angles, bound, server_static_t::clients, color, colormap, entity_state_t::colormap, colormod, entity_state_t::colormod, server_t::csqcentityversion, entity_state_t::customizeentityforclient, defaultstate, drawonlytoclient, entity_state_t::drawonlytoclient, EF_BLUE, EF_BRIGHTFIELD, EF_BRIGHTLIGHT, EF_DIMLIGHT, EF_FLAME, EF_FULLBRIGHT, EF_LOWPRECISION, EF_MUZZLEFLASH, EF_RED, EF_ROTATE, EF_STARDUST, effects, entity_state_t::effects, entity_state_t::exteriormodelforclient, exteriormodeltoclient, f, FL_MONSTER, entity_state_t::flags, flags, entity_state_t::frame, frame, framegroupblend_t::frame, frame1time, frame2, frame2time, frame3, frame3time, frame4, frame4time, entity_state_t::framegroupblend, GAME_TENEBRAE, gamemode, glow_color, glow_size, glow_trail, entity_state_t::glowcolor, entity_state_t::glowmod, glowmod, entity_state_t::glowsize, i, int(), cvar_t::integer, framegroupblend_t::lerp, lerpfrac, lerpfrac3, lerpfrac4, entity_state_t::light, light_lev, entity_state_t::lightpflags, entity_state_t::lightstyle, max, MAX_ENTITYCLUSTERS, MAX_MODELS, server_static_t::maxclients, maxs, min, mins, mod_null, model, modelflags, entity_state_t::modelindex, modelindex, server_t::models, movetype, MOVETYPE_STEP, entity_state_t::netcenter, entity_state_t::nodrawtoclient, nodrawtoclient, entity_state_t::number, entity_state_t::origin, origin, pflags, PFLAGS_FULLDYNAMIC, prvm_edict_t::priv, PRVM_GetString(), PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictfunction, PRVM_serveredictstring, PRVM_serveredictvector, RENDER_COLORMAPPED, RENDER_COMPLEXANIMATION, RENDER_GLOWTRAIL, RENDER_LOWPRECISION, RENDER_STEP, RENDER_VIEWMODEL, entity_state_t::scale, scale, prvm_edict_t::server, skeletonindex, entity_state_t::skeletonobject, entity_state_t::skin, skin, entity_state_t::specialvisibilityradius, framegroupblend_t::start, style, sv, SV_GetModelByIndex(), sv_onlycsqcnetworking, svs, SVVM_prog, tag_entity, tag_index, entity_state_t::tagentity, entity_state_t::tagindex, entity_state_t::traileffectnum, traileffectnum, v, VectorAdd, VectorCompare, VectorCopy, VectorLength2, VectorMA, VectorMAM, version, entity_state_t::viewmodelforclient, viewmodelforclient, server_t::worldmodel, and server_t::writeentitiestoclient_cliententitynumber.

Referenced by SV_MarkWriteEntityStateToClient(), and SV_PrepareEntitiesForSending().

SV_SendClientDatagram()

static void SV_SendClientDatagram ( client_t * client )

static

Definition at line 1425 of file sv_send.c.

{
    int clientrate, maxrate, maxsize, maxsize2, downloadsize;
    sizebuf_t msg;
    int stats[MAX_CL_STATS];
    static unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE];
    double timedelta;
 
    // obey rate limit by limiting packet frequency if the packet size
    // limiting fails
    // (usually this is caused by reliable messages)
    if (!NetConn_CanSend(client->netconnection))
        return;
 
    // PROTOCOL_DARKPLACES5 and later support packet size limiting of updates
    maxrate = max(NET_MINRATE, sv_maxrate.integer);
    if (sv_maxrate.integer != maxrate)
        Cvar_SetValueQuick(&sv_maxrate, maxrate);
 
    // clientrate determines the 'cleartime' of a packet
    // (how long to wait before sending another, based on this packet's size)
    clientrate = bound(NET_MINRATE, client->rate, maxrate);
 
    switch (sv.protocol)
    {
    case PROTOCOL_QUAKE:
    case PROTOCOL_QUAKEDP:
    case PROTOCOL_NEHAHRAMOVIE:
    case PROTOCOL_NEHAHRABJP:
    case PROTOCOL_NEHAHRABJP2:
    case PROTOCOL_NEHAHRABJP3:
    case PROTOCOL_QUAKEWORLD:
        // no packet size limit support on Quake protocols because it just
        // causes missing entities/effects
        // packets are simply sent less often to obey the rate limit
        maxsize = 1024;
        maxsize2 = 1024;
        break;
    case PROTOCOL_DARKPLACES1:
    case PROTOCOL_DARKPLACES2:
    case PROTOCOL_DARKPLACES3:
    case PROTOCOL_DARKPLACES4:
        // no packet size limit support on DP1-4 protocols because they kick
        // the client off if they overflow, and miss effects
        // packets are simply sent less often to obey the rate limit
        maxsize = sizeof(sv_sendclientdatagram_buf);
        maxsize2 = sizeof(sv_sendclientdatagram_buf);
        break;
    default:
        // DP5 and later protocols support packet size limiting which is a
        // better method than limiting packet frequency as QW does
        //
        // at very low rates (or very small sys_ticrate) the packet size is
        // not reduced below 128, but packets may be sent less often
 
        // how long are bursts?
        timedelta = host_client->rate_burstsize / (double)client->rate;
 
        // how much of the burst do we keep reserved?
        timedelta *= 1 - net_burstreserve.value;
 
        // only try to use excess time
        timedelta = bound(0, host.realtime - host_client->netconnection->cleartime, timedelta);
 
        // but we know next packet will be in sys_ticrate, so we can use up THAT bandwidth
        timedelta += sys_ticrate.value;
 
        // note: packet overhead (not counted in maxsize) is 28 bytes
        maxsize = (int)(clientrate * timedelta) - 28;
 
        // put it in sound bounds
        maxsize = bound(128, maxsize, 1400);
        maxsize2 = 1400;
 
        // csqc entities can easily exceed 128 bytes, so disable throttling in
        // mods that use csqc (they are likely to use less bandwidth anyway)
        if((net_usesizelimit.integer == 1) ? (sv.csqc_progsize > 0) : (net_usesizelimit.integer < 1))
            maxsize = maxsize2;
 
        break;
    }
 
    if (LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP && !host_limitlocal.integer)
    {
        // for good singleplayer, send huge packets
        maxsize = sizeof(sv_sendclientdatagram_buf);
        maxsize2 = sizeof(sv_sendclientdatagram_buf);
        // never limit frequency in singleplayer
        clientrate = 1000000000;
    }
 
    // while downloading, limit entity updates to half the packet
    // (any leftover space will be used for downloading)
    if (host_client->download_file)
        maxsize /= 2;
 
    msg.data = sv_sendclientdatagram_buf;
    msg.maxsize = sizeof(sv_sendclientdatagram_buf);
    msg.cursize = 0;
    msg.allowoverflow = false;
 
    if (host_client->begun)
    {
        // the player is in the game
        MSG_WriteByte (&msg, svc_time);
        MSG_WriteFloat (&msg, sv.time);
 
        // add the client specific data to the datagram
        SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
        // now update the stats[] array using any registered custom fields
        VM_SV_UpdateCustomStats(client, client->edict, &msg, stats);
        // set host_client->statsdeltabits
        Protocol_UpdateClientStats (stats);
 
        // add as many queued unreliable messages (effects) as we can fit
        // limit effects to half of the remaining space
        if (client->unreliablemsg.cursize)
            SV_WriteUnreliableMessages (client, &msg, maxsize/2, maxsize2);
 
        // now write as many entities as we can fit, and also sends stats
        SV_WriteEntitiesToClient (client, client->edict, &msg, maxsize);
    }
    else if (host.realtime > client->keepalivetime)
    {
        // the player isn't totally in the game yet
        // send small keepalive messages if too much time has passed
        // (may also be sending downloads)
        client->keepalivetime = host.realtime + 5;
        MSG_WriteChar (&msg, svc_nop);
    }
 
    // if a download is active, see if there is room to fit some download data
    // in this packet
    downloadsize = min(maxsize*2,maxsize2) - msg.cursize - 7;
    if (host_client->download_file && host_client->download_started && downloadsize > 0)
    {
        fs_offset_t downloadstart;
        unsigned char data[1400];
        downloadstart = FS_Tell(host_client->download_file);
        downloadsize = min(downloadsize, (int)sizeof(data));
        downloadsize = FS_Read(host_client->download_file, data, downloadsize);
        // note this sends empty messages if at the end of the file, which is
        // necessary to keep the packet loss logic working
        // (the last blocks may be lost and need to be re-sent, and that will
        //  only occur if the client acks the empty end messages, revealing
        //  a gap in the download progress, causing the last blocks to be
        //  sent again)
        MSG_WriteChar (&msg, svc_downloaddata);
        MSG_WriteLong (&msg, downloadstart);
        MSG_WriteShort (&msg, downloadsize);
        if (downloadsize > 0)
            SZ_Write (&msg, data, downloadsize);
    }
 
    // reliable only if none is in progress
    if(client->sendsignon != 2 && !client->netconnection->sendMessageLength)
        SV_WriteDemoMessage(client, &(client->netconnection->message), false);
    // unreliable
    SV_WriteDemoMessage(client, &msg, false);
 
// send the datagram
    NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, client->rate_burstsize, client->sendsignon == 2);
    if (client->sendsignon == 1 && !client->netconnection->message.cursize)
        client->sendsignon = 2; // prevent reliable until client sends prespawn (this is the keepalive phase)
}

References sizebuf_t::allowoverflow, client_t::begun, bound, netconn_t::cleartime, server_t::csqc_progsize, sizebuf_t::cursize, Cvar_SetValueQuick(), data, sizebuf_t::data, client_t::download_file, client_t::download_started, client_t::edict, FS_Read(), FS_Tell(), host, host_client, host_limitlocal, int(), cvar_t::integer, client_t::keepalivetime, LHNETADDRESS_GetAddressType(), LHNETADDRESSTYPE_LOOP, max, MAX_CL_STATS, sizebuf_t::maxsize, netconn_t::message, min, MSG_WriteByte(), MSG_WriteChar(), MSG_WriteFloat(), MSG_WriteLong(), MSG_WriteShort(), net_burstreserve, NET_MAXMESSAGE, NET_MINRATE, net_usesizelimit, NetConn_CanSend(), NetConn_SendUnreliableMessage(), client_t::netconnection, netconn_t::peeraddress, server_t::protocol, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PROTOCOL_QUAKEWORLD, Protocol_UpdateClientStats(), client_t::rate, client_t::rate_burstsize, host_static_t::realtime, netconn_t::sendMessageLength, client_t::sendsignon, sv, sv_maxrate, SV_WriteClientdataToMessage(), SV_WriteDemoMessage(), SV_WriteEntitiesToClient(), SV_WriteUnreliableMessages(), svc_downloaddata, svc_nop, svc_time, sys_ticrate, SZ_Write(), server_t::time, client_t::unreliablemsg, cvar_t::value, and VM_SV_UpdateCustomStats().

Referenced by SV_SendClientMessages().

SV_SendClientMessages()

void SV_SendClientMessages

(

void

)

Definition at line 1697 of file sv_send.c.

{
    int i, prepared = false;
 
    if (sv.protocol == PROTOCOL_QUAKEWORLD)
        Sys_Error("SV_SendClientMessages: no quakeworld support\n");
 
    SV_FlushBroadcastMessages();
 
// update frags, names, etc
    SV_UpdateToReliableMessages();
 
// build individual updates
    for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
    {
        if (!host_client->active)
            continue;
        if (!host_client->netconnection)
            continue;
 
        if (host_client->netconnection->message.overflowed)
        {
            SV_DropClient (true, "Buffer overflow in net message"); // if the message couldn't send, kick off
            continue;
        }
 
        if (!prepared)
        {
            prepared = true;
            // only prepare entities once per frame
            SV_PrepareEntitiesForSending();
        }
        SV_SendClientDatagram(host_client);
    }
 
// clear muzzle flashes
    SV_CleanupEnts();
}

References client_t::active, server_static_t::clients, host_client, i, server_static_t::maxclients, netconn_t::message, client_t::netconnection, sizebuf_t::overflowed, server_t::protocol, PROTOCOL_QUAKEWORLD, sv, SV_CleanupEnts(), SV_DropClient(), SV_FlushBroadcastMessages(), SV_PrepareEntitiesForSending(), SV_SendClientDatagram(), SV_UpdateToReliableMessages(), svs, and Sys_Error().

Referenced by SV_Frame(), and SV_ThreadFunc().

SV_StartEffect()

void SV_StartEffect	(	vec3_t	org,
		int	modelindex,
		int	startframe,
		int	framecount,
		int	framerate )

Definition at line 182 of file sv_send.c.

{
    if (modelindex >= 256 || startframe >= 256)
    {
        if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
            return;
        MSG_WriteByte (&sv.datagram, svc_effect2);
        MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
        MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
        MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
        MSG_WriteShort (&sv.datagram, modelindex);
        MSG_WriteShort (&sv.datagram, startframe);
        MSG_WriteByte (&sv.datagram, framecount);
        MSG_WriteByte (&sv.datagram, framerate);
    }
    else
    {
        if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
            return;
        MSG_WriteByte (&sv.datagram, svc_effect);
        MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
        MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
        MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
        MSG_WriteByte (&sv.datagram, modelindex);
        MSG_WriteByte (&sv.datagram, startframe);
        MSG_WriteByte (&sv.datagram, framecount);
        MSG_WriteByte (&sv.datagram, framerate);
    }
    SV_FlushBroadcastMessages();
}

References sizebuf_t::cursize, server_t::datagram, MAX_PACKETFRAGMENT, modelindex, MSG_WriteByte(), MSG_WriteCoord(), MSG_WriteShort(), server_t::protocol, sv, SV_FlushBroadcastMessages(), svc_effect, and svc_effect2.

Referenced by VM_SV_effect().

SV_StartParticle()

void SV_StartParticle	(	vec3_t	org,
		vec3_t	dir,
		int	color,
		int	count )

Definition at line 158 of file sv_send.c.

{
    int i;
 
    if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
        return;
    MSG_WriteByte (&sv.datagram, svc_particle);
    MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
    MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
    MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
    for (i=0 ; i<3 ; i++)
        MSG_WriteChar (&sv.datagram, (int)bound(-128, dir[i]*16, 127));
    MSG_WriteByte (&sv.datagram, count);
    MSG_WriteByte (&sv.datagram, color);
    SV_FlushBroadcastMessages();
}

References bound, color, count, sizebuf_t::cursize, server_t::datagram, dir, i, MAX_PACKETFRAGMENT, MSG_WriteByte(), MSG_WriteChar(), MSG_WriteCoord(), server_t::protocol, sv, SV_FlushBroadcastMessages(), and svc_particle.

Referenced by VM_SV_particle().

SV_StartPointSound()

void SV_StartPointSound	(	vec3_t	origin,
		const char *	sample,
		int	nvolume,
		float	attenuation,
		float	speed )

Definition at line 320 of file sv_send.c.

{
    int sound_num, field_mask, i, speed4000;
 
    if (nvolume < 0 || nvolume > 255)
    {
        Con_Printf ("SV_StartPointSound: volume = %i\n", nvolume);
        return;
    }
 
    if (attenuation < 0 || attenuation > 4)
    {
        Con_Printf ("SV_StartPointSound: attenuation = %f\n", attenuation);
        return;
    }
 
    if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
        return;
 
    // find precache number for sound
    sound_num = SV_SoundIndex(sample, 1);
    if (!sound_num)
        return;
 
    speed4000 = (int)(speed * 40.0f);
    field_mask = 0;
    if (nvolume != DEFAULT_SOUND_PACKET_VOLUME)
        field_mask |= SND_VOLUME;
    if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
        field_mask |= SND_ATTENUATION;
    if (sound_num >= 256)
        field_mask |= SND_LARGESOUND;
    if (speed4000 && speed4000 != 4000)
        field_mask |= SND_SPEEDUSHORT4000;
 
// directed messages go only to the entity they are targeted on
    MSG_WriteByte (&sv.datagram, svc_sound);
    MSG_WriteByte (&sv.datagram, field_mask);
    if (field_mask & SND_VOLUME)
        MSG_WriteByte (&sv.datagram, nvolume);
    if (field_mask & SND_ATTENUATION)
        MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
    if (field_mask & SND_SPEEDUSHORT4000)
        MSG_WriteShort (&sv.datagram, speed4000);
    // Always write entnum 0 for the world entity
    MSG_WriteShort (&sv.datagram, (0<<3) | 0);
    if (field_mask & SND_LARGESOUND)
        MSG_WriteShort (&sv.datagram, sound_num);
    else
        MSG_WriteByte (&sv.datagram, sound_num);
    for (i = 0;i < 3;i++)
        MSG_WriteCoord (&sv.datagram, origin[i], sv.protocol);
    SV_FlushBroadcastMessages();
}

References Con_Printf(), sizebuf_t::cursize, server_t::datagram, DEFAULT_SOUND_PACKET_ATTENUATION, DEFAULT_SOUND_PACKET_VOLUME, i, int(), MAX_PACKETFRAGMENT, MSG_WriteByte(), MSG_WriteCoord(), MSG_WriteShort(), origin, server_t::protocol, SND_ATTENUATION, SND_LARGESOUND, SND_SPEEDUSHORT4000, SND_VOLUME, sv, SV_FlushBroadcastMessages(), SV_SoundIndex(), and svc_sound.

Referenced by VM_SV_pointsound().

SV_StartSound()

void SV_StartSound	(	prvm_edict_t *	entity,
		int	channel,
		const char *	sample,
		int	nvolume,
		float	attenuation,
		qbool	reliable,
		float	speed )

Definition at line 228 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    sizebuf_t *dest;
    int sound_num, field_mask, i, ent, speed4000;
 
    dest = (reliable ? &sv.reliable_datagram : &sv.datagram);
 
    if (nvolume < 0 || nvolume > 255)
    {
        Con_Printf ("SV_StartSound: volume = %i\n", nvolume);
        return;
    }
 
    if (attenuation < 0 || attenuation > 4)
    {
        Con_Printf ("SV_StartSound: attenuation = %f\n", attenuation);
        return;
    }
 
    if (!IS_CHAN(channel))
    {
        Con_Printf ("SV_StartSound: channel = %i\n", channel);
        return;
    }
 
    channel = CHAN_ENGINE2NET(channel);
 
    if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
        return;
 
// find precache number for sound
    sound_num = SV_SoundIndex(sample, 1);
    if (!sound_num)
        return;
 
    ent = PRVM_NUM_FOR_EDICT(entity);
 
    speed4000 = (int)floor(speed * 4000.0f + 0.5f);
    field_mask = 0;
    if (nvolume != DEFAULT_SOUND_PACKET_VOLUME)
        field_mask |= SND_VOLUME;
    if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
        field_mask |= SND_ATTENUATION;
    if (speed4000 && speed4000 != 4000)
        field_mask |= SND_SPEEDUSHORT4000;
    if (ent >= 8192 || channel < 0 || channel > 7)
        field_mask |= SND_LARGEENTITY;
    if (sound_num >= 256)
        field_mask |= SND_LARGESOUND;
 
// directed messages go only to the entity they are targeted on
    MSG_WriteByte (dest, svc_sound);
    MSG_WriteByte (dest, field_mask);
    if (field_mask & SND_VOLUME)
        MSG_WriteByte (dest, nvolume);
    if (field_mask & SND_ATTENUATION)
        MSG_WriteByte (dest, (int)(attenuation*64));
    if (field_mask & SND_SPEEDUSHORT4000)
        MSG_WriteShort (dest, speed4000);
    if (field_mask & SND_LARGEENTITY)
    {
        MSG_WriteShort (dest, ent);
        MSG_WriteChar (dest, channel);
    }
    else
        MSG_WriteShort (dest, (ent<<3) | channel);
    if ((field_mask & SND_LARGESOUND) || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
        MSG_WriteShort (dest, sound_num);
    else
        MSG_WriteByte (dest, sound_num);
    for (i = 0;i < 3;i++)
        MSG_WriteCoord (dest, PRVM_serveredictvector(entity, origin)[i]+0.5*(PRVM_serveredictvector(entity, mins)[i]+PRVM_serveredictvector(entity, maxs)[i]), sv.protocol);
 
    // TODO do we have to do anything here when dest is &sv.reliable_datagram?
    if(!reliable)
        SV_FlushBroadcastMessages();
}

References CHAN_ENGINE2NET, Con_Printf(), sizebuf_t::cursize, server_t::datagram, DEFAULT_SOUND_PACKET_ATTENUATION, DEFAULT_SOUND_PACKET_VOLUME, entity(), floor(), i, int(), IS_CHAN, MAX_PACKETFRAGMENT, maxs, mins, MSG_WriteByte(), MSG_WriteChar(), MSG_WriteCoord(), MSG_WriteShort(), origin, server_t::protocol, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PRVM_NUM_FOR_EDICT, PRVM_serveredictvector, server_t::reliable_datagram, SND_ATTENUATION, SND_LARGEENTITY, SND_LARGESOUND, SND_SPEEDUSHORT4000, SND_VOLUME, sv, SV_FlushBroadcastMessages(), SV_SoundIndex(), svc_sound, and SVVM_prog.

Referenced by SV_CheckWaterTransition(), SV_Physics_Step(), and VM_SV_sound().

SV_UpdateToReliableMessages()

static void SV_UpdateToReliableMessages ( void )

static

Definition at line 1596 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i, j;
    client_t *client;
    const char *name;
    const char *model;
    const char *skin;
    int clientcamera;
 
// check for changes to be sent over the reliable streams
    for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
    {
        // update the host_client fields we care about according to the entity fields
        host_client->edict = PRVM_EDICT_NUM(i+1);
 
        // DP_SV_CLIENTNAME
        name = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, netname));
        if (name == NULL)
            name = "";
        // always point the string back at host_client->name to keep it safe
        //strlcpy (host_client->name, name, sizeof (host_client->name));
        if (name != host_client->name) // prevent buffer overlap SIGABRT on Mac OSX
            dp_strlcpy (host_client->name, name, sizeof (host_client->name));
        SV_Name(i);
 
        // DP_SV_CLIENTCOLORS
        host_client->colors = (int)PRVM_serveredictfloat(host_client->edict, clientcolors);
        if (host_client->old_colors != host_client->colors)
        {
            host_client->old_colors = host_client->colors;
            // send notification to all clients
            MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
            MSG_WriteByte (&sv.reliable_datagram, i);
            MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
        }
 
        // NEXUIZ_PLAYERMODEL
        model = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, playermodel));
        if (model == NULL)
            model = "";
        // always point the string back at host_client->name to keep it safe
        //strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
        if (model != host_client->playermodel) // prevent buffer overlap SIGABRT on Mac OSX
            dp_strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
        PRVM_serveredictstring(host_client->edict, playermodel) = PRVM_SetEngineString(prog, host_client->playermodel);
 
        // NEXUIZ_PLAYERSKIN
        skin = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, playerskin));
        if (skin == NULL)
            skin = "";
        // always point the string back at host_client->name to keep it safe
        //strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
        if (skin != host_client->playerskin) // prevent buffer overlap SIGABRT on Mac OSX
            dp_strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
        PRVM_serveredictstring(host_client->edict, playerskin) = PRVM_SetEngineString(prog, host_client->playerskin);
 
        // TODO: add an extension name for this [1/17/2008 Black]
        clientcamera = PRVM_serveredictedict(host_client->edict, clientcamera);
        if (clientcamera > 0)
        {
            int oldclientcamera = host_client->clientcamera;
            if (clientcamera >= prog->max_edicts || PRVM_EDICT_NUM(clientcamera)->free)
                clientcamera = PRVM_NUM_FOR_EDICT(host_client->edict);
            host_client->clientcamera = clientcamera;
 
            if (oldclientcamera != host_client->clientcamera && host_client->netconnection)
            {
                MSG_WriteByte(&host_client->netconnection->message, svc_setview);
                MSG_WriteShort(&host_client->netconnection->message, host_client->clientcamera);
            }
        }
 
        // frags
        host_client->frags = (int)PRVM_serveredictfloat(host_client->edict, frags);
        if(IS_OLDNEXUIZ_DERIVED(gamemode))
            if(!host_client->begun && host_client->netconnection)
                host_client->frags = -666;
        if (host_client->old_frags != host_client->frags)
        {
            host_client->old_frags = host_client->frags;
            // send notification to all clients
            MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
            MSG_WriteByte (&sv.reliable_datagram, i);
            MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
        }
    }
 
    for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
        if (client->netconnection && (client->begun || client->clientconnectcalled)) // also send MSG_ALL to people who are past ClientConnect, but not spawned yet
            SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
 
    SZ_Clear (&sv.reliable_datagram);
}

References client_t::begun, client_t::clientcamera, clientcamera, clientcolors, client_t::clientconnectcalled, server_static_t::clients, client_t::colors, sizebuf_t::cursize, sizebuf_t::data, dp_strlcpy, client_t::edict, client_t::frags, frags, gamemode, host_client, i, int(), IS_OLDNEXUIZ_DERIVED, prvm_prog_t::max_edicts, server_static_t::maxclients, netconn_t::message, model, MSG_WriteByte(), MSG_WriteShort(), client_t::name, name, client_t::netconnection, netname, NULL, client_t::old_colors, client_t::old_frags, client_t::playermodel, playermodel, client_t::playerskin, playerskin, PRVM_EDICT_NUM, PRVM_GetString(), PRVM_NUM_FOR_EDICT, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictstring, PRVM_SetEngineString(), server_t::reliable_datagram, skin, sv, SV_Name(), svc_setview, svc_updatecolors, svc_updatefrags, svs, SVVM_prog, SZ_Clear(), and SZ_Write().

Referenced by SV_SendClientMessages().

SV_WriteClientdataToMessage()

void SV_WriteClientdataToMessage	(	client_t *	client,
		prvm_edict_t *	ent,
		sizebuf_t *	msg,
		int *	stats )

Definition at line 1091 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int     bits;
    int     i;
    prvm_edict_t    *other;
    int     items;
    vec3_t  punchvector;
    int     viewzoom;
    const char *s;
    float   *statsf = (float *)stats;
    float gravity;
 
//
// send a damage message
//
    if (PRVM_serveredictfloat(ent, dmg_take) || PRVM_serveredictfloat(ent, dmg_save))
    {
        other = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, dmg_inflictor));
        MSG_WriteByte (msg, svc_damage);
        MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_save));
        MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_take));
        for (i=0 ; i<3 ; i++)
            MSG_WriteCoord (msg, PRVM_serveredictvector(other, origin)[i] + 0.5*(PRVM_serveredictvector(other, mins)[i] + PRVM_serveredictvector(other, maxs)[i]), sv.protocol);
 
        PRVM_serveredictfloat(ent, dmg_take) = 0;
        PRVM_serveredictfloat(ent, dmg_save) = 0;
    }
 
//
// send the current viewpos offset from the view entity
//
    SV_SetIdealPitch ();        // how much to look up / down ideally
 
// a fixangle might get lost in a dropped packet.  Oh well.
    if(PRVM_serveredictfloat(ent, fixangle))
    {
        // angle fixing was requested by global thinking code...
        // so store the current angles for later use
        VectorCopy(PRVM_serveredictvector(ent, angles), host_client->fixangle_angles);
        host_client->fixangle_angles_set = true;
 
        // and clear fixangle for the next frame
        PRVM_serveredictfloat(ent, fixangle) = 0;
    }
 
    if (host_client->fixangle_angles_set)
    {
        MSG_WriteByte (msg, svc_setangle);
        for (i=0 ; i < 3 ; i++)
            MSG_WriteAngle (msg, host_client->fixangle_angles[i], sv.protocol);
        host_client->fixangle_angles_set = false;
    }
 
    // the runes are in serverflags, pack them into the items value, also pack
    // in the items2 value for mission pack huds
    // (used only in the mission packs, which do not use serverflags)
    items = (int)PRVM_serveredictfloat(ent, items)
        | (((int)PRVM_serveredictfloat(ent, items2) & ((1<<9)-1)) << 23)
        | (((int)PRVM_serverglobalfloat(serverflags) & ((1<<4)-1)) << 28);
 
    VectorCopy(PRVM_serveredictvector(ent, punchvector), punchvector);
 
    // cache weapon model name and index in client struct to save time
    // (this search can be almost 1% of cpu time!)
    s = PRVM_GetString(prog, PRVM_serveredictstring(ent, weaponmodel));
    if (strcmp(s, client->weaponmodel))
    {
        dp_strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
        client->weaponmodelindex = SV_ModelIndex(s, 1);
    }
 
    viewzoom = (int)(PRVM_serveredictfloat(ent, viewzoom) * 255.0f);
    if (viewzoom == 0)
        viewzoom = 255;
 
    bits = 0;
 
    if ((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND)
        bits |= SU_ONGROUND;
    if (PRVM_serveredictfloat(ent, waterlevel) >= 2)
        bits |= SU_INWATER;
    if (PRVM_serveredictfloat(ent, idealpitch))
        bits |= SU_IDEALPITCH;
 
    for (i=0 ; i<3 ; i++)
    {
        if (PRVM_serveredictvector(ent, punchangle)[i])
            bits |= (SU_PUNCH1<<i);
        if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
            if (punchvector[i])
                bits |= (SU_PUNCHVEC1<<i);
        if (PRVM_serveredictvector(ent, velocity)[i])
            bits |= (SU_VELOCITY1<<i);
    }
 
    gravity = PRVM_serveredictfloat(ent, gravity);if (!gravity) gravity = 1.0f;
 
    memset(stats, 0, sizeof(int[MAX_CL_STATS]));
    stats[STAT_VIEWHEIGHT] = (int)PRVM_serveredictvector(ent, view_ofs)[2];
    stats[STAT_ITEMS] = items;
    stats[STAT_WEAPONFRAME] = (int)PRVM_serveredictfloat(ent, weaponframe);
    stats[STAT_ARMOR] = (int)PRVM_serveredictfloat(ent, armorvalue);
    stats[STAT_WEAPON] = client->weaponmodelindex;
    stats[STAT_HEALTH] = (int)PRVM_serveredictfloat(ent, health);
    stats[STAT_AMMO] = (int)PRVM_serveredictfloat(ent, currentammo);
    stats[STAT_SHELLS] = (int)PRVM_serveredictfloat(ent, ammo_shells);
    stats[STAT_NAILS] = (int)PRVM_serveredictfloat(ent, ammo_nails);
    stats[STAT_ROCKETS] = (int)PRVM_serveredictfloat(ent, ammo_rockets);
    stats[STAT_CELLS] = (int)PRVM_serveredictfloat(ent, ammo_cells);
    stats[STAT_ACTIVEWEAPON] = (int)PRVM_serveredictfloat(ent, weapon);
    stats[STAT_VIEWZOOM] = viewzoom;
    stats[STAT_TOTALSECRETS] = (int)PRVM_serverglobalfloat(total_secrets);
    stats[STAT_TOTALMONSTERS] = (int)PRVM_serverglobalfloat(total_monsters);
    // the QC bumps these itself by sending svc_'s, so we have to keep them
    // zero or they'll be corrected by the engine
    //stats[STAT_SECRETS] = PRVM_serverglobalfloat(found_secrets);
    //stats[STAT_MONSTERS] = PRVM_serverglobalfloat(killed_monsters);
 
    if(!sv_qcstats.integer)
    {
        statsf[STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR] = sv_airaccel_qw_stretchfactor.value;
        statsf[STAT_MOVEVARS_AIRCONTROL_PENALTY] = sv_aircontrol_penalty.value;
        statsf[STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW] = sv_airspeedlimit_nonqw.value;       
        statsf[STAT_MOVEVARS_AIRSTRAFEACCEL_QW] = sv_airstrafeaccel_qw.value;
        statsf[STAT_MOVEVARS_AIRCONTROL_POWER] = sv_aircontrol_power.value;
        // movement settings for prediction
        // note: these are not sent in protocols with lower MAX_CL_STATS limits
        stats[STAT_MOVEFLAGS] = MOVEFLAG_VALID
            | (sv_gameplayfix_q2airaccelerate.integer ? MOVEFLAG_Q2AIRACCELERATE : 0)
            | (sv_gameplayfix_nogravityonground.integer ? MOVEFLAG_NOGRAVITYONGROUND : 0)
            | (sv_gameplayfix_gravityunaffectedbyticrate.integer ? MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE : 0)
        ;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL] = sv_warsowbunny_airforwardaccel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL] = sv_warsowbunny_accel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED] = sv_warsowbunny_topspeed.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL] = sv_warsowbunny_turnaccel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO] = sv_warsowbunny_backtosideratio.value;
        statsf[STAT_MOVEVARS_AIRSTOPACCELERATE] = sv_airstopaccelerate.value;
        statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE] = sv_airstrafeaccelerate.value;
        statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED] = sv_maxairstrafespeed.value;
        statsf[STAT_MOVEVARS_AIRCONTROL] = sv_aircontrol.value;
        statsf[STAT_FRAGLIMIT] = fraglimit.value;
        statsf[STAT_TIMELIMIT] = timelimit.value;
        statsf[STAT_MOVEVARS_FRICTION] = sv_friction.value; 
        statsf[STAT_MOVEVARS_WATERFRICTION] = sv_waterfriction.value >= 0 ? sv_waterfriction.value : sv_friction.value;
        statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
        statsf[STAT_MOVEVARS_TIMESCALE] = host_timescale.value;
        statsf[STAT_MOVEVARS_GRAVITY] = sv_gravity.value;
        statsf[STAT_MOVEVARS_STOPSPEED] = sv_stopspeed.value;
        statsf[STAT_MOVEVARS_MAXSPEED] = sv_maxspeed.value;
        statsf[STAT_MOVEVARS_SPECTATORMAXSPEED] = sv_maxspeed.value; // FIXME: QW has a separate cvar for this
        statsf[STAT_MOVEVARS_ACCELERATE] = sv_accelerate.value;
        statsf[STAT_MOVEVARS_AIRACCELERATE] = sv_airaccelerate.value >= 0 ? sv_airaccelerate.value : sv_accelerate.value;
        statsf[STAT_MOVEVARS_WATERACCELERATE] = sv_wateraccelerate.value >= 0 ? sv_wateraccelerate.value : sv_accelerate.value;
        statsf[STAT_MOVEVARS_ENTGRAVITY] = gravity;
        statsf[STAT_MOVEVARS_JUMPVELOCITY] = sv_jumpvelocity.value;
        statsf[STAT_MOVEVARS_EDGEFRICTION] = sv_edgefriction.value;
        statsf[STAT_MOVEVARS_MAXAIRSPEED] = sv_maxairspeed.value;
        statsf[STAT_MOVEVARS_STEPHEIGHT] = sv_stepheight.value;
        statsf[STAT_MOVEVARS_AIRACCEL_QW] = sv_airaccel_qw.value;
        statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION] = sv_airaccel_sideways_friction.value;
    }
 
    if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
    {
        if (stats[STAT_VIEWHEIGHT] != DEFAULT_VIEWHEIGHT) bits |= SU_VIEWHEIGHT;
        bits |= SU_ITEMS;
        if (stats[STAT_WEAPONFRAME]) bits |= SU_WEAPONFRAME;
        if (stats[STAT_ARMOR]) bits |= SU_ARMOR;
        bits |= SU_WEAPON;
        // FIXME: which protocols support this?  does PROTOCOL_DARKPLACES3 support viewzoom?
        if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
            if (viewzoom != 255)
                bits |= SU_VIEWZOOM;
    }
 
    if (bits >= 65536)
        bits |= SU_EXTEND1;
    if (bits >= 16777216)
        bits |= SU_EXTEND2;
 
    // send the data
    MSG_WriteByte (msg, svc_clientdata);
    MSG_WriteShort (msg, bits);
    if (bits & SU_EXTEND1)
        MSG_WriteByte(msg, bits >> 16);
    if (bits & SU_EXTEND2)
        MSG_WriteByte(msg, bits >> 24);
 
    if (bits & SU_VIEWHEIGHT)
        MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
 
    if (bits & SU_IDEALPITCH)
        MSG_WriteChar (msg, (int)PRVM_serveredictfloat(ent, idealpitch));
 
    for (i=0 ; i<3 ; i++)
    {
        if (bits & (SU_PUNCH1<<i))
        {
            if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
                MSG_WriteChar(msg, (int)PRVM_serveredictvector(ent, punchangle)[i]);
            else
                MSG_WriteAngle16i(msg, PRVM_serveredictvector(ent, punchangle)[i]);
        }
        if (bits & (SU_PUNCHVEC1<<i))
        {
            if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
                MSG_WriteCoord16i(msg, punchvector[i]);
            else
                MSG_WriteCoord32f(msg, punchvector[i]);
        }
        if (bits & (SU_VELOCITY1<<i))
        {
            if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
                MSG_WriteChar(msg, (int)(PRVM_serveredictvector(ent, velocity)[i] * (1.0f / 16.0f)));
            else
                MSG_WriteCoord32f(msg, PRVM_serveredictvector(ent, velocity)[i]);
        }
    }
 
    if (bits & SU_ITEMS)
        MSG_WriteLong (msg, stats[STAT_ITEMS]);
 
    if (sv.protocol == PROTOCOL_DARKPLACES5)
    {
        if (bits & SU_WEAPONFRAME)
            MSG_WriteShort (msg, stats[STAT_WEAPONFRAME]);
        if (bits & SU_ARMOR)
            MSG_WriteShort (msg, stats[STAT_ARMOR]);
        if (bits & SU_WEAPON)
            MSG_WriteShort (msg, stats[STAT_WEAPON]);
        MSG_WriteShort (msg, stats[STAT_HEALTH]);
        MSG_WriteShort (msg, stats[STAT_AMMO]);
        MSG_WriteShort (msg, stats[STAT_SHELLS]);
        MSG_WriteShort (msg, stats[STAT_NAILS]);
        MSG_WriteShort (msg, stats[STAT_ROCKETS]);
        MSG_WriteShort (msg, stats[STAT_CELLS]);
        MSG_WriteShort (msg, stats[STAT_ACTIVEWEAPON]);
        if (bits & SU_VIEWZOOM)
            MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
    }
    else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
    {
        if (bits & SU_WEAPONFRAME)
            MSG_WriteByte (msg, stats[STAT_WEAPONFRAME]);
        if (bits & SU_ARMOR)
            MSG_WriteByte (msg, stats[STAT_ARMOR]);
        if (bits & SU_WEAPON)
        {
            if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
                MSG_WriteShort (msg, stats[STAT_WEAPON]);
            else
                MSG_WriteByte (msg, stats[STAT_WEAPON]);
        }
        MSG_WriteShort (msg, stats[STAT_HEALTH]);
        MSG_WriteByte (msg, stats[STAT_AMMO]);
        MSG_WriteByte (msg, stats[STAT_SHELLS]);
        MSG_WriteByte (msg, stats[STAT_NAILS]);
        MSG_WriteByte (msg, stats[STAT_ROCKETS]);
        MSG_WriteByte (msg, stats[STAT_CELLS]);
        if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_QUOTH || IS_OLDNEXUIZ_DERIVED(gamemode))
        {
            for (i = 0;i < 32;i++)
                if (stats[STAT_ACTIVEWEAPON] & (1<<i))
                    break;
            MSG_WriteByte (msg, i);
        }
        else
            MSG_WriteByte (msg, stats[STAT_ACTIVEWEAPON]);
        if (bits & SU_VIEWZOOM)
        {
            if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
                MSG_WriteByte (msg, bound(0, stats[STAT_VIEWZOOM], 255));
            else
                MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
        }
    }
}

References ammo_cells, ammo_nails, ammo_rockets, ammo_shells, angles, armorvalue, bound, currentammo, DEFAULT_VIEWHEIGHT, dmg_inflictor, dmg_save, dmg_take, dp_strlcpy, fixangle, client_t::fixangle_angles, client_t::fixangle_angles_set, FL_ONGROUND, flags, fraglimit, GAME_HIPNOTIC, GAME_QUOTH, GAME_ROGUE, gamemode, health, host_client, host_timescale, i, idealpitch, int(), cvar_t::integer, IS_OLDNEXUIZ_DERIVED, items, MAX_CL_STATS, maxs, mins, MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE, MOVEFLAG_NOGRAVITYONGROUND, MOVEFLAG_Q2AIRACCELERATE, MOVEFLAG_VALID, MSG_WriteAngle(), MSG_WriteAngle16i(), MSG_WriteByte(), MSG_WriteChar(), MSG_WriteCoord(), MSG_WriteCoord16i(), MSG_WriteCoord32f(), MSG_WriteLong(), MSG_WriteShort(), origin, other, server_t::protocol, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_DARKPLACES5, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PRVM_GetString(), PRVM_PROG_TO_EDICT, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictstring, PRVM_serveredictvector, PRVM_serverglobalfloat, punchangle, punchvector, serverflags, STAT_ACTIVEWEAPON, STAT_AMMO, STAT_ARMOR, STAT_CELLS, STAT_FRAGLIMIT, STAT_HEALTH, STAT_ITEMS, STAT_MOVEFLAGS, STAT_MOVEVARS_ACCELERATE, STAT_MOVEVARS_AIRACCEL_QW, STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR, STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION, STAT_MOVEVARS_AIRACCELERATE, STAT_MOVEVARS_AIRCONTROL, STAT_MOVEVARS_AIRCONTROL_PENALTY, STAT_MOVEVARS_AIRCONTROL_POWER, STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW, STAT_MOVEVARS_AIRSTOPACCELERATE, STAT_MOVEVARS_AIRSTRAFEACCEL_QW, STAT_MOVEVARS_AIRSTRAFEACCELERATE, STAT_MOVEVARS_EDGEFRICTION, STAT_MOVEVARS_ENTGRAVITY, STAT_MOVEVARS_FRICTION, STAT_MOVEVARS_GRAVITY, STAT_MOVEVARS_JUMPVELOCITY, STAT_MOVEVARS_MAXAIRSPEED, STAT_MOVEVARS_MAXAIRSTRAFESPEED, STAT_MOVEVARS_MAXSPEED, STAT_MOVEVARS_SPECTATORMAXSPEED, STAT_MOVEVARS_STEPHEIGHT, STAT_MOVEVARS_STOPSPEED, STAT_MOVEVARS_TICRATE, STAT_MOVEVARS_TIMESCALE, STAT_MOVEVARS_WARSOWBUNNY_ACCEL, STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL, STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO, STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED, STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL, STAT_MOVEVARS_WATERACCELERATE, STAT_MOVEVARS_WATERFRICTION, STAT_NAILS, STAT_ROCKETS, STAT_SHELLS, STAT_TIMELIMIT, STAT_TOTALMONSTERS, STAT_TOTALSECRETS, STAT_VIEWHEIGHT, STAT_VIEWZOOM, STAT_WEAPON, STAT_WEAPONFRAME, SU_ARMOR, SU_EXTEND1, SU_EXTEND2, SU_IDEALPITCH, SU_INWATER, SU_ITEMS, SU_ONGROUND, SU_PUNCH1, SU_PUNCHVEC1, SU_VELOCITY1, SU_VIEWHEIGHT, SU_VIEWZOOM, SU_WEAPON, SU_WEAPONFRAME, sv, sv_accelerate, sv_airaccel_qw, sv_airaccel_qw_stretchfactor, sv_airaccel_sideways_friction, sv_airaccelerate, sv_aircontrol, sv_aircontrol_penalty, sv_aircontrol_power, sv_airspeedlimit_nonqw, sv_airstopaccelerate, sv_airstrafeaccel_qw, sv_airstrafeaccelerate, sv_edgefriction, sv_friction, sv_gameplayfix_gravityunaffectedbyticrate, sv_gameplayfix_nogravityonground, sv_gameplayfix_q2airaccelerate, sv_gravity, sv_jumpvelocity, sv_maxairspeed, sv_maxairstrafespeed, sv_maxspeed, SV_ModelIndex(), sv_qcstats, SV_SetIdealPitch(), sv_stepheight, sv_stopspeed, sv_warsowbunny_accel, sv_warsowbunny_airforwardaccel, sv_warsowbunny_backtosideratio, sv_warsowbunny_topspeed, sv_warsowbunny_turnaccel, sv_wateraccelerate, sv_waterfriction, svc_clientdata, svc_damage, svc_setangle, SVVM_prog, sys_ticrate, timelimit, total_monsters, total_secrets, cvar_t::value, VectorCopy, velocity, view_ofs, viewzoom, waterlevel, weapon, weaponframe, client_t::weaponmodel, weaponmodel, and client_t::weaponmodelindex.

Referenced by SV_SendClientDatagram(), and SV_Spawn_f().

SV_WriteUnreliableMessages()

static void SV_WriteUnreliableMessages ( client_t * client, sizebuf_t * msg, int maxsize, int maxsize2 )

static

Definition at line 1387 of file sv_send.c.

{
    // scan the splitpoints to find out how many we can fit in
    int numsegments, j, split;
    if (!client->unreliablemsg_splitpoints)
        return;
    // always accept the first one if it's within 1024 bytes, this ensures
    // that very big datagrams which are over the rate limit still get
    // through, just to keep it working
    for (numsegments = 1;numsegments < client->unreliablemsg_splitpoints;numsegments++)
        if (msg->cursize + client->unreliablemsg_splitpoint[numsegments] > maxsize)
            break;
    // the first segment gets an exemption from the rate limiting, otherwise
    // it could get dropped consistently due to a low rate limit
    if (numsegments == 1)
        maxsize = maxsize2;
    // some will fit, so add the ones that will fit
    split = client->unreliablemsg_splitpoint[numsegments-1];
    // note this discards ones that were accepted by the segments scan but
    // can not fit, such as a really huge first one that will never ever
    // fit in a packet...
    if (msg->cursize + split <= maxsize)
        SZ_Write(msg, client->unreliablemsg.data, split);
    // remove the part we sent, keeping any remaining data
    client->unreliablemsg.cursize -= split;
    if (client->unreliablemsg.cursize > 0)
        memmove(client->unreliablemsg.data, client->unreliablemsg.data + split, client->unreliablemsg.cursize);
    // adjust remaining splitpoints
    client->unreliablemsg_splitpoints -= numsegments;
    for (j = 0;j < client->unreliablemsg_splitpoints;j++)
        client->unreliablemsg_splitpoint[j] = client->unreliablemsg_splitpoint[numsegments + j] - split;
}

References sizebuf_t::cursize, sizebuf_t::data, SZ_Write(), client_t::unreliablemsg, client_t::unreliablemsg_splitpoint, and client_t::unreliablemsg_splitpoints.

Referenced by SV_SendClientDatagram().

Variable Documentation

sv_airaccel_qw_stretchfactor

cvar_t sv_airaccel_qw_stretchfactor

extern

Definition at line 58 of file sv_main.c.

{CF_SERVER, "sv_airaccel_qw_stretchfactor", "0", "when set, the maximum acceleration increase the player may get compared to forward-acceleration when strafejumping"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_cullentities_trace_delay_players

cvar_t sv_cullentities_trace_delay_players

extern

Definition at line 86 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_delay_players", "0.2", "number of seconds until the entity gets actually culled if it is a player entity"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_trace_entityocclusion

cvar_t sv_cullentities_trace_entityocclusion

extern

Definition at line 92 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_entityocclusion", "0", "also check if doors and other bsp models are in the way"};

Referenced by SV_CanSeeBox(), and SV_Init().

sv_cullentities_trace_expand

cvar_t sv_cullentities_trace_expand

extern

Definition at line 88 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_expand", "0", "box is expanded by this many units for entity culling (also applies to portal camera eyes even if sv_cullentities_trace is 0)"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_trace_eyejitter

cvar_t sv_cullentities_trace_eyejitter

extern

Definition at line 89 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_eyejitter", "16", "jitter the eye by this much for each trace (also applies to portal camera eyes even if sv_cullentities_trace is 0)"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_trace_samples_players

cvar_t sv_cullentities_trace_samples_players

extern

Definition at line 95 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_samples_players", "8", "number of samples to test for entity culling when the entity is a player entity"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_trace_spectators

cvar_t sv_cullentities_trace_spectators

extern

Definition at line 96 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_spectators", "0", "enables trace entity culling for clients that are spectating"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_onlycsqcnetworking

cvar_t sv_onlycsqcnetworking

extern

Definition at line 163 of file sv_main.c.

{CF_SERVER, "sv_onlycsqcnetworking", "0", "disables legacy entity networking code for higher performance (except on clients, which can still be legacy)"};

Referenced by SV_Init(), and SV_PrepareEntityForSending().

sv_qcstats

cvar_t sv_qcstats

extern

Definition at line 148 of file sv_main.c.

{CF_SERVER, "sv_qcstats", "0", "Disables engine sending of stats 220 and above, for use by certain games such as Xonotic, NOTE: it's strongly recommended that SVQC send correct STAT_MOVEVARS_TICRATE and STAT_MOVEVARS_TIMESCALE"};

Referenced by SV_WriteClientdataToMessage().

sv_warsowbunny_accel

cvar_t sv_warsowbunny_accel

extern

Definition at line 159 of file sv_main.c.

{CF_SERVER, "sv_warsowbunny_accel", "0.1585", "how fast you accelerate until after reaching sv_maxspeed (it gets harder as you near sv_warsowbunny_topspeed)"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_warsowbunny_airforwardaccel

cvar_t sv_warsowbunny_airforwardaccel

extern

Definition at line 158 of file sv_main.c.

{CF_SERVER, "sv_warsowbunny_airforwardaccel", "1.00001", "how fast you accelerate until you reach sv_maxspeed"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_warsowbunny_backtosideratio

cvar_t sv_warsowbunny_backtosideratio

extern

Definition at line 162 of file sv_main.c.

{CF_SERVER, "sv_warsowbunny_backtosideratio", "0.8", "lower values make it easier to change direction without losing speed; the drawback is \"understeering\" in sharp turns"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_warsowbunny_topspeed

cvar_t sv_warsowbunny_topspeed

extern

Definition at line 160 of file sv_main.c.

{CF_SERVER, "sv_warsowbunny_topspeed", "925", "soft speed limit (can get faster with rjs and on ramps)"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_warsowbunny_turnaccel

cvar_t sv_warsowbunny_turnaccel

extern

Definition at line 161 of file sv_main.c.

{CF_SERVER, "sv_warsowbunny_turnaccel", "0", "max sharpness of turns (also master switch for the sv_warsowbunny_* mode; set this to 9 to enable)"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().