HoldableItem *HoldableItem::createHoldableItem( const str &className, const str &modelName, Sentient *sentient )
{
str fullname;
SpawnArgs args;
ClassDef *cls;
HoldableItem *holdableItem;
fullname = "HoldableItem";
fullname += className;
args.setArg( "classname", fullname.c_str() );
cls = args.getClassDef();
if ( !cls )
return NULL;
if ( !checkInheritance( &HoldableItem::ClassInfo, cls ) )
return NULL;
holdableItem = (HoldableItem *)cls->newInstance();
if ( !holdableItem )
return NULL;
holdableItem->init( modelName, sentient );
return holdableItem;
}
Rune *Rune::CreateRune( const str &className, const str &modelName, Sentient *sentient )
{
str fullname;
SpawnArgs args;
ClassDef *cls;
Rune *rune;
fullname = "Rune";
fullname += className;
args.setArg( "classname", fullname.c_str() );
cls = args.getClassDef();
if ( !cls )
return NULL;
if ( !checkInheritance( &Rune::ClassInfo, cls ) )
return NULL;
rune = (Rune *)cls->newInstance();
if ( !rune )
return NULL;
rune->init( modelName, sentient );
return rune;
}
void Powerup::spawn( const Vector &origin )
{
SpawnArgs args;
Entity *ent;
Item *item;
if ( _timeLeft <= 0.0f )
return;
args.setArg( "model", _modelName );
ent = args.Spawn();
if ( !ent || !ent->isSubclassOf( Item ) )
return;
item = (Item *)ent;
item->setOrigin( origin );
item->ProcessPendingEvents();
item->PlaceItem();
item->setOrigin( origin );
//item->velocity = Vector( G_CRandom( 100.0f ), G_CRandom( 100.0f ), 200.0f + G_Random( 200.0f ) );
item->edict->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
item->_nextPickupTime = level.time + 1.0f;
item->setAmount( (int)( _timeLeft + 1.0f ) );
item->setRespawn( false );
}
Powerup *Powerup::CreatePowerup( const str &className, const str &modelName, Sentient *sentient )
{
str fullname;
SpawnArgs args;
ClassDef *cls;
Powerup *powerup;
fullname = "Powerup";
fullname += className;
args.setArg( "classname", fullname.c_str() );
cls = args.getClassDef();
if ( !cls )
return NULL;
if ( !checkInheritance( &Powerup::ClassInfo, cls ) )
return NULL;
powerup = (Powerup *)cls->newInstance();
if ( !powerup )
return NULL;
powerup->init( modelName, sentient );
return powerup;
}
//--------------------------------------------------------------
//
// Name: G_DropItemCmd
// Class: None
//
// Description: Drops an item that is clicked on from the inventory
//
// Parameters: gentity_t -- the entity issuing the command. This
// is the player who issued the command.
//
// Returns: qboolean -- true if the command was executed.
//
//--------------------------------------------------------------
qboolean G_DropItemCmd( const gentity_t *ent )
{
if ( gi.argc() < 1 ) return false ;
if ( !ent->entity->isSubclassOf( Player ) ) return false ;
Player *player = (Player*)ent->entity ;
str objectName = gi.argv( 1 );
str propertyName = gi.argv( 2 );
GameplayManager *gpm = GameplayManager::getTheGameplayManager();
if ( !gpm ) return false ;
str itemName = gpm->getStringValue( objectName, propertyName );
if ( itemName == "Empty" )
return false;
str tikiName = gpm->getStringValue( itemName, "model" );
str itemType = gpm->getStringValue( itemName, "class" );
str playerItem("CurrentPlayer." + itemType);
if ( !gpm->hasObject(playerItem) )
{
gi.WPrintf( "Warning: Unknown item type %s for item %s", itemType.c_str(), itemName.c_str() );
return false ;
}
// Empty the slot
gpm->setStringValue( objectName, propertyName, "Empty" );
// Give the player the item to drop
//Item *givenItem = player->giveItem(tikiName);
Weapon *dropweap;
ClassDef *cls;
cls = getClass( tikiName.c_str() );
if ( !cls )
{
SpawnArgs args;
args.setArg( "model", tikiName.c_str() );
cls = args.getClassDef();
if ( !cls )
return false;
}
dropweap = ( Weapon * )cls->newInstance();
dropweap->setModel( tikiName.c_str() );
dropweap->ProcessPendingEvents();
dropweap->SetOwner(player);
dropweap->hideModel();
dropweap->setAttached(true);
dropweap->Drop();
return true ;
}
void Rune::spawn( const Vector &origin )
{
SpawnArgs args;
Entity *ent;
Item *item;
args.setArg( "model", _modelName );
ent = args.Spawn();
if ( !ent || !ent->isSubclassOf( Item ) )
return;
item = (Item *)ent;
item->setOrigin( origin );
item->ProcessPendingEvents();
item->PlaceItem();
item->setOrigin( origin );
//item->velocity = Vector( G_CRandom( 100.0f ), G_CRandom( 100.0f ), 200.0f + G_Random( 200.0f ) );
item->edict->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
item->_nextPickupTime = level.time + 1.0f;
item->animate->RandomAnimate( "idle" );
if ( item->isSubclassOf( Rune ) )
{
Rune *rune = (Rune *)item;
rune->setOriginalOrigin( getOriginalOrigin(), true );
rune->PostEvent( EV_Rune_Respawn, 60.0f );
}
}
//--------------------------------------------------------------
//
// Name: processGameplayData
// Class: WeaponDualWield
//
// Description: Process gameplay data
//
// Parameters: Event *ev -- not used
//
// Returns: None
//
//--------------------------------------------------------------
void WeaponDualWield::processGameplayData( Event * )
{
ClassDef *cls;
GameplayManager *gpm = GameplayManager::getTheGameplayManager();
if ( !gpm->hasObject(getArchetype()) )
return;
str leftmodel = gpm->getStringValue(getArchetype(), "leftmodel");
str rightmodel = gpm->getStringValue(getArchetype(), "rightmodel");
if ( !_leftweapon )
{
cls = getClass( leftmodel );
if ( !cls )
{
SpawnArgs args;
args.setArg( "model", leftmodel );
cls = args.getClassDef();
if ( !cls )
return;
}
_leftweapon = ( Weapon * )cls->newInstance();
_leftweapon->setModel( leftmodel );
_leftweapon->ProcessPendingEvents();
_leftweapon->hideModel();
}
if ( !_rightweapon )
{
cls = getClass( rightmodel );
if ( !cls )
{
SpawnArgs args;
args.setArg( "model", rightmodel );
cls = args.getClassDef();
if ( !cls )
return;
}
_rightweapon = ( Weapon * )cls->newInstance();
_rightweapon->setModel( rightmodel );
_rightweapon->ProcessPendingEvents();
_rightweapon->hideModel();
}
// Process gameplay data on myself.
Weapon::processGameplayData( NULL );
}
//====================
//Player::SpawnActor
//====================
void Player::SpawnActor
(
Event *ev
)
{
Entity *ent;
str name;
str text;
Vector forward;
Vector up;
Vector delta;
Vector v;
int n;
int i;
ClassDef *cls;
Event *e;
if ( ev->NumArgs() < 1 )
{
ScriptError( "Usage: actor [modelname] [keyname] [value]..." );
return;
}
name = ev->GetString( 1 );
if ( !name[ 0 ] )
{
ScriptError( "Must specify a model name" );
return;
}
if ( !strstr( name.c_str(), ".tik" ) )
{
name += ".tik";
}
// create a new entity
SpawnArgs args;
args.setArg( "model", name.c_str() );
cls = args.getClassDef();
if ( cls == &Object::ClassInfo )
{
cls = &Actor::ClassInfo;
}
if ( !cls || !checkInheritance( &Actor::ClassInfo, cls ) )
{
ScriptError( "%s is not a valid Actor", name.c_str() );
return;
}
ent = ( Entity * )cls->newInstance();
e = new Event( EV_Model );
e->AddString( name.c_str() );
ent->PostEvent( e, EV_SPAWNARG );
angles.AngleVectors( &forward, NULL, &up );
v = origin + ( forward + up ) * 40;
e = new Event( EV_SetOrigin );
e->AddVector( v );
ent->PostEvent( e, EV_SPAWNARG );
delta = origin - v;
v = delta.toAngles();
e = new Event( EV_SetAngle );
e->AddFloat( v[ 1 ] );
ent->PostEvent( e, EV_SPAWNARG );
if ( ev->NumArgs() > 2 )
{
n = ev->NumArgs();
for( i = 2; i <= n; i += 2 )
{
e = new Event( ev->GetString( i ) );
e->AddToken( ev->GetString( i + 1 ) );
ent->PostEvent( e, EV_SPAWNARG );
}
}
}
//====================
//Player::SpawnEntity
//====================
void Player::SpawnEntity
(
Event *ev
)
{
Entity *ent;
str name;
ClassDef *cls;
str text;
Vector forward;
Vector up;
Vector delta;
Vector v;
int n;
int i;
Event *e;
if ( ev->NumArgs() < 1 )
{
ScriptError( "Usage: spawn entityname [keyname] [value]..." );
return;
}
name = ev->GetString( 1 );
if ( !name.length() )
{
ScriptError( "Must specify an entity name" );
return;
}
// create a new entity
SpawnArgs args;
args.setArg( "classname", name.c_str() );
args.setArg( "model", name.c_str() );
cls = args.getClassDef();
if ( !cls )
{
cls = &Entity::ClassInfo;
}
if ( !checkInheritance( &Entity::ClassInfo, cls ) )
{
ScriptError( "%s is not a valid Entity", name.c_str() );
return;
}
ent = ( Entity * )cls->newInstance();
e = new Event( EV_Model );
e->AddString( name.c_str() );
ent->PostEvent( e, EV_PRIORITY_SPAWNARG );
angles.AngleVectors( &forward, NULL, &up );
v = origin + ( forward + up ) * 40;
e = new Event( EV_SetOrigin );
e->AddVector( v );
ent->PostEvent( e, EV_SPAWNARG );
delta = origin - v;
v.x = 0;
v.y = delta.toYaw();
v.z = 0;
e = new Event( EV_SetAngles );
e->AddVector( v );
ent->PostEvent( e, EV_SPAWNARG );
if ( ev->NumArgs() > 2 )
{
n = ev->NumArgs();
for( i = 2; i <= n; i += 2 )
{
e = new Event( ev->GetString( i ) );
e->AddToken( ev->GetString( i + 1 ) );
ent->PostEvent( e, EV_SPAWNARG );
}
}
e = new Event( EV_SetAnim );
e->AddString( "idle" );
ent->PostEvent( e, EV_SPAWNARG );
}
bool HoldableItemSpawnPowerup::use( void )
{
SpawnArgs args;
Entity *ent;
Item *item;
if ( _powerupToSpawn.length() == 0 )
return true;
if ( _owner )
{
args.setArg( "model", _powerupToSpawn );
ent = args.Spawn();
if ( !ent || !ent->isSubclassOf( Item ) )
return true;
item = (Item *)ent;
item->setOrigin( _owner->centroid );
item->ProcessPendingEvents();
item->PlaceItem();
item->setOrigin( _owner->centroid );
if ( _owner->isSubclassOf( Player ) )
{
Vector viewAngles;
Vector viewDir;
Player *player = (Player *)_owner;
Vector pos;
player->GetPlayerView( &pos, &viewAngles );
//viewAngles = player->GetVAngles();
viewAngles.AngleVectors( &viewDir );
viewDir.normalize();
viewDir *= 500.0f;
item->velocity = viewDir;
item->setOrigin( pos );
}
else
{
item->velocity = Vector( G_CRandom( 100.0f ), G_CRandom( 100.0f ), 200.0f + G_Random( 200.0f ) );
}
item->edict->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
item->_nextPickupTime = level.time + 1.0f;
item->setRespawn( false );
// Powerup is only gets half time
item->setAmount( item->getAmount() / 2.0f );
// Get rid of the spawned powerup in 10 seconds
item->PostEvent( EV_Remove, 10.0f );
return true;
}
return false;
}
/*
==============
SpawnEntities
Creates a server's entity / program execution context by
parsing textual entity definitions out of an ent file.
==============
*/
void Level::SpawnEntities( const char *themapname, const char *entities, int levelTime )
{
int inhibit,count=0;
const char *value;
SpawnArgs args;
char *spawnpos;
// Init the level variables
Init();
spawnpos = const_cast<char*>(strchr( themapname, '$' ));
if ( spawnpos )
{
mapname = str( themapname, 0, spawnpos - themapname );
spawnpoint = spawnpos + 1;
}
else
{
mapname = themapname;
spawnpoint = "";
}
// set up time so functions still have valid times
setTime( levelTime, 1000 / 20 );
if ( !LoadingServer )
{
// Get rid of anything left over from the last level
//CleanUp( false );
// Set up for a new map
thePathManager.Init( mapname );
}
setSkill( skill->integer );
// reset out count of the number of game traces
sv_numtraces = 0;
// parse world
entities = args.Parse( entities );
spawn_entnum = ENTITYNUM_WORLD;
args.Spawn();
if ( !world )
Com_Error( ERR_FATAL, "No world\n" );
if ( g_gametype->integer == GT_MULTIPLAYER || g_gametype->integer == GT_BOT_SINGLE_PLAYER )
{
multiplayerManager.initMultiplayerGame();
}
// parse ents
inhibit = 0;
for( entities = args.Parse( entities ); entities != NULL; entities = args.Parse( entities ) )
{
// remove things (except the world) from different skill levels or deathmatch
spawnflags = 0;
value = args.getArg( "spawnflags" );
if ( value )
{
spawnflags = atoi( value );
if ( inhibitEntity( spawnflags ) )
{
inhibit++;
continue;
}
}
args.Spawn();
count++;
gi.ProcessLoadingScreen( "$$SpawningEntities$$" );
}
gi.DPrintf( "%i entities spawned\n", count );
gi.DPrintf( "%i entities inhibited\n", inhibit );
// Process the spawn events
L_ProcessPendingEvents();
if ( multiplayerManager.inMultiplayer() )
{
multiplayerManager.initItems();
}
// Setup bots
if ( gi.Cvar_VariableIntegerValue( "bot_enable" ) && multiplayerManager.inMultiplayer() )
{
BotAIShutdown( 0 );
BotAISetup( 0 );
BotAILoadMap( 0 );
G_InitBots( 0 );
}
if ( !LoadingServer || game.autosaved )
{
Start();
}
postLoad();
//-------------------------------------------------------------------------------
//
// Deletion Note:
// Since hNodeController is an Entity, it is deleted
// when all the other entities are deleted in the clean up function
// specifically the line
//
//
// if ( active_edicts.next->entity )
// {
// delete active_edicts.next->entity;
// }
//
//
// Since it is already being deleted like this
// We do not need to explcitily delete the controller... In fact
// you will error out if you try to.
//--------------------------------------------------------------------------------
hNodeController = new HelperNodeController;
if ( hNodeController )
hNodeController->SetTargetName( "HelperNodeController" );
//
// if this is a single player game, spawn the single player in now
// this allows us to read persistant data into the player before the client
// is completely ready
//
if ( game.maxclients == 1 )
{
spawn_entnum = 0;
new Player;
}
}
