PlacementSystem.h

浏览该文件的文档.

#pragma once
 
// 放置操作静态入口 + 可插拔校验 / 吸附 / 变更钩子。
//
// C++ 侧通过 register* 扩展；脚本侧通过定义/世界上的策略名字符串选用已注册规则。
 
#include "building/BuildingTypes.h"
 
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::building {
 
class PlacementWorld;
class Ghost;
 
class PlacementSystem {
public:
    using ValidateFn = std::function<bool(const PlacementWorld &world, const PlacementQuery &q,
                                          std::string *reason)>;
    using SnapFn =
        std::function<SnapResult(const PlacementWorld &world, float worldX, float worldY)>;
    using ChangeHook = std::function<void(const BuildingChangeEvent &ev)>;
 
    struct PlacementHit {
        float worldX = 0.f;
        float worldY = 0.f;
        float worldZ = 0.f;
    };
    using SurfaceFn = std::function<bool(const PlacementWorld &world, float x, float y,
                                         PlacementHit *hit)>;
 
    static PlacementSystem &inst();
 
    static void registerValidateRule(const std::string &name, ValidateFn fn);
    static void unregisterValidateRule(const std::string &name);
    static bool hasValidateRule(const std::string &name);
 
    static void registerSnapRule(const std::string &name, SnapFn fn);
    static void unregisterSnapRule(const std::string &name);
    static bool hasSnapRule(const std::string &name);
 
    static void registerChangeHook(const std::string &name, ChangeHook fn);
    static void unregisterChangeHook(const std::string &name);
    static bool hasChangeHook(const std::string &name);
 
    static void registerSurface(const std::string &name, SurfaceFn fn);
    static void unregisterSurface(const std::string &name);
    static bool hasSurface(const std::string &name);
    static bool surfaceHit(const PlacementWorld &world, const std::string &name, float x,
                           float y, PlacementHit *hit);
    static std::vector<std::string> surfaceNames();
    static void setPlaneSurfaceHeight(float h);
    static float getPlaneSurfaceHeight();
 
    static void ensureBuiltins();
 
    static SnapResult snap(const PlacementWorld &world, const std::string &buildingId, float worldX,
                           float worldY);
    static SnapResult snap3D(const PlacementWorld &world, const std::string &buildingId,
                             float worldX, float worldY, float worldZ);
    static SnapResult snapWithMode(const PlacementWorld &world, const std::string &mode,
                                   float worldX, float worldY);
 
    static float normalizeRotation(const std::string &buildingId, float rotationDeg);
 
    static void effectiveFootprint(const BuildingDefinition &def, float rotationDeg, int *outW,
                                   int *outH);
 
    static bool foreachFootprintCell(const BuildingDefinition &def, int originCellX,
                                     int originCellY, float rotationDeg,
                                     const std::function<bool(int cx, int cy)> &fn);
 
    static bool canPlace(PlacementWorld *world, const std::string &buildingId, int cellX, int cellY,
                         float rotationDeg = 0.f, int excludeInstanceId = 0,
                         std::string *reason = nullptr);
    static bool canPlaceElev(PlacementWorld *world, const std::string &buildingId, int cellX,
                             int cellY, float elevation, float rotationDeg = 0.f,
                             int excludeInstanceId = 0, std::string *reason = nullptr);
 
    static int placeAt(PlacementWorld *world, const std::string &buildingId, int cellX, int cellY,
                       float rotationDeg = 0.f);
    static int placeAtWorld(PlacementWorld *world, const std::string &buildingId, float worldX,
                            float worldY, float rotationDeg = 0.f);
    static int placeAtWorld3D(PlacementWorld *world, const std::string &buildingId, float worldX,
                              float worldY, float worldZ, float rotationDeg = 0.f);
    static int placeGhost(PlacementWorld *world, Ghost *ghost);
 
    static bool removeBuilding(PlacementWorld *world, int instanceId);
    static bool moveBuilding(PlacementWorld *world, int instanceId, int cellX, int cellY,
                             float rotationDeg = -1.f);
    static void clearBuildings(PlacementWorld *world);
 
    static void pushEvent(BuildingChangeEvent ev);
    static void pollEvents(std::vector<BuildingChangeEvent> &out);
    static void clearEvents();
    static const std::vector<BuildingChangeEvent> &events();
 
    static int nextInstanceId();
 
private:
    static bool runValidate(const PlacementWorld &world, const BuildingDefinition &def,
                            const PlacementQuery &q, std::string *reason);
    static bool checkBoundsAndOccupancy(const PlacementWorld &world, const BuildingDefinition &def,
                                        const PlacementQuery &q, bool checkOccupancy,
                                        std::string *reason);
    static bool checkTerrain(const PlacementWorld &world, const BuildingDefinition &def,
                             const PlacementQuery &q, std::string *reason);
    static bool checkAdjacency(const PlacementWorld &world, const BuildingDefinition &def,
                               const PlacementQuery &q, std::string *reason);
    static void writeOccupancy(PlacementWorld &world, const BuildingDefinition &def,
                               const PlacedBuilding &placed, int instanceId);
    static void clearOccupancy(PlacementWorld &world, int instanceId);
    static void emit(BuildingChangeEvent ev);
 
    static std::unordered_map<std::string, ValidateFn> &validateRules();
    static std::unordered_map<std::string, SnapFn> &snapRules();
    static std::unordered_map<std::string, ChangeHook> &changeHooks();
    static std::unordered_map<std::string, SurfaceFn> &surfaces();
    static float &planeSurfaceHeight();
    static std::vector<BuildingChangeEvent> &eventQueue();
    static int &instanceCounter();
    static bool &builtinsReady();
 
    PlacementSystem() = default;
    ~PlacementSystem() = default;
    PlacementSystem(const PlacementSystem &) = delete;
    PlacementSystem &operator=(const PlacementSystem &) = delete;
 
    std::unordered_map<std::string, ValidateFn> validateRules_;
    std::unordered_map<std::string, SnapFn> snapRules_;
    std::unordered_map<std::string, ChangeHook> changeHooks_;
    std::unordered_map<std::string, SurfaceFn> surfaces_;
    std::vector<BuildingChangeEvent> eventQueue_;
    int instanceCounter_ = 0;
    bool builtinsReady_ = false;
    float planeSurfaceHeight_ = 0.f;
};
 
}  // namespace eve::building