action.hpp

#ifndef ACTION_HPP_
#define ACTION_HPP_
 
#include <vector>
#include <unordered_set>
#include <algorithm>
#include <stdexcept>
 
#include "board.hpp"
#include "pboard.hpp"
#include "util.hpp"
 
class GameActionMgr {
public:
 
    struct AnimState {
 
        enum class AnimType {
            BUBBLE,
            BUBBLE_GLOW,
            PARTICLE
        };
 
        size_t hue;
        ssize_t duration;
        AnimType type;
        float x;
        float y;
        float xVel;
        float yVel;
        bool hasGravity;
 
        AnimState(const float x, const float y, const float xVel, const float yVel, const AnimType type, const size_t hue, const ssize_t duration, const bool hasGravity)
            : x(x), y(y), xVel(xVel), yVel(yVel), type(type), hue(hue), duration(duration), hasGravity(hasGravity) {};
    
 
        static AnimState bubble(const float x, const float y, const float xVel, const float yVel, const size_t hue) {
            return AnimState(x, y, xVel, yVel, AnimType::BUBBLE, hue, -1, false);
        }
 
        static AnimState gravityBubble(const float x, const float y, const float xVel, const float yVel, const size_t hue) {
            return AnimState(x, y, xVel, yVel, AnimType::BUBBLE, hue, -1, true);
        }
 
        static AnimState particle(const float x, const float y, const float xVel, const float yVel, const ssize_t duration) {
            return AnimState(x, y, xVel, yVel, AnimType::PARTICLE, 0, duration, false);
        }
 
        static AnimState gravityParticle(const float x, const float y, const float xVel, const float yVel, const ssize_t duration) {
            return AnimState(x, y, xVel, yVel, AnimType::PARTICLE, 0, duration, true);
        }
 
    };
 
    struct ActionType {
 
        enum class Effect {
            STATIC,
            KINEMATIC,
            BOUNCE,
            BUBBLE
        };
 
        enum class PruneType {
            OOB_BOARD,
            OOB_WINDOW
        };
 
        GameActionMgr* parent;
        AnimState obj;
        Effect effect;
        PruneType pruneType;
        bool pruneFlag;
        size_t id; 
 
        ActionType(const Effect effect, const PruneType pruneType, const AnimState& animData, GameActionMgr* mgr)
            : effect(effect), parent(mgr), obj(animData), pruneType(pruneType), pruneFlag(false) {};
 
        void step(const float scale = 1.0f);
 
        bool shouldPrune() const;
 
        bool repeated(const size_t row, const size_t col);
    };
 
    GameActionMgr(PlacedBoard& boardData);
 
 
    std::vector<ActionType>::iterator begin() {
        return actions.begin();
    }
 
    std::vector<ActionType>::iterator end() {
        return actions.end();
    }
 
 
 
    size_t size() const;
 
 
 
    size_t enqueue(ActionType action);
 
    void step(const float scale = 1.0f);
 
    void prune();
 
    bool find(const size_t id) const;
 
 
private:
    const float GRAVITY;
    const size_t MAX_IDS;
 
    PlacedBoard& boardData;
    std::vector<ActionType> actions;
    std::unordered_set<size_t> ids;
    size_t lastId;
 
    void nextId();
};
 
#endif