DoomRTX/neo/doom3/game/ai/AI_monster_demon_archvile.cpp

// AI_monster_demon_archvile.cpp
    // Native state-machine replacement for ai_monster_demon_archvile.script.

#include "precompiled.h"
#pragma hdrstop
#include "../Game_local.h"



    rvmMonsterDemonArchvile::rvmMonsterDemonArchvile() {
    nextDodge = 0.0f;
    nextAttack = 0.0f;
    nextNoFOVAttack = 0.0f;
    painNextTime = 0.0f;
    keep_alive = 0.0f;
    num_start = 0.0f;
    summon_delay = 0.0f;
    summon_time = 0.0f;
    combat_node = NULL;
    resurrectionTarget = NULL;
    flameWallOrigin = vec3_zero;
    incinerateOrigin = vec3_zero;
}

void rvmMonsterDemonArchvile::Init( idAI* aiOwner ) {
    rvmMonsterBase::Init( aiOwner );
    keep_alive = GetFloatKey( "keep_alive", "0" );
    num_start = GetFloatKey( "num_start", "0" );
    summon_delay = GetFloatKey( "summon_delay", "0" );
    summon_time = Time() + summon_delay;
    SetState( "state_Begin" );
}

stateResult_t rvmMonsterDemonArchvile::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_Resurrect", Torso_Resurrect );
    AI_DISPATCH_STATE( "Torso_MeleeAttack", Torso_MeleeAttack );
    AI_DISPATCH_STATE( "Torso_FlameWallAttack", Torso_FlameWallAttack );
    AI_DISPATCH_STATE( "Torso_IncinerateAttack", Torso_IncinerateAttack );
    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_resurrect", combat_resurrect );
    AI_DISPATCH_STATE( "combat_flamewall", combat_flamewall );
    AI_DISPATCH_STATE( "combat_incinerate", combat_incinerate );
    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 );
    AI_DISPATCH_STATE( "spawn_flame_wall", spawn_flame_wall );
    AI_DISPATCH_STATE( "spawn_incerate", spawn_incerate );
    AI_DISPATCH_STATE( "flame_wall_loop", flame_wall_loop );
    AI_DISPATCH_STATE( "flame_wall", flame_wall );
    AI_DISPATCH_STATE( "incinerate", incinerate );
    AI_DISPATCH_STATE( "resurrection", resurrection );
    return rvmMonsterBase::RunStateByName( stateName, parms );
}

