/*
============
G_SpawnItem
Sets the clipping size and plants the object on the floor.
Items can't be immediately dropped to floor, because they might
be on an entity that hasn't spawned yet.
============
*/
void G_SpawnItem (gentity_t *ent, gitem_t *item) {
char *noise;
G_SpawnFloat( "random", "0", &ent->random );
G_SpawnFloat( "wait", "0", &ent->wait );
ent->item = item;
// some movers spawn on the second frame, so delay item
// spawns until the third frame so they can ride trains
ent->nextthink = level.time + FRAMETIME * 2;
ent->think = FinishSpawningItem;
if(G_SpawnString("noise", 0, &noise))
ent->noise_index = G_SoundIndex(noise);
ent->physicsBounce = 0.50; // items are bouncy
if(ent->model) {
ent->s.modelindex2 = G_ModelIndex(ent->model);
}
if ( item->giType == IT_TEAM ) {
G_SpawnInt( "count", "1", &ent->s.density );
G_SpawnInt( "speedscale", "100", &ent->splashDamage );
if( !ent->splashDamage ) {
ent->splashDamage = 100;
}
}
}
//----------------------------------------------------------
void SP_CreatePuffSystem( gentity_t *ent )
{
char temp[128];
// Initialize the puff system to either 1000 particles or whatever they choose.
G_SpawnInt( "count", "1000", &ent->count );
cvar_t *r_weatherScale = gi.cvar( "r_weatherScale", "1", CVAR_ARCHIVE );
// See which puff system to use.
int iPuffSystem = 0;
int iVal = 0;
if ( G_SpawnInt( "whichsystem", "0", &iVal ) )
{
iPuffSystem = iVal;
if ( iPuffSystem < 0 || iPuffSystem > 1 )
{
iPuffSystem = 0;
//ri.Error( ERR_DROP, "Weather Effect: Invalid value for whichsystem key" );
Com_Printf( "Weather Effect: Invalid value for whichsystem key\n" );
}
}
if ( r_weatherScale->value > 0.0f )
{
sprintf( temp, "puff%i init %i", iPuffSystem, (int)( ent->count * r_weatherScale->value ));
G_FindConfigstringIndex( temp, CS_WORLD_FX, MAX_WORLD_FX, qtrue );
// Should return here??? It didn't originally...
}
// See whether we should have the saber spark from the puff system.
iVal = 0;
G_SpawnInt( "sabersparks", "0", &iVal );
if ( iVal == 1 )
level.worldFlags |= WF_PUFFING;
else
level.worldFlags &= ~WF_PUFFING;
// Go through all the fields and assign the values to the created puff system now.
for ( int i = 0; i < 20; i++ )
{
char *key = NULL;
char *value = NULL;
// Fetch a field.
if ( !G_SpawnField( i, &key, &value ) )
continue;
// Make sure we don't get key's that are worthless.
if ( Q_stricmp( key, "origin" ) == 0 || Q_stricmp( key, "classname" ) == 0 ||
Q_stricmp( key, "count" ) == 0 || Q_stricmp( key, "targetname" ) == 0 ||
Q_stricmp( key, "sabersparks" ) == 0 || Q_stricmp( key, "whichsystem" ) == 0 )
continue;
// Send the command.
_snprintf( temp, 128, "puff%i %s %s", iPuffSystem, key, value );
G_FindConfigstringIndex( temp, CS_WORLD_FX, MAX_WORLD_FX, qtrue );
}
}
void SP_trigger_stage( gentity_t *self )
{
G_SpawnInt( "team", "0", (int *)&self->stageTeam );
G_SpawnInt( "stage", "0", (int *)&self->stageStage );
self->use = trigger_stage_use;
self->r.svFlags = SVF_NOCLIENT;
}
/*
===================
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 );
}
}
/*QUAKED info_player_deathmatch (1 0 1) (-16 -16 -24) (16 16 32) initial
potential spawning position for deathmatch games.
The first time a player enters the game, they will be at an 'initial' spot.
Targets will be fired when someone spawns in on them.
"nobots" will prevent bots from using this spot.
"nohumans" will prevent non-bots from using this spot.
*/
void SP_info_player_deathmatch( gentity_t *ent ) {
int i;
G_SpawnInt( "nobots", "0", &i);
if ( i ) {
ent->flags |= FL_NO_BOTS;
}
G_SpawnInt( "nohumans", "0", &i );
if ( i ) {
ent->flags |= FL_NO_HUMANS;
}
}
//-----------------------------------------------------
void SP_misc_turretG2( gentity_t *base )
//-----------------------------------------------------
{
int customscaleVal;
char* s;
turretG2_set_models( base, qfalse );
G_SpawnInt("painwait", "0", &base->genericValue4);
base->genericValue8 = 0;
G_SpawnInt("customscale", "0", &customscaleVal);
base->s.iModelScale = customscaleVal;
if (base->s.iModelScale)
{
if (base->s.iModelScale > 1023)
{
base->s.iModelScale = 1023;
}
base->modelScale[0] = base->modelScale[1] = base->modelScale[2] = base->s.iModelScale/100.0f;
}
G_SpawnString( "icon", "", &s );
if (s && s[0])
{
// We have an icon, so index it now. We are reusing the genericenemyindex
// variable rather than adding a new one to the entity state.
base->s.genericenemyindex = G_IconIndex(s);
}
finish_spawning_turretG2( base );
if (( base->spawnflags & 1 )) // Start_Off
{
base->s.frame = 1; // black
}
else
{
base->s.frame = 0; // glow
}
if ( !(base->spawnflags&SPF_TURRETG2_TURBO) )
{
base->s.eFlags |= EF_SHADER_ANIM;
}
if (base->spawnflags & SPF_SHOWONRADAR)
{
base->s.eFlags |= EF_RADAROBJECT;
}
#undef name
#undef name2
#undef name3
}
/*QUAKED trigger_multiple (.1 .5 .1) ? CLIENTONLY FACING USE_BUTTON FIRE_BUTTON NPCONLY x x INACTIVE MULTIPLE
CLIENTONLY - only a player can trigger this by touch
FACING - Won't fire unless triggering ent's view angles are within 45 degrees of trigger's angles (in addition to any other conditions)
USE_BUTTON - Won't fire unless player is in it and pressing use button (in addition to any other conditions)
FIRE_BUTTON - Won't fire unless player/NPC is in it and pressing fire button (in addition to any other conditions)
NPCONLY - only non-player NPCs can trigger this by touch
INACTIVE - Start off, has to be activated to be touchable/usable
MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0
"wait" Seconds between triggerings, 0 default, number < 0 means one time only.
"random" wait variance, default is 0
"delay" how many seconds to wait to fire targets after tripped
"hiderange" As long as NPC's head is in this trigger, NPCs out of this hiderange cannot see him. If you set an angle on the trigger, they're only hidden from enemies looking in that direction. the player's crouch viewheight is 36, his standing viewheight is 54. So a trigger thast should hide you when crouched but not standing should be 48 tall.
"target2" The trigger will fire this only when the trigger has been activated and subsequently 'cleared'( once any of the conditions on the trigger have not been satisfied). This will not fire the "target" more than once until the "target2" is fired (trigger field is 'cleared')
"speed" How many seconds to wait to fire the target2, default is 1
"noise" Sound to play when the trigger fires (plays at activator's origin)
"NPC_targetname" Only the NPC with this NPC_targetname fires this trigger
Variable sized repeatable trigger. Must be targeted at one or more entities.
so, the basic time between firing is a random time between
(wait - random) and (wait + random)
"team" - If set, only this team can trip this trigger
0 - any
1 - red
2 - blue
"soundSet" Ambient sound set to play when this trigger is activated
usetime - If specified (in milliseconds) along with the USE_BUTTON flag, will
require a client to hold the use key for x amount of ms before firing.
Applicable only during Siege gametype:
teamuser - if 1, team 2 can't use this. If 2, team 1 can't use this.
siegetrig - if non-0, can only be activated by players carrying a misc_siege_item
which is associated with this trigger by the item's goaltarget value.
teambalance - if non-0, is "owned" by the last team that activated. Can only be activated
by the other team if the number of players on the other team inside the
trigger outnumber the number of players on the owning team inside the
trigger.
target3 - fire when activated by team1
target4 - fire when activated by team2
idealclass - Can only be used by this class/these classes. You can specify use by
multiple classes with the use of |, e.g.:
"Imperial Medic|Imperial Assassin|Imperial Demolitionist"
*/
void SP_trigger_multiple( gentity_t *ent )
{
char *s;
if ( G_SpawnString( "noise", "", &s ) )
{
if (s && s[0])
{
ent->noise_index = G_SoundIndex(s);
}
else
{
ent->noise_index = 0;
}
}
G_SpawnInt("usetime", "0", &ent->genericValue7);
//For siege gametype
G_SpawnInt("siegetrig", "0", &ent->genericValue1);
G_SpawnInt("teambalance", "0", &ent->genericValue2);
G_SpawnInt("delay", "0", &ent->delay);
if ( (ent->wait > 0) && (ent->random >= ent->wait) ) {
ent->random = ent->wait - FRAMETIME;
Com_Printf(S_COLOR_YELLOW"trigger_multiple has random >= wait\n");
}
ent->delay *= 1000;//1 = 1 msec, 1000 = 1 sec
if ( !ent->speed && ent->target2 && ent->target2[0] )
{
ent->speed = 1000;
}
else
{
ent->speed *= 1000;
}
ent->touch = Touch_Multi;
ent->use = Use_Multi;
if ( ent->team && ent->team[0] )
{
ent->alliedTeam = atoi(ent->team);
ent->team = NULL;
}
InitTrigger( ent );
trap->LinkEntity((sharedEntity_t *)ent);
}
void SP_rail_lane(gentity_t *ent)
{
gi.SetBrushModel(ent, ent->model);
G_SpawnInt("delay", "0", &ent->delay);
mRailLanes.push_back().Setup(ent);
G_FreeEntity(ent);
}
/*
===============
SP_trigger_heal
===============
*/
void SP_trigger_heal( gentity_t *self )
{
G_SpawnInt( "heal", "5", &self->damage );
if ( self->damage <= 0 )
{
self->damage = 1;
G_Printf( S_COLOR_YELLOW "WARNING: trigger_heal with negative damage key\n" );
}
self->touch = trigger_heal_touch;
self->use = trigger_heal_use;
InitTrigger( self );
// link in to the world if starting active
if ( self->spawnflags & 1 )
{
trap_UnlinkEntity( self );
}
else
{
trap_LinkEntity( self );
}
}
void SP_gfx_light_flare( gentity_t *self )
{
self->s.eType = ET_LIGHTFLARE;
self->s.modelindex = G_ShaderIndex( self->shaderKey );
VectorCopy( self->activatedPosition, self->s.origin2 );
//try to find a spot near to the flare which is empty. This
//is used to facilitate visibility testing
findEmptySpot( self->s.origin, 8.0f, self->s.angles2 );
self->act = gfx_light_flare_toggle;
if( !self->config.speed )
self->config.speed = 200;
self->s.time = self->config.speed;
G_SpawnInt( "mindist", "0", &self->s.generic1 );
if ( self->spawnflags & SPF_SPAWN_DISABLED )
{
self->s.eFlags |= EF_NODRAW;
}
trap_LinkEntity( self );
}
/*QUAKED script_mover (0.5 0.25 1.0) ? TRIGGERSPAWN SOLID EXPLOSIVEDAMAGEONLY
Scripted brush entity. A simplified means of moving brushes around based on events.
"modelscale" - Scale multiplier (defaults to 1, and scales uniformly)
"modelscale_vec" - Set scale per-axis. Overrides "modelscale", so if you have both the "modelscale" is ignored
"model2" optional md3 to draw over the solid clip brush
"scriptname" name used for scripting purposes (like aiName in AI scripting)
"health" optionally make this entity damagable
*/
void SP_script_mover( gentity_t *ent ) {
float scale[3] = {1,1,1};
vec3_t scalevec;
if ( !ent->model ) {
G_Error( "script_model_med must have a \"model\"\n" );
}
if ( !ent->scriptName ) {
G_Error( "script_model_med must have a \"scriptname\"\n" );
}
ent->blocked = script_mover_blocked;
// first position at start
VectorCopy( ent->s.origin, ent->pos1 );
// VectorCopy( ent->r.currentOrigin, ent->pos1 );
VectorCopy( ent->pos1, ent->pos2 ); // don't go anywhere just yet
trap_SetBrushModel( ent, ent->model );
InitMover( ent );
ent->reached = NULL;
if ( ent->spawnflags & 1 ) {
ent->use = script_mover_use;
trap_UnlinkEntity( ent ); // make sure it's not visible
return;
}
G_SetAngle( ent, ent->s.angles );
G_SpawnInt( "health", "0", &ent->health );
if ( ent->health ) {
ent->takedamage = qtrue;
}
ent->die = script_mover_die;
ent->pain = script_mover_pain;
// look for general scaling
if ( G_SpawnFloat( "modelscale", "1", &scale[0] ) ) {
scale[2] = scale[1] = scale[0];
}
// look for axis specific scaling
if ( G_SpawnVector( "modelscale_vec", "1 1 1", &scalevec[0] ) ) {
VectorCopy( scalevec, scale );
}
if ( scale[0] != 1 || scale[1] != 1 || scale[2] != 1 ) {
// ent->s.eType = ET_MOVERSCALED;
ent->s.density = ET_MOVERSCALED;
// scale is stored in 'angles2'
VectorCopy( scale, ent->s.angles2 );
}
script_mover_spawn( ent );
}
/*
================
EnergyShieldStationSettings
================
*/
void EnergyShieldStationSettings(gentity_t *ent)
{
G_SpawnInt( "count", "0", &ent->count );
if (!ent->count)
{
ent->count = 50;
}
G_SpawnInt("chargerate", "0", &ent->bolt_Head);
if (!ent->bolt_Head)
{
ent->bolt_Head = STATION_RECHARGE_TIME;
}
}
/*
===================
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 );
}
void SP_misc_beam(gentity_t *self)
{
char *str;
G_SpawnString("target2", "", &str);
if (*str)
{
self->message = G_NewString(str);
}
G_SpawnString("shader", "lightningBolt", &str);
if (*str)
{
self->s.modelindex2 = G_ShaderIndex(str);
}
G_SpawnInt("scale", "1", &self->s.torsoAnim);
G_SpawnVector("color", "1 1 1", self->s.angles2);
// let everything else get spawned before we start firing
self->accuracy = 0;
self->think = misc_beam_start;
self->nextthink = level.time + FRAMETIME;
}
/*QUAKED target_fog (1 1 0) (-8 -8 -8) (8 8 8)
color picker chooses color of fog
"distance" sets fog distance. Use value '0' to give control back to the game (and use the fog values specified in the sky shader if present)
"time" time it takes to change fog to new value. default time is 1 sec
*/
void SP_target_fog(gentity_t *ent)
{
int dist;
float ftime;
ent->use = Use_target_fog;
// ent->s.density will carry the 'distance' value
if (G_SpawnInt("distance", "0", &dist))
{
if (dist >= 0)
{
ent->s.density = dist;
}
}
// ent->s.time will carry the 'time' value
if (G_SpawnFloat("time", "0.5", &ftime))
{
if (ftime >= 0)
{
ent->s.time = ftime * 1000; // sec to ms
}
}
}
/*QUAKED func_pendulum (0 .5 .8) ?
You need to have an origin brush as part of this entity.
Pendulums always swing north / south on unrotated models. Add an angles field to the model to allow rotation in other directions.
Pendulum frequency is a physical constant based on the length of the beam and gravity.
"model2" .md3 model to also draw
"speed" the number of degrees each way the pendulum swings, (30 default)
"phase" the 0.0 to 1.0 offset in the cycle to start at
"dmg" damage to inflict when blocked (2 default)
"color" constantLight color
"light" constantLight radius
*/
void SP_func_pendulum(gentity_t *ent) {
float freq;
float length;
float phase;
float speed;
G_SpawnFloat( "speed", "30", &speed );
G_SpawnInt( "dmg", "2", &ent->damage );
G_SpawnFloat( "phase", "0", &phase );
trap_SetBrushModel( ent, ent->model );
// find pendulum length
length = fabs( ent->r.mins[2] );
if ( length < 8 ) {
length = 8;
}
freq = 1 / ( M_PI * 2 ) * sqrt( g_gravity.value / ( 3 * length ) );
ent->s.pos.trDuration = ( 1000 / freq );
InitMover( ent );
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
VectorCopy( ent->s.angles, ent->s.apos.trBase );
ent->s.apos.trDuration = 1000 / freq;
ent->s.apos.trTime = ent->s.apos.trDuration * phase;
ent->s.apos.trType = TR_SINE;
ent->s.apos.trDelta[2] = speed;
}
void SP_trigger_entdist( gentity_t *self )
{
G_SpawnInt( "distance", "0", &self->count);
self->e_UseFunc = useF_trigger_entdist_use;
}
void SP_target_stoptimer(gentity_t *ent) {
char *t = NULL;
// Nico, used to look for parent
gentity_t *parent = NULL;
// Nico, override wait -1 or wait 9999 on stop timer entities
if (g_forceTimerReset.integer) {
parent = G_FindByTarget(NULL, ent->targetname);
if (parent && parent->wait != 0.5 && !Q_stricmp(parent->classname, "trigger_multiple")) {
G_DPrintf("%s: SP_target_stoptimer, wait found = %f, overrided to 0.5\n", GAME_VERSION, parent->wait);
G_SpawnFloat("wait", "0.5", &parent->wait);
}
}
G_SpawnString("name", "default", &t);
ent->timerunName = G_NewString(t);
// create a timerun with this name if it doesn't exit yet
GetTimerunNum(ent->timerunName);
G_SpawnInt("mincheckpoints", "0", &ent->count);
ent->use = target_stoptimer_use;
level.isTimerun = qtrue;
}
/*QUAKED func_bobbing (0 .5 .8) ? X_AXIS Y_AXIS
Normally bobs on the Z axis
"model2" .md3 model to also draw
"height" amplitude of bob (32 default)
"speed" seconds to complete a bob cycle (4 default)
"phase" the 0.0 to 1.0 offset in the cycle to start at
"dmg" damage to inflict when blocked (2 default)
"color" constantLight color
"light" constantLight radius
*/
void SP_func_bobbing (gentity_t *ent) {
float height;
float phase;
G_SpawnFloat( "speed", "4", &ent->speed );
G_SpawnFloat( "height", "32", &height );
G_SpawnInt( "dmg", "2", &ent->damage );
G_SpawnFloat( "phase", "0", &phase );
trap_SetBrushModel( ent, ent->model );
InitMover( ent );
VectorCopy( ent->s.origin, ent->s.pos.trBase );
VectorCopy( ent->s.origin, ent->r.currentOrigin );
ent->s.pos.trDuration = ent->speed * 1000;
ent->s.pos.trTime = ent->s.pos.trDuration * phase;
ent->s.pos.trType = TR_SINE;
// set the axis of bobbing
if ( ent->spawnflags & 1 ) {
ent->s.pos.trDelta[0] = height;
} else if ( ent->spawnflags & 2 ) {
ent->s.pos.trDelta[1] = height;
} else {
ent->s.pos.trDelta[2] = height;
}
}
/*
============
G_SpawnItem
Sets the clipping size and plants the object on the floor.
Items can't be immediately dropped to floor, because they might
be on an entity that hasn't spawned yet.
============
*/
void G_SpawnItem( gentity_t *ent, gitem_t *item ) {
char *noise;
int page;
G_SpawnFloat( "random", "0", &ent->random );
G_SpawnFloat( "wait", "0", &ent->wait );
RegisterItem( item );
ent->item = item;
// some movers spawn on the second frame, so delay item
// spawns until the third frame so they can ride trains
ent->nextthink = level.time + FRAMETIME * 2;
ent->think = FinishSpawningItem;
if ( G_SpawnString( "noise", 0, &noise ) ) {
ent->noise_index = G_SoundIndex( noise );
}
ent->physicsBounce = 0.50; // items are bouncy
if ( ent->model ) {
ent->s.modelindex2 = G_ModelIndex( ent->model );
}
if ( item->giType == IT_CLIPBOARD ) {
if ( G_SpawnInt( "notebookpage", "1", &page ) ) {
ent->key = page;
}
}
if ( item->giType == IT_POWERUP ) {
G_SoundIndex( "sound/items/poweruprespawn.wav" );
}
}
/*QUAKED target_fog (1 1 0) (-8 -8 -8) (8 8 8)
color picker chooses color of fog
"distance" sets fog distance. Use value '0' to give control back to the game (and use the fog values specified in the sky shader if present)
distance value sets the type of fog. values > 1 are distance fog (ex. 2048), values < 1 are density fog (ex. .0002)
"near" is fog start distance when using distance fog
"time" time it takes to change fog to new value. default time is 1 sec
*/
void SP_target_fog(gentity_t *ent)
{
int dist;
float startdist;
float ftime;
ent->use = Use_target_fog;
// ent->random will carry the 'far' or density value
G_SpawnInt("distance", "0", &dist);
if(dist >= 0)
{
ent->random = dist;
}
G_SpawnFloat("near", "1.0", &startdist);
ent->accuracy = startdist;
// ent->s.time will carry the 'time' value
G_SpawnFloat("time", "0.5", &ftime);
if(ftime >= 0)
{
ent->s.time = ftime * 1000; // sec to ms
}
}
/*
===================
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 );
}
}
/*
================
AICast_DelayedSpawnCast
================
*/
void AICast_DelayedSpawnCast( gentity_t *ent, int castType )
{
// ............................
// head separation
if(!ent->aiSkin)
G_SpawnString( "skin", "", &ent->aiSkin);
if(!ent->aihSkin)
G_SpawnString( "head", "default", &ent->aihSkin);
G_SpawnInt( "aiteam", "-1", &ent->aiTeam);
// ............................
// we have to wait a bit before spawning it, otherwise the server will just delete it, since it's treated like a client
ent->think = AIChar_spawn;
ent->nextthink = level.time + FRAMETIME*4; // have to wait more than 3 frames, since the server runs 3 frames before it clears all clients
// we don't really want to start this character right away, but if we don't spawn the client
// now, if the game gets saved after the character spawns in, when it gets re-loaded, the client
// won't get spawned properly.
if (ent->spawnflags & 1) // TriggerSpawn
{
ent->AIScript_AlertEntity = AIChar_AIScript_AlertEntity;
ent->aiInactive = qtrue;
}
// RF, had to move this down since some dev maps don't properly spawn the guys in, so we
// get a crash when transitioning between levels after they all spawn at once (overloading
// the client/server command buffers)
ent->nextthink += FRAMETIME * ((numSpawningCast+1) / 3); // space them out a bit so we don't overflow the client
ent->aiCharacter = castType;
numSpawningCast++;
}
/*QUAKED target_fx (0 0 1) (-8 -8 -8) (8 8 8)
*/
void SP_target_fx(gentity_t * self)
{
char *effectName;
int startOn = 0;
self->s.eType = ET_INVISIBLE;
G_SpawnFloat("wait", "0.5", &self->wait);
G_SpawnFloat("random", "0", &self->random);
G_SpawnInt("start_on", "0", &startOn);
if(!startOn)
self->s.eFlags |= EF_NODRAW;
G_SpawnString("luaThink", "", &effectName);
self->s.modelindex = G_EffectIndex(effectName);
G_SetOrigin(self, self->s.origin);
// save angles
VectorCopy(self->s.angles, self->s.apos.trBase);
self->s.apos.trType = TR_STATIONARY;
self->s.apos.trTime = 0;
self->s.apos.trDuration = 0;
VectorClear(self->s.apos.trDelta);
//VectorCopy(origin, ent->r.currentAOrigin);
VectorClear(self->r.mins);
VectorClear(self->r.maxs);
trap_LinkEntity(self);
self->think = target_fx_think;
self->nextthink = level.time + 1000;
}
void SP_pos_location( gentity_t *self )
{
char *message;
self->s.eType = entityType_t::ET_LOCATION;
self->r.svFlags = SVF_BROADCAST;
trap_LinkEntity( self ); // make the server send them to the clients
if ( G_SpawnInt( "count", "", &self->customNumber) )
{
if ( self->customNumber < 0 )
{
self->customNumber = 0;
}
if ( self->customNumber > 7 )
{
self->customNumber = 7;
}
message = va( "%c%c%s^7", Color::Constants::ESCAPE, self->customNumber + '0',
self->message );
}
else
{
message = self->message;
}
self->nextPathSegment = level.locationHead;
self->s.generic1 = G_LocationIndex(message);
level.locationHead = self;
G_SetOrigin( self, self->s.origin );
}
/*
===================
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;
}
void SP_rail_track(gentity_t *ent)
{
gi.SetBrushModel(ent, ent->model);
G_SpawnInt("delay", "0", &ent->delay);
mRailTracks.push_back().Setup(ent);
G_FreeEntity(ent);
mRailSystemActive = true;
}
void SP_trigger_win( gentity_t *self )
{
G_SpawnInt( "team", "0", (int *)&self->stageTeam );
self->use = trigger_win;
self->r.svFlags = SVF_NOCLIENT;
}
/*
=======================================================================================================================================
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);
}
}
void SP_func_usable( gentity_t *self )
{
gi.SetBrushModel( self, self->model );
InitMover( self );
VectorCopy( self->s.origin, self->s.pos.trBase );
VectorCopy( self->s.origin, self->currentOrigin );
VectorCopy( self->s.origin, self->pos1 );
self->count = 1;
if (self->spawnflags & 1)
{
self->spawnContents = self->contents; // It Navs can temporarly turn it "on"
self->s.solid = 0;
self->contents = 0;
self->clipmask = 0;
self->svFlags |= SVF_NOCLIENT;
self->s.eFlags |= EF_NODRAW;
self->count = 0;
}
if (self->spawnflags & 2)
{
self->s.eFlags |= EF_ANIM_ALLFAST;
}
if (self->spawnflags & 4)
{//FIXME: need to be able to do change to something when it's done? Or not be usable until it's done?
self->s.eFlags |= EF_ANIM_ONCE;
}
self->e_UseFunc = useF_func_usable_use;
if ( self->health )
{
self->takedamage = qtrue;
self->e_DieFunc = dieF_func_usable_die;
self->e_PainFunc = painF_func_usable_pain;
}
if ( self->endFrame > 0 )
{
self->s.frame = self->startFrame = 0;
self->s.eFlags |= EF_SHADER_ANIM;
}
gi.linkentity (self);
int forceVisible = 0;
G_SpawnInt( "forcevisible", "0", &forceVisible );
if ( forceVisible )
{//can see these through walls with force sight, so must be broadcast
if ( VectorCompare( self->s.origin, vec3_origin ) )
{//no origin brush
self->svFlags |= SVF_BROADCAST;
}
self->s.eFlags |= EF_FORCE_VISIBLE;
}
}
