LevelDocument.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/BorrowedRef.h"
#include "common/Value.h"
#include "map/level/editing/TileBuffer.h"
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::level_editing {
 
enum class LevelChange { Changed, Unchanged };
 
struct LevelObject {
    std::string id;
    std::string type;
    std::string name;
    float       x = 0.f, y = 0.f, width = 0.f, height = 0.f, rotation = 0.f;
    bool        visible = true;
 
    std::unordered_map<std::string, std::string> properties;
    eve::Value::Object extensions;
};
 
struct LevelLayer {
    enum class Kind { Tiles, Objects };
 
    std::string id;
    std::string name;
    Kind        kind    = Kind::Tiles;
    bool        visible = true;
    bool        locked  = false;
    float       opacity = 1.f;
    float       offsetX = 0.f, offsetY = 0.f;
 
    std::unique_ptr<TileBuffer> tiles;
    std::vector<LevelObject>    objects;
 
    std::unordered_map<std::string, std::string> properties;
    eve::Value::Object extensions;
};
 
class EVENGINE_API_DOMAINS LevelDocument {
public:
    LevelDocument(int width = 1, int height = 1, float tileWidth = 32.f, float tileHeight = 32.f);
 
    // std::vector<LevelLayer> holds a unique_ptr member, so the implicit copy
    // operations were already deleted; a class-level dllexport would nonetheless
    // instantiate std::vector<LevelLayer>::operator= and hard-error (C2280).
    // Spell the four out so the export surface stays defined; semantics unchanged.
    LevelDocument(const LevelDocument&)            = delete;
    LevelDocument& operator=(const LevelDocument&) = delete;
    LevelDocument(LevelDocument&&)                 = default;
    LevelDocument& operator=(LevelDocument&&)      = default;
 
    void               resize(int width, int height);
    int                getWidth() const { return width_; }
    int                getHeight() const { return height_; }
    float              getTileWidth() const { return tileWidth_; }
    float              getTileHeight() const { return tileHeight_; }
    void               setTileSize(float width, float height);
    void               setOrientation(const std::string& orientation);
    const std::string& getOrientation() const { return orientation_; }
 
    int                       addTileLayer(const std::string& name);
    int                       addObjectLayer(const std::string& name);
    [[nodiscard]] LevelChange removeLayer(int index);
    [[nodiscard]] LevelChange moveLayer(int from, int to);
    int                       getLayerCount() const { return static_cast<int>(layers_.size()); }
    const std::string&        getLayerName(int index) const;
    void                      setLayerName(int index, const std::string& name);
    const std::string         getLayerKind(int index) const;
 
    [[nodiscard]] eve::OptionalRef<TileBuffer>       getTileLayer(int index);
    [[nodiscard]] eve::OptionalRef<const TileBuffer> getTileLayer(int index) const;
    [[nodiscard]] eve::OptionalRef<LevelLayer>       layer(int index);
    [[nodiscard]] eve::OptionalRef<const LevelLayer> layer(int index) const;
 
    int addObject(int layerIndex, const std::string& type, float x, float y);
    int getObjectCount(int layerIndex) const;
 
    [[nodiscard]] eve::OptionalRef<LevelObject>       object(int layerIndex, int objectIndex);
    [[nodiscard]] eve::OptionalRef<const LevelObject> object(int layerIndex, int objectIndex) const;
    [[nodiscard]] LevelChange                         removeObject(int layerIndex, int objectIndex);
 
    void        setProperty(const std::string& key, const std::string& value);
    std::string getProperty(const std::string& key, const std::string& fallback = {}) const;
 
    std::unordered_map<std::string, std::string>&       properties() { return properties_; }
    const std::unordered_map<std::string, std::string>& properties() const { return properties_; }
 
    std::vector<LevelLayer>&       layers() { return layers_; }
    const std::vector<LevelLayer>& layers() const { return layers_; }
 
private:
    friend class LevelFormatCodec;
    eve::Value::Object extensions_;
    std::string nextId(const char* prefix);
    int         width_, height_;
    float       tileWidth_, tileHeight_;
    std::string orientation_ = "orthogonal";
    unsigned    nextId_      = 1;
 
    std::vector<LevelLayer>                      layers_;
    std::unordered_map<std::string, std::string> properties_;
};
 
}  // namespace eve::level_editing