Level.h

Go to the documentation of this file.

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

 
namespace core {

struct Mechanism {
    GridPosition switchPosition;
    GridPosition doorPosition;
};

struct TileTextureOverride {
    GridPosition position;
    std::string assetName;
};

struct LevelData {
    std::string name;
    TileMap tileMap;
    std::vector<TileLayer> layers;
    std::vector<MapEntity> entities;
    GridPosition entry{};
    GridPosition exit{};
    std::vector<Mechanism> mechanisms;
    std::optional<std::string> background;
    std::optional<std::string> skinSet;
    std::vector<TileTextureOverride> textureOverrides;
    CameraFramingConfig cameraFraming;
    std::vector<Plane> planes;
    bool parallaxEnabled = true;
};
 
class Level {
public:
    explicit Level(LevelData data)
        : _name(std::move(data.name)),
          _tileMap(std::move(data.tileMap)),
          _layers(std::move(data.layers)),
          _entities(std::move(data.entities)),
          _entry(data.entry),
          _exit(data.exit),
          _mechanisms(std::move(data.mechanisms)),
          _background(std::move(data.background)),
          _skinSet(std::move(data.skinSet)),
          _textureOverrides(std::move(data.textureOverrides)),
          _cameraFraming(std::move(data.cameraFraming)),
          _planes(std::move(data.planes)),
          _parallaxEnabled(data.parallaxEnabled) {}

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

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

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

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

    [[nodiscard]] GridPosition entry() const noexcept {
        return _entry;
    }

    [[nodiscard]] GridPosition exit() const noexcept {
        return _exit;
    }

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

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

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

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

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

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

    [[nodiscard]] const CameraFramingConfig& cameraFraming() const noexcept {
        return _cameraFraming;
    }
 
private:
    std::string _name;
    TileMap _tileMap;
    std::vector<TileLayer> _layers;
    std::vector<MapEntity> _entities;
    GridPosition _entry;
    GridPosition _exit;
    std::vector<Mechanism> _mechanisms;
    std::optional<std::string> _background;
    std::optional<std::string> _skinSet;
    std::vector<TileTextureOverride> _textureOverrides;
    CameraFramingConfig _cameraFraming;
    std::vector<Plane> _planes;
    bool _parallaxEnabled = true;
};
 
}  // namespace core