LevelDraft.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <cstddef>
#include <optional>
#include <string>
#include <vector>
 
#include "Core/Levels/CameraFraming.h"
#include "Core/Levels/GridPosition.h"
#include "Core/Levels/Level.h"
#include "Core/Levels/LevelLoader.h"
#include "Core/Levels/MapEntity.h"
#include "Core/Levels/TileLayer.h"
#include "Core/Levels/TileMap.h"
#include "Core/Levels/TileType.h"

 
namespace core {

class LevelDraft {
public:
    [[nodiscard]] static LevelDraft empty(std::string name, int width, int height);

    [[nodiscard]] static LevelDraft fromLevel(const Level& level);

    void paintTile(int column, int row, TileType type);

    void paintRegion(int originColumn, int originRow,
                     const std::vector<std::vector<TileType>>& block);

    void setEntry(int column, int row);

    void setExit(int column, int row);

    void linkMechanism(GridPosition switchPosition, GridPosition targetPosition);

    void unlinkMechanism(GridPosition targetPosition);
    void setTextureOverride(GridPosition position, std::string assetName);

    void removeTextureOverride(GridPosition position);


    void addPlane(Plane plane);

    void removePlane(std::size_t index);

    bool setPlaneDensity(std::size_t index, int pixelsPerUnit);

    bool setPlaneParallax(std::size_t index, float parallaxX, float parallaxY);

    bool setPlaneOpacity(std::size_t index, float opacity);

    bool setPlaneDepth(std::size_t index, PlaneDepth depth);

    std::optional<std::size_t> movePlaneForward(std::size_t index);

    std::optional<std::size_t> movePlaneBackward(std::size_t index);

    std::optional<std::size_t> movePlaneToFront(std::size_t index);

    std::optional<std::size_t> movePlaneToBack(std::size_t index);

    void setParallaxEnabled(bool enabled);


    void resize(int width, int height);

    [[nodiscard]] bool wouldResizeDropContent(int width, int height) const noexcept;

    bool undo();

    bool redo();

    [[nodiscard]] bool canUndo() const noexcept {
        return !_undoHistory.empty();
    }

    [[nodiscard]] bool canRedo() const noexcept {
        return !_redoHistory.empty();
    }

    void setName(std::string name) {
        _name = std::move(name);
    }

    void setBackground(std::optional<std::string> background);

    void setSkinSet(std::optional<std::string> skinSet);

    void setCameraFraming(CameraFramingConfig cameraFraming);

    void addCameraZone(CameraZone zone);

    void removeCameraZone(std::size_t index);

    [[nodiscard]] const std::string& name() const noexcept {
        return _name;
    }

    [[nodiscard]] const TileMap& tileMap() const noexcept {
        return _tileMap;
    }

    [[nodiscard]] std::optional<GridPosition> entry() const noexcept {
        return _entry;
    }

    [[nodiscard]] std::optional<GridPosition> exit() const noexcept {
        return _exit;
    }

    [[nodiscard]] const std::vector<Mechanism>& mechanisms() const noexcept {
        return _mechanisms;
    }

    [[nodiscard]] const std::vector<TileTextureOverride>& textureOverrides() const noexcept {
        return _textureOverrides;
    }

    [[nodiscard]] const std::vector<Plane>& planes() const noexcept {
        return _planes;
    }

    [[nodiscard]] const std::vector<TileLayer>& layers() const noexcept {
        return _layers;
    }

    [[nodiscard]] const std::vector<MapEntity>& entities() const noexcept {
        return _entities;
    }

    [[nodiscard]] bool parallaxEnabled() const noexcept {
        return _parallaxEnabled;
    }

    [[nodiscard]] const std::optional<std::string>& background() const noexcept {
        return _background;
    }

    [[nodiscard]] const std::optional<std::string>& skinSet() const noexcept {
        return _skinSet;
    }

    [[nodiscard]] const CameraFramingConfig& cameraFraming() const noexcept {
        return _cameraFraming;
    }

    [[nodiscard]] LevelLoadResult toLevel() const;
 
private:
    LevelDraft(std::string name, TileMap tileMap);

    void paintTileInternal(int column, int row, TileType type);

    void setEntryInternal(int column, int row);

    void setExitInternal(int column, int row);

    void removeLinkedDataAt(GridPosition position, bool keepTextureOverride = false);


    struct State {
        std::string name;
        TileMap tileMap;
        std::optional<GridPosition> entry;
        std::optional<GridPosition> exit;
        std::vector<Mechanism> mechanisms;
        std::vector<TileLayer> layers;
        std::vector<MapEntity> entities;
        std::optional<std::string> background;
        std::optional<std::string> skinSet;
        std::vector<TileTextureOverride> textureOverrides;
        CameraFramingConfig cameraFraming;
        std::vector<Plane> planes;
        bool parallaxEnabled;
    };

    [[nodiscard]] State snapshot() const;

    void restore(State state);

    void pushUndo();
 
    std::string _name;
    TileMap _tileMap;
    std::optional<GridPosition> _entry;
    std::optional<GridPosition> _exit;
    std::vector<Mechanism> _mechanisms;
    std::vector<TileLayer> _layers;
    std::vector<MapEntity> _entities;
    std::optional<std::string> _background;
    std::optional<std::string> _skinSet;
    std::vector<TileTextureOverride> _textureOverrides;
    CameraFramingConfig _cameraFraming;
    std::vector<Plane> _planes;
    bool _parallaxEnabled = true;
    std::vector<State> _undoHistory;
    std::vector<State> _redoHistory;
};
 
}  // namespace core