g_spawn.c

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2010 UFO: Alien Invasion.

Original file from Quake 2 v3.21: quake2-2.31/game/g_spawn.c
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/


#include "g_local.h"
#include "../shared/parse.h"

static spawn_temp_t st;

static void SP_light(edict_t *ent);
static void SP_dummy(edict_t *ent);
static void SP_player_start(edict_t *ent);
static void SP_human_start(edict_t *ent);
static void SP_alien_start(edict_t *ent);
static void SP_civilian_start(edict_t *ent);
static void SP_worldspawn(edict_t *ent);
static void SP_2x2_start(edict_t *ent);
static void SP_civilian_target(edict_t *ent);
static void SP_misc_model(edict_t *ent);
static void SP_misc_item(edict_t *ent);
static void SP_misc_mission(edict_t *ent);
static void SP_misc_mission_aliens(edict_t *ent);
static void SP_misc_message(edict_t *ent);

typedef struct {
    const char *name;
    void (*spawn) (edict_t * ent);
} spawn_t;

static const spawn_t spawns[] = {
    {"worldspawn", SP_worldspawn},
    {"light", SP_light},
    {"misc_item", SP_misc_item},
    {"misc_sound", SP_dummy},
    {"misc_model", SP_misc_model},
    {"misc_particle", SP_dummy},
    {"misc_mission", SP_misc_mission},
    {"misc_mission_aliens", SP_misc_mission_aliens},
    {"info_player_start", SP_player_start},
    {"info_human_start", SP_human_start},
    {"info_alien_start", SP_alien_start},
    {"info_civilian_start", SP_civilian_start},
    {"info_civilian_target", SP_civilian_target},
    {"info_2x2_start", SP_2x2_start},
    {"info_null", SP_dummy},
    {"func_breakable", SP_func_breakable},
    {"func_door", SP_func_door},
    {"func_rotating", SP_func_rotating},
    {"trigger_hurt", SP_trigger_hurt},
    {"trigger_touch", SP_trigger_touch},
    {"trigger_rescue", SP_trigger_rescue},
    {"misc_message", SP_misc_message},

    {NULL, NULL}
};

typedef enum {
    F_INT,
    F_FLOAT,
    F_LSTRING,                  /* string on disk, pointer in memory, TAG_LEVEL */
    F_VECTOR,
    F_IGNORE
} fieldtype_t;

typedef struct {
    const char *name;
    size_t ofs;
    fieldtype_t type;
    int flags;
} field_t;

static const field_t fields[] = {
    {"classname", offsetof(edict_t, classname), F_LSTRING, 0},
    {"model", offsetof(edict_t, model), F_LSTRING, 0},
    {"spawnflags", offsetof(edict_t, spawnflags), F_INT, 0},
    {"speed", offsetof(edict_t, speed), F_INT, 0},
    {"target", offsetof(edict_t, target), F_LSTRING, 0},
    {"targetname", offsetof(edict_t, targetname), F_LSTRING, 0},
    {"item", offsetof(edict_t, item), F_LSTRING, 0},
    {"noise", offsetof(edict_t, noise), F_LSTRING, 0},
    {"particle", offsetof(edict_t, particle), F_LSTRING, 0},
    {"frame", offsetof(edict_t, frame), F_INT, 0},
    {"team", offsetof(edict_t, team), F_INT, 0},
    {"group", offsetof(edict_t, group), F_LSTRING, 0},
    {"size", offsetof(edict_t, fieldSize), F_INT, 0},
    {"count", offsetof(edict_t, count), F_INT, 0},
    {"time", offsetof(edict_t, time), F_INT, 0},
    {"health", offsetof(edict_t, HP), F_INT, 0},
    {"sounds", offsetof(edict_t, sounds), F_INT, 0},
    {"material", offsetof(edict_t, material), F_INT, 0},
    {"light", 0, F_IGNORE, 0},
    {"maxteams", 0, F_IGNORE, 0},
    {"maxlevel", 0, F_IGNORE, 0},
    {"dmg", offsetof(edict_t, dmg), F_INT, 0},
    {"origin", offsetof(edict_t, origin), F_VECTOR, 0},
    {"angles", offsetof(edict_t, angles), F_VECTOR, 0},
    {"angle", offsetof(edict_t, angle), F_FLOAT, 0},
    {"message", offsetof(edict_t, message), F_LSTRING, 0},

    {"nextmap", offsetof(spawn_temp_t, nextmap), F_LSTRING, FFL_SPAWNTEMP},
    {"randomspawn", offsetof(spawn_temp_t, randomSpawn), F_INT, FFL_SPAWNTEMP},

    {0, 0, 0, 0}
};

