---

---

AI_Actor.h

Go to the documentation of this file.

#ifndef AI_ACTOR_H
#define AI_ACTOR_H

#include "utils/AI_Array.h"
#include "AI_Obstacle.h"
#include "AI_AStar.h"
#include "AI_StateMachine.h"
#include "AI_State.h"
#include "AI_NavigationMesh.h"


class AI_Actor : public AI_Obstacle
{
//*** Embedded
public:
    enum ACT { 
        NONE,   
        WAIT,   
        WALK,   
        WANDER, 
        TURN,   
        ATTACK, 
        DEATH   
    };


    enum FEEDBACK {
        ATTACK_FINISHED = (1<<0),   
        HIT = (1<<1)                
    };

    enum ENEMY_TYPE {
        ET_HERO,            
        ET_OTHER_CLANS,     
        ET_CLAN             
    };

    class StateMachineSession : public AI_StateMachine::Session
    {
    private:
        AI_Actor *m_ptr_actor;
        AI_Ref<AI_Actor> m_ref_heard_enemy;
        float m_f_time_elapsed;
        float m_f_time_plan;

    public:
        StateMachineSession();

        void setActor(AI_Actor *ptr_actor);
        void setHeardEnemy(AI_Actor *ptr_actor);

        AI_Actor *getActor(void);
        AI_Actor *getHeardEnemy(void);

        void setTimePlan(const float f_time);
        const float getTimePlan(void);
        void resetTime(void);
        void addTime(const float f_time);
        const float getTime(void);
    };


    class StateAct : public AI_State
    {
    private:
        ACT m_act;

