game.c File Reference

#include "server.h"

Go to the source code of this file.

Macros
#define	CHECK_PARAMS

Functions
static void	PF_configstring (int index, const char *val)
static int	PF_FindIndex (const char *name, int start, int max)
static int	PF_ModelIndex (const char *name)
static int	PF_SoundIndex (const char *name)
static int	PF_ImageIndex (const char *name)
static void	PF_Unicast (edict_t *ent, qboolean reliable)
static void	PF_bprintf (int level, const char *fmt,...)
static void	PF_dprintf (const char *fmt,...)
static void	PF_cprintf (edict_t *ent, int level, const char *fmt,...)
static void	PF_centerprintf (edict_t *ent, const char *fmt,...)
static q_noreturn void	PF_error (const char *fmt,...)
static void	PF_setmodel (edict_t *ent, const char *name)
static void	PF_WriteFloat (float f)
static qboolean	PF_inVIS (vec3_t p1, vec3_t p2, int vis)
static qboolean	PF_inPVS (vec3_t p1, vec3_t p2)
static qboolean	PF_inPHS (vec3_t p1, vec3_t p2)
static void	PF_StartSound (edict_t *edict, int channel, int soundindex, float volume, float attenuation, float timeofs)
static void	PF_PositionedSound (vec3_t origin, edict_t *entity, int channel, int soundindex, float volume, float attenuation, float timeofs)
void	PF_Pmove (pmove_t *pm)
static cvar_t *	PF_cvar (const char *name, const char *value, int flags)
static void	PF_AddCommandString (const char *string)
static void	PF_SetAreaPortalState (int portalnum, qboolean open)
static qboolean	PF_AreasConnected (int area1, int area2)
static void *	PF_TagMalloc (size_t size, unsigned tag)
static void	PF_FreeTags (unsigned tag)
static void	PF_DebugGraph (float value, int color)
void	SV_ShutdownGameProgs (void)
static void *	_SV_LoadGameLibrary (const char *path)
static void *	SV_LoadGameLibrary (const char *game, const char *prefix)
void	SV_InitGameProgs (void)

Variables
game_export_t *	ge
static void *	game_library

Macro Definition Documentation

CHECK_PARAMS

#define CHECK_PARAMS

Value:

    if (volume < 0 || volume > 1.0) \
        Com_Error(ERR_DROP, "%s: volume = %f", __func__, volume); \
    if (attenuation < 0 || attenuation > 4) \
        Com_Error(ERR_DROP, "%s: attenuation = %f", __func__, attenuation); \
    if (timeofs < 0 || timeofs > 0.255) \
        Com_Error(ERR_DROP, "%s: timeofs = %f", __func__, timeofs); \
    if (soundindex < 0 || soundindex >= MAX_SOUNDS) \
        Com_Error(ERR_DROP, "%s: soundindex = %d", __func__, soundindex);

Definition at line 501 of file game.c.

Function Documentation

_SV_LoadGameLibrary()

static void* _SV_LoadGameLibrary ( const char *  path )

static

Definition at line 799 of file game.c.

{
    void *entry;
 
    entry = Sys_LoadLibrary(path, "GetGameAPI", &game_library);
    if (!entry)
        Com_EPrintf("Failed to load game library: %s\n", Com_GetLastError());
    else
        Com_Printf("Loaded game library from %s\n", path);
 
    return entry;
}

Referenced by SV_InitGameProgs(), and SV_LoadGameLibrary().

PF_AddCommandString()

static void PF_AddCommandString ( const char *  string )

static

Definition at line 727 of file game.c.

{
    Cbuf_AddText(&cmd_buffer, string);
}

Referenced by SV_InitGameProgs().

PF_AreasConnected()

static qboolean PF_AreasConnected ( int  area1, int  area2  )

static

Definition at line 740 of file game.c.

{
    if (!sv.cm.cache) {
        Com_Error(ERR_DROP, "%s: no map loaded", __func__);
    }
    return CM_AreasConnected(&sv.cm, area1, area2);
}

