server.h File Reference

#include "../qcommon/qcommon.h"
#include "../game/game.h"

Go to the source code of this file.

Classes
struct	server_t
struct	client_frame_t
struct	client_s
struct	challenge_t
struct	server_static_t

Macros
#define	MAX_MASTERS   8
#define	EDICT_NUM(n)   ((edict_t *)((byte *)ge->edicts + ge->edict_size*(n)))
#define	NUM_FOR_EDICT(e)   ( ((byte *)(e)-(byte *)ge->edicts ) / ge->edict_size)
#define	LATENCY_COUNTS   16
#define	RATE_MESSAGES   10
#define	MAX_CHALLENGES   1024
#define	SV_OUTPUTBUF_LENGTH   (MAX_MSGLEN - 16)

Typedefs
typedef struct client_s	client_t

Enumerations
enum	server_state_t {   ss_dead, ss_loading, ss_game, ss_cinematic,   ss_demo, ss_pic }
enum	client_state_t { cs_free, cs_zombie, cs_connected, cs_spawned }
enum	redirect_t { RD_NONE, RD_CLIENT, RD_PACKET }

Functions
void	SV_FinalMessage (char *message, qboolean reconnect)
void	SV_DropClient (client_t *drop)
int	SV_ModelIndex (char *name)
int	SV_SoundIndex (char *name)
int	SV_ImageIndex (char *name)
void	SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg)
void	SV_ExecuteUserCommand (char *s)
void	SV_InitOperatorCommands (void)
void	SV_SendServerinfo (client_t *client)
void	SV_UserinfoChanged (client_t *cl)
void	Master_Heartbeat (void)
void	Master_Packet (void)
void	SV_InitGame (void)
void	SV_Map (qboolean attractloop, char *levelstring, qboolean loadgame)
void	SV_PrepWorldFrame (void)
void	SV_FlushRedirect (int sv_redirected, char *outputbuf)
void	SV_DemoCompleted (void)
void	SV_SendClientMessages (void)
void	SV_Multicast (vec3_t origin, multicast_t to)
void	SV_StartSound (vec3_t origin, edict_t *entity, int channel, int soundindex, float volume, float attenuation, float timeofs)
void	SV_ClientPrintf (client_t *cl, int level, char *fmt,...)
void	SV_BroadcastPrintf (int level, char *fmt,...)
void	SV_BroadcastCommand (char *fmt,...)
void	SV_Nextserver (void)
void	SV_ExecuteClientMessage (client_t *cl)
void	SV_ReadLevelFile (void)
void	SV_Status_f (void)
void	SV_WriteFrameToClient (client_t *client, sizebuf_t *msg)
void	SV_RecordDemoMessage (void)
void	SV_BuildClientFrame (client_t *client)
void	SV_Error (char *error,...)
void	SV_InitGameProgs (void)
void	SV_ShutdownGameProgs (void)
void	SV_InitEdict (edict_t *e)
void	SV_ClearWorld (void)
void	SV_UnlinkEdict (edict_t *ent)
void	SV_LinkEdict (edict_t *ent)
int	SV_AreaEdicts (vec3_t mins, vec3_t maxs, edict_t **list, int maxcount, int areatype)
int	SV_PointContents (vec3_t p)
trace_t	SV_Trace (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, edict_t *passedict, int contentmask)

Variables
netadr_t	net_from
sizebuf_t	net_message
netadr_t	master_adr [MAX_MASTERS]
server_static_t	svs
server_t	sv
cvar_t *	sv_paused
cvar_t *	maxclients
cvar_t *	sv_noreload
cvar_t *	sv_airaccelerate
cvar_t *	sv_enforcetime
client_t *	sv_client
edict_t *	sv_player
char	sv_outputbuf [SV_OUTPUTBUF_LENGTH]
game_export_t *	ge

Macro Definition Documentation

EDICT_NUM

#define EDICT_NUM

(

n

)

((edict_t *)((byte *)ge->edicts + ge->edict_size*(n)))

Definition at line 69 of file server.h.

LATENCY_COUNTS

#define LATENCY_COUNTS   16

Definition at line 92 of file server.h.

MAX_CHALLENGES

#define MAX_CHALLENGES   1024

Definition at line 148 of file server.h.

MAX_MASTERS

#define MAX_MASTERS   8

Definition at line 30 of file server.h.

NUM_FOR_EDICT

#define NUM_FOR_EDICT

(

e

)

( ((byte *)(e)-(byte *)ge->edicts ) / ge->edict_size)

Definition at line 70 of file server.h.

RATE_MESSAGES

#define RATE_MESSAGES   10

Definition at line 93 of file server.h.

SV_OUTPUTBUF_LENGTH

#define SV_OUTPUTBUF_LENGTH   (MAX_MSGLEN - 16)

Definition at line 243 of file server.h.

Typedef Documentation

client_t

typedef struct client_s client_t

Enumeration Type Documentation

client_state_t

enum client_state_t

Enumerator
cs_free
cs_zombie
cs_connected
cs_spawned

Definition at line 73 of file server.h.

{
    cs_free,        // can be reused for a new connection
    cs_zombie,      // client has been disconnected, but don't reuse
                    // connection for a couple seconds
    cs_connected,   // has been assigned to a client_t, but not in game yet
    cs_spawned      // client is fully in game
} client_state_t;

redirect_t

enum redirect_t

Enumerator
RD_NONE
RD_CLIENT
RD_PACKET

Definition at line 242 of file server.h.

{RD_NONE, RD_CLIENT, RD_PACKET} redirect_t;

server_state_t

enum server_state_t

Enumerator
ss_dead
ss_loading
ss_game
ss_cinematic
ss_demo
ss_pic

Definition at line 32 of file server.h.

             {
    ss_dead,            // no map loaded
    ss_loading,         // spawning level edicts
    ss_game,            // actively running
    ss_cinematic,
    ss_demo,
    ss_pic
} server_state_t;

Function Documentation

Master_Heartbeat()

void Master_Heartbeat

(

void

)

Definition at line 827 of file sv_main.c.

{
    char        *string;
    int         i;
 
    // pgm post3.19 change, cvar pointer not validated before dereferencing
    if (!dedicated || !dedicated->value)
        return;     // only dedicated servers send heartbeats
 
    // pgm post3.19 change, cvar pointer not validated before dereferencing
    if (!public_server || !public_server->value)
        return;     // a private dedicated game
 
    // check for time wraparound
    if (svs.last_heartbeat > svs.realtime)
        svs.last_heartbeat = svs.realtime;
 
    if (svs.realtime - svs.last_heartbeat < HEARTBEAT_SECONDS*1000)
        return;     // not time to send yet
 
    svs.last_heartbeat = svs.realtime;
 
    // send the same string that we would give for a status OOB command
    string = SV_StatusString();
 
    // send to group master
    for (i=0 ; i<MAX_MASTERS ; i++)
        if (master_adr[i].port)
        {
            Com_Printf ("Sending heartbeat to %s\n", NET_AdrToString (master_adr[i]));
            Netchan_OutOfBandPrint (NS_SERVER, master_adr[i], "heartbeat\n%s", string);
        }
}

Referenced by SV_Frame().

Master_Packet()

void Master_Packet

(

void

)

SV_AreaEdicts()

int SV_AreaEdicts	(	vec3_t	mins,
		vec3_t	maxs,
		edict_t **	list,
		int	maxcount,
		int	areatype
	)

Definition at line 408 of file sv_world.c.

{
    area_mins = mins;
    area_maxs = maxs;
    area_list = list;
    area_count = 0;
    area_maxcount = maxcount;
    area_type = areatype;
 
    SV_AreaEdicts_r (sv_areanodes);
 
    return area_count;
}

Referenced by SV_ClipMoveToEntities(), SV_InitGameProgs(), and SV_PointContents().

SV_BroadcastCommand()

void SV_BroadcastCommand	(	char *	fmt,
			...
	)

Definition at line 132 of file sv_send.c.

{
    va_list     argptr;
    char        string[1024];
    
    if (!sv.state)
        return;
    va_start (argptr,fmt);
    vsprintf (string, fmt,argptr);
    va_end (argptr);
 
    MSG_WriteByte (&sv.multicast, svc_stufftext);
    MSG_WriteString (&sv.multicast, string);
    SV_Multicast (NULL, MULTICAST_ALL_R);
}

Referenced by SV_Map().

