// AI_monster_demon_cherub.cpp
    // Native state-machine replacement for ai_monster_demon_cherub.script.

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



    rvmMonsterDemonCherub::rvmMonsterDemonCherub() {
    explode = false;
    nextDodge = 0.0f;
    nextLeap = 0.0f;
    painNextTime = 0.0f;
    jumpVelocity = vec3_zero;
    combat_node = NULL;
}

void rvmMonsterDemonCherub::Init( idAI* aiOwner ) {
    rvmMonsterBase::Init( aiOwner );
    run_distance = CHERUB_RUNDISTANCE;
    walk_turn = CHERUB_WALKTURN;
    SetState( "state_Begin" );
}

stateResult_t rvmMonsterDemonCherub::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_LeapAttack", Torso_LeapAttack );
    AI_DISPATCH_STATE( "Torso_Walk", Torso_Walk );
    AI_DISPATCH_STATE( "Torso_Run", Torso_Run );
    AI_DISPATCH_STATE( "Torso_DodgeLeft", Torso_DodgeLeft );
    AI_DISPATCH_STATE( "Torso_DodgeRight", Torso_DodgeRight );
    AI_DISPATCH_STATE( "state_Begin", state_Begin );
    AI_DISPATCH_STATE( "state_Idle", state_Idle );
    AI_DISPATCH_STATE( "combat_leap", combat_leap );
    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( "path_jump", path_jump );
    return rvmMonsterBase::RunStateByName( stateName, parms );
}