Referenced by SV_InitGameProgs().

PF_bprintf()

static void PF_bprintf ( int  level, const char *  fmt,   ...  )

static

Definition at line 140 of file game.c.

{
    va_list     argptr;
    char        string[MAX_STRING_CHARS];
    client_t    *client;
    size_t      len;
    int         i;
 
    va_start(argptr, fmt);
    len = Q_vsnprintf(string, sizeof(string), fmt, argptr);
    va_end(argptr);
 
    if (len >= sizeof(string)) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    SV_MvdBroadcastPrint(level, string);
 
    MSG_WriteByte(svc_print);
    MSG_WriteByte(level);
    MSG_WriteData(string, len + 1);
 
    // echo to console
    if (COM_DEDICATED) {
        // mask off high bits
        for (i = 0; i < len; i++)
            string[i] &= 127;
        Com_Printf("%s", string);
    }
 
    FOR_EACH_CLIENT(client) {
        if (client->state != cs_spawned)
            continue;
        if (level >= client->messagelevel) {
            SV_ClientAddMessage(client, MSG_RELIABLE);
        }
    }
 
    SZ_Clear(&msg_write);
}

Referenced by SV_InitGameProgs().

PF_centerprintf()

static void PF_centerprintf ( edict_t *  ent, const char *  fmt,   ...  )

static

Definition at line 266 of file game.c.

{
    char        msg[MAX_STRING_CHARS];
    va_list     argptr;
    int         n;
    size_t      len;
 
    if (!ent) {
        return;
    }
 
    n = NUM_FOR_EDICT(ent);
    if (n < 1 || n > sv_maxclients->integer) {
        Com_WPrintf("%s to a non-client %d\n", __func__, n - 1);
        return;
    }
 
    va_start(argptr, fmt);
    len = Q_vsnprintf(msg, sizeof(msg), fmt, argptr);
    va_end(argptr);
 
    if (len >= sizeof(msg)) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    MSG_WriteByte(svc_centerprint);
    MSG_WriteData(msg, len + 1);
 
    PF_Unicast(ent, qtrue);
}

Referenced by SV_InitGameProgs().

PF_configstring()

static void PF_configstring ( int  index, const char *  val  )

static

Definition at line 356 of file game.c.

{
    size_t len, maxlen;
    client_t *client;
    char *dst;
 
    if (index < 0 || index >= MAX_CONFIGSTRINGS)
        Com_Error(ERR_DROP, "%s: bad index: %d", __func__, index);
 
    if (sv.state == ss_dead) {
        Com_WPrintf("%s: not yet initialized\n", __func__);
        return;
    }
 
    if (!val)
        val = "";
 
    // error out entirely if it exceedes array bounds
    len = strlen(val);
    maxlen = (MAX_CONFIGSTRINGS - index) * MAX_QPATH;
    if (len >= maxlen) {
        Com_Error(ERR_DROP,
                  "%s: index %d overflowed: %"PRIz" > %"PRIz,
                  __func__, index, len, maxlen - 1);
    }
 
    // print a warning and truncate everything else
    maxlen = CS_SIZE(index);
    if (len >= maxlen) {
        Com_WPrintf(
            "%s: index %d overflowed: %"PRIz" > %"PRIz"\n",
            __func__, index, len, maxlen - 1);
        len = maxlen - 1;
    }
 
    dst = sv.configstrings[index];
    if (!strncmp(dst, val, len)) {
        return;
    }
 
    // change the string in sv
    memcpy(dst, val, len);
    dst[len] = 0;
 
    if (sv.state == ss_loading) {
        return;
    }
 
    SV_MvdConfigstring(index, val, len);
 
    // send the update to everyone
    MSG_WriteByte(svc_configstring);
    MSG_WriteShort(index);
    MSG_WriteData(val, len);
    MSG_WriteByte(0);
 
    FOR_EACH_CLIENT(client) {
        if (client->state < cs_primed) {
            continue;
        }
        SV_ClientAddMessage(client, MSG_RELIABLE);
    }
 
    SZ_Clear(&msg_write);
}