    public:
        StateAct(ACT i_act, ai_index i_index_out);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateStop : public AI_State
    {
    public:
        StateStop (ai_index i_index_out);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateChase : public AI_State
    {
    public:
        StateChase (ai_index i_index_out);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateAttack : public AI_State
    {
    public:
        StateAttack (ai_index i_index_out);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateWander : public AI_State
    {
    public:
        StateWander (ai_index i_index_out);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateIsSee : public AI_State
    {
    private:
        bool m_b_invisible; 

    public:
        StateIsSee (ai_index i_index_true, ai_index i_index_false, bool b_invisible = false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;

    private:
        const bool isSee(AI_Actor *ptr_actor_this, AI_Actor *ptr_actor_other) const;
    };


    class StateIsHear : public AI_State
    {
    public:
        StateIsHear (ai_index i_index_true, ai_index i_index_false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;

    private:
        const bool isHear(AI_Actor *ptr_actor_this, AI_Actor *ptr_actor_other, AI_Actor::StateMachineSession *ptr_session) const;
    };


    class StateIsAccessible : public AI_State
    {
    private:
        float m_f_pane_size;
        float m_f_two_pane_size;
        float m_f_three_pane_size;
        float m_f_four_pane_size;

    public:
        StateIsAccessible (ai_index i_index_true, ai_index i_index_false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    
    private:
        float convertWidthToPanes(const float f_width);
        void setPaneSize(const float f_pane_size);
    };


    class StateIsTouch : public AI_State
    {
    public:
        StateIsTouch (ai_index i_index_true, ai_index i_index_false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateIsInOptimum : public AI_State
    {
    public:
        StateIsInOptimum (ai_index i_index_true, ai_index i_index_false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateIsFeedback : public AI_State
    {
    private:
        FEEDBACK m_feedback;

    public:
        StateIsFeedback (FEEDBACK dw_feedback, ai_index i_index_true, ai_index i_index_false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateIsInRange : public AI_State
    {
    public:
        StateIsInRange (ai_index i_index_true, ai_index i_index_false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    class StateIsAct : public AI_State
    {
    public:
        typedef enum ACTOR {
            ME,
            ENEMY,
            CHASED
        };

    private:
        AI_Actor::ACT m_act;
        ACTOR m_actor;

    public:
        StateIsAct (AI_Actor::ACT act, AI_Actor::StateIsAct::ACTOR actor, ai_index i_index_true, ai_index i_index_false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };

    class StateTimePlan : public AI_State
    {
    public:
        float m_f_time_min;
        float m_f_time_max;

    public:
        StateTimePlan (float f_time, ai_index i_index_true);
        StateTimePlan (float f_time_min, float f_time_max, ai_index i_index_true);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };

    class StateIsTimePlan : public AI_State
    {
    public:
        StateIsTimePlan (ai_index i_index_true, ai_index i_index_false);
        virtual ai_index step(AI_StateMachine::Session *ptr_session);
        virtual bool isInterrupt( void ) const;
    };


    typedef AI_Array<AI_Actor*> ActorArray;
    typedef ActorArray::iterator ActorArrayIt;

//*** Attributes
private:
    //*** General
    AI_Ref<AI_Actor> m_ref_actor_chased;
    AI_Ref<AI_Actor> m_ref_actor_enemy;
    AI_Ref<AI_Actor> m_ref_actor_attacker;
    ai_dword m_dw_feedback;
    AgentArray m_arr_near_agents;
    ObstacleArray m_arr_near_obstacles;
    ActorArray m_arr_near_actors;
    AgentArray m_arr_near_items;
    ActorArray m_arr_near_enemies;
    float m_f_near_agents_distance;
    ai_dword m_dw_db_version;

    //*** Orientation in space
    AI_Vector3 m_v_dest;
    AI_Vector3 m_v_dest_prev;
    AI_NavigationMesh::Session m_session_navmesh;
    AI_Array<AI_Vector3> m_arr_way;
    AI_Vector3 m_v_pivot;
    AI_Vector2 m_v_feeler_tip;
    float m_f_feeler_length;
    float m_f_pivot_distance;
    int m_i_actual_way_point;
    float m_f_fov;
    float m_f_turn_direction;
    float m_f_wall_evasive_direction;
    float m_f_desired_angle;
    float m_f_wander_deviation;
    double m_d_dest_check_period;
    AI_Vector3 m_v_segment_direction;
    float m_f_way_length;

    //*** Behaviour
    int m_i_act;
    int m_i_act_next;
    AI_StateMachine *m_ptr_state_machine;
    StateMachineSession m_session_state_machine;
    AI_Vector3 m_v_walk_direction;

    //*** Characteristic
    double m_d_reflex;
    float m_f_linear_velocity;
    float m_f_angular_velocity;
    float m_f_sight;
    float m_f_earshot;
    float m_f_range;
    float m_f_optimal_dist;
    float m_f_chase_dist;
    int m_i_clan;
    int m_i_enemy_clan;
    ENEMY_TYPE m_enemy_type;

    //*** Timestamps
    double m_d_time_state_machine;
    double m_d_time_near_agents;
    double m_d_time_dest_check;

    double m_d_time_sleep;
    double m_d_time_sleep_plan;
double m_d_time_touch;

    //flags
    struct {
        bool m_b_ai_enable : 1;
        bool m_b_new_near_obstacles : 1;
        bool m_b_new_near_actors : 1;
        bool m_b_new_near_items : 1;
        bool m_b_new_near_enemies : 1;
        bool m_b_on_path : 1;
        bool m_b_heading_pivot : 1;
        bool m_b_replan_path : 1;
        bool m_b_attack_finished : 1;
        bool m_b_sleep : 1;
        bool m_b_visible : 1;
        bool m_b_noise : 1;
        bool m_b_fixed_feeler_length : 1;
        bool m_b_fixed_pivot_distance : 1;
        bool m_b_untouchable : 1;
    };

public:
    //*** Constructors & destructors
    AI_Actor(void);
    ~AI_Actor(void);

    //*** General
    void trigger( double d_time );
    void setLockedChased( AI_Actor *ptr_actor );
    AI_Actor *getLockedChased( void );
    void setLockedEnemy( AI_Actor *ptr_actor );
    void setAttacker( AI_Actor *ptr_attacker );
    AI_Actor *getLockedEnemy( void );
    AI_Actor *getAttacker( void );
    bool updateNearAgents( const float f_distance );
    AgentArray &getNearAgents( const float f_distance );
    ActorArray &getNearActors( const float f_distance );
    ObstacleArray &getNearObstacles( const float f_distance );
    ActorArray &getNearEnemies( const float f_distance );
    const bool isEnemy( AI_Actor *ptr_actor );
    virtual void setEnable( const bool b_enable );

    //*** Orientation in space
    const AI_Vector3 &getDestination( void );
    AI_NavigationMesh::Session &getNavmeshSession( void );
    void clearWay( void );
    int getWaySize( void ) const;
    AI_Vector3 &getWayPoint( int i ) const;
    const bool isTouch( AI_Obstacle *ptr_agent_other, const float f_tolerance ) const;
    const bool isCollision( AI_Obstacle *ptr_obstacle, const double d_time ) const;
    const AI_Vector3 &getWalkDirection( void ) const;
    const AI_Vector3 &getWalkWayPoint( void ) const;
    const AI_Vector2 &getFeelerTip( void ) const;
    const AI_Vector3 &getPivot( void ) const;
    const float getTurnDirection( void ) const;
    const float getDesiredAngle( void ) const;
    const float getWayLength( void );
    bool isOnSurface(void);
    bool getNearestSurfacePosition(AI_Vector3 &v_nearest_position);

    //*** Behaviour
    void setAIEnable (bool b_ai = true);
    bool isAIEnable (void) const;
    void setStateMachine( AI_StateMachine *ptr_state_machine );
    AI_StateMachine *getStateMachine( void );
    AI_StateMachine::Session &getStateMachineSession( void );
    void setAct(int i_act);
    int getAct(void) const;
    const AI_Actor *getAttackTarget( void );
    const bool isSleeping(void) const;
    void setFeelerLength(bool b_fixed, float f_length = -1);
    void setPivotDistance(bool b_fixed, float f_distance = -1);
    const float getFeelerLength(void) const;
    const float getPivotDistance(void) const;

    //*** Characteristics
    void setRefex( const double d_reflex );
    void setLinearVelocity( const float f_linear_velocity );
    void setAngularVelocity( const float f_angular_velocity );
    void setClan( const int i_clan );
    void setEnemyClan( const int i_clan );
    void setEnemyType( const ENEMY_TYPE type );
    void setSight( const float f_sight );
    void setEarshot( const float f_earshot );
    void setFOV( const float f_fov );
    void setRange( const float f_range );
    void setOptimalDistance( const float f_dist );
    void setChaseDistance( const float f_dist );
    virtual void setWidth( const float f_width );
    void setVisible( const bool b );
    void setNoise( const bool b );
    void setUntouchable( const bool b );
    const float getAngularVelocity( void ) const;

    const double getReflex( void ) const;
    const float getLinearVelocity( void ) const;
    const int getClan( void ) const;
    const int getEnemyClan( void ) const;
    const ENEMY_TYPE getEnemyType( void ) const;
    const float getSight( void ) const;
    const float getEarshot( void ) const;
    const float getFOV( void ) const;
    const float getRange( void ) const;
    const float getOptimalDistance( void ) const;
    const float getChaseDistance( void ) const;
    const bool isVisible(void) const;
    const bool isNoise(void) const;
    const bool isUntouchable(void) const;

    //*** Commands
    void walkTo(const AI_Vector3 &v_dest);
    void wander( void );
    void turnTo(const float f_angle);
    void chaseActor(AI_Actor *ptr_actor);
    void attack(AI_Actor *ptr_actor);
    void stop(void);
    void die(void);
    void reset(void);

    //*** Feedback
    void sendFeedback(FEEDBACK dw_feedback);
    bool checkFeedback(ai_dword dw_feedback);
    void clearFeedback(ai_dword dw_feedback);
    void flushFeedback(void);

protected:
    void updateWait( const double d_time );
    void updateWalkDirection( const double d_time );
    void updateWandering( const double d_time );
    void updateOrientation( const double d_time );
    void updateAttack( const double d_time );
    bool findWay( void );
    void updatePivot( const double d_time );
    void updateFeeler( void );
    void updateDestination( const double d_time );
    AI_Obstacle *findNearestObstacle( const double d_time, float &f_obstacle_distance );
    float findNearestWall( float &f_wall_distance );
    const bool findInitialWay( void );
    void avoidObstacle( AI_Obstacle *ptr_obstacle, const double d_time );
    void avoidWall( const float f_dir, const double d_time );
    void goBackToPath( const double d_time );
    void doJink( const float f_evasive_angle );
    bool isDesiredAngle( const double d_time );
    void updateSteeringLengths( void );
    void makeDesiredAngleFromDirection( AI_Vector3 &v_direction );
    void makeTurnDirection( void );
    void changeWayPoint( void );
    bool isFinishReached(const double d_time, AI_Obstacle *ptr_obstacle, const bool b_obstruct_dest );
    void makePositionPrediction( AI_Vector3 &v_position, const double d_time ) const;
    void sleep( const double d_time );
    const bool detectDeadWayWall( const float f_walk_evasive_direction, const float f_wall_distance );
    const bool detectDeadWayObstacle( const double d_time, AI_Obstacle *ptr_obstacle, const float f_obstacle_distance );
    const bool detectDeadWayFarFromPath( void );
    AI_Obstacle *checkObstacleWhileWalking( AI_Obstacle *ptr_obstacle, const float f_obstacle_distance, bool &b_obstruct_dest );
};


inline
AI_Actor::StateAct::StateAct(ACT i_act, ai_index i_index_out)
{
    m_act = i_act;
    m_i_true_state = i_index_out;
}


inline
AI_Actor::StateStop::StateStop (ai_index i_index_out)
{
    m_i_true_state = i_index_out;
}


inline
AI_Actor::StateChase::StateChase (ai_index i_index_out)
{
    m_i_true_state = i_index_out;
}


inline
AI_Actor::StateAttack::StateAttack (ai_index i_index_out)
{
    m_i_true_state = i_index_out;
}


inline
AI_Actor::StateWander::StateWander (ai_index i_index_out)
{
    m_i_true_state = i_index_out;
}


inline
AI_Actor::StateIsSee::StateIsSee (ai_index i_index_true, ai_index i_index_false, bool b_invisible)
{
    m_b_invisible = b_invisible;
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
}


inline
AI_Actor::StateIsHear::StateIsHear (ai_index i_index_true, ai_index i_index_false)
{
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
}


inline
AI_Actor::StateIsAccessible::StateIsAccessible (ai_index i_index_true, ai_index i_index_false)
{
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
}


inline
AI_Actor::StateIsTouch::StateIsTouch (ai_index i_index_true, ai_index i_index_false)
{
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
}


inline
AI_Actor::StateIsInOptimum::StateIsInOptimum (ai_index i_index_true, ai_index i_index_false)
{
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
}


inline
AI_Actor::StateIsFeedback::StateIsFeedback (FEEDBACK dw_feedback, ai_index i_index_true, ai_index i_index_false)
{
    m_feedback = dw_feedback;
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
}


inline
AI_Actor::StateIsInRange::StateIsInRange (ai_index i_index_true, ai_index i_index_false)
{
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
}


inline
AI_Actor::StateIsAct::StateIsAct (AI_Actor::ACT act, AI_Actor::StateIsAct::ACTOR actor, ai_index i_index_true, ai_index i_index_false)
{
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
    m_act = act;
    m_actor = actor;
}


inline
AI_Actor::StateTimePlan::StateTimePlan (float f_time, ai_index i_index_true)
{
    m_i_true_state = i_index_true;
    m_f_time_min = m_f_time_max = f_time;
}


inline
AI_Actor::StateTimePlan::StateTimePlan (float f_time_min, float f_time_max, ai_index i_index_true)
{
    m_i_true_state = i_index_true;
    m_f_time_min = f_time_min;
    m_f_time_max = f_time_max;
}


inline
AI_Actor::StateIsTimePlan::StateIsTimePlan (ai_index i_index_true, ai_index i_index_false)
{
    m_i_true_state = i_index_true;
    m_i_false_state = i_index_false;
}


inline
AI_Actor::StateMachineSession::StateMachineSession() :
    m_f_time_elapsed(0),
    m_f_time_plan(-1.0f)
{
}


inline
void AI_Actor::StateMachineSession::setActor(AI_Actor *ptr_actor)
{
    m_ptr_actor = ptr_actor;
}


inline
AI_Actor *AI_Actor::StateMachineSession::getActor(void)
{
    return m_ptr_actor;
}


inline
void AI_Actor::StateMachineSession::setHeardEnemy(AI_Actor *ptr_actor)
{
    m_ref_heard_enemy = ptr_actor;
}


inline
AI_Actor *AI_Actor::StateMachineSession::getHeardEnemy(void)
{
    return m_ref_heard_enemy.get_unsafe();
}


inline
void AI_Actor::StateMachineSession::setTimePlan(const float f_time)
{
    m_f_time_plan = f_time;
}


inline
const float AI_Actor::StateMachineSession::getTimePlan(void)
{
    return m_f_time_plan;
}


inline
void AI_Actor::StateMachineSession::resetTime(void)
{
    m_f_time_elapsed = 0;
}


inline
void AI_Actor::StateMachineSession::addTime(const float f_time)
{
    m_f_time_elapsed += f_time;
}


inline
const float AI_Actor::StateMachineSession::getTime(void)
{
    return m_f_time_elapsed;
}


inline
bool AI_Actor::StateAct::isInterrupt( void ) const
{
    return true;
}


inline
bool AI_Actor::StateStop::isInterrupt( void ) const
{
    return true;
}


inline
bool AI_Actor::StateChase::isInterrupt( void ) const
{
    return true;
}


inline
bool AI_Actor::StateAttack::isInterrupt( void ) const
{
    return true;
}


inline
bool AI_Actor::StateWander::isInterrupt( void ) const
{
    return true;
}


inline
bool AI_Actor::StateIsSee::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateIsHear::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateIsAccessible::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateIsTouch::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateIsInOptimum::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateIsFeedback::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateIsInRange::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateIsAct::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateTimePlan::isInterrupt( void ) const
{
    return false;
}


inline
bool AI_Actor::StateIsTimePlan::isInterrupt( void ) const
{
    return false;
}


inline
const AI_Vector3 &AI_Actor::getDestination( void )
{
    return m_v_dest;
}


inline
AI_NavigationMesh::Session &AI_Actor::getNavmeshSession( void )
{
    return m_session_navmesh;
}


inline
AI_Vector3 &AI_Actor::getWayPoint( int i ) const
{
    return m_arr_way[i];
}


inline
void AI_Actor::clearWay( void )
{
    m_arr_way.Reset();
}


inline
int AI_Actor::getWaySize( void ) const
{
    return m_arr_way.Size();
}


inline
const float AI_Actor::getWayLength( void )
{
    if ( !m_f_way_length )
    {
        for (int i=1; i<m_arr_way.Size(); i++)
            m_f_way_length += (m_arr_way[i-1]-m_arr_way[i]).len();
    }
    return m_f_way_length;
}


inline
void AI_Actor::setLockedChased( AI_Actor *ptr_actor )
{
    m_ref_actor_chased = ptr_actor;
}


inline
void AI_Actor::setLockedEnemy( AI_Actor *ptr_actor )
{
    m_ref_actor_enemy = ptr_actor;
}


inline
void AI_Actor::setAttacker( AI_Actor *ptr_attacker )
{
    m_ref_actor_attacker = ptr_attacker;
}


inline
AI_Actor *AI_Actor::getLockedChased( void )
{
    return m_ref_actor_chased.get_unsafe();
}


inline
AI_Actor *AI_Actor::getLockedEnemy( void )
{
    if ( m_ref_actor_enemy.isvalid() && !isEnemy( m_ref_actor_enemy.get_unsafe() ) )
        m_ref_actor_enemy.invalidate();

    return m_ref_actor_enemy.get_unsafe();
}


inline
AI_Actor *AI_Actor::getAttacker( void )
{
    return m_ref_actor_attacker.get_unsafe();
}


inline
void AI_Actor::setAIEnable (bool b_ai /*= true*/)
{
    m_b_ai_enable = b_ai;
}


inline
bool AI_Actor::isAIEnable (void) const
{
    return ( m_b_ai_enable && m_ptr_state_machine );
}


inline
void AI_Actor::setStateMachine( AI_StateMachine *ptr_state_machine )
{
    m_ptr_state_machine = ptr_state_machine;
}


inline
AI_StateMachine *AI_Actor::getStateMachine( void )
{
    return m_ptr_state_machine;
}


inline
AI_StateMachine::Session &AI_Actor::getStateMachineSession( void )
{
    return m_session_state_machine;
}


inline
void AI_Actor::setAct(int i_act)
{
    m_i_act = i_act;
}


inline
int AI_Actor::getAct(void) const
{
    return m_i_act;
}


inline
const AI_Vector3 &AI_Actor::getWalkDirection( void ) const
{
    return m_v_walk_direction;
}


inline
const AI_Vector3 &AI_Actor::getWalkWayPoint( void ) const
{
    return getWayPoint(m_i_actual_way_point); 
}


inline
void AI_Actor::setRefex( const double d_reflex )
{
    m_d_reflex = d_reflex;
    m_d_time_state_machine = m_d_reflex;
}


inline
const double AI_Actor::getReflex( void ) const
{
    return m_d_reflex;
}


inline
void AI_Actor::setLinearVelocity( const float f_linear_velocity )
{
    m_f_linear_velocity = f_linear_velocity;
    updateSteeringLengths();
}


inline
void AI_Actor::setAngularVelocity( const float f_angular_velocity )
{
    m_f_angular_velocity = f_angular_velocity;
}


inline
const float AI_Actor::getAngularVelocity( void ) const
{
    return m_f_angular_velocity;
}


inline
const float AI_Actor::getLinearVelocity( void ) const
{
    return m_f_linear_velocity;
}


inline
void AI_Actor::walkTo(const AI_Vector3 &v_dest)
{
    //if ( !(getAct()==WALK || m_b_sleep || (getAct()==TURN && m_i_act_next==WALK) ) )
    if ( !(getAct()==WALK || (m_b_sleep && m_i_act_next==WALK) || (getAct()==TURN && m_i_act_next==WALK) ) )
    {
        stop();

        setAct( TURN );
        m_i_act_next = WALK;

        m_v_dest = m_v_dest_prev = v_dest;
        m_b_replan_path = true;
    }
    else if ( getLockedChased() )
    {
        m_v_dest = m_v_dest_prev = v_dest;
        m_b_replan_path = true;
    }

    m_v_dest = v_dest;
    setLockedChased( NULL );
}


inline
void AI_Actor::turnTo(const float f_angle)
{
    if ( !(getAct()==TURN && m_i_act_next==NONE) )
    {
        stop();
        setAct(TURN);
        m_f_desired_angle = f_angle;
    }
}


inline
void AI_Actor::setSight( const float f_sight )
{
    m_f_sight = f_sight;
}


inline
const float AI_Actor::getSight( void ) const
{
    return m_f_sight;
}


inline
void AI_Actor::setEarshot( const float f_earshot )
{
    m_f_earshot = f_earshot;
}


inline
const float AI_Actor::getEarshot( void ) const
{
    return m_f_earshot;
}


inline
void AI_Actor::sendFeedback(FEEDBACK dw_feedback)
{
    m_dw_feedback |= dw_feedback;

    if ( dw_feedback & ATTACK_FINISHED )
    {
        m_b_attack_finished = true;
    }
}


inline
bool AI_Actor::checkFeedback(ai_dword dw_feedback)
{
    return ((m_dw_feedback & dw_feedback)==dw_feedback) ? true : false;
}


inline
void AI_Actor::clearFeedback(ai_dword dw_feedback)
{
    m_dw_feedback &= ~dw_feedback;
}


inline
void AI_Actor::flushFeedback(void)
{
    m_dw_feedback = 0;
}


inline
void AI_Actor::setFOV( const float f_fov )
{
    m_f_fov = f_fov;
}


inline
const float AI_Actor::getFOV( void ) const
{
    return m_f_fov;
}


inline
void AI_Actor::setRange( const float f_range )
{
    m_f_range = f_range;
}


inline
const float AI_Actor::getRange( void ) const
{
    return m_f_range;
}


inline
void AI_Actor::setOptimalDistance( const float f_dist )
{
    m_f_optimal_dist = f_dist;
}


inline
void AI_Actor::setChaseDistance( const float f_dist )
{
    m_f_chase_dist = f_dist;
}


inline
const float AI_Actor::getOptimalDistance( void ) const
{
    return m_f_optimal_dist;
}


inline
const float AI_Actor::getChaseDistance( void ) const
{
    return m_f_chase_dist;
}


inline
void AI_Actor::die(void)
{
    stop();
    setAct( DEATH );
}


inline
void AI_Actor::makePositionPrediction( AI_Vector3 &v_position, const double d_time ) const
{
    if ( d_time && getAct()==WALK )
    {
        AI_Vector3 v_dir( m_v_walk_direction );
        v_dir.norm();

        v_position = getPosition() + v_dir * (float)d_time * m_f_linear_velocity;
    }
    else
    {
        v_position = getPosition();
    }
}


inline
const bool AI_Actor::isTouch( AI_Obstacle *ptr_obstacle, const float f_tolerance ) const
{
    AI_Vector3 v_dist = ptr_obstacle->getPosition() - getPosition();
    v_dist.y = 0;
    float f_dist = v_dist.len();

    float f_touch = getWidth() + ptr_obstacle->getWidth() + f_tolerance;

    return ( f_dist <= f_touch );
}


inline
const bool AI_Actor::isCollision( AI_Obstacle *ptr_obstacle, const double d_time ) const
{
    //*** Predict actor's position
    AI_Vector3 v_position;
    makePositionPrediction( v_position, d_time );

    //*** Predict obstacle position
    AI_Vector3 v_other_position;
    if ( ptr_obstacle->getType()==ACTOR )
    {
        ((AI_Actor*)ptr_obstacle)->makePositionPrediction( v_other_position, d_time );
    }
    else
    {
        v_other_position = ptr_obstacle->getPosition();
    }

    //*** Test if obstacles in predicted positions will touch
    return ai_isInRange( v_position, v_other_position, getWidth() + ptr_obstacle->getWidth() );

    //AI_Vector3 v_dist = v_other_position - v_position;
    //v_dist.y = 0;
    //float f_dist = v_dist.len();

    //float f_touch = getWidth() + ptr_obstacle->getWidth();

    //return ( f_dist <= f_touch );
}


inline
const AI_Vector2 &AI_Actor::getFeelerTip( void ) const
{
    return m_v_feeler_tip;
}


inline
const AI_Vector3 &AI_Actor::getPivot( void ) const
{
    return m_v_pivot;
}


inline
void AI_Actor::avoidWall( const float f_dir, const double d_time )
{
    doJink( m_f_angular_velocity * (float)d_time * f_dir );

    m_b_on_path = false;
    m_b_heading_pivot = false;
}


inline
void AI_Actor::doJink( const float f_evasive_angle )
{
    AI_Quaternion q;
    q.set_rotate_y( f_evasive_angle );

    m_v_walk_direction = q.rotate( m_v_walk_direction );
}


inline
void AI_Actor::updateSteeringLengths( void )
{
    if (!m_b_fixed_feeler_length)
        m_f_feeler_length = AI_PIVOT_MAX_LEADING * m_f_linear_velocity + m_f_width;
    
    if (!m_b_fixed_pivot_distance)
        m_f_pivot_distance = AI_PIVOT_MAX_DISTANCE * m_f_linear_velocity + m_f_width;
}


inline
void AI_Actor::makeDesiredAngleFromDirection( AI_Vector3 &v_direction )
{
    v_direction.y = 0;
    v_direction.norm();

    m_f_desired_angle = ai_acos( v_direction.x );
    if ( v_direction.z > 0.0f )
        m_f_desired_angle = AI_2PI - m_f_desired_angle; //flip angle
}


inline
void AI_Actor::makeTurnDirection( void )
{
    if (m_f_desired_angle > m_v_orientation.y)
    {
        if ( (m_f_desired_angle - m_v_orientation.y) < AI_PI )
            m_f_turn_direction = 1.0f;
        else
            m_f_turn_direction = -1.0f;
    }
    else
    {
        if ( (m_v_orientation.y - m_f_desired_angle) < AI_PI )
            m_f_turn_direction = -1.0f;
        else
            m_f_turn_direction = 1.0f;
    }
}


inline
const float AI_Actor::getTurnDirection( void ) const
{
    return m_f_turn_direction;
}


inline
void AI_Actor::changeWayPoint( void )
{
    m_i_actual_way_point++;
                        
    m_v_segment_direction = getWayPoint(m_i_actual_way_point) - getWayPoint(m_i_actual_way_point-1);
    m_v_segment_direction.norm();
}


inline
bool AI_Actor::isDesiredAngle( const double d_time )
{
    return ( abs(m_f_desired_angle - m_v_orientation.y) <= m_f_angular_velocity * (float)d_time );
}


inline
void AI_Actor::stop( void )
{
    setAct(WAIT);
    m_i_act_next = NONE;

    m_f_turn_direction = 0;
    m_b_sleep = false;
    m_b_attack_finished = false;
    m_b_replan_path = false;
}


inline
void AI_Actor::sleep( const double d_time )
{
    stop();
    
    m_b_sleep = true;
    m_d_time_sleep_plan = d_time;
    m_d_time_sleep = 0;
}


inline
void AI_Actor::reset( void )
{
    stop();
    m_session_state_machine.reset();
    m_d_time_state_machine = m_d_reflex;
}


inline
void AI_Actor::setClan( const int i_clan )
{
    if ( getEnemyType()==ET_OTHER_CLANS )
    {   m_ref_actor_enemy.invalidate();
        m_b_new_near_enemies = true;
    }

    m_i_clan = i_clan;
}


inline
void AI_Actor::setEnemyClan( const int i_clan )
{
    if ( getEnemyType()==ET_CLAN && m_i_enemy_clan!=i_clan )
    {   m_ref_actor_enemy.invalidate();
        m_b_new_near_enemies = true;
    }

    m_i_enemy_clan = i_clan;
}


inline
const int AI_Actor::getClan( void ) const
{
    return m_i_clan;
}


inline
const int AI_Actor::getEnemyClan( void ) const
{
    return m_i_enemy_clan;
}


inline
void AI_Actor::setVisible( const bool b )
{
    m_b_visible = b;
}


inline
void AI_Actor::setNoise( const bool b )
{
    m_b_noise = b;
}


inline
const bool AI_Actor::isVisible(void) const
{
    return m_b_visible;
}


inline
const bool AI_Actor::isNoise(void) const
{
    return m_b_noise;
}


inline
void AI_Actor::setEnemyType( const AI_Actor::ENEMY_TYPE type )
{
    if ( m_enemy_type!=type && type!=ET_HERO )
        m_b_new_near_enemies = true;

    m_enemy_type = type;


}


inline
const AI_Actor::ENEMY_TYPE AI_Actor::getEnemyType( void ) const
{
    return m_enemy_type;
}


inline
AI_Agent::AgentArray &AI_Actor::getNearAgents( const float f_distance )
{
    updateNearAgents( f_distance );
    return m_arr_near_agents;
}


inline
const bool AI_Actor::isSleeping(void) const
{
    return m_b_sleep;
}


inline
const float AI_Actor::getDesiredAngle( void ) const
{
    return m_f_desired_angle;
}


inline
void AI_Actor::setFeelerLength(bool b_fixed, float f_length)
{
    m_b_fixed_feeler_length = b_fixed;
    if (f_length>=0)
        m_f_feeler_length = f_length;
}


inline
void AI_Actor::setPivotDistance(bool b_fixed, float f_distance)
{
    m_b_fixed_pivot_distance = b_fixed;
    if (f_distance>=0)
        m_f_pivot_distance = f_distance;
}


inline
const float AI_Actor::getFeelerLength(void) const
{
    return m_f_feeler_length;
}


inline
const float AI_Actor::getPivotDistance(void) const
{
    return m_f_pivot_distance;
}


inline
void AI_Actor::setUntouchable( const bool b )
{
    m_b_untouchable = b;
}


inline
const bool AI_Actor::isUntouchable(void) const
{
    return m_b_untouchable;
}


#endif

---

InExIn pages are hosted by
InExIn documentation generated by doxygen at Tue Dec 18 12:55:27 2007