// AI_monster_flying_lostsoul.cpp
    // Native state-machine replacement for ai_monster_flying_lostsoul.script.

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



    rvmMonsterFlyingLostsoul::rvmMonsterFlyingLostsoul() {
    nextAttack = 0.0f;
    nextNoFOVAttack = 0.0f;
    noMeleeTime = 0.0f;
    fly_offset = 0.0f;
    painNextTime = 0.0f;
    chargeVelocity = vec3_zero;
}

void rvmMonsterFlyingLostsoul::Init( idAI* aiOwner ) {
    rvmMonsterBase::Init( aiOwner );
    fly_offset = GetFloatKey( "fly_offset", "0" );
    SetState( "state_Begin" );
}

stateResult_t rvmMonsterFlyingLostsoul::RunStateByName( const char* stateName, stateParms_t* parms ) {
    AI_DISPATCH_STATE( "Torso_Idle", Torso_Idle );
    AI_DISPATCH_STATE( "Torso_Fly", Torso_Fly );
    AI_DISPATCH_STATE( "Torso_Charge", Torso_Charge );
    AI_DISPATCH_STATE( "Torso_Pain", Torso_Pain );
    AI_DISPATCH_STATE( "Torso_MeleeAttack", Torso_MeleeAttack );
    AI_DISPATCH_STATE( "state_Begin", state_Begin );
    AI_DISPATCH_STATE( "state_Idle", state_Idle );
    AI_DISPATCH_STATE( "combat_charge", combat_charge );
    AI_DISPATCH_STATE( "combat_melee", combat_melee );
    AI_DISPATCH_STATE( "combat_retreat", combat_retreat );
    return rvmMonsterBase::RunStateByName( stateName, parms );
}

stateResult_t rvmMonsterFlyingLostsoul::Torso_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_TORSO, "idle" ); parms->stage = 1; }
    if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
    if ( MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Fly", 4 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterFlyingLostsoul::Torso_Fly( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_TORSO, "fly" ); parms->stage = 1; }
    if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
    if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterFlyingLostsoul::Torso_Charge( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_CHARGE };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayCycle( ANIMCHANNEL_TORSO, "charge" );
            AttackBegin( "melee_lostsoul_charge" );
            scratchEndTime = DelayTime( ( EnemyRange() + 256.0f ) / LOSTSOUL_CHARGE_SPEED );
            parms->stage = STAGE_CHARGE;
            return SRESULT_WAIT;
        case STAGE_CHARGE:
            if ( InfluenceActive() || Pain() || Time() >= scratchEndTime ) {
                AttackEnd();
                FinishAction( "charge_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
                return SRESULT_DONE;
            }
            if ( CheckForMelee() ) { AttackMelee( "melee_lostsoul_charge" ); }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterFlyingLostsoul::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", 0 ); return SRESULT_DONE; }
            if ( AnimDone( ANIMCHANNEL_TORSO, 2 ) ) {
                FinishAction( "pain" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 2 );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

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

stateResult_t rvmMonsterFlyingLostsoul::state_Begin( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_MONSTER_BEGIN };
    switch ( parms->stage ) {
        case STAGE_START:
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 0 );
            StartAction( "monster_begin" );
            parms->stage = STAGE_MONSTER_BEGIN;
            return SRESULT_WAIT;
        case STAGE_MONSTER_BEGIN:
            if ( InAction() ) { return SRESULT_WAIT; }
            SetMoveType( MOVETYPE_FLY );
            SetState( "state_Idle" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

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

int rvmMonsterFlyingLostsoul::check_attacks() {
    int flags = 0;
    const float currentTime = Time();
    if ( currentTime >= noMeleeTime && CheckForMelee() ) { flags |= ATTACK_MELEE; }
    if ( ( Time() > nextNoFOVAttack && EnemyVisible() ) || EnemyInFOV() ) {
        const float range = EnemyRange();
        if ( range < 40.0f ) { flags |= ATTACK_LOSTSOUL_RETREAT; }
        if ( range >= LOSTSOUL_CHARGE_RANGE_MIN && range < LOSTSOUL_CHARGE_RANGE_MAX && ( !CanReachEnemy() || currentTime >= nextAttack ) && owner && owner->TestChargeAttack() > 0.0f ) {
            flags |= ATTACK_LOSTSOUL_CHARGE;
        }
    }
    return static_cast<float>( flags );
}

bool rvmMonsterFlyingLostsoul::do_attack( int attack_flags ) {
    nextNoFOVAttack = Time() + LOSTSOUL_NOFOVTIME;
    const int flags = attack_flags;
    if ( flags & ATTACK_LOSTSOUL_RETREAT ) { StartAction( "combat_retreat" ); return true; }
    if ( flags & ATTACK_MELEE ) { StartAction( "combat_melee" ); return true; }
    if ( flags & ATTACK_LOSTSOUL_CHARGE ) { StartAction( "combat_charge" ); return true; }
    return false;
}

stateResult_t rvmMonsterFlyingLostsoul::combat_charge( stateParms_t* parms ) {
    enum { STAGE_RISE, STAGE_FACE, STAGE_CHARGE, STAGE_FINISH };
    switch ( parms->stage ) {
        case STAGE_RISE:
            SetFlyOffset( idMath::Ftoi( fly_offset + 200.0f ) );
            scratchEndTime = DelayTime( 0.5f );
            parms->stage = STAGE_FACE;
            return SRESULT_WAIT;
        case STAGE_FACE: {
            if ( Time() < scratchEndTime ) { return SRESULT_WAIT; }
            FaceEnemy();
            idVec3 forward = GetEnemyPos() - GetOrigin();
            forward.z = 0.0f;
            forward.Normalize();
            chargeVelocity = forward * LOSTSOUL_CHARGE_SPEED;
            SetFlyOffset( idMath::Ftoi( fly_offset ) );
            SetFlySpeed( LOSTSOUL_CHARGE_SPEED );
            waitActionName = "charge_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_Charge", 4 );
            parms->stage = STAGE_CHARGE;
            return SRESULT_WAIT;
        }
        case STAGE_CHARGE: {
            if ( !ActionDone( "charge_attack" ) ) {
                idVec3 vel = chargeVelocity;
                const idVec3 org = GetOrigin();
                const idVec3 pos = GetEnemyPos();
                vel.z = -( org.z - pos.z + 16.0f ) * 3.0f;
                SetLinearVelocity( vel );
                return SRESULT_WAIT;
            }
            SetFlySpeed( LOSTSOUL_NORMAL_SPEED );
            nextAttack = DelayTime( LOSTSOUL_ATTACK_RATE );
            nextNoFOVAttack = Time() + LOSTSOUL_NOFOVTIME;
            noMeleeTime = Time() + 1.0f;
            return SRESULT_DONE;
        }
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterFlyingLostsoul::combat_melee( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            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; }
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterFlyingLostsoul::combat_retreat( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_MOVE };
    switch ( parms->stage ) {
        case STAGE_START:
            MoveOutOfRange( GetEnemy(), EnemyRange() + 256.0f );
            scratchEndTime = DelayTime( 1.0f );
            parms->stage = STAGE_MOVE;
            return SRESULT_WAIT;
        case STAGE_MOVE:
            if ( MoveDone() || Time() >= scratchEndTime ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}