PlacementWorld.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "building/BuildingTypes.h"
#include "common/Result.h"
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::map {
class TileLayer;
}
 
namespace eve::grid {
struct GridConfig;
}
 
namespace eve::building {
 
class Ghost;
 
class EVENGINE_API_WORLD PlacementWorld {
public:
    using ChannelMap = std::unordered_map<std::string, std::vector<int>>;
    PlacementWorld(int width, int height, float cellSize = 32.f);
    ~PlacementWorld();
 
    PlacementWorld(const PlacementWorld &) = delete;
    PlacementWorld &operator=(const PlacementWorld &) = delete;
 
    void destroy();
 
    std::string getId() const { return id_; }
    void setId(const std::string &id) { id_ = id; }
 
    int getWidth() const { return width_; }
    int getHeight() const { return height_; }
    float getCellSize() const;
    void setCellSize(float s);
 
    float getOriginX() const;
    float getOriginY() const;
    void setOrigin(float x, float y);
 
    float getFloorHeight() const { return floorHeight_; }
    void setFloorHeight(float height);
    int getActiveLevel() const { return activeLevel_; }
    void setActiveLevel(int level) { activeLevel_ = level; }
 
    std::string getSnapMode() const { return snapMode_; }
    void setSnapMode(const std::string &mode) { snapMode_ = mode; }
    std::string getValidateRule() const { return validateRule_; }
    void setValidateRule(const std::string &rule) { validateRule_ = rule; }
 
    void setExtra(const std::string &key, const std::string &value);
    std::string getExtra(const std::string &key, const std::string &fallback = {}) const;
 
    // ---- Grid 配置（默认正交 2D，等价旧行为）----
    const grid::GridConfig &getGrid() const;
    grid::GridConfig &getGrid();
    void setGridLayout(const std::string &layout);
    std::string getGridLayoutName() const;
    void setGridPlane(const std::string &plane);
    std::string getGridPlaneName() const;
    void setCellGap(float gapX, float gapY);
    void setHexSideLength(float s);
    void setStagger(const std::string &axis, const std::string &index);
    void setGridFromLayer(map::TileLayer *layer);
    bool hasGridFromLayer() const { return tileLayer_ != nullptr; }
 
    // ---- 坐标换算 ----
    int worldToCellX(float worldX) const;
    int worldToCellY(float worldY) const;
    float cellToWorldX(int cellX) const;
    float cellToWorldY(int cellY) const;
    void cellToWorldPlane(int cellX, int cellY, float &px, float &py) const;
    void cellToWorld3D(int cellX, int cellY, float elevation, float &worldX, float &worldY,
                       float &worldZ) const;
    float cellToWorld3DX(int cellX, int cellY, float elevation) const;
    float cellToWorld3DY(int cellX, int cellY, float elevation) const;
    float cellToWorld3DZ(int cellX, int cellY, float elevation) const;
    void worldToCell3D(float worldX, float worldY, float worldZ, int &cellX, int &cellY) const;
    int worldToCell3DX(float worldX, float worldY, float worldZ) const;
    int worldToCell3DY(float worldX, float worldY, float worldZ) const;
 
    void fillTerrain(int semantic);
    void setTerrain(int cellX, int cellY, int semantic);
    int getTerrain(int cellX, int cellY) const;
    bool inBounds(int cellX, int cellY) const;
 
    // ---- Tilemap 绑定 ----
    void bindTileLayer(map::TileLayer *layer);
    map::TileLayer *getTileLayer() const { return tileLayer_; }
    void clearTileLayer();
    void setTerrainGidMapJson(const std::string &json);
    void setTerrainGid(int gid, int semantic);
    void clearTerrainGidMap();
 
