AIStubTypes.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <string>
#include "common/Math.h"
#include "common/Types.h"
#include "tree/TreeNode.h"

namespace ai {

struct AIStateAggroEntry {
    AIStateAggroEntry(ai::CharacterId _id, float _aggro) :
            id(_id), aggro(_aggro) {
    }
    ai::CharacterId id;
    float aggro;
};

class AIStateAggro {
private:
    std::vector<AIStateAggroEntry> _aggro;
public:
    inline void reserve(std::size_t size) {
        if (size > 0)
            _aggro.reserve(size);
    }

    inline void addAggro(const AIStateAggroEntry& entry) {
        _aggro.push_back(entry);
    }

    inline const std::vector<AIStateAggroEntry>& getAggro() const {
        return _aggro;
    }
};

class AIStateNodeStatic {
private:
    int32_t _id;
    std::string _name;
    std::string _type;
    std::string _parameters;
    std::string _conditionType;
    std::string _conditionParameters;
public:
    AIStateNodeStatic(const int32_t id, const std::string& name, const std::string& type, const std::string& parameters, const std::string& conditionType, const std::string& conditionParameters) :
            _id(id), _name(name), _type(type), _parameters(parameters), _conditionType(conditionType), _conditionParameters(conditionParameters) {
    }

    AIStateNodeStatic() :
            _id(-1) {
    }

    inline int32_t getId() const {
        return _id;
    }

    inline const std::string& getName() const {
        return _name;
    }

    inline const std::string& getType() const {
        return _type;
    }

    inline const std::string& getParameters() const {
        return _parameters;
    }

    inline const std::string& getConditionParameters() const {
        return _conditionParameters;
    }

    inline std::string getCondition() const {
        return _conditionType + "(" + _conditionParameters + ")";
    }

    inline const std::string& getConditionType() const {
        return _conditionType;
    }
};

class AIStateNode {
private:
    int32_t _nodeId;
    std::string _condition;
    typedef std::vector<AIStateNode> NodeVector;
    NodeVector _children;
    int64_t _lastRun;
    TreeNodeStatus _status;
    bool _currentlyRunning;
public:
    AIStateNode(int32_t id, const std::string& condition, int64_t lastRun, TreeNodeStatus status, bool currentlyRunning) :
            _nodeId(id), _condition(condition), _lastRun(lastRun), _status(status), _currentlyRunning(currentlyRunning) {
    }

    AIStateNode() :
            _nodeId(-1), _lastRun(-1L), _status(UNKNOWN), _currentlyRunning(false) {
    }

    void addChildren(const AIStateNode& child) {
        _children.push_back(child);
    }

    void addChildren(AIStateNode&& child) {
        _children.push_back(std::move(child));
    }

    inline const std::vector<AIStateNode>& getChildren() const {
        return _children;
    }

    inline std::vector<AIStateNode>& getChildren() {
        return _children;
    }

    inline int32_t getNodeId() const {
        return _nodeId;
    }

    inline const std::string& getCondition() const {
        return _condition;
    }

    inline int64_t getLastRun() const {
        return _lastRun;
    }

    inline TreeNodeStatus getStatus() const {
        return _status;
    }

    inline bool isRunning() const {
        return _currentlyRunning;
    }
};

class AIStateWorld {
private:
    ai::CharacterId _id;
    glm::vec3 _position;
    float _orientation;
    CharacterAttributes _attributes;
public:
    AIStateWorld() : _id(-1), _position(0.0f, 0.0f, 0.0f), _orientation(0.0f) {}

    AIStateWorld(const ai::CharacterId& id, const glm::vec3& position, float orientation, const CharacterAttributes& attributes) :
            _id(id), _position(position), _orientation(orientation), _attributes(attributes) {
    }

    AIStateWorld(const ai::CharacterId& id, const glm::vec3& position, float orientation, CharacterAttributes&& attributes) :
            _id(id), _position(position), _orientation(orientation), _attributes(std::move(attributes)) {
    }

    AIStateWorld(const ai::CharacterId& id, const glm::vec3& position, float orientation) :
            _id(id), _position(position), _orientation(orientation) {
    }

    inline bool operator==(const AIStateWorld &other) const {
        return _id == other._id;
    }

    inline bool operator<(const AIStateWorld &other) const {
        return _id < other._id;
    }

    inline const ai::CharacterId& getId() const {
        return _id;
    }

    inline float getOrientation() const {
        return _orientation;
    }

    inline const glm::vec3& getPosition() const {
        return _position;
    }

    inline const CharacterAttributes& getAttributes() const {
        return _attributes;
    }

    inline CharacterAttributes& getAttributes() {
        return _attributes;
    }
};

}