Referenced by PF_FindIndex(), and SV_InitGameProgs().

PF_cprintf()

static void PF_cprintf ( edict_t *  ent, int  level, const char *  fmt,   ...  )

static

Definition at line 211 of file game.c.

{
    char        msg[MAX_STRING_CHARS];
    va_list     argptr;
    int         clientNum;
    size_t      len;
    client_t    *client;
 
    va_start(argptr, fmt);
    len = Q_vsnprintf(msg, sizeof(msg), fmt, argptr);
    va_end(argptr);
 
    if (len >= sizeof(msg)) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    if (!ent) {
        Com_LPrintf(level == PRINT_CHAT ? PRINT_TALK : PRINT_ALL, "%s", msg);
        return;
    }
 
    clientNum = NUM_FOR_EDICT(ent) - 1;
    if (clientNum < 0 || clientNum >= sv_maxclients->integer) {
        Com_Error(ERR_DROP, "%s to a non-client %d", __func__, clientNum);
    }
 
    client = svs.client_pool + clientNum;
    if (client->state <= cs_zombie) {
        Com_WPrintf("%s to a free/zombie client %d\n", __func__, clientNum);
        return;
    }
 
    MSG_WriteByte(svc_print);
    MSG_WriteByte(level);
    MSG_WriteData(msg, len + 1);
 
    if (level >= client->messagelevel) {
        SV_ClientAddMessage(client, MSG_RELIABLE);
    }
 
    SV_MvdUnicast(ent, clientNum, qtrue);
 
    SZ_Clear(&msg_write);
}

Referenced by SV_InitGameProgs().

PF_cvar()

static cvar_t* PF_cvar ( const char *  name, const char *  value, int  flags  )

static

Definition at line 717 of file game.c.

{
    if (flags & CVAR_EXTENDED_MASK) {
        Com_WPrintf("Game attemped to set extended flags on '%s', masked out.\n", name);
        flags &= ~CVAR_EXTENDED_MASK;
    }
 
    return Cvar_Get(name, value, flags | CVAR_GAME);
}

Referenced by SV_InitGameProgs().

PF_DebugGraph()

static void PF_DebugGraph ( float  value, int  color  )

static

Definition at line 767 of file game.c.

{
#if (defined _DEBUG) && USE_CLIENT
    SCR_DebugGraph(value, color);
#endif
}

Referenced by SV_InitGameProgs().

PF_dprintf()

static void PF_dprintf ( const char *  fmt,   ...  )

static

Definition at line 190 of file game.c.

{
    char        msg[MAXPRINTMSG];
    va_list     argptr;
 
    va_start(argptr, fmt);
    Q_vsnprintf(msg, sizeof(msg), fmt, argptr);
    va_end(argptr);
 
    Com_Printf("%s", msg);
}

Referenced by SV_InitGameProgs().

PF_error()

static q_noreturn void PF_error ( const char *  fmt,   ...  )

static

Definition at line 306 of file game.c.

{
    char        msg[MAXERRORMSG];
    va_list     argptr;
 
    va_start(argptr, fmt);
    Q_vsnprintf(msg, sizeof(msg), fmt, argptr);
    va_end(argptr);
 
    Com_Error(ERR_DROP, "Game Error: %s", msg);
}

Referenced by SV_InitGameProgs().

PF_FindIndex()

static int PF_FindIndex ( const char *  name, int  start, int  max  )

static

Definition at line 32 of file game.c.

{
    char *string;
    int i;
 
    if (!name || !name[0])
        return 0;
 
    for (i = 1; i < max; i++) {
        string = sv.configstrings[start + i];
        if (!string[0]) {
            break;
        }
        if (!strcmp(string, name)) {
            return i;
        }
    }
 
    if (i == max)
        Com_Error(ERR_DROP, "PF_FindIndex: overflow");
 
    PF_configstring(i + start, name);
 
    return i;
}

