Example #1
0
static void InitBodyQue(void)
{
	string_t	istrClassname = MAKE_STRING("bodyque");

	g_pBodyQueueHead = CREATE_NAMED_ENTITY( istrClassname );
	entvars_t *pev = VARS(g_pBodyQueueHead);
	
	// Reserve 3 more slots for dead bodies
	for ( int i = 0; i < 3; i++ )
	{
		pev->owner = CREATE_NAMED_ENTITY( istrClassname );
		pev = VARS(pev->owner);
	}
	
	pev->owner = g_pBodyQueueHead;
}
Example #2
0
void AvHKnife::Spawn() 
{ 
    AvHMarineWeapon::Spawn(); 

	Precache();

	this->m_iId = AVH_WEAPON_KNIFE;
	//this->m_iDefaultAmmo = kKNMaxClip;
	
    // Set our class name
	this->pev->classname = MAKE_STRING(kwsKnife);
	
	SET_MODEL(ENT(this->pev), kNullModel);
	
	FallInit();// get ready to fall down.
} 
Example #3
0
static void httpapp_send_all_usage( tcp_sock sock )
{
    str_t content = { 0, 0 };
    str_t content_type = MAKE_STRING( "application/x-json" );
    user_t * u = 0;

    while( (u = get_next_user(u)) != 0 )
    {
        str_t usage = httpapp_user_usage(u, get_next_user(u) != 0);
        append_string( &content, &usage );
        free( usage.str );
    }

    httpserv_send_content(sock, content_type, content, 1, 0 );
    log_printf( "200 OK %d bytes\n", content.len );
}
Example #4
0
static void httpapp_send_stat_counts( tcp_sock sock )
{
    str_t content = { 0, 0 };
    str_t content_type = MAKE_STRING( "application/x-json" );

    void * c = 0;
    while( 0 != (c = stats_get_next_counter(c) ))
    {
        str_t counter = httpapp_make_counter_json(c, stats_get_next_counter(c) != 0);
        append_string( &content, &counter );
        free( counter.str );
    }

    httpserv_send_content(sock, content_type, content, 1, 0);
    log_printf( "200 OK %d bytes\n", content.len );
}
Example #5
0
void CAWP::Spawn( )
{
	pev->classname = MAKE_STRING( "weapon_awp" );
	Precache( );
	SET_MODEL( ENT(pev), "models/weapons/awp/w_awp.mdl" );
	m_iId = WEAPON_AWP;
	m_iDefaultAmmo = 120;
	FallInit();

	wepspread_s.MaxSpreadX = 5;
	wepspread_s.MaxSpreadY = 5;

	wepspread_s.SpreadX = 5;
	wepspread_s.SpreadY = 5;
	scope = false;
}
Example #6
0
void CM249::Spawn(void)
{
	BINTRACE

	pev->classname = MAKE_STRING("weapon_m249");

	Precache();
	m_iId = WEAPON_M249;
	SET_MODEL(ENT(pev), "models/w_m249.mdl");

	m_iDefaultAmmo = M249_DEFAULT_GIVE;
	m_flAccuracy = 0.2;
	m_iShotsFired = 0;

	FallInit();
}
Example #7
0
void CBaseDelay::SUB_UseTargets(CBaseEntity *pActivator, USE_TYPE useType, float value)
{
	if (FStringNull(pev->target) && !m_iszKillTarget)
		return;

	if (m_flDelay != 0)
	{
		CBaseDelay *pTemp = GetClassPtr((CBaseDelay *)NULL);

		if (pTemp->pev->classname)
			RemoveEntityHashValue(pTemp->pev, STRING(pTemp->pev->classname), CLASSNAME);

		pTemp->pev->classname = MAKE_STRING("DelayedUse");
		AddEntityHashValue(pTemp->pev, STRING(pTemp->pev->classname), CLASSNAME);

		pTemp->pev->nextthink = gpGlobals->time + m_flDelay;
		pTemp->SetThink(&CBaseDelay::DelayThink);
		pTemp->pev->button = (int)useType;
		pTemp->m_iszKillTarget = m_iszKillTarget;
		pTemp->m_flDelay = 0;
		pTemp->pev->target = pev->target;

		if (pActivator && pActivator->IsPlayer())
			pTemp->pev->owner = pActivator->edict();
		else
			pTemp->pev->owner = NULL;

		return;
	}

	if (m_iszKillTarget)
	{
		ALERT(at_aiconsole, "KillTarget: %s\n", STRING(m_iszKillTarget));
		edict_t *pentKillTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(m_iszKillTarget));

		while (!FNullEnt(pentKillTarget))
		{
			UTIL_Remove(CBaseEntity::Instance(pentKillTarget));
			ALERT(at_aiconsole, "killing %s\n", STRING(pentKillTarget->v.classname));
			pentKillTarget = FIND_ENTITY_BY_TARGETNAME(pentKillTarget, STRING(m_iszKillTarget));
		}
	}

	if (!FStringNull(pev->target))
		FireTargets(STRING(pev->target), pActivator, this, useType, value);
}
Example #8
0
static void httpapp_send_user_bindings( tcp_sock sock )
{
    str_t content = { 0, 0 };
    str_t content_type = MAKE_STRING( "application/x-json" );

    user_t * u = 0;

    while( 0 != (u = get_next_user(u) ))
    {
        str_t binding = httpapp_user_binding(u, get_next_user(u) != 0);
        append_string( &content, &binding );
        free( binding.str );
    }

    httpserv_send_content(sock, content_type, content, 1, 0);
    log_printf( "200 OK %d bytes\n", content.len );
}
Example #9
0
File: xen.cpp Project: Arkshine/NS
CXenHull *CXenHull :: CreateHull( CBaseEntity *source, const Vector &mins, const Vector &maxs, const Vector &offset )
{
	CXenHull *pHull = GetClassPtr( (CXenHull *)NULL );

	UTIL_SetOrigin( pHull->pev, source->pev->origin + offset );
	SET_MODEL( pHull->edict(), STRING(source->pev->model) );
	pHull->pev->solid = SOLID_BBOX;
	pHull->pev->classname = MAKE_STRING("xen_hull");
	pHull->pev->movetype = MOVETYPE_NONE;
	pHull->pev->owner = source->edict();
	UTIL_SetSize( pHull->pev, mins, maxs );
	pHull->pev->renderamt = 0;
	pHull->pev->rendermode = kRenderTransTexture;
	//	pHull->pev->effects = EF_NODRAW;

	return pHull;
}
Example #10
0
void CTeamSpawn::Spawn( void )
{
	pev->solid = SOLID_NOT;

	if( !stricmp( STRING( pev->classname ), "info_player_start" ) )
	{
		pev->team = TEAM_EARTH;
	}
	else if( !stricmp( STRING( pev->classname ), "info_player_deathmatch" ) )
	{
		pev->team = TEAM_SPACE;
	}

	pev->classname = MAKE_STRING( "info_team_spawn" );

//	ALERT( at_console, "SPAWNS %i\n", pev->team );
}
Example #11
0
void CSquidSpit:: Spawn( void )
{
	pev->movetype = MOVETYPE_FLY;
	pev->classname = MAKE_STRING( "squidspit" );

	pev->solid = SOLID_BBOX;
	pev->rendermode = kRenderTransAlpha;
	pev->renderamt = 255;

	SET_MODEL(ENT(pev), "sprites/bigspit.spr");
	pev->frame = 0;
	pev->scale = 0.5;

	UTIL_SetSize( pev, Vector( 0, 0, 0), Vector(0, 0, 0) );

	m_maxFrame = (float) MODEL_FRAMES( pev->modelindex ) - 1;
}
void AvHFlameGun::Spawn() 
{ 
    AvHMarineWeapon::Spawn(); 

	Precache();

	//this->m_iId = AVH_WEAPON_FLAMER;
	ASSERT(false);
	this->m_iDefaultAmmo = kFGMaxClip;

    // Set our class name
	this->pev->classname = MAKE_STRING(kwsFlameGun);

	SET_MODEL(ENT(this->pev), kFGWModel);

	FallInit();// get ready to fall down.
} 
Example #13
0
void CHostage::Precache(void)
{
	BINTRACE

	m_whichModel = 0;

	if (FStringNull(pev->model))
		pev->model = MAKE_STRING("models/scientist.mdl");

	PRECACHE_MODEL((char *)STRING(pev->model));
	PRECACHE_SOUND("hostage/hos1.wav");
	PRECACHE_SOUND("hostage/hos2.wav");
	PRECACHE_SOUND("hostage/hos3.wav");
	PRECACHE_SOUND("hostage/hos4.wav");
	PRECACHE_SOUND("hostage/hos5.wav");
	PRECACHE_MODEL("sprites/smoke.spr");
}
Example #14
0
	void Save( ISave *pSave )
	{
		pSave->StartBlock( "Squads" );
		short nSquads = (short)g_AI_SquadManager.NumSquads();
		pSave->WriteShort( &nSquads );
		
		AISquadsIter_t iter;
		string_t squadName;
		CAI_Squad* pSquad = g_AI_SquadManager.GetFirstSquad( &iter );
		while (pSquad)
		{
			squadName = MAKE_STRING( pSquad->GetName() );
			pSave->WriteString( "", &squadName ); // Strings require a header to be read properly
			pSave->WriteAll( pSquad );
			pSquad = g_AI_SquadManager.GetNextSquad( &iter );
		}
		
		pSave->EndBlock();

		//---------------------------------
		
		pSave->StartBlock( "Enemies" );
		short nMemories = 0;
		
		CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
		int i;

		for ( i = 0; i < g_AI_Manager.NumAIs(); i++ )
		{
			if ( ppAIs[i]->GetEnemies() )
				nMemories++;
		}

		pSave->WriteShort( &nMemories );
		
		for ( i = 0; i < g_AI_Manager.NumAIs(); i++ )
		{
			if ( ppAIs[i]->GetEnemies() )
			{
				CBaseEntity *p = ppAIs[i];
				pSave->WriteEntityPtr( &p );
				pSave->WriteAll( ppAIs[i]->GetEnemies() );
			}
		}
		pSave->EndBlock();
	}
