/* =================== 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 ); } G_SpawnInt( "notep", "0", &i ); if ( i ) { 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 ); } }
void UserSpawn( gentity_t *ent, const char *name ) { vec3_t origin; vec3_t vf; vec3_t angles; gentity_t *ent2; //Spawn the ent ent2 = G_Spawn(); ent2->classname = G_NewString( name ); //FIXME: This will leave floating memory... //TODO: This should ultimately make sure this is a safe spawn! //Spawn the entity and place it there VectorSet( angles, 0, ent->s.apos.trBase[YAW], 0 ); AngleVectors( angles, vf, NULL, NULL ); VectorMA( ent->s.pos.trBase, 96, vf, origin ); //FIXME: Find the radius size of the object, and push out 32 + radius origin[2] += 8; VectorCopy( origin, ent2->s.pos.trBase ); VectorCopy( origin, ent2->s.origin ); VectorCopy( ent->s.apos.trBase, ent2->s.angles ); gi.linkentity( ent2 ); //Find a valid spawning spot if ( G_CallSpawn( ent2 ) == qfalse ) { gi.SendServerCommand( ent-g_entities, "print \"Failed to spawn '%s'\n\"", name ); G_FreeEntity( ent2 ); 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; 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 ( ( ( int ) ent->s.v.spawnflags & SPAWNFLAG_NOT_DEATHMATCH ) ) { ent_remove( ent ); return; } // if we didn't get a classname, don't bother spawning anything if ( !G_CallSpawn( ent ) ) { ent_remove( ent ); return; } // if(!ent->s.v.classname)ent->s.v.classname=""; }
/* =================== 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; bgEntitySpawnInfo_t spawnInfo; // 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 ); } spawnInfo.gametype = g_gametype.integer; spawnInfo.spawnInt = G_SpawnInt; spawnInfo.spawnString = G_SpawnString; // check "notsingle", "notfree", "notteam", etc if ( !BG_CheckSpawnEntity( &spawnInfo ) ) { 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( 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 ); G_SpawnInt( "notq3a", "0", &i ); if( i ) { 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 =================== */ gentity_t *G_SpawnGEntityFromSpawnVars(void) { int i; gentity_t *ent = G_Spawn(); // get the next free entity char *str; 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 NULL; } // 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); } return 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", "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_DUEL, 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; } } 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->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 ); } }
void SpawnCTFItem( char* classname, float x, float y, float z, float angle ) { gedict_t *item = spawn(); item->s.v.classname = classname; setorigin( item, x, y, z ); item->s.v.angles[0] = 0; item->s.v.angles[1] = angle; G_CallSpawn( item ); }
/* =============== AICast_DBG_Spawn_f =============== */ void AICast_DBG_Spawn_f( gclient_t *client, char *cmd ) { extern qboolean G_CallSpawn( gentity_t *ent ); gentity_t *ent; vec3_t dir; ent = G_Spawn(); ent->classname = G_Alloc( strlen( cmd ) + 1 ); strcpy( ent->classname, cmd ); AngleVectors( client->ps.viewangles, dir, NULL, NULL ); VectorMA( client->ps.origin, 96, dir, ent->s.origin ); if ( !G_CallSpawn( ent ) ) { G_Printf( "Error: unable to spawn \"%s\" entity\n", cmd ); } }
static void use_target_spawner( edict_t *self, edict_t *other, edict_t *activator ) { edict_t *ent; ent = G_Spawn(); ent->classname = self->target; VectorCopy( self->s.origin, ent->s.origin ); VectorCopy( self->s.angles, ent->s.angles ); G_CallSpawn( ent ); GClip_UnlinkEntity( ent ); KillBox( ent ); GClip_LinkEntity( ent ); if( self->speed ) VectorCopy( self->moveinfo.movedir, ent->velocity ); }
/* ======================================================================================================================================= 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); } }
/* =================== 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", "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 ); } }
/* =================== 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 ); } }
// Spawn an entity and fill in all of the level fields from level.spawnVars[], then call the class specfic spawn function gentity_t *G_SpawnGEntityFromSpawnVars( qboolean inSubBSP ) { int i; gentity_t *ent; char *s, *value; const char *gametypeName; static const 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++ ) { BG_ParseField( fields, ARRAY_LEN( fields ), level.spawnVars[i][0], level.spawnVars[i][1], (byte *)ent ); } // check for "notsingle" flag if ( level.gametype == GT_SINGLE_PLAYER ) { G_SpawnInt( "notsingle", "0", &i ); if ( i ) { G_FreeEntity( ent ); return NULL; } } // check for "notteam" flag (GT_FFA, GT_DUEL, GT_SINGLE_PLAYER) if ( level.gametype >= GT_TEAM ) { G_SpawnInt( "notteam", "0", &i ); if ( i ) { G_FreeEntity( ent ); return NULL; } } else { G_SpawnInt( "notfree", "0", &i ); if ( i ) { G_FreeEntity( ent ); return NULL; } } G_SpawnInt( "notta", "0", &i ); if ( i ) { G_FreeEntity( ent ); return NULL; } if ( G_SpawnString( "gametype", NULL, &value ) ) { if ( level.gametype >= GT_FFA && level.gametype < GT_MAX_GAME_TYPE ) { gametypeName = gametypeNames[level.gametype]; s = strstr( value, gametypeName ); if ( !s ) { G_FreeEntity( ent ); return NULL; } } } // 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 ); return NULL; } //Tag on the ICARUS scripting information only to valid recipients if ( trap->ICARUS_ValidEnt( (sharedEntity_t *)ent ) ) { trap->ICARUS_InitEnt( (sharedEntity_t *)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 ); } } } if ( level.manualSpawning ) { ent->jpSpawned = qtrue; } return 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; // 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() { 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(); } }
// For Maker Mod objects // combine the two sets of spawnVars. newVars overwrite spawnVars // we end up with level.spawnVars setup with our final values, the values applied to our ent, // and the appropriate spawn function executed. void G_ApplySpawnVars( gentity_t *ent, char *spawnVars, char *newVars ) { int i; char *token; //static char *gametypeNames[] = {"ffa", "holocron", "jedimaster", "duel", "powerduel", "single", "team", "siege", "ctf", "cty"}; char* p; char field[MAX_FIELDNAME_LENGTH + 1]; level.numSpawnVars = 0; level.numSpawnVarChars = 0; level.spawnVarChars[0] = '/0'; p = spawnVars; while ( p ) { token = ParseExt( &p, qfalse ); // TODO : make sure it's safe to use this function if ( token[0] == 0 ) break; strncpy( field, token, MAX_FIELDNAME_LENGTH ); token = ParseExt( &p, qfalse ); if ( token[0] == 0 ) break; AddSpawnField( field, token ); } p = newVars; while ( p ) { token = ParseExt( &p, qfalse ); // TODO : make sure it's safe to use this function if ( token[0] == 0 ) break; strncpy( field, token, MAX_FIELDNAME_LENGTH ); token = ParseExt( &p, qfalse ); if ( token[0] == 0 ) break; AddSpawnField( field, token ); } for ( i = 0 ; i < level.numSpawnVars ; i++ ) { BG_ParseField( fields, level.spawnVars[i][0], level.spawnVars[i][1], (byte *)ent ); } // 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 ); } } } }
/* * SpawnEntities * * Creates a server's entity / program execution context by * parsing textual entity definitions out of an ent file. */ void G_InitLevel( char *mapname, char *entities, int entstrlen, unsigned int levelTime, unsigned int serverTime, unsigned int realTime ) { char *mapString = NULL; char name[MAX_CONFIGSTRING_CHARS]; int i; edict_t *ent; char *token; const gsitem_t *item; G_asGarbageCollect( true ); GT_asCallShutdown(); G_asCallMapExit(); G_asShutdownMapScript(); GT_asShutdownScript(); G_FreeCallvotes(); game.serverTime = serverTime; game.realtime = realTime; game.levelSpawnCount++; GClip_ClearWorld(); // clear areas links if( !entities ) G_Error( "G_SpawnLevel: NULL entities string\n" ); // make a copy of the raw entities string so it's not freed with the pool mapString = ( char * )G_Malloc( entstrlen + 1 ); memcpy( mapString, entities, entstrlen ); Q_strncpyz( name, mapname, sizeof( name ) ); // clear old data G_LevelInitPool( strlen( mapname ) + 1 + ( entstrlen + 1 ) * 2 + G_LEVELPOOL_BASE_SIZE ); G_StringPoolInit(); memset( &level, 0, sizeof( level_locals_t ) ); memset( &gs.gameState, 0, sizeof( gs.gameState ) ); level.spawnedTimeStamp = game.realtime; level.time = levelTime; level.gravity = g_gravity->value; // get the strings back Q_strncpyz( level.mapname, name, sizeof( level.mapname ) ); level.mapString = ( char * )G_LevelMalloc( entstrlen + 1 ); level.mapStrlen = entstrlen; memcpy( level.mapString, mapString, entstrlen ); G_Free( mapString ); mapString = NULL; // make a copy of the raw entities string for parsing level.map_parsed_ents = ( char * )G_LevelMalloc( entstrlen + 1 ); level.map_parsed_ents[0] = 0; if( !level.time ) memset( game.edicts, 0, game.maxentities * sizeof( game.edicts[0] ) ); else { G_FreeEdict( world ); for( i = gs.maxclients + 1; i < game.maxentities; i++ ) { if( game.edicts[i].r.inuse ) G_FreeEdict( game.edicts + i ); } } game.numentities = gs.maxclients + 1; // link client fields on player ents for( i = 0; i < gs.maxclients; i++ ) { game.edicts[i+1].s.number = i+1; game.edicts[i+1].r.client = &game.clients[i]; game.edicts[i+1].r.inuse = ( trap_GetClientState( i ) >= CS_CONNECTED ) ? true : false; memset( &game.clients[i].level, 0, sizeof( game.clients[0].level ) ); game.clients[i].level.timeStamp = level.time; } // initialize game subsystems trap_ConfigString( CS_MAPNAME, level.mapname ); trap_ConfigString( CS_SKYBOX, "" ); trap_ConfigString( CS_AUDIOTRACK, "" ); trap_ConfigString( CS_STATNUMS, va( "%i %i %i", STAT_SCORE, STAT_HEALTH, STAT_LAST_KILLER ) ); trap_ConfigString( CS_POWERUPEFFECTS, va( "%i %i %i %i", EF_QUAD, EF_SHELL, EF_CARRIER, EF_REGEN ) ); trap_ConfigString( CS_SCB_PLAYERTAB_LAYOUT, "" ); trap_ConfigString( CS_SCB_PLAYERTAB_TITLES, "" ); trap_ConfigString( CS_MATCHNAME, "" ); trap_ConfigString( CS_MATCHSCORE, "" ); // reset map messages for( i = 0; i < MAX_HELPMESSAGES; i++ ) { trap_ConfigString( CS_HELPMESSAGES + i, "" ); } G_InitGameCommands(); G_MapLocations_Init(); G_CallVotes_Init(); G_SpawnQueue_Init(); G_Teams_Init(); // load map script G_asLoadMapScript( level.mapname ); G_Gametype_Init(); // ch : this would be the location to "transfer ratings" G_PrecacheItems(); // set configstrings for items (gametype must be initialized) G_PrecacheMedia(); G_PrecacheGameCommands(); // adding commands after this point won't update them to the client AI_InitLevel(); // load navigation file of the current map // start spawning entities level.canSpawnEntities = true; G_InitBodyQueue(); // reserve some spots for dead player bodies entities = level.mapString; i = 0; ent = NULL; while( 1 ) { level.spawning_entity = NULL; // parse the opening brace token = COM_Parse( &entities ); if( !entities ) break; if( token[0] != '{' ) G_Error( "G_SpawnMapEntities: found %s when expecting {", token ); if( !ent ) { ent = world; G_InitEdict( world ); } else ent = G_Spawn(); ent->spawnString = entities; // keep track of string definition of this entity entities = ED_ParseEdict( entities, ent ); if( !ent->classname ) { i++; // racesow - introducing the freestyle map bug again in // order to make some freestyle maps work if( !level.gametype.freestyleMapFix ) G_FreeEdict( ent ); // !racesow G_FreeEdict( ent ); continue; } if( !G_CanSpawnEntity( ent ) ) { i++; G_FreeEdict( ent ); continue; } if( !G_CallSpawn( ent ) ) { i++; G_FreeEdict( ent ); continue; } // check whether an item is allowed to spawn if( ( item = ent->item ) ) { // not pickable items aren't spawnable if( item->flags & ITFLAG_PICKABLE ) { if( G_Gametype_CanSpawnItem( item ) ) { // override entity's classname with whatever item specifies ent->classname = item->classname; PrecacheItem( item ); continue; } } i++; G_FreeEdict( ent ); continue; } } G_FindTeams(); // is the parsing string sane? assert( (int)level.map_parsed_len < entstrlen ); level.map_parsed_ents[level.map_parsed_len] = 0; // make sure server got the edicts data trap_LocateEntities( game.edicts, sizeof( game.edicts[0] ), game.numentities, game.maxentities ); // items need brush model entities spawned before they are linked G_Items_FinishSpawningItems(); // // initialize game subsystems which require entities initialized // // call gametype specific GT_asCallSpawn(); // call map specific G_asCallMapInit(); AI_InitEntitiesData(); // always start in warmup match state and let the thinking code // revert it to wait state if empty ( so gametype based item masks are setup ) G_Match_LaunchState( MATCH_STATE_WARMUP ); G_asGarbageCollect( true ); // racesow RS_Init(); }
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 if ( level.entCount > (MAX_GENTITIES - g_objectMargin.integer)) { G_Printf("ERROR :Run out of entities\n"); return; } ent = G_Spawn(); for ( i = 0 ; i < level.numSpawnVars ; i++ ) { BG_ParseField( fields, level.spawnVars[i][0], level.spawnVars[i][1], (byte *)ent ); } if ( level.stripping == qtrue ) { // strip out any undesirable object classes. if( Q_stricmpn( "item_", ent->classname, 5 ) == 0 || Q_stricmpn( "trigger_", ent->classname, 8 ) == 0 || Q_stricmpn( "target_", ent->classname, 7 ) == 0 || Q_stricmpn( "NPC_", ent->classname, 4 ) == 0 ) { G_FreeEntity( ent ); return; } } // 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_DUEL, 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; } } G_SpawnInt( "notta", "0", &i ); if ( i ) { 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 ) { 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 ); } } } }