Referenced by PF_ImageIndex(), PF_ModelIndex(), and PF_SoundIndex().

PF_FreeTags()

static void PF_FreeTags ( unsigned  tag )

static

Definition at line 759 of file game.c.

{
    if (tag + TAG_MAX < tag) {
        Com_Error(ERR_FATAL, "%s: bad tag", __func__);
    }
    Z_FreeTags(tag + TAG_MAX);
}

Referenced by SV_InitGameProgs().

PF_ImageIndex()

static int PF_ImageIndex ( const char *  name )

static

Definition at line 68 of file game.c.

{
    return PF_FindIndex(name, CS_IMAGES, MAX_IMAGES);
}

Referenced by SV_InitGameProgs().

PF_inPHS()

static qboolean PF_inPHS ( vec3_t  p1, vec3_t  p2  )

static

Definition at line 469 of file game.c.

{
    return PF_inVIS(p1, p2, DVIS_PHS);
}

Referenced by SV_InitGameProgs().

PF_inPVS()

static qboolean PF_inPVS ( vec3_t  p1, vec3_t  p2  )

static

Definition at line 457 of file game.c.

{
    return PF_inVIS(p1, p2, DVIS_PVS);
}

Referenced by SV_InitGameProgs().

PF_inVIS()

static qboolean PF_inVIS ( vec3_t  p1, vec3_t  p2, int  vis  )

static

Definition at line 427 of file game.c.

{
    mleaf_t *leaf1, *leaf2;
    byte mask[VIS_MAX_BYTES];
    bsp_t *bsp = sv.cm.cache;
 
    if (!bsp) {
        Com_Error(ERR_DROP, "%s: no map loaded", __func__);
    }
 
    leaf1 = BSP_PointLeaf(bsp->nodes, p1);
    BSP_ClusterVis(bsp, mask, leaf1->cluster, vis);
 
    leaf2 = BSP_PointLeaf(bsp->nodes, p2);
    if (leaf2->cluster == -1)
        return qfalse;
    if (!Q_IsBitSet(mask, leaf2->cluster))
        return qfalse;
    if (!CM_AreasConnected(&sv.cm, leaf1->area, leaf2->area))
        return qfalse;        // a door blocks it
    return qtrue;
}

Referenced by PF_inPHS(), and PF_inPVS().

PF_ModelIndex()

static int PF_ModelIndex ( const char *  name )

static

Definition at line 58 of file game.c.

{
    return PF_FindIndex(name, CS_MODELS, MAX_MODELS);
}

Referenced by PF_setmodel(), and SV_InitGameProgs().

PF_Pmove()

void PF_Pmove

(

pmove_t *

pm

)

Definition at line 708 of file game.c.

{
    if (sv_client) {
        Pmove(pm, &sv_client->pmp);
    } else {
        Pmove(pm, &sv_pmp);
    }
}

Referenced by MVD_GameClientThink(), and SV_InitGameProgs().

PF_PositionedSound()

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

static

Definition at line 651 of file game.c.

