void StartSequenceDesigGridCell::SetStartSequence(int nValue)
{
TestZoneCurve& currTZC = testZoneCurves.GetRef(tzcIndex);
SetSequence(currTZC.startSeqID, nValue);
if (StringLength(currTZC.endSeqID) == 0)
SetSequence(currTZC.endSeqID, nValue);
}
//-----------------------------------------------------------------------------
// Purpose: the entity
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::Spawn( void )
{
Precache();
BaseClass::Spawn();
SetViewOffset( vec3_origin );
AddEFlags( EFL_NO_DISSOLVE );
SetModel( ROCKET_TURRET_MODEL_NAME );
SetSolid( SOLID_VPHYSICS );
m_iMuzzleAttachment = LookupAttachment ( "barrel" );
m_iLightAttachment = LookupAttachment ( "eye" );
m_iPosePitch = LookupPoseParameter( "aim_pitch" );
m_iPoseYaw = LookupPoseParameter( "aim_yaw" );
m_vecCurrentAngles = m_vecGoalAngles = GetAbsAngles();
CreateVPhysics();
//Set our autostart state
m_bEnabled = ( ( m_spawnflags & SF_ROCKET_TURRET_START_INACTIVE ) == false );
// Set Locked sprite
if ( m_bEnabled )
{
m_iLaserState = 1;
SetSequence(LookupSequence("idle"));
}
else
{
m_iLaserState = 0;
SetSequence(LookupSequence("inactive"));
}
SetCycle(1.0f);
UpdateSkin( ROCKET_SKIN_IDLE );
SetPoseParameter( "aim_pitch", 0 );
SetPoseParameter( "aim_yaw", -180 );
if ( m_bEnabled )
{
SetThink( &CNPC_RocketTurret::FollowThink );
}
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
}
void KeyframeMeshInstance::RecoverFromTempSequence()
{
m_isRunningTempSequence = false;
SetSequence(m_oldSequenceName, m_oldSequenceLoop);
m_oldSequenceName.clear();
m_oldSequenceLoop = false;
}
void QUA_helicopter::SetActivity(Activity NewActivity) {
int sequence;
if (m_Activity == NewActivity)
{
return;
} else {
sequence = SelectHeaviestSequence( NewActivity );
//int sequence = this->LookupSequence("Idle01");
if ( sequence != ACTIVITY_NOT_AVAILABLE )
{
m_Activity=NewActivity;
SetSequence( sequence );
SetActivity(NewActivity);
SetCycle( 0 );
ResetSequenceInfo( );
if(NewActivity==ACT_MELEE_ATTACK1) {
SetPlaybackRate(2.0f);
} else {
SetPlaybackRate(1.0f);
}
//m_Activity=NewActivity;
} else {
return;
}
}
}
void CAnimating::ResetSequenceInfo()
{
if (GetSequence() == -1)
{
// This shouldn't happen. Setting m_nSequence blindly is a horrible coding practice.
SetSequence( 0 );
}
CStudioHdr *pStudioHdr = GetModelPtr();
m_flGroundSpeed = GetSequenceGroundSpeed( pStudioHdr, GetSequence() );
m_bSequenceLoops = ((GetSequenceFlags( pStudioHdr, GetSequence() ) & STUDIO_LOOPING) != 0);
// m_flAnimTime = gpGlobals->time;
m_flPlaybackRate = 1.0;
m_bSequenceFinished = false;
m_flLastEventCheck = 0;
m_nNewSequenceParity = ( *(m_nNewSequenceParity)+1 ) & EF_PARITY_MASK;
m_nResetEventsParity = ( *(m_nResetEventsParity)+1 ) & EF_PARITY_MASK;
// FIXME: why is this called here? Nothing should have changed to make this nessesary
if ( pStudioHdr )
{
SetEventIndexForSequence( pStudioHdr->pSeqdesc( GetSequence() ) );
}
}
void CBaseTurret::Spawn()
{
Precache( );
SetNextThink( gpGlobals->curtime + 1 );
SetMoveType( MOVETYPE_FLY );
SetSequence(0);
SetCycle(0);
SetSolid( SOLID_SLIDEBOX );
m_takedamage = DAMAGE_YES;
AddFlag( FL_AIMTARGET );
m_iAmmoType = g_pGameRules->GetAmmoDef()->Index("SMG1");
AddFlag( FL_NPC );
if (( m_spawnflags & SF_NPC_TURRET_AUTOACTIVATE ) && !( m_spawnflags & SF_NPC_TURRET_STARTINACTIVE ))
{
m_iAutoStart = true;
}
ResetSequenceInfo( );
SetPoseParameter( TURRET_BC_YAW, 0 );
SetPoseParameter( TURRET_BC_PITCH, 0 );
// Activities
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_OPEN );
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_CLOSE );
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_CLOSED_IDLE );
ADD_CUSTOM_ACTIVITY( CBase`matTurret, ACT_TURRET_OPEN_IDLE );
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_FIRE );
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_RELOAD );
}
//-----------------------------------------------------------------------------
// Purpose: This used to have something to do with bees flying, but
// now it only initializes moving furniture in scripted sequences
//-----------------------------------------------------------------------------
void CNPC_Furniture::Spawn( )
{
Precache();
SetModel( STRING(GetModelName()) );
SetMoveType( MOVETYPE_STEP );
SetSolid( SOLID_BBOX );
// Our collision, if needed, will be done through bone followers
AddSolidFlags( FSOLID_NOT_SOLID );
SetBloodColor( DONT_BLEED );
m_iHealth = TOO_MUCH_HEALTH_TO_DIE; //wow
m_takedamage = DAMAGE_AIM;
SetSequence( 0 );
SetCycle( 0 );
SetNavType( NAV_FLY );
AddFlag( FL_FLY );
CapabilitiesAdd( bits_CAP_MOVE_FLY | bits_CAP_TURN_HEAD | bits_CAP_ANIMATEDFACE );
AddEFlags( EFL_NO_MEGAPHYSCANNON_RAGDOLL );
// pev->nextthink += 1.0;
// SetThink (WalkMonsterDelay);
ResetSequenceInfo( );
SetCycle( 0 );
NPCInit();
// Furniture needs to block LOS
SetBlocksLOS( true );
}
void C_PortalGhostRenderable::PerFrameUpdate( void )
{
if( m_pGhostedRenderable )
{
SetModelName( m_pGhostedRenderable->GetModelName() );
SetModelIndex( m_pGhostedRenderable->GetModelIndex() );
SetEffects( m_pGhostedRenderable->GetEffects() | EF_NOINTERP );
m_flAnimTime = m_pGhostedRenderable->m_flAnimTime;
if( m_bSourceIsBaseAnimating )
{
C_BaseAnimating *pSource = (C_BaseAnimating *)m_pGhostedRenderable;
SetCycle( pSource->GetCycle() );
SetSequence( pSource->GetSequence() );
m_nBody = pSource->m_nBody;
m_nSkin = pSource->m_nSkin;
}
}
// Set position and angles relative to the object it's ghosting
Vector ptNewOrigin = m_matGhostTransform * m_pGhostedRenderable->GetAbsOrigin();
QAngle qNewAngles = TransformAnglesToWorldSpace( m_pGhostedRenderable->GetAbsAngles(), m_matGhostTransform.As3x4() );
SetAbsOrigin( ptNewOrigin );
SetAbsAngles( qNewAngles );
AddEffects( EF_NOINTERP );
RemoveFromInterpolationList();
g_pClientLeafSystem->RenderableChanged( RenderHandle() );
}
void CGrenadeSpit::Spawn( void )
{
Precache( );
SetSolid( SOLID_BBOX );
SetMoveType( MOVETYPE_FLYGRAVITY );
// FIXME, if these is a sprite, then we need a base class derived from CSprite rather than
// CBaseAnimating. pev->scale becomes m_flSpriteScale in that case.
SetModel( "models/spitball_large.mdl" );
UTIL_SetSize(this, Vector(0, 0, 0), Vector(0, 0, 0));
m_nRenderMode = kRenderTransAdd;
SetRenderColor( 255, 255, 255, 255 );
m_nRenderFX = kRenderFxNone;
SetThink( SpitThink );
SetUse( DetonateUse );
SetTouch( GrenadeSpitTouch );
SetNextThink( gpGlobals->curtime + 0.1f );
m_flDamage = sk_dmg_spit_grenade.GetFloat();
m_DmgRadius = sk_spit_grenade_radius.GetFloat();
m_takedamage = DAMAGE_YES;
m_iHealth = 1;
SetGravity( UTIL_ScaleForGravity( SPIT_GRAVITY ) );
SetFriction( 0.8 );
SetSequence( 1 );
SetCollisionGroup( HL2COLLISION_GROUP_SPIT );
}
static int EncodeAttributes(EncodedAttrib* ea, int eaSz,
PKCS7Attrib* attribs, int attribsSz)
{
int i;
int maxSz = min(eaSz, attribsSz);
int allAttribsSz = 0;
for (i = 0; i < maxSz; i++)
{
int attribSz = 0;
ea[i].value = attribs[i].value;
ea[i].valueSz = attribs[i].valueSz;
attribSz += ea[i].valueSz;
ea[i].valueSetSz = SetSet(attribSz, ea[i].valueSet);
attribSz += ea[i].valueSetSz;
ea[i].oid = attribs[i].oid;
ea[i].oidSz = attribs[i].oidSz;
attribSz += ea[i].oidSz;
ea[i].valueSeqSz = SetSequence(attribSz, ea[i].valueSeq);
attribSz += ea[i].valueSeqSz;
ea[i].totalSz = attribSz;
allAttribsSz += attribSz;
}
return allAttribsSz;
}
Npc::Npc(sf::Texture* tex):Image(tex) {
locked=true;
direction=0;
objectIndex=6;
index=0;
SetOrigin(imageWidth/2,imageHeight-11);
SetBBox(-engine->gridSize/2+engine->gridSize/32*4,-engine->gridSize/2+engine->gridSize/32*8,
engine->gridSize-engine->gridSize/32*8,engine->gridSize-engine->gridSize/32*15);
AddSequence(0,0,0.25);
AddSequence(5,5,0.25);
AddSequence(10,10,0.25);
AddSequence(15,15,0.25);
AddSequence(1,4,0.2);
AddSequence(6,9,0.2);
AddSequence(11,14,0.2);
AddSequence(16,19,0.2);
SetSequence(0,1);
sprShadow.setTexture(*engine->resourcesManager->GetTexture("sprShadow"),true);
sprShadow.setOrigin(engine->resourcesManager->GetTexture("sprShadow")->getSize().x/2,
engine->resourcesManager->GetTexture("sprShadow")->getSize().y/2-1*2);
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_NPC_Puppet::ClientThink( void )
{
if ( m_hAnimationTarget == NULL )
return;
C_BaseAnimating *pTarget = m_hAnimationTarget->GetBaseAnimating();
if ( pTarget == NULL )
return;
int nTargetSequence = pTarget->GetSequence();
const char *pSequenceName = pTarget->GetSequenceName( nTargetSequence );
int nSequence = LookupSequence( pSequenceName );
if ( nSequence >= 0 )
{
if ( nSequence != GetSequence() )
{
SetSequence( nSequence );
UpdateVisibility();
}
SetCycle( pTarget->GetCycle() );
SetPlaybackRate( pTarget->GetPlaybackRate() );
}
}
void CBasePlayer::SharedSpawn()
{
SetMoveType( MOVETYPE_WALK );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetFriction( 1.0f );
pl.deadflag = false;
m_lifeState = LIFE_ALIVE;
m_iHealth = 100;
m_takedamage = DAMAGE_YES;
m_Local.m_bDrawViewmodel = true;
m_Local.m_flStepSize = sv_stepsize.GetFloat();
m_Local.m_bAllowAutoMovement = true;
m_nRenderFX = kRenderFxNone;
m_flNextAttack = gpGlobals->curtime;
m_flMaxspeed = 0.0f;
MDLCACHE_CRITICAL_SECTION();
SetSequence( SelectWeightedSequence( ACT_IDLE ) );
if ( GetFlags() & FL_DUCKING )
SetCollisionBounds( VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX );
else
SetCollisionBounds( VEC_HULL_MIN, VEC_HULL_MAX );
// dont let uninitialized value here hurt the player
m_Local.m_flFallVelocity = 0;
SetBloodColor( BLOOD_COLOR_RED );
}
void CNPC_Sentry::Spawn()
{
Precache( );
SetModel( "models/sentry.mdl" );
m_iHealth = sk_sentry_health.GetFloat();
m_HackedGunPos = Vector( 0, 0, 48 );
SetViewOffset( Vector(0,0,48) );
m_flMaxWait = 1E6;
m_flMaxSpin = 1E6;
BaseClass::Spawn();
SetSequence( TURRET_ANIM_RETIRE );
SetCycle( 0.0 );
m_flPlaybackRate = 0.0;
m_iRetractHeight = 64;
m_iDeployHeight = 64;
m_iMinPitch = -60;
UTIL_SetSize(this, Vector(-16, -16, -m_iRetractHeight), Vector(16, 16, m_iRetractHeight));
SetTouch(&CNPC_Sentry::SentryTouch);
SetThink(&CNPC_Sentry::Initialize);
SetNextThink(gpGlobals->curtime + 0.3);
m_bStartedDeploy = false;
}
// If the local player is visible (thirdperson mode, tf2 taunts, etc., then make sure that we are using the
// w_ (world) model not the v_ (view) model or else the model can flicker, etc.
// Otherwise, if we're not the local player, always use the world model
void C_BaseCombatWeapon::EnsureCorrectRenderingModel()
{
C_BasePlayer *localplayer = C_BasePlayer::GetLocalPlayer();
if ( localplayer &&
localplayer == GetOwner() &&
!localplayer->ShouldDrawLocalPlayer() )
{
return;
}
MDLCACHE_CRITICAL_SECTION();
// BRJ 10/14/02
// FIXME: Remove when Yahn's client-side prediction is done
// It's a hacky workaround for the model indices fighting
// (GetRenderBounds uses the model index, which is for the view model)
SetModelIndex( GetWorldModelIndex() );
// Validate our current sequence just in case ( in theory the view and weapon models should have the same sequences for sequences that overlap at least )
CStudioHdr *pStudioHdr = GetModelPtr();
if ( pStudioHdr &&
GetSequence() >= pStudioHdr->GetNumSeq() )
{
SetSequence( 0 );
}
}
word32 EncodeDSA_Signature(const Integer& r, const Integer& s, byte* output)
{
word32 rSz = r.ByteCount();
word32 sSz = s.ByteCount();
byte rLen[MAX_LENGTH_SZ + 1];
byte sLen[MAX_LENGTH_SZ + 1];
rLen[0] = INTEGER;
sLen[0] = INTEGER;
word32 rLenSz = SetLength(rSz, &rLen[1]) + 1;
word32 sLenSz = SetLength(sSz, &sLen[1]) + 1;
byte seqArray[MAX_SEQ_SZ];
word32 seqSz = SetSequence(rLenSz + rSz + sLenSz + sSz, seqArray);
// seq
memcpy(output, seqArray, seqSz);
// r
memcpy(output + seqSz, rLen, rLenSz);
r.Encode(output + seqSz + rLenSz, rSz);
// s
memcpy(output + seqSz + rLenSz + rSz, sLen, sLenSz);
s.Encode(output + seqSz + rLenSz + rSz + sLenSz, sSz);
return seqSz + rLenSz + rSz + sLenSz + sSz;
}
/* build PKCS#7 data content type */
int PKCS7_EncodeData(PKCS7* pkcs7, byte* output, word32 outputSz)
{
static const byte oid[] =
{ ASN_OBJECT_ID, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01,
0x07, 0x01 };
byte seq[MAX_SEQ_SZ];
byte octetStr[MAX_OCTET_STR_SZ];
word32 seqSz;
word32 octetStrSz;
word32 oidSz = (word32)sizeof(oid);
int idx = 0;
octetStrSz = SetOctetString(pkcs7->contentSz, octetStr);
seqSz = SetSequence(pkcs7->contentSz + octetStrSz + oidSz, seq);
if (outputSz < pkcs7->contentSz + octetStrSz + oidSz + seqSz)
return BUFFER_E;
XMEMCPY(output, seq, seqSz);
idx += seqSz;
XMEMCPY(output + idx, oid, oidSz);
idx += oidSz;
XMEMCPY(output + idx, octetStr, octetStrSz);
idx += octetStrSz;
XMEMCPY(output + idx, pkcs7->content, pkcs7->contentSz);
idx += pkcs7->contentSz;
return idx;
}
void CGrenadePathfollower::Spawn( void )
{
Precache( );
// -------------------------
// Inert when first spawned
// -------------------------
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_NONE );
AddFlag( FL_OBJECT ); // So can be shot down
AddEffects( EF_NODRAW );
UTIL_SetSize(this, Vector(0, 0, 0), Vector(0, 0, 0));
m_flDamage = sk_dmg_pathfollower_grenade.GetFloat();
m_DmgRadius = sk_pathfollower_grenade_radius.GetFloat();
m_takedamage = DAMAGE_YES;
m_iHealth = 200;
SetGravity( 0.00001 );
SetFriction( 0.8 );
SetSequence( 1 );
}
void CSatchelCharge::Spawn( void )
{
Precache( );
SetModel( "models/Weapons/w_slam.mdl" );
VPhysicsInitNormal( SOLID_BBOX, GetSolidFlags() | FSOLID_TRIGGER, false );
SetMoveType( MOVETYPE_VPHYSICS );
SetCollisionGroup( COLLISION_GROUP_WEAPON );
UTIL_SetSize(this, Vector( -6, -6, -2), Vector(6, 6, 2));
SetThink( &CSatchelCharge::SatchelThink );
SetNextThink( gpGlobals->curtime + 0.1f );
m_flDamage = sk_plr_dmg_satchel.GetFloat();
m_DmgRadius = sk_satchel_radius.GetFloat();
m_takedamage = DAMAGE_YES;
m_iHealth = 1;
SetGravity( UTIL_ScaleForGravity( 560 ) ); // slightly lower gravity
SetFriction( 1.0 );
SetSequence( 1 );
SetDamage( 150 );
m_bIsAttached = false;
m_bInAir = true;
m_flNextBounceSoundTime = 0;
m_vLastPosition = vec3_origin;
m_hGlowSprite = NULL;
CreateEffects();
}
void CSatchelCharge::Spawn( void )
{
Precache( );
// motor
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
SetSolid( SOLID_BBOX );
SetCollisionGroup( COLLISION_GROUP_PROJECTILE );
SetModel( "models/Weapons/w_slam.mdl" );
UTIL_SetSize(this, Vector( -6, -6, -2), Vector(6, 6, 2));
SetTouch( SatchelTouch );
SetUse( SatchelUse );
SetThink( SatchelThink );
SetNextThink( gpGlobals->curtime + 0.1f );
m_flDamage = sk_plr_dmg_satchel.GetFloat();
m_DmgRadius = sk_satchel_radius.GetFloat();
m_takedamage = DAMAGE_YES;
m_iHealth = 1;
SetGravity( UTIL_ScaleForGravity( 560 ) ); // slightly lower gravity
SetFriction( 1.0 );
SetSequence( 1 );
m_bIsAttached = false;
m_bInAir = true;
m_flSlideVolume = -1.0;
m_flNextBounceSoundTime = 0;
m_vLastPosition = vec3_origin;
InitSlideSound();
}
void CGrenadeMP5::Spawn( void )
{
Precache( );
SetSolid( SOLID_BBOX );
SetMoveType( MOVETYPE_FLY );
AddFlag( FL_GRENADE );
SetModel( "models/grenade.mdl" );
//UTIL_SetSize(this, Vector(-3, -3, -3), Vector(3, 3, 3));
UTIL_SetSize(this, Vector(0, 0, 0), Vector(0, 0, 0));
SetUse( &CBaseGrenade::DetonateUse );
SetTouch( &CGrenadeMP5::GrenadeMP5Touch );
SetNextThink( gpGlobals->curtime + 0.1f );
m_flDamage = sk_plr_dmg_mp5_grenade.GetFloat();
m_DmgRadius = sk_mp5_grenade_radius.GetFloat();
m_takedamage = DAMAGE_YES;
m_bIsLive = true;
m_iHealth = 1;
SetGravity( UTIL_ScaleForGravity( 400 ) ); // use a lower gravity for grenades to make them easier to see
SetFriction( 0.8 );
SetSequence( 0 );
m_fSpawnTime = gpGlobals->curtime;
}
bool StudioModel::PostLoadModel( const char *modelname )
{
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
CStudioHdr *pStudioHdr = GetStudioHdr();
if (pStudioHdr == NULL)
return false;
SetSequence (0);
SetController (0, 0.0f);
SetController (1, 0.0f);
SetController (2, 0.0f);
SetController (3, 0.0f);
SetBlendTime( DEFAULT_BLEND_TIME );
// SetHeadTurn( 1.0f ); // FIXME:!!!
int n;
for (n = 0; n < pStudioHdr->numbodyparts(); n++)
{
SetBodygroup (n, 0);
}
SetSkin (0);
/*
Vector mins, maxs;
ExtractBbox (mins, maxs);
if (mins[2] < 5.0f)
m_origin[2] = -mins[2];
*/
return true;
}
void CPropScalable::Spawn( void )
{
// Stomp our model name if we're the coreball (legacy)
if ( FClassnameIs( this, "prop_coreball" ) )
{
PrecacheModel( COREBALL_MODEL );
SetModel( COREBALL_MODEL );
}
else
{
char *szModel = (char *)STRING( GetModelName() );
if (!szModel || !*szModel)
{
Warning( "prop_scalable at %.0f %.0f %0.f missing modelname\n", GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z );
UTIL_Remove( this );
return;
}
PrecacheModel( szModel );
SetModel( szModel );
}
SetMoveType( MOVETYPE_NONE );
BaseClass::Spawn();
AddEffects( EF_NOSHADOW );
SetSequence( 0 );
SetPlaybackRate( 1.0f );
}
void CGEBloodScreenVM::SendViewModelMatchingSequence( int sequence )
{
SetSequence( sequence );
m_nAnimationParity = ( m_nAnimationParity + 1 ) & ( (1<<VIEWMODEL_ANIMATION_PARITY_BITS) - 1 );
SetCycle( 0 );
ResetSequenceInfo();
}
void CPropThumper::Spawn( void )
{
char *szModel = (char *)STRING( GetModelName() );
if (!szModel || !*szModel)
{
szModel = THUMPER_MODEL_NAME;
SetModelName( AllocPooledString(szModel) );
}
Precache();
SetModel( szModel );
SetSolid( SOLID_VPHYSICS );
SetMoveType( MOVETYPE_NONE );
VPhysicsInitStatic();
BaseClass::Spawn();
m_bEnabled = true;
SetThink( &CPropThumper::Think );
SetNextThink( gpGlobals->curtime + 1.0f );
int iSequence = SelectHeaviestSequence ( ACT_IDLE );
if ( iSequence != ACT_INVALID )
{
SetSequence( iSequence );
ResetSequenceInfo();
//Do this so we get the nice ramp-up effect.
m_flPlaybackRate = random->RandomFloat( 0.0f, 1.0f);
}
m_iHammerAttachment = LookupAttachment( "hammer" );
CAntlionRepellant *pRepellant = (CAntlionRepellant*)CreateEntityByName( "point_antlion_repellant" );
if ( pRepellant )
{
pRepellant->Spawn();
pRepellant->SetAbsOrigin( GetAbsOrigin() );
pRepellant->SetRadius( THUMPER_RADIUS );
m_hRepellantEnt = pRepellant;
}
if ( m_iDustScale == 0 )
m_iDustScale = THUMPER_MIN_SCALE;
#if HL2_EPISODIC
if ( m_iEffectRadius == 0 )
m_iEffectRadius = 1000;
#endif
}
bool Npc::Update() {
xPrev=x;
yPrev=y;
SetSequence(floor(direction)+4*(isMoving));
Image::Update();
sprShadow.setPosition(floor(x),floor(y));
locked=false;
MoveToChunk();
return true;
};
void KeyframeMeshInstance::SetSequence(const stl::string &name, bool loop)
{
if (m_currentSequenceName == name)
return;
const AnimationSequence *sequence = GetMesh()->GetAnimation(name);
ASSERT(sequence != NULL);
SetSequence(sequence->start, sequence->stop, loop);
m_currentSequenceName = name;
}
//-----------------------------------------------------------------------------
// Purpose: Make the grub angry!
//-----------------------------------------------------------------------------
void CAntlionGrub::InputAgitate( inputdata_t &inputdata )
{
SetSequence( SelectWeightedSequence( ACT_SMALL_FLINCH ) );
m_State = GRUB_STATE_AGITATED;
m_flNextSquealSoundTime = gpGlobals->curtime;
m_flFlinchTime = gpGlobals->curtime + inputdata.value.Float();
SetNextThink( gpGlobals->curtime );
}
//-----------------------------------------------------------------------------
// Purpose: Input that sets the sequence of the entity
//-----------------------------------------------------------------------------
void CEnvParticleScript::InputSetSequence( inputdata_t &inputdata )
{
if ( inputdata.value.StringID() != NULL_STRING )
{
int nSequence = LookupSequence( STRING( inputdata.value.StringID() ) );
if ( nSequence != ACT_INVALID )
{
SetSequence( nSequence );
}
}
}
//=========================================================
// ********** DeadBarney SPAWN **********
//=========================================================
void CNPC_DeadBarney::Spawn( void )
{
PrecacheModel("models/barneyhl1.mdl");
SetModel( "models/barneyhl1.mdl");
ClearEffects();
SetSequence( 0 );
m_bloodColor = BLOOD_COLOR_RED;
SetRenderColor( 255, 255, 255, 255 );
SetSequence( m_iDesiredSequence = LookupSequence( m_szPoses[m_iPose] ) );
if ( GetSequence() == -1 )
{
Msg ( "Dead barney with bad pose\n" );
}
// Corpses have less health
m_iHealth = 0.0;//gSkillData.barneyHealth;
NPCInitDead();
}