END_CLASS_STATES
//------------------------------------------------------------
// rvMonsterBossBuddy::State_Torso_RocketAttack
//------------------------------------------------------------
stateResult_t rvMonsterBossBuddy::State_Torso_RocketAttack( const stateParms_t& parms )
{
enum
{
STAGE_INIT,
STAGE_WAITSTART,
STAGE_LOOP,
STAGE_WAITLOOP,
STAGE_WAITEND
};
switch ( parms.stage )
{
case STAGE_INIT:
DisableAnimState( ANIMCHANNEL_LEGS );
PlayAnim( ANIMCHANNEL_TORSO, "attack_rocket2start", parms.blendFrames );
mShots = (gameLocal.random.RandomInt( 3 ) + 2) * combat.aggressiveScale;
return SRESULT_STAGE( STAGE_WAITSTART );
case STAGE_WAITSTART:
if ( AnimDone( ANIMCHANNEL_TORSO, 0 ))
{
return SRESULT_STAGE( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_LOOP:
PlayAnim( ANIMCHANNEL_TORSO, "attack_rocket2loop2", 0 );
return SRESULT_STAGE( STAGE_WAITLOOP );
case STAGE_WAITLOOP:
if ( AnimDone( ANIMCHANNEL_TORSO, 0 ))
{
if ( --mShots <= 0 || // exhausted mShots? .. or
(!IsEnemyVisible() && rvRandom::irand(0,10)>=8 ) || // ... player is no longer visible .. or
( enemy.ent && DistanceTo(enemy.ent)<256 ) ) // ... player is so close, we prolly want to do a melee attack
{
PlayAnim( ANIMCHANNEL_TORSO, "attack_rocket2end", 0 );
return SRESULT_STAGE( STAGE_WAITEND );
}
return SRESULT_STAGE( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_WAITEND:
if ( AnimDone( ANIMCHANNEL_TORSO, 4 ))
{
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvWeaponGauntlet::State_Fire
================
*/
stateResult_t rvWeaponGauntlet::State_Fire( const stateParms_t& parms ) {
enum {
STAGE_START,
STAGE_START_WAIT,
STAGE_LOOP,
STAGE_LOOP_WAIT,
STAGE_END,
STAGE_END_WAIT
};
switch ( parms.stage ) {
case STAGE_START:
PlayAnim( ANIMCHANNEL_ALL, "attack_start", parms.blendFrames );
StartBlade();
loopSound = LOOP_NONE;
// #32 - no gauntlet spin up
//return SRESULT_STAGE( STAGE_START_WAIT );
return SRESULT_STAGE( STAGE_LOOP );
case STAGE_START_WAIT:
if ( !wsfl.attack ) {
return SRESULT_STAGE( STAGE_END );
}
if ( AnimDone( ANIMCHANNEL_ALL, parms.blendFrames ) ) {
return SRESULT_STAGE( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_LOOP:
PlayCycle( ANIMCHANNEL_ALL, "attack_loop", parms.blendFrames );
StartSound( "snd_spin_loop", SND_CHANNEL_WEAPON, 0, false, 0 );
return SRESULT_STAGE(STAGE_LOOP_WAIT);
case STAGE_LOOP_WAIT:
if ( !wsfl.attack || wsfl.lowerWeapon ) {
return SRESULT_STAGE( STAGE_END );
}
Attack();
return SRESULT_WAIT;
case STAGE_END:
PlayAnim( ANIMCHANNEL_ALL, "attack_end", parms.blendFrames );
StopBlade();
StartSound( "snd_spin_down", SND_CHANNEL_WEAPON, 0, false, 0 );
return SRESULT_STAGE( STAGE_END_WAIT );
case STAGE_END_WAIT:
if ( wsfl.attack || AnimDone( ANIMCHANNEL_ALL, parms.blendFrames ) ) {
PostState( "Idle", parms.blendFrames );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
END_CLASS_STATES
/*
================
rvMonsterRepairBot::State_Legs_Move
================
*/
stateResult_t rvMonsterRepairBot::State_Legs_Move ( const stateParms_t& parms ) {
enum {
STAGE_START,
STAGE_START_WAIT,
STAGE_MOVE,
STAGE_MOVE_WAIT,
STAGE_STOP,
STAGE_STOP_WAIT
};
switch ( parms.stage ) {
case STAGE_START:
PlayAnim ( ANIMCHANNEL_LEGS, "idle_to_run", 4 );
return SRESULT_STAGE ( STAGE_START_WAIT );
case STAGE_START_WAIT:
if ( AnimDone ( ANIMCHANNEL_LEGS, 4 ) ) {
return SRESULT_STAGE ( STAGE_MOVE );
}
return SRESULT_WAIT;
case STAGE_MOVE:
PlayCycle ( ANIMCHANNEL_LEGS, "run", 4 );
return SRESULT_STAGE ( STAGE_MOVE_WAIT );
case STAGE_MOVE_WAIT:
if ( !move.fl.moving || !CanMove() ) {
return SRESULT_STAGE ( STAGE_STOP );
}
return SRESULT_WAIT;
case STAGE_STOP:
PlayAnim ( ANIMCHANNEL_LEGS, "run_to_idle", 4 );
return SRESULT_STAGE ( STAGE_STOP_WAIT );
case STAGE_STOP_WAIT:
if ( AnimDone ( ANIMCHANNEL_LEGS, 4 ) ) {
PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
void Torch::Update(Level& level, const sf::Time& timePassed)
{
light.Update(level);
if(IsActive() && !IsFinished()) {
light.Toggle();
isActive = false;
}
if(light.GetIsOn()) {
PlayAnim("on", timePassed);
} else {
PlayAnim("idle", timePassed);
}
}
/*
================
rvWeaponGrenadeLauncher::State_Reload
================
*/
stateResult_t WeaponNapalmGun::State_EmptyReload( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch ( parms.stage ) {
case STAGE_INIT:
if ( wsfl.netReload ) {
wsfl.netReload = false;
} else {
NetReload ( );
}
SetStatus ( WP_RELOAD );
PlayAnim ( ANIMCHANNEL_ALL, "reload_empty", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_ALL, 0 ) ) {
AddToClip ( ClipSize() );
cylinderState = CYLINDER_MOVE_POSITION;
SetState ( "Idle", 4 );
return SRESULT_DONE;
}
if ( wsfl.lowerWeapon ) {
SetState ( "Lower", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
END_CLASS_STATES
stateResult_t WeaponNapalmGun::State_Reload( const stateParms_t& parms) {
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch ( parms.stage ) {
case STAGE_INIT:
PlayAnim ( ANIMCHANNEL_ALL, "reload", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_ALL, 0 ) ) {
SetState ( "Idle", 4 );
return SRESULT_DONE;
}
if ( wsfl.lowerWeapon ) {
SetState ( "Lower", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterTurret::State_Torso_BlasterAttack
================
*/
stateResult_t rvMonsterTurret::State_Torso_BlasterAttack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_FIRE,
STAGE_WAIT,
};
switch ( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
shots = (minShots + gameLocal.random.RandomInt(maxShots-minShots+1)) * combat.aggressiveScale;
return SRESULT_STAGE ( STAGE_FIRE );
case STAGE_FIRE:
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack", 2 );
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 2 ) ) {
if ( --shots <= 0 ) {
return SRESULT_DONE;
}
return SRESULT_STAGE ( STAGE_FIRE );
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvWeaponMachinegun::State_Fire
================
*/
stateResult_t rvWeaponMachinegun::State_Fire ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch ( parms.stage ) {
case STAGE_INIT:
if ( wsfl.zoom ) {
nextAttackTime = gameLocal.time + (altFireRate * owner->PowerUpModifier ( PMOD_FIRERATE ));
Attack ( true, 1, spreadZoom, 0, 1.0f );
fireHeld = true;
} else {
nextAttackTime = gameLocal.time + (fireRate * owner->PowerUpModifier ( PMOD_FIRERATE ));
Attack ( false, 1, spread, 0, 1.0f );
}
PlayAnim ( ANIMCHANNEL_ALL, "fire", 0 );
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( !fireHeld && wsfl.attack && gameLocal.time >= nextAttackTime && AmmoInClip() && !wsfl.lowerWeapon ) {
SetState ( "Fire", 0 );
return SRESULT_DONE;
}
if ( AnimDone ( ANIMCHANNEL_ALL, 0 ) ) {
SetState ( "Idle", 0 );
return SRESULT_DONE;
}
if ( UpdateFlashlight ( ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterConvoyGround::State_Torso_BlasterAttack
================
*/
stateResult_t rvMonsterConvoyGround::State_Torso_BlasterAttack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_ATTACK,
STAGE_WAIT
};
switch ( parms.stage ) {
case STAGE_INIT:
shots = (gameLocal.random.RandomInt ( maxShots - minShots ) + minShots) * combat.aggressiveScale;
return SRESULT_STAGE ( STAGE_ATTACK );
case STAGE_ATTACK:
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack", parms.blendFrames );
shots--;
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
if ( --shots <= 0 || (IsEnemyVisible() && !enemy.fl.inFov) ) {
return SRESULT_DONE;
}
return SRESULT_STAGE ( STAGE_ATTACK );
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvWeaponMachinegun::State_Flashlight
================
*/
stateResult_t rvWeaponMachinegun::State_Flashlight ( const stateParms_t& parms ) {
enum {
FLASHLIGHT_INIT,
FLASHLIGHT_WAIT,
};
switch ( parms.stage ) {
case FLASHLIGHT_INIT:
SetStatus ( WP_FLASHLIGHT );
// Wait for the flashlight anim to play
PlayAnim( ANIMCHANNEL_ALL, "flashlight", 0 );
return SRESULT_STAGE ( FLASHLIGHT_WAIT );
case FLASHLIGHT_WAIT:
if ( !AnimDone ( ANIMCHANNEL_ALL, 4 ) ) {
return SRESULT_WAIT;
}
if ( owner->IsFlashlightOn() ) {
Flashlight ( false );
} else {
Flashlight ( true );
}
SetState ( "Idle", 4 );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
//------------------------------------------------------------
// rvMonsterBossBuddy::State_Torso_TurnLeft90
//------------------------------------------------------------
stateResult_t rvMonsterBossBuddy::State_Torso_TurnLeft90( const stateParms_t& parms )
{
enum
{
STAGE_INIT,
STAGE_WAIT
};
switch ( parms.stage )
{
case STAGE_INIT:
DisableAnimState( ANIMCHANNEL_LEGS );
PlayAnim( ANIMCHANNEL_TORSO, "turn_left", parms.blendFrames );
AnimTurn( 90.0f, true );
return SRESULT_STAGE( STAGE_WAIT );
case STAGE_WAIT:
if ( move.fl.moving || AnimDone( ANIMCHANNEL_TORSO, 0 ))
{
AnimTurn( 0, true );
combat.investigateTime = gameLocal.time + 250;
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
END_CLASS_STATES
/*
================
rvWeaponGauntlet::State_Raise
================
*/
stateResult_t rvWeaponGauntlet::State_Raise( const stateParms_t& parms ) {
enum {
RAISE_INIT,
RAISE_WAIT,
};
switch ( parms.stage ) {
case RAISE_INIT:
SetStatus( WP_RISING );
PlayAnim( ANIMCHANNEL_ALL, "raise", parms.blendFrames );
return SRESULT_STAGE( RAISE_WAIT );
case RAISE_WAIT:
if ( AnimDone( ANIMCHANNEL_ALL, 4 ) ) {
SetState( "Idle", 4 );
return SRESULT_DONE;
}
if ( wsfl.lowerWeapon ) {
SetState( "Lower", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvWeaponShotgun::State_Fire
================
*/
stateResult_t rvWeaponShotgun::State_Fire( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch ( parms.stage ) {
case STAGE_INIT:
nextAttackTime = gameLocal.time + (fireRate * owner->PowerUpModifier ( PMOD_FIRERATE ));
Attack( false, hitscans, spread, 0, 1.0f );
PlayAnim( ANIMCHANNEL_ALL, "fire", 0 );
return SRESULT_STAGE( STAGE_WAIT );
case STAGE_WAIT:
if ( (!gameLocal.isMultiplayer && (wsfl.lowerWeapon || AnimDone( ANIMCHANNEL_ALL, 0 )) ) || AnimDone( ANIMCHANNEL_ALL, 0 ) ) {
SetState( "Idle", 0 );
return SRESULT_DONE;
}
if ( wsfl.attack && gameLocal.time >= nextAttackTime && AmmoInClip() ) {
SetState( "Fire", 0 );
return SRESULT_DONE;
}
if ( clipSize ) {
if ( (wsfl.netReload || (wsfl.reload && AmmoInClip() < ClipSize() && AmmoAvailable()>AmmoInClip())) ) {
SetState( "Reload", 4 );
return SRESULT_DONE;
}
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
void Animate::ForwardExec( Event *ev )
{
str name = ev->GetString( 1 );
PlayAnim( name, 0 );
SetTime( 0, 0.0f );
}
/*
================
rvMonsterConvoyGround::State_Torso_Pain
================
*/
stateResult_t rvMonsterConvoyGround::State_Torso_Pain ( const stateParms_t& parms ) {
enum {
STAGE_START,
STAGE_END
};
switch ( parms.stage ) {
case STAGE_START:
// Force the orientation to the direction we got hit from so the animation looks correct
OverrideFlag ( AIFLAGOVERRIDE_NOTURN, true );
TurnToward ( physicsObj.GetOrigin() - lastPainDir * 128.0f );
move.current_yaw = move.ideal_yaw;
// Just in case the pain anim wasnt set before we got here.
if ( !painAnim.Length ( ) ) {
painAnim = "pain";
}
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, painAnim, parms.blendFrames );
return SRESULT_STAGE ( STAGE_END );
case STAGE_END:
if ( AnimDone ( ANIMCHANNEL_TORSO, parms.blendFrames ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterGrunt::State_Torso_LeapAttack
================
*/
stateResult_t rvMonsterGrunt::State_Torso_LeapAttack ( const stateParms_t& parms ) {
enum {
STAGE_ANIM,
STAGE_ANIM_WAIT,
};
switch ( parms.stage ) {
case STAGE_ANIM:
DisableAnimState ( ANIMCHANNEL_LEGS );
lastAttackTime = 0;
// Play the action animation
PlayAnim ( ANIMCHANNEL_TORSO, animator.GetAnim ( actionAnimNum )->FullName ( ), parms.blendFrames );
return SRESULT_STAGE ( STAGE_ANIM_WAIT );
case STAGE_ANIM_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, parms.blendFrames ) ) {
// If we missed our leap attack get angry
if ( !lastAttackTime && rageThreshold ) {
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Enrage", parms.blendFrames );
}
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvWeaponMachinegun::State_Reload
================
*/
stateResult_t rvWeaponMachinegun::State_Reload ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch ( parms.stage ) {
case STAGE_INIT:
if ( wsfl.netReload ) {
wsfl.netReload = false;
} else {
NetReload ( );
}
SetStatus ( WP_RELOAD );
PlayAnim ( ANIMCHANNEL_ALL, "reload", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_ALL, 4 ) ) {
AddToClip ( ClipSize() );
SetState ( "Idle", 4 );
return SRESULT_DONE;
}
if ( wsfl.lowerWeapon ) {
SetState ( "Lower", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvWeaponGauntlet::State_Lower
================
*/
stateResult_t rvWeaponGauntlet::State_Lower( const stateParms_t& parms ) {
enum {
LOWER_INIT,
LOWER_WAIT,
LOWER_WAITRAISE
};
switch ( parms.stage ) {
case LOWER_INIT:
SetStatus ( WP_LOWERING );
PlayAnim( ANIMCHANNEL_ALL, "lower", parms.blendFrames );
return SRESULT_STAGE(LOWER_WAIT);
case LOWER_WAIT:
if ( AnimDone ( ANIMCHANNEL_ALL, 0 ) ) {
SetStatus ( WP_HOLSTERED );
return SRESULT_STAGE(LOWER_WAITRAISE);
}
return SRESULT_WAIT;
case LOWER_WAITRAISE:
if ( wsfl.raiseWeapon ) {
SetState ( "Raise", 0 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
END_CLASS_STATES
/*
================
rvMonsterBerserker::State_Torso_ChargeAttack
================
*/
stateResult_t rvMonsterBerserker::State_Torso_ChargeAttack ( const stateParms_t& parms ) {
enum {
TORSO_CHARGEATTACK_INIT,
TORSO_CHARGEATTACK_WAIT,
TORSO_CHARGEATTACK_RECOVER,
TORSO_CHARGEATTACK_RECOVERWAIT
};
switch ( parms.stage ) {
// Start the charge attack animation
case TORSO_CHARGEATTACK_INIT:
// Full body animations
DisableAnimState ( ANIMCHANNEL_LEGS );
// Play the ground strike
PlayAnim ( ANIMCHANNEL_TORSO, "ground_strike", parms.blendFrames );
return SRESULT_STAGE ( TORSO_CHARGEATTACK_WAIT );
// Wait for charge attack animation to finish
case TORSO_CHARGEATTACK_WAIT:
if ( AnimDone ( ANIMCHANNEL_LEGS, 0 ) ) {
return SRESULT_STAGE ( TORSO_CHARGEATTACK_RECOVER );
}
return SRESULT_WAIT;
// Play recover animation
case TORSO_CHARGEATTACK_RECOVER:
PlayAnim ( ANIMCHANNEL_TORSO, "ground_strike_recover", parms.blendFrames );
return SRESULT_STAGE ( TORSO_CHARGEATTACK_RECOVERWAIT );
// Wait for recover animation to finish
case TORSO_CHARGEATTACK_RECOVERWAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 2 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
void Animate::PlayAnim( const char *name, int index )
{
int num = cgi.Anim_NumForName( tiki, name );
if( num != -1 ) {
PlayAnim( num, index );
}
}
void AnimationComponent::PlayAnim(const std::string& name, int flags)
{
unsigned int anim = FindAnim(name);
if (anim != NOT_FOUND)
{
PlayAnim(anim, flags);
}
}
void CModel::Load( const char * szFile )
{
CXMLElement * pModelXML = NULL;
g_pXMLWrapper->LoadXML( szFile, &pModelXML );
if ( !pModelXML )
return;
CXMLElement * pMeshXML = pModelXML->GetChild( "Mesh" );
if ( pMeshXML )
{
CXMLAttr * pMeshAttr = pMeshXML->GetAttr( "File" );
if ( pMeshAttr )
{
LoadObjects( pMeshAttr->GetValue() );
}
//----------------------------------------------------------------------
// Tip: Читаем материалы
//----------------------------------------------------------------------
for ( uint n = 0; n < pMeshXML->GetNumChilds(); ++n )
{
LoadMaterial( pMeshXML->GetChild( n ) );
}
}
//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
CXMLElement * pAnimXML = pModelXML->GetChild( "Animations" );
if ( pAnimXML )
{
for ( uint n = 0; n < pAnimXML->GetNumChilds(); ++n )
{
CXMLElement * pCurAnimXML = pAnimXML->GetChild( n );
CXMLAttr * pFileAttr = pCurAnimXML->GetAttr( "File" );
CXMLAttr * pNameAttr = pCurAnimXML->GetAttr( "Name" );
CAnim * pAnim = NEW CAnim;
if ( pAnim->Load( pFileAttr->GetValue() ) )
{
pAnim->SetName( pNameAttr->GetValue() );
AddAnim( pAnim );
PlayAnim( "test_anim" );
continue;
}
DEL( pAnim );
}
}
DEL( pModelXML );
}
END_CLASS_STATES
/*
================
rvMonsterConvoyGround::State_Fall
================
*/
stateResult_t rvMonsterConvoyGround::State_Fall ( const stateParms_t& parms ) {
enum {
STAGE_INIT, // Initialize fall stage
STAGE_WAITIMPACT, // Wait for the drop turret to hit the ground
STAGE_IMPACT, // Handle drop turret impact, switch to combat state
STAGE_WAITDONE,
STAGE_DONE
};
switch ( parms.stage ) {
case STAGE_INIT:
StopMove ( MOVE_STATUS_DONE );
StopAnimState ( ANIMCHANNEL_LEGS );
StopAnimState ( ANIMCHANNEL_TORSO );
StartSound ( "snd_falling", SND_CHANNEL_VOICE, 0, false, NULL );
PlayEffect ( "fx_droptrail", animator.GetJointHandle ( "origin" ), true );
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayCycle ( ANIMCHANNEL_TORSO, "idle", 0 );
oldOrigin = physicsObj.GetOrigin ( );
return SRESULT_STAGE(STAGE_WAITIMPACT);
case STAGE_WAITIMPACT:
if ( physicsObj.HasGroundContacts ( ) ) {
return SRESULT_STAGE(STAGE_IMPACT);
}
return SRESULT_WAIT;
case STAGE_IMPACT:
StopSound ( SND_CHANNEL_VOICE, false );
StopEffect ( "fx_droptrail" );
PlayEffect ( "fx_landing", GetPhysics()->GetOrigin(), (-GetPhysics()->GetGravityNormal()).ToMat3() );
if ( (physicsObj.GetOrigin ( ) - oldOrigin).LengthSqr() > Square(128.0f) ) {
PlayAnim ( ANIMCHANNEL_TORSO, "land", 0 );
return SRESULT_STAGE ( STAGE_WAITDONE );
}
return SRESULT_STAGE ( STAGE_DONE );
case STAGE_WAITDONE:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_STAGE ( STAGE_DONE );
}
return SRESULT_WAIT;
case STAGE_DONE:
onGround = true;
SetAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle" );
SetAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle" );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterStreamProtector::State_Torso_LightningAttack
================
*/
stateResult_t rvMonsterStreamProtector::State_Torso_LightningAttack ( const stateParms_t& parms ) {
enum {
STAGE_START,
STAGE_WAITSTART,
STAGE_LOOP,
STAGE_WAITLOOP,
STAGE_WAITEND
};
switch ( parms.stage ) {
case STAGE_START:
DisableAnimState ( ANIMCHANNEL_LEGS );
attackEndTime = gameLocal.time + 5000;
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_lightning_start", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAITSTART );
case STAGE_WAITSTART:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
return SRESULT_STAGE ( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_LOOP:
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_lightning_fire", 0 );
return SRESULT_STAGE ( STAGE_WAITLOOP );
case STAGE_WAITLOOP:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
if ( gameLocal.time > attackEndTime || (IsEnemyVisible() && !enemy.fl.inFov) ) {
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_lightning_end", 0 );
return SRESULT_STAGE ( STAGE_WAITEND );
}
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_lightning_fire", 0 );
return SRESULT_STAGE ( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_WAITEND:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterStreamProtector::State_Torso_BlasterAttack
================
*/
stateResult_t rvMonsterStreamProtector::State_Torso_BlasterAttack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAITSTART,
STAGE_LOOP,
STAGE_WAITLOOP,
STAGE_WAITEND
};
switch ( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "range_blaster_start", parms.blendFrames );
shots = (gameLocal.random.RandomInt ( 8 ) + 4) * combat.aggressiveScale;
return SRESULT_STAGE ( STAGE_WAITSTART );
case STAGE_WAITSTART:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
return SRESULT_STAGE ( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_LOOP:
PlayAnim ( ANIMCHANNEL_TORSO, "range_blaster_fire", 0 );
return SRESULT_STAGE ( STAGE_WAITLOOP );
case STAGE_WAITLOOP:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
if ( --shots <= 0 || (IsEnemyVisible() && !enemy.fl.inFov) ) {
PlayAnim ( ANIMCHANNEL_TORSO, "range_blaster_end", 0 );
return SRESULT_STAGE ( STAGE_WAITEND );
}
return SRESULT_STAGE ( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_WAITEND:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvVehicleDropPod::Event_ScriptedAnim
================
*/
void rvVehicleDropPod::Event_ScriptedAnim( const char* animname, int blendFrames, bool loop, bool endWithIdle ) {
vfl.endWithIdle = endWithIdle;
if ( loop ) {
PlayCycle ( ANIMCHANNEL_LEGS, animname, blendFrames );
} else {
PlayAnim ( ANIMCHANNEL_LEGS, animname, blendFrames );
}
SetAnimState ( ANIMCHANNEL_LEGS, "State_ScriptedAnim", blendFrames );
vfl.scripted = true;
}
void Stairs::Update(Level& level, const sf::Time& timePassed)
{
if(IsActive()) {
//The beginning of the end...
level.SetLevelTransition(nextLevel, nextSpawn);
isActive = false;
}
PlayAnim("idle", timePassed);
}
void tcColorCar(Car car)
{
LIST *colors, *bubble;
ubyte choice;
U32 costs;
Person marc = (Person) dbGetObject(Person_Marc_Smith);
costs = (U32)tcColorCosts(car);
bubble = txtGoKeyAndInsert(BUSINESS_TXT, "LACKIEREN", (U32) costs, NULL);
SetPictID(marc->PictID);
Bubble(bubble, 0, 0L, 0L);
RemoveList(bubble);
if (Say(BUSINESS_TXT, 0, MATT_PICTID, "LACKIEREN_ANT") == 0) {
colors = txtGoKey(OBJECTS_ENUM_TXT, "enum_ColorE");
txtPutCharacter(colors, 0, '*');
if (tcSpendMoney(costs, 1)) {
char exp[TXT_KEY_LENGTH];
txtGetFirstLine(BUSINESS_TXT, "NO_CHOICE", exp);
ExpandObjectList(colors, exp);
if (ChoiceOk
(choice =
Bubble(colors, (ubyte) car->ColorIndex, 0L, 0L), GET_OUT,
colors)) {
car->ColorIndex = (ubyte) choice;
SetCarColors(car->ColorIndex);
gfxPrepareRefresh();
PlayAnim("Umlackieren", 3000, GFX_DONT_SHOW_FIRST_PIC);
inpSetWaitTicks(200L);
inpWaitFor(INP_LBUTTONP | INP_TIME);
StopAnim();
inpSetWaitTicks(1L);
gfxRefresh();
/*gfxShow(26,GFX_NO_REFRESH|GFX_ONE_STEP,0L,-1L,-1L);*/
/*gfxShow((uword)car->PictID,GFX_NO_REFRESH|GFX_OVERLAY,1L,-1L,-1L);*/
}
}
RemoveList(colors);
}
AddVTime(137);
}
/*
================
WeaponNapalmGun::State_Fire
================
*/
stateResult_t WeaponNapalmGun::State_Fire( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch ( parms.stage ) {
case STAGE_INIT:
if ( wsfl.zoom ) {
nextAttackTime = gameLocal.time + (altFireRate * owner->PowerUpModifier ( PMOD_FIRERATE ));
Attack ( true, 1, spread, 0, 1.0f );
PlayAnim ( ANIMCHANNEL_ALL, "idle", parms.blendFrames );
//fireHeld = true;
} else {
nextAttackTime = gameLocal.time + (fireRate * owner->PowerUpModifier ( PMOD_FIRERATE ));
Attack ( false, 1, spread, 0, 1.0f );
int animNum = viewModel->GetAnimator()->GetAnim ( "fire" );
if ( animNum ) {
idAnim* anim;
anim = (idAnim*)viewModel->GetAnimator()->GetAnim ( animNum );
anim->SetPlaybackRate ( (float)anim->Length() / (fireRate * owner->PowerUpModifier ( PMOD_FIRERATE )) );
}
PlayAnim ( ANIMCHANNEL_ALL, "fire", parms.blendFrames );
}
previousAmmo = AmmoInClip();
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_ALL, 0 ) ) {
if ( !wsfl.zoom )
SetState ( "Reload", 4 );
else
SetState ( "Idle", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvTramGate::Event_Activate
================
*/
void rvTramGate::Event_Activate( idEntity* activator ) {
if( !IsDoorMasterValid() ) {
return;
}
// FIXME: may need some better logic than this.
const char* animName = (IsClosed()) ? "open" : (IsOpen()) ? "close" : NULL;
if( animName ) {
PlayAnim( ANIMCHANNEL_ALL, animName );
GetDoorMaster()->ProcessEvent( &EV_Activate, this );
}
}
