// AI_monster_zombie_commando_cgun.cpp
// Native state-machine replacement for ai_monster_zombie_commando_cgun.script.

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



rvmMonsterZombieCommandoCGun::rvmMonsterZombieCommandoCGun() {
    fire = false;
    crouch_fire = false;
    step_left = false;
    step_right = false;
    run_attack = false;
    nextDodge = 0.0f;
    nextAttack = 0.0f;
    nextNoFOVAttack = 0.0f;
    combat_node = NULL;
    painNextTime = 0.0f;
    attackEndTime = 0.0f;
    loopEndTime = 0.0f;
    minShootTime = 0.0f;
    firstShot = false;
}

void rvmMonsterZombieCommandoCGun::Init( idAI* aiOwner ) {
    rvmMonsterBase::Init( aiOwner );
    run_distance = ZOMBIE_CGUN_RUNDISTANCE;
    walk_turn = ZOMBIE_CGUN_WALKTURN;
    SetState( "state_Begin" );
}

stateResult_t rvmMonsterZombieCommandoCGun::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_RangeAttack", Torso_RangeAttack );
    AI_DISPATCH_STATE( "Torso_TurretAttack", Torso_TurretAttack );
    AI_DISPATCH_STATE( "Torso_CrouchAttack", Torso_CrouchAttack );
    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( "Legs_StepLeft", Legs_StepLeft );
    AI_DISPATCH_STATE( "Legs_StepRight", Legs_StepRight );
    AI_DISPATCH_STATE( "state_Begin", state_Begin );
    AI_DISPATCH_STATE( "state_Idle", state_Idle );
    AI_DISPATCH_STATE( "stand_attack", stand_attack );
    AI_DISPATCH_STATE( "crouch_attack", crouch_attack );
    AI_DISPATCH_STATE( "combat_dodge_left", combat_dodge_left );
    AI_DISPATCH_STATE( "combat_dodge_right", combat_dodge_right );
    return rvmMonsterBase::RunStateByName( stateName, parms );
}

