// AI_monster_boss_cyberdemon.cpp
    // Native state-machine replacement for ai_monster_boss_cyberdemon.script.

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



    rvmMonsterBossCyberdemon::rvmMonsterBossCyberdemon() {
    nextAttack = 0.0f;
    nextNoFOVAttack = 0.0f;
    painNextTime = 0.0f;
    kick_entity = NULL;
}

void rvmMonsterBossCyberdemon::Init( idAI* aiOwner ) {
    rvmMonsterBase::Init( aiOwner );
    nextNoFOVAttack = 0.0f;
    SetState( "state_Begin" );
}

stateResult_t rvmMonsterBossCyberdemon::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( "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 rvmMonsterBossCyberdemon::Torso_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_TORSO, "idle" ); parms->stage = 1; }
    if ( ( owner && owner->AI_SPECIAL_DAMAGE ) ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", CYBER_IDLE_TO_PAIN ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterBossCyberdemon::Torso_Pain( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_RUNNING };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_TORSO, GetPainAnim() );
            painNextTime = DelayTime( CYBER_PAIN_DELAY );
            parms->stage = STAGE_RUNNING;
            return SRESULT_WAIT;
        case STAGE_RUNNING:
            if ( ( owner && owner->AI_SPECIAL_DAMAGE ) && Time() > painNextTime ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", CYBER_PAIN_TO_PAIN ); return SRESULT_DONE; }
            if ( AnimDone( ANIMCHANNEL_TORSO, CYBER_PAIN_TO_IDLE ) ) {
                FinishAction( "pain" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", CYBER_PAIN_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterBossCyberdemon::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.1f );
            if ( AnimDone( ANIMCHANNEL_TORSO, CYBER_MELEE_TO_IDLE ) ) {
                FinishAction( "melee_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", CYBER_MELEE_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterBossCyberdemon::Torso_RangeAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_RUNNING };
    switch ( parms->stage ) {
        case STAGE_START:
            PreventPain( 1.0f );
            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, CYBER_RANGE_TO_IDLE ) ) {
                AllowMovement( true );
                FinishAction( "range_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", CYBER_RANGE_TO_IDLE );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

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

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

stateResult_t rvmMonsterBossCyberdemon::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 rvmMonsterBossCyberdemon::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;
            SetState( "state_Combat" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

int rvmMonsterBossCyberdemon::check_attacks() {
    int flags = 0;
    if ( EnemyVisible() ) {
        const idVec3 org = GetOrigin();
        kick_entity = FindActorsInBounds( org + idVec3( -65, -65, 0 ), org + idVec3( 65, 65, 300 ) );
        if ( kick_entity.GetEntity() ) { flags |= ATTACK_MELEE; }
    }
    if ( ( Time() > nextNoFOVAttack && EnemyVisible() ) || EnemyInFOV() ) {
        if ( !CanReachEnemy() || Time() >= nextAttack ) {
            range_attack_anim = ChooseAnim( ANIMCHANNEL_LEGS, "range_attack" );
            if ( CanHitEnemyFromAnim( range_attack_anim.c_str() ) ) { flags |= ATTACK_MISSILE; }
        }
    }
    return static_cast<float>( flags );
}

bool rvmMonsterBossCyberdemon::do_attack( int attack_flags ) {
    nextNoFOVAttack = Time() + CYBER_NOFOVTIME;
    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 rvmMonsterBossCyberdemon::combat_range( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            FaceEnemy();
            StopMove();
            waitActionName = "range_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_RangeAttack", CYBER_WALK_TO_RANGEATTACK );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "range_attack" ) ) { return SRESULT_WAIT; }
            nextAttack = DelayTime( CYBER_ATTACK_RATE );
            nextNoFOVAttack = Time() + CYBER_NOFOVTIME;
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterBossCyberdemon::combat_melee( stateParms_t* parms ) {
    enum { STAGE_KICK, STAGE_DAMAGE };
    switch ( parms->stage ) {
        case STAGE_KICK:
            if ( owner ) { owner->KickObstacles( kick_entity.GetEntity(), 200.0f ); }
            scratchEndTime = DelayTime( 0.5f );
            parms->stage = STAGE_DAMAGE;
            return SRESULT_WAIT;
        case STAGE_DAMAGE:
            if ( Time() < scratchEndTime ) { return SRESULT_WAIT; }
            DirectDamage( kick_entity.GetEntity(), "melee_cyberdemon_kick" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}