    // ---- 占用查询 ----
    int getOccupant(int cellX, int cellY) const;
    int getOccupantInChannel(const std::string &channel, int cellX, int cellY) const;
    int getOccupantAtLevel(const std::string &channel, int cellX, int cellY, int level) const;
    int getAnyOccupant(int cellX, int cellY) const;
    int getAnyOccupantAtLevel(int cellX, int cellY, int level) const;
    bool isCellEmpty(int cellX, int cellY) const;
    bool isCellEmptyInChannel(const std::string &channel, int cellX, int cellY) const;
    int getEdgeOccupant(const std::string &channel, int cellX, int cellY,
                        const std::string &direction) const;
    int getEdgeOccupantAtLevel(const std::string &channel, int cellX, int cellY,
                               const std::string &direction, int level) const;
    bool isEdgeEmpty(const std::string &channel, int cellX, int cellY,
                     const std::string &direction) const;
    int getCornerOccupant(const std::string &channel, int vertexX, int vertexY) const;
    int getCornerOccupantAtLevel(const std::string &channel, int vertexX, int vertexY,
                                 int level) const;
    int getAnyCornerOccupantAtLevel(int vertexX, int vertexY, int level) const;
    bool isCornerEmpty(const std::string &channel, int vertexX, int vertexY) const;
    int getFreeOccupant(const std::string &channel, float worldX, float worldY) const;
    int getFreeOccupantAtLevel(const std::string &channel, float worldX, float worldY,
                               int level) const;
    int getEdgeConnectionMask(int instanceId) const;
    std::string getEdgeVariant(int instanceId) const;
    int getBuildingCount() const;
    bool hasBuilding(int instanceId) const;
    std::string getBuildingId(int instanceId) const;
    int getBuildingCellX(int instanceId) const;
    int getBuildingCellY(int instanceId) const;
    float getBuildingWorldX(int instanceId) const;
    float getBuildingWorldY(int instanceId) const;
    float getBuildingWorldZ(int instanceId) const;
    float getBuildingElevation(int instanceId) const;
    int getBuildingLevel(int instanceId) const;
    int getBuildingSupportCount(int instanceId) const;
    int getBuildingSupportAt(int instanceId, int index) const;
    int getBuildingDependentCount(int instanceId) const;
    std::string getBuildingSurfaceId(int instanceId) const;
    int64_t getBuildingSurfaceRevision(int instanceId) const;
    float getBuildingSurfaceNormalX(int instanceId) const;
    float getBuildingSurfaceNormalY(int instanceId) const;
    float getBuildingSurfaceNormalZ(int instanceId) const;
    std::string getBuildingChannel(int instanceId) const;
    float getBuildingRotation(int instanceId) const;
    std::string getBuildingProp(int instanceId, const std::string &key,
                                const std::string &fallback = {}) const;
    void setBuildingProp(int instanceId, const std::string &key, const std::string &value);
    bool buildingHasTag(int instanceId, const std::string &tag) const;
    int getBuildingInstanceAt(int index) const;
    int getEdgeCurveGroupCount() const { return static_cast<int>(edgeCurveGroups_.size()); }
    EdgeCurveGroupId nextEdgeCurveGroupId() const { return {nextEdgeCurveGroupId_}; }
    std::vector<EdgeCurveGroupId> edgeCurveGroupIds() const;
    [[nodiscard]] eve::Result<EdgeCurveGroup> edgeCurveGroup(EdgeCurveGroupId id) const;
    [[nodiscard]] eve::Result<EdgeCurveGroup> edgeCurveGroupForInstance(int instanceId) const;
 
