CUBehaviorParser.h

//
//  CUBehaviorParser.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a behavior parser in order to create a
//  BodyDefNode from a JSON.  It is hear because we have not yet folded
//  an official AI asset loader into this release.
//
//  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_PARSER_H__
#define __CU_BEHAVIOR_PARSER_H__

#include <cugl/ai/behavior/CUBehaviorNode.h>
#include <cugl/ai/behavior/CUBehaviorAction.h>
#include <cugl/io/CUJsonReader.h>
#include <unordered_map>
#include <string>
#include <vector>

namespace cugl {
    namespace ai {
class BehaviorParser {
private:
    std::unordered_map<std::string,std::function<float()>> _prioritizers;
    std::unordered_map<std::string,std::shared_ptr<BehaviorActionDef>> _actions;
    
#pragma mark Constructors
public:
    BehaviorParser() {}
    
    ~BehaviorParser() { dispose(); }
    
    void dispose();
    
    bool init() { return true; }
    
    static std::shared_ptr<BehaviorParser> alloc() {
        std::shared_ptr<BehaviorParser> result = std::make_shared<BehaviorParser>();
        return (result->init() ? result : nullptr);
    }

#pragma mark Parser State

    void addPrioritizer(const std::string& name, std::function<float()> prioritizer);

    void addPrioritizer(const char* name, std::function<float()> prioritizer) {
        addPrioritizer(std::string(name),prioritizer);
    }

    std::function<float()> getPrioritizer(const std::string& name) const;

    std::function<float()> getPrioritizer(const char* name) const {
        return getPrioritizer(std::string(name));
    }

    std::function<float()> removePrioritizer(const std::string& name);
    
    std::function<float()> removePrioritizer(const char* name) {
        return removePrioritizer(std::string(name));
    }

    void addAction(std::shared_ptr<BehaviorActionDef> actiondef) {
        addAction(actiondef->name,actiondef);
    }
    
    void addAction(const std::string& name, std::shared_ptr<BehaviorActionDef> actiondef);

    void addAction(const char* name, std::shared_ptr<BehaviorActionDef> actiondef) {
        addAction(std::string(name),actiondef);
    }
    
    std::shared_ptr<BehaviorActionDef> getAction(const std::string& name) const;
    
    std::shared_ptr<BehaviorActionDef> getAction(const char* name) const {
        return getAction(std::string(name));
    }
    
    std::shared_ptr<BehaviorActionDef> removeAction(const std::string& name);
    
    std::shared_ptr<BehaviorActionDef> removeAction(const char* name) {
        return removeAction(std::string(name));
    }

#pragma mark Parsing Functions

    std::unordered_map<std::string, std::shared_ptr<BehaviorNodeDef>>
        parseFile(const std::string& file) {
        return parseFile(file.c_str());
    }

    std::unordered_map<std::string, std::shared_ptr<BehaviorNodeDef>>
        parseFile(const char* file);

private:
    std::shared_ptr<BehaviorNodeDef> parseJson(const std::shared_ptr<JsonValue>& json);
};

    }
}
#endif /* __CU_BEHAVIOR_PARSER_H__ */