{
    int     sendchan;
    int     flags;
    int     ent;
 
    if (!origin)
        Com_Error(ERR_DROP, "%s: NULL origin", __func__);
    CHECK_PARAMS
 
    ent = NUM_FOR_EDICT(entity);
 
    sendchan = (ent << 3) | (channel & 7);
 
    // always send the entity number for channel overrides
    flags = SND_ENT | SND_POS;
    if (volume != DEFAULT_SOUND_PACKET_VOLUME)
        flags |= SND_VOLUME;
    if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
        flags |= SND_ATTENUATION;
    if (timeofs)
        flags |= SND_OFFSET;
 
    MSG_WriteByte(svc_sound);
    MSG_WriteByte(flags);
    MSG_WriteByte(soundindex);
 
    if (flags & SND_VOLUME)
        MSG_WriteByte(volume * 255);
    if (flags & SND_ATTENUATION)
        MSG_WriteByte(attenuation * 64);
    if (flags & SND_OFFSET)
        MSG_WriteByte(timeofs * 1000);
 
    MSG_WriteShort(sendchan);
    MSG_WritePos(origin);
 
    // if the sound doesn't attenuate,send it to everyone
    // (global radio chatter, voiceovers, etc)
    if (attenuation == ATTN_NONE || (channel & CHAN_NO_PHS_ADD)) {
        if (channel & CHAN_RELIABLE) {
            SV_Multicast(NULL, MULTICAST_ALL_R);
        } else {
            SV_Multicast(NULL, MULTICAST_ALL);
        }
    } else {
        if (channel & CHAN_RELIABLE) {
            SV_Multicast(origin, MULTICAST_PHS_R);
        } else {
            SV_Multicast(origin, MULTICAST_PHS);
        }
    }
}

Referenced by SV_InitGameProgs().

PF_SetAreaPortalState()

static void PF_SetAreaPortalState ( int  portalnum, qboolean  open  )

static

Definition at line 732 of file game.c.

{
    if (!sv.cm.cache) {
        Com_Error(ERR_DROP, "%s: no map loaded", __func__);
    }
    CM_SetAreaPortalState(&sv.cm, portalnum, open);
}

Referenced by SV_InitGameProgs().

PF_setmodel()

static void PF_setmodel ( edict_t *  ent, const char *  name  )

static

Definition at line 326 of file game.c.

{
    int         i;
    mmodel_t    *mod;
 
    if (!name)
        Com_Error(ERR_DROP, "PF_setmodel: NULL");
 
    i = PF_ModelIndex(name);
 
    ent->s.modelindex = i;
 
// if it is an inline model, get the size information for it
    if (name[0] == '*') {
        mod = CM_InlineModel(&sv.cm, name);
        VectorCopy(mod->mins, ent->mins);
        VectorCopy(mod->maxs, ent->maxs);
        PF_LinkEdict(ent);
    }
 
}

Referenced by SV_InitGameProgs().

PF_SoundIndex()

static int PF_SoundIndex ( const char *  name )

static

Definition at line 63 of file game.c.

{
    return PF_FindIndex(name, CS_SOUNDS, MAX_SOUNDS);
}

Referenced by SV_InitGameProgs().

PF_StartSound()

static void PF_StartSound ( edict_t *  edict, int  channel, int  soundindex, float  volume, float  attenuation, float  timeofs  )

static

Definition at line 511 of file game.c.

