RaceManager.hh

#pragma once
 
#include "game/system/KPadController.hh"
#include "game/system/Random.hh"
#include "game/system/map/MapdataCheckPoint.hh"
#include "game/system/map/MapdataJugemPoint.hh"
 
#include <egg/math/Vector.hh>
 
namespace Kinoko {
 
namespace Host {
 
class Context;
 
} // namespace Host
 
namespace System {
 
class RaceManager : EGG::Disposer {
    friend class Host::Context;
 
public:
    class Player {
    public:
        Player();
        virtual ~Player() {}
 
        void init();
        void calc();
 
        [[nodiscard]] Timer getLapSplit(size_t idx) const;
 
        [[nodiscard]] u16 checkpointId() const {
            return m_checkpointId;
        }
 
        [[nodiscard]] f32 raceCompletion() const {
            return m_raceCompletion;
        }
 
        [[nodiscard]] s8 jugemId() const {
            return m_jugemId;
        }
 
        [[nodiscard]] bool drivingWrongWay() const {
            return m_drivingWrongWay;
        }
 
        [[nodiscard]] const std::array<Timer, 3> &lapTimers() const {
            return m_lapTimers;
        }
 
        [[nodiscard]] const Timer &lapTimer(size_t idx) const {
            ASSERT(idx < m_lapTimers.size());
            return m_lapTimers[idx];
        }
 
        [[nodiscard]] const Timer &raceTimer() const {
            return m_raceTimer;
        }
 
        [[nodiscard]] const KPad *inputs() const {
            return m_inputs;
        }
 
    private:
        MapdataCheckPoint *calcCheckpoint(u16 checkpointId, f32 distanceRatio);
        [[nodiscard]] bool areCheckpointsSubsequent(const MapdataCheckPoint *checkpoint,
                u16 nextCheckpointId) const;
 
        void decrementLap();
        void incrementLap();
        void endRace(const Timer &finishTime);
 
        u16 m_checkpointId;
        f32 m_raceCompletion;
        f32 m_checkpointFactor; 
        f32 m_checkpointStartLapCompletion;
        f32 m_lapCompletion;
        s8 m_jugemId;
        s16 m_currentLap;
        s8 m_maxLap;
        s8 m_maxKcp;
        bool m_drivingWrongWay;
        std::array<Timer, 3> m_lapTimers;
        Timer m_raceTimer;
        const KPad *m_inputs;
    };
 
    enum class Stage {
        Intro = 0,
        Countdown = 1,
        Race = 2,
        FinishLocal = 3,
        FinishGlobal = 4,
    };
 
    void init();
 
    void findKartStartPoint(EGG::Vector3f &pos, EGG::Vector3f &angles);
    void endPlayerRace(u32 idx);
 
    void calc();
 
    [[nodiscard]] bool isStageReached(Stage stage) const {
        return static_cast<std::underlying_type_t<Stage>>(m_stage) >=
                static_cast<std::underlying_type_t<Stage>>(stage);
    }
 
    [[nodiscard]] MapdataJugemPoint *jugemPoint() const;
 
    [[nodiscard]] int getCountdownTimer() const {
        return STAGE_COUNTDOWN_DURATION - m_timer;
    }
 
    [[nodiscard]] Random &random() {
        return m_random;
    }
 
    [[nodiscard]] const Player &player() const {
        return m_player;
    }
 
    [[nodiscard]] const TimerManager &timerManager() const {
        return m_timerManager;
    }
 
    [[nodiscard]] Stage stage() const {
        return m_stage;
    }
 
    [[nodiscard]] u32 timer() const {
        return m_timer;
    }
 
    static RaceManager *CreateInstance();
    static void DestroyInstance();
 
    [[nodiscard]] static RaceManager *Instance() {
        return s_instance;
    }
 
private:
    RaceManager();
    ~RaceManager() override;
 
    Random m_random;
    Player m_player;
    TimerManager m_timerManager;
    Stage m_stage;
    u16 m_introTimer;
    u32 m_timer;
 
    static constexpr u16 STAGE_COUNTDOWN_DURATION = 240;
    static constexpr u32 RNG_SEED = 0x74A1B095;
 
    static RaceManager *s_instance; 
};
 
} // namespace System
 
} // namespace Kinoko