---

---

AI_World.h

Go to the documentation of this file.

#ifndef AI_WORLD_H
#define AI_WORLD_H

#include "utils/AI_List.h"
#include "AI_NavigationMesh.h"
#include "AI_Actor.h"


class AI_World
{
//*** Attributes
protected:
    AI_List m_list_agents;
    AI_NavigationMesh m_navigation_mesh;
    AI_SDB_SpatialAABBTree m_spatial_tree;
    AI_SDB_VisibilityVisitor::VisibleElements m_visible_elements;
    float m_f_enable_dist;
    float m_f_disable_dist;
    AI_Ref<AI_Actor> m_ref_actor_pivot;
    AI_Ref<AI_Actor> m_ref_hero;
    ai_dword m_dw_db_version;
    double m_d_time_auto_enable;

    AI_Actor::ActorArray m_arr_enabled_actors;
    AI_Actor::ActorArray m_arr_temp_actors;

    struct {
        bool m_b_auto_enable : 1;
        bool m_b_auto_disable : 1;
        bool m_b_wide_agents : 1;
    };

public:
    AI_World(void);
    ~AI_World(void);

    //run
    void trigger (double d_time);
    bool findWay( AI_Actor &actor );
    bool testVisibility( const AI_Vector3 &v_first, const AI_Vector3 &v_second);
    const bool testWallDistance( const AI_Vector3 &v_first, const AI_Vector3 &v_second, float &f_distance );
    bool isOnSurface(const AI_Vector3 &v_pos);
    bool getNearestSurfacePosition(const AI_Vector3 &v_position,float radius,bool cylinder,AI_Vector3 &v_nearest_position);

    //creation
    bool addAgent( AI_Agent *ptr_agent );
    void removeAgent( AI_Agent *ptr_agent );

    //sets
    void setAutoEnable( bool b_enable );
    void setAutoDisable( bool b_enable );
    void setAutoEnableDisablePivot( AI_Actor *ptr_actor );
    void setAutoEnableDistance( const float f_dist );
    void setAutoDisableDistance( const float f_dist );
    void setWideAgents( bool b );
    void setHero( AI_Actor *ptr_actor );

    //gets
    AI_NavigationMesh &getNavigationMesh( void );
    bool isAutoEnable( void ) const;
    bool isAutoDisable( void ) const;
    const float getAutoEnableDistance( void ) const;
    const float getAutoDisableDistance( void ) const;
    AI_Actor *getAutoEnableDisablePivot( void );
    bool isWideAgents( void );
    const ai_dword getDBVersion( void );
    AI_Actor *getHero( void );
    AI_Actor::ActorArray &getEnabledActors(void);

    //others
    void updateSpatialElement( AI_SDB_SpatialElement *ptr_spatial_element, const AI_BBox &bbox_new );
    void getNearAgents( const AI_Vector3 &v_position, const float f_range, AI_Agent::AgentArray &arr_near_agents, AI_Agent *ptr_agent_exclude = NULL );
    void enableActor( AI_Actor *ptr_actor );
    void disableActor( AI_Actor *ptr_actor );

private:
    void increaseDBVersion( void );
};


inline
AI_World::AI_World(void) :
    m_b_auto_enable(false),
    m_b_auto_disable(false),
    m_f_enable_dist(10.0f),
    m_f_disable_dist(20.0f),
    m_dw_db_version(0),
    m_d_time_auto_enable(AI_AUTO_ENABLE_CHECK)
{
}


inline
AI_World::~AI_World(void)
{
}


inline
bool AI_World::addAgent(AI_Agent *ptr_agent)
{
    //*** Add agent in the world
    m_list_agents.AddTail(ptr_agent);
    ptr_agent->setWorld( this );

    //*** Add agent in the spatial tree
    AI_BBox bbox_agent ( ptr_agent->getPosition(), ptr_agent->getAura() );
    AI_SDB_BBoxSpatialElement *ptr_element = new AI_SDB_BBoxSpatialElement( bbox_agent );

    ptr_agent->setSpatialElement( ptr_element );
    ptr_element->SetPtr( ptr_agent );

    m_spatial_tree.AddElement ( ptr_element );
    increaseDBVersion();

    return true;
}


inline
void AI_World::removeAgent(AI_Agent *ptr_agent)
{
    //*** Remove from spatial database
    m_spatial_tree.RemoveElement( ptr_agent->getSpatialElement() );
    increaseDBVersion();

    //*** Remove from list
    ptr_agent->Remove();

    //*** Reset world
    ptr_agent->setWorld( NULL );

    //*** Reset pivot
    if ( ptr_agent==m_ref_actor_pivot.get_unsafe() )
        m_ref_actor_pivot.invalidate();

    //*** Disable
    ptr_agent->setEnable( false );
    if ( ptr_agent->getType()==AI_Agent::ACTOR )
        disableActor( (AI_Actor*)ptr_agent );
}


