BoardBackdropPlayback.hpp

Go to the documentation of this file.

#pragma once
 
#include "Display.hpp"
#include "SequencePlayback.hpp"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <expected>
#include <filesystem>
#include <optional>
#include <string>
 
namespace monopoly::boarddisplay
{
    inline constexpr std::uint16_t BoardBackdropPriority = 10;
    inline constexpr data::DataTag MainBoardBitmapBaseTag = 0x0000;
    inline constexpr data::DataTag TradeBoardBitmapBaseTag = 0x01AD;
    inline constexpr std::size_t MainBoardBufferCount = 4;
    inline constexpr std::uint32_t BoardCameraCount = 39;
    inline constexpr std::uint32_t UsaCityCount = 11;
    inline constexpr std::uint32_t BoardsPerCity = 39;
    inline constexpr std::uint32_t MainBoardWidth = 800;
    inline constexpr std::uint32_t MainBoardHeight = 450;
    inline constexpr std::uint32_t TradeBoardWidth = 400;
    inline constexpr std::uint32_t TradeBoardHeight = 225;
 
    struct BoardBackdropInputs
    {
        display::Screen2D view{display::Screen2D::Invalid};
        bool game3DOn{true};
        int city{};
        pieces::BoardCameraView camera{pieces::BoardCameraView::TopDownSoccer};
        std::uint32_t tick{};
        std::filesystem::path customRoot;
    };
    struct BoardBackdropBuffer
    {
        data::DataId surface{data::EmptyDataId};
        int cityLoaded{-1};
        int viewLoaded{-1};
        std::uint32_t timeLoaded{};
        std::filesystem::path customRootLoaded;
    };
 
    class BoardBackdropPlayback final
    {
    public:
        [[nodiscard]] std::expected<void, std::string> sync(
            const BoardBackdropInputs& inputs,
            engine::SequencePlayback& playback);
        void reset() noexcept;
 
        [[nodiscard]] data::DataId activeBackdrop() const noexcept
        { return activeBackdrop_; }
        [[nodiscard]] const std::array<BoardBackdropBuffer, MainBoardBufferCount>&
        mainBuffers() const noexcept { return mainBuffers_; }
        [[nodiscard]] std::optional<std::size_t> currentMainBuffer() const noexcept
        { return currentMainBuffer_; }
        [[nodiscard]] data::DataId tradeSurface() const noexcept
        { return tradeSurface_; }
 
    private:
        [[nodiscard]] std::expected<void, std::string> ensureSurfaces(
            engine::SequencePlayback& playback);
        [[nodiscard]] std::expected<data::LegacyBitmapRGBA8, std::string>
        loadBoardBitmap(data::DataId id, engine::SequencePlayback& playback) const;
        [[nodiscard]] std::expected<data::LegacyBitmapRGBA8, std::string>
        loadCustomBoardBitmap(std::uint32_t camera,
            const std::filesystem::path& customRoot,
            engine::SequencePlayback& playback) const;
        [[nodiscard]] std::expected<void, std::string> validateCustomBoardSet(
            const std::filesystem::path& customRoot,
            engine::SequencePlayback& playback) const;
        [[nodiscard]] std::expected<void, std::string> compileImageInto(
            data::DataId surface, const data::LegacyBitmapRGBA8& sourceImage,
            engine::SequencePlayback& playback) const;
        [[nodiscard]] std::expected<void, std::string> compileInto(
            data::DataId surface, data::DataId source,
            engine::SequencePlayback& playback) const;
        [[nodiscard]] std::expected<data::DataId, std::string> selectBackdrop(
            display::Screen2D view, int city, pieces::BoardCameraView camera,
            std::uint32_t tick, const std::filesystem::path& customRoot,
            engine::SequencePlayback& playback);
 
        std::array<BoardBackdropBuffer, MainBoardBufferCount> mainBuffers_{};
        data::DataId tradeSurface_{data::EmptyDataId};
        std::optional<std::size_t> currentMainBuffer_;
        data::DataId activeBackdrop_{data::EmptyDataId};
        display::Screen2D currentView_{display::Screen2D::Invalid};
        std::optional<int> currentCity_;
        std::optional<pieces::BoardCameraView> currentCamera_;
        std::filesystem::path currentCustomRoot_;
        std::filesystem::path validatedCustomRoot_;
        bool surfacesReady_{};
    };
}