    bool canPlace(const std::string &buildingId, int cellX, int cellY, float rotationDeg = 0.f);
    std::string canPlaceReason(const std::string &buildingId, int cellX, int cellY,
                               float rotationDeg = 0.f);
    int placeAt(const std::string &buildingId, int cellX, int cellY, float rotationDeg = 0.f);
    int placeAtWorld(const std::string &buildingId, float worldX, float worldY,
                     float rotationDeg = 0.f);
    int placeAtWorld3D(const std::string &buildingId, float worldX, float worldY, float worldZ,
                       float rotationDeg = 0.f);
    int placeGhost(Ghost *ghost);
    int placeEdge(const std::string &buildingId, int cellX, int cellY,
                  const std::string &direction);
    bool canPlaceEdge(const std::string &buildingId, int cellX, int cellY,
                      const std::string &direction);
    std::string canPlaceEdgeReason(const std::string &buildingId, int cellX, int cellY,
                                   const std::string &direction);
    int placeCorner(const std::string &buildingId, int vertexX, int vertexY);
    bool canPlaceCorner(const std::string &buildingId, int vertexX, int vertexY);
    std::string canPlaceCornerReason(const std::string &buildingId, int vertexX, int vertexY);
    int placeFree(const std::string &buildingId, float worldX, float worldY,
                  float elevation = 0.f, float rotationDeg = 0.f);
    bool canPlaceFree(const std::string &buildingId, float worldX, float worldY);
    std::string canPlaceFreeReason(const std::string &buildingId, float worldX, float worldY);
    bool removeBuilding(int instanceId);
    std::string canRemoveBuildingReason(int instanceId) const;
    int removeBuildingCascade(int instanceId);
    bool moveBuilding(int instanceId, int cellX, int cellY, float rotationDeg = -1.f);
    void clearBuildings();
 
    [[nodiscard]] std::unique_ptr<PlacementWorld> cloneState() const;
    void swapState(PlacementWorld& candidate) noexcept;
 
    // ---- 供 System 直接访问 ----
    const std::vector<int> &occupancy() const { return occupancy_; }
    std::vector<int> &occupancy() { return occupancy_; }
    const std::vector<int> &terrain() const { return terrain_; }
    std::vector<int> &terrain() { return terrain_; }
    const std::unordered_map<std::string, std::vector<int>> &allChannels() const {
        return allChannels_;
    }
    std::unordered_map<std::string, std::vector<int>> &allChannels() { return allChannels_; }
    std::vector<int> &channelOccupancy(const std::string &channel);
    std::vector<int> &channelOccupancy(const std::string &channel, int level);
    const std::unordered_map<int, PlacedBuilding> &buildings() const { return buildings_; }
    std::unordered_map<int, PlacedBuilding> &buildings() { return buildings_; }
 
private:
    friend class PlacementSystem;
 
    int terrainFromGid(int cellX, int cellY) const;
    ChannelMap &edgeChannels(EdgeAxis axis, int level);
    const ChannelMap *findEdgeChannels(EdgeAxis axis, int level) const;
    ChannelMap &cornerChannels(int level);
    const ChannelMap *findCornerChannels(int level) const;
 
    std::string id_;
    int width_ = 0;
    int height_ = 0;
    float floorHeight_ = 3.f;
    int activeLevel_ = 0;
    std::unique_ptr<grid::GridConfig> grid_;
    std::string snapMode_ = "grid";
    std::string validateRule_ = "default";
    std::vector<int> occupancy_;
    std::vector<int> terrain_;
    std::vector<uint8_t> terrainOverrides_;  
    std::unordered_map<std::string, std::vector<int>> allChannels_;
    std::unordered_map<std::string, std::vector<int>> horizontalEdgeChannels_;
    std::unordered_map<std::string, std::vector<int>> verticalEdgeChannels_;
    std::unordered_map<std::string, std::vector<int>> cornerChannels_;
    std::unordered_map<int, ChannelMap> cellChannelsByLevel_;
    std::unordered_map<int, ChannelMap> horizontalEdgesByLevel_;
    std::unordered_map<int, ChannelMap> verticalEdgesByLevel_;
    std::unordered_map<int, ChannelMap> cornersByLevel_;
    std::unordered_map<int, PlacedBuilding> buildings_;
    std::unordered_map<uint64_t, EdgeCurveGroup> edgeCurveGroups_;
    uint64_t nextEdgeCurveGroupId_ = 1;
    bool publishEvents_ = true;
    std::unordered_map<std::string, std::string> extra_;
    std::vector<int> instanceOrder_;
 
    // tilemap 绑定（可空）
    map::TileLayer *tileLayer_ = nullptr;
    bool terrainBound_ = false;
    std::unordered_map<int, int> terrainGidMap_;
};
 
}  // namespace eve::building