SV_BroadcastPrintf()

void SV_BroadcastPrintf	(	int	level,
		char *	fmt,
			...
	)

Definition at line 89 of file sv_send.c.

{
    va_list     argptr;
    char        string[2048];
    client_t    *cl;
    int         i;
 
    va_start (argptr,fmt);
    vsprintf (string, fmt,argptr);
    va_end (argptr);
    
    // echo to console
    if (dedicated->value)
    {
        char    copy[1024];
        int     i;
        
        // mask off high bits
        for (i=0 ; i<1023 && string[i] ; i++)
            copy[i] = string[i]&127;
        copy[i] = 0;
        Com_Printf ("%s", copy);
    }
 
    for (i=0, cl = svs.clients ; i<maxclients->value; i++, cl++)
    {
        if (level < cl->messagelevel)
            continue;
        if (cl->state != cs_spawned)
            continue;
        MSG_WriteByte (&cl->netchan.message, svc_print);
        MSG_WriteByte (&cl->netchan.message, level);
        MSG_WriteString (&cl->netchan.message, string);
    }
}

Referenced by SV_CheckTimeouts(), SV_InitGameProgs(), SV_Kick_f(), and SV_SendClientMessages().

SV_BuildClientFrame()

void SV_BuildClientFrame

(

client_t *

client

)

Definition at line 524 of file sv_ents.c.

{
    int     e, i;
    vec3_t  org;
    edict_t *ent;
    edict_t *clent;
    client_frame_t  *frame;
    entity_state_t  *state;
    int     l;
    int     clientarea, clientcluster;
    int     leafnum;
    int     c_fullsend;
    byte    *clientphs;
    byte    *bitvector;
 
    clent = client->edict;
    if (!clent->client)
        return;     // not in game yet
 
#if 0
    numprojs = 0; // no projectiles yet
#endif
 
    // this is the frame we are creating
    frame = &client->frames[sv.framenum & UPDATE_MASK];
 
    frame->senttime = svs.realtime; // save it for ping calc later
 
    // find the client's PVS
    for (i=0 ; i<3 ; i++)
        org[i] = clent->client->ps.pmove.origin[i]*0.125 + clent->client->ps.viewoffset[i];
 
    leafnum = CM_PointLeafnum (org);
    clientarea = CM_LeafArea (leafnum);
    clientcluster = CM_LeafCluster (leafnum);
 
    // calculate the visible areas
    frame->areabytes = CM_WriteAreaBits (frame->areabits, clientarea);
 
    // grab the current player_state_t
    frame->ps = clent->client->ps;
 
 
    SV_FatPVS (org);
    clientphs = CM_ClusterPHS (clientcluster);
 
    // build up the list of visible entities
    frame->num_entities = 0;
    frame->first_entity = svs.next_client_entities;
 
    c_fullsend = 0;
 
    for (e=1 ; e<ge->num_edicts ; e++)
    {
        ent = EDICT_NUM(e);
 
        // ignore ents without visible models
        if (ent->svflags & SVF_NOCLIENT)
            continue;
 
        // ignore ents without visible models unless they have an effect
        if (!ent->s.modelindex && !ent->s.effects && !ent->s.sound
            && !ent->s.event)
            continue;
 
        // ignore if not touching a PV leaf
        if (ent != clent)
        {
            // check area
            if (!CM_AreasConnected (clientarea, ent->areanum))
            {   // doors can legally straddle two areas, so
                // we may need to check another one
                if (!ent->areanum2
                    || !CM_AreasConnected (clientarea, ent->areanum2))
                    continue;       // blocked by a door
            }
 
            // beams just check one point for PHS
            if (ent->s.renderfx & RF_BEAM)
            {
                l = ent->clusternums[0];
                if ( !(clientphs[l >> 3] & (1 << (l&7) )) )
                    continue;
            }
            else
            {
                // FIXME: if an ent has a model and a sound, but isn't
                // in the PVS, only the PHS, clear the model
                if (ent->s.sound)
                {
                    bitvector = fatpvs; //clientphs;
                }
                else
                    bitvector = fatpvs;
 
                if (ent->num_clusters == -1)
                {   // too many leafs for individual check, go by headnode
                    if (!CM_HeadnodeVisible (ent->headnode, bitvector))
                        continue;
                    c_fullsend++;
                }
                else
                {   // check individual leafs
                    for (i=0 ; i < ent->num_clusters ; i++)
                    {
                        l = ent->clusternums[i];
                        if (bitvector[l >> 3] & (1 << (l&7) ))
                            break;
                    }
                    if (i == ent->num_clusters)
                        continue;       // not visible
                }
 
                if (!ent->s.modelindex)
                {   // don't send sounds if they will be attenuated away
                    vec3_t  delta;
                    float   len;
 
                    VectorSubtract (org, ent->s.origin, delta);
                    len = VectorLength (delta);
                    if (len > 400)
                        continue;
                }
            }
        }
 
#if 0
        if (SV_AddProjectileUpdate(ent))
            continue; // added as a special projectile
#endif
 
        // add it to the circular client_entities array
        state = &svs.client_entities[svs.next_client_entities%svs.num_client_entities];
        if (ent->s.number != e)
        {
            Com_DPrintf ("FIXING ENT->S.NUMBER!!!\n");
            ent->s.number = e;
        }
        *state = ent->s;
 
        // don't mark players missiles as solid
        if (ent->owner == client->edict)
            state->solid = 0;
 
        svs.next_client_entities++;
        frame->num_entities++;
    }
}

Referenced by SV_SendClientDatagram().

SV_ClearWorld()

void SV_ClearWorld

(

void

)

Definition at line 135 of file sv_world.c.

{
    memset (sv_areanodes, 0, sizeof(sv_areanodes));
    sv_numareanodes = 0;
    SV_CreateAreaNode (0, sv.models[1]->mins, sv.models[1]->maxs);
}

Referenced by SV_CheckForSavegame(), and SV_SpawnServer().

SV_ClientPrintf()

void SV_ClientPrintf	(	client_t *	cl,
		int	level,
		char *	fmt,
			...
	)

Definition at line 65 of file sv_send.c.

{
    va_list     argptr;
    char        string[1024];
    
    if (level < cl->messagelevel)
        return;
    
    va_start (argptr,fmt);
    vsprintf (string, fmt,argptr);
    va_end (argptr);
    
    MSG_WriteByte (&cl->netchan.message, svc_print);
    MSG_WriteByte (&cl->netchan.message, level);
    MSG_WriteString (&cl->netchan.message, string);
}

Referenced by PF_cprintf(), SV_ConSay_f(), and SV_Kick_f().

SV_DemoCompleted()

void SV_DemoCompleted

(

void

)

Definition at line 440 of file sv_send.c.

{
    if (sv.demofile)
    {
        fclose (sv.demofile);
        sv.demofile = NULL;
    }
    SV_Nextserver ();
}

Referenced by SV_SendClientMessages().

SV_DropClient()

void SV_DropClient

(

client_t *

drop

)

Definition at line 70 of file sv_main.c.

{
    // add the disconnect
    MSG_WriteByte (&drop->netchan.message, svc_disconnect);
 
    if (drop->state == cs_spawned)
    {
        // call the prog function for removing a client
        // this will remove the body, among other things
        ge->ClientDisconnect (drop->edict);
    }
 
    if (drop->download)
    {
        FS_FreeFile (drop->download);
        drop->download = NULL;
    }
 
    drop->state = cs_zombie;        // become free in a few seconds
    drop->name[0] = 0;
}

Referenced by SV_CheckTimeouts(), SV_Disconnect_f(), SV_ExecuteClientMessage(), SV_Kick_f(), and SV_SendClientMessages().

SV_Error()

void SV_Error	(	char *	error,
			...
	)

SV_ExecuteClientMessage()

void SV_ExecuteClientMessage

(

client_t *

cl

)

Definition at line 539 of file sv_user.c.

