PixelWorld.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/Time.h"
#include "pixelworld/PixelMaterial.h"
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <span>
#include <vector>
 
namespace eve::pixelworld {
 
class PixelWorldControlService;
 
inline constexpr int kPixelChunkSize = 64;
inline constexpr std::uint8_t kPixelSleepHysteresisTicks = 3;
 
struct PixelCell {
    MaterialId material = MaterialId::Air;
    std::int16_t temperature = 20;
    std::uint8_t lifetime = 0;
    std::uint16_t thermalRemainder = 0;
 
    friend bool operator==(const PixelCell&, const PixelCell&) = default;
};
 
struct StepStats {
    eve::SimulationTick tick = eve::SimulationTick::zero();
    std::uint32_t chunksVisited = 0;
    std::uint32_t cellsVisited = 0;
    std::uint32_t cellsChanged = 0;
    std::uint32_t cellsMoved = 0;
    std::uint32_t temperatureTransfers = 0;
    std::uint64_t thermalEnergyTransferred = 0;
    std::uint64_t thermalEnergyClamped = 0;
    std::uint32_t phaseChanges = 0;
    std::uint32_t reactions = 0;
    std::uint32_t parallelTasks = 0;
    std::uint32_t chunksReclaimed = 0;
};
 
class PixelWorkScheduler {
public:
    virtual ~PixelWorkScheduler() = default;
    virtual void parallelFor(std::size_t workItems,
                             const std::function<void(std::size_t)>& body) = 0;
    [[nodiscard]] virtual std::size_t workerCount() const noexcept = 0;
};
 
struct PixelChunkSnapshot {
    int x = 0;
    int y = 0;
    std::uint64_t revision = 0;
    bool removed = false;
    std::vector<PixelCell> cells;
 
    friend bool operator==(const PixelChunkSnapshot&, const PixelChunkSnapshot&) = default;
};
 
struct PixelChunkBatch {
    std::uint64_t catalogFingerprint = 0;
    std::uint64_t sourceSeed = 0;
    std::uint64_t sourceRevision = 0;
    eve::SimulationTick sourceTick = eve::SimulationTick::zero();
    std::uint64_t sourceLastEditSequence = 0;
    bool fullResync = false;
    std::vector<PixelChunkSnapshot> chunks;
 
    friend bool operator==(const PixelChunkBatch&, const PixelChunkBatch&) = default;
};
 
struct PixelChunkRegion {
    int minX = 0;
    int minY = 0;
    int maxX = -1;
    int maxY = -1;
 
    friend bool operator==(const PixelChunkRegion&, const PixelChunkRegion&) = default;
};
 
struct PixelChunkDiagnostic {
    int x = 0;
    int y = 0;
    std::uint64_t revision = 0;
    std::uint32_t nonAirCells = 0;
    std::uint32_t mobileCells = 0;
    std::int16_t minimumTemperature = 20;
    std::int16_t maximumTemperature = 20;
    std::uint8_t idleTicks = 0;
    bool active = false;
};
 
struct PixelChunkApplyReceipt {
    std::uint64_t revisionBefore = 0;
    std::uint64_t revisionAfter = 0;
    std::uint32_t chunksReplaced = 0;
    std::uint32_t chunksRemoved = 0;
    std::uint64_t worldEpoch = 0;
};
 
struct PixelCatalogReloadReceipt {
    std::uint64_t fingerprintBefore = 0;
    std::uint64_t fingerprintAfter = 0;
    std::uint64_t revisionBefore = 0;
    std::uint64_t revisionAfter = 0;
    std::uint64_t worldEpoch = 0;
    std::uint32_t chunksRebuilt = 0;
    bool replayHistoryInvalidated = false;
};
 
enum class PixelEditKind : std::uint8_t { PaintCircle, HeatCircle, Explosion };
 
struct PixelEditCommand {
    std::uint64_t sequence = 0;
    PixelEditKind kind = PixelEditKind::PaintCircle;
    int centerX = 0;
    int centerY = 0;
    int radius = 0;
    MaterialId material = MaterialId::Air;
    int strength = 0;
    std::int16_t temperatureDelta = 0;
};
 
struct PixelEditReceipt {
    std::uint64_t sequence = 0;
    std::uint64_t revisionBefore = 0;
    std::uint64_t revisionAfter = 0;
    std::uint32_t cellsChanged = 0;
    std::uint32_t cellsRemoved = 0;
    std::uint32_t cellsHeated = 0;
};
 
struct PixelRegion {
    int minX = 0;
    int minY = 0;
    int maxX = -1;
    int maxY = -1;
};
 
struct PixelWorldLink {
    std::uint64_t world = 0;
    std::uint64_t epoch = 0;
    friend bool operator==(const PixelWorldLink&, const PixelWorldLink&) = default;
};
 
struct PixelFragment {
    PixelWorldLink source;
    std::uint64_t id = 0;
    int originX = 0;
    int originY = 0;
    int width = 0;
    int height = 0;
    std::uint32_t solidCellCount = 0;
    std::vector<PixelCell> cells;
};
 
struct PixelFragmentRasterReceipt {
    std::uint64_t fragmentId = 0;
    std::uint64_t revisionBefore = 0;
    std::uint64_t revisionAfter = 0;
    std::uint32_t cellsPlaced = 0;
};
 
class EVENGINE_API_FOUNDATION PixelWorld {
public:
    explicit PixelWorld(std::uint64_t seed = 1);
    PixelWorld(std::uint64_t seed, MaterialCatalog catalog);
    ~PixelWorld();
    PixelWorld(PixelWorld&&) noexcept;
    PixelWorld& operator=(PixelWorld&&) noexcept;
    PixelWorld(const PixelWorld&) = delete;
    PixelWorld& operator=(const PixelWorld&) = delete;
 
