/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void ) {
int i;
gentity_t *ent;
char *str;
// get the next free entity
ent = G_Spawn();
for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
// check for "notteam" / "notfree" flags
G_SpawnInt( "notteam", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
// allowteams handling
G_SpawnString( "allowteams", "", &str );
if( str[0] ) {
str = Q_strlwr( str );
if( strstr( str, "axis" ) ) {
ent->allowteams |= ALLOW_AXIS_TEAM;
}
if( strstr( str, "allies" ) ) {
ent->allowteams |= ALLOW_ALLIED_TEAM;
}
if( strstr( str, "cvops" ) ) {
ent->allowteams |= ALLOW_DISGUISED_CVOPS;
}
}
if( ent->targetname && *ent->targetname ) {
ent->targetnamehash = BG_StringHashValue( ent->targetname );
} else {
ent->targetnamehash = -1;
}
// move editor origin to pos
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) ) {
G_FreeEntity( ent );
}
// RF, try and move it into the bot entities if possible
// BotCheckBotGameEntity( ent );
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void ) {
int i;
gentity_t *ent;
char *s, *value, *gametypeName;
static char *gametypeNames[] = {"aw_dm", "aw_team", "aw_tactical"};
// get the next free entity
ent = G_Spawn();
for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
// check for "notteam" flag (GT_FFA, GT_TOURNAMENT, GT_SINGLE_PLAYER)
if ( g_gametype.integer < GT_DM ) {
G_SpawnInt( "notteam", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
} else {
G_SpawnInt( "notdm", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
}
if( G_SpawnString( "gametype", NULL, &value ) ) {
if( g_gametype.integer >= GT_DM && g_gametype.integer < GT_MAX_GAME_TYPE ) {
gametypeName = gametypeNames[g_gametype.integer];
s = strstr( value, gametypeName );
if( !s ) {
G_FreeEntity( ent );
return;
}
}
}
// move editor origin to pos
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) ) {
G_FreeEntity( ent );
}
}
/*
=======================================================================================================================================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
=======================================================================================================================================
*/
void G_SpawnGEntityFromSpawnVars(void) {
int i;
gentity_t *ent;
// get the next free entity
ent = G_Spawn();
for (i = 0; i < level.numSpawnVars; i++) {
G_ParseField(level.spawnVars[i][0], level.spawnVars[i][1], ent);
}
// check for "notteam"/"notfree" flags
if (g_gametype.integer == GT_SINGLE_PLAYER) {
G_SpawnInt("notsingle", "0", &i);
if (i) {
ADJUST_AREAPORTAL();
G_FreeEntity(ent);
return;
}
}
if (g_gametype.integer >= GT_TEAM) {
G_SpawnInt("notteam", "0", &i);
if (i) {
ADJUST_AREAPORTAL();
G_FreeEntity(ent);
return;
}
} else {
G_SpawnInt("notfree", "0", &i);
if (i) {
ADJUST_AREAPORTAL();
G_FreeEntity(ent);
return;
}
}
// move editor origin to pos
VectorCopy(ent->s.origin, ent->s.pos.trBase);
VectorCopy(ent->s.origin, ent->r.currentOrigin);
// if we didn't get a classname, don't bother spawning anything
if (!G_CallSpawn(ent)) {
ADJUST_AREAPORTAL();
G_FreeEntity(ent);
}
}
/*
* @brief Parses an edict out of the given string, returning the new position
* in said string. The edict parameter should be a properly initialized
* free edict.
*/
static const char *G_ParseEntity(const char *data, g_edict_t *ent) {
_Bool init;
char key[MAX_QPATH];
const char *tok;
init = false;
memset(&g_game.spawn, 0, sizeof(g_game.spawn));
// go through all the dictionary pairs
while (true) {
// parse key
tok = ParseToken(&data);
if (tok[0] == '}')
break;
if (!data)
gi.Error("EOF without closing brace\n");
g_strlcpy(key, tok, sizeof(key));
// parse value
tok = ParseToken(&data);
if (!data)
gi.Error("EOF in edict definition\n");
if (tok[0] == '}')
gi.Error("No edict definition\n");
init = true;
// keys with a leading underscore are used for utility comments,
// and are immediately discarded by quake
if (key[0] == '_')
continue;
G_ParseField(key, tok, ent);
}
if (!init)
memset(ent, 0, sizeof(*ent));
return data;
}
/**
* @brief Parses an entity out of the given string.
* The entity should be a properly initialized free entity.
*/
static void G_ParseEntity(parser_t *parser, g_entity_t *ent) {
char key[MAX_BSP_ENTITY_KEY], value[MAX_BSP_ENTITY_VALUE];
_Bool init = false;
memset(&g_game.spawn, 0, sizeof(g_game.spawn));
// go through all the dictionary pairs
while (true) {
// parse key
if (!Parse_Token(parser, PARSE_DEFAULT, key, sizeof(key))) {
gi.Error("EOF without closing brace\n");
}
if (key[0] == '}') {
break;
}
// parse value
if (!Parse_Token(parser, PARSE_DEFAULT | PARSE_NO_WRAP, value, sizeof(value))) {
gi.Error("EOF in entity definition\n");
}
if (value[0] == '}') {
gi.Error("No entity definition\n");
}
init = true;
// keys with a leading underscore are used for utility comments,
// and are immediately discarded by quake
if (key[0] == '_') {
continue;
}
G_ParseField(key, value, ent);
}
if (!init) {
G_ClearEntity(ent);
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void ) {
int i;
gentity_t *ent;
// get the next free entity
ent = G_Spawn();
for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
if ( g_gametype.integer >= GT_TEAM ) {
G_SpawnInt( "notteam", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
} else {
G_SpawnInt( "notfree", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
}
if ( ent->targetname && *ent->targetname ) {
ent->targetnamehash = BG_StringHashValue( ent->targetname );
} else {
ent->targetnamehash = -1;
}
// move editor origin to pos
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) ) {
G_FreeEntity( ent );
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void )
{
int i;
gedict_t *ent;
// get the next free entity
ent = spawn();
for ( i = 0; i < numSpawnVars; i++ )
{
G_ParseField( spawnVars[i][0], spawnVars[i][1], ent );
}
if ( deathmatch )
{
if ( ( ( int ) ent->s.v.spawnflags & SPAWNFLAG_NOT_DEATHMATCH ) )
{
// G_cprint( "%s removed because of SPAWNFLAG_NOT_DEATHMATCH\n", ent->s.v.classname );
ent_remove( ent );
return;
}
}
else if ( ( skill == 0 && ((int)ent->s.v.spawnflags & SPAWNFLAG_NOT_EASY) )
|| ( skill == 1 && ((int)ent->s.v.spawnflags & SPAWNFLAG_NOT_MEDIUM) )
|| ( skill >= 2 && ((int)ent->s.v.spawnflags & SPAWNFLAG_NOT_HARD) )
)
{
// G_cprint( "%s removed because of SPAWNFLAG_NOT_XXX\n", ent->s.v.classname );
ent_remove( ent );
return;
}
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) )
{
ent_remove( ent );
return;
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void ) {
int i;
gentity_t *ent;
char *s, *value, *gametypeName;
static char *gametypeNames[] = { "ffa", "tournament", "single", "team", "ca" /*FIXME "clanarena" */, "ctf", "oneflag", "obelisk", "harvester", "ft", "dom", "ad", "rr", "race" };
// get the next free entity
ent = G_Spawn();
for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
// check for "notsingle" flag
if ( g_gametype.integer == GT_SINGLE_PLAYER ) {
G_SpawnInt( "notsingle", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
// check for "notteam" flag (GT_FFA, GT_TOURNAMENT, GT_SINGLE_PLAYER)
if ( g_gametype.integer >= GT_TEAM ) {
G_SpawnInt( "notteam", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
} else {
G_SpawnInt( "notfree", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
//FIXME this can also be a string in quake live
if (G_SpawnString("not_gametype", NULL, &value)) {
//FIXME did quakelive also use ints before ?
if (isdigit(value[0])) {
// old check using integer gametype values
if (g_gametype.integer == i) {
ADJUST_AREAPORTAL();
G_FreeEntity(ent);
return;
}
} else {
if (g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE) {
gametypeName = gametypeNames[g_gametype.integer];
s = strstr(value, gametypeName);
if (!s) {
// try alternate quake live gametype names
if (g_gametype.integer == GT_TEAM) {
s = strstr(value, "tdm");
} else if (g_gametype.integer == GT_TOURNAMENT) {
s = strstr(value, "duel");
} else if (g_gametype.integer == GT_HARVESTER) {
s = strstr(value, "har");
} else if (g_gametype.integer == GT_1FCTF) {
s = strstr(value, "1f");
} else if (g_gametype.integer == GT_OBELISK) {
s = strstr(value, "ob");
}
}
if (s) {
//G_Printf("skipping item, not in gametype string: '%s'\n", value);
ADJUST_AREAPORTAL();
G_FreeEntity(ent);
return;
}
}
}
}
#if 1 //def MPACK
G_SpawnInt( "notta", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
#else
G_SpawnInt( "notq3a", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
#endif
if (G_SpawnString("gametype", NULL, &value)) {
//Com_Printf("^5gametype: %s\n", value);
//FIXME gametype as int? q3 mods?
if (g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE) {
gametypeName = gametypeNames[g_gametype.integer];
s = strstr(value, gametypeName);
if (!s) {
// try alternate quake live gametype names
if (g_gametype.integer == GT_TEAM) {
s = strstr(value, "tdm");
} else if (g_gametype.integer == GT_TOURNAMENT) {
s = strstr(value, "duel");
} else if (g_gametype.integer == GT_HARVESTER) {
s = strstr(value, "har");
} else if (g_gametype.integer == GT_1FCTF) {
s = strstr(value, "1f");
} else if (g_gametype.integer == GT_OBELISK) {
s = strstr(value, "ob");
}
}
if (!s) {
//G_Printf("skipping item, not in gametype string: '%s'\n", value);
ADJUST_AREAPORTAL();
G_FreeEntity(ent);
return;
}
}
}
// move editor origin to pos
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) ) {
G_FreeEntity( ent );
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( bool inSubBSP )
{
gentity_t *ent;
char *value;
if (inSubBSP)
{
// filter out the unwanted entities
G_SpawnString("filter", "", &value);
if (value[0] && strcmp(level.mFilter, value))
{
// we are not matching up to the filter, so no spawney
return;
}
}
// get the next free entity
ent = G_Spawn();
int i;
for (i = 0 ; i < level.numSpawnVars ; i++ )
{
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
// check for "notteam" flag (GT_DM)
if ( level.gametypeData->teams )
{
G_SpawnInt( "notteam", "0", &i );
if ( i )
{
G_FreeEntity( ent );
return;
}
}
else
{
G_SpawnInt( "notfree", "0", &i );
if ( i )
{
G_FreeEntity( ent );
return;
}
}
// Only spawn this entity in the specified gametype
if( G_SpawnString( "gametype", NULL, &value ) )
{
// Has to be a case match
if ( value && !strstr ( value, level.gametypeData->name ) )
{
G_FreeEntity ( ent );
return;
}
}
// move editor origin to pos
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) )
{
G_FreeEntity( ent );
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void )
{
int i, j;
gentity_t *spawningEntity;
// get the next free entity
spawningEntity = G_NewEntity();
for ( i = 0; i < level.numSpawnVars; i++ )
{
G_ParseField( level.spawnVars[ i ][ 0 ], level.spawnVars[ i ][ 1 ], spawningEntity );
}
if(G_SpawnBoolean( "nop", qfalse ) || G_SpawnBoolean( "notunv", qfalse ))
{
G_FreeEntity( spawningEntity );
return;
}
/*
* will have only the classname or missing it…
* both aren't helping us and might even create a error later
* in the server, where we dont know as much anymore about it,
* so we fail rather here, so mappers have a chance to remove it
*/
if( level.numSpawnVars <= 1 )
{
G_Error( S_ERROR "encountered ghost-entity #%i with only one field: %s = %s\n", spawningEntity->s.number, level.spawnVars[ 0 ][ 0 ], level.spawnVars[ 0 ][ 1 ] );
}
// move editor origin to pos
VectorCopy( spawningEntity->s.origin, spawningEntity->s.pos.trBase );
VectorCopy( spawningEntity->s.origin, spawningEntity->r.currentOrigin );
// don't leave any "gaps" between multiple names
j = 0;
for (i = 0; i < MAX_ENTITY_ALIASES; ++i)
{
if (spawningEntity->names[i])
spawningEntity->names[j++] = spawningEntity->names[i];
}
spawningEntity->names[ j ] = NULL;
/*
* for backward compatbility, since before targets were used for calling,
* we'll have to copy them over to the called-targets as well for now
*/
if(!spawningEntity->callTargetCount)
{
for (i = 0; i < MAX_ENTITY_TARGETS && i < MAX_ENTITY_CALLTARGETS; i++)
{
if (!spawningEntity->targets[i])
continue;
spawningEntity->calltargets[i].event = "target";
spawningEntity->calltargets[i].eventType = ON_DEFAULT;
spawningEntity->calltargets[i].actionType = ECA_DEFAULT;
spawningEntity->calltargets[i].name = spawningEntity->targets[i];
spawningEntity->callTargetCount++;
}
}
// don't leave any "gaps" between multiple targets
j = 0;
for (i = 0; i < MAX_ENTITY_TARGETS; ++i)
{
if (spawningEntity->targets[i])
spawningEntity->targets[j++] = spawningEntity->targets[i];
}
spawningEntity->targets[ j ] = NULL;
// if we didn't get necessary fields (like the classname), don't bother spawning anything
if ( !G_CallSpawnFunction( spawningEntity ) )
{
G_FreeEntity( spawningEntity );
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( qboolean inSubBSP ) {
int i;
gentity_t *ent;
char *s, *value, *gametypeName;
static char *gametypeNames[] = {"ffa", "holocron", "jedimaster", "duel", "powerduel", "single", "team", "siege", "ctf", "cty"};
// get the next free entity
ent = G_Spawn();
for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
// check for "notsingle" flag
if ( g_gametype.integer == GT_SINGLE_PLAYER ) {
G_SpawnInt( "notsingle", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
// check for "notteam" flag (GT_FFA, GT_DUEL, GT_SINGLE_PLAYER)
if ( g_gametype.integer >= GT_TEAM ) {
G_SpawnInt( "notteam", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
} else {
G_SpawnInt( "notfree", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if( G_SpawnString( "gametype", NULL, &value ) ) {
if( g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE ) {
gametypeName = gametypeNames[g_gametype.integer];
s = strstr( value, gametypeName );
if( !s ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
}
// move editor origin to pos
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) ) {
G_FreeEntity( ent );
}
//Tag on the ICARUS scripting information only to valid recipients
if ( trap_ICARUS_ValidEnt( ent ) )
{
trap_ICARUS_InitEnt( ent );
if ( ent->classname && ent->classname[0] )
{
if ( Q_strncmp( "NPC_", ent->classname, 4 ) != 0 )
{//Not an NPC_spawner (rww - probably don't even care for MP, but whatever)
G_ActivateBehavior( ent, BSET_SPAWN );
}
}
}
}
void SP_worldspawn( void )
{
char *text, temp[32];
int i;
int lengthRed, lengthBlue, lengthGreen;
//I want to "cull" entities out of net sends to clients to reduce
//net traffic on our larger open maps -rww
G_SpawnFloat("distanceCull", "6000.0", &g_cullDistance);
trap_SetServerCull(g_cullDistance);
G_SpawnString( "classname", "", &text );
if ( Q_stricmp( text, "worldspawn" ) ) {
G_Error( "SP_worldspawn: The first entity isn't 'worldspawn'" );
}
for ( i = 0 ; i < level.numSpawnVars ; i++ )
{
if ( Q_stricmp( "spawnscript", level.spawnVars[i][0] ) == 0 )
{//ONly let them set spawnscript, we don't want them setting an angle or something on the world.
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], &g_entities[ENTITYNUM_WORLD] );
}
}
//The server will precache the standard model and animations, so that there is no hit
//when the first client connnects.
if (!BGPAFtextLoaded)
{
BG_ParseAnimationFile("models/players/_humanoid/animation.cfg", bgHumanoidAnimations, qtrue);
}
if (!precachedKyle)
{
int defSkin;
trap_G2API_InitGhoul2Model(&precachedKyle, "models/players/kyle/model.glm", 0, 0, -20, 0, 0);
if (precachedKyle)
{
defSkin = trap_R_RegisterSkin("models/players/kyle/model_default.skin");
trap_G2API_SetSkin(precachedKyle, 0, defSkin, defSkin);
}
}
if (!g2SaberInstance)
{
trap_G2API_InitGhoul2Model(&g2SaberInstance, "models/weapons2/saber/saber_w.glm", 0, 0, -20, 0, 0);
if (g2SaberInstance)
{
// indicate we will be bolted to model 0 (ie the player) on bolt 0 (always the right hand) when we get copied
trap_G2API_SetBoltInfo(g2SaberInstance, 0, 0);
// now set up the gun bolt on it
trap_G2API_AddBolt(g2SaberInstance, 0, "*blade1");
}
}
if (g_gametype.integer == GT_SIEGE)
{ //a tad bit of a hack, but..
EWebPrecache();
}
// make some data visible to connecting client
trap_SetConfigstring( CS_GAME_VERSION, GAME_VERSION );
trap_SetConfigstring( CS_LEVEL_START_TIME, va("%i", level.startTime ) );
G_SpawnString( "music", "", &text );
trap_SetConfigstring( CS_MUSIC, text );
G_SpawnString( "message", "", &text );
trap_SetConfigstring( CS_MESSAGE, text ); // map specific message
trap_SetConfigstring( CS_MOTD, g_motd.string ); // message of the day
G_SpawnString( "gravity", "800", &text );
trap_Cvar_Set( "g_gravity", text );
G_SpawnString( "enableBreath", "0", &text );
trap_Cvar_Set( "g_enableBreath", text );
G_SpawnString( "soundSet", "default", &text );
trap_SetConfigstring( CS_GLOBAL_AMBIENT_SET, text );
g_entities[ENTITYNUM_WORLD].s.number = ENTITYNUM_WORLD;
g_entities[ENTITYNUM_WORLD].classname = "worldspawn";
// see if we want a warmup time
trap_SetConfigstring( CS_WARMUP, "" );
if ( g_restarted.integer ) {
trap_Cvar_Set( "g_restarted", "0" );
level.warmupTime = 0;
}
//Raz: Fix warmup
#if 0
/*
else if ( g_doWarmup.integer && g_gametype.integer != GT_DUEL && g_gametype.integer != GT_POWERDUEL ) { // Turn it on
else if ( g_doWarmup.integer && level.gametype != GT_DUEL && level.gametype != GT_POWERDUEL ) { // Turn it on
level.warmupTime = -1;
trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) );
G_LogPrintf( "Warmup:\n" );
}
*/
#else
else if ( g_doWarmup.integer && g_gametype.integer != GT_DUEL && g_gametype.integer != GT_POWERDUEL && g_gametype.integer != GT_SIEGE ) { // Turn it on
level.warmupTime = -1;
trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) );
G_LogPrintf( "Warmup:\n" );
}
#endif
trap_SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+0, defaultStyles[0][0]);
trap_SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+1, defaultStyles[0][1]);
trap_SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+2, defaultStyles[0][2]);
for(i=1;i<LS_NUM_STYLES;i++)
{
Com_sprintf(temp, sizeof(temp), "ls_%dr", i);
G_SpawnString(temp, defaultStyles[i][0], &text);
lengthRed = strlen(text);
trap_SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+0, text);
Com_sprintf(temp, sizeof(temp), "ls_%dg", i);
G_SpawnString(temp, defaultStyles[i][1], &text);
lengthGreen = strlen(text);
trap_SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+1, text);
Com_sprintf(temp, sizeof(temp), "ls_%db", i);
G_SpawnString(temp, defaultStyles[i][2], &text);
lengthBlue = strlen(text);
trap_SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+2, text);
if (lengthRed != lengthGreen || lengthGreen != lengthBlue)
{
Com_Error(ERR_DROP, "Style %d has inconsistent lengths: R %d, G %d, B %d",
i, lengthRed, lengthGreen, lengthBlue);
}
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void ) {
int i;
gentity_t *ent;
char *s, *value, *gametypeName;
static char *gametypeNames[] = {"ffa", "tournament", "single", "team", "ctf", "oneflag", "obelisk", "harvester", "teamtournament"};
// get the next free entity
ent = G_Spawn();
for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
// check for "notsingle" flag
if ( g_gametype.integer == GT_SINGLE_PLAYER ) {
G_SpawnInt( "notsingle", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
}
// check for "notteam" flag (GT_FFA, GT_TOURNAMENT, GT_SINGLE_PLAYER)
if ( g_gametype.integer >= GT_TEAM ) {
G_SpawnInt( "notteam", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
} else {
G_SpawnInt( "notfree", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
}
#ifdef MISSIONPACK
G_SpawnInt( "notta", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
#else
G_SpawnInt( "notq3a", "0", &i );
if ( i ) {
G_FreeEntity( ent );
return;
}
#endif
if( G_SpawnString( "gametype", NULL, &value ) ) {
if( g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE ) {
gametypeName = gametypeNames[g_gametype.integer];
s = strstr( value, gametypeName );
if( !s ) {
G_FreeEntity( ent );
return;
}
}
}
// move editor origin to pos
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) ) {
G_FreeEntity( ent );
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars()
{
int i;
// GameEntity *ent;
SpawnFieldHolder sfh;
memset( &sfh, 0, sizeof(sfh) );
char *s, *value, *gametypeName;
static char *gametypeNames[] = {"ffa", "tournament", "single", "missioneditor", "team", "ctf", "oneflag", "obelisk", "harvester", "teamtournament"};
// get the next free entity
// ent = G_Spawn();
for ( i = 0 ; i < theLevel.numSpawnVars_ ; i++ )
{
// G_ParseField( theLevel.spawnVars_[i][0], theLevel.spawnVars_[i][1], ent );
G_ParseField( theLevel.spawnVars_[i][0], theLevel.spawnVars_[i][1], &sfh );
}
// check for "notsingle" flag
if ( g_gametype.integer == GT_SINGLE_PLAYER )
{
G_SpawnInt( "notsingle", "0", &i );
if ( i )
{
//ent->free();
return;
}
}
// check for "notteam" flag (GT_FFA, GT_TOURNAMENT, GT_SINGLE_PLAYER)
if ( g_gametype.integer >= GT_TEAM )
{
G_SpawnInt( "notteam", "0", &i );
// MFQ3 special case for flags
if( (g_gametype.integer != GT_CTF) &&
(Q_stricmp( sfh.classname_, "team_CTF_redflag" ) == 0 ||
Q_stricmp( sfh.classname_, "team_CTF_blueflag" ) == 0 ) )
{
//ent->free();
return;
}
if ( i )
{
//ent->free();
return;
}
}
else
{
G_SpawnInt( "notfree", "0", &i );
if ( i )
{
//ent->free();
return;
}
}
if( G_SpawnString( "gametype", NULL, &value ) )
{
if( g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE )
{
gametypeName = gametypeNames[g_gametype.integer];
s = strstr( value, gametypeName );
if( !s ) {
//ent->free();
return;
}
}
}
// move editor origin to pos
//VectorCopy( ent->s.origin, ent->s.pos.trBase );
//VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( &sfh ) )
{
//ent->free();
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void ) {
int i;
gentity_t *ent;
char *s, *value;
// get the next free entity
ent = G_Spawn();
for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
// check for "notsingle" flag
if ( g_gametype.integer == GT_SINGLE_PLAYER ) {
G_SpawnInt( "notsingle", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
// check for "notteam" flag (GT_FFA, GT_TOURNAMENT, GT_SINGLE_PLAYER)
if ( gt[g_gametype.integer].teams ) {
G_SpawnInt( "notteam", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
} else {
G_SpawnInt( "notfree", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
#ifdef MISSIONPACK
G_SpawnInt( "notta", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
#else
G_SpawnInt( "notq3a", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
#endif
//fnq3
G_SpawnInt( "notfnq3", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
if ( g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE ) {
if ( G_SpawnString("gametype", NULL, &value) ) {
s = strstr( value, gt[g_gametype.integer].refName );
if ( !s ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( G_SpawnString("not_gametype", NULL, &value) ) {
s = strstr( value, gt[g_gametype.integer].refName );
if ( s ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
}
if ( gt[g_gametype.integer].arena ) {
G_SpawnInt( "not_gt_arena", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( gt[g_gametype.integer].ctf ) {
G_SpawnInt( "not_gt_ctf", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( gt[g_gametype.integer].dom ) {
G_SpawnInt( "not_gt_dom", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( gt[g_gametype.integer].duel ) {
G_SpawnInt( "not_gt_duel", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( gt[g_gametype.integer].elimination ) {
G_SpawnInt( "not_gt_elim", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( gt[g_gametype.integer].freeze ) {
G_SpawnInt( "not_gt_freeze", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( gt[g_gametype.integer].single ) {
G_SpawnInt( "not_gt_single", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( gt[g_gametype.integer].tdm ) {
G_SpawnInt( "not_gt_tdm", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
if ( gt[g_gametype.integer].teams ) {
G_SpawnInt( "not_gt_teams", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
//-fnq3
// move editor origin to pos
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn(ent) ) {
G_FreeEntity( ent );
}
}
/*
===================
G_SpawnGEntityFromSpawnVars
Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void ) {
int i;
gentity_t *ent;
char *s, *value, *gametypeName;
static char *gametypeNames[] = {"ffa", "tournament", "single", "team", "ctf", "oneflag", "obelisk", "harvester"};
int spawnVarsOffset[MAX_SPAWN_VARS][2]; // key / value pairs offsets
// Convert to offsets.
for (i = 0; i < level.numSpawnVars; ++i) {
spawnVarsOffset[i][0] = level.spawnVars[i][0] - level.spawnVarChars;
spawnVarsOffset[i][1] = level.spawnVars[i][1] - level.spawnVarChars;
}
// Early out if spawn is not required.
if (!dmlab_update_spawn_vars(
level.spawnVarChars,
&level.numSpawnVarChars,
spawnVarsOffset,
&level.numSpawnVars)) {
return;
}
// Convert from offsets.
for (i = 0; i < level.numSpawnVars; ++i) {
level.spawnVars[i][0] = level.spawnVarChars + spawnVarsOffset[i][0];
level.spawnVars[i][1] = level.spawnVarChars + spawnVarsOffset[i][1];
}
// get the next free entity
ent = G_Spawn();
for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
G_ParseField( level.spawnVars[i][0], level.spawnVars[i][1], ent );
}
// check for "notsingle" flag
if ( g_gametype.integer == GT_SINGLE_PLAYER ) {
G_SpawnInt( "notsingle", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
// check for "notteam" flag (GT_FFA, GT_TOURNAMENT, GT_SINGLE_PLAYER)
if ( g_gametype.integer >= GT_TEAM ) {
G_SpawnInt( "notteam", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
} else {
G_SpawnInt( "notfree", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
#ifdef MISSIONPACK
G_SpawnInt( "notta", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
#else
G_SpawnInt( "notq3a", "0", &i );
if ( i ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
#endif
if( G_SpawnString( "gametype", NULL, &value ) ) {
if( g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE ) {
gametypeName = gametypeNames[g_gametype.integer];
s = strstr( value, gametypeName );
if( !s ) {
ADJUST_AREAPORTAL();
G_FreeEntity( ent );
return;
}
}
}
// move editor origin to pos
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
// if we didn't get a classname, don't bother spawning anything
if ( !G_CallSpawn( ent ) ) {
G_FreeEntity( ent );
}
}
