// AI_monster_demon_wraith.cpp
    // Native state-machine replacement for ai_monster_demon_wraith.script.

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



    rvmMonsterDemonWraith::rvmMonsterDemonWraith() {
    invisible = false;
    nextDodge = 0.0f;
    nextInvisible = 0.0f;
    painNextTime = 0.0f;
    combat_node = NULL;
    spawn_effect = NULL;
}

void rvmMonsterDemonWraith::Init( idAI* aiOwner ) {
    rvmMonsterBase::Init( aiOwner );
    run_distance = WRAITH_RUNDISTANCE;
    walk_turn = WRAITH_WALKTURN;
    SetState( "state_Begin" );
}

stateResult_t rvmMonsterDemonWraith::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( "Legs_Idle", Legs_Idle );
    AI_DISPATCH_STATE( "Legs_Walk", Legs_Walk );
    AI_DISPATCH_STATE( "Legs_Run", Legs_Run );
    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( "state_LostCombat", state_LostCombat );
    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( "combat_become_visible", combat_become_visible );
    AI_DISPATCH_STATE( "combat_become_invisible", combat_become_invisible );
    AI_DISPATCH_STATE( "spawn_fx", spawn_fx );
    return rvmMonsterBase::RunStateByName( stateName, parms );
}

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

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

stateResult_t rvmMonsterDemonWraith::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, WRAITH_MELEE_TO_IDLE ) ) {
                FinishAction( "melee_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", WRAITH_MELEE_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonWraith::Legs_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_LEGS, "idle" ); parms->stage = 1; }
    if ( run && MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Run", WRAITH_IDLE_TO_RUN ); return SRESULT_DONE; }
    if ( MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Walk", WRAITH_IDLE_TO_WALK ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonWraith::Legs_Walk( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_LEGS, "walk" ); parms->stage = 1; }
    if ( run && MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Run", WRAITH_IDLE_TO_RUN ); return SRESULT_DONE; }
    if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", WRAITH_RUN_TO_IDLE ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonWraith::Legs_Run( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_LEGS, "run" ); parms->stage = 1; }
    if ( !run && MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Walk", WRAITH_IDLE_TO_WALK ); return SRESULT_DONE; }
    if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", WRAITH_RUN_TO_IDLE ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

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

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

stateResult_t rvmMonsterDemonWraith::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 rvmMonsterDemonWraith::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; }
                nextDodge = RandomTime( WRAITH_DODGE_RATE );
                nextInvisible = 0.0f;
            SetState( "state_Combat" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

int rvmMonsterDemonWraith::check_attacks() {
    int flags = 0;
    const float range = EnemyRange();
    const float currentTime = Time();
    if ( invisible ) {
        if ( ( range < WRAITH_INVISIBLE_DIST_MIN || currentTime >= nextInvisible ) && CanBecomeSolid() ) { flags |= ATTACK_BECOME_VISIBLE; }
        return static_cast<float>( flags );
    }
    const bool canMelee = CheckForMelee();
    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 ( owner && owner->AI_ONGROUND && range > WRAITH_INVISIBLE_DIST_MAX && currentTime >= nextInvisible ) { flags |= ATTACK_BECOME_INVISIBLE; }
    return static_cast<float>( flags );
}

bool rvmMonsterDemonWraith::do_attack( int attack_flags ) {
    const int flags = attack_flags;
    if ( flags & ATTACK_BECOME_VISIBLE ) { StartAction( "combat_become_visible" ); return true; }
    if ( flags & ATTACK_BECOME_INVISIBLE ) { StartAction( "combat_become_invisible" ); return true; }
    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; }
    return false;
}

stateResult_t rvmMonsterDemonWraith::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", WRAITH_WALK_TO_MELEE );
            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 rvmMonsterDemonWraith::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", WRAITH_WALK_TO_DODGE_LEFT );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
            nextDodge = DelayTime( WRAITH_DODGE_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonWraith::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", WRAITH_WALK_TO_DODGE_RIGHT );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
            nextDodge = DelayTime( WRAITH_DODGE_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonWraith::spawn_fx( stateParms_t* parms ) {
    // Project-specific effect spawning is intentionally isolated here.
    // Bind your wraith_spawneffect entity to spawn_effect if desired.
    return SRESULT_DONE;
}

stateResult_t rvmMonsterDemonWraith::combat_become_visible( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_SOLID, STAGE_FADE, STAGE_DONE };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            if ( !invisible ) { nextInvisible = RandomDelay( WRAITH_INVISIBLE_DELAY_MIN, WRAITH_INVISIBLE_DELAY_MAX ); return SRESULT_DONE; }
            AllowMovement( false );
            parms->stage = STAGE_SOLID;
            return SRESULT_WAIT;
        case STAGE_SOLID:
            if ( !CanBecomeSolid() ) { return SRESULT_WAIT; }
            BecomeSolid();
            if ( owner ) { owner->AllowHiddenMovement( 0 ); }
            AllowMovement( true );
            SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 0 );
            StartSoundKey( "snd_fade_in", SND_CHANNEL_VOICE2, false );
            ShowOwner();
            scratchEndTime = DelayTime( 0.75f );
            parms->stage = STAGE_FADE;
            return SRESULT_WAIT;
        case STAGE_FADE:
            if ( Time() < scratchEndTime ) { return SRESULT_WAIT; }
            ClearBurn();
            invisible = false;
            nextInvisible = RandomDelay( WRAITH_INVISIBLE_DELAY_MIN, WRAITH_INVISIBLE_DELAY_MAX );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonWraith::combat_become_invisible( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_FADEOUT, STAGE_HIDE };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            if ( invisible ) { return SRESULT_DONE; }
            invisible = true;
            StartSoundKey( "snd_fade_out", SND_CHANNEL_VOICE2, false );
            scratchEndTime = DelayTime( 0.817f );
            parms->stage = STAGE_FADEOUT;
            return SRESULT_WAIT;
        case STAGE_FADEOUT:
            if ( Time() < scratchEndTime ) { return SRESULT_WAIT; }
            PreBurn();
            HideOwner();
            if ( owner ) { owner->AllowHiddenMovement( 1 ); }
            nextInvisible = RandomDelay( WRAITH_VISIBLE_DELAY_MIN, WRAITH_VISIBLE_DELAY_MAX );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonWraith::state_LostCombat( stateParms_t* parms ) {
    enum { STAGE_INVISIBLE, STAGE_ROUTE, STAGE_VISIBLE };
    switch ( parms->stage ) {
        case STAGE_INVISIBLE:
            StartAction( "combat_become_invisible" );
            parms->stage = STAGE_ROUTE;
            return SRESULT_WAIT;
        case STAGE_ROUTE:
            if ( InAction() || Time() < nextInvisible ) { return SRESULT_WAIT; }
            StopMove();
            if ( !CanReachEnemy() ) { return SRESULT_WAIT; }
            scratchEndTime = DelayTime( 2.0f );
            parms->stage = STAGE_VISIBLE;
            return SRESULT_WAIT;
        case STAGE_VISIBLE:
            if ( Time() < scratchEndTime ) { return SRESULT_WAIT; }
            StartAction( "combat_become_visible" );
            SetState( "state_Combat" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}