{
    int         sendchan;
    int         flags;
    int         ent;
    vec3_t      origin;
    client_t    *client;
    byte        mask[VIS_MAX_BYTES];
    mleaf_t     *leaf;
    int         area;
    player_state_t      *ps;
    message_packet_t    *msg;
    int         i;
 
    if (!edict)
        return;
 
    CHECK_PARAMS
 
    ent = NUM_FOR_EDICT(edict);
 
    if ((g_features->integer & GMF_PROPERINUSE) && !edict->inuse) {
        Com_DPrintf("%s: entnum not in use: %d\n", __func__, ent);
        return;
    }
 
    sendchan = (ent << 3) | (channel & 7);
 
    // always send the entity number for channel overrides
    flags = SND_ENT;
    if (volume != DEFAULT_SOUND_PACKET_VOLUME)
        flags |= SND_VOLUME;
    if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
        flags |= SND_ATTENUATION;
    if (timeofs)
        flags |= SND_OFFSET;
 
    // if the sound doesn't attenuate,send it to everyone
    // (global radio chatter, voiceovers, etc)
    if (attenuation == ATTN_NONE) {
        channel |= CHAN_NO_PHS_ADD;
    }
 
    FOR_EACH_CLIENT(client) {
        // do not send sounds to connecting clients
        if (client->state != cs_spawned || client->download || client->nodata) {
            continue;
        }
 
        // PHS cull this sound
        if (!(channel & CHAN_NO_PHS_ADD)) {
            // get client viewpos
            ps = &client->edict->client->ps;
            VectorMA(ps->viewoffset, 0.125f, ps->pmove.origin, origin);
            leaf = CM_PointLeaf(&sv.cm, origin);
            area = CM_LeafArea(leaf);
            if (!CM_AreasConnected(&sv.cm, area, edict->areanum)) {
                // doors can legally straddle two areas, so
                // we may need to check another one
                if (!edict->areanum2 || !CM_AreasConnected(&sv.cm, area, edict->areanum2)) {
                    continue;        // blocked by a door
                }
            }
            BSP_ClusterVis(sv.cm.cache, mask, leaf->cluster, DVIS_PHS);
            if (!SV_EdictIsVisible(&sv.cm, edict, mask)) {
                continue; // not in PHS
            }
        }
 
        // use the entity origin unless it is a bmodel
        if (edict->solid == SOLID_BSP) {
            VectorAvg(edict->mins, edict->maxs, origin);
            VectorAdd(edict->s.origin, origin, origin);
        } else {
            VectorCopy(edict->s.origin, origin);
        }
 
        // reliable sounds will always have position explicitly set,
        // as no one gurantees reliables to be delivered in time
        if (channel & CHAN_RELIABLE) {
            MSG_WriteByte(svc_sound);
            MSG_WriteByte(flags | SND_POS);
            MSG_WriteByte(soundindex);
 
            if (flags & SND_VOLUME)
                MSG_WriteByte(volume * 255);
            if (flags & SND_ATTENUATION)
                MSG_WriteByte(attenuation * 64);
            if (flags & SND_OFFSET)
                MSG_WriteByte(timeofs * 1000);
 
            MSG_WriteShort(sendchan);
            MSG_WritePos(origin);
 
            SV_ClientAddMessage(client, MSG_RELIABLE | MSG_CLEAR);
            continue;
        }
 
        if (LIST_EMPTY(&client->msg_free_list)) {
            Com_WPrintf("%s: %s: out of message slots\n",
                        __func__, client->name);
            continue;
        }
 
        // send origin for invisible entities
        if (edict->svflags & SVF_NOCLIENT) {
            flags |= SND_POS;
        }
 
        // default client doesn't know that bmodels have weird origins
        if (edict->solid == SOLID_BSP && client->protocol == PROTOCOL_VERSION_DEFAULT) {
            flags |= SND_POS;
        }
 
        msg = LIST_FIRST(message_packet_t, &client->msg_free_list, entry);
 
        msg->cursize = 0;
        msg->flags = flags;
        msg->index = soundindex;
        msg->volume = volume * 255;
        msg->attenuation = attenuation * 64;
        msg->timeofs = timeofs * 1000;
        msg->sendchan = sendchan;
        for (i = 0; i < 3; i++) {
            msg->pos[i] = origin[i] * 8;
        }
 
        List_Remove(&msg->entry);
        List_Append(&client->msg_unreliable_list, &msg->entry);
        client->msg_unreliable_bytes += MAX_SOUND_PACKET;
 
        flags &= ~SND_POS;
    }
 
    SV_MvdStartSound(ent, channel, flags, soundindex,
                     volume * 255, attenuation * 64, timeofs * 1000);
}

Referenced by SV_InitGameProgs().

PF_TagMalloc()

static void* PF_TagMalloc ( size_t  size, unsigned  tag  )

static

Definition at line 748 of file game.c.

{
    if (tag + TAG_MAX < tag) {
        Com_Error(ERR_FATAL, "%s: bad tag", __func__);
    }
    if (!size) {
        return NULL;
    }
    return memset(Z_TagMalloc(size, tag + TAG_MAX), 0, size);
}

Referenced by SV_InitGameProgs().

