CUBehaviorAction.h

//
//  CUBehaviorAction.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for an action, which is a user-defined result
//  chosen by a behavior tree. Instead of requiring the user to subclass an
//  interface, have elected to use functions pointers to allow the user more
//  flexibilty.
//
//  BehaviorAction objects are managed by BehaviorManager, and should never
//  be allocated directly.  Instead, you create a behavior action 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/21/2018
//
#ifndef __CU_BEHAVIOR_ACTION_H__
#define __CU_BEHAVIOR_ACTION_H__
#include <cugl/util/CUDebug.h>
#include <functional>
#include <memory>
#include <string>
 
namespace cugl {
    namespace ai {
 
#pragma mark -
#pragma mark Behavior Action Definition
 
class BehaviorActionDef {
public:
    std::string name;
 
    std::function<void()> start;
 
    std::function<bool(float dt)> update;
 
    std::function<void()> terminate;
 
#pragma mark Methods
 
    BehaviorActionDef() : name(""), start(nullptr), update(nullptr), terminate(nullptr) {}
    
    static std::shared_ptr<BehaviorActionDef> alloc() {
        return std::make_shared<BehaviorActionDef>();
    }
};
 
#pragma mark -
#pragma mark Behavior Action
 
class BehaviorAction {
#pragma mark Values
public:
    enum class State : unsigned int {
        INACTIVE = 0,
        RUNNING = 1,
        PAUSED = 2,
        FINISHED = 3
    };
 
protected:
    std::string _name;
 
    BehaviorAction::State _state;
 
    std::function<void()> _start;
 
    std::function<bool(float dt)> _update;
 
    std::function<void()> _terminate;
 
public:
#pragma mark Constructors
 
    BehaviorAction();
 
    ~BehaviorAction() { dispose(); }
 
    bool init(const std::shared_ptr<BehaviorActionDef>& actiondef);
    
    void dispose();
 
#pragma mark Attributes
 
    const std::string& getName() const { return _name; }
 
    BehaviorAction::State getState() const { return _state; }
 
    void setState(BehaviorAction::State state) { _state = state; }
 
#pragma mark Action Management
 
    void start();
 
    void terminate();
 
    void pause();
    
    void resume();
 
    void reset();
    
    BehaviorAction::State update(float dt);
 
};
    }
}
#endif /* __CU_BEHAVIOR_ACTION_H__ */