move_types.h

 
#pragma once
 
#include <stdint.h>
 
enum class MoveXValue : uint8_t {
    None = 0,  
    Right = 1, 
    Left = 2   
};
 
enum class MoveYValue : uint8_t {
    None = 0, 
    Up = 1,   
    Down = 2  
};
 
template <typename EnumType> class MoveDirection
{
public:
    constexpr MoveDirection(EnumType v) : _value(v) {}
 
    bool is_none() const { return static_cast<uint8_t>(_value) == 0; }
 
    EnumType get_value() const { return _value; }
 
    bool operator!() const { return is_none(); }
 
    operator uint8_t() const { return static_cast<uint8_t>(_value); }
 
    bool operator==(EnumType v) const { return _value == v; }
 
    bool operator!=(EnumType v) const { return _value != v; }
 
protected:
    EnumType _value; 
};
 
class MoveX : public MoveDirection<MoveXValue>
{
public:
    static constexpr MoveXValue None = MoveXValue::None;
    static constexpr MoveXValue Right = MoveXValue::Right;
    static constexpr MoveXValue Left = MoveXValue::Left;
 
    using MoveDirection<MoveXValue>::MoveDirection;
 
    constexpr MoveX() : MoveDirection(MoveXValue::None) {}
 
    const char* to_string() const
    {
        switch (this->_value)
        {
        case MoveXValue::Right:
            return "Right";
        case MoveXValue::Left:
            return "Left";
        default:
            return "None";
        }
    }
};
 
class MoveY : public MoveDirection<MoveYValue>
{
public:
    static constexpr MoveYValue None = MoveYValue::None;
    static constexpr MoveYValue Up = MoveYValue::Up;
    static constexpr MoveYValue Down = MoveYValue::Down;
 
    using MoveDirection<MoveYValue>::MoveDirection;
 
    constexpr MoveY() : MoveDirection(MoveYValue::None) {}
 
    const char* to_string() const
    {
        switch (this->_value)
        {
        case MoveYValue::Up:
            return "Up";
        case MoveYValue::Down:
            return "Down";
        default:
            return "None";
        }
    }
};