path: root/src/port/Game.cpp

#include <libultraship.h>

#include "Game.h"

#include <Fast3D/gfx_pc.h>
#include "Engine.h"
#include "engine/World.h"
#include "engine/courses/Course.h"
#include "engine/courses/MarioRaceway.h"
#include "engine/courses/ChocoMountain.h"
#include "engine/courses/BowsersCastle.h"
#include "engine/courses/BansheeBoardwalk.h"
#include "engine/courses/YoshiValley.h"
#include "engine/courses/FrappeSnowland.h"
#include "engine/courses/KoopaTroopaBeach.h"
#include "engine/courses/RoyalRaceway.h"
#include "engine/courses/LuigiRaceway.h"
#include "engine/courses/MooMooFarm.h"
#include "engine/courses/ToadsTurnpike.h"
#include "engine/courses/KalimariDesert.h"
#include "engine/courses/SherbetLand.h"
#include "engine/courses/RainbowRoad.h"
#include "engine/courses/WarioStadium.h"
#include "engine/courses/BlockFort.h"
#include "engine/courses/Skyscraper.h"
#include "engine/courses/DoubleDeck.h"
#include "engine/courses/DKJungle.h"
#include "engine/courses/BigDonut.h"
#include "engine/courses/TestCourse.h"

#include "engine/courses/PodiumCeremony.h"

#include "engine/TrainCrossing.h"
#include "engine/vehicles/OBombKart.h"

#include "Smoke.h"

extern "C" {
#include "main.h"
#include "audio/load.h"
#include "audio/external.h"
#include "networking/networking.h"
#include "render_courses.h"
//#include "engine/wasm.h"
}

extern "C" void Graphics_PushFrame(Gfx* data) {
    GameEngine::ProcessGfxCommands(data);
}

extern "C" void Timer_Update();

// Create the world instance
World gWorldInstance;

MarioRaceway* gMarioRaceway;
ChocoMountain* gChocoMountain;
BowsersCastle* gBowsersCastle;
BansheeBoardwalk* gBansheeBoardwalk;
YoshiValley* gYoshiValley;
FrappeSnowland* gFrappeSnowland;
KoopaTroopaBeach* gKoopaTroopaBeach;
RoyalRaceway* gRoyalRaceway;
LuigiRaceway* gLuigiRaceway;
MooMooFarm* gMooMooFarm;
ToadsTurnpike* gToadsTurnpike;
KalimariDesert* gKalimariDesert;
SherbetLand* gSherbetLand;
RainbowRoad* gRainbowRoad;
WarioStadium* gWarioStadium;
BlockFort* gBlockFort;
Skyscraper* gSkyscraper;
DoubleDeck* gDoubleDeck;
DKJungle* gDkJungle;
BigDonut* gBigDonut;
PodiumCeremony* gPodiumCeremony;
TestCourse* gTestCourse;

Cup* gMushroomCup;
Cup* gFlowerCup;
Cup* gStarCup;
Cup* gSpecialCup;
Cup* gBattleCup;

