BuildingTypes.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Revision.h"
 
#include <cstdint>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::building {
 
enum class EdgeAxis : uint8_t { Horizontal, Vertical };
 
struct EdgeAddress {
    int x = 0;
    int y = 0;
    EdgeAxis axis = EdgeAxis::Horizontal;
 
    bool operator==(const EdgeAddress &) const = default;
};
 
struct CornerAddress {
    int x = 0;
    int y = 0;
 
    bool operator==(const CornerAddress &) const = default;
};
 
struct EdgeCurveGroupId {
    uint64_t value = 0;
 
    explicit operator bool() const { return value != 0; }
    bool operator==(const EdgeCurveGroupId &) const = default;
};
 
struct EdgeCurveControlPoint {
    float x = 0.f;
    float y = 0.f;
 
    bool operator==(const EdgeCurveControlPoint &) const = default;
};
 
struct EdgeCurveSurfaceSample {
    float worldX = 0.f;
    float worldY = 0.f;
    float worldZ = 0.f;
    float normalX = 0.f;
    float normalY = 1.f;
    float normalZ = 0.f;
 
    bool operator==(const EdgeCurveSurfaceSample &) const = default;
};
 
struct EdgeCurveGroup {
    EdgeCurveGroupId id;
    std::string buildingId;
    int level = 0;
    std::vector<EdgeCurveControlPoint> controlPoints;
    int subdivisions = 0;
    std::vector<int> instanceIds;
    std::string surfaceProviderName;
    std::string surfaceId;
    uint64_t surfaceRevision = 0;
    std::vector<EdgeCurveSurfaceSample> surfaceSamples;
 
    bool operator==(const EdgeCurveGroup &) const = default;
};
 
struct EVENGINE_API_WORLD BuildingDefinition {
    std::string id;
    std::string displayName;
    std::string category;
    std::string channel;
    std::string renderMode;
    std::string placementKind = "cell";
    float freeRadiusCells = 0.25f;
    float freeFootprintWidthCells = 0.f;
    float freeFootprintHeightCells = 0.f;
    std::vector<float> freeFootprintVertices;
    std::string connectionGroup;
    std::string structuralRole;
    std::string supportMode = "none";
    std::string supportTag;
    int footprintW = 1;
    int footprintH = 1;
    std::vector<uint8_t> footprintMask;
    std::string snapMode = "grid";
    std::string rotationMode = "cardinal";
    std::string validateRule = "default";
    float maxSurfaceSlopeDegrees = 180.f;
    float maxSurfaceHeightDelta = -1.f;
    std::vector<std::string> tags;
    std::vector<int> requireTerrain;
    std::vector<int> forbidTerrain;
    std::string requireAdjacentTag;
    int requireAdjacentTerrain = -1;
    std::unordered_map<std::string, int> cost;
    std::unordered_map<std::string, std::string> extra;
    std::unordered_map<std::string, std::string> visual2d;
    std::unordered_map<std::string, std::string> visual3d;
 
    bool hasTag(const std::string &tag) const;
    std::string getExtra(const std::string &key, const std::string &fallback = {}) const;
    std::string getVisual2d(const std::string &key, const std::string &fallback = {}) const;
    std::string getVisual3d(const std::string &key, const std::string &fallback = {}) const;
    int getCost(const std::string &resource, int fallback = 0) const;
    bool maskAt(int localX, int localY) const;
};
 
struct GarrisonMember {
    std::string              id;
    std::string              type = "building.garrison.member";
    std::vector<std::string> tags;
};
 
struct EVENGINE_API_WORLD PlacedBuilding {
    int instanceId = 0;
    std::string buildingId;
    std::string placementKind = "cell";
    EdgeAddress edge;
    EdgeCurveGroupId edgeCurveGroupId;
    CornerAddress corner;
    float freeRadius = 0.f;
    float freeHalfWidth = 0.f;
    float freeHalfHeight = 0.f;
    std::vector<float> freeFootprintVertices;
    int originCellX = 0;
    int originCellY = 0;
    int level = 0;
    float worldX = 0.f;
    float worldY = 0.f;
    float elevation = 0.f;
    std::string surfaceId;
    uint64_t surfaceRevision = 0;
    float surfaceNormalX = 0.f;
    float surfaceNormalY = 1.f;
    float surfaceNormalZ = 0.f;
    float surfaceTangentX = 1.f;
    float surfaceTangentY = 0.f;
    float surfaceTangentZ = 0.f;
    int surfaceSampleCount = 0;
    float surfaceMaxSlopeDegrees = 0.f;
    float surfaceHeightDelta = 0.f;
    float rotationDeg = 0.f;
    std::string channel;
    std::unordered_map<std::string, std::string> props;
    std::vector<std::string> tags;
    std::vector<int> supportInstanceIds;
    std::vector<GarrisonMember> garrison;
    eve::Revision garrisonRevision = eve::Revision::zero();
 
    bool hasTag(const std::string &tag) const;
    std::string getProp(const std::string &key, const std::string &fallback = {}) const;
    void setProp(const std::string &key, const std::string &value);
};
 
struct BuildingChangeEvent {
    std::string action;  
    std::string worldId;
    std::string buildingId;
    std::string otherBuildingId;
    int instanceId = 0;
    int cellX = -1;
    int cellY = -1;
    int otherCellX = -1;
    int otherCellY = -1;
    int level = 0;
    int otherLevel = 0;
    float rotationDeg = 0.f;
    float worldX = 0.f;
    float worldY = 0.f;
    float elevation = 0.f;
    std::string channel;
};
 
struct PlacementQuery {
    std::string buildingId;
    int cellX = 0;
    int cellY = 0;
    int level = 0;
    float worldX = 0.f;
    float worldY = 0.f;
    float elevation = 0.f;
    std::string surfaceId;
    uint64_t surfaceRevision = 0;
    float surfaceNormalX = 0.f;
    float surfaceNormalY = 1.f;
    float surfaceNormalZ = 0.f;
    int surfaceSampleCount = 0;
    float surfaceMaxSlopeDegrees = 0.f;
    float surfaceHeightDelta = 0.f;
    float rotationDeg = 0.f;
    int excludeInstanceId = 0;  
};
 
struct SnapResult {
    int cellX = 0;
    int cellY = 0;
    float worldX = 0.f;
    float worldY = 0.f;
    float elevation = 0.f;
};
 
struct PlacementEditReceipt {
    PlacedBuilding before;
    PlacedBuilding after;
};
 
struct StructuralRemovalReceipt {
    std::vector<PlacedBuilding> removed;
};
 
struct StructuralLinkRebuildReceipt {
    int inspectedCount = 0;
    int changedCount = 0;
};
 
}  // namespace eve::building