// AI_monster_zombie_commando_tentacle.cpp
// Native state-machine replacement for ai_monster_zombie_commando_tentacle.script.

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



rvmMonsterZombieCommandoTentacle::rvmMonsterZombieCommandoTentacle() {
    nextAttack = 0.0f;
    nextNoFOVAttack = 0.0f;
    tentacleDamage = false;
    painNextTime = 0.0f;
}

void rvmMonsterZombieCommandoTentacle::Init( idAI* aiOwner ) {
    rvmMonsterBase::Init( aiOwner );
    run_distance = ZCT_RUNDISTANCE;
    walk_turn = ZCT_WALKTURN;
    SetState( "state_Begin" );
}

stateResult_t rvmMonsterZombieCommandoTentacle::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_TentacleAttack", Torso_TentacleAttack );
    AI_DISPATCH_STATE( "Legs_Idle", Legs_Idle );
    AI_DISPATCH_STATE( "Legs_Walk", Legs_Walk );
    AI_DISPATCH_STATE( "Legs_Run", Legs_Run );
    AI_DISPATCH_STATE( "state_Begin", state_Begin );
    AI_DISPATCH_STATE( "state_Idle", state_Idle );
    AI_DISPATCH_STATE( "combat_tentacle", combat_tentacle );
    AI_DISPATCH_STATE( "combat_melee", combat_melee );
    return rvmMonsterBase::RunStateByName( stateName, parms );
}

stateResult_t rvmMonsterZombieCommandoTentacle::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;
    }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterZombieCommandoTentacle::Torso_Pain( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_WAIT };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_TORSO, GetPainAnim() );
            painNextTime = DelayTime( 0.25f );
            parms->stage = STAGE_WAIT;
            return SRESULT_WAIT;
        case STAGE_WAIT:
            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 rvmMonsterZombieCommandoTentacle::Torso_MeleeAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_WAIT };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_TORSO, "melee_attack" );
            parms->stage = STAGE_WAIT;
            return SRESULT_WAIT;
        case STAGE_WAIT:
            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 rvmMonsterZombieCommandoTentacle::Torso_TentacleAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_WAIT };
    switch ( parms->stage ) {
        case STAGE_START:
            FaceEnemy();
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack" );
            parms->stage = STAGE_WAIT;
            return SRESULT_WAIT;
        case STAGE_WAIT:
            if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) {
                FinishAction( "tentacle_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

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

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

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

stateResult_t rvmMonsterZombieCommandoTentacle::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 rvmMonsterZombieCommandoTentacle::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; }
            tentacleDamage = false;
            nextAttack = 0.0f;
            nextNoFOVAttack = 0.0f;
            SetState( "state_Combat" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

int rvmMonsterZombieCommandoTentacle::check_attacks() {
    int attack_flags = 0;
    if ( CheckForMelee() ) {
        attack_flags |= ATTACK_MELEE;
    }
    if ( ( Time() > nextNoFOVAttack && EnemyVisible() ) || EnemyInFOV() ) {
        const float range = EnemyRange();
        if ( range < ZCT_TENTACLE_RANGE_MAX && ( !CanReachEnemy() || Time() >= nextAttack ) && CanHitEnemy() ) {
            attack_flags |= ATTACK_TENTACLE;
        }
    }
    return attack_flags;
}

bool rvmMonsterZombieCommandoTentacle::do_attack( int attack_flags ) {
    const int flags = attack_flags;
    nextNoFOVAttack = Time() + ZCT_NOFOVTIME;
    if ( flags & ATTACK_MELEE ) {
        StartAction( "combat_melee" );
        return true;
    }
    if ( flags & ATTACK_TENTACLE ) {
        StartAction( "combat_tentacle" );
        return true;
    }
    return false;
}

stateResult_t rvmMonsterZombieCommandoTentacle::combat_tentacle( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_LOOP };
    switch ( parms->stage ) {
        case STAGE_START:
            tentacleDamage = false;
            StopMove();
            waitActionName = "tentacle_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_TentacleAttack", 4 );
            parms->stage = STAGE_LOOP;
            return SRESULT_WAIT;
        case STAGE_LOOP:
            if ( tentacleDamage && owner && owner->MeleeAttackToJoint( "joint13", "melee_commandoTentacle" ) ) {
                tentacleDamage = false;
            }
            if ( !InAnimState( ANIMCHANNEL_TORSO, "Torso_TentacleAttack" ) || ActionDone( "tentacle_attack" ) ) {
                tentacleDamage = false;
                nextAttack = DelayTime( ZCT_ATTACK_RATE );
                nextNoFOVAttack = Time() + ZCT_NOFOVTIME;
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterZombieCommandoTentacle::combat_melee( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_LOOP };
    switch ( parms->stage ) {
        case STAGE_START:
            tentacleDamage = false;
            FaceEnemy();
            waitActionName = "melee_attack";
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_MeleeAttack", 5 );
            parms->stage = STAGE_LOOP;
            return SRESULT_WAIT;
        case STAGE_LOOP:
            LookAtEnemy( 1.0f );
            if ( tentacleDamage && owner && owner->MeleeAttackToJoint( "joint13", "melee_commandoTentacle" ) ) {
                tentacleDamage = false;
            }
            if ( !InAnimState( ANIMCHANNEL_TORSO, "Torso_MeleeAttack" ) || ActionDone( "melee_attack" ) ) {
                tentacleDamage = false;
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

void rvmMonsterZombieCommandoTentacle::tentacle_attack_start() {
    tentacleDamage = true;
}

void rvmMonsterZombieCommandoTentacle::tentacle_attack_end() {
    tentacleDamage = false;
}