block.hpp

#pragma once
 
#include <string>
#include <unordered_map>
 
namespace LevelZ {
 
    struct Block {
        public:
            std::string name;
 
            std::unordered_map<std::string, std::string> properties;
 
            explicit Block(std::string name) : name(name) {}
 
            Block(std::string name, std::unordered_map<std::string, std::string> properties) : name(name), properties(properties) {}
 
            std::string getProperty(std::string key) const {
                return properties.at(key);
            }
 
            std::string getProperty(std::string key, std::string defaultValue) const {
                return properties.find(key) != properties.end() ? properties.at(key) : defaultValue;
            }
 
            bool hasProperty(std::string key) const {
                return properties.find(key) != properties.end();
            }
 
            bool operator==(const Block& other) const {
                return name == other.name && properties == other.properties;
            }
 
            bool operator!=(const Block& other) const {
                return name != other.name || properties != other.properties;
            }
 
            std::string to_string() const {
                std::string str;
                if (properties.empty()) return name;
 
                str += name + "<";
 
                for (auto const& [k, v] : properties) {
                    str += k + "=" + v;
                }
 
                str += ">";
 
                return str;
            }
 
            std::ostream& operator<<(std::ostream &strm) {
                return strm << to_string();
            }
    };
 
    struct LevelObject {
        private:
            Coordinate* _coordinate;
            Block _block;
        public:
            LevelObject(Block block, Coordinate2D coordinate) : _block(block), _coordinate(new Coordinate2D(coordinate)) {}
 
            LevelObject(Block block, Coordinate3D coordinate) : _block(block), _coordinate(new Coordinate3D(coordinate)) {}
 
            inline Block block() {
                return _block;
            }
            
            inline Coordinate* coordinate() {
                return _coordinate;
            }
 
            bool operator==(const LevelObject& other) const {
                return _block == other._block && _coordinate->getMagnitude() == other._coordinate->getMagnitude();
            }
 
            bool operator!=(const LevelObject& other) const {
                return _block != other._block || _coordinate->getMagnitude() != other._coordinate->getMagnitude();
            }
 
            std::string to_string() const {
                return _block.to_string() + ": " + _coordinate->to_string();
            }
 
            std::ostream& operator<<(std::ostream &strm) {
                return strm << to_string();
            }
    };
 
}