CUBehaviorManager.h

//
//  CUBehaviorManager.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a behavior tree manager. The behavior tree
//  manager controls the creation and execution of behavior trees. It is akin
//  to a world object in Box2d.
//
//  EXPERIMENTAL: This module is experimental.  The API may change significantly
//  in future CUGL releases.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  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_MANAGER_H__
#define __CU_BEHAVIOR_MANAGER_H__
#include <cugl/ai/behavior/CUBehaviorNode.h>
#include <cugl/ai/behavior/CUBehaviorAction.h>
#include <unordered_map>
#include <functional>
#include <random>
#include <string>

namespace cugl {
    namespace ai {
class BehaviorManager {
#pragma mark Values
protected:
    std::unordered_map<std::string, std::shared_ptr<BehaviorNode>> _trees;

    std::minstd_rand _random;
    
#pragma mark -
#pragma mark Constructors
public:
    BehaviorManager() {};

    ~BehaviorManager() { dispose(); }

    void dispose();

    bool init();
    
    bool init(Uint32 seed);

    static std::shared_ptr<BehaviorManager> alloc() {
        std::shared_ptr<BehaviorManager> result = std::make_shared<BehaviorManager>();
        return (result->init() ? result : nullptr);
    }

    static std::shared_ptr<BehaviorManager> alloc(Uint32 seed) {
        std::shared_ptr<BehaviorManager> result = std::make_shared<BehaviorManager>();
        return (result->init(seed) ? result : nullptr);
    }

#pragma mark -
#pragma mark Tree Management

    bool containsTree(const std::string& name) const;
    
    bool containsTree(const char* name) const {
        return containsTree(std::string(name));
    }

    const BehaviorNode* getTree(const std::string& name) const;
    
    const BehaviorNode* getTree(const char* name) const {
        return getTree(std::string(name));
    }

    bool addTree(const std::shared_ptr<BehaviorNodeDef>& treedef);

    bool addTree(const std::string& name, const std::shared_ptr<BehaviorNodeDef>& treedef);

    bool addTree(const char* name, const std::shared_ptr<BehaviorNodeDef>& treedef) {
        return addTree(std::string(name),treedef);
    }
    
    BehaviorNode::State getTreeState(const std::string& name) const {
        return getTree(name)->getState();
    }

#pragma mark -
#pragma mark Behavior Management

    void startTree(const std::string& name);

    void pauseTree(const std::string& name);

    void resumeTree(const std::string& name);

    void removeTree(const std::string& name);

    void resetTree(const std::string& name);

    void update(float dt);

private:
    std::shared_ptr<BehaviorNode> createTree(const std::shared_ptr<BehaviorNodeDef>& treedef);
};
    }
}
#endif /* __CU_BEHAVIOR_MANAGER_H__ */