// AI_alphalabs2_scientist1.cpp
// Native state-machine replacement for ai_alphalabs2_scientist1.script.

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



void rvmAIAlphaLabs2Scientist1::Init( idAI* aiOwner ) {
    rvmAIObject::Init( aiOwner );
    SetState( "state_Begin" );
}

void rvmAIAlphaLabs2Scientist1::Destroy() {
    rvmAIObject::Destroy();
}

stateResult_t rvmAIAlphaLabs2Scientist1::RunStateByName( const char* stateName, stateParms_t* parms ) {
    AI_DISPATCH_STATE( "Head_Idle", Head_Idle );
    AI_DISPATCH_STATE( "Head_Death", Head_Death );
    AI_DISPATCH_STATE( "Head_DeathScene", Head_DeathScene );
    AI_DISPATCH_STATE( "Head_Greeting", Head_Greeting );
    AI_DISPATCH_STATE( "Head_Speech", Head_Speech );
    AI_DISPATCH_STATE( "Head_Hurry", Head_Hurry );
    AI_DISPATCH_STATE( "Head_StayClose", Head_StayClose );
    AI_DISPATCH_STATE( "Head_Electro_Pulses", Head_Electro_Pulses );
    AI_DISPATCH_STATE( "Head_Pulse1", Head_Pulse1 );
    AI_DISPATCH_STATE( "Head_Pulse2", Head_Pulse2 );
    AI_DISPATCH_STATE( "Head_WatchIt", Head_WatchIt );
    AI_DISPATCH_STATE( "Head_Spooked", Head_Spooked );
    AI_DISPATCH_STATE( "Head_Exit", Head_Exit );
    AI_DISPATCH_STATE( "Head_SayStuff", Head_SayStuff );
    AI_DISPATCH_STATE( "Head_Attacked", Head_Attacked );
    AI_DISPATCH_STATE( "Head_AttackDone", Head_AttackDone );
    AI_DISPATCH_STATE( "Torso_Work", Torso_Work );
    AI_DISPATCH_STATE( "Torso_DeathScene", Torso_DeathScene );
    AI_DISPATCH_STATE( "Torso_Death", Torso_Death );
    AI_DISPATCH_STATE( "Torso_Idle", Torso_Idle );
    AI_DISPATCH_STATE( "Torso_Pain", Torso_Pain );
    AI_DISPATCH_STATE( "Legs_Death", Legs_Death );
    AI_DISPATCH_STATE( "Legs_Idle", Legs_Idle );
    AI_DISPATCH_STATE( "Legs_Walk", Legs_Walk );
    AI_DISPATCH_STATE( "Legs_TurnLeft", Legs_TurnLeft );
    AI_DISPATCH_STATE( "Legs_TurnRight", Legs_TurnRight );
    AI_DISPATCH_STATE( "Legs_Cower", Legs_Cower );
    AI_DISPATCH_STATE( "light_fade1", light_fade1 );
    AI_DISPATCH_STATE( "light_fade2", light_fade2 );
    AI_DISPATCH_STATE( "doEvent", doEvent );
    AI_DISPATCH_STATE( "sayStuff", sayStuff );
    AI_DISPATCH_STATE( "hurry_up", hurry_up );
    AI_DISPATCH_STATE( "updatePlayerPositionThread", updatePlayerPositionThread );
    AI_DISPATCH_STATE( "checkBlocked", checkBlocked );
    AI_DISPATCH_STATE( "state_Killed", state_Killed );
    AI_DISPATCH_STATE( "state_DeathScene", state_DeathScene );
    AI_DISPATCH_STATE( "state_WorkingOnStuff", state_WorkingOnStuff );
    AI_DISPATCH_STATE( "state_NoticePlayer", state_NoticePlayer );
    AI_DISPATCH_STATE( "state_Wait", state_Wait );
    AI_DISPATCH_STATE( "state_GetCloser", state_GetCloser );
    AI_DISPATCH_STATE( "state_CantReachPlayer", state_CantReachPlayer );
    AI_DISPATCH_STATE( "state_Spooked", state_Spooked );
    AI_DISPATCH_STATE( "state_Lead", state_Lead );
    AI_DISPATCH_STATE( "state_FindPlayer", state_FindPlayer );
    AI_DISPATCH_STATE( "state_Cower", state_Cower );
    return rvmAIObject::RunStateByName( stateName, parms );
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_HEAD, "stand" ); parms->stage = 1; }
    return SRESULT_WAIT;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Death( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_DeathScene( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Greeting( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Speech( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Hurry( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_StayClose( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Electro_Pulses( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Pulse1( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Pulse2( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_WatchIt( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Spooked( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Exit( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_SayStuff( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_Attacked( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Head_AttackDone( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_HEAD, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_HEAD, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Torso_Work( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_TORSO, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Torso_DeathScene( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_TORSO, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Torso_Death( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_TORSO, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Torso_Idle( stateParms_t* parms ) {
    if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_TORSO, "stand" ); parms->stage = 1; }
    if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 4 ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Torso_Pain( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_TORSO, GetPainAnim() );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) { FinishAction( "pain" ); return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Legs_Death( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_LEGS, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_LEGS, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

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

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

stateResult_t rvmAIAlphaLabs2Scientist1::Legs_TurnLeft( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_LEGS, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_LEGS, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Legs_TurnRight( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_LEGS, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_LEGS, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::Legs_Cower( stateParms_t* parms ) {
    enum { STAGE_START, STAGE_ANIM };
    switch ( parms->stage ) {
        case STAGE_START:
            PlayAnim( ANIMCHANNEL_LEGS, "idle" );
            parms->stage = STAGE_ANIM;
            return SRESULT_WAIT;
        case STAGE_ANIM:
            if ( AnimDone( ANIMCHANNEL_LEGS, 4 ) ) { return SRESULT_DONE; }
            return SRESULT_WAIT;
    }
    return SRESULT_ERROR;
}

stateResult_t rvmAIAlphaLabs2Scientist1::light_fade1( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::light_fade2( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::doEvent( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::sayStuff( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::hurry_up( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::updatePlayerPositionThread( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::checkBlocked( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_Killed( stateParms_t* parms ) {
    StopMove();
    SetAnimState( ANIMCHANNEL_TORSO, "Torso_Death", 0 );
    SetAnimState( ANIMCHANNEL_LEGS, "Legs_Death", 0 );
    StopThinking();
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_DeathScene( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_WorkingOnStuff( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_NoticePlayer( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_Wait( stateParms_t* parms ) {
    if ( GetEnemy() ) { SetState( "state_Combat" ); return SRESULT_DONE; }
    return SRESULT_WAIT;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_GetCloser( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_CantReachPlayer( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_Spooked( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_Lead( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_FindPlayer( stateParms_t* parms ) {
    return SRESULT_DONE;
}

stateResult_t rvmAIAlphaLabs2Scientist1::state_Cower( stateParms_t* parms ) {
    return SRESULT_DONE;
}

void rvmAIAlphaLabs2Scientist1::faceTowardsEntity( idEntity* target, float duration ) {
}

void rvmAIAlphaLabs2Scientist1::light_fade_out( float fadeTime ) {
}

void rvmAIAlphaLabs2Scientist1::light_fade_in( float fadeTime ) {
}

void rvmAIAlphaLabs2Scientist1::light_fade( float stay_off ) {
}

float rvmAIAlphaLabs2Scientist1::checkDestinationDistance(  ) {
    return 0.0f;
}