inline
AI_NavigationMesh &AI_World::getNavigationMesh( void )
{
    return m_navigation_mesh;
}


inline
bool AI_World::findWay( AI_Actor &actor )
{
    return m_navigation_mesh.findWay( actor.getNavmeshSession() );
}


inline
bool AI_World::isOnSurface(const AI_Vector3 &v_pos)
{
    return m_navigation_mesh.identifyTriangle(v_pos) ? true : false;
}


inline
bool AI_World::getNearestSurfacePosition(const AI_Vector3 &v_position,float radius,bool cylinder,AI_Vector3 &v_nearest_position)
{
    return m_navigation_mesh.getNearestPosition(v_position,radius,cylinder,v_nearest_position);
}


inline
bool AI_World::testVisibility( const AI_Vector3 &v_first, const AI_Vector3 &v_second)
{
    return m_navigation_mesh.testVisibility( v_first, v_second );
}


inline
const bool AI_World::testWallDistance( const AI_Vector3 &v_first, const AI_Vector3 &v_second, float &f_distance )
{
    return m_navigation_mesh.testBorderIntersection(v_first, v_second, f_distance);
}


inline
void AI_World::setAutoEnable( bool b_enable )
{
    m_b_auto_enable = b_enable;
}


inline
void AI_World::setAutoDisable( bool b_enable )
{
    m_b_auto_disable = b_enable;
}


inline
bool AI_World::isAutoEnable( void ) const
{
    return m_b_auto_enable;
}


inline
bool AI_World::isAutoDisable( void ) const
{
    return m_b_auto_disable;
}


inline
void AI_World::setAutoEnableDisablePivot( AI_Actor *ptr_actor )
{
    if ( ptr_actor->getWorld()!=this )
    {   ai_log(AI_STR_AGENT_ISNT_IN_WORLD);
        return;
    }

    m_ref_actor_pivot = ptr_actor;
    
    ptr_actor->setEnable(true);
}


inline
AI_Actor *AI_World::getAutoEnableDisablePivot( void )
{
    return m_ref_actor_pivot.get_unsafe();
}


inline
void AI_World::setAutoEnableDistance( const float f_dist )
{
    m_f_enable_dist = f_dist;
}


inline
void AI_World::setAutoDisableDistance( const float f_dist )
{
    m_f_disable_dist = f_dist;
}


inline
const float AI_World::getAutoEnableDistance( void ) const
{
    return m_f_enable_dist;
}


inline
const float AI_World::getAutoDisableDistance( void ) const
{
    return m_f_disable_dist;
}


inline
void AI_World::updateSpatialElement( AI_SDB_SpatialElement *ptr_spatial_element, const AI_BBox &bbox_new )
{
    m_spatial_tree.MoveElement( ptr_spatial_element, bbox_new );
}


inline
void AI_World::setWideAgents( bool b )
{
    m_navigation_mesh.setWideAgents( b );
}


inline
bool AI_World::isWideAgents( void )
{
    return m_navigation_mesh.isWideAgents();
}


inline
const ai_dword AI_World::getDBVersion( void )
{
    return m_dw_db_version;
}


inline
void AI_World::increaseDBVersion( void )
{
    m_dw_db_version++;
    
    //*** If we keep 100FPS and made DB change every frame and AI world runs nearly 500 hours
    //    then DB version number can overflow. If some agent's last used DB version was not 
    //    changed within 500 hours then db actor's DB version and this DB version can match.
    //    Thus the actor can work with invalid data and cause crash.
    //if (m_dw_db_version)
    //{
    //    ai_log("AI spatial databse overflow!");
    //}
}


inline
void AI_World::setHero( AI_Actor *ptr_actor )
{
    m_ref_hero = ptr_actor;
}


inline
AI_Actor *AI_World::getHero( void )
{
    return m_ref_hero.get_unsafe();
}


inline 
void AI_World::enableActor( AI_Actor *ptr_actor )
{
    AI_Actor::ActorArrayIt it = m_arr_enabled_actors.Find( ptr_actor );
    if ( !it )
        m_arr_enabled_actors.Append( ptr_actor );
}


inline 
void AI_World::disableActor( AI_Actor *ptr_actor )
{
    AI_Actor::ActorArrayIt it = m_arr_enabled_actors.Find( ptr_actor );
    if ( it )
        m_arr_enabled_actors.Erase( it );
}


inline
AI_Actor::ActorArray &AI_World::getEnabledActors(void)
{
    return m_arr_enabled_actors;
}


#endif

---

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