PlacementSession.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
// 放置会话：封装「选择建筑 -> 跟随指针 -> 校验 -> 放置 / 拆除」的交互状态。
// 纯逻辑、不接输入设备；脚本每帧喂指针坐标 / 表面命中，会话内部驱动 Ghost。
 
#include <string>
#include <vector>
 
#include "building/PlacementSystem.h"
 
namespace eve::building {
 
class PlacementWorld;
class Ghost;
 
enum class EdgeUpdateStatus { Updated, Rejected };
enum class CornerUpdateStatus { Updated, Rejected };
enum class FreeUpdateStatus { Updated, Rejected };
enum class EdgeLineExecuteStatus { Placed, Rejected };
enum class EdgePathUpdateStatus { Updated, Rejected };
enum class PlacementEditExecuteStatus { Committed, Rejected };
enum class AreaExecuteStatus { Accepted, Rejected };
enum class PatternUpdateStatus { Updated, Rejected };
enum class PatternExecuteStatus { Placed, Rejected };
 
class EVENGINE_API_WORLD PlacementSession {
public:
    PlacementSession();
    ~PlacementSession() = default;
 
    PlacementSession(const PlacementSession &) = delete;
    PlacementSession &operator=(const PlacementSession &) = delete;
 
    void destroy();
 
    bool startPlacement(PlacementWorld *world, const std::string &buildingId);
    void stopPlacement();
    bool isActive() const { return active_; }
    PlacementWorld *getWorld() const { return world_; }
    std::string getBuildingId() const;
    Ghost *getGhost() const { return ghost_; }
 
    void setMode(const std::string &mode);
    std::string getMode() const { return mode_; }
 
    void setRotationDeg(float deg);
    void rotateBy(float deltaDeg);
    float getRotationDeg() const;
 
    bool updateFromWorld(PlacementWorld *world, float worldX, float worldY);
    bool updateFromWorld3D(PlacementWorld *world, float worldX, float worldY, float worldZ);
    bool updateFromSurface(PlacementWorld *world, const std::string &surface, float x, float y);
    EdgeUpdateStatus updateEdge(PlacementWorld *world, int cellX, int cellY,
                                const std::string &direction);
    CornerUpdateStatus updateCorner(PlacementWorld *world, int vertexX, int vertexY);
    FreeUpdateStatus updateFree(PlacementWorld *world, float worldX, float worldY,
                                float elevation = 0.f);
 
    bool isValid() const;
    std::string getReason() const;
 
    int execute();
    EdgeLineExecuteStatus executeEdgeLine(int startVertexX, int startVertexY, int endVertexX,
                                          int endVertexY);
    EdgePathUpdateStatus beginEdgePath(int vertexX, int vertexY);
    EdgePathUpdateStatus appendEdgePathVertex(int vertexX, int vertexY);
    EdgeLineExecuteStatus executeEdgePath();
    int getEdgePathVertexCount() const { return static_cast<int>(edgePathVertices_.size()); }
    EdgePathUpdateStatus beginEdgeCurve(float x, float y);
    EdgePathUpdateStatus appendEdgeCurveControlPoint(float x, float y);
    EdgeLineExecuteStatus executeEdgeCurve(int subdivisions);
    EdgeLineExecuteStatus executeEdgeCurveOnSurface(int subdivisions,
                                                    const std::string &surfaceName);
    int getEdgeCurveControlPointCount() const {
        return static_cast<int>(edgeCurveControlPoints_.size());
    }
    const std::vector<PlacementSystem::EdgeCurvePoint> &edgeCurveControlPoints() const {
        return edgeCurveControlPoints_;
    }
    int getLastPlacedCount() const { return static_cast<int>(lastPlacedIds_.size()); }
    int getLastPlacedId(int index) const;
    PlacementEditExecuteStatus executeMove(int instanceId);
    PlacementEditExecuteStatus executeReplace(int instanceId);
    int getLastEditedId() const { return lastEditedId_; }
    AreaExecuteStatus previewRectangle(int minCellX, int minCellY, int maxCellX, int maxCellY);
    AreaExecuteStatus previewBrush(int centerCellX, int centerCellY, int radius);
    AreaExecuteStatus executeRectangle(int minCellX, int minCellY, int maxCellX, int maxCellY);
    AreaExecuteStatus executeBrush(int centerCellX, int centerCellY, int radius);
    int getAreaPreviewCount() const { return static_cast<int>(areaPreview_.cells.size()); }
    int getAreaPreviewCellX(int index) const;
    int getAreaPreviewCellY(int index) const;
    bool getAreaPreviewAccepted(int index) const;
    std::string getAreaPreviewReason(int index) const;
 
    PatternUpdateStatus beginPattern(const std::string &kind);
    PatternUpdateStatus appendPatternPoint(float x, float y);
    PatternUpdateStatus setPatternRadius(int radius);
    PatternUpdateStatus setPatternSubdivisions(int subdivisions);
    PatternUpdateStatus setPatternSurface(const std::string &surfaceName);
    PatternUpdateStatus previewPattern();
    PatternExecuteStatus executePattern();
    std::string getPatternKind() const;
    int getPatternPointCount() const {
        return static_cast<int>(patternRequest_.points.size());
    }
    int getPatternPreviewCount() const {
        return patternPreview_.anchorCount();
    }
    int getPatternPreviewX(int index) const;
    int getPatternPreviewY(int index) const;
    std::string getPatternPreviewAxis(int index) const;
    bool getPatternPreviewAccepted(int index) const;
    std::string getPatternPreviewReason(int index) const;
 
private:
    void refreshValidate();
 
    PlacementWorld *world_ = nullptr;
    Ghost *ghost_ = nullptr;
    std::string mode_ = "place";
    bool active_ = false;
    std::vector<int> lastPlacedIds_;
    std::vector<CornerAddress> edgePathVertices_;
    std::vector<PlacementSystem::EdgeCurvePoint> edgeCurveControlPoints_;
    int lastEditedId_ = 0;
    PlacementSystem::AreaPreview areaPreview_;
    PlacementSystem::PatternRequest patternRequest_;
    PlacementSystem::PatternPreview patternPreview_;
    bool patternActive_ = false;
};
 
}  // namespace eve::building