stateResult_t rvmMonsterZombieCommandoCGun::Torso_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) {
        IdleAnim( ANIMCHANNEL_TORSO, "range_attack_aim" );
        parms->stage = 1;
    }
    if ( Pain() ) {
        SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 );
        return SRESULT_DONE;
    }
    if ( fire ) {
        SetAnimState( ANIMCHANNEL_TORSO, "Torso_RangeAttack", 8 );
        return SRESULT_DONE;
    }
    if ( crouch_fire ) {
        SetAnimState( ANIMCHANNEL_TORSO, "Torso_CrouchAttack", 8 );
        return SRESULT_DONE;
    }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterZombieCommandoCGun::Torso_Pain( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_WAIT };
    switch ( parms->stage ) {
        case STAGE_START:
            SetBlendFrames( ANIMCHANNEL_TORSO, 3 );
            PlayAnim( ANIMCHANNEL_TORSO, GetPainAnim() );
            painNextTime = DelayTime( 0.25f );
            parms->stage = STAGE_WAIT;
            return SRESULT_WAIT;
        case STAGE_WAIT:
            if ( AnimDone( ANIMCHANNEL_TORSO, 12 ) ) {
                PreventPain( 0.6f );
                FinishAction( "pain" );
                SetBlendFrames( ANIMCHANNEL_TORSO, 12 );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 12 );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterZombieCommandoCGun::Torso_RangeAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_INTRO, STAGE_LOOP_START, STAGE_LOOP_WAIT, STAGE_END, STAGE_END_WAIT };
    switch ( parms->stage ) {
        case STAGE_START:
            SetAnimPrefix( "" );
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack" );
            parms->stage = STAGE_INTRO;
            return SRESULT_WAIT;
        case STAGE_INTRO:
            if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 ); return SRESULT_DONE; }
            if ( !AnimDone( ANIMCHANNEL_TORSO, 12 ) ) { return SRESULT_WAIT; }
            minShootTime = Time() + ZOMBIE_CGUN_MIN_SHOT_TIME;
            parms->stage = STAGE_LOOP_START;
            return SRESULT_WAIT;
        case STAGE_LOOP_START:
            if ( !fire && Time() >= minShootTime ) { parms->stage = STAGE_END; return SRESULT_WAIT; }
            if ( InfluenceActive() ) { fire = false; parms->stage = STAGE_END; return SRESULT_WAIT; }
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack_loop" );
            parms->stage = STAGE_LOOP_WAIT;
            return SRESULT_WAIT;
        case STAGE_LOOP_WAIT:
            if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 ); return SRESULT_DONE; }
            if ( InfluenceActive() ) { fire = false; parms->stage = STAGE_END; return SRESULT_WAIT; }
            if ( !AnimDone( ANIMCHANNEL_TORSO, 12 ) ) { return SRESULT_WAIT; }
            parms->stage = STAGE_LOOP_START;
            return SRESULT_WAIT;
        case STAGE_END:
            if ( !AnimDone( ANIMCHANNEL_TORSO, 8 ) ) { SetBlendFrames( ANIMCHANNEL_TORSO, 8 ); }
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack_end" );
            parms->stage = STAGE_END_WAIT;
            return SRESULT_WAIT;
        case STAGE_END_WAIT:
            if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 3 ); return SRESULT_DONE; }
            if ( AnimDone( ANIMCHANNEL_TORSO, 12 ) ) {
                FinishAction( "range_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 12 );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterZombieCommandoCGun::Torso_TurretAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_INTRO, STAGE_LOOP_START, STAGE_LOOP_WAIT, STAGE_END, STAGE_END_WAIT };
    switch ( parms->stage ) {
        case STAGE_START:
            SetAnimPrefix( "" );
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack" );
            parms->stage = STAGE_INTRO;
            return SRESULT_WAIT;
        case STAGE_INTRO:
            if ( !AnimDone( ANIMCHANNEL_TORSO, 8 ) ) { return SRESULT_WAIT; }
            attackEndTime = RandomDelay( ZOMBIE_CGUN_STAND_ATTACK_MIN_LENGTH, ZOMBIE_CGUN_STAND_ATTACK_MAX_LENGTH );
            parms->stage = STAGE_LOOP_START;
            return SRESULT_WAIT;
        case STAGE_LOOP_START:
            if ( Time() >= attackEndTime || !CanHitEnemyFromAnim( "range_attack_loop" ) || InfluenceActive() ) { parms->stage = STAGE_END; return SRESULT_WAIT; }
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack_loop" );
            parms->stage = STAGE_LOOP_WAIT;
            return SRESULT_WAIT;
        case STAGE_LOOP_WAIT:
            if ( !AnimDone( ANIMCHANNEL_TORSO, 8 ) ) { return SRESULT_WAIT; }
            parms->stage = STAGE_LOOP_START;
            return SRESULT_WAIT;
        case STAGE_END:
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack_end" );
            parms->stage = STAGE_END_WAIT;
            return SRESULT_WAIT;
        case STAGE_END_WAIT:
            if ( AnimDone( ANIMCHANNEL_TORSO, 8 ) ) {
                FinishAction( "turret_attack" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 8 );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterZombieCommandoCGun::Torso_CrouchAttack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_INTRO, STAGE_LOOP_START, STAGE_LOOP_WAIT, STAGE_AIM, STAGE_END, STAGE_END_WAIT };
    switch ( parms->stage ) {
        case STAGE_START:
            OverrideAnim( ANIMCHANNEL_LEGS );
            SetAnimPrefix( "crouch" );
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack" );
            parms->stage = STAGE_INTRO;
            return SRESULT_WAIT;
        case STAGE_INTRO:
            if ( !AnimDone( ANIMCHANNEL_TORSO, 8 ) ) { return SRESULT_WAIT; }
            minShootTime = Time() + ZOMBIE_CGUN_MIN_SHOT_TIME;
            parms->stage = STAGE_LOOP_START;
            return SRESULT_WAIT;
        case STAGE_LOOP_START:
            if ( !crouch_fire && Time() >= minShootTime ) { parms->stage = STAGE_END; return SRESULT_WAIT; }
            loopEndTime = RandomDelay( ZOMBIE_CGUN_STAND_ATTACK_MIN_LENGTH, ZOMBIE_CGUN_STAND_ATTACK_MAX_LENGTH );
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack_loop" );
            parms->stage = STAGE_LOOP_WAIT;
            return SRESULT_WAIT;
        case STAGE_LOOP_WAIT:
            if ( InfluenceActive() ) { crouch_fire = false; parms->stage = STAGE_END; return SRESULT_WAIT; }
            if ( !AnimDone( ANIMCHANNEL_TORSO, 8 ) ) { return SRESULT_WAIT; }
            if ( !crouch_fire || Time() >= loopEndTime ) {
                PlayCycle( ANIMCHANNEL_TORSO, "range_attack_aim" );
                loopEndTime = RandomDelay( ZOMBIE_CGUN_WAIT_MIN_LENGTH, ZOMBIE_CGUN_WAIT_MAX_LENGTH );
                parms->stage = STAGE_AIM;
                return SRESULT_WAIT;
            }
            parms->stage = STAGE_LOOP_START;
            return SRESULT_WAIT;
        case STAGE_AIM:
            if ( !crouch_fire || InfluenceActive() ) { crouch_fire = false; parms->stage = STAGE_END; return SRESULT_WAIT; }
            if ( Time() < loopEndTime ) { return SRESULT_WAIT; }
            parms->stage = STAGE_LOOP_START;
            return SRESULT_WAIT;
        case STAGE_END:
            PlayAnim( ANIMCHANNEL_TORSO, "range_attack_end" );
            parms->stage = STAGE_END_WAIT;
            return SRESULT_WAIT;
        case STAGE_END_WAIT:
            if ( AnimDone( ANIMCHANNEL_TORSO, 8 ) ) {
                FinishAction( "crouch_attack" );
                SetAnimPrefix( "" );
                SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 8 );
                return SRESULT_DONE;
            }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterZombieCommandoCGun::Legs_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_LEGS, "range_attack_aim" ); parms->stage = 1; }
    if ( GetEnemy() ) { run = true; }
    if ( run && MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Run", 8 ); return SRESULT_DONE; }
    if ( MovingForward() ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_Walk", 8 ); return SRESULT_DONE; }
    if ( step_left ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_StepLeft", 8 ); return SRESULT_DONE; }
    if ( step_right ) { SetAnimState( ANIMCHANNEL_LEGS, "Legs_StepRight", 8 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

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

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

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

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

stateResult_t rvmMonsterZombieCommandoCGun::Legs_StepLeft( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_LEGS, "step_left" ); parms->stage = 1; }
    if ( AnimDone( ANIMCHANNEL_LEGS, 8 ) ) { step_left = false; FinishAction( "sidestep" ); SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 8 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterZombieCommandoCGun::Legs_StepRight( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_LEGS, "step_right" ); parms->stage = 1; }
    if ( AnimDone( ANIMCHANNEL_LEGS, 8 ) ) { step_right = false; FinishAction( "sidestep" ); SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 8 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmMonsterZombieCommandoCGun::state_Begin( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_MONSTER_BEGIN };
    switch ( parms->stage ) {
        case STAGE_START:
            fire = false; crouch_fire = false; step_left = false; step_right = false;
            SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 8 );
            SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 8 );
            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 rvmMonsterZombieCommandoCGun::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;
            nextDodge = RandomTime( ZOMBIE_CGUN_DODGE_RATE );
            SetState( "state_Combat" );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

int rvmMonsterZombieCommandoCGun::check_attacks() {
    int attack_flags = 0;
    const float currentTime = Time();
    if ( Pain() && currentTime >= nextDodge && owner ) {
        if ( owner->TestAnimMove( "evade_left" ) ) { attack_flags |= ATTACK_DODGE_LEFT; }
        if ( owner->TestAnimMove( "evade_right" ) ) {
            attack_flags |= ATTACK_DODGE_RIGHT;
            if ( attack_flags & ATTACK_DODGE_LEFT ) {
                if ( RandomFloat( 100.0f ) < 50.0f ) { attack_flags &= ~ATTACK_DODGE_RIGHT; } else { attack_flags &= ~ATTACK_DODGE_LEFT; }
            }
        }
    }

    combat_node = GetCombatNode();
    if ( combat_node.GetEntity() ) { attack_flags |= ATTACK_COMBAT_NODE; }

    const bool reachable = CanReachEnemy();
    bool try_attack = false;
    if ( EnemyInFOV() && ( !reachable || currentTime >= nextAttack ) ) {
        try_attack = true;
    } else if ( Time() > nextNoFOVAttack && EnemyVisible() && ( !reachable || currentTime >= nextAttack ) ) {
        try_attack = true;
    } else if ( EnemyRange() < 64.0f ) {
        try_attack = true;
    }

    if ( try_attack ) {
        if ( RandomFloat() < 0.5f ) {
            if ( CanHitEnemyFromAnim( "crouch_range_attack_loop" ) ) { attack_flags |= ATTACK_ZCC_CROUCHFIRE; }
            else if ( CanHitEnemyFromAnim( "range_attack_loop" ) ) { attack_flags |= ATTACK_MISSILE; }
        } else if ( CanHitEnemyFromAnim( "range_attack_loop" ) ) {
            attack_flags |= ATTACK_MISSILE;
        }
    }
    return attack_flags;
}

bool rvmMonsterZombieCommandoCGun::do_attack( int attack_flags ) {
    const int flags = attack_flags;
    nextNoFOVAttack = Time() + ZOMBIE_CGUN_NOFOVTIME;
    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_ZCC_CROUCHFIRE ) { StartAction( "crouch_attack" ); return true; }
    if ( flags & ATTACK_MISSILE ) { StartAction( "stand_attack" ); return true; }
    return false;
}

stateResult_t rvmMonsterZombieCommandoCGun::stand_attack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_LOOP, STAGE_FINISH };
    switch ( parms->stage ) {
        case STAGE_START:
            fire = true;
            attackEndTime = RandomDelay( ZOMBIE_CGUN_STAND_ATTACK_MIN_LENGTH, ZOMBIE_CGUN_STAND_ATTACK_MAX_LENGTH );
            loopEndTime = RandomDelay( 0.5f, 1.0f );
            parms->stage = STAGE_LOOP;
            return SRESULT_WAIT;
        case STAGE_LOOP:
            if ( InfluenceActive() || Time() > attackEndTime || !EnemyVisible() || !CanHitEnemyFromAnim( "range_attack_loop" ) ) {
                fire = false;
                parms->stage = STAGE_FINISH;
                return SRESULT_WAIT;
            }
            LookAtEnemy( 1.0f );
            if ( !run_attack || EnemyRange() < 90.0f ) {
                FaceEnemy();
            } else if ( !EntityInAttackCone( GetEnemy() ) ) {
                fire = false;
                parms->stage = STAGE_FINISH;
                return SRESULT_WAIT;
            } else {
                MoveToEnemy();
            }
            if ( Time() >= loopEndTime ) {
                loopEndTime = RandomDelay( 0.5f, 1.0f );
                if ( owner ) {
                    const bool left = owner->TestAnimMove( "step_left" ) != 0;
                    const bool right = owner->TestAnimMove( "step_right" ) != 0;
                    if ( left && right ) {
                        step_left = RandomFloat( 100.0f ) >= 50.0f;
                        step_right = !step_left;
                    } else {
                        step_left = left;
                        step_right = right;
                    }
                }
            }
            return SRESULT_WAIT;
        case STAGE_FINISH:
            fire = false;
            if ( InAnimState( ANIMCHANNEL_TORSO, "Torso_RangeAttack" ) ) { return SRESULT_WAIT; }
            nextAttack = RandomDelay( ZOMBIE_CGUN_ATTACK_DELAY_MIN, ZOMBIE_CGUN_ATTACK_DELAY_MAX );
            nextNoFOVAttack = Time() + ZOMBIE_CGUN_NOFOVTIME;
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterZombieCommandoCGun::crouch_attack( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_LOOP, STAGE_FINISH };
    switch ( parms->stage ) {
        case STAGE_START:
            FaceEnemy();
            crouch_fire = true;
            attackEndTime = RandomDelay( ZOMBIE_CGUN_CROUCH_ATTACK_MIN_LENGTH, ZOMBIE_CGUN_CROUCH_ATTACK_MAX_LENGTH );
            parms->stage = STAGE_LOOP;
            return SRESULT_WAIT;
        case STAGE_LOOP:
            if ( InfluenceActive() || Time() > attackEndTime || !EnemyVisible() || !CanHitEnemyFromAnim( "range_attack_loop" ) ) {
                crouch_fire = false;
                SetAnimPrefix( "" );
                parms->stage = STAGE_FINISH;
                return SRESULT_WAIT;
            }
            LookAtEnemy( 1.0f );
            return SRESULT_WAIT;
        case STAGE_FINISH:
            crouch_fire = false;
            if ( InAnimState( ANIMCHANNEL_TORSO, "Torso_CrouchAttack" ) ) { return SRESULT_WAIT; }
            nextAttack = RandomDelay( ZOMBIE_CGUN_ATTACK_DELAY_MIN, ZOMBIE_CGUN_ATTACK_DELAY_MAX );
            nextNoFOVAttack = Time() + ZOMBIE_CGUN_NOFOVTIME;
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterZombieCommandoCGun::combat_dodge_left( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_WAIT_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "strafe";
            SetAnimState( ANIMCHANNEL_LEGS, "Legs_DodgeLeft", 8 );
            parms->stage = STAGE_WAIT_ACTION;
            return SRESULT_WAIT;
        case STAGE_WAIT_ACTION:
            if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
            nextDodge = DelayTime( ZOMBIE_CGUN_DODGE_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmMonsterZombieCommandoCGun::combat_dodge_right( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_WAIT_ACTION };
    switch ( parms->stage ) {
        case STAGE_START:
            StopMove();
            FaceEnemy();
            waitActionName = "strafe";
            SetAnimState( ANIMCHANNEL_LEGS, "Legs_DodgeRight", 8 );
            parms->stage = STAGE_WAIT_ACTION;
            return SRESULT_WAIT;
        case STAGE_WAIT_ACTION:
            if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
            nextDodge = DelayTime( ZOMBIE_CGUN_DODGE_RATE );
            return SRESULT_DONE;
    }
    return SRESULT_ERROR;
}