{
    int     c;
    char    *s;
 
    usercmd_t   nullcmd;
    usercmd_t   oldest, oldcmd, newcmd;
    int     net_drop;
    int     stringCmdCount;
    int     checksum, calculatedChecksum;
    int     checksumIndex;
    qboolean    move_issued;
    int     lastframe;
 
    sv_client = cl;
    sv_player = sv_client->edict;
 
    // only allow one move command
    move_issued = false;
    stringCmdCount = 0;
 
    while (1)
    {
        if (net_message.readcount > net_message.cursize)
        {
            Com_Printf ("SV_ReadClientMessage: badread\n");
            SV_DropClient (cl);
            return;
        }   
 
        c = MSG_ReadByte (&net_message);
        if (c == -1)
            break;
                
        switch (c)
        {
        default:
            Com_Printf ("SV_ReadClientMessage: unknown command char\n");
            SV_DropClient (cl);
            return;
                        
        case clc_nop:
            break;
 
        case clc_userinfo:
            strncpy (cl->userinfo, MSG_ReadString (&net_message), sizeof(cl->userinfo)-1);
            SV_UserinfoChanged (cl);
            break;
 
        case clc_move:
            if (move_issued)
                return;     // someone is trying to cheat...
 
            move_issued = true;
            checksumIndex = net_message.readcount;
            checksum = MSG_ReadByte (&net_message);
            lastframe = MSG_ReadLong (&net_message);
            if (lastframe != cl->lastframe) {
                cl->lastframe = lastframe;
                if (cl->lastframe > 0) {
                    cl->frame_latency[cl->lastframe&(LATENCY_COUNTS-1)] = 
                        svs.realtime - cl->frames[cl->lastframe & UPDATE_MASK].senttime;
                }
            }
 
            memset (&nullcmd, 0, sizeof(nullcmd));
            MSG_ReadDeltaUsercmd (&net_message, &nullcmd, &oldest);
            MSG_ReadDeltaUsercmd (&net_message, &oldest, &oldcmd);
            MSG_ReadDeltaUsercmd (&net_message, &oldcmd, &newcmd);
 
            if ( cl->state != cs_spawned )
            {
                cl->lastframe = -1;
                break;
            }
 
            // if the checksum fails, ignore the rest of the packet
            calculatedChecksum = COM_BlockSequenceCRCByte (
                net_message.data + checksumIndex + 1,
                net_message.readcount - checksumIndex - 1,
                cl->netchan.incoming_sequence);
 
            if (calculatedChecksum != checksum)
            {
                Com_DPrintf ("Failed command checksum for %s (%d != %d)/%d\n", 
                    cl->name, calculatedChecksum, checksum, 
                    cl->netchan.incoming_sequence);
                return;
            }
 
            if (!sv_paused->value)
            {
                net_drop = cl->netchan.dropped;
                if (net_drop < 20)
                {
 
//if (net_drop > 2)
 
//  Com_Printf ("drop %i\n", net_drop);
                    while (net_drop > 2)
                    {
                        SV_ClientThink (cl, &cl->lastcmd);
 
                        net_drop--;
                    }
                    if (net_drop > 1)
                        SV_ClientThink (cl, &oldest);
 
                    if (net_drop > 0)
                        SV_ClientThink (cl, &oldcmd);
 
                }
                SV_ClientThink (cl, &newcmd);
            }
 
            cl->lastcmd = newcmd;
            break;
 
        case clc_stringcmd: 
            s = MSG_ReadString (&net_message);
 
            // malicious users may try using too many string commands
            if (++stringCmdCount < MAX_STRINGCMDS)
                SV_ExecuteUserCommand (s);
 
            if (cl->state == cs_zombie)
                return; // disconnect command
            break;
        }
    }
}

Referenced by SV_ReadPackets().

SV_ExecuteUserCommand()

void SV_ExecuteUserCommand

(

char *

s

)

Definition at line 477 of file sv_user.c.

{
    ucmd_t  *u;
    
    /*******
     * Security Fix... This is being set to false so that client's can't
     * macro expand variables on the server.  It seems unlikely that a
     * client ever ought to need to be able to do this...
     * old line = Cmd_TokenizeString (s, true);
     *******/
    Cmd_TokenizeString(s, false);
    sv_player = sv_client->edict;
 
//  SV_BeginRedirect (RD_CLIENT);
 
    for (u=ucmds ; u->name ; u++)
        if (!strcmp (Cmd_Argv(0), u->name) )
        {
            u->func ();
            break;
        }
 
    if (!u->name && sv.state == ss_game)
        ge->ClientCommand (sv_player);
 
//  SV_EndRedirect ();
}

Referenced by SV_ExecuteClientMessage().

SV_FinalMessage()

void SV_FinalMessage	(	char *	message,
		qboolean	reconnect
	)

Definition at line 996 of file sv_main.c.

{
    int         i;
    client_t    *cl;
    
    SZ_Clear (&net_message);
    MSG_WriteByte (&net_message, svc_print);
    MSG_WriteByte (&net_message, PRINT_HIGH);
    MSG_WriteString (&net_message, message);
 
    if (reconnect)
        MSG_WriteByte (&net_message, svc_reconnect);
    else
        MSG_WriteByte (&net_message, svc_disconnect);
 
    // send it twice
    // stagger the packets to crutch operating system limited buffers
 
    for (i=0, cl = svs.clients ; i<maxclients->value ; i++, cl++)
        if (cl->state >= cs_connected)
            Netchan_Transmit (&cl->netchan, net_message.cursize
            , net_message.data);
 
    for (i=0, cl = svs.clients ; i<maxclients->value ; i++, cl++)
        if (cl->state >= cs_connected)
            Netchan_Transmit (&cl->netchan, net_message.cursize
            , net_message.data);
}

Referenced by SV_Shutdown().

SV_FlushRedirect()

void SV_FlushRedirect	(	int	sv_redirected,
		char *	outputbuf
	)

Definition at line 34 of file sv_send.c.

{
    if (sv_redirected == RD_PACKET)
    {
        Netchan_OutOfBandPrint (NS_SERVER, net_from, "print\n%s", outputbuf);
    }
    else if (sv_redirected == RD_CLIENT)
    {
        MSG_WriteByte (&sv_client->netchan.message, svc_print);
        MSG_WriteByte (&sv_client->netchan.message, PRINT_HIGH);
        MSG_WriteString (&sv_client->netchan.message, outputbuf);
    }
}

Referenced by SVC_RemoteCommand(), and SVC_Status().

SV_ImageIndex()

int SV_ImageIndex

(

char *

name

)

Definition at line 74 of file sv_init.c.

{
    return SV_FindIndex (name, CS_IMAGES, MAX_IMAGES, true);
}

Referenced by SV_InitGameProgs().

SV_InitEdict()

void SV_InitEdict

(

edict_t *

e

)

SV_InitGame()

void SV_InitGame

(

void

)

Definition at line 289 of file sv_init.c.

