id-software/DoomRTX
1
0
Fork 0
mirror of https://github.com/jmarshall23/DoomRTX.git synced 2026-08-16 08:10:32 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
3b222499ca22fe56db0b011fdfbab1b75e893d64
DoomRTX/neo/doom3/game/ai/AI_monster_demon_revenant.cpp
T
Justin Marshall 293942d07c TypeInfoGen will now autobind doom scripts.
2026-05-23 20:50:12 -07:00

309 lines
12 KiB
C++
Raw Blame History

// AI_monster_demon_revenant.cpp
// Native state-machine replacement for ai_monster_demon_revenant.script.
#include "precompiled.h"
#pragma hdrstop
#include "../Game_local.h"
rvmMonsterDemonRevenant::rvmMonsterDemonRevenant() {
nextDodge = 0.0f;
nextAttack = 0.0f;
nextNoFOVAttack = 0.0f;
nextLeap = 0.0f;
painNextTime = 0.0f;
jumpVelocity = vec3_zero;
combat_node = NULL;
}
void rvmMonsterDemonRevenant::Init( idAI* aiOwner ) {
rvmMonsterBase::Init( aiOwner );
walk_turn = REV_WALKTURN;
SetState( "state_Begin" );
}
stateResult_t rvmMonsterDemonRevenant::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( "Legs_DodgeLeft", Legs_DodgeLeft );
AI_DISPATCH_STATE( "Legs_DodgeRight", Legs_DodgeRight );
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 );
AI_DISPATCH_STATE( "combat_dodge_left", combat_dodge_left );
AI_DISPATCH_STATE( "combat_dodge_right", combat_dodge_right );
return rvmMonsterBase::RunStateByName( stateName, parms );
}
stateResult_t rvmMonsterDemonRevenant::Torso_Idle( stateParms_t* parms ) {
if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_TORSO, "idle" ); parms->stage = 1; }
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 2 ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
stateResult_t rvmMonsterDemonRevenant::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", 7 ); return SRESULT_DONE; }
if ( AnimDone( ANIMCHANNEL_TORSO, 7 ) ) {
FinishAction( "pain" );
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 7 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonRevenant::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 rvmMonsterDemonRevenant::Torso_RangeAttack( stateParms_t* parms ) {
enum { STAGE_START, STAGE_RUNNING };
switch ( parms->stage ) {
case STAGE_START:
PreventPain( 1.0f );
FaceEnemy();
PlayAnim( ANIMCHANNEL_TORSO, range_attack_anim.c_str() );
parms->stage = STAGE_RUNNING;
return SRESULT_WAIT;
case STAGE_RUNNING:
LookAtEnemy( 1.0f );
if ( AnimDone( ANIMCHANNEL_TORSO, 2 ) ) {
AllowMovement( true );
FinishAction( "range_attack" );
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 2 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonRevenant::Torso_TurretAttack( stateParms_t* parms ) {
enum { STAGE_START, STAGE_RUNNING };
switch ( parms->stage ) {
case STAGE_START:
AllowMovement( false );
PreventPain( 1.0f );
FaceEnemy();
PlayAnim( ANIMCHANNEL_TORSO, "turret_attack" );
parms->stage = STAGE_RUNNING;
return SRESULT_WAIT;
case STAGE_RUNNING:
FaceEnemy();
if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) {
AllowMovement( true );
FinishAction( "turret_attack" );
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonRevenant::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 rvmMonsterDemonRevenant::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 rvmMonsterDemonRevenant::Legs_DodgeLeft( stateParms_t* parms ) {
if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_LEGS, "evade_left" ); parms->stage = 1; }
if ( AnimDone( ANIMCHANNEL_LEGS, 4 ) ) { FinishAction( "strafe" ); SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 4 ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
stateResult_t rvmMonsterDemonRevenant::Legs_DodgeRight( stateParms_t* parms ) {
if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_LEGS, "evade_right" ); parms->stage = 1; }
if ( AnimDone( ANIMCHANNEL_LEGS, 4 ) ) { FinishAction( "strafe" ); SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 4 ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
stateResult_t rvmMonsterDemonRevenant::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 rvmMonsterDemonRevenant::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;
nextDodge = RandomTime( REV_DODGE_RATE );
nextLeap = 0.0f;
SetState( "state_Combat" );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
int rvmMonsterDemonRevenant::check_attacks() {
int flags = 0;
const bool canMelee = CheckForMelee();
const float currentTime = Time();
if ( !canMelee && Pain() && currentTime >= nextDodge ) {
if ( TestAnimMove( "evade_left" ) ) { flags |= ATTACK_DODGE_LEFT; }
if ( TestAnimMove( "evade_right" ) ) {
flags |= ATTACK_DODGE_RIGHT;
if ( flags & ATTACK_DODGE_LEFT ) {
if ( RandomFloat( 100.0f ) < 50.0f ) { flags &= ~ATTACK_DODGE_RIGHT; } else { flags &= ~ATTACK_DODGE_LEFT; }
}
}
}
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() || currentTime >= nextAttack ) {
range_attack_anim = ChooseAnim( ANIMCHANNEL_LEGS, "turret_attack" );
if ( CanHitEnemyFromAnim( range_attack_anim.c_str() ) ) { flags |= ATTACK_MISSILE; }
const char* movingAnim = ChooseAnim( ANIMCHANNEL_LEGS, "range_attack" );
if ( TestAnimMoveTowardEnemy( movingAnim ) && CanHitEnemyFromAnim( movingAnim ) ) {
range_attack_anim = movingAnim;
flags |= ATTACK_MISSILE;
}
}
}
return static_cast<float>( flags );
}
bool rvmMonsterDemonRevenant::do_attack( int attack_flags ) {
nextNoFOVAttack = Time() + REV_NOFOVTIME;
const int flags = attack_flags;
if ( flags & ATTACK_DODGE_LEFT ) { StartAction( "combat_dodge_left" ); return true; }
if ( flags & ATTACK_DODGE_RIGHT ) { StartAction( "combat_dodge_right" ); return true; }
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 rvmMonsterDemonRevenant::combat_range( stateParms_t* parms ) {
enum { STAGE_START, STAGE_ACTION };
switch ( parms->stage ) {
case STAGE_START:
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( REV_ATTACK_RATE );
nextNoFOVAttack = Time() + REV_NOFOVTIME;
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonRevenant::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;
}
stateResult_t rvmMonsterDemonRevenant::combat_dodge_left( stateParms_t* parms ) {
enum { STAGE_START, STAGE_ACTION };
switch ( parms->stage ) {
case STAGE_START:
FaceEnemy();
StopMove();
waitActionName = "strafe";
SetAnimState( ANIMCHANNEL_LEGS, "Legs_DodgeLeft", 2 );
parms->stage = STAGE_ACTION;
return SRESULT_WAIT;
case STAGE_ACTION:
if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
nextDodge = DelayTime( REV_DODGE_RATE );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonRevenant::combat_dodge_right( stateParms_t* parms ) {
enum { STAGE_START, STAGE_ACTION };
switch ( parms->stage ) {
case STAGE_START:
FaceEnemy();
StopMove();
waitActionName = "strafe";
SetAnimState( ANIMCHANNEL_LEGS, "Legs_DodgeRight", 2 );
parms->stage = STAGE_ACTION;
return SRESULT_WAIT;
case STAGE_ACTION:
if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
nextDodge = DelayTime( REV_DODGE_RATE );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
Reference in New Issue View Git Blame Copy Permalink