CourseMap.hh

#pragma once
 
#include "game/system/map/MapdataAccessorBase.hh"
#include "game/system/map/MapdataArea.hh"
#include "game/system/map/MapdataCannonPoint.hh"
#include "game/system/map/MapdataCheckPath.hh"
#include "game/system/map/MapdataCheckPoint.hh"
#include "game/system/map/MapdataFileAccessor.hh"
#include "game/system/map/MapdataGeoObj.hh"
#include "game/system/map/MapdataJugemPoint.hh"
#include "game/system/map/MapdataPointInfo.hh"
#include "game/system/map/MapdataStageInfo.hh"
#include "game/system/map/MapdataStartPoint.hh"
 
#include <egg/math/Vector.hh>
 
namespace Kinoko {
 
namespace Host {
 
class Context;
 
} // namespace Host
 
namespace System {
 
template <typename T>
concept MapdataDerived = is_derived_from_template_v<MapdataAccessorBase, T>;
 
class CourseMap : EGG::Disposer {
    friend class Host::Context;
 
public:
    void init();
 
    template <MapdataDerived T>
    [[nodiscard]] T *parseMapdata(u32 sectionName) const {
        const MapSectionHeader *sectionPtr = m_course->findSection(sectionName);
        return sectionPtr ? new T(sectionPtr) : nullptr;
    }
 
    [[nodiscard]] s16 findSector(const EGG::Vector3f &pos, u16 checkpointIdx, f32 &distanceRatio);
    [[nodiscard]] s16 findRecursiveSector(const EGG::Vector3f &pos, s16 depth,
            bool searchBackwardsFirst, MapdataCheckPoint *checkpoint, f32 &completion,
            bool playerIsForwards) const;
 
    [[nodiscard]] u16 getCheckPointEntryOffsetMs(u16 i, const EGG::Vector3f &pos,
            const EGG::Vector3f &prevPos) const;
    [[nodiscard]] f32 getCheckPointEntryOffsetExact(u16 i, const EGG::Vector3f &pos,
            const EGG::Vector3f &prevPos) const;
    [[nodiscard]] s16 getCurrentAreaID(s16 i, const EGG::Vector3f &pos,
            MapdataAreaBase::Type type) const;
 
    [[nodiscard]] MapdataCannonPoint *getCannonPoint(u16 i) const {
        return i < getCannonPointCount() ? m_cannonPoint->get(i) : nullptr;
    }
 
    [[nodiscard]] MapdataCheckPath *getCheckPath(u16 i) const {
        return i < getCheckPathCount() ? m_checkPath->get(i) : nullptr;
    }
 
    [[nodiscard]] MapdataCheckPoint *getCheckPoint(u16 i) const {
        return i < getCheckPointCount() ? m_checkPoint->get(i) : nullptr;
    }
 
    [[nodiscard]] MapdataGeoObj *getGeoObj(u16 i) const {
        return i < getGeoObjCount() ? m_geoObj->get(i) : nullptr;
    }
 
    [[nodiscard]] MapdataAreaBase *getArea(u16 i) const {
        return i < getAreaCount() ? m_area->get(i) : nullptr;
    }
 
    [[nodiscard]] MapdataAreaBase *getAreaSorted(u16 i) const {
        return i < getAreaCount() ? m_area->getSorted(i) : nullptr;
    }
 
    [[nodiscard]] MapdataPointInfo *getPointInfo(u16 i) const {
        return i < getPointInfoCount() ? m_pointInfo->get(i) : nullptr;
    }
 
    [[nodiscard]] MapdataJugemPoint *getJugemPoint(u16 i) const {
        return i < getJugemPointCount() ? m_jugemPoint->get(i) : nullptr;
    }
 
    [[nodiscard]] MapdataStageInfo *getStageInfo() const {
        return getStageInfoCount() != 0 ? m_stageInfo->get(0) : nullptr;
    }
 
    [[nodiscard]] MapdataStartPoint *getStartPoint(u16 i) const {
        return i < getStartPointCount() ? m_startPoint->get(i) : nullptr;
    }
 