void CCycler :: GenericCyclerSpawn(char *szModel, Vector vecMin, Vector vecMax)
{
	if (!szModel || !*szModel)
	{
		ALERT(at_error, "cycler at %.0f %.0f %0.f missing modelname", pev->origin.x, pev->origin.y, pev->origin.z );
		REMOVE_ENTITY(ENT(pev));
		return;
	}

	pev->classname		= MAKE_STRING("cycler");
	PRECACHE_MODEL( szModel );
	SET_MODEL(ENT(pev),	szModel);

	CCycler::Spawn( );

	UTIL_SetSize(pev, vecMin, vecMax);
}
Example #16
0
// UNDONE: right now this is pretty much a copy of the squid spit with minor changes to the way it does damage
void CBMortar:: Spawn( void )
{
	pev->movetype = MOVETYPE_TOSS;
	pev->classname = MAKE_STRING( "bmortar" );
	
	pev->solid = SOLID_BBOX;
	pev->rendermode = kRenderTransAlpha;
	pev->renderamt = 255;

	SET_MODEL(ENT(pev), "sprites/mommaspit.spr");
	pev->frame = 0;
	pev->scale = 0.5;

	UTIL_SetSize( pev, Vector( 0, 0, 0), Vector(0, 0, 0) );

	m_maxFrame = (float) MODEL_FRAMES( pev->modelindex ) - 1;
	pev->dmgtime = gpGlobals->time + 0.4;
}
Example #17
0
// NOTE: szName must be a pointer to constant memory, e.g. "monster_class" because the entity
// will keep a pointer to it after this call.
CBaseEntity *CBaseEntity::Create(char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner)
{
	edict_t *    pent;
	CBaseEntity *pEntity;

	pent = CREATE_NAMED_ENTITY(MAKE_STRING(szName));
	if(FNullEnt(pent))
	{
		ALERT(at_console, "NULL Ent in Create!\n");
		return NULL;
	}
	pEntity              = Instance(pent);
	pEntity->pev->owner  = pentOwner;
	pEntity->pev->origin = vecOrigin;
	pEntity->pev->angles = vecAngles;
	DispatchSpawn(pEntity->edict());
	return pEntity;
}
//=========================================================
//=========================================================
void CFlockingFlyer :: SpawnCommonCode( )
{
	pev->deadflag	= DEAD_NO;
	pev->classname	= MAKE_STRING("monster_flyer");
	pev->solid		= SOLID_SLIDEBOX;
	pev->movetype	= MOVETYPE_FLY;
	pev->takedamage	= DAMAGE_NO;
	pev->health		= 1;

	m_fPathBlocked	= FALSE;// obstacles will be detected
	m_flFieldOfView	= 0.2;

	//SET_MODEL(ENT(pev), "models/aflock.mdl");
	SET_MODEL(ENT(pev), "models/boid.mdl");

//	UTIL_SetSize(pev, Vector(0,0,0), Vector(0,0,0));
	UTIL_SetSize(pev, Vector(-5,-5,0), Vector(5,5,2));
}
Example #19
0
void CBaseTrigger :: Spawn( void )
{
	pev->solid = SOLID_TRIGGER;
	pev->movetype = MOVETYPE_NONE;
	pev->takedamage = DAMAGE_NO;
	UTIL_SetModel( ENT( pev ), pev->model );    // set size and link into world
	SetObjectClass( ED_TRIGGER );
          
	// create a null-terminator for the registry
	m_pRegister = GetClassPtr(( CInOutRegister *)NULL );
	m_pRegister->m_hValue = NULL;
	m_pRegister->m_pNext = NULL;
	m_pRegister->m_pField = this;
	m_pRegister->pev->classname = MAKE_STRING("zoneent");
	m_pRegister->SetObjectClass( ED_STATIC );

	SetThink( Update );
}
Example #20
0
void CSmokeGrenade::Spawn( void )
{
    pev->classname = MAKE_STRING( "weapon_smokegrenade" );

    Precache();
    m_iId = WEAPON_SMOKEGRENADE;
    SET_MODEL( edict(), "models/w_smokegrenade.mdl" );

    pev->dmg = 4;

    ClearBits( m_iWeaponState, WPNSTATE_SHIELD_DRAWN );

    m_iDefaultAmmo   = SMOKEGRENADE_DEFAULT_GIVE;
    m_flStartThrow   = 0;
    m_flReleaseThrow = -1;

    FallInit();
}
Example #21
0
SCM_EXPORT ScmObj
scm_p_number2string(ScmObj num, ScmObj args)
{
    char *str;
    intmax_t n;
    int r;
    ScmValueFormat vfmt;
    DECLARE_FUNCTION("number->string", procedure_variadic_1);

    ENSURE_INT(num);

    n = (intmax_t)SCM_INT_VALUE(num);
    r = prepare_radix(SCM_MANGLE(name), args);
    SCM_VALUE_FORMAT_INIT(vfmt);
    str = scm_int2string(vfmt, (uintmax_t)n, r);

    return MAKE_STRING(str, SCM_STRLEN_UNKNOWN);
}
Example #22
0
//=========================================================
CQuakeRocket *CQuakeRocket::CreateGrenade( Vector vecOrigin, Vector vecVelocity, CBaseEntity *pOwner )
{
	CQuakeRocket *pRocket = GetClassPtr( (CQuakeRocket *)NULL );

	UTIL_SetOrigin( pRocket->pev, vecOrigin );
	SET_MODEL(ENT(pRocket->pev), "models/grenade.mdl");
	pRocket->Spawn();
	pRocket->pev->classname = MAKE_STRING("grenade");
	pRocket->pev->owner = pOwner->edict();

	// Setup
	pRocket->pev->movetype = MOVETYPE_BOUNCE;
	pRocket->pev->solid = SOLID_BBOX;

	pRocket->pev->avelocity = Vector(300,300,300);
	
	// Velocity
	pRocket->pev->velocity = vecVelocity;
	pRocket->pev->angles = UTIL_VecToAngles(vecVelocity);
	pRocket->pev->friction = 0.5;

	// Touch
	pRocket->SetTouch( CQuakeRocket::GrenadeTouch );

	// set newmis duration
	if ( gpGlobals->deathmatch == 4 )
	{
		pRocket->m_flAttackFinished = gpGlobals->time + 1.1;	// What's this used for?
		if (pOwner)
			pOwner->TakeDamage( pOwner->pev, pOwner->pev, 10, DMG_GENERIC );
	}

	pRocket->pev->nextthink = gpGlobals->time + 2.5;
	pRocket->SetThink( CQuakeRocket::GrenadeExplode );

	PLAYBACK_EVENT_FULL (FEV_GLOBAL, pRocket->edict(), g_sTrail, 0.0, 
	(float *)&g_vecZero, (float *)&g_vecZero, 0.7, 0.0, pRocket->entindex(), GRENADE_TRAIL, 0, 0);


	return pRocket;
}
Example #23
0
void CGrenade::Spawn(void)
{
	m_iBounceCount = 0;

	pev->movetype = MOVETYPE_BOUNCE;

	if (pev->classname)
		RemoveEntityHashValue(pev, STRING(pev->classname), CLASSNAME);

	pev->classname = MAKE_STRING("grenade");
	AddEntityHashValue(pev, STRING(pev->classname), CLASSNAME);

	m_bIsC4 = false;
	pev->solid = SOLID_BBOX;

	SET_MODEL(ENT(pev), "models/grenade.mdl");
	UTIL_SetSize(pev, Vector(0, 0, 0), Vector(0, 0, 0));

	pev->dmg = 30;
	m_fRegisteredSound = FALSE;
}
Example #24
0
void CTankCam :: Spawn( void )
{
	Precache();

	SET_MODEL(ENT(pev), "models/tank_cam.mdl");
	UTIL_SetSize(pev, Vector(0,0,0),Vector(0,0,0) );

	UTIL_SetOrigin( pev, pev->origin );

	pev->movetype = MOVETYPE_NOCLIP;
	pev->solid = SOLID_NOT;

	pev->classname = MAKE_STRING("info_tank_camera");	//necessaire pour le passage a la sauvegarde : getclassptr ne cree pas de pev->classname et donc l entite n est pas prise en compte

	pev->takedamage		= DAMAGE_NO;


	SetThink ( CamThink );
	pev->nextthink = gpGlobals->time + 1.5;

}
void CTriggerAreaCapture::InputSetControlPoint( inputdata_t &inputdata )
{
	BreakCapture( false );	// clear the capping for the previous point, forces us to recalc on the new one

	char parseString[255];
	Q_strncpy(parseString, inputdata.value.String(), sizeof(parseString));

	m_iszCapPointName = MAKE_STRING( parseString );
	m_hPoint = NULL;	// force a reset of this
	InputRoundSpawn( inputdata );

	// force everyone touching to re-touch so the hud gets set up properly
	for ( int i = 0; i < m_hTouchingEntities.Count(); i++ )
	{
		CBaseEntity *ent = m_hTouchingEntities[i];
		if ( ent && ent->IsPlayer() )
		{
			EndTouch( ent );
			StartTouch( ent );
		}
	}
}
Example #26
0
void CMomentaryDoor :: Precache( void )
{
	int m_sound = UTIL_LoadSoundPreset( m_iMoveSnd );

	// set the door's "in-motion" sound
	switch( m_sound )
	{
	case 1:
		pev->noise = UTIL_PrecacheSound( "doors/doormove1.wav" );
		break;
	case 2:
		pev->noise = UTIL_PrecacheSound( "doors/doormove2.wav" );
		break;
	case 3:
		pev->noise = UTIL_PrecacheSound( "doors/doormove3.wav" );
		break;
	case 4:
		pev->noise = UTIL_PrecacheSound( "doors/doormove4.wav" );
		break;
	case 5:
		pev->noise = UTIL_PrecacheSound( "doors/doormove5.wav" );
		break;
	case 6:
		pev->noise = UTIL_PrecacheSound( "doors/doormove6.wav" );
		break;
	case 7:
		pev->noise = UTIL_PrecacheSound( "doors/doormove7.wav" );
		break;
	case 8:
		pev->noise = UTIL_PrecacheSound( "doors/doormove8.wav" );
		break;
	case 0:
		pev->noise = MAKE_STRING( "common/null.wav" );
		break;
	default:
		pev->noise = UTIL_PrecacheSound( m_sound );
		break;
	}
}
Example #27
0
// SidLuke
static cell AMX_NATIVE_CALL strip_user_weapons(AMX *amx, cell *params) // index
{
	CHECK_PLAYER(params[1]);

	edict_t* pPlayer = MF_GetPlayerEdict(params[1]);

	string_t item = MAKE_STRING("player_weaponstrip");
	edict_t *pent = CREATE_NAMED_ENTITY(item);
	
	if (FNullEnt(pent)) 
	{
		return 0;
	}

	MDLL_Spawn(pent);
	MDLL_Use(pent, pPlayer);
	REMOVE_ENTITY(pent);

	*reinterpret_cast<int *>(MF_PlayerPropAddr(params[1], Player_CurrentWeapon)) = 0;

	return 1;
}
//=========================================================
//=========================================================
void CDirectorBatterySpawn::Make()
{
	// Desactivado.
	if ( Disabled )
		return;

	if ( !MaySpawn() )
		return;

	// Creamos la bateria.
	CItem *pItem = (CItem *)CreateEntityByName("item_battery");

	// Hubo un problema al crear el objeto.
	if ( !pItem )
	{
		DevWarning("[DIRECTOR BATTERY MAKER] Ha ocurrido un problema al crear la bateria.");
		return;
	}

	Vector origin;

	if ( !CanSpawn(pItem, &origin) )
		return;

	QAngle angles = GetAbsAngles();

	// Lugar de creación.
	pItem->SetAbsOrigin(origin);

	// Nombre de la entidad.
	pItem->SetName(MAKE_STRING(ITEM_NAME));
	pItem->SetAbsAngles(angles);

	// Creamos la bateria, le decimos quien es su dios (creador) y lo activamos.
	DispatchSpawn(pItem);
	pItem->SetOwnerEntity(this);
	pItem->Activate();
}
Example #29
0
// Precaches the weapon and queues the weapon info for sending to clients
void UTIL_PrecacheOtherWeapon( const char *szClassname )
{
	edict_t	*pent;

	pent = CREATE_NAMED_ENTITY( MAKE_STRING( szClassname ) );
	if ( FNullEnt( pent ) )
	{
		ALERT ( at_console, "NULL Ent in UTIL_PrecacheOtherWeapon\n" );
		return;
	}
	
	CBaseEntity *pEntity = CBaseEntity::Instance (VARS( pent ));

	if (pEntity)
	{
		ItemInfo II;
		pEntity->Precache( );
		memset( &II, 0, sizeof II );
		if ( ((CBasePlayerItem*)pEntity)->GetItemInfo( &II ) )
		{
			CBasePlayerItem::ItemInfoArray[II.iId] = II;

			if ( II.pszAmmo1 && *II.pszAmmo1 )
			{
				AddAmmoNameToAmmoRegistry( II.pszAmmo1 );
			}

			if ( II.pszAmmo2 && *II.pszAmmo2 )
			{
				AddAmmoNameToAmmoRegistry( II.pszAmmo2 );
			}

			memset( &II, 0, sizeof II );
		}
	}

	REMOVE_ENTITY(pent);
}
void CCharleville::SetAllVars()
{
	pData->p_model = "models/p_charleville.mdl";
	pData->v_model = "models/v_charleville.mdl";
	pData->w_model = "models/w_charleville.mdl";
	pData->player_anim = "charleville";

	pData->snd_prim_fire = "weapons/charleville/fire1.wav";
	pData->snd_second_fire = "weapons/charleville/fire2.wav";
	pData->snd_reload = "weapons/charleville/reload.wav";
	pData->snd_draw = "weapons/charleville/draw.wav";
	pData->snd_holster = "weapons/charleville/holster.wav";
	pData->snd_hit = "weapons/charleville/hit.wav";
	pData->snd_hitwall = "weapons/charleville/hitwall.wav";

	pData->event_second = "events/melee.sc";

	pData->iId = WEAPON_CHARLE;
	pData->flPrimaryDmgModifier = CHARLE_FIRE_DAMAGE;
	pData->flSecondaryDmgModifier = CHARLE_BAYONET_DAMAGE;
	pData->iWeight = CHARLE_WEIGHT;
	pData->flSpeedModifier = CHARLE_SPEED;

	pData->flStandMoving = 11.5;
	pData->flStandStill = 3.5;
	pData->flCrouchMoving = 11.5;
	pData->flCrouchStill = 3.5;

	pData->iDefaultGive = CHARLE_DEFAULT_GIVE;
	pData->iMaxAmmo = CHARLE_MAX_CARRY;

	pData->classname = MAKE_STRING("weapon_Charleville");

	pData->flBladeLength = 77.0;
	pData->bBayonet = true;

	pData->flDeployDelay = 0.0;
}