PF_Unicast()

static void PF_Unicast ( edict_t *  ent, qboolean  reliable  )

static

Definition at line 81 of file game.c.

{
    client_t    *client;
    int         cmd, flags, clientNum;
 
    if (!ent) {
        goto clear;
    }
 
    clientNum = NUM_FOR_EDICT(ent) - 1;
    if (clientNum < 0 || clientNum >= sv_maxclients->integer) {
        Com_WPrintf("%s to a non-client %d\n", __func__, clientNum);
        goto clear;
    }
 
    client = svs.client_pool + clientNum;
    if (client->state <= cs_zombie) {
        Com_WPrintf("%s to a free/zombie client %d\n", __func__, clientNum);
        goto clear;
    }
 
    if (!msg_write.cursize) {
        Com_DPrintf("%s with empty data\n", __func__);
        goto clear;
    }
 
    cmd = msg_write.data[0];
 
    flags = 0;
    if (reliable) {
        flags |= MSG_RELIABLE;
    }
 
    if (cmd == svc_layout) {
        flags |= MSG_COMPRESS;
    }
 
    SV_ClientAddMessage(client, flags);
 
    // fix anti-kicking exploit for broken mods
    if (cmd == svc_disconnect) {
        client->drop_hack = qtrue;
        goto clear;
    }
 
    SV_MvdUnicast(ent, clientNum, reliable);
 
clear:
    SZ_Clear(&msg_write);
}

Referenced by PF_centerprintf(), and SV_InitGameProgs().

PF_WriteFloat()

static void PF_WriteFloat ( float  f )

static

Definition at line 422 of file game.c.

{
    Com_Error(ERR_DROP, "PF_WriteFloat not implemented");
}

Referenced by SV_InitGameProgs().

SV_InitGameProgs()

void SV_InitGameProgs

(

void

)

Definition at line 841 of file game.c.

{
    game_import_t   import;
    game_export_t   *(*entry)(game_import_t *) = NULL;
 
    // unload anything we have now
    SV_ShutdownGameProgs();
 
    // for debugging or `proxy' mods
    if (sys_forcegamelib->string[0])
        entry = _SV_LoadGameLibrary(sys_forcegamelib->string);
 
    // try game first
    if (!entry && fs_game->string[0]) {
        entry = SV_LoadGameLibrary(fs_game->string, "q2pro_");
        if (!entry)
            entry = SV_LoadGameLibrary(fs_game->string, "");
    }
 
    // then try baseq2
    if (!entry) {
        entry = SV_LoadGameLibrary(BASEGAME, "q2pro_");
        if (!entry)
            entry = SV_LoadGameLibrary(BASEGAME, "");
    }
 
    // all paths failed
    if (!entry)
        Com_Error(ERR_DROP, "Failed to load game library");
 
    // load a new game dll
    import.multicast = SV_Multicast;
    import.unicast = PF_Unicast;
    import.bprintf = PF_bprintf;
    import.dprintf = PF_dprintf;
    import.cprintf = PF_cprintf;
    import.centerprintf = PF_centerprintf;
    import.error = PF_error;
 
    import.linkentity = PF_LinkEdict;
    import.unlinkentity = PF_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 = PF_Pmove;
 
    import.modelindex = PF_ModelIndex;
    import.soundindex = PF_SoundIndex;
    import.imageindex = PF_ImageIndex;
 
    import.configstring = PF_configstring;
    import.sound = PF_StartSound;
    import.positioned_sound = PF_PositionedSound;
 
    import.WriteChar = MSG_WriteChar;
    import.WriteByte = MSG_WriteByte;
    import.WriteShort = MSG_WriteShort;
    import.WriteLong = MSG_WriteLong;
    import.WriteFloat = PF_WriteFloat;
    import.WriteString = MSG_WriteString;
    import.WritePosition = MSG_WritePos;
    import.WriteDir = MSG_WriteDir;
    import.WriteAngle = MSG_WriteAngle;
 
    import.TagMalloc = PF_TagMalloc;
    import.TagFree = Z_Free;
    import.FreeTags = PF_FreeTags;
 
    import.cvar = PF_cvar;
    import.cvar_set = Cvar_UserSet;
    import.cvar_forceset = Cvar_Set;
 
    import.argc = Cmd_Argc;
    import.argv = Cmd_Argv;
    // original Cmd_Args() did actually return raw arguments
    import.args = Cmd_RawArgs;
    import.AddCommandString = PF_AddCommandString;
 
    import.DebugGraph = PF_DebugGraph;
    import.SetAreaPortalState = PF_SetAreaPortalState;
    import.AreasConnected = PF_AreasConnected;
 
    ge = entry(&import);
    if (!ge) {
        Com_Error(ERR_DROP, "Game DLL returned NULL exports");
    }
 
    if (ge->apiversion != GAME_API_VERSION) {
        Com_Error(ERR_DROP, "Game DLL is version %d, expected %d",
                  ge->apiversion, GAME_API_VERSION);
    }
 
    // initialize
    ge->Init();
 
    // sanitize edict_size
    if (ge->edict_size < sizeof(edict_t) || ge->edict_size > SIZE_MAX / MAX_EDICTS) {
        Com_Error(ERR_DROP, "Game DLL returned bad size of edict_t");
    }
 
    // sanitize max_edicts
    if (ge->max_edicts <= sv_maxclients->integer || ge->max_edicts > MAX_EDICTS) {
        Com_Error(ERR_DROP, "Game DLL returned bad number of max_edicts");
    }
}