void CustomEngineInit() {

    gMarioRaceway = new MarioRaceway();
    gChocoMountain = new ChocoMountain();
    gBowsersCastle = new BowsersCastle();
    gBansheeBoardwalk = new BansheeBoardwalk();
    gYoshiValley = new YoshiValley();
    gFrappeSnowland = new FrappeSnowland();
    gKoopaTroopaBeach = new KoopaTroopaBeach();
    gRoyalRaceway = new RoyalRaceway();
    gLuigiRaceway = new LuigiRaceway();
    gMooMooFarm = new MooMooFarm();
    gToadsTurnpike = new ToadsTurnpike();
    gKalimariDesert = new KalimariDesert();
    gSherbetLand = new SherbetLand();
    gRainbowRoad = new RainbowRoad();
    gWarioStadium = new WarioStadium();
    gBlockFort = new BlockFort();
    gSkyscraper = new Skyscraper();
    gDoubleDeck = new DoubleDeck();
    gDkJungle = new DKJungle();
    gBigDonut = new BigDonut();
    gPodiumCeremony = new PodiumCeremony();
    gTestCourse = new TestCourse();

    /* Add all courses to the global course list */
    gWorldInstance.AddCourse(gMarioRaceway);
    gWorldInstance.AddCourse(gChocoMountain);
    gWorldInstance.AddCourse(gBowsersCastle);
    gWorldInstance.AddCourse(gBansheeBoardwalk);
    gWorldInstance.AddCourse(gYoshiValley);
    gWorldInstance.AddCourse(gFrappeSnowland);
    gWorldInstance.AddCourse(gKoopaTroopaBeach);
    gWorldInstance.AddCourse(gRoyalRaceway);
    gWorldInstance.AddCourse(gLuigiRaceway);
    gWorldInstance.AddCourse(gMooMooFarm);
    gWorldInstance.AddCourse(gToadsTurnpike);
    gWorldInstance.AddCourse(gKalimariDesert);
    gWorldInstance.AddCourse(gSherbetLand);
    gWorldInstance.AddCourse(gRainbowRoad);
    gWorldInstance.AddCourse(gWarioStadium);
    gWorldInstance.AddCourse(gBlockFort);
    gWorldInstance.AddCourse(gSkyscraper);
    gWorldInstance.AddCourse(gDoubleDeck);
    gWorldInstance.AddCourse(gDkJungle);
    gWorldInstance.AddCourse(gBigDonut);
    gWorldInstance.AddCourse(gTestCourse);

    gMushroomCup = new Cup("mk:mushroom_cup", "mushroom cup", std::vector<Course*>{ gLuigiRaceway, gMooMooFarm, gKoopaTroopaBeach, gKalimariDesert });
    gFlowerCup = new Cup("mk:flower_cup", "flower cup", std::vector<Course*>{ gToadsTurnpike, gFrappeSnowland, gChocoMountain, gMarioRaceway });
    gStarCup = new Cup("mk:star_cup", "star cup", std::vector<Course*>{ gWarioStadium, gSherbetLand, gRoyalRaceway, gBowsersCastle });
    gSpecialCup = new Cup("mk:special_cup", "special cup", std::vector<Course*>{ gDkJungle, gYoshiValley, gBansheeBoardwalk, gRainbowRoad });
    gBattleCup = new Cup("mk:battle_cup", "battle", std::vector<Course*>{ gBigDonut, gBlockFort, gDoubleDeck, gSkyscraper });

    /* Instantiate Cups */
    gWorldInstance.AddCup(gMushroomCup);
    gWorldInstance.AddCup(gFlowerCup);
    gWorldInstance.AddCup(gStarCup);
    gWorldInstance.AddCup(gSpecialCup);
    gWorldInstance.AddCup(gBattleCup);

    /* Set default course; mario raceway */
    gWorldInstance.CurrentCourse = gMarioRaceway;
    gWorldInstance.CurrentCup = gMushroomCup;
    gWorldInstance.CurrentCup->CursorPosition = 3;
    gWorldInstance.CupIndex = 0;
}

