Merge pull request #52 from PikalaxALT/seagallop

Decompile seagallop

1 files changed, 460 insertions, 0 deletions

diff --git a/src/seagallop.c b/src/seagallop.c
new file mode 100644
index 000000000..585838607
--- /dev/null
+++ b/src/seagallop.c
@@ -0,0 +1,460 @@
+#include "global.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "palette.h"
+#include "malloc.h"
+#include "scanline_effect.h"
+#include "battle_dome_cards.h"
+#include "window.h"
+#include "text_window.h"
+#include "sound.h"
+#include "task.h"
+#include "help_system.h"
+#include "overworld.h"
+#include "event_data.h"
+#include "field_fadetransition.h"
+#include "field_weather.h"
+#include "constants/songs.h"
+#include "constants/maps.h"
+#include "seagallop.h"
+
+#define TILESTAG_FERRY 3000
+#define TILESTAG_WAKE  4000
+
+#define PALTAG_FERRY_WAKE 3000
+
+static EWRAM_DATA void * sBg3TilemapBuffer = NULL;
+
+static void CB2_SetUpSeaGallopScene(void);
+static void VBlankCB_SeaGallop(void);
+static void MainCB2_SeaGallop(void);
+static void Task_SeaGallop_0(u8 taskId);
+static void Task_SeaGallop_1(u8 taskId);
+static void Task_SeaGallop_2(u8 taskId);
+static void Task_SeaGallop_3(void);
+static void ResetGPU(void);
+static void ResetAllAssets(void);
+static void SetDispcnt(void);
+static void ResetBGPos(void);
+static void LoadFerrySpriteResources(void);
+static void FreeFerrySpriteResources(void);
+static void CreateFerrySprite(void);
+static void SpriteCB_Ferry(struct Sprite * sprite);
+static void CreateWakeSprite(s16 x);
+static void SpriteCB_Wake(struct Sprite * sprite);
+static bool8 GetDirectionOfTravel(void);
+
+static const u16 sWaterTiles[] = INCBIN_U16("data/seagallop/water.4bpp");
+static const u16 sWaterPal[] = INCBIN_U16("data/seagallop/water.gbapal");
+static const u16 sWaterTilemap_WB[] = INCBIN_U16("data/seagallop/wb_tilemap.bin");
+static const u16 sWaterTilemap_EB[] = INCBIN_U16("data/seagallop/eb_tilemap.bin");
+static const u16 sFerrySpriteTiles[] = INCBIN_U16("data/seagallop/ferry_sprite.4bpp");
+static const u16 sFerryAndWakePal[] = INCBIN_U16("data/seagallop/ferry_and_wake.gbapal");
+static const u16 sWakeSpriteTiles[] = INCBIN_U16("data/seagallop/wake.4bpp");
+
+static const struct BgTemplate sBGTemplates[] = {
+    {
+        .bg = 3,
+        .charBaseIndex = 3,
+        .mapBaseIndex = 30,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0x000
+    }
+};
+
+static const s8 sSeaGallopSpawnTable[][4] = {
+                                   // Map                     X     Y
+    [SEAGALLOP_VERMILION_CITY]  = {MAP(VERMILIONCITY),      0x17, 0x20},
+    [SEAGALLOP_ONE_ISLAND]      = {MAP(ONEISLAND_HARBOR),   0x08, 0x05},
+    [SEAGALLOP_TWO_ISLAND]      = {MAP(TWOISLAND_HARBOR),   0x08, 0x05},
+    [SEAGALLOP_THREE_ISLAND]    = {MAP(THREEISLAND_HARBOR), 0x08, 0x05},
+    [SEAGALLOP_FOUR_ISLAND]     = {MAP(FOURISLAND_HARBOR),  0x08, 0x05},
+    [SEAGALLOP_FIVE_ISLAND]     = {MAP(FIVEISLAND_HARBOR),  0x08, 0x05},
+    [SEAGALLOP_SIX_ISLAND]      = {MAP(SIXISLAND_HARBOR),   0x08, 0x05},
+    [SEAGALLOP_SEVEN_ISLAND]    = {MAP(SEVENISLAND_HARBOR), 0x08, 0x05},
+    [SEAGALLOP_CINNABAR_ISLAND] = {MAP(CINNABARISLAND),     0x15, 0x07},
+    [SEAGALLOP_NAVEL_ROCK]      = {MAP(NAVELROCK_HARBOR),   0x08, 0x05},
+    [SEAGALLOP_BIRTH_ISLAND]    = {MAP(BIRTHISLAND_HARBOR), 0x08, 0x05}
+};
+
+// Bitpacked array.  In the commented section, right-most bit is the
+// flag for traveling from (row port) to Vermilion City, and so on.
+// Flags follow these enums:
+
+enum TravelDirections
+{
+    DIRN_WESTBOUND = 0,
+    DIRN_EASTBOUND = 1
+};
+
+static const u16 sTravelDirectionMatrix[] = {
+    [SEAGALLOP_VERMILION_CITY]  = 0x6fe, // 11011111110
+    [SEAGALLOP_ONE_ISLAND]      = 0x6fc, // 11011111100
+    [SEAGALLOP_TWO_ISLAND]      = 0x6f8, // 11011111000
+    [SEAGALLOP_THREE_ISLAND]    = 0x6f0, // 11011110000
+    [SEAGALLOP_FOUR_ISLAND]     = 0x6e0, // 11011100000
+    [SEAGALLOP_FIVE_ISLAND]     = 0x4c0, // 10011000000
+    [SEAGALLOP_SIX_ISLAND]      = 0x400, // 10000000000
+    [SEAGALLOP_SEVEN_ISLAND]    = 0x440, // 10001000000
+    [SEAGALLOP_CINNABAR_ISLAND] = 0x7ff, // 11111111111
+    [SEAGALLOP_NAVEL_ROCK]      = 0x6e0, // 11011100000
+    [SEAGALLOP_BIRTH_ISLAND]    = 0x000  // 00000000000
+};
+
+static const union AnimCmd sSpriteAnims_Ferry_WB[] = {
+    ANIMCMD_FRAME(0, 10),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnims_Ferry_EB[] = {
+    ANIMCMD_FRAME(0, 10, .hFlip = TRUE),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_Ferry[] = {
+    sSpriteAnims_Ferry_WB,
+    sSpriteAnims_Ferry_EB
+};
+
+static const struct OamData sOamData_Ferry = {
+    .size = 3
+};
+
+static const struct SpriteTemplate sFerrySpriteTemplate = {
+    TILESTAG_FERRY,
+    PALTAG_FERRY_WAKE,
+    &sOamData_Ferry,
+    sSpriteAnimTable_Ferry,
+    NULL,
+    gDummySpriteAffineAnimTable,
+    SpriteCB_Ferry
+};
+
+static const struct SpriteSheet sFerryAndWakeSpriteSheets[] = {
+    {(const void *)sWakeSpriteTiles,  sizeof(sWakeSpriteTiles),  TILESTAG_WAKE},
+    {(const void *)sFerrySpriteTiles, sizeof(sFerrySpriteTiles), TILESTAG_FERRY},
+    {}
+};
+
+static const struct SpritePalette sFerryAndWakeSpritePalettes[] = {
+    {sFerryAndWakePal, PALTAG_FERRY_WAKE},
+    {}
+};
+
+static const union AnimCmd sSpriteAnims_Wake_WB[] = {
+    ANIMCMD_FRAME(0x00, 0x14),
+    ANIMCMD_FRAME(0x10, 0x14),
+    ANIMCMD_FRAME(0x20, 0x0f),
+    ANIMCMD_END,
+};
+
+static const union AnimCmd sSpriteAnims_Wake_EB[] = {
+    ANIMCMD_FRAME(0x00, 0x14, .hFlip = TRUE),
+    ANIMCMD_FRAME(0x10, 0x14, .hFlip = TRUE),
+    ANIMCMD_FRAME(0x20, 0x0f, .hFlip = TRUE),
+    ANIMCMD_END,
+};
+
+static const union AnimCmd *const sSpriteAnimTable_Wake[] = {
+    sSpriteAnims_Wake_WB,
+    sSpriteAnims_Wake_EB
+};
+
+static const struct OamData sOamData_Wake = {
+    .size = 2
+};
+
+static const struct SpriteTemplate sWakeSpriteTemplate = {
+    TILESTAG_WAKE,
+    PALTAG_FERRY_WAKE,
+    &sOamData_Wake,
+    sSpriteAnimTable_Wake,
+    NULL,
+    gDummySpriteAffineAnimTable,
+    SpriteCB_Wake
+};
+
+void ScrSpecial_SeaGallopFerry(void)
+{
+    SetVBlankCallback(NULL);
+    sub_812B478();
+    SetMainCallback2(CB2_SetUpSeaGallopScene);
+}
+
+static void CB2_SetUpSeaGallopScene(void)
+{
+    void ** ptr;
+    switch (gMain.state)
+    {
+    case 0:
+        SetVBlankCallback(NULL); // redundant since the setup routine already did this
+        ResetGPU();
+        gMain.state++;
+        break;
+    case 1:
+        ResetAllAssets();
+        gMain.state++;
+        break;
+    case 2:
+        ptr = &sBg3TilemapBuffer;
+        *ptr = AllocZeroed(0x800);
+        ResetBgsAndClearDma3BusyFlags(0);
+        InitBgsFromTemplates(0, sBGTemplates, NELEMS(sBGTemplates));
+        SetBgTilemapBuffer(3, *ptr);
+        ResetBGPos();
+        gMain.state++;
+        break;
+    case 3:
+        LoadBgTiles(3, sWaterTiles, sizeof(sWaterTiles), 0);
+        if (GetDirectionOfTravel() == DIRN_EASTBOUND)
+        {
+            CopyToBgTilemapBufferRect(3, sWaterTilemap_EB, 0, 0, 32, 32);
+        }
+        else
+        {
+            CopyToBgTilemapBufferRect(3, sWaterTilemap_WB, 0, 0, 32, 32);
+        }
+        LoadPalette(sWaterPal, 0x40, 0x20);
+        LoadPalette(stdpal_get(2), 0xF0, 0x20);
+        gMain.state++;
+        break;
+    case 4:
+        if (IsDma3ManagerBusyWithBgCopy() != DIRN_EASTBOUND)
+        {
+            ShowBg(0);
+            ShowBg(3);
+            CopyBgTilemapBufferToVram(3);
+            gMain.state++;
+        }
+        break;
+    case 5:
+        LoadFerrySpriteResources();
+        BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK);
+        gMain.state++;
+        break;
+    case 6:
+        BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
+        gMain.state++;
+        break;
+    case 7:
+        SetDispcnt();
+        SetVBlankCallback(VBlankCB_SeaGallop);
+        PlaySE(SE_NAMINORI);
+        CreateFerrySprite();
+        SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+        SetGpuReg(REG_OFFSET_WININ, 0x3F);
+        SetGpuReg(REG_OFFSET_WINOUT, 0x00);
+        SetGpuReg(REG_OFFSET_WIN0H, 0x00F0);
+        SetGpuReg(REG_OFFSET_WIN0V, 0x1888);
+        CreateTask(Task_SeaGallop_0, 8);
+        SetMainCallback2(MainCB2_SeaGallop);
+        gMain.state = 0;
+        break;
+    }
+}
+
+static void VBlankCB_SeaGallop(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static void MainCB2_SeaGallop(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void Task_SeaGallop_0(u8 taskId)
+{
+    gTasks[taskId].func = Task_SeaGallop_1;
+}
+
+static void ScrollBG(void)
+{
+    if (GetDirectionOfTravel() == DIRN_EASTBOUND)
+    {
+        ChangeBgX(3, 0x600, 1);
+    }
+    else
+    {
+        ChangeBgX(3, 0x600, 2);
+    }
+}
+
+static void Task_SeaGallop_1(u8 taskId)
+{
+    struct Task * task = &gTasks[taskId];
+
+    ScrollBG();
+    if (++task->data[1] == 140)
+    {
+        Overworld_FadeOutMapMusic();
+        sub_807DC18();
+        task->func = Task_SeaGallop_2;
+    }
+}
+
+static void Task_SeaGallop_2(u8 taskId)
+{
+    ScrollBG();
+    if (sub_8055FC4() && !gPaletteFade.active)
+    {
+        Task_SeaGallop_3();
+        sub_812B484();
+        DestroyTask(taskId);
+    }
+}
+
+static void Task_SeaGallop_3(void)
+{
+    const s8 * warpInfo;
+
+    if (gSpecialVar_0x8006 >= NELEMS(sSeaGallopSpawnTable))
+        gSpecialVar_0x8006 = 0;
+
+    warpInfo = sSeaGallopSpawnTable[gSpecialVar_0x8006];
+    Overworld_SetWarpDestination(warpInfo[0], warpInfo[1], -1, warpInfo[2], warpInfo[3]);
+    play_some_sound();
+    PlaySE(SE_KAIDAN);
+    gUnknown_3005020 = sub_807DF64;
+    warp_in();
+    SetMainCallback2(sub_805671C);
+    ResetInitialPlayerAvatarState();
+    FreeFerrySpriteResources();
+    Free(sBg3TilemapBuffer);
+    FreeAllWindowBuffers();
+}
+
+static void ResetGPU(void)
+{
+    void * dest = (void *) VRAM;
+    DmaClearLarge16(3, dest, VRAM_SIZE, 0x1000);
+
+    DmaClear32(3, (void *)OAM, OAM_SIZE);
+    DmaClear16(3, (void *)PLTT, PLTT_SIZE);
+    SetGpuReg(REG_OFFSET_DISPCNT, 0);
+    SetGpuReg(REG_OFFSET_BG0CNT, 0);
+    SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG1CNT, 0);
+    SetGpuReg(REG_OFFSET_BG1HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG1VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG2CNT, 0);
+    SetGpuReg(REG_OFFSET_BG2HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG3CNT, 0);
+    SetGpuReg(REG_OFFSET_BG3HOFS, 0);
+    SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+    SetGpuReg(REG_OFFSET_WIN0H, 0);
+    SetGpuReg(REG_OFFSET_WIN0V, 0);
+    SetGpuReg(REG_OFFSET_WININ, 0);
+    SetGpuReg(REG_OFFSET_WINOUT, 0);
+    SetGpuReg(REG_OFFSET_BLDCNT, 0);
+    SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+    SetGpuReg(REG_OFFSET_BLDY, 0);
+}
+
+static void ResetAllAssets(void)
+{
+    ScanlineEffect_Stop();
+    ResetTasks();
+    ResetSpriteData();
+    dp13_810BB8C();
+    ResetPaletteFade();
+    FreeAllSpritePalettes();
+}
+
+static void SetDispcnt(void)
+{
+    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON | DISPCNT_BG3_ON | DISPCNT_OBJ_ON);
+}
+
+static void ResetBGPos(void)
+{
+    ChangeBgX(0, 0, 0);
+    ChangeBgY(0, 0, 0);
+    ChangeBgX(1, 0, 0);
+    ChangeBgY(1, 0, 0);
+    ChangeBgX(2, 0, 0);
+    ChangeBgY(2, 0, 0);
+    ChangeBgX(3, 0, 0);
+    ChangeBgY(3, 0, 0);
+}
+
+static void LoadFerrySpriteResources(void)
+{
+    LoadSpriteSheets(sFerryAndWakeSpriteSheets);
+    LoadSpritePalettes(sFerryAndWakeSpritePalettes);
+}
+
+static void FreeFerrySpriteResources(void)
+{
+    FreeSpriteTilesByTag(TILESTAG_FERRY);
+    FreeSpriteTilesByTag(TILESTAG_WAKE);
+    FreeSpritePaletteByTag(PALTAG_FERRY_WAKE);
+}
+
+static void CreateFerrySprite(void)
+{
+    u8 spriteId = CreateSprite(&sFerrySpriteTemplate, 0, 92, 0);
+    gSprites[spriteId].data[0] = 48;
+    if (GetDirectionOfTravel() == DIRN_EASTBOUND)
+    {
+        StartSpriteAnim(&gSprites[spriteId], 1);
+    }
+    else
+    {
+        gSprites[spriteId].pos1.x = 240;
+        gSprites[spriteId].data[0] *= -1;
+    }
+}
+
+static void SpriteCB_Ferry(struct Sprite * sprite)
+{
+    sprite->data[1] += sprite->data[0];
+    sprite->pos2.x = sprite->data[1] >> 4;
+    if (sprite->data[2] % 5 == 0)
+    {
+        CreateWakeSprite(sprite->pos1.x + sprite->pos2.x);
+    }
+    sprite->data[2]++;
+    if ((u16)(300 + sprite->pos2.x) > 600)
+    {
+        DestroySprite(sprite);
+    }
+}
+
+static void CreateWakeSprite(s16 x)
+{
+    u8 spriteId = CreateSprite(&sWakeSpriteTemplate, x, 92, 8);
+    if (spriteId != MAX_SPRITES)
+    {
+        if (GetDirectionOfTravel() == DIRN_EASTBOUND)
+        {
+            StartSpriteAnim(&gSprites[spriteId], 1);
+        }
+    }
+}
+
+static void SpriteCB_Wake(struct Sprite * sprite)
+{
+    if (sprite->animEnded)
+    {
+        DestroySprite(sprite);
+    }
+}
+
+static bool8 GetDirectionOfTravel(void)
+{
+    if (gSpecialVar_0x8004 >= NELEMS(sTravelDirectionMatrix))
+    {
+        return DIRN_EASTBOUND;
+    }
+    return (sTravelDirectionMatrix[gSpecialVar_0x8004] >> gSpecialVar_0x8006) & 1;
+}