static void ED_CallSpawn (edict_t * ent)
{
    const spawn_t *s;

    if (!ent->classname)
        return;

    /* check normal spawn functions */
    for (s = spawns; s->name; s++) {
        /* found it */
        if (!strcmp(s->name, ent->classname)) {
            s->spawn(ent);
            return;
        }
    }

    ent->inuse = qfalse;
}

static char *ED_NewString (const char *string)
{
    char *newb, *new_p;
    int i;
    const size_t l = strlen(string) + 1;

    newb = (char*)G_TagMalloc(l, TAG_LEVEL);
    new_p = newb;

    for (i = 0; i < l; i++) {
        /* check for special chars and convert them */
        if (string[i] == '\\' && i < l - 1) {
            i++;
            if (string[i] == 'n')
                *new_p++ = '\n';
            else
                *new_p++ = '\\';
        } else
            *new_p++ = string[i];
    }

    return newb;
}

static void ED_ParseField (const char *key, const char *value, edict_t * ent)
{
    const field_t *f;
    byte *b;
    vec3_t vec;

    for (f = fields; f->name; f++) {
        if (!(f->flags & FFL_NOSPAWN) && !Q_strcasecmp(f->name, key)) {
            /* found it */
            if (f->flags & FFL_SPAWNTEMP)
                b = (byte *) & st;
            else
                b = (byte *) ent;

            switch (f->type) {
            case F_LSTRING:
                *(char **) (b + f->ofs) = ED_NewString(value);
                break;
            case F_VECTOR:
                sscanf(value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
                ((float *) (b + f->ofs))[0] = vec[0];
                ((float *) (b + f->ofs))[1] = vec[1];
                ((float *) (b + f->ofs))[2] = vec[2];
                break;
            case F_INT:
                *(int *) (b + f->ofs) = atoi(value);
                break;
            case F_FLOAT:
                *(float *) (b + f->ofs) = atof(value);
                break;
            case F_IGNORE:
                break;
            }
            return;
        }
    }
}

static const char *ED_ParseEdict (const char *data, edict_t * ent)
{
    qboolean init;
    char keyname[MAX_VAR];

    init = qfalse;
    memset(&st, 0, sizeof(st));

    /* go through all the dictionary pairs */
    while (1) {
        /* parse key */
        const char *c = Com_Parse(&data);
        if (c[0] == '}')
            break;
        if (!data)
            gi.Error("ED_ParseEntity: EOF without closing brace");

        Q_strncpyz(keyname, c, sizeof(keyname));

        /* parse value */
        c = Com_Parse(&data);
        if (!data)
            gi.Error("ED_ParseEntity: EOF without closing brace");

        if (c[0] == '}')
            gi.Error("ED_ParseEntity: closing brace without data");

        init = qtrue;

        /* keynames with a leading underscore are used for utility comments,
         * and are immediately discarded by ufo */
        if (keyname[0] == '_')
            continue;

        ED_ParseField(keyname, c, ent);
    }

    if (!init)
        memset(ent, 0, sizeof(*ent));

    return data;
}

static void G_FindEdictGroups (void)
{
    edict_t *ent = G_EdictsGetFirst(); /* the first edict is always a world edict that can be skipped */

    while ((ent = G_EdictsGetNextInUse(ent))) {
        edict_t *ent2, *chain;

        if (!ent->group)
            continue;
        if (ent->flags & FL_GROUPSLAVE)
            continue;
        chain = ent;
        ent->groupMaster = ent;
        ent2 = ent;         /* search only the remainder of the entities */
        while ((ent2 = G_EdictsGetNextInUse(ent2))) {
            if (!ent2->group)
                continue;
            if (ent2->flags & FL_GROUPSLAVE)
                continue;
            if (!strcmp(ent->group, ent2->group)) {
                chain->groupChain = ent2;
                ent2->groupMaster = ent;
                chain = ent2;
                ent2->flags |= FL_GROUPSLAVE;
            }
        }
    }
}

void G_SpawnEntities (const char *mapname, qboolean day, const char *entities)
{
    edict_t *ent;
    int entnum;

    G_FreeTags(TAG_LEVEL);

    memset(&level, 0, sizeof(level));
    G_EdictsReset();

    Q_strncpyz(level.mapname, mapname, sizeof(level.mapname));
    level.day = day;

    G_ResetClientData();

    ent = NULL;
    level.activeTeam = TEAM_NO_ACTIVE;
    level.actualRound = 1;
    level.hurtAliens = sv_hurtaliens->integer;
    ai_waypointList = NULL;

    /* parse ents */
    entnum = 0;
    while (1) {
        /* parse the opening brace */
        const char *token = Com_Parse(&entities);
        if (!entities)
            break;
        if (token[0] != '{')
            gi.Error("ED_LoadFromFile: found %s when expecting {", token);

        if (!ent)
            ent = G_EdictsGetFirst();
        else
            ent = G_Spawn();

        entities = ED_ParseEdict(entities, ent);

        ent->mapNum = entnum++;

        /* Set the position of the entity */
        VecToPos(ent->origin, ent->pos);

        /* Call this entity's specific initializer (sets ent->type) */
        ED_CallSpawn(ent);

        /* if this entity is an bbox (e.g. actor), then center its origin based on its position */
        if (ent->solid == SOLID_BBOX)
            G_EdictCalcOrigin(ent);
    }

    /* spawn ai players, if needed */
    if (level.num_spawnpoints[TEAM_CIVILIAN]) {
        if (AI_CreatePlayer(TEAM_CIVILIAN) == NULL)
            gi.DPrintf("Could not create civilian\n");
    }

    if ((sv_maxclients->integer == 1 || ai_numactors->integer) && level.num_spawnpoints[TEAM_ALIEN]) {
        if (AI_CreatePlayer(TEAM_ALIEN) == NULL)
            gi.DPrintf("Could not create alien\n");
    }

    Com_Printf("Used inventory slots after ai spawn: %i\n", game.i.GetUsedSlots(&game.i));

    G_FindEdictGroups();
}

static inline void G_InitEdict (edict_t * ent)
{
    ent->inuse = qtrue;
    ent->classname = "noclass";
    ent->number = G_EdictsGetNumber(ent);
    ent->fieldSize = ACTOR_SIZE_NORMAL;
}

edict_t *G_Spawn (void)
{
    edict_t *ent = G_EdictsGetNewEdict();

    if (!ent)
        gi.Error("G_Spawn: no free edicts");

    G_InitEdict(ent);
    return ent;
}

edict_t *G_SpawnFloor (const pos3_t pos)
{
    edict_t *floor;

    floor = G_Spawn();
    floor->classname = "item";
    floor->type = ET_ITEM;
    /* make sure that the item is always on a field that even the smallest actor can reach */
    floor->fieldSize = ACTOR_SIZE_NORMAL;
    VectorCopy(pos, floor->pos);
    floor->pos[2] = gi.GridFall(gi.routingMap, floor->fieldSize, floor->pos);
    G_EdictCalcOrigin(floor);
    return floor;
}

edict_t *G_SpawnParticle (const vec3_t origin, int spawnflags, const char *particle)
{
    edict_t *ent = G_Spawn();
    ent->classname = "particle";
    ent->type = ET_PARTICLE;
    VectorCopy(origin, ent->origin);

    /* Set the position of the entity */
    VecToPos(ent->origin, ent->pos);

    ent->particle = particle;
    ent->spawnflags = spawnflags;

    G_CheckVis(ent, qtrue);

    return ent;
}

static void G_ActorSpawn (edict_t *ent)
{
    /* set properties */
    level.num_spawnpoints[ent->team]++;
    ent->classname = "actor";
    ent->type = ET_ACTORSPAWN;
    ent->fieldSize = ACTOR_SIZE_NORMAL;

    /* Fall to ground */
    if (ent->pos[2] >= PATHFINDING_HEIGHT)
        ent->pos[2] = PATHFINDING_HEIGHT - 1;

    ent->pos[2] = gi.GridFall(gi.routingMap, ent->fieldSize, ent->pos);
    if (ent->pos[2] >= PATHFINDING_HEIGHT)
        gi.DPrintf("G_ActorSpawn: Warning: z level is out of bounds: %i\n", ent->pos[2]);

    G_EdictCalcOrigin(ent);

    /* link it for collision detection */
    ent->dir = AngleToDir(ent->angle);
    assert(ent->dir < CORE_DIRECTIONS);
    ent->solid = SOLID_BBOX;

    /* Set bounding box. Maybe this is already set in one of the spawn functions? */
    if (ent->maxs[0] == 0)
        VectorSet(ent->maxs, PLAYER_WIDTH, PLAYER_WIDTH, PLAYER_STAND);
    if (ent->mins[0] == 0)
        VectorSet(ent->mins, -PLAYER_WIDTH, -PLAYER_WIDTH, PLAYER_MIN);
}

static void G_Actor2x2Spawn (edict_t *ent)
{
    /* set properties */
    level.num_2x2spawnpoints[ent->team]++;
    ent->classname = "ugv";
    ent->type = ET_ACTOR2x2SPAWN;
    ent->fieldSize = ACTOR_SIZE_2x2;

    /* Fall to ground */
    if (ent->pos[2] >= PATHFINDING_HEIGHT)
        ent->pos[2] = PATHFINDING_HEIGHT - 1;
    ent->pos[2] = gi.GridFall(gi.routingMap, ent->fieldSize, ent->pos);
    if (ent->pos[2] >= PATHFINDING_HEIGHT)
        gi.DPrintf("G_Actor2x2Spawn: Warning: z level is out of bounds: %i\n", ent->pos[2]);
    G_EdictCalcOrigin(ent);

    /* link it for collision detection */
    ent->dir = AngleToDir(ent->angle);
    assert(ent->dir < CORE_DIRECTIONS);
    ent->solid = SOLID_BBOX;

    /* Set bounding box. Maybe this is already set in one of the spawn functions? */
    if (ent->maxs[0] == 0)
        VectorSet(ent->maxs, PLAYER2x2_WIDTH, PLAYER2x2_WIDTH, PLAYER_STAND);
    if (ent->mins[0] == 0)
        VectorSet(ent->mins, -PLAYER2x2_WIDTH, -PLAYER2x2_WIDTH, PLAYER_MIN);
}

static void SP_light (edict_t *ent)
{
    /* lights aren't client-server communicated items */
    /* they are completely client side */
    G_FreeEdict(ent);
}

static void SP_player_start (edict_t *ent)
{
    /* only used in multi player */
    if (sv_maxclients->integer == 1) {
        G_FreeEdict(ent);
        return;
    }

    /* maybe there are already the max soldiers allowed per team connected */
    if (sv_maxsoldiersperteam->integer > level.num_spawnpoints[ent->team]) {
        ent->STUN = 0;
        ent->HP = MAX_HP;
        G_ActorSpawn(ent);
    } else
        G_FreeEdict(ent);
}

static void SP_human_start (edict_t *ent)
{
    /* only used in single player */
    if (sv_maxclients->integer > 1) {
        G_FreeEdict(ent);
        return;
    }
    ent->team = TEAM_PHALANX;
    ent->STUN = 0;
    ent->HP = MAX_HP;
    G_ActorSpawn(ent);
}


static void SP_2x2_start (edict_t *ent)
{
    /* no 2x2 unit in multiplayer */
    if (sv_maxclients->integer > 1) {
        G_FreeEdict(ent);
        return;
    }
    /* set stats */
    ent->STUN = 0;
    ent->HP = MAX_HP;

    if (!ent->team)
        ent->team = TEAM_PHALANX;

    /* these units are bigger */
    VectorSet(ent->maxs, PLAYER_WIDTH * 2, PLAYER_WIDTH * 2, PLAYER_STAND);
    VectorSet(ent->mins, -(PLAYER_WIDTH * 2), -(PLAYER_WIDTH * 2), PLAYER_MIN);

    /* spawn singleplayer 2x2 unit */
    G_Actor2x2Spawn(ent);
}

static void SP_alien_start (edict_t *ent)
{
    /* deactivateable in multiplayer */
    if (sv_maxclients->integer > 1 && !ai_numactors->integer) {
        G_FreeEdict(ent);
        return;
    }
    ent->team = TEAM_ALIEN;
    /* set stats */
    ent->STUN = 0;
    ent->HP = MAX_HP;
    /* hurt aliens in ufo crash missions (5%: almost dead, 15%: wounded, 30%: stunned)  */
    if (level.hurtAliens) {
        const float random = frand();
        if (random <= .05f) {
            ent->STUN = 50;
            ent->HP = 5;
        } else if (random <= .15f) {
            ent->STUN = 30;
            ent->HP /= 2;
        } else if (random <= .3f) {
            ent->STUN = 75;
        }
    }

    G_ActorSpawn(ent);
}


static void SP_civilian_start (edict_t *ent)
{
    /* deactivateable in multiplayer */
    if (sv_maxclients->integer > 1 && !ai_numcivilians->integer) {
        G_FreeEdict(ent);
        return;
    }
    ent->team = TEAM_CIVILIAN;
    /* set stats */
    ent->STUN = 99; 
    ent->HP = MAX_HP;
    ent->count = 100; /* current waypoint */
    G_ActorSpawn(ent);
}

static void SP_civilian_target (edict_t *ent)
{
    /* target point for which team */
    ent->team = TEAM_CIVILIAN;
    ent->classname = "civtarget";
    ent->type = ET_CIVILIANTARGET;
    ent->fieldSize = ACTOR_SIZE_NORMAL; /* to let the grid fall function work */

    /* add the edict to the list of known waypoints */
    G_AddToWayPointList(ent);

    /* fall to ground */
    if (ent->pos[2] >= PATHFINDING_HEIGHT)
        ent->pos[2] = PATHFINDING_HEIGHT - 1;
    ent->pos[2] = gi.GridFall(gi.routingMap, ent->fieldSize, ent->pos);
    G_EdictCalcOrigin(ent);
}

static void SP_misc_mission (edict_t *ent)
{
    edict_t *other;

    ent->classname = "mission";
    ent->type = ET_MISSION;

    /* maybe this was set to something else for multiplayer */
    if (!ent->team)
        ent->team = TEAM_PHALANX;

    ent->solid = SOLID_BBOX;

    if (ent->HP) {
        ent->flags |= FL_DESTROYABLE;
        ent->destroy = G_MissionDestroy;
    }

    if (!ent->HP && !ent->time && !ent->target) {
        G_FreeEdict(ent);
        gi.DPrintf("misc_mission given with no objective\n");
        return;
    }

    /* think function values */
    ent->think = G_MissionThink;
    ent->nextthink = 1;

    VectorSet(ent->absmax, PLAYER_WIDTH * 3, PLAYER_WIDTH * 3, PLAYER_STAND);
    VectorSet(ent->absmin, -(PLAYER_WIDTH * 3), -(PLAYER_WIDTH * 3), PLAYER_MIN);

    /* spawn the trigger entity */
    other = G_TriggerSpawn(ent);
    other->touch = G_MissionTouch;
    if (ent->target)
        ent->use = G_MissionUse;
    ent->child = other;

    gi.LinkEdict(ent);
}

static void SP_misc_mission_aliens (edict_t *ent)
{
    edict_t *other;

    ent->classname = "mission";
    ent->type = ET_MISSION;
    ent->team = TEAM_ALIEN;
    ent->solid = SOLID_BBOX;

    /* think function values */
    ent->think = G_MissionThink;
    ent->nextthink = 1;

    VectorSet(ent->absmax, PLAYER_WIDTH * 3, PLAYER_WIDTH * 3, PLAYER_STAND);
    VectorSet(ent->absmin, -(PLAYER_WIDTH * 3), -(PLAYER_WIDTH * 3), PLAYER_MIN);

    /* spawn the trigger entity */
    other = G_TriggerSpawn(ent);
    other->touch = G_MissionTouch;
    ent->child = other;

    gi.LinkEdict(ent);
}

static void G_BuildForbiddenListForEntity (edict_t *ent)
{
    pos3_t mins, maxs, origin;
    vec3_t center, shiftedMins, shiftedMaxs;
    int xDelta, yDelta, size, i, j;

    VectorAdd(ent->absmin, ent->origin, shiftedMins);
    VectorAdd(ent->absmax, ent->origin, shiftedMaxs);

    VectorCenterFromMinsMaxs(shiftedMins, shiftedMaxs, center);
    VecToPos(shiftedMins, mins);
    VecToPos(shiftedMaxs, maxs);
    VecToPos(center, origin);

    xDelta = max(1, maxs[0] - mins[0]);
    yDelta = max(1, maxs[1] - mins[1]);

    size = xDelta * yDelta;
    ent->forbiddenListPos = (pos3_t *)G_TagMalloc(size * sizeof(pos3_t), TAG_LEVEL);
    ent->forbiddenListSize = size;

    for (i = 0; i < xDelta; i++) {
        for (j = 0; j < yDelta; j++) {
            const pos_t x = mins[0] + i;
            const pos_t y = mins[1] + j;
            const pos_t z = origin[2];
            VectorSet(ent->forbiddenListPos[i], x, y, z);
        }
    }
}

#define MISC_MODEL_SOLID 256

static void SP_misc_model (edict_t *ent)
{
    if (ent->spawnflags & MISC_MODEL_SOLID) {
        if (ent->model && ent->model[0] != '\0') {
            vec3_t modelMins, modelMaxs;
            if (gi.LoadModelMinsMaxs(ent->model, ent->frame, modelMins, modelMaxs)) {
                ent->classname = "model";
                VectorCopy(modelMaxs, ent->absmax);
                VectorCopy(modelMins, ent->absmin);
                ent->type = ET_SOLID;
                ent->solid = SOLID_BBOX;
                ent->fieldSize = ACTOR_SIZE_NORMAL;
                G_BuildForbiddenListForEntity(ent);
                gi.LinkEdict(ent);
            } else {
                gi.DPrintf("Could not get mins/maxs for model '%s'\n", ent->model);
                G_FreeEdict(ent);
            }
        } else {
            gi.DPrintf("server_solid misc_model with no model given\n");
            G_FreeEdict(ent);
        }
    } else {
        /* handled client side */
        G_FreeEdict(ent);
    }
}

static void SP_misc_item (edict_t *ent)
{
    if (!ent->item) {
        gi.DPrintf("No item defined in misc_item\n");
        G_FreeEdict(ent);
        return;
    }

    G_AddItemToFloor(ent->pos, ent->item);

    /* now we can free the original edict */
    G_FreeEdict(ent);
}

static qboolean Message_Use (edict_t *self, edict_t *activator)
{
    if (!activator || !G_IsActor(activator)) {
        return qfalse;
    } else {
        player_t *player = G_PLAYER_FROM_ENT(activator);
        const char *msg = self->message;
        /* remove gettext marker */
        if (msg[0] == '_')
            msg++;
        G_ClientPrintf(player, PRINT_HUD, "%s", msg);

        if (self->spawnflags & 1)
            G_FreeEdict(self);

        return qfalse;
    }
}

static void SP_misc_message (edict_t *ent)
{
    if (!ent->message) {
        G_FreeEdict(ent);
        return;
    }

    if (ent->message[0] != '_')
        gi.DPrintf("No translation marker for misc_message set\n");
    ent->use = Message_Use;
    ent->classname = "misc_message";
    ent->type = ET_MESSAGE;
    ent->solid = SOLID_NOT;
}

static void SP_dummy (edict_t *ent)
{
    /* particles aren't client-server communicated items
     * they are completely client side */
    G_FreeEdict(ent);
}

static void SP_worldspawn (edict_t *ent)
{
    ent->solid = SOLID_BSP;
    /* since the world doesn't use G_Spawn() */
    ent->inuse = qtrue;
    ent->classname = "worldspawn";

    if (st.nextmap)
        Q_strncpyz(level.nextmap, st.nextmap, sizeof(level.nextmap));
    level.randomSpawn = st.randomSpawn;

    gi.ConfigString(CS_MAXCLIENTS, "%i", sv_maxclients->integer);

    /* only used in multi player */
    if (sv_maxclients->integer >= 2) {
        gi.ConfigString(CS_MAXSOLDIERSPERTEAM, "%i", sv_maxsoldiersperteam->integer);
        gi.ConfigString(CS_MAXSOLDIERSPERPLAYER, "%i", sv_maxsoldiersperplayer->integer);
        gi.ConfigString(CS_ENABLEMORALE, "%i", sv_enablemorale->integer);
        gi.ConfigString(CS_MAXTEAMS, "%s", sv_maxteams->string);
    }
}