CUActionManager.h

//
//  CUActionManager.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the manager to provide tweened animations.  Actions
//  themselves are not animations; they are only templates for an animation.
//  The action manager attaches an action to a scene graph node and performs
//  the (timed) animation.
//
//  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: Sophie Huang and Walker White
//  Version: 3/12/17
//
#ifndef __CU_ACTION_MANAGER_H__
#define __CU_ACTION_MANAGER_H__
 
#include "CUAction.h"
#include <SDL/SDL.h>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
 
namespace cugl {
 
class ActionManager {
#pragma mark ActionInstance
 
    class ActionInstance {
    public:
        std::shared_ptr<Node> target;
        
        std::shared_ptr<Action> action;
        
        std::function<float(float)> interpolant;
        
        Uint64 state;
        
        /* The desired completion time of the action */
        float duration;
        
        float elapsed;
        
        bool  paused;
        
    public:
        ActionInstance() : state(0), duration(0.0f), elapsed(0.0f), paused(false) {}
        
        ~ActionInstance();
    };
    
#pragma mark Values
protected:
    std::unordered_map<Node*, std::unordered_set<std::string>> _keys;
    
    std::unordered_map<std::string, ActionInstance*> _actions;
    
 
public:
#pragma mark Constructors
 
    ActionManager() {}
    
    ~ActionManager() { dispose(); }
    
    void dispose();
    
    bool init() { return true; }
    
#pragma mark Static Constructors
 
    static std::shared_ptr<ActionManager> alloc() {
        std::shared_ptr<ActionManager> result = std::make_shared<ActionManager>();
        return (result->init() ? result : nullptr);
    }
 
#pragma mark -
#pragma mark Action Management
 
    bool isActive(std::string key) const;
    
    bool activate(std::string key,
                  const std::shared_ptr<Action>& action,
                  const std::shared_ptr<Node>& target) {
        return activate(key,action,target, nullptr);
    };
 
 
    bool activate(std::string key,
                  const std::shared_ptr<Action>& action,
                  const std::shared_ptr<Node>& target,
                  std::function<float(float)> easing);
    
    bool remove(std::string key);
 
    void update(float dt);
 
#pragma mark -
#pragma mark Pausing
 
    bool isPaused(std::string key);
 
    void pause(std::string key);
 
    void unpause(std::string key);
 
#pragma mark -
#pragma mark Node Management
 
    void clearAllActions(const std::shared_ptr<Node>& target);
    
    void pauseAllActions(const std::shared_ptr<Node>& target);
 
    void unpauseAllActions(const std::shared_ptr<Node>& target);
 
    std::vector<std::string> getAllActions(const std::shared_ptr<Node>& target) const;
 
};
 
}
#endif /* __CU_ACTION_MANAGER_H__ */