CUBehaviorNode.h

//
//  CUBehaviorNode.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a behavior node as part of a behavior tree.
//  The behavior tree node chooses an action by setting a priority for each node
//  and then traverses down the tree to select an action.
//
//  BehaviorNode objects are managed by BehaviorManager, and should never
//  be allocated directly.  Instead, you create a behavior node definition
//  and pass it to a factor method in BehaviorManager.
//
//  EXPERIMENTAL: This module is experimental.  The API may change significantly
//  in future CUGL releases.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Apurv Sethi and Andrew Matsumoto (with Walker White)
//  Version: 5/22/2018
//
#ifndef __CU_BEHAVIOR_NODE_H__
#define __CU_BEHAVIOR_NODE_H__
#include <cugl/ai/behavior/CUBehaviorAction.h>
#include <functional>
#include <string>
#include <vector>
 
namespace cugl {
    namespace ai {
 
#pragma mark Behavior Node Defintion
 
class BehaviorNodeDef : public std::enable_shared_from_this<BehaviorNodeDef> {
public:
    enum class Type : int {
        PRIORITY_NODE,
        SELECTOR_NODE,
        RANDOM_NODE,
        INVERTER_NODE,
        TIMER_NODE,
        LEAF_NODE
    };
    
    std::string name;
 
    Type type;
 
    std::function<float()> prioritizer;
    
    bool background;
 
    bool preemptive;
 
    bool uniform;
 
    float delay;
    
    std::vector<std::shared_ptr<BehaviorNodeDef>> children;
 
    std::shared_ptr<BehaviorActionDef> action;
 
#pragma mark Methods
 
    BehaviorNodeDef();
 
    static std::shared_ptr<BehaviorNodeDef> alloc() {
        return std::make_shared<BehaviorNodeDef>();
    }
    
    std::shared_ptr<BehaviorNodeDef> getNodeByName(const std::string& name);
 
    std::shared_ptr<BehaviorNodeDef> getNodeByName(const char* name) {
        return getNodeByName(std::string(name));
    }
 
};
 
    
#pragma mark -
#pragma mark Behavior Node
 
class BehaviorNode {
#pragma mark Values
public:
    enum class State : unsigned int {
        INACTIVE = 0,
        RUNNING = 1,
        PAUSED  = 2,
        FINISHED = 3
    };
 
protected:
    std::string _name;
 
    std::string _classname;
    
    BehaviorNode* _parent;
 
    BehaviorNode::State _state;
 
    float _priority;
 
    std::function<float()> _prioritizer;
 
    std::vector<std::shared_ptr<BehaviorNode>> _children;
 
    int _activeChild;
 
    int _childOffset;
 
public:
#pragma mark Constructors
 
    BehaviorNode();
 
    ~BehaviorNode() { dispose(); }
 
    bool init(const std::string& name);
 
    virtual void dispose();
 
#pragma mark Attributes
 
    const std::string& getName() const { return _name; }
 
    float getPriority() const { return _priority; }
 
    BehaviorNode::State getState() const { return _state; }
 
    virtual void setState(BehaviorNode::State state);
 
    std::function<float()> getPrioritizer() const { return _prioritizer; }
    
    void setPrioritizer(const std::function<float()>& func) {
        _prioritizer = func;
    }
 
    virtual std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }
 
#pragma mark Tree Access
 
    const BehaviorNode* getParent() const { return _parent; }
 
    void setParent(BehaviorNode* parent) { _parent = parent; }
 
    void removeFromParent() { if (_parent) _parent->removeChild(_childOffset); }
 
    int getParentalOffset() const { return _childOffset; }
 
    size_t getChildCount() const { return _children.size(); }
    
    std::vector<const BehaviorNode*> getChildren() const;
    
    const BehaviorNode* getChild(Uint32 pos) const;
 
    template <typename T>
    const T* getChild(Uint32 pos) const {
        return dynamic_cast<const T*>(getChild(pos));
    }
    
    const BehaviorNode* getNodeByName(const std::string& name) const;
    
    const BehaviorNode* getNodeByName(const char* name) const {
        return getNodeByName(std::string(name));
    }
    
    template <typename T>
    const T* getNodeByName(const std::string& name) const {
        return dynamic_cast<const T*>(getNodeByName(name));
    }
 
    template <typename T>
    const T* getNodeByName(const char* name) const {
        return dynamic_cast<const T*>(getNodeByName(name));
    }
    
#pragma mark Behavior Management
 
    virtual void reset();
 
    virtual void pause();
 
    virtual void resume();
 
    virtual void preempt();
 
    virtual void start();
    
    virtual void query(float dt) = 0;
    
    virtual BehaviorNode::State update(float dt) = 0;
 
    void setPriority(float priority);
 
    std::shared_ptr<BehaviorNode> removeChild(Uint32 pos);
 
    void addChild(const std::shared_ptr<BehaviorNode> child);
 
    static bool compareSiblings(const std::shared_ptr<BehaviorNode>& a,
                                const std::shared_ptr<BehaviorNode>& b);
};
    }
}
#endif /* __CU_BEHAVIOR_NODE_H__ */