ModuleAssembly.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "common/Result.h"
 
#include <array>
#include <string>
#include <vector>
 
namespace eve::procgen {
 
enum class ModuleFacing : unsigned char { North, East, South, West, Up, Down };
 
struct ModuleConnector {
    int          cellX  = 0;
    int          cellZ  = 0;
    ModuleFacing facing = ModuleFacing::North;
    std::string  tag;
    std::string  accepts;
    int          levelOffset = 0;
};
 
struct ModuleDefinition {
    std::string                  id;
    int                          widthCells = 1;
    int                          depthCells = 1;
    std::vector<ModuleConnector> connectors;
    int                          heightLevels = 1;
};
 
struct ModulePlacement {
    std::string moduleId;
    int         cellX       = 0;
    int         cellZ       = 0;
    int         level       = 0;
    int         quarterTurn = 0;
};
 
struct ModuleAssemblyConstraints {
    float               cellSize    = 4.0f;
    float               floorHeight = 4.0f;
    int                 minCellX    = 0;
    int                 maxCellX    = 0;
    int                 minCellZ    = 0;
    int                 maxCellZ    = 0;
    int                 maxLevels   = 1;
    std::array<bool, 4> allowedQuarterTurns{true, true, true, true};
    bool                bounded             = false;
    bool                requireConnection   = true;
    float               minimumSupportRatio = 0.0f;
};
 
class EVENGINE_API_DOMAINS ModuleAssemblyPlan {
public:
    ModuleAssemblyPlan() = default;
    explicit ModuleAssemblyPlan(ModuleAssemblyConstraints constraints);
 
    [[nodiscard]] Result<void> configure(float cellSize, float floorHeight, int minCellX, int maxCellX, int minCellZ,
                                         int maxCellZ, int maxLevels, bool bounded, bool requireConnection);
 
    [[nodiscard]] Result<void> setAllowedQuarterTurns(bool turn0, bool turn90, bool turn180, bool turn270);
 
    [[nodiscard]] Result<void> setMinimumSupportRatio(float ratio);
 
    [[nodiscard]] Result<void> applyConfigJson(const std::string& json);
 
    [[nodiscard]] Result<void> registerModuleType(std::string id, int widthCells, int depthCells);
 
    [[nodiscard]] Result<void> registerVolumeModuleType(std::string id, int widthCells, int depthCells,
                                                        int heightLevels);
 
    [[nodiscard]] Result<void> addConnector(const std::string& moduleId, int cellX, int cellZ, int facing,
                                            std::string tag, std::string accepts);
 
    [[nodiscard]] Result<void> addVolumeConnector(const std::string& moduleId, int cellX, int cellZ, int levelOffset,
                                                  int facing, std::string tag, std::string accepts);
 
    [[nodiscard]] Result<void> registerModule(ModuleDefinition definition);
 
    [[nodiscard]] Result<void> place(ModulePlacement placement);
 
    [[nodiscard]] const std::vector<ModulePlacement>& placements() const noexcept { return placements_; }
    [[nodiscard]] int getPlacementCount() const noexcept { return static_cast<int>(placements_.size()); }
    [[nodiscard]] std::string getPlacementModule(int index) const;
    [[nodiscard]] float getPlacementX(int index) const noexcept;
    [[nodiscard]] float getPlacementY(int index) const noexcept;
    [[nodiscard]] float getPlacementZ(int index) const noexcept;
    [[nodiscard]] float getPlacementYawDegrees(int index) const noexcept;
    [[nodiscard]] const ModuleAssemblyConstraints& constraints() const noexcept { return constraints_; }
 
private:
    ModuleAssemblyConstraints     constraints_;
    std::vector<ModuleDefinition> definitions_;
    std::vector<ModulePlacement>  placements_;
};
 
}  // namespace eve::procgen