level.hpp

#pragma once
 
#include <vector>
#include <unordered_map>
 
#include "block.hpp"
#include "coordinate.hpp"
 
namespace LevelZ {
 
    struct Level {
        protected:
            std::unordered_map<std::string, std::string> _headers = {};
            std::vector<LevelZ::LevelObject> _blocks = {};
 
            Level() {}
 
        public:
            inline std::unordered_map<std::string, std::string> headers() const {
                return _headers;
            }
 
            inline std::vector<LevelObject> blocks() const {
                return _blocks;
            }
 
            bool operator==(const Level& other) const {
                return _headers == other._headers && _blocks == other._blocks;
            }
 
            bool operator!=(const Level& other) const {
                return _headers != other._headers || _blocks != other._blocks;
            }
    };
 
    enum Scroll {
        NONE,
        
        HORIZONTAL_LEFT,
 
        HORIZONTAL_RIGHT,
 
        VERTICAL_UP,
 
        VERTICAL_DOWN
    };
 
    struct Level2D : Level {
        public:
            Coordinate2D spawn = Coordinate2D(0, 0);
 
            Level2D() {}
 
            explicit Level2D(const std::unordered_map<std::string, std::string>& headers) : Level2D(headers, {}) {}
 
            Level2D(const std::unordered_map<std::string, std::string>& headers, const std::vector<LevelObject>& blocks) {
                _headers = headers;
                _blocks = blocks;
 
                if (headers.find("type") == headers.end())
                    _headers["type"] = "2";
 
                spawn = Coordinate2D(0, 0);
                if (headers.find("spawn") != headers.end()) {
                    spawn = Coordinate2D::from_string(headers.at("spawn"));
                }
            }
 
            explicit Level2D(const Level& level) : Level2D(level.headers(), level.blocks()) {};
 
            inline Scroll scroll() {
                if (_headers.find("scroll") == _headers.end())
                    return Scroll::NONE;
 
                std::string scroll = _headers.at("scroll");
 
                if (scroll == "none") return Scroll::NONE;
                if (scroll == "horizontal-left") return Scroll::HORIZONTAL_LEFT;
                if (scroll == "horizontal-right") return Scroll::HORIZONTAL_RIGHT;
                if (scroll == "vertical-up") return Scroll::VERTICAL_UP;
                if (scroll == "vertical-down") return Scroll::VERTICAL_DOWN;
 
                return Scroll::NONE;
            }
    };
 
    struct Level3D : Level {
        public:
            Coordinate3D spawn = Coordinate3D(0, 0, 0);
 
            Level3D() {}
 
            explicit Level3D(const std::unordered_map<std::string, std::string>& headers) : Level3D(headers, {}) {}
 
            Level3D(const std::unordered_map<std::string, std::string>& headers, const std::vector<LevelObject>& blocks) {
                _headers = headers;
                _blocks = blocks;
 
                if (headers.find("type") == headers.end())
                    _headers["type"] = "3";
 
                spawn = Coordinate3D(0, 0, 0);
                if (headers.find("spawn") != headers.end()) {
                    spawn = Coordinate3D::from_string(headers.at("spawn"));
                }
            }
 
            explicit Level3D(const Level& level) : Level3D(level.headers(), level.blocks()) {};
    };
 
}