    PixelCell getCell(int x, int y) const noexcept;
    int getMaterial(int x, int y) const noexcept;
    bool isSolidMaterial(MaterialId material) const noexcept;
    std::uint32_t materialDisplayRgba(MaterialId material) const noexcept;
    [[nodiscard]] eve::Result<PixelCatalogReloadReceipt> reloadMaterialCatalog(
        MaterialCatalog catalog, std::uint64_t expectedFingerprint);
    void setCell(int x, int y, PixelCell cell);
    void setMaterial(int x, int y, std::string_view material);
    [[nodiscard]] eve::Result<void> setMaterialChecked(int x, int y, std::string_view material);
    std::size_t paintCircle(int centerX, int centerY, int radius, std::string_view material);
    [[nodiscard]] eve::Result<std::size_t> paintCircleChecked(int centerX, int centerY, int radius,
                                                              std::string_view material);
    [[nodiscard]] eve::Result<PixelEditReceipt> applyEdit(const PixelEditCommand& command);
    PixelEditReceipt explode(int centerX, int centerY, int radius, int strength,
                             std::int16_t temperatureDelta);
    [[nodiscard]] eve::Result<std::vector<PixelFragment>> extractUnsupportedFragments(
        PixelRegion region, int supportY, std::uint32_t minimumCells = 1);
    [[nodiscard]] eve::Result<PixelFragmentRasterReceipt> rasterizeFragment(
        const PixelFragment& fragment, int originX, int originY);
    PixelWorldLink worldLink() const noexcept;
    void clear() noexcept;
 
    [[nodiscard]] eve::Result<StepStats> advance(eve::SimulationTick tick);
    [[nodiscard]] eve::Result<StepStats> advanceScheduled(eve::SimulationTick tick,
                                                          PixelWorkScheduler& scheduler);
    StepStats step();
 
    void setPaused(bool paused) noexcept;
    bool isPaused() const noexcept;
 
    std::uint64_t seed() const noexcept;
    std::uint64_t revision() const noexcept;
    std::uint64_t tickValue() const noexcept;
    std::uint64_t lastEditSequence() const noexcept;
    int chunkCount() const noexcept;
    int activeChunkCount() const noexcept;
    std::uint64_t materialCatalogFingerprint() const noexcept;
 
    std::vector<PixelChunkSnapshot> snapshotChangedChunks(std::uint64_t sinceRevision) const;
 
    [[nodiscard]] eve::Result<std::vector<PixelChunkSnapshot>> snapshotChunksInRegion(
        PixelChunkRegion region, std::uint64_t sinceRevision = 0) const;
 
    [[nodiscard]] eve::Result<std::vector<PixelChunkDiagnostic>> chunkDiagnostics(
        PixelChunkRegion region) const;
 
    [[nodiscard]] eve::Result<PixelChunkApplyReceipt> applyChunkBatch(
        const PixelChunkBatch& batch, std::uint64_t expectedRevision);
 
    [[nodiscard]] eve::Result<std::vector<std::byte>> saveSnapshot() const;
    [[nodiscard]] eve::Result<void> restoreSnapshot(std::span<const std::byte> bytes);
 
private:
    friend class PixelWorldControlService;
    eve::Result<StepStats> advanceImpl(eve::SimulationTick tick, PixelWorkScheduler* scheduler);
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace eve::pixelworld