stateResult_t rvmMonsterDemonArchvile::Torso_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_TORSO, "stand" ); parms->stage = 1; }
    if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", ARCH_IDLE_TO_PAIN ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonArchvile::Torso_Pain( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_RUNNING };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_TORSO, GetPainAnim() );
            painNextTime = DelayTime( ARCH_PAIN_DELAY );
            parms->stage = STAGE_RUNNING;
            return SRESULT_WAIT;
        case STAGE_RUNNING:
            if ( Pain() && Time() > painNextTime ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", ARCH_PAIN_TO_PAIN ); return SRESULT_DONE; }
            if ( AnimDone( ANIMCHANNEL_TORSO, ARCH_PAIN_TO_IDLE ) ) {
                FinishAction( "pain" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", ARCH_PAIN_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::Torso_Resurrect( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_RUNNING };
    switch ( parms->stage ) {
        case STAGE_START:
            PreventPain( 1.0f );
            SetSmokeVisibility( -1, true );
            PlayAnim( ANIMCHANNEL_TORSO, "resurrection" );
            parms->stage = STAGE_RUNNING;
            return SRESULT_WAIT;
        case STAGE_RUNNING:
            if ( AnimDone( ANIMCHANNEL_TORSO, ARCH_RESURRECT_TO_IDLE ) ) {
                SetSmokeVisibility( -1, false );
                FinishAction( "resurrect" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", ARCH_RESURRECT_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::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:
            LookAtEnemy( 0.2f );
            if ( AnimDone( ANIMCHANNEL_TORSO, ARCH_MELEE_TO_IDLE ) ) {
                FinishAction( "melee_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", ARCH_MELEE_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::Torso_FlameWallAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_RUNNING };
    switch ( parms->stage ) {
        case STAGE_START:
            PreventPain( 1.0f );
            FaceEnemy();
            SetSmokeVisibility( -1, true );
            PlayAnim( ANIMCHANNEL_TORSO, "flamewall_attack" );
            parms->stage = STAGE_RUNNING;
            return SRESULT_WAIT;
        case STAGE_RUNNING:
            LookAtEnemy( 1.0f );
            if ( AnimDone( ANIMCHANNEL_TORSO, ARCH_FLAMEWALL_TO_IDLE ) ) {
                SetSmokeVisibility( -1, false );
                nextAttack = DelayTime( ARCH_ATTACK_RATE );
                FinishAction( "flamewall_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", ARCH_FLAMEWALL_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::Torso_IncinerateAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_RUNNING };
    switch ( parms->stage ) {
        case STAGE_START:
            PreventPain( 1.0f );
            FaceEnemy();
            PlayAnim( ANIMCHANNEL_TORSO, "incinerate_attack" );
            parms->stage = STAGE_RUNNING;
            return SRESULT_WAIT;
        case STAGE_RUNNING:
            LookAtEnemy( 1.0f );
            if ( AnimDone( ANIMCHANNEL_TORSO, ARCH_INCINERATE_TO_IDLE ) ) {
                nextAttack = DelayTime( ARCH_ATTACK_RATE );
                FinishAction( "incinerate_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", ARCH_INCINERATE_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::Torso_TurretAttack( stateParms_t* parms ) {
    // The DoomScript turret attack can resurrect, flame-wall, or incinerate from the same entry.
    // Choose once at entry, then delegate to the concrete non-blocking torso state.
    if ( parms->stage == 0 ) {
        if ( num_minions() < keep_alive && Time() >= summon_time ) {
            waitActionName = "resurrect";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_Resurrect", ARCH_IDLE_TO_TURRETATTACK );
        } else if ( EnemyRange() < ARCH_FLAME_WALL_RANGE && CanHitEnemy() ) {
            waitActionName = "flamewall_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_FlameWallAttack", ARCH_IDLE_TO_TURRETATTACK );
        } else {
            waitActionName = "incinerate_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_IncinerateAttack", ARCH_IDLE_TO_TURRETATTACK );
        }
        parms->stage = 1;
        return SRESULT_WAIT;
    }
    if ( InAnimState( ANIMCHANNEL_TORSO, "Torso_TurretAttack" ) ) { return SRESULT_WAIT; }
    FinishAction( "turret_attack" );
    SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", ARCH_TURRETATTACK_TO_IDLE );
    return SRESULT_DONE;
}

stateResult_t rvmMonsterDemonArchvile::Legs_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_LEGS, "stand" ); parms->stage = 1; }
    if ( MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Walk", ARCH_IDLE_TO_WALK ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonArchvile::Legs_Walk( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_LEGS, "walk" ); parms->stage = 1; }
    if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", ARCH_WALK_TO_IDLE ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonArchvile::Legs_DodgeLeft( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_LEGS, "evade_left" ); parms->stage = 1; }
    if ( AnimDone( ANIMCHANNEL_LEGS, ARCH_DODGE_LEFT_TO_IDLE ) ) { FinishAction( "strafe" ); SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", ARCH_DODGE_LEFT_TO_IDLE ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonArchvile::Legs_DodgeRight( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_LEGS, "evade_right" ); parms->stage = 1; }
    if ( AnimDone( ANIMCHANNEL_LEGS, ARCH_DODGE_RIGHT_TO_IDLE ) ) { FinishAction( "strafe" ); SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", ARCH_DODGE_RIGHT_TO_IDLE ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonArchvile::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 rvmMonsterDemonArchvile::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( ARCH_DODGE_RATE );
                summon_time = Time() + summon_delay;
            SetState( "state_Combat" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

float rvmMonsterDemonArchvile::num_minions() {
    // Integration hook: the script counted live minion targets from its target list.  Return zero here
    // so a native port can opt into resurrect behavior without blocking; replace with target iteration
    // if your project exposes the original target array to native AI objects.
    return 0;
}

int rvmMonsterDemonArchvile::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 ( num_minions() < keep_alive && currentTime >= summon_time ) { flags |= ATTACK_RESURRECT; }
    if ( ( Time() > nextNoFOVAttack && EnemyVisible() ) || EnemyInFOV() ) {
        if ( currentTime >= nextAttack ) {
            if ( EnemyRange() < ARCH_FLAME_WALL_RANGE && CanHitEnemy() ) { flags |= ATTACK_FLAMEWALL; }
            if ( CanHitEnemy() ) { flags |= ATTACK_MISSILE; }
        }
    }
    return static_cast<float>( flags );
}

bool rvmMonsterDemonArchvile::do_attack( int attack_flags ) {
    nextNoFOVAttack = Time() + ARCH_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_RESURRECT ) { StartAction( "combat_resurrect" ); return true; }
    if ( flags & ATTACK_FLAMEWALL ) { StartAction( "combat_flamewall" ); 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_incinerate" ); return true; }
    return false;
}

stateResult_t rvmMonsterDemonArchvile::combat_resurrect( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "resurrect";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_Resurrect", ARCH_IDLE_TO_RESURRECT );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "resurrect" ) ) { return SRESULT_WAIT; }
            summon_time = Time() + summon_delay;
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::combat_flamewall( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "flamewall_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_FlameWallAttack", ARCH_IDLE_TO_FLAMEWALLATTACK );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "flamewall_attack" ) ) { return SRESULT_WAIT; }
            nextAttack = DelayTime( ARCH_ATTACK_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::combat_incinerate( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "incinerate_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_IncinerateAttack", ARCH_IDLE_TO_INCINERATEATTACK );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "incinerate_attack" ) ) { return SRESULT_WAIT; }
            nextAttack = DelayTime( ARCH_ATTACK_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::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", ARCH_WALK_TO_MELEE );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "melee_attack" ) ) { return SRESULT_WAIT; }
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::combat_dodge_left( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "strafe";
            SetAnimState( ANIMCHANNEL_LEGS, "Legs_DodgeLeft", ARCH_WALK_TO_DODGE_LEFT );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
            nextDodge = DelayTime( ARCH_DODGE_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::combat_dodge_right( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "strafe";
            SetAnimState( ANIMCHANNEL_LEGS, "Legs_DodgeRight", ARCH_WALK_TO_DODGE_RIGHT );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
            nextDodge = DelayTime( ARCH_DODGE_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::spawn_flame_wall( stateParms_t* parms ) {
    // Hook point for the original script's repeated sys.spawn of flame-wall projectiles.
    // The looping behavior is represented by flame_wall_loop() below, not a blocking wait.
    return SRESULT_DONE;
}

stateResult_t rvmMonsterDemonArchvile::spawn_incerate( stateParms_t* parms ) {
    // Hook point for the original script's incinerate projectile spawn.
    return SRESULT_DONE;
}

stateResult_t rvmMonsterDemonArchvile::flame_wall_loop( stateParms_t* parms ) {
    enum { STAGE_INIT, STAGE_SPAWN, STAGE_DELAY };
    switch ( parms->stage ) {
        case STAGE_INIT:
            scratchCount = 0;
            parms->stage = STAGE_SPAWN;
            return SRESULT_WAIT;
        case STAGE_SPAWN:
            if ( scratchCount >= ARCH_FLAME_WALL_NUM ) { return SRESULT_DONE; }
            flameWallOrigin = GetEnemyPos();
            StartAction( "spawn_flame_wall" );
            scratchCount++;
            scratchEndTime = DelayTime( 0.05f );
            parms->stage = STAGE_DELAY;
            return SRESULT_WAIT;
        case STAGE_DELAY:
            if ( InAction() || Time() < scratchEndTime ) { return SRESULT_WAIT; }
            parms->stage = STAGE_SPAWN;
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonArchvile::flame_wall( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { StartAction( "flame_wall_loop" ); parms->stage = 1; return SRESULT_WAIT; }
    return InAction() ? SRESULT_WAIT : SRESULT_DONE;
}

stateResult_t rvmMonsterDemonArchvile::incinerate( stateParms_t* parms ) {
    incinerateOrigin = GetEnemyPos();
    StartAction( "spawn_incerate" );
    return SRESULT_DONE;
}

stateResult_t rvmMonsterDemonArchvile::resurrection( stateParms_t* parms ) {
    // Hook point for resurrecting a selected dead minion.  This remains non-blocking.
    resurrectionTarget = NULL;
    return SRESULT_DONE;
}