extern "C" {

    World* GetWorld(void) {
        return &gWorldInstance;
    }

    u32 WorldNextCup(void) {
        return gWorldInstance.NextCup();
    }

    u32 WorldPreviousCup(void) {
        return gWorldInstance.PreviousCup();
    }

    void CourseManager_SetCup(void* cup) {
        gWorldInstance.SetCup((Cup*)cup);
    }

    void* GetCup() {
        return gWorldInstance.CurrentCup;
    }

    u32 GetCupIndex(void) {
        return gWorldInstance.GetCupIndex();
    }

    const char* GetCupName(void) {
        return gWorldInstance.CurrentCup->Name;
    }

    void LoadCourse() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->Load();
        }
    }

    CProperties* GetCoursePropsA() {
        return (CProperties*) gWorldInstance.GetCourseProps();
    }

    size_t GetCourseIndex() {
        return gWorldInstance.CourseIndex;
    }

    void SetCourse(const char* name) {
        gWorldInstance.SetCourse(name);
    }

    void NextCourse() {
        gWorldInstance.NextCourse();
    }


    void PreviousCourse() {
        gWorldInstance.PreviousCourse();
    }

    void SetCourseById(s32 course) {
        if (course < 0 || course >= gWorldInstance.Courses.size()) {
            return;
        }
        gWorldInstance.CourseIndex = course;
        gWorldInstance.CurrentCourse = gWorldInstance.Courses[gWorldInstance.CourseIndex];
    }

    void CourseManager_SpawnVehicles() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->SpawnVehicles();
        }
    }

    void CourseManager_VehiclesSpawn() {
        for (auto& vehicle : gWorldInstance.Vehicles) {
            if (vehicle) {
                vehicle->Spawn();
            }
        }
    }

    void CourseManager_VehiclesTick() {
        for (auto& vehicle : gWorldInstance.Vehicles) {
            if (vehicle) {
                vehicle->Tick();
            }
        }
    }

    void CourseManager_VehiclesCollision(s32 playerId, Player* player) {
        for (auto& vehicle : gWorldInstance.Vehicles) {
            if (vehicle) {
                vehicle->Collision(playerId, player);
            }
        }
    }

    void CourseManager_SpawnBombKarts() {
        for (auto& kart : gWorldInstance.BombKarts) {
            if (kart) {
                kart->Spawn();
            }
        }
    }

    void CourseManager_TickBombKarts() {
        for (auto& kart : gWorldInstance.BombKarts) {
            if (kart) {
                kart->Tick();
            }
        }
    }

    void CourseManager_DrawBombKarts(s32 cameraId) {
        for (auto& kart : gWorldInstance.BombKarts) {
            if (kart) {
                kart->Draw(cameraId);
            }
        }
    }

    void CourseManager_DrawBattleBombKarts(s32 cameraId) {
        for (auto& kart : gWorldInstance.BombKarts) {
            if (kart) {
                kart->DrawBattle(cameraId);
            }
        }
    }

    void CourseManager_BombKartsWaypoint(s32 cameraId) {
        for (auto& kart : gWorldInstance.BombKarts) {
            if (kart) {
                kart->Waypoint(cameraId);
            }
        }
    }

    void CourseManager_DrawVehicles(s32 playerId) {
        for (auto& vehicle : gWorldInstance.Vehicles) {
            if (vehicle) {
                vehicle->Draw(playerId);
            }
        }
    }

    void CourseManager_ClearVehicles(void) {
        gWorldInstance.ClearVehicles();
        gWorldInstance.Crossings.clear();
        gWorldInstance.BombKarts.clear();
        gWorldInstance.Thwomps.clear();
        gWorldInstance.Penguins.clear();
    }

    void CourseManager_CrossingTrigger() {
        for (auto& crossing : gWorldInstance.Crossings) {
            if (crossing) {
                crossing->CrossingTrigger();
            }
        }
    }

    void CourseManager_AICrossingBehaviour(s32 playerId) {
        for (auto& crossing : gWorldInstance.Crossings) {
            if (crossing) {
                crossing->AICrossingBehaviour(playerId);
            }
        }
    }

    s32 CourseManager_GetCrossingOnTriggered(uintptr_t* crossing) {
        TrainCrossing* ptr = (TrainCrossing*) crossing;
        if (ptr) {
            return ptr->OnTriggered;
        }
    }

    void CourseManager_TrainSmokeTick(void) {
        TrainSmokeTick();
    }

    void CourseManager_TrainSmokeDraw(s32 cameraId) {
        TrainSmokeDraw(cameraId);
    }

    void CourseManager_LoadTextures() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->LoadTextures();
        }
    }

    void CourseManager_RenderCourse(struct UnkStruct_800DC5EC* arg0) {
        if (gWorldInstance.CurrentCourse->IsMod() == false) {
            if ((CVarGetInteger("gFreecam", 0) == true)) {
                // Render credits courses
                func_8029569C();
                return;
            }
        }

        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->Render(arg0);
        }
    }

    void CourseManager_RenderCredits() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->RenderCredits();
        }
    }

    void CourseManager_TickActors() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.TickActors();
        }
    }

    void CourseManager_DrawActor(Camera* camera, struct Actor* actor) {
        AActor* a = gWorldInstance.ConvertActorToAActor(actor);
        if (a->IsMod()) {
            a->Draw(camera);
        }
    }

    void CourseManager_SpawnActors() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->SpawnActors();
        }
    }

    void CourseManager_InitClouds() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->InitClouds();
        }
    }

    void CourseManager_UpdateClouds(s32 arg0, Camera* camera) {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->UpdateClouds(arg0, camera);
        }
    }

    void CourseManager_Waypoints(Player* player, int8_t playerId) {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->Waypoints(player, playerId);
        }
    }

    void CourseManager_SomeCollisionThing(Player* player, Vec3f arg1, Vec3f arg2, Vec3f arg3, f32* arg4, f32* arg5,
                                        f32* arg6, f32* arg7) {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->SomeCollisionThing(player, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
        }
    }

    void CourseManager_MinimapSettings() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->MinimapSettings();
        }
    }

    void CourseManager_InitCourseObjects() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->InitCourseObjects();
        }
    }

    void CourseManager_UpdateCourseObjects() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->UpdateCourseObjects();
        }
    }

    void CourseManager_RenderCourseObjects(s32 cameraId) {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->RenderCourseObjects(cameraId);
        }
    }

    void CourseManager_SomeSounds() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->SomeSounds();
        }
    }

    void CourseManager_CreditsSpawnActors() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->CreditsSpawnActors();
        }
    }

    void CourseManager_WhatDoesThisDo(Player* player, int8_t playerId) {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->WhatDoesThisDo(player, playerId);
        }
    }

    void CourseManager_WhatDoesThisDoAI(Player* player, int8_t playerId) {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->WhatDoesThisDoAI(player, playerId);
        }
    }

    void CourseManager_MinimapFinishlinePosition() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->MinimapFinishlinePosition();
        }
    }

    void CourseManager_SetStaffGhost() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->SetStaffGhost();
        }
    }

    CProperties* CourseManager_GetProps() {
        if (gWorldInstance.CurrentCourse) {
            return (CProperties*) &gWorldInstance.CurrentCourse->Props;
        }
    }

    void CourseManager_ScrollingTextures() {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->ScrollingTextures();
        }
    }

    void CourseManager_DrawWater(struct UnkStruct_800DC5EC* screen, uint16_t pathCounter, uint16_t cameraRot, uint16_t playerDirection) {
        if (gWorldInstance.CurrentCourse) {
            gWorldInstance.CurrentCourse->DrawWater(screen, pathCounter, cameraRot, playerDirection);
        }
    }

    extern Vec3su D_80165834;
    void CourseManager_TickThwomps() {
        // TickLights
        if (gWorldInstance.Thwomps.size()) {
            D_80165834[0] += 0x100;
            D_80165834[1] += 0x200;
        }

        for (auto& thwomp : gWorldInstance.Thwomps) {
            if (thwomp) {
                thwomp->Tick();
            }
        }
    }

    void CourseManager_DrawThwomps(s32 cameraId) {
        for (auto& thwomp : gWorldInstance.Thwomps) {
            if (thwomp) {
                thwomp->Draw(cameraId);
            }
        }
    }

    void CourseManager_TickPenguins(void) {
        for (auto& penguin : gWorldInstance.Penguins) {
            if (penguin) {
                penguin->Tick();
            }
        }
    }

    void CourseManager_DrawPenguins(s32 cameraId) {
        for (auto& penguin : gWorldInstance.Penguins) {
            if (penguin) {
                penguin->Draw(cameraId);
            }
        }
    }

    size_t GetCupCursorPosition() {
        return gWorldInstance.CurrentCup->CursorPosition;
    }

    void SetCupCursorPosition(size_t position) {
        gWorldInstance.CurrentCup->SetCourse(position);
        //gWorldInstance.CurrentCup->CursorPosition = position;
    }

    size_t GetCupSize() {
        return gWorldInstance.CurrentCup->GetSize();
    }

    void SetCourseFromCup() {
        gWorldInstance.CurrentCourse = gWorldInstance.CurrentCup->GetCourse();
    }

    void* GetCourse(void) {
        return gWorldInstance.CurrentCourse;
    }

    void SetCourseByClass(void* course) {
        gWorldInstance.CurrentCourse = (Course*) course;
    }

    struct Actor* m_GetActor(size_t index) {
        if (index < gWorldInstance.Actors.size()) {
            AActor* actor = gWorldInstance.Actors[index];
            return reinterpret_cast<struct Actor*>(reinterpret_cast<char*>(actor) + sizeof(void*));
        } else {
            //throw std::runtime_error("GetActor() index out of bounds");
            return NULL;
        }
    }

    size_t m_FindActorIndex(Actor* actor) {
        // Move the ptr back to look at the vtable.
        // This gets us the proper C++ class instead of just the variables used in C.
        AActor* a = reinterpret_cast<AActor*>((char*)actor - sizeof(void*));
        auto actors = gWorldInstance.Actors;

        auto it = std::find(actors.begin(), actors.end(), static_cast<AActor*>(a));
        if (it != actors.end()) {
            return std::distance(actors.begin(), it);
        }
        printf("FindActorIndex() actor not found\n");
        return 0;
    }

    void m_DeleteActor(size_t index) {
        std::vector<AActor*> actors = gWorldInstance.Actors;
        if (index < actors.size()) {
            actors.erase(actors.begin() + index);
        }
    }
    
    void m_ClearActors(void) {
        gWorldInstance.Actors.clear();
    }

    struct Actor* m_AddBaseActor(void) {
        return (struct Actor*) gWorldInstance.AddBaseActor();
    }

    size_t m_GetActorSize() {
        return gWorldInstance.Actors.size();
    }

    void m_ActorCollision(Player* player, Actor* actor) {
        AActor* a = gWorldInstance.ConvertActorToAActor(actor);

        if (a->IsMod()) {
            a->Collision(player, a);
        }
    }

    void* GetMarioRaceway(void) {
        return gMarioRaceway;
    }

    void* GetLuigiRaceway(void) {
        return gLuigiRaceway;
    }

    void* GetChocoMountain(void) {
        return gChocoMountain;
    }

    void* GetBowsersCastle(void) {
        return gBowsersCastle;
    }

    void* GetBansheeBoardwalk(void) {
        return gBansheeBoardwalk;
    }

    void* GetYoshiValley(void) {
        return gYoshiValley;
    }

    void* GetFrappeSnowland(void) {
        return gFrappeSnowland;
    }

    void* GetKoopaTroopaBeach(void) {
        return gKoopaTroopaBeach;
    }

    void* GetRoyalRaceway(void) {
        return gRoyalRaceway;
    }

    void* GetMooMooFarm(void) {
        return gMooMooFarm;
    }

    void* GetToadsTurnpike(void) {
        return gToadsTurnpike;
    }

    void* GetKalimariDesert(void) {
        return gKalimariDesert;
    }

    void* GetSherbetLand(void) {
        return gSherbetLand;
    }

    void* GetRainbowRoad(void) {
        return gRainbowRoad;
    }

    void* GetWarioStadium(void) {
        return gWarioStadium;
    }

    void* GetBlockFort(void) {
        return gBlockFort;
    }

    void* GetSkyscraper(void) {
        return gSkyscraper;
    }

    void* GetDoubleDeck(void) {
        return gDoubleDeck;
    }

    void* GetDkJungle(void) {
        return gDkJungle;
    }

    void* GetBigDonut(void) {
        return gBigDonut;
    }

    void* GetPodiumCeremony(void) {
        return gPodiumCeremony;
    }

    void* GetMushroomCup(void) {
        return gMushroomCup;
    }

    void* GetFlowerCup(void) {
        return gFlowerCup;
    }

    void* GetStarCup(void) {
        return gStarCup;
    }

    void* GetSpecialCup(void) {
        return gSpecialCup;
    }

    void* GetBattleCup(void) {
        return gBattleCup;
    }
}

void push_frame() {
     GameEngine::StartAudioFrame();
     GameEngine::Instance->StartFrame();
     thread5_iteration();
     GameEngine::EndAudioFrame();
    // thread5_game_loop();
    // Graphics_ThreadUpdate();w
    // Timer_Update();
}

#ifdef _WIN32
int SDL_main(int argc, char** argv) {
#else
#if defined(__cplusplus) && defined(PLATFORM_IOS)
extern "C"
#endif
int main(int argc, char* argv[]) {
#endif
     //load_wasm();
    GameEngine::Create();
    audio_init();
    sound_init();

    CustomEngineInit();
    thread5_game_loop();
    while (WindowIsRunning()) {
        push_frame();
    }
    // GameEngine::Instance->ProcessFrame(push_frame);
    GameEngine::Instance->Destroy();
    return 0;
}