{
    int     i;
    edict_t *ent;
    char    idmaster[32];
 
    if (svs.initialized)
    {
        // cause any connected clients to reconnect
        SV_Shutdown ("Server restarted\n", true);
    }
    else
    {
        // make sure the client is down
        CL_Drop ();
        SCR_BeginLoadingPlaque ();
    }
 
    // get any latched variable changes (maxclients, etc)
    Cvar_GetLatchedVars ();
 
    svs.initialized = true;
 
    if (Cvar_VariableValue ("coop") && Cvar_VariableValue ("deathmatch"))
    {
        Com_Printf("Deathmatch and Coop both set, disabling Coop\n");
        Cvar_FullSet ("coop", "0",  CVAR_SERVERINFO | CVAR_LATCH);
    }
 
    // dedicated servers are can't be single player and are usually DM
    // so unless they explicity set coop, force it to deathmatch
    if (dedicated->value)
    {
        if (!Cvar_VariableValue ("coop"))
            Cvar_FullSet ("deathmatch", "1",  CVAR_SERVERINFO | CVAR_LATCH);
    }
 
    // init clients
    if (Cvar_VariableValue ("deathmatch"))
    {
        if (maxclients->value <= 1)
            Cvar_FullSet ("maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH);
        else if (maxclients->value > MAX_CLIENTS)
            Cvar_FullSet ("maxclients", va("%i", MAX_CLIENTS), CVAR_SERVERINFO | CVAR_LATCH);
    }
    else if (Cvar_VariableValue ("coop"))
    {
        if (maxclients->value <= 1 || maxclients->value > 4)
            Cvar_FullSet ("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH);
#ifdef COPYPROTECT
        if (!sv.attractloop && !dedicated->value)
            Sys_CopyProtect ();
#endif
    }
    else    // non-deathmatch, non-coop is one player
    {
        Cvar_FullSet ("maxclients", "1", CVAR_SERVERINFO | CVAR_LATCH);
#ifdef COPYPROTECT
        if (!sv.attractloop)
            Sys_CopyProtect ();
#endif
    }
 
    svs.spawncount = rand();
    svs.clients = Z_Malloc (sizeof(client_t)*maxclients->value);
    svs.num_client_entities = maxclients->value*UPDATE_BACKUP*64;
    svs.client_entities = Z_Malloc (sizeof(entity_state_t)*svs.num_client_entities);
 
    // init network stuff
    NET_Config ( (maxclients->value > 1) );
 
    // heartbeats will always be sent to the id master
    svs.last_heartbeat = -99999;        // send immediately
    Com_sprintf(idmaster, sizeof(idmaster), "192.246.40.37:%i", PORT_MASTER);
    NET_StringToAdr (idmaster, &master_adr[0]);
 
    // init game
    SV_InitGameProgs ();
    for (i=0 ; i<maxclients->value ; i++)
    {
        ent = EDICT_NUM(i+1);
        ent->s.number = i+1;
        svs.clients[i].edict = ent;
        memset (&svs.clients[i].lastcmd, 0, sizeof(svs.clients[i].lastcmd));
    }
}

Referenced by SV_Map(), and SV_ReadServerFile().

SV_InitGameProgs()

void SV_InitGameProgs

(

void

)

Definition at line 325 of file sv_game.c.

{
    game_import_t   import;
 
    // unload anything we have now
    if (ge)
        SV_ShutdownGameProgs ();
 
 
    // load a new game dll
    import.multicast = SV_Multicast;
    import.unicast = PF_Unicast;
    import.bprintf = SV_BroadcastPrintf;
    import.dprintf = PF_dprintf;
    import.cprintf = PF_cprintf;
    import.centerprintf = PF_centerprintf;
    import.error = PF_error;
 
    import.linkentity = SV_LinkEdict;
    import.unlinkentity = SV_UnlinkEdict;
    import.BoxEdicts = SV_AreaEdicts;
    import.trace = SV_Trace;
    import.pointcontents = SV_PointContents;
    import.setmodel = PF_setmodel;
    import.inPVS = PF_inPVS;
    import.inPHS = PF_inPHS;
    import.Pmove = Pmove;
 
    import.modelindex = SV_ModelIndex;
    import.soundindex = SV_SoundIndex;
    import.imageindex = SV_ImageIndex;
 
    import.configstring = PF_Configstring;
    import.sound = PF_StartSound;
    import.positioned_sound = SV_StartSound;
 
    import.WriteChar = PF_WriteChar;
    import.WriteByte = PF_WriteByte;
    import.WriteShort = PF_WriteShort;
    import.WriteLong = PF_WriteLong;
    import.WriteFloat = PF_WriteFloat;
    import.WriteString = PF_WriteString;
    import.WritePosition = PF_WritePos;
    import.WriteDir = PF_WriteDir;
    import.WriteAngle = PF_WriteAngle;
 
    import.TagMalloc = Z_TagMalloc;
    import.TagFree = Z_Free;
    import.FreeTags = Z_FreeTags;
 
    import.cvar = Cvar_Get;
    import.cvar_set = Cvar_Set;
    import.cvar_forceset = Cvar_ForceSet;
 
    import.argc = Cmd_Argc;
    import.argv = Cmd_Argv;
    import.args = Cmd_Args;
    import.AddCommandString = Cbuf_AddText;
 
    import.DebugGraph = SCR_DebugGraph;
    import.SetAreaPortalState = CM_SetAreaPortalState;
    import.AreasConnected = CM_AreasConnected;
 
    ge = (game_export_t *)Sys_GetGameAPI (&import);
 
    if (!ge)
        Com_Error (ERR_DROP, "failed to load game DLL");
    if (ge->apiversion != GAME_API_VERSION)
        Com_Error (ERR_DROP, "game is version %i, not %i", ge->apiversion,
        GAME_API_VERSION);
 
    ge->Init ();
}

Referenced by SV_InitGame().

SV_InitOperatorCommands()

void SV_InitOperatorCommands

(

void

)

Definition at line 1024 of file sv_ccmds.c.

{
    Cmd_AddCommand ("heartbeat", SV_Heartbeat_f);
    Cmd_AddCommand ("kick", SV_Kick_f);
    Cmd_AddCommand ("status", SV_Status_f);
    Cmd_AddCommand ("serverinfo", SV_Serverinfo_f);
    Cmd_AddCommand ("dumpuser", SV_DumpUser_f);
 
    Cmd_AddCommand ("map", SV_Map_f);
    Cmd_AddCommand ("demomap", SV_DemoMap_f);
    Cmd_AddCommand ("gamemap", SV_GameMap_f);
    Cmd_AddCommand ("setmaster", SV_SetMaster_f);
 
    if ( dedicated->value )
        Cmd_AddCommand ("say", SV_ConSay_f);
 
    Cmd_AddCommand ("serverrecord", SV_ServerRecord_f);
    Cmd_AddCommand ("serverstop", SV_ServerStop_f);
 
    Cmd_AddCommand ("save", SV_Savegame_f);
    Cmd_AddCommand ("load", SV_Loadgame_f);
 
    Cmd_AddCommand ("killserver", SV_KillServer_f);
 
    Cmd_AddCommand ("sv", SV_ServerCommand_f);
}

Referenced by SV_Init().

SV_LinkEdict()

void SV_LinkEdict

(

edict_t *

ent

)

Definition at line 165 of file sv_world.c.

{
    areanode_t  *node;
    int         leafs[MAX_TOTAL_ENT_LEAFS];
    int         clusters[MAX_TOTAL_ENT_LEAFS];
    int         num_leafs;
    int         i, j, k;
    int         area;
    int         topnode;
 
    if (ent->area.prev)
        SV_UnlinkEdict (ent);   // unlink from old position
        
    if (ent == ge->edicts)
        return;     // don't add the world
 
    if (!ent->inuse)
        return;
 
    // set the size
    VectorSubtract (ent->maxs, ent->mins, ent->size);
    
    // encode the size into the entity_state for client prediction
    if (ent->solid == SOLID_BBOX && !(ent->svflags & SVF_DEADMONSTER))
    {   // assume that x/y are equal and symetric
        i = ent->maxs[0]/8;
        if (i<1)
            i = 1;
        if (i>31)
            i = 31;
 
        // z is not symetric
        j = (-ent->mins[2])/8;
        if (j<1)
            j = 1;
        if (j>31)
            j = 31;
 
        // and z maxs can be negative...
        k = (ent->maxs[2]+32)/8;
        if (k<1)
            k = 1;
        if (k>63)
            k = 63;
 
        ent->s.solid = (k<<10) | (j<<5) | i;
    }
    else if (ent->solid == SOLID_BSP)
    {
        ent->s.solid = 31;      // a solid_bbox will never create this value
    }
    else
        ent->s.solid = 0;
 
    // set the abs box
    if (ent->solid == SOLID_BSP && 
    (ent->s.angles[0] || ent->s.angles[1] || ent->s.angles[2]) )
    {   // expand for rotation
        float       max, v;
        int         i;
 
        max = 0;
        for (i=0 ; i<3 ; i++)
        {
            v =fabs( ent->mins[i]);
            if (v > max)
                max = v;
            v =fabs( ent->maxs[i]);
            if (v > max)
                max = v;
        }
        for (i=0 ; i<3 ; i++)
        {
            ent->absmin[i] = ent->s.origin[i] - max;
            ent->absmax[i] = ent->s.origin[i] + max;
        }
    }
    else
    {   // normal
        VectorAdd (ent->s.origin, ent->mins, ent->absmin);  
        VectorAdd (ent->s.origin, ent->maxs, ent->absmax);
    }
 
    // because movement is clipped an epsilon away from an actual edge,
    // we must fully check even when bounding boxes don't quite touch
    ent->absmin[0] -= 1;
    ent->absmin[1] -= 1;
    ent->absmin[2] -= 1;
    ent->absmax[0] += 1;
    ent->absmax[1] += 1;
    ent->absmax[2] += 1;
 
// link to PVS leafs
    ent->num_clusters = 0;
    ent->areanum = 0;
    ent->areanum2 = 0;
 
    //get all leafs, including solids
    num_leafs = CM_BoxLeafnums (ent->absmin, ent->absmax,
        leafs, MAX_TOTAL_ENT_LEAFS, &topnode);
 
    // set areas
    for (i=0 ; i<num_leafs ; i++)
    {
        clusters[i] = CM_LeafCluster (leafs[i]);
        area = CM_LeafArea (leafs[i]);
        if (area)
        {   // doors may legally straggle two areas,
            // but nothing should evern need more than that
            if (ent->areanum && ent->areanum != area)
            {
                if (ent->areanum2 && ent->areanum2 != area && sv.state == ss_loading)
                    Com_DPrintf ("Object touching 3 areas at %f %f %f\n",
                    ent->absmin[0], ent->absmin[1], ent->absmin[2]);
                ent->areanum2 = area;
            }
            else
                ent->areanum = area;
        }
    }
 
    if (num_leafs >= MAX_TOTAL_ENT_LEAFS)
    {   // assume we missed some leafs, and mark by headnode
        ent->num_clusters = -1;
        ent->headnode = topnode;
    }
    else
    {
        ent->num_clusters = 0;
        for (i=0 ; i<num_leafs ; i++)
        {
            if (clusters[i] == -1)
                continue;       // not a visible leaf
            for (j=0 ; j<i ; j++)
                if (clusters[j] == clusters[i])
                    break;
            if (j == i)
            {
                if (ent->num_clusters == MAX_ENT_CLUSTERS)
                {   // assume we missed some leafs, and mark by headnode
                    ent->num_clusters = -1;
                    ent->headnode = topnode;
                    break;
                }
 
                ent->clusternums[ent->num_clusters++] = clusters[i];
            }
        }
    }
 
    // if first time, make sure old_origin is valid
    if (!ent->linkcount)
    {
        VectorCopy (ent->s.origin, ent->s.old_origin);
    }
    ent->linkcount++;
 
    if (ent->solid == SOLID_NOT)
        return;
 
// find the first node that the ent's box crosses
    node = sv_areanodes;
    while (1)
    {
        if (node->axis == -1)
            break;
        if (ent->absmin[node->axis] > node->dist)
            node = node->children[0];
        else if (ent->absmax[node->axis] < node->dist)
            node = node->children[1];
        else
            break;      // crosses the node
    }
    
    // link it in   
    if (ent->solid == SOLID_TRIGGER)
        InsertLinkBefore (&ent->area, &node->trigger_edicts);
    else
        InsertLinkBefore (&ent->area, &node->solid_edicts);
 
}

Referenced by PF_setmodel(), and SV_InitGameProgs().

SV_Map()

void SV_Map	(	qboolean	attractloop,
		char *	levelstring,
		qboolean	loadgame
	)

Definition at line 393 of file sv_init.c.

{
    char    level[MAX_QPATH];
    char    *ch;
    int     l;
    char    spawnpoint[MAX_QPATH];
 
    sv.loadgame = loadgame;
    sv.attractloop = attractloop;
 
    if (sv.state == ss_dead && !sv.loadgame)
        SV_InitGame (); // the game is just starting
 
    strcpy (level, levelstring);
 
    // if there is a + in the map, set nextserver to the remainder
    ch = strstr(level, "+");
    if (ch)
    {
        *ch = 0;
            Cvar_Set ("nextserver", va("gamemap \"%s\"", ch+1));
    }
    else
        Cvar_Set ("nextserver", "");
 
    //ZOID special hack for end game screen in coop mode
    if (Cvar_VariableValue ("coop") && !Q_stricmp(level, "victory.pcx"))
        Cvar_Set ("nextserver", "gamemap \"*base1\"");
 
    // if there is a $, use the remainder as a spawnpoint
    ch = strstr(level, "$");
    if (ch)
    {
        *ch = 0;
        strcpy (spawnpoint, ch+1);
    }
    else
        spawnpoint[0] = 0;
 
    // skip the end-of-unit flag if necessary
    if (level[0] == '*')
        strcpy (level, level+1);
 
    l = strlen(level);
    if (l > 4 && !strcmp (level+l-4, ".cin") )
    {
        SCR_BeginLoadingPlaque ();          // for local system
        SV_BroadcastCommand ("changing\n");
        SV_SpawnServer (level, spawnpoint, ss_cinematic, attractloop, loadgame);
    }
    else if (l > 4 && !strcmp (level+l-4, ".dm2") )
    {
        SCR_BeginLoadingPlaque ();          // for local system
        SV_BroadcastCommand ("changing\n");
        SV_SpawnServer (level, spawnpoint, ss_demo, attractloop, loadgame);
    }
    else if (l > 4 && !strcmp (level+l-4, ".pcx") )
    {
        SCR_BeginLoadingPlaque ();          // for local system
        SV_BroadcastCommand ("changing\n");
        SV_SpawnServer (level, spawnpoint, ss_pic, attractloop, loadgame);
    }
    else
    {
        SCR_BeginLoadingPlaque ();          // for local system
        SV_BroadcastCommand ("changing\n");
        SV_SendClientMessages ();
        SV_SpawnServer (level, spawnpoint, ss_game, attractloop, loadgame);
        Cbuf_CopyToDefer ();
    }
 
    SV_BroadcastCommand ("reconnect\n");
}

Referenced by SV_DemoMap_f(), SV_GameMap_f(), and SV_Loadgame_f().

SV_ModelIndex()

int SV_ModelIndex

(

char *

name

)

Definition at line 64 of file sv_init.c.

{
    return SV_FindIndex (name, CS_MODELS, MAX_MODELS, true);
}

Referenced by PF_setmodel(), and SV_InitGameProgs().

SV_Multicast()

void SV_Multicast	(	vec3_t	origin,
		multicast_t	to
	)

Definition at line 161 of file sv_send.c.

{
    client_t    *client;
    byte        *mask;
    int         leafnum, cluster;
    int         j;
    qboolean    reliable;
    int         area1, area2;
 
    reliable = false;
 
    if (to != MULTICAST_ALL_R && to != MULTICAST_ALL)
    {
        leafnum = CM_PointLeafnum (origin);
        area1 = CM_LeafArea (leafnum);
    }
    else
    {
        leafnum = 0;    // just to avoid compiler warnings
        area1 = 0;
    }
 
    // if doing a serverrecord, store everything
    if (svs.demofile)
        SZ_Write (&svs.demo_multicast, sv.multicast.data, sv.multicast.cursize);
    
    switch (to)
    {
    case MULTICAST_ALL_R:
        reliable = true;    // intentional fallthrough
    case MULTICAST_ALL:
        leafnum = 0;
        mask = NULL;
        break;
 
    case MULTICAST_PHS_R:
        reliable = true;    // intentional fallthrough
    case MULTICAST_PHS:
        leafnum = CM_PointLeafnum (origin);
        cluster = CM_LeafCluster (leafnum);
        mask = CM_ClusterPHS (cluster);
        break;
 
    case MULTICAST_PVS_R:
        reliable = true;    // intentional fallthrough
    case MULTICAST_PVS:
        leafnum = CM_PointLeafnum (origin);
        cluster = CM_LeafCluster (leafnum);
        mask = CM_ClusterPVS (cluster);
        break;
 
    default:
        mask = NULL;
        Com_Error (ERR_FATAL, "SV_Multicast: bad to:%i", to);
    }
 
    // send the data to all relevent clients
    for (j = 0, client = svs.clients; j < maxclients->value; j++, client++)
    {
        if (client->state == cs_free || client->state == cs_zombie)
            continue;
        if (client->state != cs_spawned && !reliable)
            continue;
 
        if (mask)
        {
            leafnum = CM_PointLeafnum (client->edict->s.origin);
            cluster = CM_LeafCluster (leafnum);
            area2 = CM_LeafArea (leafnum);
            if (!CM_AreasConnected (area1, area2))
                continue;
            if ( mask && (!(mask[cluster>>3] & (1<<(cluster&7)) ) ) )
                continue;
        }
 
        if (reliable)
            SZ_Write (&client->netchan.message, sv.multicast.data, sv.multicast.cursize);
        else
            SZ_Write (&client->datagram, sv.multicast.data, sv.multicast.cursize);
    }
 
    SZ_Clear (&sv.multicast);
}

Referenced by PF_Configstring(), SV_BroadcastCommand(), SV_FindIndex(), SV_InitGameProgs(), and SV_StartSound().

SV_Nextserver()

void SV_Nextserver

(

void

)

Definition at line 405 of file sv_user.c.

{
    char    *v;
 
    //ZOID, ss_pic can be nextserver'd in coop mode
    if (sv.state == ss_game || (sv.state == ss_pic && !Cvar_VariableValue("coop")))
        return;     // can't nextserver while playing a normal game
 
    svs.spawncount++;   // make sure another doesn't sneak in
    v = Cvar_VariableString ("nextserver");
    if (!v[0])
        Cbuf_AddText ("killserver\n");
    else
    {
        Cbuf_AddText (v);
        Cbuf_AddText ("\n");
    }
    Cvar_Set ("nextserver","");
}

Referenced by SV_DemoCompleted(), and SV_Nextserver_f().

SV_PointContents()

int SV_PointContents

(

vec3_t

p

)

Definition at line 431 of file sv_world.c.

{
    edict_t     *touch[MAX_EDICTS], *hit;
    int         i, num;
    int         contents, c2;
    int         headnode;
    float       *angles;
 
    // get base contents from world
    contents = CM_PointContents (p, sv.models[1]->headnode);
 
    // or in contents from all the other entities
    num = SV_AreaEdicts (p, p, touch, MAX_EDICTS, AREA_SOLID);
 
    for (i=0 ; i<num ; i++)
    {
        hit = touch[i];
 
        // might intersect, so do an exact clip
        headnode = SV_HullForEntity (hit);
        angles = hit->s.angles;
        if (hit->solid != SOLID_BSP)
            angles = vec3_origin;   // boxes don't rotate
 
        c2 = CM_TransformedPointContents (p, headnode, hit->s.origin, hit->s.angles);
 
        contents |= c2;
    }
 
    return contents;
}

Referenced by SV_InitGameProgs().

SV_PrepWorldFrame()

void SV_PrepWorldFrame

(

void

)

Definition at line 703 of file sv_main.c.

{
    edict_t *ent;
    int     i;
 
    for (i=0 ; i<ge->num_edicts ; i++, ent++)
    {
        ent = EDICT_NUM(i);
        // events only last for a single message
        ent->s.event = 0;
    }
 
}

Referenced by SV_Frame().

SV_ReadLevelFile()

void SV_ReadLevelFile

(

void

)

Definition at line 306 of file sv_ccmds.c.

{
    char    name[MAX_OSPATH];
    FILE    *f;
 
    Com_DPrintf("SV_ReadLevelFile()\n");
 
    Com_sprintf (name, sizeof(name), "%s/save/current/%s.sv2", FS_Gamedir(), sv.name);
    f = fopen(name, "rb");
    if (!f)
    {
        Com_Printf ("Failed to open %s\n", name);
        return;
    }
    FS_Read (sv.configstrings, sizeof(sv.configstrings), f);
    CM_ReadPortalState (f);
    fclose (f);
 
    Com_sprintf (name, sizeof(name), "%s/save/current/%s.sav", FS_Gamedir(), sv.name);
    ge->ReadLevel (name);
}

Referenced by SV_CheckForSavegame().

SV_RecordDemoMessage()

void SV_RecordDemoMessage

(

void

)

Definition at line 682 of file sv_ents.c.

{
    int         e;
    edict_t     *ent;
    entity_state_t  nostate;
    sizebuf_t   buf;
    byte        buf_data[32768];
    int         len;
 
    if (!svs.demofile)
        return;
 
    memset (&nostate, 0, sizeof(nostate));
    SZ_Init (&buf, buf_data, sizeof(buf_data));
 
    // write a frame message that doesn't contain a player_state_t
    MSG_WriteByte (&buf, svc_frame);
    MSG_WriteLong (&buf, sv.framenum);
 
    MSG_WriteByte (&buf, svc_packetentities);
 
    e = 1;
    ent = EDICT_NUM(e);
    while (e < ge->num_edicts) 
    {
        // ignore ents without visible models unless they have an effect
        if (ent->inuse &&
            ent->s.number && 
            (ent->s.modelindex || ent->s.effects || ent->s.sound || ent->s.event) && 
            !(ent->svflags & SVF_NOCLIENT))
            MSG_WriteDeltaEntity (&nostate, &ent->s, &buf, false, true);
 
        e++;
        ent = EDICT_NUM(e);
    }
 
    MSG_WriteShort (&buf, 0);       // end of packetentities
 
    // now add the accumulated multicast information
    SZ_Write (&buf, svs.demo_multicast.data, svs.demo_multicast.cursize);
    SZ_Clear (&svs.demo_multicast);
 
    // now write the entire message to the file, prefixed by the length
    len = LittleLong (buf.cursize);
    fwrite (&len, 4, 1, svs.demofile);
    fwrite (buf.data, buf.cursize, 1, svs.demofile);
}

Referenced by SV_Frame().

SV_SendClientMessages()

void SV_SendClientMessages

(

void

)

Definition at line 490 of file sv_send.c.

{
    int         i;
    client_t    *c;
    int         msglen;
    byte        msgbuf[MAX_MSGLEN];
    int         r;
 
    msglen = 0;
 
    // read the next demo message if needed
    if (sv.state == ss_demo && sv.demofile)
    {
        if (sv_paused->value)
            msglen = 0;
        else
        {
            // get the next message
            r = fread (&msglen, 4, 1, sv.demofile);
            if (r != 1)
            {
                SV_DemoCompleted ();
                return;
            }
            msglen = LittleLong (msglen);
            if (msglen == -1)
            {
                SV_DemoCompleted ();
                return;
            }
            if (msglen > MAX_MSGLEN)
                Com_Error (ERR_DROP, "SV_SendClientMessages: msglen > MAX_MSGLEN");
            r = fread (msgbuf, msglen, 1, sv.demofile);
            if (r != 1)
            {
                SV_DemoCompleted ();
                return;
            }
        }
    }
 
    // send a message to each connected client
    for (i=0, c = svs.clients ; i<maxclients->value; i++, c++)
    {
        if (!c->state)
            continue;
        // if the reliable message overflowed,
        // drop the client
        if (c->netchan.message.overflowed)
        {
            SZ_Clear (&c->netchan.message);
            SZ_Clear (&c->datagram);
            SV_BroadcastPrintf (PRINT_HIGH, "%s overflowed\n", c->name);
            SV_DropClient (c);
        }
 
        if (sv.state == ss_cinematic 
            || sv.state == ss_demo 
            || sv.state == ss_pic
            )
            Netchan_Transmit (&c->netchan, msglen, msgbuf);
        else if (c->state == cs_spawned)
        {
            // don't overrun bandwidth
            if (SV_RateDrop (c))
                continue;
 
            SV_SendClientDatagram (c);
        }
        else
        {
    // just update reliable if needed
            if (c->netchan.message.cursize  || curtime - c->netchan.last_sent > 1000 )
                Netchan_Transmit (&c->netchan, 0, NULL);
        }
    }
}

Referenced by SV_Frame(), and SV_Map().

SV_SendServerinfo()

void SV_SendServerinfo

(

client_t *

client

)

SV_ShutdownGameProgs()

void SV_ShutdownGameProgs

(

void

)

Definition at line 307 of file sv_game.c.

{
    if (!ge)
        return;
    ge->Shutdown ();
    Sys_UnloadGame ();
    ge = NULL;
}

Referenced by SV_InitGameProgs(), and SV_Shutdown().

SV_SoundIndex()

int SV_SoundIndex

(

char *

name

)

Definition at line 69 of file sv_init.c.

{
    return SV_FindIndex (name, CS_SOUNDS, MAX_SOUNDS, true);
}

Referenced by SV_InitGameProgs().

SV_StartSound()

void SV_StartSound	(	vec3_t	origin,
		edict_t *	entity,
		int	channel,
		int	soundindex,
		float	volume,
		float	attenuation,
		float	timeofs
	)

Definition at line 272 of file sv_send.c.

{       
    int         sendchan;
    int         flags;
    int         i;
    int         ent;
    vec3_t      origin_v;
    qboolean    use_phs;
 
    if (volume < 0 || volume > 1.0)
        Com_Error (ERR_FATAL, "SV_StartSound: volume = %f", volume);
 
    if (attenuation < 0 || attenuation > 4)
        Com_Error (ERR_FATAL, "SV_StartSound: attenuation = %f", attenuation);
 
//  if (channel < 0 || channel > 15)
//      Com_Error (ERR_FATAL, "SV_StartSound: channel = %i", channel);
 
    if (timeofs < 0 || timeofs > 0.255)
        Com_Error (ERR_FATAL, "SV_StartSound: timeofs = %f", timeofs);
 
    ent = NUM_FOR_EDICT(entity);
 
    if (channel & 8)    // no PHS flag
    {
        use_phs = false;
        channel &= 7;
    }
    else
        use_phs = true;
 
    sendchan = (ent<<3) | (channel&7);
 
    flags = 0;
    if (volume != DEFAULT_SOUND_PACKET_VOLUME)
        flags |= SND_VOLUME;
    if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
        flags |= SND_ATTENUATION;
 
    // the client doesn't know that bmodels have weird origins
    // the origin can also be explicitly set
    if ( (entity->svflags & SVF_NOCLIENT)
        || (entity->solid == SOLID_BSP) 
        || origin )
        flags |= SND_POS;
 
    // always send the entity number for channel overrides
    flags |= SND_ENT;
 
    if (timeofs)
        flags |= SND_OFFSET;
 
    // use the entity origin unless it is a bmodel or explicitly specified
    if (!origin)
    {
        origin = origin_v;
        if (entity->solid == SOLID_BSP)
        {
            for (i=0 ; i<3 ; i++)
                origin_v[i] = entity->s.origin[i]+0.5*(entity->mins[i]+entity->maxs[i]);
        }
        else
        {
            VectorCopy (entity->s.origin, origin_v);
        }
    }
 
    MSG_WriteByte (&sv.multicast, svc_sound);
    MSG_WriteByte (&sv.multicast, flags);
    MSG_WriteByte (&sv.multicast, soundindex);
 
    if (flags & SND_VOLUME)
        MSG_WriteByte (&sv.multicast, volume*255);
    if (flags & SND_ATTENUATION)
        MSG_WriteByte (&sv.multicast, attenuation*64);
    if (flags & SND_OFFSET)
        MSG_WriteByte (&sv.multicast, timeofs*1000);
 
    if (flags & SND_ENT)
        MSG_WriteShort (&sv.multicast, sendchan);
 
    if (flags & SND_POS)
        MSG_WritePos (&sv.multicast, origin);
 
    // if the sound doesn't attenuate,send it to everyone
    // (global radio chatter, voiceovers, etc)
    if (attenuation == ATTN_NONE)
        use_phs = false;
 
    if (channel & CHAN_RELIABLE)
    {
        if (use_phs)
            SV_Multicast (origin, MULTICAST_PHS_R);
        else
            SV_Multicast (origin, MULTICAST_ALL_R);
    }
    else
    {
        if (use_phs)
            SV_Multicast (origin, MULTICAST_PHS);
        else
            SV_Multicast (origin, MULTICAST_ALL);
    }
}           

Referenced by PF_StartSound(), and SV_InitGameProgs().

SV_Status_f()

void SV_Status_f

(

void

)

Definition at line 737 of file sv_ccmds.c.

{
    int         i, j, l;
    client_t    *cl;
    char        *s;
    int         ping;
    if (!svs.clients)
    {
        Com_Printf ("No server running.\n");
        return;
    }
    Com_Printf ("map              : %s\n", sv.name);
 
    Com_Printf ("num score ping name            lastmsg address               qport \n");
    Com_Printf ("--- ----- ---- --------------- ------- --------------------- ------\n");
    for (i=0,cl=svs.clients ; i<maxclients->value; i++,cl++)
    {
        if (!cl->state)
            continue;
        Com_Printf ("%3i ", i);
        Com_Printf ("%5i ", cl->edict->client->ps.stats[STAT_FRAGS]);
 
        if (cl->state == cs_connected)
            Com_Printf ("CNCT ");
        else if (cl->state == cs_zombie)
            Com_Printf ("ZMBI ");
        else
        {
            ping = cl->ping < 9999 ? cl->ping : 9999;
            Com_Printf ("%4i ", ping);
        }
 
        Com_Printf ("%s", cl->name);
        l = 16 - strlen(cl->name);
        for (j=0 ; j<l ; j++)
            Com_Printf (" ");
 
        Com_Printf ("%7i ", svs.realtime - cl->lastmessage );
 
        s = NET_AdrToString ( cl->netchan.remote_address);
        Com_Printf ("%s", s);
        l = 22 - strlen(s);
        for (j=0 ; j<l ; j++)
            Com_Printf (" ");
        
        Com_Printf ("%5i", cl->netchan.qport);
 
        Com_Printf ("\n");
    }
    Com_Printf ("\n");
}

Referenced by SV_InitOperatorCommands().

SV_Trace()

trace_t SV_Trace	(	vec3_t	start,
		vec3_t	mins,
		vec3_t	maxs,
		vec3_t	end,
		edict_t *	passedict,
		int	contentmask
	)

Definition at line 624 of file sv_world.c.

{
    moveclip_t  clip;
 
    if (!mins)
        mins = vec3_origin;
    if (!maxs)
        maxs = vec3_origin;
 
    memset ( &clip, 0, sizeof ( moveclip_t ) );
 
    // clip to world
    clip.trace = CM_BoxTrace (start, end, mins, maxs, 0, contentmask);
    clip.trace.ent = ge->edicts;
    if (clip.trace.fraction == 0)
        return clip.trace;      // blocked by the world
 
    clip.contentmask = contentmask;
    clip.start = start;
    clip.end = end;
    clip.mins = mins;
    clip.maxs = maxs;
    clip.passedict = passedict;
 
    VectorCopy (mins, clip.mins2);
    VectorCopy (maxs, clip.maxs2);
    
    // create the bounding box of the entire move
    SV_TraceBounds ( start, clip.mins2, clip.maxs2, end, clip.boxmins, clip.boxmaxs );
 
    // clip to other solid entities
    SV_ClipMoveToEntities ( &clip );
 
    return clip.trace;
}

Referenced by SV_InitGameProgs().

SV_UnlinkEdict()

void SV_UnlinkEdict

(

edict_t *

ent

)

Definition at line 149 of file sv_world.c.

{
    if (!ent->area.prev)
        return;     // not linked in anywhere
    RemoveLink (&ent->area);
    ent->area.prev = ent->area.next = NULL;
}

Referenced by SV_InitGameProgs(), and SV_LinkEdict().

SV_UserinfoChanged()

void SV_UserinfoChanged

(

client_t *

cl

)

Definition at line 901 of file sv_main.c.

{
    char    *val;
    int     i;
 
    // call prog code to allow overrides
    ge->ClientUserinfoChanged (cl->edict, cl->userinfo);
    
    // name for C code
    strncpy (cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name)-1);
    // mask off high bit
    for (i=0 ; i<sizeof(cl->name) ; i++)
        cl->name[i] &= 127;
 
    // rate command
    val = Info_ValueForKey (cl->userinfo, "rate");
    if (strlen(val))
    {
        i = atoi(val);
        cl->rate = i;
        if (cl->rate < 100)
            cl->rate = 100;
        if (cl->rate > 15000)
            cl->rate = 15000;
    }
    else
        cl->rate = 5000;
 
    // msg command
    val = Info_ValueForKey (cl->userinfo, "msg");
    if (strlen(val))
    {
        cl->messagelevel = atoi(val);
    }
 
}

Referenced by SV_ExecuteClientMessage(), and SVC_DirectConnect().

SV_WriteClientdataToMessage()

void SV_WriteClientdataToMessage	(	client_t *	client,
		sizebuf_t *	msg
	)

SV_WriteFrameToClient()

void SV_WriteFrameToClient	(	client_t *	client,
		sizebuf_t *	msg
	)

Definition at line 415 of file sv_ents.c.

{
    client_frame_t      *frame, *oldframe;
    int                 lastframe;
 
//Com_Printf ("%i -> %i\n", client->lastframe, sv.framenum);
    // this is the frame we are creating
    frame = &client->frames[sv.framenum & UPDATE_MASK];
 
    if (client->lastframe <= 0)
    {   // client is asking for a retransmit
        oldframe = NULL;
        lastframe = -1;
    }
    else if (sv.framenum - client->lastframe >= (UPDATE_BACKUP - 3) )
    {   // client hasn't gotten a good message through in a long time
//      Com_Printf ("%s: Delta request from out-of-date packet.\n", client->name);
        oldframe = NULL;
        lastframe = -1;
    }
    else
    {   // we have a valid message to delta from
        oldframe = &client->frames[client->lastframe & UPDATE_MASK];
        lastframe = client->lastframe;
    }
 
    MSG_WriteByte (msg, svc_frame);
    MSG_WriteLong (msg, sv.framenum);
    MSG_WriteLong (msg, lastframe); // what we are delta'ing from
    MSG_WriteByte (msg, client->surpressCount); // rate dropped packets
    client->surpressCount = 0;
 
    // send over the areabits
    MSG_WriteByte (msg, frame->areabytes);
    SZ_Write (msg, frame->areabits, frame->areabytes);
 
    // delta encode the playerstate
    SV_WritePlayerstateToClient (oldframe, frame, msg);
 
    // delta encode the entities
    SV_EmitPacketEntities (oldframe, frame, msg);
}

Referenced by SV_SendClientDatagram().

Variable Documentation

ge

game_export_t* ge

Definition at line 24 of file sv_game.c.

Referenced by SV_Begin_f(), SV_BuildClientFrame(), SV_CheckForSavegame(), SV_ClientThink(), SV_CreateBaseline(), SV_DropClient(), SV_ExecuteUserCommand(), SV_InitGameProgs(), SV_LinkEdict(), SV_PrepWorldFrame(), SV_ReadLevelFile(), SV_ReadServerFile(), SV_RunGameFrame(), SV_ServerCommand_f(), SV_ShutdownGameProgs(), SV_SpawnServer(), SV_Trace(), SV_UserinfoChanged(), SV_WriteLevelFile(), SV_WriteServerFile(), and SVC_DirectConnect().

master_adr

netadr_t master_adr[MAX_MASTERS]

Definition at line 23 of file sv_main.c.

Referenced by Master_Heartbeat(), Master_Shutdown(), SV_InitGame(), and SV_SetMaster_f().

maxclients

cvar_t* maxclients

Definition at line 44 of file g_main.c.

Referenced by CheckDMRules(), ClientEndServerFrames(), ExitLevel(), SV_CalcPings(), SV_GiveMsec(), SV_Init(), SV_ReadPackets(), SV_RunGameFrame(), SV_StatusString(), and SVC_Info().

net_from

netadr_t net_from

Definition at line 81 of file net_chan.c.

Referenced by CL_ConnectionlessPacket(), CL_DumpPackets(), CL_ParseStatusMessage(), CL_ReadPackets(), NET_GetLoopPacket(), NET_GetPacket(), SV_ConnectionlessPacket(), SV_FlushRedirect(), SV_ReadPackets(), SVC_Ack(), SVC_DirectConnect(), SVC_GetChallenge(), SVC_Info(), SVC_Ping(), SVC_RemoteCommand(), and SVC_Status().

net_message

sizebuf_t net_message

Definition at line 82 of file net_chan.c.

Referenced by CL_ConnectionlessPacket(), CL_DumpPackets(), CL_Init(), CL_ParseBeam(), CL_ParseBeam2(), CL_ParseConfigString(), CL_ParseDelta(), CL_ParseDownload(), CL_ParseEntityBits(), CL_ParseFrame(), CL_ParseInventory(), CL_ParseLaser(), CL_ParseLightning(), CL_ParseMuzzleFlash(), CL_ParseMuzzleFlash2(), CL_ParseNuke(), CL_ParsePacketEntities(), CL_ParseParticles(), CL_ParsePlayerBeam(), CL_ParsePlayerstate(), CL_ParseServerData(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseStatusMessage(), CL_ParseSteam(), CL_ParseTEnt(), CL_ParseWidow(), CL_ReadPackets(), CL_WriteDemoMessage(), NET_GetLoopPacket(), NET_GetPacket(), SHOWNET(), SV_ConnectionlessPacket(), SV_ExecuteClientMessage(), SV_FinalMessage(), SV_Init(), SV_ReadPackets(), and SVC_RemoteCommand().

sv

server_t sv

Definition at line 24 of file sv_init.c.

Referenced by Draw_StretchPicImplementation(), PF_centerprintf(), PF_Configstring(), PF_Unicast(), PF_WriteAngle(), PF_WriteByte(), PF_WriteChar(), PF_WriteDir(), PF_WriteFloat(), PF_WriteLong(), PF_WritePos(), PF_WriteShort(), PF_WriteString(), Qcommon_Frame(), SV_Baselines_f(), SV_BeginDemoserver(), SV_BroadcastCommand(), SV_BuildClientFrame(), SV_CalcPings(), SV_CheckForSavegame(), SV_ClearWorld(), SV_Configstrings_f(), SV_CreateBaseline(), SV_DemoCompleted(), SV_EmitPacketEntities(), SV_ExecuteUserCommand(), SV_FindIndex(), SV_Frame(), SV_GameMap_f(), SV_GiveMsec(), SV_HullForEntity(), SV_InitGame(), SV_LinkEdict(), SV_Loadgame_f(), SV_Map(), SV_Map_f(), SV_Multicast(), SV_New_f(), SV_Nextserver(), SV_PointContents(), SV_RateDrop(), SV_ReadLevelFile(), SV_RecordDemoMessage(), SV_RunGameFrame(), SV_Savegame_f(), SV_SendClientDatagram(), SV_SendClientMessages(), SV_ServerRecord_f(), SV_Shutdown(), SV_SpawnServer(), SV_StartSound(), SV_Status_f(), SV_WriteFrameToClient(), SV_WriteLevelFile(), SV_WriteServerFile(), SVC_DirectConnect(), and SVC_Info().

sv_airaccelerate

cvar_t* sv_airaccelerate

Definition at line 43 of file sv_main.c.

Referenced by SV_Init(), and SV_SpawnServer().

sv_client

client_t* sv_client

Definition at line 25 of file sv_main.c.

Referenced by SV_Baselines_f(), SV_Begin_f(), SV_BeginDownload_f(), SV_Configstrings_f(), SV_Disconnect_f(), SV_DumpUser_f(), SV_ExecuteClientMessage(), SV_ExecuteUserCommand(), SV_FlushRedirect(), SV_Kick_f(), SV_New_f(), SV_NextDownload_f(), SV_Nextserver_f(), SV_SetPlayer(), and SVC_DirectConnect().

sv_enforcetime

cvar_t* sv_enforcetime

Definition at line 30 of file sv_main.c.

Referenced by SV_ClientThink(), and SV_Init().

sv_noreload

cvar_t* sv_noreload

Definition at line 45 of file sv_main.c.

Referenced by SV_CheckForSavegame(), and SV_Init().

sv_outputbuf

char sv_outputbuf[SV_OUTPUTBUF_LENGTH]

Definition at line 32 of file sv_send.c.

Referenced by SVC_RemoteCommand(), and SVC_Status().

sv_paused

cvar_t* sv_paused

Definition at line 27 of file sv_main.c.

Referenced by SV_ExecuteClientMessage(), SV_Init(), SV_RunGameFrame(), and SV_SendClientMessages().

sv_player

edict_t* sv_player

Definition at line 24 of file sv_user.c.

Referenced by SV_Begin_f(), SV_ExecuteClientMessage(), SV_ExecuteUserCommand(), and SV_SetPlayer().

svs

server_static_t svs

Definition at line 23 of file sv_init.c.

Referenced by Master_Heartbeat(), PF_cprintf(), PF_Unicast(), SV_Baselines_f(), SV_Begin_f(), SV_BroadcastPrintf(), SV_BuildClientFrame(), SV_CalcPings(), SV_CheckTimeouts(), SV_Configstrings_f(), SV_ConSay_f(), SV_EmitPacketEntities(), SV_ExecuteClientMessage(), SV_FinalMessage(), SV_Frame(), SV_GameMap_f(), SV_GiveMsec(), SV_Heartbeat_f(), SV_InitGame(), SV_Kick_f(), SV_KillServer_f(), SV_Loadgame_f(), SV_Multicast(), SV_New_f(), SV_Nextserver(), SV_Nextserver_f(), SV_ReadPackets(), SV_ReadServerFile(), SV_RecordDemoMessage(), SV_RunGameFrame(), SV_Savegame_f(), SV_SendClientMessages(), SV_ServerRecord_f(), SV_ServerStop_f(), SV_SetMaster_f(), SV_SetPlayer(), SV_Shutdown(), SV_SpawnServer(), SV_Status_f(), SV_StatusString(), SV_WriteServerFile(), SVC_DirectConnect(), SVC_GetChallenge(), and SVC_Info().