Referenced by SV_InitGame().

SV_LoadGameLibrary()

static void* SV_LoadGameLibrary ( const char *  game, const char *  prefix  )

static

Definition at line 812 of file game.c.

{
    char path[MAX_OSPATH];
    size_t len;
 
    len = Q_concat(path, sizeof(path), sys_libdir->string,
                   PATH_SEP_STRING, game, PATH_SEP_STRING,
                   prefix, "game" CPUSTRING LIBSUFFIX, NULL);
    if (len >= sizeof(path)) {
        Com_EPrintf("Game library path length exceeded\n");
        return NULL;
    }
 
    if (os_access(path, F_OK)) {
        if (!*prefix)
            Com_Printf("Can't access %s: %s\n", path, strerror(errno));
        return NULL;
    }
 
    return _SV_LoadGameLibrary(path);
}

Referenced by SV_InitGameProgs().

SV_ShutdownGameProgs()

void SV_ShutdownGameProgs

(

void

)

Definition at line 786 of file game.c.

{
    if (ge) {
        ge->Shutdown();
        ge = NULL;
    }
    if (game_library) {
        Sys_FreeLibrary(game_library);
        game_library = NULL;
    }
    Cvar_Set("g_features", "0");
}

Referenced by SV_InitGame(), SV_InitGameProgs(), and SV_Shutdown().

Variable Documentation

game_library

void* game_library

static

Definition at line 776 of file game.c.

Referenced by _SV_LoadGameLibrary(), and SV_ShutdownGameProgs().

ge

game_export_t* ge

Definition at line 22 of file game.c.

Referenced by build_gamestate(), dummy_command(), dummy_create(), dummy_run(), dummy_spawn(), emit_frame(), PF_LinkEdict(), read_level_file(), read_server_file(), SV_Begin_f(), SV_CheckForSavegame(), SV_ClearWorld(), SV_ClientThink(), SV_DropClient(), SV_ExecuteUserCommand(), SV_InitGame(), SV_InitGameProgs(), SV_PrepWorldFrame(), SV_RunGameFrame(), SV_ServerCommand_f(), SV_Shutdown(), SV_ShutdownGameProgs(), SV_SpawnServer(), SV_Trace(), SV_UserinfoChanged(), SVC_DirectConnect(), write_level_file(), and write_server_file().