AI.h

Go to the documentation of this file.

#pragma once

#include <unordered_map>
#include <memory>

#include "group/GroupId.h"
#include "aggro/AggroMgr.h"
#include "ICharacter.h"
#include "tree/TreeNode.h"
#include "tree/loaders/ITreeLoader.h"
#include "common/Thread.h"
#include "common/Types.h"
#include "common/NonCopyable.h"
#include "common/Math.h"

namespace ai {

class ICharacter;
typedef std::shared_ptr<ICharacter> ICharacterPtr;
class Zone;

typedef std::vector<CharacterId> FilteredEntities;

#ifndef AI_NOTHING_SELECTED
#define AI_NOTHING_SELECTED (-1)
#endif

class AI : public NonCopyable, public std::enable_shared_from_this<AI> {
    friend class TreeNode;
    friend class LUAAIRegistry;
    friend class IFilter;
    friend class Filter;
    friend class Server;
protected:
    typedef std::unordered_map<int, TreeNodeStatus> NodeStates;
    NodeStates _lastStatus;
    typedef std::unordered_map<int, uint64_t> LastExecMap;
    LastExecMap _lastExecMillis;

    mutable FilteredEntities _filteredEntities;

    void setFilteredEntities(const FilteredEntities& filteredEntities);

    void addFilteredEntity(CharacterId id);

    typedef std::unordered_map<int, int> SelectorStates;
    SelectorStates _selectorStates;

    typedef std::unordered_map<int, int> LimitStates;
    LimitStates _limitStates;

    TreeNodePtr _behaviour;
    AggroMgr _aggroMgr;

    ICharacterPtr _character;

    bool _pause;
    bool _debuggingActive;

    int64_t _time;

    Zone* _zone;

    std::atomic_bool _reset;
public:
    explicit AI(const TreeNodePtr& behaviour) :
            _behaviour(behaviour), _pause(false), _debuggingActive(false), _time(0L), _zone(nullptr), _reset(false) {
    }
    virtual ~AI() {
    }

    virtual void update(int64_t dt, bool debuggingActive);

    void setZone(Zone* zone);
    Zone* getZone() const;
    bool hasZone() const;

    void setPause(bool pause);

    bool isPause() const;

    bool isDebuggingActive() const;

    TreeNodePtr getBehaviour() const;
    TreeNodePtr setBehaviour(const TreeNodePtr& newBehaviour);
    ICharacterPtr getCharacter() const;
    void setCharacter(const ICharacterPtr& character);

    template <typename CharacterType>
    inline CharacterType& getCharacterCast() const {
        return *static_cast<CharacterType*>(_character.get());
    }

    int64_t getTime() const;

    CharacterId getId() const;

    AggroMgr& getAggroMgr();
    const AggroMgr& getAggroMgr() const;

    const FilteredEntities& getFilteredEntities() const;

    inline std::shared_ptr<AI> ptr() {
        return shared_from_this();
    }
};

inline TreeNodePtr AI::getBehaviour() const {
    return _behaviour;
}

inline TreeNodePtr AI::setBehaviour(const TreeNodePtr& newBehaviour) {
    TreeNodePtr current = _behaviour;
    _behaviour = newBehaviour;
    _reset = true;
    return current;
}

inline void AI::setPause(bool pause) {
    _pause = pause;
}

inline bool AI::isPause() const {
    return _pause;
}

inline ICharacterPtr AI::getCharacter() const {
    return _character;
}

inline void AI::setCharacter(const ICharacterPtr& character) {
    ai_assert(!_character, "There is already a character set");
    _character = character;
}

inline AggroMgr& AI::getAggroMgr() {
    return _aggroMgr;
}

inline const AggroMgr& AI::getAggroMgr() const {
    return _aggroMgr;
}

inline const FilteredEntities& AI::getFilteredEntities() const {
    return _filteredEntities;
}

inline void AI::setFilteredEntities(const FilteredEntities& filteredEntities) {
    _filteredEntities = filteredEntities;
}

inline void AI::addFilteredEntity(CharacterId id) {
    _filteredEntities.push_back(id);
}

inline bool AI::isDebuggingActive() const {
    return _debuggingActive;
}

inline void AI::setZone(Zone* zone) {
    _zone = zone;
}

inline Zone* AI::getZone() const {
    return _zone;
}

inline bool AI::hasZone() const {
    return _zone != nullptr;
}

inline int64_t AI::getTime() const {
    return _time;
}

inline CharacterId AI::getId() const {
    if (!_character) {
        return AI_NOTHING_SELECTED;
    }
    return _character->getId();
}

inline void AI::update(int64_t dt, bool debuggingActive) {
    if (isPause()) {
        return;
    }

    if (_character) {
        _character->update(dt, debuggingActive);
    }

    if (_reset) {
        // safe to do it like this, because update is not called from multiple threads
        _reset = false;
        _lastStatus.clear();
        _lastExecMillis.clear();
        _filteredEntities.clear();
        _selectorStates.clear();
    }

    _debuggingActive = debuggingActive;
    _time += dt;
    _aggroMgr.update(dt);
}

typedef std::shared_ptr<AI> AIPtr;

}