    [[nodiscard]] u16 getCannonPointCount() const {
        return m_cannonPoint ? m_cannonPoint->size() : 0;
    }
 
    [[nodiscard]] u16 getCheckPathCount() const {
        return m_checkPath ? m_checkPath->size() : 0;
    }
 
    [[nodiscard]] u16 getCheckPointCount() const {
        return m_checkPoint ? m_checkPoint->size() : 0;
    }
 
    [[nodiscard]] u16 getGeoObjCount() const {
        return m_geoObj ? m_geoObj->size() : 0;
    }
 
    [[nodiscard]] u16 getAreaCount() const {
        return m_area ? m_area->size() : 0;
    }
 
    [[nodiscard]] u16 getPointInfoCount() const {
        return m_pointInfo ? m_pointInfo->size() : 0;
    }
 
    [[nodiscard]] u16 getJugemPointCount() const {
        return m_jugemPoint ? m_jugemPoint->size() : 0;
    }
 
    [[nodiscard]] u16 getStageInfoCount() const {
        return m_stageInfo ? m_stageInfo->size() : 0;
    }
 
    [[nodiscard]] u16 getStartPointCount() const {
        return m_startPoint ? m_startPoint->size() : 0;
    }
 
    [[nodiscard]] u32 version() const {
        return m_course->version();
    }
 
    [[nodiscard]] MapdataCheckPathAccessor *checkPath() const {
        return m_checkPath;
    }
 
    [[nodiscard]] MapdataCheckPointAccessor *checkPoint() const {
        return m_checkPoint;
    }
 
    [[nodiscard]] f32 startTmpAngle() const {
        return m_startTmpAngle;
    }
 
    [[nodiscard]] f32 startTmp0() const {
        return m_startTmp0;
    }
 
    [[nodiscard]] f32 startTmp1() const {
        return m_startTmp1;
    }
 
    [[nodiscard]] f32 startTmp2() const {
        return m_startTmp2;
    }
 
    [[nodiscard]] f32 startTmp3() const {
        return m_startTmp3;
    }
 
    static CourseMap *CreateInstance();
    static void DestroyInstance();
 
    [[nodiscard]] static CourseMap *Instance() {
        return s_instance;
    }
 
private:
    CourseMap();
    ~CourseMap() override;
 
    [[nodiscard]] s16 findSectorBetweenSides(const EGG::Vector3f &pos,
            MapdataCheckPoint *checkpoint, f32 &distanceRatio);
    [[nodiscard]] s16 findSectorOutsideSector(const EGG::Vector3f &pos,
            MapdataCheckPoint *checkpoint, f32 &distanceRatio);
    [[nodiscard]] s16 findSectorRegional(const EGG::Vector3f &pos, MapdataCheckPoint *checkpoint,
            f32 &distanceRatio);
    [[nodiscard]] s16 searchNextCheckpoint(const EGG::Vector3f &pos, s16 depth,
            const MapdataCheckPoint *checkpoint, f32 &completion, bool playerIsForwards,
            bool useCache) const;
    [[nodiscard]] s16 searchPrevCheckpoint(const EGG::Vector3f &pos, s16 depth,
            const MapdataCheckPoint *checkpoint, f32 &completion, bool playerIsForwards,
            bool useCache) const;
    void clearSectorChecked();
 
    MapdataFileAccessor *m_course;
    MapdataStartPointAccessor *m_startPoint;
    MapdataCheckPathAccessor *m_checkPath;
    MapdataCheckPointAccessor *m_checkPoint;
    MapdataPointInfoAccessor *m_pointInfo;
    MapdataGeoObjAccessor *m_geoObj;
    MapdataAreaAccessor *m_area;
    MapdataJugemPointAccessor *m_jugemPoint;
    MapdataCannonPointAccessor *m_cannonPoint;
    MapdataStageInfoAccessor *m_stageInfo;
 
    // TODO: Better names
    f32 m_startTmpAngle;
    f32 m_startTmp0;
    f32 m_startTmp1;
    f32 m_startTmp2;
    f32 m_startTmp3;
 
    static void *LoadFile(const char *filename); 
 
    static CourseMap *s_instance;
};
 
} // namespace System
 
} // namespace Kinoko