mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-16 08:10:32 +02:00
Justin Marshall
307 lines
13 KiB
C++
307 lines
13 KiB
C++
// AI_monster_boss_sabaoth.cpp
|
|
// Native state-machine replacement for ai_monster_boss_sabaoth.script.
|
|
|
|
#include "precompiled.h"
|
|
#pragma hdrstop
|
|
#include "../Game_local.h"
|
|
|
|
|
|
|
|
rvmMonsterBossSabaoth::rvmMonsterBossSabaoth() {
|
|
nextAttack = 0.0f;
|
|
nextMeleeAttack = 0.0f;
|
|
pathSpeed = 0.0f;
|
|
noSlowToStop = false;
|
|
currentPath = NULL;
|
|
nextPath = NULL;
|
|
}
|
|
|
|
void rvmMonsterBossSabaoth::Init( idAI* aiOwner ) {
|
|
rvmMonsterBase::Init( aiOwner );
|
|
SetMoveType( MOVETYPE_SLIDE );
|
|
SetState( "state_Begin" );
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::RunStateByName( const char* stateName, stateParms_t* parms ) {
|
|
AI_DISPATCH_STATE( "Torso_Idle", Torso_Idle );
|
|
AI_DISPATCH_STATE( "Torso_MeleeAttack", Torso_MeleeAttack );
|
|
AI_DISPATCH_STATE( "Torso_RangeAttack", Torso_RangeAttack );
|
|
AI_DISPATCH_STATE( "Legs_Idle", Legs_Idle );
|
|
AI_DISPATCH_STATE( "Legs_Walk", Legs_Walk );
|
|
AI_DISPATCH_STATE( "state_Killed", state_Killed );
|
|
AI_DISPATCH_STATE( "state_Begin", state_Begin );
|
|
AI_DISPATCH_STATE( "state_Idle", state_Idle );
|
|
AI_DISPATCH_STATE( "move_to_corner", move_to_corner );
|
|
AI_DISPATCH_STATE( "turn_to_corner", turn_to_corner );
|
|
AI_DISPATCH_STATE( "closeSection", closeSection );
|
|
AI_DISPATCH_STATE( "openSection", openSection );
|
|
AI_DISPATCH_STATE( "state_Combat", state_Combat );
|
|
AI_DISPATCH_STATE( "combat_range", combat_range );
|
|
AI_DISPATCH_STATE( "combat_melee", combat_melee );
|
|
AI_DISPATCH_STATE( "fire_bfg", fire_bfg );
|
|
AI_DISPATCH_STATE( "open_section_1", open_section_1 );
|
|
AI_DISPATCH_STATE( "close_section_1", close_section_1 );
|
|
AI_DISPATCH_STATE( "open_section_2", open_section_2 );
|
|
AI_DISPATCH_STATE( "close_section_2", close_section_2 );
|
|
AI_DISPATCH_STATE( "open_section_3", open_section_3 );
|
|
AI_DISPATCH_STATE( "close_section_3", close_section_3 );
|
|
AI_DISPATCH_STATE( "open_section_4", open_section_4 );
|
|
AI_DISPATCH_STATE( "close_section_4", close_section_4 );
|
|
AI_DISPATCH_STATE( "open_section_5", open_section_5 );
|
|
AI_DISPATCH_STATE( "close_section_5", close_section_5 );
|
|
AI_DISPATCH_STATE( "open_section_6", open_section_6 );
|
|
AI_DISPATCH_STATE( "close_section_6", close_section_6 );
|
|
AI_DISPATCH_STATE( "open_section_7", open_section_7 );
|
|
AI_DISPATCH_STATE( "close_section_7", close_section_7 );
|
|
AI_DISPATCH_STATE( "open_section_8", open_section_8 );
|
|
AI_DISPATCH_STATE( "close_section_8", close_section_8 );
|
|
return rvmMonsterBase::RunStateByName( stateName, parms );
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::Torso_Idle( stateParms_t* parms ) {
|
|
if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_TORSO, "stand" ); parms->stage = 1; }
|
|
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 4 ); return SRESULT_DONE; }
|
|
return SRESULT_WAIT;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::Torso_MeleeAttack( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_RUNNING };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
FaceEnemy();
|
|
AllowMovement( false );
|
|
PlayAnim( ANIMCHANNEL_TORSO, "melee_attack" );
|
|
parms->stage = STAGE_RUNNING;
|
|
return SRESULT_WAIT;
|
|
case STAGE_RUNNING:
|
|
if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) {
|
|
AllowMovement( true );
|
|
FinishAction( "melee_attack" );
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_WAIT;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::Torso_RangeAttack( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_RUNNING };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
FaceEnemy();
|
|
AllowMovement( false );
|
|
PlayAnim( ANIMCHANNEL_TORSO, "range_attack" );
|
|
parms->stage = STAGE_RUNNING;
|
|
return SRESULT_WAIT;
|
|
case STAGE_RUNNING:
|
|
if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) {
|
|
AllowMovement( true );
|
|
FinishAction( "range_attack" );
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_WAIT;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::Legs_Idle( stateParms_t* parms ) {
|
|
if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_LEGS, "idle" ); parms->stage = 1; }
|
|
if ( MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Walk", 4 ); return SRESULT_DONE; }
|
|
return SRESULT_WAIT;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::Legs_Walk( stateParms_t* parms ) {
|
|
if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_LEGS, "walk" ); parms->stage = 1; }
|
|
if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 4 ); return SRESULT_DONE; }
|
|
return SRESULT_WAIT;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::state_Killed( stateParms_t* parms ) {
|
|
return rvmMonsterBase::state_Killed( parms );
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::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_SLIDE );
|
|
SetState( "state_Idle" );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::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 = DelayTime( 1.0f );
|
|
nextMeleeAttack = 0.0f;
|
|
SetState( "state_Combat" );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::move_to_corner( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_WAIT };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
if ( scratchEntity.GetEntity() ) { MoveToEntity( scratchEntity.GetEntity() ); } else { MoveToEnemy(); }
|
|
SetAnimState( ANIMCHANNEL_LEGS, "Legs_Walk", 4 );
|
|
parms->stage = STAGE_WAIT;
|
|
return SRESULT_WAIT;
|
|
case STAGE_WAIT:
|
|
if ( check_attacks( false ) != 0 ) { return SRESULT_DONE; }
|
|
if ( !MoveDone() ) { return SRESULT_WAIT; }
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::turn_to_corner( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_WAIT };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
if ( scratchEntity.GetEntity() ) { FaceEntity( scratchEntity.GetEntity() ); } else { FaceEnemy(); }
|
|
parms->stage = STAGE_WAIT;
|
|
return SRESULT_WAIT;
|
|
case STAGE_WAIT:
|
|
if ( check_attacks( false ) != 0 ) { return SRESULT_DONE; }
|
|
if ( !FacingIdeal() ) { return SRESULT_WAIT; }
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::closeSection( stateParms_t* parms ) {
|
|
// Native hook for the map section-close target dispatch used by the script.
|
|
return SRESULT_DONE;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::openSection( stateParms_t* parms ) {
|
|
// Native hook for the map section-open target dispatch used by the script.
|
|
return SRESULT_DONE;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::state_Combat( stateParms_t* parms ) {
|
|
enum { STAGE_SELECT, STAGE_ACTION };
|
|
switch ( parms->stage ) {
|
|
case STAGE_SELECT:
|
|
if ( EnemyDead() ) { SetState( "state_LostCombat" ); return SRESULT_DONE; }
|
|
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); }
|
|
if ( do_attack( check_attacks( false ) ) ) { parms->stage = STAGE_ACTION; return SRESULT_WAIT; }
|
|
if ( !MoveDone() ) { return SRESULT_WAIT; }
|
|
MoveToEnemy();
|
|
return SRESULT_WAIT;
|
|
case STAGE_ACTION:
|
|
if ( InAction() ) { return SRESULT_WAIT; }
|
|
parms->stage = STAGE_SELECT;
|
|
return SRESULT_WAIT;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
int rvmMonsterBossSabaoth::check_attacks( bool meleeOnly ) {
|
|
int flags = 0;
|
|
if ( CheckForMelee() && Time() >= nextMeleeAttack ) { flags |= ATTACK_MELEE; }
|
|
if ( !meleeOnly && Time() >= nextAttack && CanHitEnemyFromAnim( "range_attack" ) ) { flags |= ATTACK_MISSILE; }
|
|
return static_cast<float>( flags );
|
|
}
|
|
|
|
int rvmMonsterBossSabaoth::check_attacks() {
|
|
return check_attacks( false );
|
|
}
|
|
|
|
bool rvmMonsterBossSabaoth::do_attack( int attack_flags ) {
|
|
const int flags = attack_flags;
|
|
if ( flags & ATTACK_MELEE ) { StartAction( "combat_melee" ); return true; }
|
|
if ( flags & ATTACK_MISSILE ) { StartAction( "combat_range" ); return true; }
|
|
return false;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::combat_range( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_ACTION };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
StopMove();
|
|
FaceEnemy();
|
|
waitActionName = "range_attack";
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_RangeAttack", 4 );
|
|
parms->stage = STAGE_ACTION;
|
|
return SRESULT_WAIT;
|
|
case STAGE_ACTION:
|
|
if ( !ActionDone( "range_attack" ) ) { return SRESULT_WAIT; }
|
|
nextAttack = DelayTime( SABAOTH_ATTACK_RATE );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::combat_melee( stateParms_t* parms ) {
|
|
enum { STAGE_START, STAGE_ACTION };
|
|
switch ( parms->stage ) {
|
|
case STAGE_START:
|
|
StopMove();
|
|
FaceEnemy();
|
|
waitActionName = "melee_attack";
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_MeleeAttack", 4 );
|
|
parms->stage = STAGE_ACTION;
|
|
return SRESULT_WAIT;
|
|
case STAGE_ACTION:
|
|
if ( !ActionDone( "melee_attack" ) ) { return SRESULT_WAIT; }
|
|
nextMeleeAttack = DelayTime( SABAOTH_ATTACK_RATE_MELEE );
|
|
return SRESULT_DONE;
|
|
}
|
|
return SRESULT_ERROR;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::fire_bfg( stateParms_t* parms ) {
|
|
AttackMissile( "bfg" );
|
|
return SRESULT_DONE;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::set_section_open( stateParms_t* parms, int section, bool open ) {
|
|
// Hook point for firing section-specific map targets. section is 1-8, open selects open/close.
|
|
scratchCount = section;
|
|
return SRESULT_DONE;
|
|
}
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::open_section_1( stateParms_t* parms ) { return set_section_open( parms, 1, true ); }
|
|
stateResult_t rvmMonsterBossSabaoth::close_section_1( stateParms_t* parms ) { return set_section_open( parms, 1, false ); }
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::open_section_2( stateParms_t* parms ) { return set_section_open( parms, 2, true ); }
|
|
stateResult_t rvmMonsterBossSabaoth::close_section_2( stateParms_t* parms ) { return set_section_open( parms, 2, false ); }
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::open_section_3( stateParms_t* parms ) { return set_section_open( parms, 3, true ); }
|
|
stateResult_t rvmMonsterBossSabaoth::close_section_3( stateParms_t* parms ) { return set_section_open( parms, 3, false ); }
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::open_section_4( stateParms_t* parms ) { return set_section_open( parms, 4, true ); }
|
|
stateResult_t rvmMonsterBossSabaoth::close_section_4( stateParms_t* parms ) { return set_section_open( parms, 4, false ); }
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::open_section_5( stateParms_t* parms ) { return set_section_open( parms, 5, true ); }
|
|
stateResult_t rvmMonsterBossSabaoth::close_section_5( stateParms_t* parms ) { return set_section_open( parms, 5, false ); }
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::open_section_6( stateParms_t* parms ) { return set_section_open( parms, 6, true ); }
|
|
stateResult_t rvmMonsterBossSabaoth::close_section_6( stateParms_t* parms ) { return set_section_open( parms, 6, false ); }
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::open_section_7( stateParms_t* parms ) { return set_section_open( parms, 7, true ); }
|
|
stateResult_t rvmMonsterBossSabaoth::close_section_7( stateParms_t* parms ) { return set_section_open( parms, 7, false ); }
|
|
|
|
stateResult_t rvmMonsterBossSabaoth::open_section_8( stateParms_t* parms ) { return set_section_open( parms, 8, true ); }
|
|
stateResult_t rvmMonsterBossSabaoth::close_section_8( stateParms_t* parms ) { return set_section_open( parms, 8, false ); }
|