stateResult_t rvmMonsterDemonCherub::Torso_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_TORSO, "idle" ); parms->stage = 1; }
    if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
    if ( run && MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Run", 4 ); return SRESULT_DONE; }
    if ( MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Walk", 4 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonCherub::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 rvmMonsterDemonCherub::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 rvmMonsterDemonCherub::Torso_LeapAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_START_WAIT, STAGE_LOOP, STAGE_END_WAIT };
    switch ( parms->stage ) {
        case STAGE_START:
            OverrideAnim( ANIMCHANNEL_LEGS );
            PreventPain( 1.0f );
            PlayAnim( ANIMCHANNEL_TORSO, "jump_start" );
            parms->stage = STAGE_START_WAIT;
            return SRESULT_WAIT;
        case STAGE_START_WAIT:
            if ( !AnimDone( ANIMCHANNEL_TORSO, 2 ) ) { return SRESULT_WAIT; }
            AttackBegin( "melee_cherubLeapAttack" );
            SetLinearVelocity( jumpVelocity );
            PlayCycle( ANIMCHANNEL_TORSO, "jump_loop" );
            parms->stage = STAGE_LOOP;
            return SRESULT_WAIT;
        case STAGE_LOOP:
            if ( owner && !owner->AI_ONGROUND ) { return SRESULT_WAIT; }
            AttackEnd();
            PlayAnim( ANIMCHANNEL_TORSO, "jump_end" );
            parms->stage = STAGE_END_WAIT;
            return SRESULT_WAIT;
        case STAGE_END_WAIT:
            if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) {
                FinishAction( "leap_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonCherub::Torso_Walk( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_TORSO, "walk" ); parms->stage = 1; }
    if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
    if ( run && MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Run", 4 ); return SRESULT_DONE; }
    if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonCherub::Torso_Run( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_TORSO, "run" ); parms->stage = 1; }
    if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
    if ( !run && MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Walk", 4 ); return SRESULT_DONE; }
    if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonCherub::Torso_DodgeLeft( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_TORSO, "evade_left" ); parms->stage = 1; }
    if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) { FinishAction( "strafe" ); SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonCherub::Torso_DodgeRight( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_TORSO, "evade_right" ); parms->stage = 1; }
    if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) { FinishAction( "strafe" ); SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterDemonCherub::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_ANIM );
            SetState( "state_Idle" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonCherub::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; }
                nextLeap = RandomTime( CHERUB_LEAP_RATE );
                nextDodge = RandomTime( CHERUB_DODGE_RATE );
            SetState( "state_Combat" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

int rvmMonsterDemonCherub::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 ( EnemyInFOV() ) {
        const float range = EnemyRange();
        if ( range >= 0 && range < CHERUB_LEAP_RANGE && currentTime >= nextLeap && CanHitEnemy() ) {
            const float t = AnimLength( ANIMCHANNEL_TORSO, "jump_start" );
            const idVec3 jumpTarget = PredictEnemyPos( t );
            jumpVelocity = GetJumpVelocity( jumpTarget, CHERUB_LEAP_SPEED, CHERUB_LEAP_MAXHEIGHT );
            if ( jumpVelocity.LengthSqr() > 0.001f ) { flags |= ATTACK_LEAP; } else { nextLeap = DelayTime( 2.0f ); }
        }
    }
    return static_cast<float>( flags );
}

bool rvmMonsterDemonCherub::do_attack( int attack_flags ) {
    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_LEAP ) { StartAction( "combat_leap" ); return true; }
    return false;
}

stateResult_t rvmMonsterDemonCherub::combat_leap( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            TurnToPos( GetOrigin() + jumpVelocity );
            waitActionName = "leap_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_LeapAttack", 4 );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "leap_attack" ) ) { return SRESULT_WAIT; }
            nextLeap = DelayTime( CHERUB_LEAP_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonCherub::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 rvmMonsterDemonCherub::combat_dodge_left( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "strafe";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_DodgeLeft", 2 );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
            nextDodge = DelayTime( CHERUB_DODGE_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonCherub::combat_dodge_right( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "strafe";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_DodgeRight", 2 );
            parms->stage = STAGE_ACTION;
            return SRESULT_WAIT;
        case STAGE_ACTION:
            if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
            nextDodge = DelayTime( CHERUB_DODGE_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterDemonCherub::path_jump( stateParms_t* parms ) {
    enum { STAGE_PATH_CORNER, STAGE_SETUP, STAGE_TURN, STAGE_LEAP, STAGE_DONE };
    idEntity* path = current_path.GetEntity();
    switch ( parms->stage ) {
        case STAGE_PATH_CORNER:
            StartAction( "path_corner" );
            parms->stage = STAGE_SETUP;
            return SRESULT_WAIT;
        case STAGE_SETUP: {
            if ( InAction() ) { return SRESULT_WAIT; }
            if ( checkForEnemy( true ) ) { return SRESULT_DONE; }
            idEntity* target = RandomPathFrom( path );
            if ( !target ) { return SRESULT_DONE; }
            scratchEntity = target;
            const idVec3 jumpTarget = target->GetPhysics()->GetOrigin();
            if ( path && path->spawnArgs.GetString( "up", "" )[0] ) {
                float forward = path->spawnArgs.GetFloat( "forward", "0" );
                idVec3 dir = jumpTarget - GetOrigin();
                dir.z = 0.0f;
                dir.Normalize();
                jumpVelocity = dir * forward;
                jumpVelocity.z = path->spawnArgs.GetFloat( "up", "0" );
            } else {
                jumpVelocity = GetJumpVelocity( jumpTarget, CHERUB_LEAP_SPEED, 1024.0f );
            }
            StopMove();
            TurnToPos( jumpTarget );
            parms->stage = STAGE_TURN;
            return SRESULT_WAIT;
        }
        case STAGE_TURN:
            if ( checkForEnemy( true ) ) { return SRESULT_DONE; }
            if ( !FacingIdeal() ) { return SRESULT_WAIT; }
            waitActionName = "leap_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_LeapAttack", 4 );
            parms->stage = STAGE_LEAP;
            return SRESULT_WAIT;
        case STAGE_LEAP:
            if ( !ActionDone( "leap_attack" ) ) { return SRESULT_WAIT; }
            StopMove();
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}