TreeNode.h

Go to the documentation of this file.

#pragma once

#include "common/Types.h"
#include "common/MemoryAllocator.h"
#include "conditions/ICondition.h"
#include "conditions/True.h"
#include <vector>
#include <string>
#include <memory>
#include <algorithm>

namespace ai {

class TreeNode;
typedef std::shared_ptr<TreeNode> TreeNodePtr;
typedef std::vector<TreeNodePtr> TreeNodes;

enum TreeNodeStatus {
    UNKNOWN,
    CANNOTEXECUTE,
    RUNNING,
    FINISHED,
    FAILED,
    EXCEPTION,

    MAX_TREENODESTATUS
};

#define NODE_FACTORY(NodeName) \
    class Factory: public ::ai::ITreeNodeFactory { \
    public: \
        ::ai::TreeNodePtr create (const ::ai::TreeNodeFactoryContext *ctx) const override { \
            return std::make_shared<NodeName>(ctx->name, ctx->parameters, ctx->condition); \
        } \
    }; \
    static const Factory& getFactory() { \
        static Factory FACTORY; \
        return FACTORY; \
    }

#define NODE_CLASS(NodeName) \
    NodeName(const std::string& name, const std::string& parameters, const ::ai::ConditionPtr& condition) : \
        ::ai::TreeNode(name, parameters, condition) { \
        _type = AI_STRINGIFY(NodeName); \
    } \
    virtual ~NodeName() { \
    } \
    \
    NODE_FACTORY(NodeName)

class TreeNode : public MemObject {
protected:
    static int getNextId() {
        static int _nextId;
        const int nextId = _nextId++;
        return nextId;
    }
    int _id;
    TreeNodes _children;
    std::string _name;
    std::string _type;
    std::string _parameters;
    ConditionPtr _condition;

    TreeNodeStatus state(const AIPtr& entity, TreeNodeStatus treeNodeState);
    int getSelectorState(const AIPtr& entity) const;
    void setSelectorState(const AIPtr& entity, int selected);
    int getLimitState(const AIPtr& entity) const;
    void setLimitState(const AIPtr& entity, int amount);
    void setLastExecMillis(const AIPtr& entity);

    TreeNodePtr getParent_r(const TreeNodePtr& parent, int id) const;

public:
    TreeNode(const std::string& name, const std::string& parameters, const ConditionPtr& condition) :
            _id(getNextId()), _name(name), _parameters(parameters), _condition(condition) {
    }

    virtual ~TreeNode() {}
    int getId() const;

    const std::string& getName() const;

    const std::string& getParameters() const;

    void setName(const std::string& name);
    const std::string& getType() const;
    const ConditionPtr& getCondition() const;
    void setCondition(const ConditionPtr& condition);
    const TreeNodes& getChildren() const;
    TreeNodes& getChildren();

    virtual void getRunningChildren(const AIPtr& entity, std::vector<bool>& active) const;
    int64_t getLastExecMillis(const AIPtr& ai) const;
    TreeNodeStatus getLastStatus(const AIPtr& ai) const;

    virtual TreeNodeStatus execute(const AIPtr& entity, int64_t deltaMillis);

    virtual void resetState(const AIPtr& entity);

    virtual bool addChild(const TreeNodePtr& child);
    TreeNodePtr getChild(int id) const;
    bool replaceChild(int id, const TreeNodePtr& newNode);
    TreeNodePtr getParent(const TreeNodePtr& self, int id) const;
};

}