mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-17 11:00:38 +02:00
Justin Marshall
246 lines
10 KiB
C++
246 lines
10 KiB
C++
// AI_monster_demon_mancubus.cpp
|
|
// Native state-machine replacement for ai_monster_demon_mancubus.script.
|
|
|
|
#include "precompiled.h"
|
|
#pragma hdrstop
|
|
#include "../Game_local.h"
|
|
|
|
|
|
|
|
rvmMonsterDemonMancubus::rvmMonsterDemonMancubus() {
|
|
nextAttack = 0.0f;
|
|
nextNoFOVAttack = 0.0f;
|
|
fire = 0.0f;
|
|
painNextTime = 0.0f;
|
|
combat_node = NULL;
|
|
}
|
|
|
|
void rvmMonsterDemonMancubus::Init( idAI* aiOwner ) {
|
|
rvmMonsterBase::Init( aiOwner );
|
|
walk_turn = MANC_WALKTURN;
|
|
SetState( "state_Begin" );
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::RunStateByName( const char* stateName, stateParms_t* parms ) {
|
|
AI_DISPATCH_STATE( "Torso_Idle", Torso_Idle );
|
|
AI_DISPATCH_STATE( "Torso_Pain", Torso_Pain );
|
|
AI_DISPATCH_STATE( "Torso_MeleeAttack", Torso_MeleeAttack );
|
|
AI_DISPATCH_STATE( "Torso_RangeAttack", Torso_RangeAttack );
|
|
AI_DISPATCH_STATE( "Torso_TurretAttack", Torso_TurretAttack );
|
|
AI_DISPATCH_STATE( "Legs_Idle", Legs_Idle );
|
|
AI_DISPATCH_STATE( "Legs_Walk", Legs_Walk );
|
|
AI_DISPATCH_STATE( "state_Begin", state_Begin );
|
|
AI_DISPATCH_STATE( "state_Idle", state_Idle );
|
|
AI_DISPATCH_STATE( "combat_range", combat_range );
|
|
AI_DISPATCH_STATE( "combat_melee", combat_melee );
|
|
return rvmMonsterBase::RunStateByName( stateName, parms );
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::Torso_Idle( stateParms_t* parms ) {
|
|
if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_TORSO, "stand" ); parms->stage = 1; }
|
|
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 ); return SRESULT_DONE; }
|
|
if ( fire > 0.0f ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_RangeAttack", 4 ); return SRESULT_DONE; }
|
|
return SRESULT_WAIT;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::Torso_Pain( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_RUNNING };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
PlayAnim( ANIMCHANNEL_TORSO, GetPainAnim() );
|
|
painNextTime = DelayTime( 0.25f );
|
|
parms->stage = STAGE_RUNNING;
|
|
return SRESULT_WAIT;
|
|
case STAGE_RUNNING:
|
|
if ( Pain() && Time() > painNextTime ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 ); return SRESULT_DONE; }
|
|
if ( AnimDone( ANIMCHANNEL_TORSO, 8 ) ) {
|
|
FinishAction( "pain" );
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 8 );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_WAIT;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::Torso_MeleeAttack( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_RUNNING };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
PlayAnim( ANIMCHANNEL_TORSO, "melee_attack" );
|
|
parms->stage = STAGE_RUNNING;
|
|
return SRESULT_WAIT;
|
|
case STAGE_RUNNING:
|
|
if ( AnimDone( ANIMCHANNEL_TORSO, 2 ) ) {
|
|
FinishAction( "melee_attack" );
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 2 );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_WAIT;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::Torso_RangeAttack( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_START_WAIT, STAGE_LOOP_START, STAGE_LOOP_WAIT, STAGE_END, STAGE_END_WAIT };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
PlayAnim( ANIMCHANNEL_TORSO, "range_attack_start" );
|
|
parms->stage = STAGE_START_WAIT;
|
|
return SRESULT_WAIT;
|
|
case STAGE_START_WAIT:
|
|
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 ); return SRESULT_DONE; }
|
|
if ( !AnimDone( ANIMCHANNEL_TORSO, 0 ) ) { return SRESULT_WAIT; }
|
|
parms->stage = STAGE_LOOP_START;
|
|
return SRESULT_WAIT;
|
|
case STAGE_LOOP_START:
|
|
if ( fire <= 0.0f ) { parms->stage = STAGE_END; return SRESULT_WAIT; }
|
|
PlayAnim( ANIMCHANNEL_TORSO, "range_attack_loop" );
|
|
parms->stage = STAGE_LOOP_WAIT;
|
|
return SRESULT_WAIT;
|
|
case STAGE_LOOP_WAIT:
|
|
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 ); return SRESULT_DONE; }
|
|
if ( !AnimDone( ANIMCHANNEL_TORSO, 0 ) ) { return SRESULT_WAIT; }
|
|
fire -= 1.0f;
|
|
parms->stage = STAGE_LOOP_START;
|
|
return SRESULT_WAIT;
|
|
case STAGE_END:
|
|
fire = 0.0f;
|
|
if ( !AnimDone( ANIMCHANNEL_TORSO, 0 ) ) { SetBlendFrames( ANIMCHANNEL_TORSO, 4 ); }
|
|
PlayAnim( ANIMCHANNEL_TORSO, "range_attack_end" );
|
|
parms->stage = STAGE_END_WAIT;
|
|
return SRESULT_WAIT;
|
|
case STAGE_END_WAIT:
|
|
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 ); return SRESULT_DONE; }
|
|
if ( AnimDone( ANIMCHANNEL_TORSO, 0 ) ) { FinishAction( "range_attack" ); SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 0 ); return SRESULT_DONE; }
|
|
return SRESULT_WAIT;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::Torso_TurretAttack( stateParms_t* parms ) {
|
|
// Uses the same staged burst sequence as Torso_RangeAttack, but completes the turret action token.
|
|
stateResult_t r = Torso_RangeAttack( parms );
|
|
if ( r == SRESULT_DONE ) { FinishAction( "turret_attack" ); SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); }
|
|
return r;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::Legs_Idle( stateParms_t* parms ) {
|
|
if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_LEGS, "stand" ); parms->stage = 1; }
|
|
if ( MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Walk", 2 ); return SRESULT_DONE; }
|
|
return SRESULT_WAIT;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::Legs_Walk( stateParms_t* parms ) {
|
|
if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_LEGS, "walk" ); parms->stage = 1; }
|
|
if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 2 ); return SRESULT_DONE; }
|
|
return SRESULT_WAIT;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::state_Begin( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_MONSTER_BEGIN };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 0 );
|
|
SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 0 );
|
|
StartAction( "monster_begin" );
|
|
parms->stage = STAGE_MONSTER_BEGIN;
|
|
return SRESULT_WAIT;
|
|
case STAGE_MONSTER_BEGIN:
|
|
if ( InAction() ) { return SRESULT_WAIT; }
|
|
SetMoveType( MOVETYPE_ANIM );
|
|
SetState( "state_Idle" );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::state_Idle( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_WAIT_FOR_ENEMY };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
StartAction( "wait_for_enemy" );
|
|
parms->stage = STAGE_WAIT_FOR_ENEMY;
|
|
return SRESULT_WAIT;
|
|
case STAGE_WAIT_FOR_ENEMY:
|
|
if ( InAction() ) { return SRESULT_WAIT; }
|
|
nextAttack = 0.0f;
|
|
nextNoFOVAttack = 0.0f;
|
|
SetState( "state_Combat" );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
int rvmMonsterDemonMancubus::check_attacks() {
|
|
int flags = 0;
|
|
const bool canMelee = CheckForMelee();
|
|
if ( !canMelee ) { combat_node = GetCombatNode(); if ( combat_node.GetEntity() ) { flags |= ATTACK_COMBAT_NODE; } }
|
|
if ( canMelee ) { flags |= ATTACK_MELEE; }
|
|
if ( ( Time() > nextNoFOVAttack && EnemyVisible() ) || EnemyInFOV() ) {
|
|
if ( !CanReachEnemy() || Time() >= nextAttack ) {
|
|
if ( CanHitEnemyFromAnim( "range_attack_loop" ) ) { flags |= ATTACK_MISSILE; }
|
|
}
|
|
}
|
|
return static_cast<float>( flags );
|
|
}
|
|
|
|
bool rvmMonsterDemonMancubus::do_attack( int attack_flags ) {
|
|
nextNoFOVAttack = Time() + MANC_NOFOVTIME;
|
|
const int flags = attack_flags;
|
|
if ( flags & ATTACK_COMBAT_NODE ) { scratchEntity = combat_node.GetEntity(); StartAction( "combat_ainode" ); return true; }
|
|
if ( flags & ATTACK_MELEE ) { StartAction( "combat_melee" ); return true; }
|
|
if ( flags & ATTACK_MISSILE ) { StartAction( "combat_range" ); return true; }
|
|
return false;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::combat_range( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_DELAY, STAGE_FIRE, STAGE_FINISH };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
FaceEnemy();
|
|
scratchEndTime = EnemyInFOV() ? Time() : DelayTime( 0.4f );
|
|
parms->stage = STAGE_DELAY;
|
|
return SRESULT_WAIT;
|
|
case STAGE_DELAY:
|
|
if ( Time() < scratchEndTime ) { return SRESULT_WAIT; }
|
|
fire = MANC_MIN_SHOTS + idMath::Ftoi( RandomFloat( MANC_MAX_SHOTS - MANC_MIN_SHOTS ) );
|
|
waitActionName = "range_attack";
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_RangeAttack", 4 );
|
|
parms->stage = STAGE_FIRE;
|
|
return SRESULT_WAIT;
|
|
case STAGE_FIRE:
|
|
if ( fire > 0.0f ) {
|
|
if ( !CanHitEnemyFromAnim( "range_attack_loop" ) ) { fire = 0.0f; }
|
|
if ( Pain() && ( check_attacks() & ATTACK_MELEE ) ) { fire = 0.0f; }
|
|
return SRESULT_WAIT;
|
|
}
|
|
parms->stage = STAGE_FINISH;
|
|
return SRESULT_WAIT;
|
|
case STAGE_FINISH:
|
|
if ( InAnimState( ANIMCHANNEL_TORSO, "Torso_RangeAttack" ) ) { return SRESULT_WAIT; }
|
|
nextAttack = DelayTime( MANC_ATTACK_RATE );
|
|
nextNoFOVAttack = Time() + MANC_NOFOVTIME;
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterDemonMancubus::combat_melee( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_ACTION };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
LookAtEnemy( 100.0f );
|
|
FaceEnemy();
|
|
waitActionName = "melee_attack";
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_MeleeAttack", 5 );
|
|
parms->stage = STAGE_ACTION;
|
|
return SRESULT_WAIT;
|
|
case STAGE_ACTION:
|
|
if ( !ActionDone( "melee_attack" ) ) { return SRESULT_WAIT; }
|
|
LookAtEnemy( 1.0f );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|