From ba176dfe0729e8c8c46a8f79c2f1b6e732ee13c8 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 1 Jan 2018 17:41:34 +0100 Subject: start working on battle transition --- src/battle_transition.c | 287 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 287 insertions(+) create mode 100644 src/battle_transition.c (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c new file mode 100644 index 000000000..386b0dd79 --- /dev/null +++ b/src/battle_transition.c @@ -0,0 +1,287 @@ +#include "global.h" +#include "battle_transition.h" +#include "unk_transition.h" +#include "main.h" +#include "overworld.h" +#include "task.h" +#include "palette.h" +#include "trig.h" +#include "field_effect.h" +#include "random.h" +#include "sprite.h" +#include "sound.h" +#include "constants/songs.h" +#include "constants/trainers.h" +#include "field_camera.h" +#include "unknown_task.h" +#include "malloc.h" + +struct TransitionData +{ + vs8 VBlank_DMA; + u16 WININ; + u16 WINOUT; + u16 field_6; + u16 WIN0V; + u16 field_A; + u16 field_C; + u16 BLDCNT; + u16 BLDALPHA; + u16 BLDY; + s16 field_14; + s16 field_16; + s16 field_18; + s16 field_1A; + s16 field_1C; + s16 field_1E; // unused + s16 field_20; + s16 field_22; // unused + s16 data[11]; +}; + +typedef bool8 (*TransitionState)(struct Task *task); +typedef bool8 (*TransitionSpriteCallback)(struct Sprite *sprite); + +extern void c2_exit_to_overworld_2_switch(void); +extern void sub_80AC3D0(void); + +// this file's functions +void LaunchBattleTransitionTask(u8 transitionId); +void Task_BattleTransitionMain(u8 taskId); +void Phase1Task_TransitionAll(u8 taskId); +void Phase2Task_Transition_Blur(u8 taskId); +void Phase2Task_Transition_Swirl(u8 taskId); +void Phase2Task_Transition_Shuffle(u8 taskId); +void Phase2Task_Transition_BigPokeball(u8 taskId); +void Phase2Task_Transition_PokeballsTrail(u8 taskId); +void Phase2Task_Transition_Clockwise_BlackFade(u8 taskId); +void Phase2Task_Transition_Ripple(u8 taskId); +void Phase2Task_Transition_Wave(u8 taskId); +void Phase2Task_Transition_Slice(u8 taskId); +void Phase2Task_Transition_WhiteFade(u8 taskId); +void Phase2Task_Transition_GridSquares(u8 taskId); +void Phase2Task_Transition_Shards(u8 taskId); +void Phase2Task_Transition_Sydney(u8 taskId); +void Phase2Task_Transition_Phoebe(u8 taskId); +void Phase2Task_Transition_Glacia(u8 taskId); +void Phase2Task_Transition_Drake(u8 taskId); +void Phase2Task_Transition_Wallace(u8 taskId); +void Phase2Task_Transition_Aqua(u8 taskId); +void Phase2Task_Transition_Magma(u8 taskId); +void Phase2Task_Transition_Regice(u8 taskId); +void Phase2Task_Transition_Registeel(u8 taskId); +void Phase2Task_Transition_Regirock(u8 taskId); +void Phase2Task_Transition_Kyogre(u8 taskId); +void Phase2Task_Transition_Groudon(u8 taskId); +void Phase2Task_Transition_Rayquaza(u8 taskId); +void Phase2Task_Transition_25(u8 taskId); +void Phase2Task_Transition_26(u8 taskId); +void Phase2Task_Transition_27(u8 taskId); +void Phase2Task_Transition_28(u8 taskId); +void Phase2Task_Transition_29(u8 taskId); +void Phase2Task_Transition_30(u8 taskId); +void Phase2Task_Transition_31(u8 taskId); +void Phase2Task_Transition_32(u8 taskId); +void Phase2Task_Transition_33(u8 taskId); +bool8 Transition_Phase1(struct Task *task); +bool8 Transition_WaitForPhase1(struct Task *task); +bool8 Transition_Phase2(struct Task *task); +bool8 Transition_WaitForPhase2(struct Task *task); + +// iwram bss vars +IWRAM_DATA u16 gUnknown_03001208; +IWRAM_DATA static u8 sTestingTransitionId; +IWRAM_DATA static u8 sTestingTransitionState; + +// ewram vars +EWRAM_DATA struct TransitionData *sTransitionStructPtr = NULL; + +// const rom data +const u32 sBigPokeball_Tileset[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp"); +const u32 sPokeballTrail_Tileset[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp"); +const u32 sSpriteImage_85B98F0[] = INCBIN_U32("graphics/battle_transitions/pokeball.4bpp"); +const u32 sUnknown_085B9AF0[] = INCBIN_U32("graphics/battle_transitions/elite_four_bg.4bpp"); +const u32 sSpriteImage_85B9CD0[] = INCBIN_U32("graphics/battle_transitions/unused_brendan.4bpp"); +const u32 sSpriteImage_85BA4D0[] = INCBIN_U32("graphics/battle_transitions/unused_lass.4bpp"); +const u32 sShrinkingBoxTileset[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); +const u32 sEvilTeam_Palette[] = INCBIN_U32("graphics/battle_transitions/evil_team.gbapal"); +const u32 sTeamAqua_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_aqua.4bpp.lz"); +const u32 sTeamAqua_Tilemap[] = INCBIN_U32("graphics/battle_transitions/team_aqua.bin.lz"); +const u32 sTeamMagma_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_magma.4bpp.lz"); +const u32 sTeamMagma_Tilemap[] = INCBIN_U32("graphics/battle_transitions/team_magma.bin.lz"); +const u32 gUnknown_085BBC14[] = INCBIN_U32("graphics/battle_transitions/85BBC14.4bpp"); +const u32 gUnknown_085BC2B4[] = INCBIN_U32("graphics/battle_transitions/85BC2B4.gbapal"); +const u32 gUnknown_085BC2D4[] = INCBIN_U32("graphics/battle_transitions/85BC2D4.gbapal"); +const u32 gUnknown_085BC2F4[] = INCBIN_U32("graphics/battle_transitions/85BC2F4.gbapal"); +const u32 gUnknown_085BC314[] = INCBIN_U32("graphics/battle_transitions/85BC314.bin"); +const u32 gUnknown_085BCB14[] = INCBIN_U32("graphics/battle_transitions/85BCB14.bin"); +const u32 gUnknown_085BD314[] = INCBIN_U32("graphics/battle_transitions/85BD314.bin"); +const u32 gUnknown_085BDB14[] = INCBIN_U32("graphics/battle_transitions/85BDB14.gbapal"); +const u32 gUnknown_085BDB34[] = INCBIN_U32("graphics/battle_transitions/kyogre.4bpp.lz"); +const u32 gUnknown_085BE1E8[] = INCBIN_U32("graphics/battle_transitions/kyogre.bin.lz"); +const u32 gUnknown_085BE51C[] = INCBIN_U32("graphics/battle_transitions/groudon.4bpp.lz"); +const u32 gUnknown_085BEA88[] = INCBIN_U32("graphics/battle_transitions/groudon.bin.lz"); +const u32 gUnknown_085BEDA0[] = INCBIN_U32("graphics/battle_transitions/kyogre_pt1.gbapal"); +const u32 gUnknown_085BEEE0[] = INCBIN_U32("graphics/battle_transitions/kyogre_pt2.gbapal"); +const u32 gUnknown_085BF0A0[] = INCBIN_U32("graphics/battle_transitions/groudon_pt1.gbapal"); +const u32 gUnknown_085BF2A0[] = INCBIN_U32("graphics/battle_transitions/groudon_pt2.gbapal"); +const u32 gUnknown_085BF4A0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.gbapal"); +const u32 gUnknown_085BF6A0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.4bpp"); +const u32 gUnknown_085C6BE0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.bin"); +const u32 gUnknown_085C7BE0[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.gbapal"); +const u32 gUnknown_085C7C00[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.4bpp.lz"); +const u32 gUnknown_085C828C[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.bin.lz"); +const u32 gUnknown_085C8578[] = INCBIN_U32("graphics/battle_transitions/frontier_squares_blanktiles.gbapal"); +const u32 gUnknown_085C8598[] = INCBIN_U32("graphics/battle_transitions/frontier_square_1.4bpp.lz"); +const u32 gUnknown_085C86F4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_2.4bpp.lz"); +const u32 gUnknown_085C87F4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_3.4bpp.lz"); +const u32 gUnknown_085C88A4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_4.4bpp.lz"); +const u32 gUnknown_085C8928[] = INCBIN_U32("graphics/battle_transitions/frontier_squares.bin"); + +const TaskFunc sPhase1_Tasks[B_TRANSITION_COUNT] = +{ + [0 ... B_TRANSITION_COUNT - 1] = &Phase1Task_TransitionAll +}; + +const TaskFunc sPhase2_Tasks[B_TRANSITION_COUNT] = +{ + Phase2Task_Transition_Blur, // 0 + Phase2Task_Transition_Swirl, // 1 + Phase2Task_Transition_Shuffle, // 2 + Phase2Task_Transition_BigPokeball, // 3 + Phase2Task_Transition_PokeballsTrail, // 4 + Phase2Task_Transition_Clockwise_BlackFade, // 5 + Phase2Task_Transition_Ripple, // 6 + Phase2Task_Transition_Wave, // 7 + Phase2Task_Transition_Slice, // 8 + Phase2Task_Transition_WhiteFade, // 9 + Phase2Task_Transition_GridSquares, // 10 + Phase2Task_Transition_Shards, // 11 + Phase2Task_Transition_Sydney, // 12 + Phase2Task_Transition_Phoebe, // 13 + Phase2Task_Transition_Glacia, // 14 + Phase2Task_Transition_Drake, // 15 + Phase2Task_Transition_Wallace, // 16 + Phase2Task_Transition_Aqua, // 17 + Phase2Task_Transition_Magma, // 18 + Phase2Task_Transition_Regice, // 19 + Phase2Task_Transition_Registeel, // 20 + Phase2Task_Transition_Regirock, // 21 + Phase2Task_Transition_Kyogre, // 22 + Phase2Task_Transition_Groudon, // 23 + Phase2Task_Transition_Rayquaza, // 24 + Phase2Task_Transition_25, // 25 + Phase2Task_Transition_26, // 26 + Phase2Task_Transition_27, // 27 + Phase2Task_Transition_28, // 28 + Phase2Task_Transition_29, // 29 + Phase2Task_Transition_30, // 30 + Phase2Task_Transition_31, // 31 + Phase2Task_Transition_32, // 32 + Phase2Task_Transition_33, // 33 + Phase2Task_Transition_34, // 34 + Phase2Task_Transition_35, // 35 + Phase2Task_Transition_36, // 36 + Phase2Task_Transition_37, // 37 + Phase2Task_Transition_38, // 38 + Phase2Task_Transition_39, // 39 + Phase2Task_Transition_40, // 40 + Phase2Task_Transition_41, // 41 +}; + +const TransitionState sMainTransitionPhases[] = +{ + &Transition_Phase1, + &Transition_WaitForPhase1, + &Transition_Phase2, + &Transition_WaitForPhase2 +}; + +// code +static void CB2_TestBattleTransition(void) +{ + switch (sTestingTransitionState) + { + case 0: + LaunchBattleTransitionTask(sTestingTransitionId); + sTestingTransitionState++; + break; + case 1: + if (IsBattleTransitionDone()) + { + sTestingTransitionState = 0; + SetMainCallback2(c2_exit_to_overworld_2_switch); + } + break; + } + + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +void TestBattleTransition(u8 transitionId) +{ + sTestingTransitionId = transitionId; + SetMainCallback2(CB2_TestBattleTransition); +} + +void BattleTransition_StartOnField(u8 transitionId) +{ + gMain.callback2 = CB2_OverworldBasic; + LaunchBattleTransitionTask(transitionId); +} + +void BattleTransition_Start(u8 transitionId) +{ + LaunchBattleTransitionTask(transitionId); +} + +#define tState data[0] +#define tTransitionID data[1] +#define tTransitionDone data[15] + +bool8 IsBattleTransitionDone(void) +{ + u8 taskId = FindTaskIdByFunc(Task_BattleTransitionMain); + if (gTasks[taskId].tTransitionDone) + { + DestroyTask(taskId); + FREE_AND_SET_NULL(sTransitionStructPtr); + return TRUE; + } + else + { + return FALSE; + } +} + +void LaunchBattleTransitionTask(u8 transitionId) +{ + u8 taskId = CreateTask(Task_BattleTransitionMain, 2); + gTasks[taskId].tTransitionID = transitionId; + sTransitionStructPtr = AllocZeroed(sizeof(*sTransitionStructPtr)); +} + +void Task_BattleTransitionMain(u8 taskId) +{ + while (sMainTransitionPhases[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Transition_Phase1(struct Task *task) +{ + sub_80AC3D0(); + CpuCopy32(gPlttBufferFaded, gPlttBufferUnfaded, 0x400); + if (sPhase1_Tasks[task->tTransitionID] != NULL) + { + CreateTask(sPhase1_Tasks[task->tTransitionID], 4); + task->tState++; + return FALSE; + } + else + { + task->tState = 2; + return TRUE; + } +} -- cgit v1.2.3 From eb00e8ba4acab773b5bcebbc622563c60abb512d Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 2 Jan 2018 20:38:33 +0100 Subject: more work on battle transition --- src/battle_transition.c | 2072 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 1988 insertions(+), 84 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 386b0dd79..e60a2d91f 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -15,6 +15,8 @@ #include "field_camera.h" #include "unknown_task.h" #include "malloc.h" +#include "gpu_regs.h" +#include "decompress.h" struct TransitionData { @@ -39,54 +41,169 @@ struct TransitionData s16 data[11]; }; -typedef bool8 (*TransitionState)(struct Task *task); +typedef bool8 (*TransitionStateFunc)(struct Task *task); typedef bool8 (*TransitionSpriteCallback)(struct Sprite *sprite); +extern u16 gUnknown_020393A8[]; +extern u16 gUnknown_02038C28[][0x3C0]; + extern void c2_exit_to_overworld_2_switch(void); extern void sub_80AC3D0(void); +extern void dp12_8087EA4(void); // this file's functions void LaunchBattleTransitionTask(u8 transitionId); void Task_BattleTransitionMain(u8 taskId); void Phase1Task_TransitionAll(u8 taskId); -void Phase2Task_Transition_Blur(u8 taskId); -void Phase2Task_Transition_Swirl(u8 taskId); -void Phase2Task_Transition_Shuffle(u8 taskId); -void Phase2Task_Transition_BigPokeball(u8 taskId); -void Phase2Task_Transition_PokeballsTrail(u8 taskId); -void Phase2Task_Transition_Clockwise_BlackFade(u8 taskId); -void Phase2Task_Transition_Ripple(u8 taskId); -void Phase2Task_Transition_Wave(u8 taskId); -void Phase2Task_Transition_Slice(u8 taskId); -void Phase2Task_Transition_WhiteFade(u8 taskId); -void Phase2Task_Transition_GridSquares(u8 taskId); -void Phase2Task_Transition_Shards(u8 taskId); -void Phase2Task_Transition_Sydney(u8 taskId); -void Phase2Task_Transition_Phoebe(u8 taskId); -void Phase2Task_Transition_Glacia(u8 taskId); -void Phase2Task_Transition_Drake(u8 taskId); -void Phase2Task_Transition_Wallace(u8 taskId); -void Phase2Task_Transition_Aqua(u8 taskId); -void Phase2Task_Transition_Magma(u8 taskId); -void Phase2Task_Transition_Regice(u8 taskId); -void Phase2Task_Transition_Registeel(u8 taskId); -void Phase2Task_Transition_Regirock(u8 taskId); -void Phase2Task_Transition_Kyogre(u8 taskId); -void Phase2Task_Transition_Groudon(u8 taskId); -void Phase2Task_Transition_Rayquaza(u8 taskId); -void Phase2Task_Transition_25(u8 taskId); -void Phase2Task_Transition_26(u8 taskId); -void Phase2Task_Transition_27(u8 taskId); -void Phase2Task_Transition_28(u8 taskId); -void Phase2Task_Transition_29(u8 taskId); -void Phase2Task_Transition_30(u8 taskId); -void Phase2Task_Transition_31(u8 taskId); -void Phase2Task_Transition_32(u8 taskId); -void Phase2Task_Transition_33(u8 taskId); +void Phase2Task_Blur(u8 taskId); +void Phase2Task_Swirl(u8 taskId); +void Phase2Task_Shuffle(u8 taskId); +void Phase2Task_BigPokeball(u8 taskId); +void Phase2Task_PokeballsTrail(u8 taskId); +void Phase2Task_Clockwise_BlackFade(u8 taskId); +void Phase2Task_Ripple(u8 taskId); +void Phase2Task_Wave(u8 taskId); +void Phase2Task_Slice(u8 taskId); +void Phase2Task_WhiteFade(u8 taskId); +void Phase2Task_GridSquares(u8 taskId); +void Phase2Task_Shards(u8 taskId); +void Phase2Task_Sydney(u8 taskId); +void Phase2Task_Phoebe(u8 taskId); +void Phase2Task_Glacia(u8 taskId); +void Phase2Task_Drake(u8 taskId); +void Phase2Task_Champion(u8 taskId); +void Phase2Task_Aqua(u8 taskId); +void Phase2Task_Magma(u8 taskId); +void Phase2Task_Regice(u8 taskId); +void Phase2Task_Registeel(u8 taskId); +void Phase2Task_Regirock(u8 taskId); +void Phase2Task_Kyogre(u8 taskId); +void Phase2Task_Groudon(u8 taskId); +void Phase2Task_Rayquaza(u8 taskId); +void Phase2Task_25(u8 taskId); +void Phase2Task_26(u8 taskId); +void Phase2Task_27(u8 taskId); +void Phase2Task_28(u8 taskId); +void Phase2Task_29(u8 taskId); +void Phase2Task_30(u8 taskId); +void Phase2Task_31(u8 taskId); +void Phase2Task_32(u8 taskId); +void Phase2Task_33(u8 taskId); +void VBlankCB_BattleTransition(void); +void VBlankCB_Phase2_Swirl(void); +void HBlankCB_Phase2_Swirl(void); +void VBlankCB_Phase2_Shuffle(void); +void HBlankCB_Phase2_Shuffle(void); +void VBlankCB0_Phase2_BigPokeball(void); +void VBlankCB1_Phase2_BigPokeball(void); +void VBlankCB_Phase2_Clockwise_BlackFade(void); +void VBlankCB_Phase2_Ripple(void); +void HBlankCB_Phase2_Ripple(void); +void VBlankCB_Phase2_Wave(void); +void VBlankCB_Phase2_Slice(void); +void HBlankCB_Phase2_Slice(void); +void VBlankCB0_Phase2_WhiteFade(void); +void VBlankCB1_Phase2_WhiteFade(void); +void HBlankCB_Phase2_WhiteFade(void); +void VBlankCB_Phase2_Shards(void); +bool8 Phase2_Blur_Func1(struct Task *task); +bool8 Phase2_Blur_Func2(struct Task *task); +bool8 Phase2_Blur_Func3(struct Task *task); +bool8 Phase2_Swirl_Func1(struct Task *task); +bool8 Phase2_Swirl_Func2(struct Task *task); +bool8 Phase2_Shuffle_Func1(struct Task *task); +bool8 Phase2_Shuffle_Func2(struct Task *task); +bool8 Phase2_Aqua_Func1(struct Task *task); +bool8 Phase2_Aqua_Func2(struct Task *task); +bool8 Phase2_Magma_Func1(struct Task *task); +bool8 Phase2_Magma_Func2(struct Task *task); +bool8 Phase2_FramesCountdown(struct Task *task); +bool8 Phase2_Regi_Func1(struct Task *task); +bool8 Phase2_Regice_Func2(struct Task *task); +bool8 Phase2_Registeel_Func2(struct Task *task); +bool8 Phase2_Regirock_Func2(struct Task *task); +bool8 Phase2_WeatherTrio_Func1(struct Task *task); +bool8 Phase2_WaitPaletteFade(struct Task *task); +bool8 Phase2_Kyogre_Func3(struct Task *task); +bool8 Phase2_Kyogre_Func4(struct Task *task); +bool8 Phase2_Kyogre_Func5(struct Task *task); +bool8 Phase2_WeatherDuo_Func6(struct Task *task); +bool8 Phase2_WeatherDuo_Func7(struct Task *task); +bool8 Phase2_BigPokeball_Func1(struct Task *task); +bool8 Phase2_BigPokeball_Func2(struct Task *task); +bool8 Phase2_BigPokeball_Func3(struct Task *task); +bool8 Phase2_BigPokeball_Func4(struct Task *task); +bool8 Phase2_BigPokeball_Func5(struct Task *task); +bool8 Phase2_BigPokeball_Func6(struct Task *task); +bool8 Phase2_PokeballsTrail_Func1(struct Task *task); +bool8 Phase2_PokeballsTrail_Func2(struct Task *task); +bool8 Phase2_PokeballsTrail_Func3(struct Task *task); +bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task); +bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task); +bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task); +bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task); +bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task); +bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task); +bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task); +bool8 Phase2_Ripple_Func1(struct Task *task); +bool8 Phase2_Ripple_Func2(struct Task *task); +bool8 Phase2_Wave_Func1(struct Task *task); +bool8 Phase2_Wave_Func2(struct Task *task); +bool8 Phase2_Wave_Func3(struct Task *task); +bool8 Phase2_Slice_Func1(struct Task *task); +bool8 Phase2_Slice_Func2(struct Task *task); +bool8 Phase2_Slice_Func3(struct Task *task); +bool8 Phase2_WhiteFade_Func1(struct Task *task); +bool8 Phase2_WhiteFade_Func2(struct Task *task); +bool8 Phase2_WhiteFade_Func3(struct Task *task); +bool8 Phase2_WhiteFade_Func4(struct Task *task); +bool8 Phase2_WhiteFade_Func5(struct Task *task); +bool8 Phase2_GridSquares_Func1(struct Task *task); +bool8 Phase2_GridSquares_Func2(struct Task *task); +bool8 Phase2_GridSquares_Func3(struct Task *task); +bool8 Phase2_Shards_Func1(struct Task *task); +bool8 Phase2_Shards_Func2(struct Task *task); +bool8 Phase2_Shards_Func3(struct Task *task); +bool8 Phase2_Shards_Func4(struct Task *task); +bool8 Phase2_Shards_Func5(struct Task *task); +bool8 Phase2_Mugshot_Func1(struct Task *task); +bool8 Phase2_Mugshot_Func2(struct Task *task); +bool8 Phase2_Mugshot_Func3(struct Task *task); +bool8 Phase2_Mugshot_Func4(struct Task *task); +bool8 Phase2_Mugshot_Func5(struct Task *task); +bool8 Phase2_Mugshot_Func6(struct Task *task); +bool8 Phase2_Mugshot_Func7(struct Task *task); +bool8 Phase2_Mugshot_Func8(struct Task *task); +bool8 Phase2_Mugshot_Func9(struct Task *task); +bool8 Phase2_Mugshot_Func10(struct Task *task); +void Phase2Task_MugShotTransition(u8 taskId); +void Mugshots_CreateOpponentPlayerSprites(struct Task *task); +void VBlankCB0_Phase2_Mugshots(void); +void VBlankCB1_Phase2_Mugshots(void); +void HBlankCB_Phase2_Mugshots(void); bool8 Transition_Phase1(struct Task *task); bool8 Transition_WaitForPhase1(struct Task *task); bool8 Transition_Phase2(struct Task *task); bool8 Transition_WaitForPhase2(struct Task *task); +void sub_8149F08(void); +void sub_8149F84(void); +void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); +void sub_814A014(u16 *a0, s16 a1, s16 a2, s16 a3); +void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize); +void sub_8149F58(u16 **a0, u16 **a1); +void sub_814A1AC(s16 *a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); +bool8 sub_814A228(s16 *a0, bool8 a1, bool8 a2); +void sub_8148484(s16 spriteId, s16 value); +void sub_814849C(s16 spriteId); +s16 sub_81484B8(s16 spriteId); +bool8 IsPhase1Done(void); +void sub_814713C(struct Sprite *sprite); +void sub_8148380(struct Sprite *sprite); +bool8 sub_81483A8(struct Sprite *sprite); +bool8 sub_81483AC(struct Sprite *sprite); +bool8 sub_81483F8(struct Sprite *sprite); +bool8 sub_814842C(struct Sprite *sprite); +bool8 sub_8148458(struct Sprite *sprite); // iwram bss vars IWRAM_DATA u16 gUnknown_03001208; @@ -116,16 +233,16 @@ const u32 gUnknown_085BC2F4[] = INCBIN_U32("graphics/battle_transitions/85BC2F4. const u32 gUnknown_085BC314[] = INCBIN_U32("graphics/battle_transitions/85BC314.bin"); const u32 gUnknown_085BCB14[] = INCBIN_U32("graphics/battle_transitions/85BCB14.bin"); const u32 gUnknown_085BD314[] = INCBIN_U32("graphics/battle_transitions/85BD314.bin"); -const u32 gUnknown_085BDB14[] = INCBIN_U32("graphics/battle_transitions/85BDB14.gbapal"); +const u16 gUnknown_085BDB14[] = INCBIN_U16("graphics/battle_transitions/85BDB14.gbapal"); const u32 gUnknown_085BDB34[] = INCBIN_U32("graphics/battle_transitions/kyogre.4bpp.lz"); const u32 gUnknown_085BE1E8[] = INCBIN_U32("graphics/battle_transitions/kyogre.bin.lz"); const u32 gUnknown_085BE51C[] = INCBIN_U32("graphics/battle_transitions/groudon.4bpp.lz"); const u32 gUnknown_085BEA88[] = INCBIN_U32("graphics/battle_transitions/groudon.bin.lz"); -const u32 gUnknown_085BEDA0[] = INCBIN_U32("graphics/battle_transitions/kyogre_pt1.gbapal"); -const u32 gUnknown_085BEEE0[] = INCBIN_U32("graphics/battle_transitions/kyogre_pt2.gbapal"); -const u32 gUnknown_085BF0A0[] = INCBIN_U32("graphics/battle_transitions/groudon_pt1.gbapal"); -const u32 gUnknown_085BF2A0[] = INCBIN_U32("graphics/battle_transitions/groudon_pt2.gbapal"); -const u32 gUnknown_085BF4A0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.gbapal"); +const u16 gUnknown_085BEDA0[] = INCBIN_U16("graphics/battle_transitions/kyogre_pt1.gbapal"); +const u16 gUnknown_085BEEE0[] = INCBIN_U16("graphics/battle_transitions/kyogre_pt2.gbapal"); +const u16 gUnknown_085BF0A0[] = INCBIN_U16("graphics/battle_transitions/groudon_pt1.gbapal"); +const u16 gUnknown_085BF2A0[] = INCBIN_U16("graphics/battle_transitions/groudon_pt2.gbapal"); +const u16 gUnknown_085BF4A0[] = INCBIN_U16("graphics/battle_transitions/rayquaza.gbapal"); const u32 gUnknown_085BF6A0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.4bpp"); const u32 gUnknown_085C6BE0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.bin"); const u32 gUnknown_085C7BE0[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.gbapal"); @@ -145,51 +262,51 @@ const TaskFunc sPhase1_Tasks[B_TRANSITION_COUNT] = const TaskFunc sPhase2_Tasks[B_TRANSITION_COUNT] = { - Phase2Task_Transition_Blur, // 0 - Phase2Task_Transition_Swirl, // 1 - Phase2Task_Transition_Shuffle, // 2 - Phase2Task_Transition_BigPokeball, // 3 - Phase2Task_Transition_PokeballsTrail, // 4 - Phase2Task_Transition_Clockwise_BlackFade, // 5 - Phase2Task_Transition_Ripple, // 6 - Phase2Task_Transition_Wave, // 7 - Phase2Task_Transition_Slice, // 8 - Phase2Task_Transition_WhiteFade, // 9 - Phase2Task_Transition_GridSquares, // 10 - Phase2Task_Transition_Shards, // 11 - Phase2Task_Transition_Sydney, // 12 - Phase2Task_Transition_Phoebe, // 13 - Phase2Task_Transition_Glacia, // 14 - Phase2Task_Transition_Drake, // 15 - Phase2Task_Transition_Wallace, // 16 - Phase2Task_Transition_Aqua, // 17 - Phase2Task_Transition_Magma, // 18 - Phase2Task_Transition_Regice, // 19 - Phase2Task_Transition_Registeel, // 20 - Phase2Task_Transition_Regirock, // 21 - Phase2Task_Transition_Kyogre, // 22 - Phase2Task_Transition_Groudon, // 23 - Phase2Task_Transition_Rayquaza, // 24 - Phase2Task_Transition_25, // 25 - Phase2Task_Transition_26, // 26 - Phase2Task_Transition_27, // 27 - Phase2Task_Transition_28, // 28 - Phase2Task_Transition_29, // 29 - Phase2Task_Transition_30, // 30 - Phase2Task_Transition_31, // 31 - Phase2Task_Transition_32, // 32 - Phase2Task_Transition_33, // 33 - Phase2Task_Transition_34, // 34 - Phase2Task_Transition_35, // 35 - Phase2Task_Transition_36, // 36 - Phase2Task_Transition_37, // 37 - Phase2Task_Transition_38, // 38 - Phase2Task_Transition_39, // 39 - Phase2Task_Transition_40, // 40 - Phase2Task_Transition_41, // 41 + Phase2Task_Blur, // 0 + Phase2Task_Swirl, // 1 + Phase2Task_Shuffle, // 2 + Phase2Task_BigPokeball, // 3 + Phase2Task_PokeballsTrail, // 4 + Phase2Task_Clockwise_BlackFade, // 5 + Phase2Task_Ripple, // 6 + Phase2Task_Wave, // 7 + Phase2Task_Slice, // 8 + Phase2Task_WhiteFade, // 9 + Phase2Task_GridSquares, // 10 + Phase2Task_Shards, // 11 + Phase2Task_Sydney, // 12 + Phase2Task_Phoebe, // 13 + Phase2Task_Glacia, // 14 + Phase2Task_Drake, // 15 + Phase2Task_Champion, // 16 + Phase2Task_Aqua, // 17 + Phase2Task_Magma, // 18 + Phase2Task_Regice, // 19 + Phase2Task_Registeel, // 20 + Phase2Task_Regirock, // 21 + Phase2Task_Kyogre, // 22 + Phase2Task_Groudon, // 23 + Phase2Task_Rayquaza, // 24 + Phase2Task_25, // 25 + Phase2Task_26, // 26 + Phase2Task_27, // 27 + Phase2Task_28, // 28 + Phase2Task_29, // 29 + Phase2Task_30, // 30 + Phase2Task_31, // 31 + Phase2Task_32, // 32 + Phase2Task_33, // 33 + Phase2Task_34, // 34 + Phase2Task_35, // 35 + Phase2Task_36, // 36 + Phase2Task_37, // 37 + Phase2Task_38, // 38 + Phase2Task_39, // 39 + Phase2Task_40, // 40 + Phase2Task_41, // 41 }; -const TransitionState sMainTransitionPhases[] = +const TransitionStateFunc sMainTransitionPhases[] = { &Transition_Phase1, &Transition_WaitForPhase1, @@ -197,6 +314,201 @@ const TransitionState sMainTransitionPhases[] = &Transition_WaitForPhase2 }; +const TransitionStateFunc sPhase2_Blur_Funcs[] = +{ + Phase2_Blur_Func1, + Phase2_Blur_Func2, + Phase2_Blur_Func3 +}; + +const TransitionStateFunc sPhase2_Swirl_Funcs[] = +{ + Phase2_Swirl_Func1, + Phase2_Swirl_Func2, +}; + +const TransitionStateFunc sPhase2_Shuffle_Funcs[] = +{ + Phase2_Shuffle_Func1, + Phase2_Shuffle_Func2, +}; + +const TransitionStateFunc sPhase2_Aqua_Funcs[] = +{ + Phase2_Aqua_Func1, + Phase2_Aqua_Func2, + Phase2_BigPokeball_Func3, + Phase2_BigPokeball_Func4, + Phase2_BigPokeball_Func5, + Phase2_FramesCountdown, + Phase2_BigPokeball_Func6 +}; + +const TransitionStateFunc sPhase2_Magma_Funcs[] = +{ + Phase2_Magma_Func1, + Phase2_Magma_Func2, + Phase2_BigPokeball_Func3, + Phase2_BigPokeball_Func4, + Phase2_BigPokeball_Func5, + Phase2_FramesCountdown, + Phase2_BigPokeball_Func6 +}; + +const TransitionStateFunc sPhase2_BigPokeball_Funcs[] = +{ + Phase2_BigPokeball_Func1, + Phase2_BigPokeball_Func2, + Phase2_BigPokeball_Func3, + Phase2_BigPokeball_Func4, + Phase2_BigPokeball_Func5, + Phase2_BigPokeball_Func6 +}; + +const TransitionStateFunc sPhase2_Regice_Funcs[] = +{ + Phase2_Regi_Func1, + Phase2_Regice_Func2, + Phase2_BigPokeball_Func3, + Phase2_BigPokeball_Func4, + Phase2_BigPokeball_Func5, + Phase2_BigPokeball_Func6 +}; + +const TransitionStateFunc sPhase2_Registeel_Funcs[] = +{ + Phase2_Regi_Func1, + Phase2_Registeel_Func2, + Phase2_BigPokeball_Func3, + Phase2_BigPokeball_Func4, + Phase2_BigPokeball_Func5, + Phase2_BigPokeball_Func6 +}; + +const TransitionStateFunc sPhase2_Regirock_Funcs[] = +{ + Phase2_Regi_Func1, + Phase2_Regirock_Func2, + Phase2_BigPokeball_Func3, + Phase2_BigPokeball_Func4, + Phase2_BigPokeball_Func5, + Phase2_BigPokeball_Func6 +}; + +const TransitionStateFunc sPhase2_Kyogre_Funcs[] = +{ + Phase2_WeatherTrio_Func1, + Phase2_WaitPaletteFade, + Phase2_Kyogre_Func3, + Phase2_Kyogre_Func4, + Phase2_Kyogre_Func5, + Phase2_FramesCountdown, + Phase2_WeatherDuo_Func6, + Phase2_WeatherDuo_Func7 +}; + +const TransitionStateFunc sPhase2_PokeballsTrail_Funcs[] = +{ + Phase2_PokeballsTrail_Func1, + Phase2_PokeballsTrail_Func2, + Phase2_PokeballsTrail_Func3 +}; + +const s16 sUnknown_085C8B88[2] = {-16, 256}; +const s16 sUnknown_085C8B8C[5] = {0, 32, 64, 18, 48}; +const s16 sUnknown_085C8B96[2] = {8, -8}; + +const TransitionStateFunc sPhase2_Clockwise_BlackFade_Funcs[] = +{ + Phase2_Clockwise_BlackFade_Func1, + Phase2_Clockwise_BlackFade_Func2, + Phase2_Clockwise_BlackFade_Func3, + Phase2_Clockwise_BlackFade_Func4, + Phase2_Clockwise_BlackFade_Func5, + Phase2_Clockwise_BlackFade_Func6, + Phase2_Clockwise_BlackFade_Func7 +}; + +const TransitionStateFunc sPhase2_Ripple_Funcs[] = +{ + Phase2_Ripple_Func1, + Phase2_Ripple_Func2 +}; + +const TransitionStateFunc sPhase2_Wave_Funcs[] = +{ + Phase2_Wave_Func1, + Phase2_Wave_Func2, + Phase2_Wave_Func3 +}; + +const TransitionStateFunc sPhase2_Mugshot_Funcs[] = +{ + Phase2_Mugshot_Func1, + Phase2_Mugshot_Func2, + Phase2_Mugshot_Func3, + Phase2_Mugshot_Func4, + Phase2_Mugshot_Func5, + Phase2_Mugshot_Func6, + Phase2_Mugshot_Func7, + Phase2_Mugshot_Func8, + Phase2_Mugshot_Func9, + Phase2_Mugshot_Func10 +}; + +const u8 sMugshotsTrainerPicIDsTable[MUGSHOTS_COUNT] = +{ + TRAINER_PIC_ELITE_FOUR_SIDNEY, + TRAINER_PIC_ELITE_FOUR_PHOEBE, + TRAINER_PIC_ELITE_FOUR_GLACIA, + TRAINER_PIC_ELITE_FOUR_DRAKE, + TRAINER_PIC_CHAMPION_WALLACE +}; +const s16 sMugshotsOpponentRotationScales[MUGSHOTS_COUNT][2] = +{ + {0x200, 0x200}, + {0x200, 0x200}, + {0x1B0, 0x1B0}, + {0x1A0, 0x1A0}, + {0x188, 0x188}, +}; +const s16 sMugshotsOpponentCoords[MUGSHOTS_COUNT][2] = +{ + {0, 0}, + {0, 0}, + {-4, 4}, + {0, 5}, + {-8, 7}, +}; + +const TransitionSpriteCallback sUnknown_085C8C24[] = +{ + sub_81483A8, + sub_81483AC, + sub_81483F8, + sub_814842C, + sub_81483A8, + sub_8148458, + sub_81483A8 +}; + +const s16 sUnknown_085C8C40[2] = {12, -12}; +const s16 sUnknown_085C8C44[2] = {-1, 1}; + +const TransitionStateFunc sPhase2_Slice_Funcs[] = +{ + Phase2_Slice_Func1, + Phase2_Slice_Func2, + Phase2_Slice_Func3 +}; + +extern const u16 gFieldEffectObjectPalette10[]; +extern const u16 sBigPokeball_Tilemap[]; +extern const u16 sMugshotsTilemap[]; +extern const struct SpriteTemplate gUnknown_085C8E68; +extern const u16 *const sOpponentMugshotsPals[MUGSHOTS_COUNT]; +extern const u16 *const sPlayerMugshotsPals[2]; + // code static void CB2_TestBattleTransition(void) { @@ -238,6 +550,7 @@ void BattleTransition_Start(u8 transitionId) LaunchBattleTransitionTask(transitionId); } +// main task that launches sub-tasks for phase1 and phase2 #define tState data[0] #define tTransitionID data[1] #define tTransitionDone data[15] @@ -285,3 +598,1594 @@ bool8 Transition_Phase1(struct Task *task) return TRUE; } } + +bool8 Transition_WaitForPhase1(struct Task *task) +{ + if (FindTaskIdByFunc(sPhase1_Tasks[task->tTransitionID]) == 0xFF) + { + task->tState++; + return TRUE; + } + else + { + return FALSE; + } +} + +bool8 Transition_Phase2(struct Task *task) +{ + CreateTask(sPhase2_Tasks[task->tTransitionID], 0); + task->tState++; + return FALSE; +} + +bool8 Transition_WaitForPhase2(struct Task *task) +{ + task->tTransitionDone = FALSE; + if (FindTaskIdByFunc(sPhase2_Tasks[task->tTransitionID]) == 0xFF) + task->tTransitionDone = TRUE; + return FALSE; +} + +#undef tState +#undef tTransitionID +#undef tTransitionDone + +// sub-task for phase1 +#define tState data[0] + +void Phase1Task_TransitionAll(u8 taskId) +{ + if (gTasks[taskId].tState == 0) + { + gTasks[taskId].tState++; + CreatePhase1Task(0, 0, 3, 2, 2); // creates a sub-task for this sub-task + } + else if (IsPhase1Done()) + { + DestroyTask(taskId); + } +} + +#undef tState + +// sub-task for phase2 +#define tState data[0] +#define tFrames data[8] +#define tOpponentSpriteId data[13] +#define tPlayerSpriteId data[14] +#define tMugshotId data[15] + +void Phase2Task_Blur(u8 taskId) +{ + while (sPhase2_Blur_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Blur_Func1(struct Task *task) +{ + SetGpuReg(REG_OFFSET_MOSAIC, 0); + SetGpuRegBits(REG_OFFSET_BG1CNT, BGCNT_MOSAIC); + SetGpuRegBits(REG_OFFSET_BG2CNT, BGCNT_MOSAIC); + SetGpuRegBits(REG_OFFSET_BG3CNT, BGCNT_MOSAIC); + task->tState++; + return TRUE; +} + +bool8 Phase2_Blur_Func2(struct Task *task) +{ + if (task->data[1] != 0) + { + task->data[1]--; + } + else + { + task->data[1] = 4; + if (++task->data[2] == 10) + BeginNormalPaletteFade(-1, -1, 0, 0x10, 0); + SetGpuReg(REG_OFFSET_MOSAIC, (task->data[2] & 15) * 17); + if (task->data[2] > 14) + task->tState++; + } + return FALSE; +} + +bool8 Phase2_Blur_Func3(struct Task *task) +{ + if (!gPaletteFade.active) + { + u8 taskId = FindTaskIdByFunc(Phase2Task_Blur); + DestroyTask(taskId); + } + return FALSE; +} + +void Phase2Task_Swirl(u8 taskId) +{ + while (sPhase2_Swirl_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Swirl_Func1(struct Task *task) +{ + sub_8149F08(); + dp12_8087EA4(); + BeginNormalPaletteFade(-1, 4, 0, 0x10, 0); + sub_8149F98(gUnknown_020393A8, sTransitionStructPtr->field_14, 0, 2, 0, 160); + + SetVBlankCallback(VBlankCB_Phase2_Swirl); + SetHBlankCallback(HBlankCB_Phase2_Swirl); + + EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_HBLANK); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Swirl_Func2(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + task->data[1] += 4; + task->data[2] += 8; + + sub_8149F98(gUnknown_02038C28[0], sTransitionStructPtr->field_14, task->data[1], 2, task->data[2], 160); + + if (!gPaletteFade.active) + { + u8 taskId = FindTaskIdByFunc(Phase2Task_Swirl); + DestroyTask(taskId); + } + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +void VBlankCB_Phase2_Swirl(void) +{ + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); +} + +void HBlankCB_Phase2_Swirl(void) +{ + u16 var = gUnknown_02038C28[1][REG_VCOUNT]; + REG_BG1HOFS = var; + REG_BG2HOFS = var; + REG_BG3HOFS = var; +} + +void Phase2Task_Shuffle(u8 taskId) +{ + while (sPhase2_Shuffle_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Shuffle_Func1(struct Task *task) +{ + sub_8149F08(); + dp12_8087EA4(); + + BeginNormalPaletteFade(-1, 4, 0, 0x10, 0); + memset(gUnknown_020393A8, sTransitionStructPtr->field_16, 0x140); + + SetVBlankCallback(VBlankCB_Phase2_Shuffle); + SetHBlankCallback(HBlankCB_Phase2_Shuffle); + + EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_HBLANK); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Shuffle_Func2(struct Task *task) +{ + u8 i; + u16 r3, r4; + + sTransitionStructPtr->VBlank_DMA = 0; + r4 = task->data[1]; + r3 = task->data[2] >> 8; + task->data[1] += 4224; + task->data[2] += 384; + + for (i = 0; i < 160; i++, r4 += 4224) + { + u16 var = r4 / 256; + gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3); + } + + if (!gPaletteFade.active) + DestroyTask(FindTaskIdByFunc(Phase2Task_Shuffle)); + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +void VBlankCB_Phase2_Shuffle(void) +{ + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); +} + +void HBlankCB_Phase2_Shuffle(void) +{ + u16 var = gUnknown_02038C28[1][REG_VCOUNT]; + REG_BG1VOFS = var; + REG_BG2VOFS = var; + REG_BG3VOFS = var; +} + +void Phase2Task_BigPokeball(u8 taskId) +{ + while (sPhase2_BigPokeball_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_Aqua(u8 taskId) +{ + while (sPhase2_Aqua_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_Magma(u8 taskId) +{ + while (sPhase2_Magma_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_Regice(u8 taskId) +{ + while (sPhase2_Regice_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_Registeel(u8 taskId) +{ + while (sPhase2_Registeel_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_Regirock(u8 taskId) +{ + while (sPhase2_Regirock_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_Kyogre(u8 taskId) +{ + while (sPhase2_Kyogre_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void sub_814669C(struct Task *task) +{ + s32 i; + + sub_8149F08(); + dp12_8087EA4(); + + task->data[1] = 16; + task->data[2] = 0; + task->data[4] = 0; + task->data[5] = 0x4000; + sTransitionStructPtr->WININ = 63; + sTransitionStructPtr->WINOUT = 0; + sTransitionStructPtr->field_6 = 240; + sTransitionStructPtr->WIN0V = 160; + sTransitionStructPtr->BLDCNT = 0x3F41; + sTransitionStructPtr->BLDALPHA = (task->data[1] << 8) | (task->data[2]); + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[1][i] = 240; + } + + SetVBlankCallback(VBlankCB0_Phase2_BigPokeball); +} + +bool8 Phase2_Aqua_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + task->tFrames = 60; + sub_814669C(task); + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + LZ77UnCompVram(sTeamAqua_Tileset, dst2); + LoadPalette(sEvilTeam_Palette, 0xF0, 0x20); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Magma_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + task->tFrames = 60; + sub_814669C(task); + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + LZ77UnCompVram(sTeamMagma_Tileset, dst2); + LoadPalette(sEvilTeam_Palette, 0xF0, 0x20); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Regi_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + task->tFrames = 60; + sub_814669C(task); + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + CpuCopy16(gUnknown_085BBC14, dst2, 0x2000); + + task->tState++; + return FALSE; +} + +bool8 Phase2_BigPokeball_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_814669C(task); + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + CpuCopy16(sBigPokeball_Tileset, dst2, 0x580); + LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); + + task->tState++; + return FALSE; +} + +bool8 Phase2_BigPokeball_Func2(struct Task *task) +{ + s16 i, j; + u16 *dst1, *dst2; + const u16 *BigPokeballMap; + + sub_8149F58(&dst1, &dst2); + BigPokeballMap = sBigPokeball_Tilemap; + for (i = 0; i < 20; i++) + { + for (j = 0; j < 30; j++, BigPokeballMap++) + { + dst1[i * 32 + j] = *BigPokeballMap | 0xF000; + } + } + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + + task->tState++; + return TRUE; +} + +bool8 Phase2_Aqua_Func2(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LZ77UnCompVram(sTeamAqua_Tilemap, dst1); + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Magma_Func2(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LZ77UnCompVram(sTeamMagma_Tilemap, dst1); + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Regice_Func2(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LoadPalette(gUnknown_085BC2B4, 0xF0, 0x20); + CpuCopy16(gUnknown_085BC314, dst1, 0x500); + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Registeel_Func2(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LoadPalette(gUnknown_085BC2D4, 0xF0, 0x20); + CpuCopy16(gUnknown_085BCB14, dst1, 0x500); + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Regirock_Func2(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LoadPalette(gUnknown_085BC2F4, 0xF0, 0x20); + CpuCopy16(gUnknown_085BD314, dst1, 0x500); + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Kyogre_Func3(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + LZ77UnCompVram(gUnknown_085BDB34, dst2); + LZ77UnCompVram(gUnknown_085BE1E8, dst1); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Kyogre_Func4(struct Task *task) +{ + if (task->data[1] % 3 == 0) + { + u16 var = task->data[1] % 30; + var /= 3; + LoadPalette(gUnknown_085BEDA0 + (var * 16), 0xF0, 0x20); + } + if (++task->data[1] > 58) + { + task->tState++; + task->data[1] = 0; + } + + return FALSE; +} + +bool8 Phase2_Kyogre_Func5(struct Task *task) +{ + if (task->data[1] % 5 == 0) + { + s16 var = task->data[1] / 5; + LoadPalette(gUnknown_085BEEE0 + (var * 16), 0xF0, 0x20); + } + if (++task->data[1] > 68) + { + task->tState++; + task->data[1] = 0; + task->tFrames = 30; + } + + return FALSE; +} + +bool8 Phase2_WeatherDuo_Func6(struct Task *task) +{ + BeginNormalPaletteFade(0xFFFF8000, 1, 0, 0x10, 0); + task->tState++; + return FALSE; +} + +bool8 Phase2_WeatherDuo_Func7(struct Task *task) +{ + if (!gPaletteFade.active) + { + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(task->func)); + } + return FALSE; +} + +bool8 Phase2_BigPokeball_Func3(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + if (task->data[3] == 0 || --task->data[3] == 0) + { + task->data[2]++; + task->data[3] = 2; + } + sTransitionStructPtr->BLDALPHA = (task->data[1] << 8) | task->data[2]; + if (task->data[2] > 15) + task->tState++; + task->data[4] += 8; + task->data[5] -= 256; + + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_BigPokeball_Func4(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + if (task->data[3] == 0 || --task->data[3] == 0) + { + task->data[1]--; + task->data[3] = 2; + } + sTransitionStructPtr->BLDALPHA = (task->data[1] << 8) | task->data[2]; + if (task->data[1] == 0) + task->tState++; + task->data[4] += 8; + task->data[5] -= 256; + + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_BigPokeball_Func5(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + task->data[4] += 8; + task->data[5] -= 256; + + sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + + if (task->data[5] <= 0) + { + task->tState++; + task->data[1] = 160; + task->data[2] = 256; + task->data[3] = 0; + } + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_FramesCountdown(struct Task *task) +{ + if (--task->tFrames == 0) + task->tState++; + return FALSE; +} + +bool8 Phase2_WeatherTrio_Func1(struct Task *task) +{ + BeginNormalPaletteFade(0x0000FFFF, 1, 0, 0x10, 0); + task->tState++; + return FALSE; +} + +bool8 Phase2_WaitPaletteFade(struct Task *task) +{ + if (!gPaletteFade.active) + task->tState++; + return FALSE; +} + +bool8 Phase2_BigPokeball_Func6(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + if (task->data[2] < 1024) + task->data[2] += 128; + if (task->data[1] != 0) + { + task->data[1] -= (task->data[2] >> 8); + if (task->data[1] < 0) + task->data[1] = 0; + } + sub_814A014(gUnknown_02038C28[0], 120, 80, task->data[1]); + if (task->data[1] == 0) + { + SetVBlankCallback(NULL); + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(task->func)); + } + else + { + if (task->data[3] == 0) + { + task->data[3]++; + SetVBlankCallback(VBlankCB1_Phase2_BigPokeball); + } + + sTransitionStructPtr->VBlank_DMA++; + } + + return FALSE; +} + +void Transition_BigPokeball_Vblank(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); + REG_WININ = sTransitionStructPtr->WININ; + REG_WINOUT = sTransitionStructPtr->WINOUT; + REG_WIN0V = sTransitionStructPtr->WIN0V; + REG_BLDCNT = sTransitionStructPtr->BLDCNT; + REG_BLDALPHA = sTransitionStructPtr->BLDALPHA; +} + +void VBlankCB0_Phase2_BigPokeball(void) +{ + Transition_BigPokeball_Vblank(); + DmaSet(0, gUnknown_020393A8, ®_BG0HOFS, 0xA2400001); +} + +void VBlankCB1_Phase2_BigPokeball(void) +{ + Transition_BigPokeball_Vblank(); + DmaSet(0, gUnknown_020393A8, ®_WIN0H, 0xA2400001); +} + +void Phase2Task_PokeballsTrail(u8 taskId) +{ + while (sPhase2_PokeballsTrail_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_PokeballsTrail_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + CpuSet(sPokeballTrail_Tileset, dst2, 0x20); + CpuFill32(0, dst1, 0x800); + LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); + + task->tState++; + return FALSE; +} + +bool8 Phase2_PokeballsTrail_Func2(struct Task *task) +{ + s16 i; + s16 rand; + s16 arr0[ARRAY_COUNT(sUnknown_085C8B88)]; + s16 arr1[ARRAY_COUNT(sUnknown_085C8B8C)]; + + memcpy(arr0, sUnknown_085C8B88, sizeof(sUnknown_085C8B88)); + memcpy(arr1, sUnknown_085C8B8C, sizeof(sUnknown_085C8B8C)); + rand = Random() & 1; + for (i = 0; i <= 4; i++, rand ^= 1) + { + gFieldEffectArguments[0] = arr0[rand]; // x + gFieldEffectArguments[1] = (i * 32) + 16; // y + gFieldEffectArguments[2] = rand; + gFieldEffectArguments[3] = arr1[i]; + FieldEffectStart(FLDEFF_POKEBALL); + } + + task->tState++; + return FALSE; +} + +bool8 Phase2_PokeballsTrail_Func3(struct Task *task) +{ + if (!FieldEffectActiveListContains(FLDEFF_POKEBALL)) + { + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(Phase2Task_PokeballsTrail)); + } + return FALSE; +} + +bool8 FldEff_Pokeball(void) +{ + u8 spriteId = CreateSpriteAtEnd(&gUnknown_085C8E68, gFieldEffectArguments[0], gFieldEffectArguments[1], 0); + gSprites[spriteId].oam.priority = 0; + gSprites[spriteId].oam.affineMode = 1; + gSprites[spriteId].data[0] = gFieldEffectArguments[2]; + gSprites[spriteId].data[1] = gFieldEffectArguments[3]; + gSprites[spriteId].data[2] = -1; + InitSpriteAffineAnim(&gSprites[spriteId]); + StartSpriteAffineAnim(&gSprites[spriteId], gFieldEffectArguments[2]); + return FALSE; +} + +#define SOME_VRAM_STORE(ptr, posY, posX, toStore) \ +{ \ + u32 index = (posY) * 32 + posX; \ + ptr[index] = toStore; \ +} + +void sub_814713C(struct Sprite *sprite) +{ + s16 arr0[ARRAY_COUNT(sUnknown_085C8B96)]; + + memcpy(arr0, sUnknown_085C8B96, sizeof(sUnknown_085C8B96)); + if (sprite->data[1] != 0) + { + sprite->data[1]--; + } + else + { + if (sprite->pos1.x >= 0 && sprite->pos1.x <= 240) + { + s16 posX = sprite->pos1.x >> 3; + s16 posY = sprite->pos1.y >> 3; + + if (posX != sprite->data[2]) + { + u32 var; + u16 *ptr; + + sprite->data[2] = posX; + var = (((REG_BG0CNT >> 8) & 0x1F) << 11); // r2 + ptr = (u16 *)(VRAM + var); + + SOME_VRAM_STORE(ptr, posY - 2, posX, 0xF001); + SOME_VRAM_STORE(ptr, posY - 1, posX, 0xF001); + SOME_VRAM_STORE(ptr, posY - 0, posX, 0xF001); + SOME_VRAM_STORE(ptr, posY + 1, posX, 0xF001); + } + } + sprite->pos1.x += arr0[sprite->data[0]]; + if (sprite->pos1.x < -15 || sprite->pos1.x > 255) + FieldEffectStop(sprite, FLDEFF_POKEBALL); + } +} + +void Phase2Task_Clockwise_BlackFade(u8 taskId) +{ + while (sPhase2_Clockwise_BlackFade_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task) +{ + u16 i; + + sub_8149F08(); + dp12_8087EA4(); + + sTransitionStructPtr->WININ = 0; + sTransitionStructPtr->WINOUT = 63; + sTransitionStructPtr->field_6 = -3855; + sTransitionStructPtr->WIN0V = 160; + + for (i = 0; i < 160; i++) + { + gUnknown_020393A8[i] = 0xF3F4; + } + + SetVBlankCallback(VBlankCB_Phase2_Clockwise_BlackFade); + sTransitionStructPtr->data[4] = 120; + + task->tState++; + return TRUE; +} + +bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + + sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], -1, 1, 1); + do + { + gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (sTransitionStructPtr->data[2] + 1) | 0x7800; + } while (!sub_814A228(sTransitionStructPtr->data, 1, 1)); + + sTransitionStructPtr->data[4] += 16; + if (sTransitionStructPtr->data[4] >= 240) + { + sTransitionStructPtr->data[5] = 0; + task->tState++; + } + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task) +{ + s16 r1, r3; + vu8 var = 0; + + sTransitionStructPtr->VBlank_DMA = 0; + + sub_814A1AC(sTransitionStructPtr->data, 120, 80, 240, sTransitionStructPtr->data[5], 1, 1); + + while (1) + { + r1 = 120, r3 = sTransitionStructPtr->data[2] + 1; + if (sTransitionStructPtr->data[5] >= 80) + r1 = sTransitionStructPtr->data[2], r3 = 240; + gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r3) | (r1 << 8); + if (var != 0) + break; + var = sub_814A228(sTransitionStructPtr->data, 1, 1); + } + + sTransitionStructPtr->data[5] += 8; + if (sTransitionStructPtr->data[5] >= 160) + { + sTransitionStructPtr->data[4] = 240; + task->tState++; + } + else + { + while (sTransitionStructPtr->data[3] < sTransitionStructPtr->data[5]) + { + gUnknown_02038C28[0][++sTransitionStructPtr->data[3]] = (r3) | (r1 << 8); + } + } + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + + sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], 160, 1, 1); + do + { + gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (sTransitionStructPtr->data[2] << 8) | 0xF0; + } while (!sub_814A228(sTransitionStructPtr->data, 1, 1)); + + sTransitionStructPtr->data[4] -= 16; + if (sTransitionStructPtr->data[4] <= 0) + { + sTransitionStructPtr->data[5] = 160; + task->tState++; + } + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task) +{ + s16 r1, r2, var4; + vu8 var = 0; + + sTransitionStructPtr->VBlank_DMA = 0; + + sub_814A1AC(sTransitionStructPtr->data, 120, 80, 0, sTransitionStructPtr->data[5], 1, 1); + + while (1) + { + r1 = (gUnknown_02038C28[0][sTransitionStructPtr->data[3]]) & 0xFF; + r2 = sTransitionStructPtr->data[2]; + if (sTransitionStructPtr->data[5] <= 80) + r2 = 120, r1 = sTransitionStructPtr->data[2]; + var4 = (r1) | (r2 << 8); + gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = var4; + if (var != 0) + break; + var = sub_814A228(sTransitionStructPtr->data, 1, 1); + } + + sTransitionStructPtr->data[5] -= 8; + if (sTransitionStructPtr->data[5] <= 0) + { + sTransitionStructPtr->data[4] = 0; + task->tState++; + } + else + { + while (sTransitionStructPtr->data[3] > sTransitionStructPtr->data[5]) + { + gUnknown_02038C28[0][--sTransitionStructPtr->data[3]] = (r1) | (r2 << 8); + } + } + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + + sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], 0, 1, 1); + do + { + s16 r2, r3; + + r2 = 120, r3 = sTransitionStructPtr->data[2]; + if (sTransitionStructPtr->data[2] >= 120) + r2 = 0, r3 = 240; + gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r3) | (r2 << 8); + + } while (!sub_814A228(sTransitionStructPtr->data, 1, 1)); + + sTransitionStructPtr->data[4] += 16; + if (sTransitionStructPtr->data[2] > 120) + task->tState++; + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task) +{ + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Clockwise_BlackFade)); + return FALSE; +} + +void VBlankCB_Phase2_Clockwise_BlackFade(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA != 0) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); + REG_WININ = sTransitionStructPtr->WININ; + REG_WINOUT = sTransitionStructPtr->WINOUT; + REG_WIN0V = sTransitionStructPtr->WIN0V; + REG_WIN0H = gUnknown_02038C28[1][0]; + DmaSet(0, gUnknown_02038C28[1], ®_WIN0H, 0xA2400001); +} + +void Phase2Task_Ripple(u8 taskId) +{ + while (sPhase2_Ripple_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Ripple_Func1(struct Task *task) +{ + u8 i; + + sub_8149F08(); + dp12_8087EA4(); + + for (i = 0; i < 160; i++) + { + gUnknown_020393A8[i] = sTransitionStructPtr->field_16; + } + + SetVBlankCallback(VBlankCB_Phase2_Ripple); + SetHBlankCallback(HBlankCB_Phase2_Ripple); + + EnableInterrupts(INTR_FLAG_HBLANK); + + task->tState++; + return TRUE; +} + +bool8 Phase2_Ripple_Func2(struct Task *task) +{ + u8 i; + s16 r3; + u16 r4, r8; + + sTransitionStructPtr->VBlank_DMA = 0; + + r3 = task->data[2] >> 8; + r4 = task->data[1]; + r8 = 384; + task->data[1] += 0x400; + if (task->data[2] <= 0x1FFF) + task->data[2] += 0x180; + + for (i = 0; i < 160; i++, r4 += r8) + { + // todo: fix the asm + s16 var = r4 >> 8; + asm(""); + gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3); + } + + if (++task->data[3] == 81) + { + task->data[4]++; + BeginNormalPaletteFade(-1, -2, 0, 0x10, 0); + } + + if (task->data[4] != 0 && !gPaletteFade.active) + DestroyTask(FindTaskIdByFunc(Phase2Task_Ripple)); + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +void VBlankCB_Phase2_Ripple(void) +{ + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); +} + +void HBlankCB_Phase2_Ripple(void) +{ + u16 var = gUnknown_02038C28[1][REG_VCOUNT]; + REG_BG1VOFS = var; + REG_BG2VOFS = var; + REG_BG3VOFS = var; +} + +void Phase2Task_Wave(u8 taskId) +{ + while (sPhase2_Wave_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Wave_Func1(struct Task *task) +{ + u8 i; + + sub_8149F08(); + dp12_8087EA4(); + + sTransitionStructPtr->WININ = 63; + sTransitionStructPtr->WINOUT = 0; + sTransitionStructPtr->field_6 = 240; + sTransitionStructPtr->WIN0V = 160; + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[1][i] = 242; + } + + SetVBlankCallback(VBlankCB_Phase2_Wave); + + task->tState++; + return TRUE; +} + +bool8 Phase2_Wave_Func2(struct Task *task) +{ + u8 i, r5; + u16* toStore; + bool8 nextFunc; + + sTransitionStructPtr->VBlank_DMA = 0; + toStore = gUnknown_02038C28[0]; + r5 = task->data[2]; + task->data[2] += 16; + task->data[1] += 8; + + for (i = 0, nextFunc = TRUE; i < 160; i++, r5 += 4, toStore++) + { + s16 value = task->data[1] + Sin(r5, 40); + if (value < 0) + value = 0; + if (value > 240) + value = 240; + *toStore = (value << 8) | (0xF1); + if (value < 240) + nextFunc = FALSE; + } + if (nextFunc) + task->tState++; + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Wave_Func3(struct Task *task) +{ + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Wave)); + return FALSE; +} + +void VBlankCB_Phase2_Wave(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA != 0) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); + REG_WININ = sTransitionStructPtr->WININ; + REG_WINOUT = sTransitionStructPtr->WINOUT; + REG_WIN0V = sTransitionStructPtr->WIN0V; + DmaSet(0, gUnknown_02038C28[1], ®_WIN0H, 0xA2400001); +} + +void Phase2Task_Sydney(u8 taskId) +{ + gTasks[taskId].tMugshotId = MUGSHOT_SYDNEY; + Phase2Task_MugShotTransition(taskId); +} + +void Phase2Task_Phoebe(u8 taskId) +{ + gTasks[taskId].tMugshotId = MUGSHOT_PHOEBE; + Phase2Task_MugShotTransition(taskId); +} + +void Phase2Task_Glacia(u8 taskId) +{ + gTasks[taskId].tMugshotId = MUGSHOT_GLACIA; + Phase2Task_MugShotTransition(taskId); +} + +void Phase2Task_Drake(u8 taskId) +{ + gTasks[taskId].tMugshotId = MUGSHOT_DRAKE; + Phase2Task_MugShotTransition(taskId); +} + +void Phase2Task_Champion(u8 taskId) +{ + gTasks[taskId].tMugshotId = MUGSHOT_CHAMPION; + Phase2Task_MugShotTransition(taskId); +} + +void Phase2Task_MugShotTransition(u8 taskId) +{ + while (sPhase2_Mugshot_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Mugshot_Func1(struct Task *task) +{ + u8 i; + + sub_8149F08(); + dp12_8087EA4(); + Mugshots_CreateOpponentPlayerSprites(task); + + task->data[1] = 0; + task->data[2] = 1; + task->data[3] = 239; + sTransitionStructPtr->WININ = 63; + sTransitionStructPtr->WINOUT = 62; + sTransitionStructPtr->WIN0V = 160; + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[1][i] = 0xF0F1; + } + + SetVBlankCallback(VBlankCB0_Phase2_Mugshots); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Mugshot_Func2(struct Task *task) +{ + s16 i, j; + u16 *dst1, *dst2; + const u16 *MugshotsMap; + + MugshotsMap = sMugshotsTilemap; + sub_8149F58(&dst1, &dst2); + CpuSet(sUnknown_085B9AF0, dst2, 0xF0); + LoadPalette(sOpponentMugshotsPals[task->tMugshotId], 0xF0, 0x20); + LoadPalette(sPlayerMugshotsPals[gSaveBlock2Ptr->playerGender], 0xFA, 0xC); + + for (i = 0; i < 20; i++) + { + for (j = 0; j < 32; j++, MugshotsMap++) + { + dst1[i * 32 + j] = *MugshotsMap | 0xF000; + } + } + + EnableInterrupts(INTR_FLAG_HBLANK); + + SetHBlankCallback(HBlankCB_Phase2_Mugshots); + task->tState++; + return FALSE; +} + +bool8 Phase2_Mugshot_Func3(struct Task *task) +{ + u8 i, r5; + u16* toStore; + s16 value; + s32 mergedValue; + + sTransitionStructPtr->VBlank_DMA = 0; + + toStore = gUnknown_02038C28[0]; + r5 = task->data[1]; + task->data[1] += 0x10; + + for (i = 0; i < 80; i++, toStore++, r5 += 0x10) + { + value = task->data[2] + Sin(r5, 0x10); + if (value < 0) + value = 1; + if (value > 0xF0) + value = 0xF0; + *toStore = value; + } + for (; i < 160; i++, toStore++, r5 += 0x10) + { + value = task->data[3] - Sin(r5, 0x10); + if (value < 0) + value = 0; + if (value > 0xEF) + value = 0xEF; + *toStore = (value << 8) | (0xF0); + } + + task->data[2] += 8; + task->data[3] -= 8; + if (task->data[2] > 0xF0) + task->data[2] = 0xF0; + if (task->data[3] < 0) + task->data[3] = 0; + mergedValue = *(s32*)(&task->data[2]); + if (mergedValue == 0xF0) + task->tState++; + + sTransitionStructPtr->field_18 -= 8; + sTransitionStructPtr->field_1A += 8; + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Mugshot_Func4(struct Task *task) +{ + u8 i; + u16* toStore; + + sTransitionStructPtr->VBlank_DMA = 0; + + for (i = 0, toStore = gUnknown_02038C28[0]; i < 160; i++, toStore++) + { + *toStore = 0xF0; + } + + task->tState++; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + sTransitionStructPtr->field_18 -= 8; + sTransitionStructPtr->field_1A += 8; + + sub_8148484(task->tOpponentSpriteId, 0); + sub_8148484(task->tPlayerSpriteId, 1); + sub_814849C(task->tOpponentSpriteId); + + PlaySE(SE_BT_START); + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Mugshot_Func5(struct Task *task) +{ + sTransitionStructPtr->field_18 -= 8; + sTransitionStructPtr->field_1A += 8; + if (sub_81484B8(task->tOpponentSpriteId)) + { + task->tState++; + sub_814849C(task->tPlayerSpriteId); + } + return FALSE; +} + +bool8 Phase2_Mugshot_Func6(struct Task *task) +{ + sTransitionStructPtr->field_18 -= 8; + sTransitionStructPtr->field_1A += 8; + if (sub_81484B8(task->tPlayerSpriteId)) + { + sTransitionStructPtr->VBlank_DMA = 0; + SetVBlankCallback(NULL); + DmaStop(0); + memset(gUnknown_02038C28[0], 0, 0x140); + memset(gUnknown_02038C28[1], 0, 0x140); + SetGpuReg(REG_OFFSET_WIN0H, 0xF0); + SetGpuReg(REG_OFFSET_BLDY, 0); + task->tState++; + task->data[3] = 0; + task->data[4] = 0; + sTransitionStructPtr->BLDCNT = 0xBF; + SetVBlankCallback(VBlankCB1_Phase2_Mugshots); + } + return FALSE; +} + +bool8 Phase2_Mugshot_Func7(struct Task *task) +{ + bool32 r6; + + sTransitionStructPtr->VBlank_DMA = 0; + r6 = TRUE; + sTransitionStructPtr->field_18 -= 8; + sTransitionStructPtr->field_1A += 8; + + if (task->data[4] < 0x50) + task->data[4] += 2; + if (task->data[4] > 0x50) + task->data[4] = 0x50; + + if (++task->data[3] & 1) + { + s16 i; + for (i = 0, r6 = FALSE; i <= task->data[4]; i++) + { + s16 index1 = 0x50 - i; + s16 index2 = 0x50 + i; + if (gUnknown_02038C28[0][index1] <= 15) + { + r6 = TRUE; + gUnknown_02038C28[0][index1]++; + } + if (gUnknown_02038C28[0][index2] <= 15) + { + r6 = TRUE; + gUnknown_02038C28[0][index2]++; + } + } + } + + if (task->data[4] == 0x50 && !r6) + task->tState++; + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Mugshot_Func8(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + BlendPalettes(-1, 0x10, 0x7FFF); + sTransitionStructPtr->BLDCNT = 0xFF; + task->data[3] = 0; + + task->tState++; + return TRUE; +} + +bool8 Phase2_Mugshot_Func9(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + + task->data[3]++; + memset(gUnknown_02038C28[0], task->data[3], 0x140); + if (task->data[3] > 15) + task->tState++; + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Mugshot_Func10(struct Task *task) +{ + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(task->func)); + return FALSE; +} + +void VBlankCB0_Phase2_Mugshots(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA != 0) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); + REG_BG0VOFS = sTransitionStructPtr->field_1C; + REG_WININ = sTransitionStructPtr->WININ; + REG_WINOUT = sTransitionStructPtr->WINOUT; + REG_WIN0V = sTransitionStructPtr->WIN0V; + DmaSet(0, gUnknown_02038C28[1], ®_WIN0H, 0xA2400001); +} + +void VBlankCB1_Phase2_Mugshots(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA != 0) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); + REG_BLDCNT = sTransitionStructPtr->BLDCNT; + DmaSet(0, gUnknown_02038C28[1], ®_BLDY, 0xA2400001); +} + +void HBlankCB_Phase2_Mugshots(void) +{ + if (REG_VCOUNT < 80) + REG_BG0HOFS = sTransitionStructPtr->field_18; + else + REG_BG0HOFS = sTransitionStructPtr->field_1A; +} + +void Mugshots_CreateOpponentPlayerSprites(struct Task *task) +{ + struct Sprite *opponentSprite, *playerSprite; + + s16 mugshotId = task->tMugshotId; + task->tOpponentSpriteId = CreateTrainerSprite(sMugshotsTrainerPicIDsTable[mugshotId], + sMugshotsOpponentCoords[mugshotId][0] - 32, + sMugshotsOpponentCoords[mugshotId][1] + 42, + 0, gDecompressionBuffer); + task->tPlayerSpriteId = CreateTrainerSprite(PlayerGenderToFrontTrainerPicId(gSaveBlock2Ptr->playerGender), 272, 106, 0, gDecompressionBuffer); + + opponentSprite = &gSprites[task->tOpponentSpriteId]; + playerSprite = &gSprites[task->tPlayerSpriteId]; + + opponentSprite->callback = sub_8148380; + playerSprite->callback = sub_8148380; + + opponentSprite->oam.affineMode = 3; + playerSprite->oam.affineMode = 3; + + opponentSprite->oam.matrixNum = AllocOamMatrix(); + playerSprite->oam.matrixNum = AllocOamMatrix(); + + opponentSprite->oam.shape = 1; + playerSprite->oam.shape = 1; + + opponentSprite->oam.size = 3; + playerSprite->oam.size = 3; + + CalcCenterToCornerVec(opponentSprite, 1, 3, 3); + CalcCenterToCornerVec(playerSprite, 1, 3, 3); + + SetOamMatrixRotationScaling(opponentSprite->oam.matrixNum, sMugshotsOpponentRotationScales[mugshotId][0], sMugshotsOpponentRotationScales[mugshotId][1], 0); + SetOamMatrixRotationScaling(playerSprite->oam.matrixNum, -512, 512, 0); +} + +void sub_8148380(struct Sprite *sprite) +{ + while (sUnknown_085C8C24[sprite->data[0]](sprite)); +} + +bool8 sub_81483A8(struct Sprite *sprite) +{ + return FALSE; +} + +bool8 sub_81483AC(struct Sprite *sprite) +{ + s16 arr0[2]; + s16 arr1[2]; + + memcpy(arr0, sUnknown_085C8C40, sizeof(sUnknown_085C8C40)); + memcpy(arr1, sUnknown_085C8C44, sizeof(sUnknown_085C8C44)); + + sprite->data[0]++; + sprite->data[1] = arr0[sprite->data[7]]; + sprite->data[2] = arr1[sprite->data[7]]; + return TRUE; +} + +bool8 sub_81483F8(struct Sprite *sprite) +{ + sprite->pos1.x += sprite->data[1]; + if (sprite->data[7] && sprite->pos1.x < 133) + sprite->data[0]++; + else if (!sprite->data[7] && sprite->pos1.x > 103) + sprite->data[0]++; + return FALSE; +} + +bool8 sub_814842C(struct Sprite *sprite) +{ + sprite->data[1] += sprite->data[2]; + sprite->pos1.x += sprite->data[1]; + if (sprite->data[1] == 0) + { + sprite->data[0]++; + sprite->data[2] = -sprite->data[2]; + sprite->data[6] = 1; + } + return FALSE; +} + +bool8 sub_8148458(struct Sprite *sprite) +{ + sprite->data[1] += sprite->data[2]; + sprite->pos1.x += sprite->data[1]; + if (sprite->pos1.x < -31 || sprite->pos1.x > 271) + sprite->data[0]++; + return FALSE; +} + +void sub_8148484(s16 spriteId, s16 value) +{ + gSprites[spriteId].data[7] = value; +} + +void sub_814849C(s16 spriteId) +{ + gSprites[spriteId].data[0]++; +} + +s16 sub_81484B8(s16 spriteId) +{ + return gSprites[spriteId].data[6]; +} + +void Phase2Task_Slice(u8 taskId) +{ + while (sPhase2_Slice_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Slice_Func1(struct Task *task) +{ + u16 i; + + sub_8149F08(); + dp12_8087EA4(); + + task->data[2] = 256; + task->data[3] = 1; + sTransitionStructPtr->WININ = 63; + sTransitionStructPtr->WINOUT = 0; + sTransitionStructPtr->WIN0V = 160; + sTransitionStructPtr->VBlank_DMA = 0; + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[1][i] = sTransitionStructPtr->field_14; + gUnknown_02038C28[1][160 + i] = 0xF0; + } + + EnableInterrupts(INTR_FLAG_HBLANK); + SetGpuRegBits(REG_OFFSET_DISPSTAT, DISPSTAT_HBLANK_INTR); + + SetVBlankCallback(VBlankCB_Phase2_Slice); + SetHBlankCallback(HBlankCB_Phase2_Slice); + + task->tState++; + return TRUE; +} + +bool8 Phase2_Slice_Func2(struct Task *task) +{ + u16 i; + + sTransitionStructPtr->VBlank_DMA = 0; + + task->data[1] += (task->data[2] >> 8); + if (task->data[1] > 0xF0) + task->data[1] = 0xF0; + if (task->data[2] <= 0xFFF) + task->data[2] += task->data[3]; + if (task->data[3] < 128) + task->data[3] <<= 1; // multiplying by two + + for (i = 0; i < 160; i++) + { + u16* storeLoc1 = &gUnknown_02038C28[0][i]; + u16* storeLoc2 = &gUnknown_02038C28[0][i + 160]; + if (1 & i) + { + *storeLoc1 = sTransitionStructPtr->field_14 + task->data[1]; + *storeLoc2 = 0xF0 - task->data[1]; + } + else + { + *storeLoc1 = sTransitionStructPtr->field_14 - task->data[1]; + *storeLoc2 = (task->data[1] << 8) | (0xF1); + } + } + + if (task->data[1] > 0xEF) + task->tState++; + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Slice_Func3(struct Task *task) +{ + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Slice)); + return FALSE; +} + +void VBlankCB_Phase2_Slice(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + REG_WININ = sTransitionStructPtr->WININ; + REG_WINOUT = sTransitionStructPtr->WINOUT; + REG_WIN0V = sTransitionStructPtr->WIN0V; + if (sTransitionStructPtr->VBlank_DMA) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 640); + DmaSet(0, &gUnknown_02038C28[1][160], ®_WIN0H, 0xA2400001); +} + +void HBlankCB_Phase2_Slice(void) +{ + if (REG_VCOUNT < 160) + { + u16 var = gUnknown_02038C28[1][REG_VCOUNT]; + REG_BG1HOFS = var; + REG_BG2HOFS = var; + REG_BG3HOFS = var; + } +} -- cgit v1.2.3 From 9106d8df1856c65b2bc85da6d61b6968669814ea Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sat, 13 Jan 2018 21:03:07 +0100 Subject: up to groudon transition --- src/battle_transition.c | 679 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 651 insertions(+), 28 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index e60a2d91f..04f48b126 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -41,6 +41,15 @@ struct TransitionData s16 data[11]; }; +struct StructRectangularSpiral +{ + u8 field_0; + s16 field_2; + u8 field_4; + s16 field_6; + u8 field_8; +}; + typedef bool8 (*TransitionStateFunc)(struct Task *task); typedef bool8 (*TransitionSpriteCallback)(struct Sprite *sprite); @@ -81,9 +90,9 @@ void Phase2Task_Kyogre(u8 taskId); void Phase2Task_Groudon(u8 taskId); void Phase2Task_Rayquaza(u8 taskId); void Phase2Task_25(u8 taskId); -void Phase2Task_26(u8 taskId); -void Phase2Task_27(u8 taskId); -void Phase2Task_28(u8 taskId); +void Phase2Task_Blackhole1(u8 taskId); +void Phase2Task_Blackhole2(u8 taskId); +void Phase2Task_RectangularSpiral(u8 taskId); void Phase2Task_29(u8 taskId); void Phase2Task_30(u8 taskId); void Phase2Task_31(u8 taskId); @@ -127,6 +136,9 @@ bool8 Phase2_WaitPaletteFade(struct Task *task); bool8 Phase2_Kyogre_Func3(struct Task *task); bool8 Phase2_Kyogre_Func4(struct Task *task); bool8 Phase2_Kyogre_Func5(struct Task *task); +bool8 Phase2_Groudon_Func3(struct Task *task); +bool8 Phase2_Groudon_Func4(struct Task *task); +bool8 Phase2_Groudon_Func5(struct Task *task); bool8 Phase2_WeatherDuo_Func6(struct Task *task); bool8 Phase2_WeatherDuo_Func7(struct Task *task); bool8 Phase2_BigPokeball_Func1(struct Task *task); @@ -166,6 +178,17 @@ bool8 Phase2_Shards_Func2(struct Task *task); bool8 Phase2_Shards_Func3(struct Task *task); bool8 Phase2_Shards_Func4(struct Task *task); bool8 Phase2_Shards_Func5(struct Task *task); +bool8 Phase2_25_Func1(struct Task *task); +bool8 Phase2_25_Func2(struct Task *task); +bool8 Phase2_25_Func3(struct Task *task); +bool8 Phase2_25_Func4(struct Task *task); +bool8 Phase2_Blackhole_Func1(struct Task *task); +bool8 Phase2_Blackhole1_Func2(struct Task *task); +bool8 Phase2_Blackhole1_Func3(struct Task *task); +bool8 Phase2_Blackhole2_Func2(struct Task *task); +bool8 Phase2_RectangularSpiral_Func1(struct Task *task); +bool8 Phase2_RectangularSpiral_Func2(struct Task *task); +bool8 Phase2_RectangularSpiral_Func3(struct Task *task); bool8 Phase2_Mugshot_Func1(struct Task *task); bool8 Phase2_Mugshot_Func2(struct Task *task); bool8 Phase2_Mugshot_Func3(struct Task *task); @@ -197,6 +220,7 @@ void sub_8148484(s16 spriteId, s16 value); void sub_814849C(s16 spriteId); s16 sub_81484B8(s16 spriteId); bool8 IsPhase1Done(void); +bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1); void sub_814713C(struct Sprite *sprite); void sub_8148380(struct Sprite *sprite); bool8 sub_81483A8(struct Sprite *sprite); @@ -206,9 +230,10 @@ bool8 sub_814842C(struct Sprite *sprite); bool8 sub_8148458(struct Sprite *sprite); // iwram bss vars -IWRAM_DATA u16 gUnknown_03001208; +IWRAM_DATA static s16 sUnusedRectangularSpiralVar; IWRAM_DATA static u8 sTestingTransitionId; IWRAM_DATA static u8 sTestingTransitionState; +IWRAM_DATA static struct StructRectangularSpiral sRectangularSpiralTransition[4]; // ewram vars EWRAM_DATA struct TransitionData *sTransitionStructPtr = NULL; @@ -288,9 +313,9 @@ const TaskFunc sPhase2_Tasks[B_TRANSITION_COUNT] = Phase2Task_Groudon, // 23 Phase2Task_Rayquaza, // 24 Phase2Task_25, // 25 - Phase2Task_26, // 26 - Phase2Task_27, // 27 - Phase2Task_28, // 28 + Phase2Task_Blackhole1, // 26 + Phase2Task_Blackhole2, // 27 + Phase2Task_RectangularSpiral, // 28 Phase2Task_29, // 29 Phase2Task_30, // 30 Phase2Task_31, // 31 @@ -502,6 +527,98 @@ const TransitionStateFunc sPhase2_Slice_Funcs[] = Phase2_Slice_Func3 }; +const TransitionStateFunc sPhase2_25_Funcs[] = +{ + Phase2_25_Func1, + Phase2_25_Func2, + Phase2_25_Func3, + Phase2_25_Func4 +}; + +const u8 gUnknown_085C8C64[] = {39, 119}; +const s16 gUnknown_085C8C66[] = {1, -1}; + +const TransitionStateFunc sPhase2_Blackhole1_Funcs[] = +{ + Phase2_Blackhole_Func1, + Phase2_Blackhole1_Func2, + Phase2_Blackhole1_Func3 +}; + +const TransitionStateFunc sPhase2_Blackhole2_Funcs[] = +{ + Phase2_Blackhole_Func1, + Phase2_Blackhole2_Func2 +}; + +const s16 gUnknown_085C8C80[] = {-6, 4}; + +const TransitionStateFunc sPhase2_RectangularSpiral_Funcs[] = +{ + Phase2_RectangularSpiral_Func1, + Phase2_RectangularSpiral_Func2, + Phase2_RectangularSpiral_Func3 +}; + +const s16 gUnknown_085C8C90[] = {1, 27, 275, -1}; +const s16 gUnknown_085C8C98[] = {2, 486, -1}; +const s16 gUnknown_085C8C9E[] = {3, 262, -1}; +const s16 gUnknown_085C8CA4[] = {4, 507, -2}; +const s16 gUnknown_085C8CAA[] = {1, 213, -1}; +const s16 gUnknown_085C8CB0[] = {2, 548, -2}; +const s16 gUnknown_085C8CB6[] = {3, 196, -1}; +const s16 gUnknown_085C8CBC[] = {4, 573, 309, -1}; +const s16 gUnknown_085C8CC4[] = {1, 474, -1}; +const s16 gUnknown_085C8CCA[] = {2, 295, 32, -1}; +const s16 gUnknown_085C8CD2[] = {3, 58, -1}; +const s16 gUnknown_085C8CD8[] = {4, 455, -1}; +const s16 gUnknown_085C8CDE[] = {1, 540, -1}; +const s16 gUnknown_085C8CE4[] = {2, 229, -1}; +const s16 gUnknown_085C8CEA[] = {3, 244, 28, -1}; +const s16 gUnknown_085C8CF2[] = {4, 517, -1}; + +const s16 *const gUnknown_085C8CF8[] = +{ + gUnknown_085C8C90, + gUnknown_085C8CA4, + gUnknown_085C8C98, + gUnknown_085C8C9E, + gUnknown_085C8CEA, + gUnknown_085C8CE4, + gUnknown_085C8CF2, + gUnknown_085C8CDE +}; + +const s16 *const gUnknown_085C8D18[] = +{ + gUnknown_085C8CBC, + gUnknown_085C8CB0, + gUnknown_085C8CB6, + gUnknown_085C8CAA, + gUnknown_085C8CCA, + gUnknown_085C8CD8, + gUnknown_085C8CC4, + gUnknown_085C8CD2 +}; + +const s16 *const *const gUnknown_085C8D38[] = +{ + gUnknown_085C8CF8, + gUnknown_085C8D18 +}; + +const TransitionStateFunc sPhase2_Groudon_Funcs[] = +{ + Phase2_WeatherTrio_Func1, + Phase2_WaitPaletteFade, + Phase2_Groudon_Func3, + Phase2_Groudon_Func4, + Phase2_Groudon_Func5, + Phase2_FramesCountdown, + Phase2_WeatherDuo_Func6, + Phase2_WeatherDuo_Func7 +}; + extern const u16 gFieldEffectObjectPalette10[]; extern const u16 sBigPokeball_Tilemap[]; extern const u16 sMugshotsTilemap[]; @@ -722,7 +839,7 @@ bool8 Phase2_Swirl_Func1(struct Task *task) bool8 Phase2_Swirl_Func2(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; task->data[1] += 4; task->data[2] += 8; @@ -780,7 +897,7 @@ bool8 Phase2_Shuffle_Func2(struct Task *task) u8 i; u16 r3, r4; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; r4 = task->data[1]; r3 = task->data[2] >> 8; task->data[1] += 4224; @@ -1084,7 +1201,7 @@ bool8 Phase2_WeatherDuo_Func7(struct Task *task) bool8 Phase2_BigPokeball_Func3(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; if (task->data[3] == 0 || --task->data[3] == 0) { task->data[2]++; @@ -1104,7 +1221,7 @@ bool8 Phase2_BigPokeball_Func3(struct Task *task) bool8 Phase2_BigPokeball_Func4(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; if (task->data[3] == 0 || --task->data[3] == 0) { task->data[1]--; @@ -1124,7 +1241,7 @@ bool8 Phase2_BigPokeball_Func4(struct Task *task) bool8 Phase2_BigPokeball_Func5(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; task->data[4] += 8; task->data[5] -= 256; @@ -1165,7 +1282,7 @@ bool8 Phase2_WaitPaletteFade(struct Task *task) bool8 Phase2_BigPokeball_Func6(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; if (task->data[2] < 1024) task->data[2] += 128; if (task->data[1] != 0) @@ -1359,7 +1476,7 @@ bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task) bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], -1, 1, 1); do @@ -1383,7 +1500,7 @@ bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task) s16 r1, r3; vu8 var = 0; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; sub_814A1AC(sTransitionStructPtr->data, 120, 80, 240, sTransitionStructPtr->data[5], 1, 1); @@ -1418,7 +1535,7 @@ bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task) bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], 160, 1, 1); do @@ -1442,7 +1559,7 @@ bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task) s16 r1, r2, var4; vu8 var = 0; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; sub_814A1AC(sTransitionStructPtr->data, 120, 80, 0, sTransitionStructPtr->data[5], 1, 1); @@ -1479,7 +1596,7 @@ bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task) bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], 0, 1, 1); do @@ -1554,7 +1671,7 @@ bool8 Phase2_Ripple_Func2(struct Task *task) s16 r3; u16 r4, r8; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; r3 = task->data[2] >> 8; r4 = task->data[1]; @@ -1633,7 +1750,7 @@ bool8 Phase2_Wave_Func2(struct Task *task) u16* toStore; bool8 nextFunc; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; toStore = gUnknown_02038C28[0]; r5 = task->data[2]; task->data[2] += 16; @@ -1772,7 +1889,7 @@ bool8 Phase2_Mugshot_Func3(struct Task *task) s16 value; s32 mergedValue; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; toStore = gUnknown_02038C28[0]; r5 = task->data[1]; @@ -1818,7 +1935,7 @@ bool8 Phase2_Mugshot_Func4(struct Task *task) u8 i; u16* toStore; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; for (i = 0, toStore = gUnknown_02038C28[0]; i < 160; i++, toStore++) { @@ -1860,7 +1977,7 @@ bool8 Phase2_Mugshot_Func6(struct Task *task) sTransitionStructPtr->field_1A += 8; if (sub_81484B8(task->tPlayerSpriteId)) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; SetVBlankCallback(NULL); DmaStop(0); memset(gUnknown_02038C28[0], 0, 0x140); @@ -1880,7 +1997,7 @@ bool8 Phase2_Mugshot_Func7(struct Task *task) { bool32 r6; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; r6 = TRUE; sTransitionStructPtr->field_18 -= 8; sTransitionStructPtr->field_1A += 8; @@ -1919,7 +2036,7 @@ bool8 Phase2_Mugshot_Func7(struct Task *task) bool8 Phase2_Mugshot_Func8(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; BlendPalettes(-1, 0x10, 0x7FFF); sTransitionStructPtr->BLDCNT = 0xFF; task->data[3] = 0; @@ -1930,7 +2047,7 @@ bool8 Phase2_Mugshot_Func8(struct Task *task) bool8 Phase2_Mugshot_Func9(struct Task *task) { - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; task->data[3]++; memset(gUnknown_02038C28[0], task->data[3], 0x140); @@ -2104,7 +2221,7 @@ bool8 Phase2_Slice_Func1(struct Task *task) sTransitionStructPtr->WININ = 63; sTransitionStructPtr->WINOUT = 0; sTransitionStructPtr->WIN0V = 160; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; for (i = 0; i < 160; i++) { @@ -2126,7 +2243,7 @@ bool8 Phase2_Slice_Func2(struct Task *task) { u16 i; - sTransitionStructPtr->VBlank_DMA = 0; + sTransitionStructPtr->VBlank_DMA = FALSE; task->data[1] += (task->data[2] >> 8); if (task->data[1] > 0xF0) @@ -2189,3 +2306,509 @@ void HBlankCB_Phase2_Slice(void) REG_BG3HOFS = var; } } + +void Phase2Task_25(u8 taskId) +{ + while (sPhase2_25_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_25_Func1(struct Task *task) +{ + u16 i; + + sub_8149F08(); + dp12_8087EA4(); + + sTransitionStructPtr->WININ = 63; + sTransitionStructPtr->WINOUT = 0; + sTransitionStructPtr->WIN0V = 160; + + for (i = 0; i < 0xA0; i++) + { + gUnknown_02038C28[1][i] = sTransitionStructPtr->field_14; + gUnknown_02038C28[1][0xA0 + i] = 0xF0; + gUnknown_02038C28[0][i] = sTransitionStructPtr->field_14; + gUnknown_02038C28[0][0xA0 + i] = 0xF0; + gUnknown_02038C28[0][0x140 + i] = 0; + gUnknown_02038C28[0][0x1E0 + i] = 0x100; + gUnknown_02038C28[0][0x280 + i] = 1; + } + + task->data[4] = 0; + task->data[5] = 0; + task->data[6] = 7; + + EnableInterrupts(INTR_FLAG_HBLANK); + + SetVBlankCallback(VBlankCB_Phase2_Slice); + SetHBlankCallback(HBlankCB_Phase2_Slice); + + task->tState++; + return TRUE; +} + +bool8 Phase2_25_Func2(struct Task *task) +{ + u16 i, j, k; + u8 arr1[ARRAY_COUNT(gUnknown_085C8C64)]; + s16 arr2[ARRAY_COUNT(gUnknown_085C8C66)]; + u8 var; + u16 *ptr4, *ptr3, *ptr1, *ptr2; + s16 unkVar; + + memcpy(arr1, gUnknown_085C8C64, sizeof(arr1)); + memcpy(arr2, gUnknown_085C8C66, sizeof(arr2)); + + sTransitionStructPtr->VBlank_DMA = FALSE; + var = 0; + + for (i = 0; i <= task->data[5]; i++) + { + for (j = 0; j < 2; j++) + { + for (k = 0; k < 2; k++) + { + unkVar = (arr1[j]) + (arr2[k] * -(i) * 2); + if (unkVar >= 0 && (unkVar != 79 || j != 1)) + { + ptr4 = &gUnknown_02038C28[0][unkVar + 320]; + ptr3 = &gUnknown_02038C28[0][unkVar + 480]; + ptr1 = &gUnknown_02038C28[0][unkVar + 640]; + if (*ptr4 > 0xEF) + { + *ptr4 = 0xF0; + var++; + } + else + { + *ptr4 += (*ptr3 >> 8); + if (*ptr1 <= 0x7F) + *ptr1 *= 2; + if (*ptr3 <= 0xFFF) + *ptr3 += *ptr1; + } + ptr2 = &gUnknown_02038C28[0][unkVar]; + ptr3 = &gUnknown_02038C28[0][unkVar + 160]; + *ptr2 = sTransitionStructPtr->field_14 + *ptr4; + *ptr3 = 0xF0 - *ptr4; + + if (i == 0) + break; + } + } + } + + for (j = 0; j < 2; j++) + { + for (k = 0; k < 2; k++) + { + unkVar = (arr1[j] + 1) + (arr2[k] * -(i) * 2); + if (unkVar <= 160 && (unkVar != 80 || j != 1)) + { + ptr4 = &gUnknown_02038C28[0][unkVar + 320]; + ptr3 = &gUnknown_02038C28[0][unkVar + 480]; + ptr1 = &gUnknown_02038C28[0][unkVar + 640]; + if (*ptr4 > 0xEF) + { + *ptr4 = 0xF0; + var++; + } + else + { + *ptr4 += (*ptr3 >> 8); + if (*ptr1 <= 0x7F) + *ptr1 *= 2; + if (*ptr3 <= 0xFFF) + *ptr3 += *ptr1; + } + ptr2 = &gUnknown_02038C28[0][unkVar]; + ptr3 = &gUnknown_02038C28[0][unkVar + 160]; + *ptr2 = sTransitionStructPtr->field_14 - *ptr4; + *ptr3 = (*ptr4 << 8) | (0xF1); + + if (i == 0) + break; + } + } + } + } + + if (--task->data[4] < 0) + task->data[4] = 0; + if (task->data[4] <= 0 && task->data[5] + 1 <= 20) + task->data[4] = task->data[6], task->data[5]++; + if (var > 0x9F) + task->tState++; + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_25_Func3(struct Task *task) +{ + u16 i; + bool32 done = TRUE; + u16 checkVar2 = 0xFF10; + + for (i = 0; i < 0xA0; i++) + { + if (gUnknown_02038C28[1][i] != 0xF0 && gUnknown_02038C28[1][i] != checkVar2) + done = FALSE; // a break statement should be put here + } + + if (done == TRUE) + task->tState++; + + return FALSE; +} + +bool8 Phase2_25_Func4(struct Task *task) +{ + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(Phase2Task_25)); + return FALSE; +} + +void Phase2Task_Blackhole1(u8 taskId) +{ + while (sPhase2_Blackhole1_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_Blackhole2(u8 taskId) +{ + while (sPhase2_Blackhole2_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Blackhole_Func1(struct Task *task) +{ + s32 i; + + sub_8149F08(); + dp12_8087EA4(); + + sTransitionStructPtr->WININ = 0; + sTransitionStructPtr->WINOUT = 63; + sTransitionStructPtr->field_6 = 240; + sTransitionStructPtr->WIN0V = 160; + + for (i = 0; i < 0xA0; i++) + { + gUnknown_02038C28[1][i] = 0; + } + + SetVBlankCallback(VBlankCB1_Phase2_BigPokeball); + + task->tState++; + task->data[1] = 1; + task->data[2] = 0x100; + task->data[7] = 0; + + return FALSE; +} + +bool8 Phase2_Blackhole1_Func3(struct Task *task) +{ + if (task->data[7] == 1) + { + DmaStop(0); + SetVBlankCallback(NULL); + DestroyTask(FindTaskIdByFunc(task->func)); + } + else + { + sTransitionStructPtr->VBlank_DMA = FALSE; + if (task->data[2] < 0x400) + task->data[2] += 0x80; + if (task->data[1] < 0xA0) + task->data[1] += (task->data[2] >> 8); + if (task->data[1] > 0xA0) + task->data[1] = 0xA0; + sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->data[1]); + if (task->data[1] == 0xA0) + { + task->data[7] = 1; + sub_8149F84(); + } + else + { + sTransitionStructPtr->VBlank_DMA++; + } + } + + return FALSE; +} + +bool8 Phase2_Blackhole1_Func2(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = FALSE; + if (task->data[7] == 0) + { + task->data[7]++; + task->data[1] = 0x30; + task->data[6] = 0; + } + task->data[1] += gUnknown_085C8C80[task->data[6]]; + task->data[6] = (task->data[6] + 1) % 2; + sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->data[1]); + if (task->data[1] < 9) + { + task->tState++; + task->data[7] = 0; + } + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Blackhole2_Func2(struct Task *task) +{ + u16 index; // should be s16 I think + s16 amplitude; + + sTransitionStructPtr->VBlank_DMA = FALSE; + if (task->data[7] == 0) + { + task->data[7]++; + task->data[5] = 2; + task->data[6] = 2; + } + if (task->data[1] > 0xA0) + task->data[1] = 0xA0; + + sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->data[1]); + if (task->data[1] == 0xA0) + { + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(task->func)); + } + + index = task->data[5]; + if ((task->data[5] & 0xFF) <= 128) + { + amplitude = task->data[6]; + task->data[5] += 8; + } + else + { + amplitude = task->data[6] - 1; + task->data[5] += 16; + } + task->data[1] += Sin(index & 0xFF, amplitude); + + if (task->data[1] <= 0) + task->data[1] = 1; + if (task->data[5] > 0xFE) + task->data[5] >>= 8, task->data[6]++; + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +void Phase2Task_RectangularSpiral(u8 taskId) +{ + while (sPhase2_RectangularSpiral_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_RectangularSpiral_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + CpuCopy16(sShrinkingBoxTileset, dst2, 0x20); + CpuCopy16(sShrinkingBoxTileset + 0x70, dst2 + 0x20, 0x20); + CpuFill16(0xF000, dst1, 0x800); + LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); + + task->data[3] = 1; + task->tState++; + + sRectangularSpiralTransition[0].field_0 = 0; + sRectangularSpiralTransition[0].field_2 = -1; + sRectangularSpiralTransition[0].field_4 = 1; + sRectangularSpiralTransition[0].field_6 = 308; + sRectangularSpiralTransition[0].field_8 = 0; + + sRectangularSpiralTransition[1].field_0 = 0; + sRectangularSpiralTransition[1].field_2 = -1; + sRectangularSpiralTransition[1].field_4 = 1; + sRectangularSpiralTransition[1].field_6 = 308; + sRectangularSpiralTransition[1].field_8 = 0; + + sRectangularSpiralTransition[2].field_0 = 0; + sRectangularSpiralTransition[2].field_2 = -3; + sRectangularSpiralTransition[2].field_4 = 1; + sRectangularSpiralTransition[2].field_6 = 307; + sRectangularSpiralTransition[2].field_8 = 0; + + sRectangularSpiralTransition[3].field_0 = 0; + sRectangularSpiralTransition[3].field_2 = -3; + sRectangularSpiralTransition[3].field_4 = 1; + sRectangularSpiralTransition[3].field_6 = 307; + sRectangularSpiralTransition[3].field_8 = 0; + + return FALSE; +} + +bool8 Phase2_RectangularSpiral_Func2(struct Task *task) +{ + u16 *dst1, *dst2; + u8 i; + u16 j; + bool32 done = TRUE; + + sub_8149F58(&dst1, &dst2); + + for (i = 0; i < 2; i++) + { + for (j = 0; j < ARRAY_COUNT(sRectangularSpiralTransition); j++) + { + s16 var = 0, var2 = 0; + s32 var3 = 0; + + if (sub_8149048(gUnknown_085C8D38[j / 2], &sRectangularSpiralTransition[j])) + { + u32 one; + done = FALSE; + var = sRectangularSpiralTransition[j].field_2; + one = 1; + if ((j & 1) == one) + var = 0x27D - var; + + var2 = var % 32; + var3 = var / 32 * 32; + + dst1[var3 + var2] = 0xF002; + } + } + } + + if (done == TRUE) + task->tState++; + return FALSE; +} + +bool8 Phase2_RectangularSpiral_Func3(struct Task *task) +{ + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(task->func)); + return FALSE; +} + +bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1) +{ + const s16 *array = arg0[arg1->field_0]; + if (array[arg1->field_4] == -1) + return FALSE; + + // ?? + sUnusedRectangularSpiralVar = array[0]; + sUnusedRectangularSpiralVar = array[1]; + sUnusedRectangularSpiralVar = array[2]; + sUnusedRectangularSpiralVar = array[3]; + + switch (array[0]) + { + case 1: + arg1->field_2 += 0x1; + break; + case 2: + arg1->field_2 -= 0x1; + break; + case 3: + arg1->field_2 -= 0x20; + break; + case 4: + arg1->field_2 += 0x20; + break; + } + + if (arg1->field_2 > 0x27F || array[arg1->field_4] == -1) + return FALSE; + + if (arg1->field_8 == 0 && array[arg1->field_4] == -2) + { + arg1->field_8 = 1; + arg1->field_4 = 1; + arg1->field_2 = arg1->field_6; + arg1->field_0 = 4; + } + + if (arg1->field_2 == array[arg1->field_4]) + { + (arg1->field_0)++; + if (arg1->field_8 == 1) + { + if (arg1->field_0 > 7) + { + (arg1->field_4)++; + (arg1->field_0) = 4; + } + } + else + { + if (arg1->field_0 > 3) + { + (arg1->field_4)++; + (arg1->field_0) = 0; + } + } + } + + return TRUE; +} + +void Phase2Task_Groudon(u8 taskId) +{ + while (sPhase2_Groudon_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Groudon_Func3(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + LZ77UnCompVram(gUnknown_085BE51C, dst2); + LZ77UnCompVram(gUnknown_085BEA88, dst1); + + task->tState++; + task->data[1] = 0; + return FALSE; +} + +bool8 Phase2_Groudon_Func4(struct Task *task) +{ + if (task->data[1] % 3 == 0) + { + u16 var = (task->data[1] % 30) / 3; + LoadPalette(gUnknown_085BF0A0 + (var * 16), 0xF0, 0x20); + } + if (++task->data[1] > 58) + { + task->tState++; + task->data[1] = 0; + } + + return FALSE; +} + +bool8 Phase2_Groudon_Func5(struct Task *task) +{ + if (task->data[1] % 5 == 0) + { + s16 var = task->data[1] / 5; + LoadPalette(gUnknown_085BF2A0 + (var * 16), 0xF0, 0x20); + } + if (++task->data[1] > 68) + { + task->tState++; + task->data[1] = 0; + task->tFrames = 30; + } + + return FALSE; +} + -- cgit v1.2.3 From fdbe7fa7de9b2e1f8a22efca87201901fcea32b4 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 14 Jan 2018 20:45:44 +0100 Subject: up to 30 battle transitions --- src/battle_transition.c | 1664 ++++++++++++++++++++++++++++++++++++++++------- src/tileset_anims.c | 5 +- 2 files changed, 1443 insertions(+), 226 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 04f48b126..def302889 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -7,6 +7,7 @@ #include "palette.h" #include "trig.h" #include "field_effect.h" +#include "field_camera.h" #include "random.h" #include "sprite.h" #include "sound.h" @@ -56,6 +57,8 @@ typedef bool8 (*TransitionSpriteCallback)(struct Sprite *sprite); extern u16 gUnknown_020393A8[]; extern u16 gUnknown_02038C28[][0x3C0]; +extern const struct OamData gFieldObjectBaseOam_32x32; + extern void c2_exit_to_overworld_2_switch(void); extern void sub_80AC3D0(void); extern void dp12_8087EA4(void); @@ -89,7 +92,7 @@ void Phase2Task_Regirock(u8 taskId); void Phase2Task_Kyogre(u8 taskId); void Phase2Task_Groudon(u8 taskId); void Phase2Task_Rayquaza(u8 taskId); -void Phase2Task_25(u8 taskId); +void Phase2Task_ShredSplit(u8 taskId); void Phase2Task_Blackhole1(u8 taskId); void Phase2Task_Blackhole2(u8 taskId); void Phase2Task_RectangularSpiral(u8 taskId); @@ -108,6 +111,8 @@ void VBlankCB1_Phase2_BigPokeball(void); void VBlankCB_Phase2_Clockwise_BlackFade(void); void VBlankCB_Phase2_Ripple(void); void HBlankCB_Phase2_Ripple(void); +void VBlankCB_Phase2_30(void); +void HBlankCB_Phase2_30(void); void VBlankCB_Phase2_Wave(void); void VBlankCB_Phase2_Slice(void); void HBlankCB_Phase2_Slice(void); @@ -115,6 +120,7 @@ void VBlankCB0_Phase2_WhiteFade(void); void VBlankCB1_Phase2_WhiteFade(void); void HBlankCB_Phase2_WhiteFade(void); void VBlankCB_Phase2_Shards(void); +void VBlankCB_Phase2_Rayquaza(void); bool8 Phase2_Blur_Func1(struct Task *task); bool8 Phase2_Blur_Func2(struct Task *task); bool8 Phase2_Blur_Func3(struct Task *task); @@ -178,10 +184,10 @@ bool8 Phase2_Shards_Func2(struct Task *task); bool8 Phase2_Shards_Func3(struct Task *task); bool8 Phase2_Shards_Func4(struct Task *task); bool8 Phase2_Shards_Func5(struct Task *task); -bool8 Phase2_25_Func1(struct Task *task); -bool8 Phase2_25_Func2(struct Task *task); -bool8 Phase2_25_Func3(struct Task *task); -bool8 Phase2_25_Func4(struct Task *task); +bool8 Phase2_ShredSplit_Func1(struct Task *task); +bool8 Phase2_ShredSplit_Func2(struct Task *task); +bool8 Phase2_ShredSplit_Func3(struct Task *task); +bool8 Phase2_ShredSplit_Func4(struct Task *task); bool8 Phase2_Blackhole_Func1(struct Task *task); bool8 Phase2_Blackhole1_Func2(struct Task *task); bool8 Phase2_Blackhole1_Func3(struct Task *task); @@ -189,6 +195,32 @@ bool8 Phase2_Blackhole2_Func2(struct Task *task); bool8 Phase2_RectangularSpiral_Func1(struct Task *task); bool8 Phase2_RectangularSpiral_Func2(struct Task *task); bool8 Phase2_RectangularSpiral_Func3(struct Task *task); +bool8 Phase2_29_Func1(struct Task *task); +bool8 Phase2_29_Func2(struct Task *task); +bool8 Phase2_30_Func1(struct Task *task); +bool8 Phase2_30_Func2(struct Task *task); +bool8 Phase2_30_Func3(struct Task *task); +bool8 Phase2_30_Func4(struct Task *task); +bool8 Phase2_Rayquaza_Func3(struct Task *task); +bool8 Phase2_Rayquaza_Func4(struct Task *task); +bool8 Phase2_Rayquaza_Func5(struct Task *task); +bool8 Phase2_Rayquaza_Func6(struct Task *task); +bool8 Phase2_Rayquaza_Func7(struct Task *task); +bool8 Phase2_Rayquaza_Func8(struct Task *task); +bool8 Phase2_Rayquaza_Func9(struct Task *task); +bool8 Phase2_31_Func1(struct Task *task); +bool8 Phase2_31_Func2(struct Task *task); +bool8 Phase2_31_Func3(struct Task *task); +bool8 Phase2_31_33_Func5(struct Task *task); +bool8 Phase2_33_Func1(struct Task *task); +bool8 Phase2_33_Func2(struct Task *task); +bool8 Phase2_33_Func3(struct Task *task); +bool8 Phase2_33_Func4(struct Task *task); +bool8 Phase2_32_Func1(struct Task *task); +bool8 Phase2_32_Func2(struct Task *task); +bool8 Phase2_32_Func3(struct Task *task); +bool8 Phase2_32_Func4(struct Task *task); +bool8 Phase2_32_Func5(struct Task *task); bool8 Phase2_Mugshot_Func1(struct Task *task); bool8 Phase2_Mugshot_Func2(struct Task *task); bool8 Phase2_Mugshot_Func3(struct Task *task); @@ -214,15 +246,19 @@ void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); void sub_814A014(u16 *a0, s16 a1, s16 a2, s16 a3); void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize); void sub_8149F58(u16 **a0, u16 **a1); +void sub_8149F40(u16 **a0); void sub_814A1AC(s16 *a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); bool8 sub_814A228(s16 *a0, bool8 a1, bool8 a2); void sub_8148484(s16 spriteId, s16 value); void sub_814849C(s16 spriteId); s16 sub_81484B8(s16 spriteId); +bool8 Phase1_TransitionAll_Func1(struct Task *task); +bool8 Phase1_TransitionAll_Func2(struct Task *task); bool8 IsPhase1Done(void); bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1); void sub_814713C(struct Sprite *sprite); void sub_8148380(struct Sprite *sprite); +void sub_8149864(struct Sprite *sprite); bool8 sub_81483A8(struct Sprite *sprite); bool8 sub_81483AC(struct Sprite *sprite); bool8 sub_81483F8(struct Sprite *sprite); @@ -236,15 +272,15 @@ IWRAM_DATA static u8 sTestingTransitionState; IWRAM_DATA static struct StructRectangularSpiral sRectangularSpiralTransition[4]; // ewram vars -EWRAM_DATA struct TransitionData *sTransitionStructPtr = NULL; +EWRAM_DATA static struct TransitionData *sTransitionStructPtr = NULL; // const rom data const u32 sBigPokeball_Tileset[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp"); const u32 sPokeballTrail_Tileset[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp"); -const u32 sSpriteImage_85B98F0[] = INCBIN_U32("graphics/battle_transitions/pokeball.4bpp"); +const u8 sSpriteImage_85B98F0[] = INCBIN_U8("graphics/battle_transitions/pokeball.4bpp"); const u32 sUnknown_085B9AF0[] = INCBIN_U32("graphics/battle_transitions/elite_four_bg.4bpp"); -const u32 sSpriteImage_85B9CD0[] = INCBIN_U32("graphics/battle_transitions/unused_brendan.4bpp"); -const u32 sSpriteImage_85BA4D0[] = INCBIN_U32("graphics/battle_transitions/unused_lass.4bpp"); +const u8 sSpriteImage_85B9CD0[] = INCBIN_U8("graphics/battle_transitions/unused_brendan.4bpp"); +const u8 sSpriteImage_85BA4D0[] = INCBIN_U8("graphics/battle_transitions/unused_lass.4bpp"); const u32 sShrinkingBoxTileset[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); const u32 sEvilTeam_Palette[] = INCBIN_U32("graphics/battle_transitions/evil_team.gbapal"); const u32 sTeamAqua_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_aqua.4bpp.lz"); @@ -312,7 +348,7 @@ const TaskFunc sPhase2_Tasks[B_TRANSITION_COUNT] = Phase2Task_Kyogre, // 22 Phase2Task_Groudon, // 23 Phase2Task_Rayquaza, // 24 - Phase2Task_25, // 25 + Phase2Task_ShredSplit, // 25 Phase2Task_Blackhole1, // 26 Phase2Task_Blackhole2, // 27 Phase2Task_RectangularSpiral, // 28 @@ -527,12 +563,12 @@ const TransitionStateFunc sPhase2_Slice_Funcs[] = Phase2_Slice_Func3 }; -const TransitionStateFunc sPhase2_25_Funcs[] = +const TransitionStateFunc sPhase2_ShredSplit_Funcs[] = { - Phase2_25_Func1, - Phase2_25_Func2, - Phase2_25_Func3, - Phase2_25_Func4 + Phase2_ShredSplit_Func1, + Phase2_ShredSplit_Func2, + Phase2_ShredSplit_Func3, + Phase2_ShredSplit_Func4 }; const u8 gUnknown_085C8C64[] = {39, 119}; @@ -619,12 +655,257 @@ const TransitionStateFunc sPhase2_Groudon_Funcs[] = Phase2_WeatherDuo_Func7 }; -extern const u16 gFieldEffectObjectPalette10[]; -extern const u16 sBigPokeball_Tilemap[]; -extern const u16 sMugshotsTilemap[]; -extern const struct SpriteTemplate gUnknown_085C8E68; -extern const u16 *const sOpponentMugshotsPals[MUGSHOTS_COUNT]; -extern const u16 *const sPlayerMugshotsPals[2]; +const TransitionStateFunc sPhase2_Rayquaza_Funcs[] = +{ + Phase2_WeatherTrio_Func1, + Phase2_WaitPaletteFade, + Phase2_Rayquaza_Func3, + Phase2_Rayquaza_Func4, + Phase2_Rayquaza_Func5, + Phase2_Rayquaza_Func6, + Phase2_Rayquaza_Func7, + Phase2_Rayquaza_Func8, + Phase2_Rayquaza_Func9, + Phase2_Blackhole1_Func2, + Phase2_Blackhole1_Func3 +}; + +const TransitionStateFunc sPhase2_WhiteFade_Funcs[] = +{ + Phase2_WhiteFade_Func1, + Phase2_WhiteFade_Func2, + Phase2_WhiteFade_Func3, + Phase2_WhiteFade_Func4, + Phase2_WhiteFade_Func5 +}; + +const s16 sUnknown_085C8DA0[] = {0, 20, 15, 40, 10, 25, 35, 5}; + +const TransitionStateFunc sPhase2_GridSquares_Funcs[] = +{ + Phase2_GridSquares_Func1, + Phase2_GridSquares_Func2, + Phase2_GridSquares_Func3 +}; + +const TransitionStateFunc sPhase2_Shards_Funcs[] = +{ + Phase2_Shards_Func1, + Phase2_Shards_Func2, + Phase2_Shards_Func3, + Phase2_Shards_Func4, + Phase2_Shards_Func5 +}; + +const s16 sUnknown_085C8DD0[][5] = +{ + {56, 0, 0, 160, 0}, + {104, 160, 240, 88, 1}, + {240, 72, 56, 0, 1}, + {0, 32, 144, 160, 0}, + {144, 160, 184, 0, 1}, + {56, 0, 168, 160, 0}, + {168, 160, 48, 0, 1}, +}; + +const s16 sUnknown_085C8E16[] = {8, 4, 2, 1, 1, 1, 0}; + +const TransitionStateFunc sPhase1_TransitionAll_Funcs[] = +{ + Phase1_TransitionAll_Func1, + Phase1_TransitionAll_Func2 +}; + +const struct SpriteFrameImage sSpriteImageTable_85C8E2C[] = +{ + sSpriteImage_85B98F0, 0x200 +}; + +const union AnimCmd sSpriteAnim_85C8E34[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END +}; + +const union AnimCmd *const sSpriteAnimTable_85C8E3C[] = +{ + sSpriteAnim_85C8E34 +}; + +const union AffineAnimCmd sSpriteAffineAnim_85C8E40[] = +{ + AFFINEANIMCMD_FRAME(0, 0, -4, 1), + AFFINEANIMCMD_JUMP(0) +}; + +const union AffineAnimCmd sSpriteAffineAnim_85C8E50[] = +{ + AFFINEANIMCMD_FRAME(0, 0, 4, 1), + AFFINEANIMCMD_JUMP(0) +}; + +const union AffineAnimCmd *const sSpriteAffineAnimTable_85C8E60[] = +{ + sSpriteAffineAnim_85C8E40, + sSpriteAffineAnim_85C8E50 +}; + +const struct SpriteTemplate gUnknown_085C8E68 = +{ + .tileTag = 0xFFFF, + .paletteTag = 4105, + .oam = &gFieldObjectBaseOam_32x32, + .anims = sSpriteAnimTable_85C8E3C, + .images = sSpriteImageTable_85C8E2C, + .affineAnims = sSpriteAffineAnimTable_85C8E60, + .callback = sub_814713C +}; + +const struct OamData gOamData_85C8E80 = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 3, + .tileNum = 0, + .priority = 0, + .paletteNum = 0, + .affineParam = 0, +}; + +const struct SpriteFrameImage sSpriteImageTable_85C8E88[] = +{ + sSpriteImage_85B9CD0, 0x800 +}; + +const struct SpriteFrameImage sSpriteImageTable_85C8E90[] = +{ + sSpriteImage_85BA4D0, 0x800 +}; + +const union AnimCmd sSpriteAnim_85C8E98[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END +}; + +const union AnimCmd *const sSpriteAnimTable_85C8EA0[] = +{ + sSpriteAnim_85C8E98 +}; + +const struct SpriteTemplate sSpriteTemplate_85C8EA4 = +{ + .tileTag = 0xFFFF, + .paletteTag = 4106, + .oam = &gOamData_85C8E80, + .anims = sSpriteAnimTable_85C8EA0, + .images = sSpriteImageTable_85C8E88, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_8148380 +}; + +const struct SpriteTemplate sSpriteTemplate_85C8EBC = +{ + .tileTag = 0xFFFF, + .paletteTag = 4106, + .oam = &gOamData_85C8E80, + .anims = sSpriteAnimTable_85C8EA0, + .images = sSpriteImageTable_85C8E90, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_8148380 +}; + +const u16 gFieldEffectObjectPalette10[] = INCBIN_U16("graphics/map_objects/palettes/field_effect_object_palette_10.gbapal"); + +const struct SpritePalette gFieldEffectObjectPaletteInfo10 = +{ + gFieldEffectObjectPalette10, 0x1009 +}; + +const u16 sMugshotPal_Sydney[] = INCBIN_U16("graphics/battle_transitions/sidney_bg.gbapal"); +const u16 sMugshotPal_Phoebe[] = INCBIN_U16("graphics/battle_transitions/phoebe_bg.gbapal"); +const u16 sMugshotPal_Glacia[] = INCBIN_U16("graphics/battle_transitions/glacia_bg.gbapal"); +const u16 sMugshotPal_Drake[] = INCBIN_U16("graphics/battle_transitions/drake_bg.gbapal"); +const u16 sMugshotPal_Champion[] = INCBIN_U16("graphics/battle_transitions/wallace_bg.gbapal"); +const u16 sMugshotPal_Brendan[] = INCBIN_U16("graphics/battle_transitions/brendan_bg.gbapal"); +const u16 sMugshotPal_May[] = INCBIN_U16("graphics/battle_transitions/may_bg.gbapal"); + +const u16 *const sOpponentMugshotsPals[MUGSHOTS_COUNT] = +{ + sMugshotPal_Sydney, + sMugshotPal_Phoebe, + sMugshotPal_Glacia, + sMugshotPal_Drake, + sMugshotPal_Champion +}; + +const u16 *const sPlayerMugshotsPals[2] = +{ + sMugshotPal_Brendan, + sMugshotPal_May +}; + +const u16 sUnusedTrainerPalette[] = INCBIN_U16("graphics/battle_transitions/unused_trainer.gbapal"); +const struct SpritePalette sSpritePalette_UnusedTrainer = +{ + sUnusedTrainerPalette, 0x100A +}; + +const u16 sBigPokeball_Tilemap[] = INCBIN_U16("graphics/battle_transitions/big_pokeball_map.bin"); +const u16 sMugshotsTilemap[] = INCBIN_U16("graphics/battle_transitions/elite_four_bg_map.bin"); + +const TransitionStateFunc sPhase2_29_Funcs[] = +{ + Phase2_29_Func1, + Phase2_29_Func2, + Phase2_BigPokeball_Func3, + Phase2_BigPokeball_Func4, + Phase2_BigPokeball_Func5, + Phase2_BigPokeball_Func6 +}; + +const TransitionStateFunc sPhase2_30_Funcs[] = +{ + Phase2_30_Func1, + Phase2_30_Func2, + Phase2_30_Func3, + Phase2_30_Func4 +}; + +const TransitionStateFunc sPhase2_31_Funcs[] = +{ + Phase2_31_Func1, + Phase2_31_Func2, + Phase2_31_Func3, + Phase2_31_33_Func5 +}; + +const TransitionStateFunc sPhase2_33_Funcs[] = +{ + Phase2_33_Func1, + Phase2_33_Func2, + Phase2_33_Func3, + Phase2_33_Func4, + Phase2_31_33_Func5 +}; + +const TransitionStateFunc sPhase2_32_Funcs[] = +{ + Phase2_32_Func1, + Phase2_32_Func2, + Phase2_32_Func3, + Phase2_32_Func4, + Phase2_32_Func5 +}; + +const u8 gUnknown_085C9A30[] = {0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x1b, 0x14, 0x0d, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0e, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x13, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x0f, 0x10, 0x11, 0x12}; +const u8 gUnknown_085C9A53[] = {0x00, 0x10, 0x29, 0x16, 0x2c, 0x02, 0x2b, 0x15, 0x2e, 0x1b, 0x09, 0x30, 0x26, 0x05, 0x39, 0x3b, 0x0c, 0x3f, 0x23, 0x1c, 0x0a, 0x35, 0x07, 0x31, 0x27, 0x17, 0x37, 0x01, 0x3e, 0x11, 0x3d, 0x1e, 0x06, 0x22, 0x0f, 0x33, 0x20, 0x3a, 0x0d, 0x2d, 0x25, 0x34, 0x0b, 0x18, 0x3c, 0x13, 0x38, 0x21, 0x1d, 0x32, 0x28, 0x36, 0x0e, 0x03, 0x2f, 0x14, 0x12, 0x19, 0x04, 0x24, 0x1a, 0x2a, 0x1f, 0x08, 0x00}; // code static void CB2_TestBattleTransition(void) @@ -667,9 +948,11 @@ void BattleTransition_Start(u8 transitionId) LaunchBattleTransitionTask(transitionId); } -// main task that launches sub-tasks for phase1 and phase2 +// in all tasks data[0] is reserved for the state #define tState data[0] -#define tTransitionID data[1] + +// main task that launches sub-tasks for phase1 and phase2 +#define tTransitionId data[1] #define tTransitionDone data[15] bool8 IsBattleTransitionDone(void) @@ -690,7 +973,7 @@ bool8 IsBattleTransitionDone(void) void LaunchBattleTransitionTask(u8 transitionId) { u8 taskId = CreateTask(Task_BattleTransitionMain, 2); - gTasks[taskId].tTransitionID = transitionId; + gTasks[taskId].tTransitionId = transitionId; sTransitionStructPtr = AllocZeroed(sizeof(*sTransitionStructPtr)); } @@ -703,9 +986,9 @@ bool8 Transition_Phase1(struct Task *task) { sub_80AC3D0(); CpuCopy32(gPlttBufferFaded, gPlttBufferUnfaded, 0x400); - if (sPhase1_Tasks[task->tTransitionID] != NULL) + if (sPhase1_Tasks[task->tTransitionId] != NULL) { - CreateTask(sPhase1_Tasks[task->tTransitionID], 4); + CreateTask(sPhase1_Tasks[task->tTransitionId], 4); task->tState++; return FALSE; } @@ -718,7 +1001,7 @@ bool8 Transition_Phase1(struct Task *task) bool8 Transition_WaitForPhase1(struct Task *task) { - if (FindTaskIdByFunc(sPhase1_Tasks[task->tTransitionID]) == 0xFF) + if (FindTaskIdByFunc(sPhase1_Tasks[task->tTransitionId]) == 0xFF) { task->tState++; return TRUE; @@ -731,7 +1014,7 @@ bool8 Transition_WaitForPhase1(struct Task *task) bool8 Transition_Phase2(struct Task *task) { - CreateTask(sPhase2_Tasks[task->tTransitionID], 0); + CreateTask(sPhase2_Tasks[task->tTransitionId], 0); task->tState++; return FALSE; } @@ -739,18 +1022,14 @@ bool8 Transition_Phase2(struct Task *task) bool8 Transition_WaitForPhase2(struct Task *task) { task->tTransitionDone = FALSE; - if (FindTaskIdByFunc(sPhase2_Tasks[task->tTransitionID]) == 0xFF) + if (FindTaskIdByFunc(sPhase2_Tasks[task->tTransitionId]) == 0xFF) task->tTransitionDone = TRUE; return FALSE; } -#undef tState -#undef tTransitionID +#undef tTransitionId #undef tTransitionDone -// sub-task for phase1 -#define tState data[0] - void Phase1Task_TransitionAll(u8 taskId) { if (gTasks[taskId].tState == 0) @@ -764,10 +1043,14 @@ void Phase1Task_TransitionAll(u8 taskId) } } -#undef tState - // sub-task for phase2 -#define tState data[0] +#define tData1 data[1] +#define tData2 data[2] +#define tData3 data[3] +#define tData4 data[4] +#define tData5 data[5] +#define tData6 data[6] +#define tFuncState data[7] #define tFrames data[8] #define tOpponentSpriteId data[13] #define tPlayerSpriteId data[14] @@ -790,17 +1073,17 @@ bool8 Phase2_Blur_Func1(struct Task *task) bool8 Phase2_Blur_Func2(struct Task *task) { - if (task->data[1] != 0) + if (task->tData1 != 0) { - task->data[1]--; + task->tData1--; } else { - task->data[1] = 4; - if (++task->data[2] == 10) + task->tData1 = 4; + if (++task->tData2 == 10) BeginNormalPaletteFade(-1, -1, 0, 0x10, 0); - SetGpuReg(REG_OFFSET_MOSAIC, (task->data[2] & 15) * 17); - if (task->data[2] > 14) + SetGpuReg(REG_OFFSET_MOSAIC, (task->tData2 & 15) * 17); + if (task->tData2 > 14) task->tState++; } return FALSE; @@ -840,10 +1123,10 @@ bool8 Phase2_Swirl_Func1(struct Task *task) bool8 Phase2_Swirl_Func2(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; - task->data[1] += 4; - task->data[2] += 8; + task->tData1 += 4; + task->tData2 += 8; - sub_8149F98(gUnknown_02038C28[0], sTransitionStructPtr->field_14, task->data[1], 2, task->data[2], 160); + sub_8149F98(gUnknown_02038C28[0], sTransitionStructPtr->field_14, task->tData1, 2, task->tData2, 160); if (!gPaletteFade.active) { @@ -898,10 +1181,10 @@ bool8 Phase2_Shuffle_Func2(struct Task *task) u16 r3, r4; sTransitionStructPtr->VBlank_DMA = FALSE; - r4 = task->data[1]; - r3 = task->data[2] >> 8; - task->data[1] += 4224; - task->data[2] += 384; + r4 = task->tData1; + r3 = task->tData2 >> 8; + task->tData1 += 4224; + task->tData2 += 384; for (i = 0; i < 160; i++, r4 += 4224) { @@ -973,16 +1256,16 @@ void sub_814669C(struct Task *task) sub_8149F08(); dp12_8087EA4(); - task->data[1] = 16; - task->data[2] = 0; - task->data[4] = 0; - task->data[5] = 0x4000; + task->tData1 = 16; + task->tData2 = 0; + task->tData4 = 0; + task->tData5 = 0x4000; sTransitionStructPtr->WININ = 63; sTransitionStructPtr->WINOUT = 0; sTransitionStructPtr->field_6 = 240; sTransitionStructPtr->WIN0V = 160; sTransitionStructPtr->BLDCNT = 0x3F41; - sTransitionStructPtr->BLDALPHA = (task->data[1] << 8) | (task->data[2]); + sTransitionStructPtr->BLDALPHA = (task->tData1 << 8) | (task->tData2); for (i = 0; i < 160; i++) { @@ -1065,7 +1348,7 @@ bool8 Phase2_BigPokeball_Func2(struct Task *task) dst1[i * 32 + j] = *BigPokeballMap | 0xF000; } } - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160); task->tState++; return TRUE; @@ -1077,7 +1360,7 @@ bool8 Phase2_Aqua_Func2(struct Task *task) sub_8149F58(&dst1, &dst2); LZ77UnCompVram(sTeamAqua_Tilemap, dst1); - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160); task->tState++; return FALSE; @@ -1089,7 +1372,7 @@ bool8 Phase2_Magma_Func2(struct Task *task) sub_8149F58(&dst1, &dst2); LZ77UnCompVram(sTeamMagma_Tilemap, dst1); - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160); task->tState++; return FALSE; @@ -1102,7 +1385,7 @@ bool8 Phase2_Regice_Func2(struct Task *task) sub_8149F58(&dst1, &dst2); LoadPalette(gUnknown_085BC2B4, 0xF0, 0x20); CpuCopy16(gUnknown_085BC314, dst1, 0x500); - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160); task->tState++; return FALSE; @@ -1115,7 +1398,7 @@ bool8 Phase2_Registeel_Func2(struct Task *task) sub_8149F58(&dst1, &dst2); LoadPalette(gUnknown_085BC2D4, 0xF0, 0x20); CpuCopy16(gUnknown_085BCB14, dst1, 0x500); - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160); task->tState++; return FALSE; @@ -1128,7 +1411,7 @@ bool8 Phase2_Regirock_Func2(struct Task *task) sub_8149F58(&dst1, &dst2); LoadPalette(gUnknown_085BC2F4, 0xF0, 0x20); CpuCopy16(gUnknown_085BD314, dst1, 0x500); - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5], 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160); task->tState++; return FALSE; @@ -1149,16 +1432,16 @@ bool8 Phase2_Kyogre_Func3(struct Task *task) bool8 Phase2_Kyogre_Func4(struct Task *task) { - if (task->data[1] % 3 == 0) + if (task->tData1 % 3 == 0) { - u16 var = task->data[1] % 30; + u16 var = task->tData1 % 30; var /= 3; LoadPalette(gUnknown_085BEDA0 + (var * 16), 0xF0, 0x20); } - if (++task->data[1] > 58) + if (++task->tData1 > 58) { task->tState++; - task->data[1] = 0; + task->tData1 = 0; } return FALSE; @@ -1166,15 +1449,15 @@ bool8 Phase2_Kyogre_Func4(struct Task *task) bool8 Phase2_Kyogre_Func5(struct Task *task) { - if (task->data[1] % 5 == 0) + if (task->tData1 % 5 == 0) { - s16 var = task->data[1] / 5; + s16 var = task->tData1 / 5; LoadPalette(gUnknown_085BEEE0 + (var * 16), 0xF0, 0x20); } - if (++task->data[1] > 68) + if (++task->tData1 > 68) { task->tState++; - task->data[1] = 0; + task->tData1 = 0; task->tFrames = 30; } @@ -1202,18 +1485,18 @@ bool8 Phase2_WeatherDuo_Func7(struct Task *task) bool8 Phase2_BigPokeball_Func3(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; - if (task->data[3] == 0 || --task->data[3] == 0) + if (task->tData3 == 0 || --task->tData3 == 0) { - task->data[2]++; - task->data[3] = 2; + task->tData2++; + task->tData3 = 2; } - sTransitionStructPtr->BLDALPHA = (task->data[1] << 8) | task->data[2]; - if (task->data[2] > 15) + sTransitionStructPtr->BLDALPHA = (task->tData1 << 8) | task->tData2; + if (task->tData2 > 15) task->tState++; - task->data[4] += 8; - task->data[5] -= 256; + task->tData4 += 8; + task->tData5 -= 256; - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160); sTransitionStructPtr->VBlank_DMA++; return FALSE; @@ -1222,18 +1505,18 @@ bool8 Phase2_BigPokeball_Func3(struct Task *task) bool8 Phase2_BigPokeball_Func4(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; - if (task->data[3] == 0 || --task->data[3] == 0) + if (task->tData3 == 0 || --task->tData3 == 0) { - task->data[1]--; - task->data[3] = 2; + task->tData1--; + task->tData3 = 2; } - sTransitionStructPtr->BLDALPHA = (task->data[1] << 8) | task->data[2]; - if (task->data[1] == 0) + sTransitionStructPtr->BLDALPHA = (task->tData1 << 8) | task->tData2; + if (task->tData1 == 0) task->tState++; - task->data[4] += 8; - task->data[5] -= 256; + task->tData4 += 8; + task->tData5 -= 256; - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160); sTransitionStructPtr->VBlank_DMA++; return FALSE; @@ -1242,17 +1525,17 @@ bool8 Phase2_BigPokeball_Func4(struct Task *task) bool8 Phase2_BigPokeball_Func5(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; - task->data[4] += 8; - task->data[5] -= 256; + task->tData4 += 8; + task->tData5 -= 256; - sub_8149F98(gUnknown_02038C28[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160); - if (task->data[5] <= 0) + if (task->tData5 <= 0) { task->tState++; - task->data[1] = 160; - task->data[2] = 256; - task->data[3] = 0; + task->tData1 = 160; + task->tData2 = 256; + task->tData3 = 0; } sTransitionStructPtr->VBlank_DMA++; @@ -1283,16 +1566,16 @@ bool8 Phase2_WaitPaletteFade(struct Task *task) bool8 Phase2_BigPokeball_Func6(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; - if (task->data[2] < 1024) - task->data[2] += 128; - if (task->data[1] != 0) + if (task->tData2 < 1024) + task->tData2 += 128; + if (task->tData1 != 0) { - task->data[1] -= (task->data[2] >> 8); - if (task->data[1] < 0) - task->data[1] = 0; + task->tData1 -= (task->tData2 >> 8); + if (task->tData1 < 0) + task->tData1 = 0; } - sub_814A014(gUnknown_02038C28[0], 120, 80, task->data[1]); - if (task->data[1] == 0) + sub_814A014(gUnknown_02038C28[0], 120, 80, task->tData1); + if (task->tData1 == 0) { SetVBlankCallback(NULL); DmaStop(0); @@ -1301,9 +1584,9 @@ bool8 Phase2_BigPokeball_Func6(struct Task *task) } else { - if (task->data[3] == 0) + if (task->tData3 == 0) { - task->data[3]++; + task->tData3++; SetVBlankCallback(VBlankCB1_Phase2_BigPokeball); } @@ -1673,12 +1956,12 @@ bool8 Phase2_Ripple_Func2(struct Task *task) sTransitionStructPtr->VBlank_DMA = FALSE; - r3 = task->data[2] >> 8; - r4 = task->data[1]; + r3 = task->tData2 >> 8; + r4 = task->tData1; r8 = 384; - task->data[1] += 0x400; - if (task->data[2] <= 0x1FFF) - task->data[2] += 0x180; + task->tData1 += 0x400; + if (task->tData2 <= 0x1FFF) + task->tData2 += 0x180; for (i = 0; i < 160; i++, r4 += r8) { @@ -1688,13 +1971,13 @@ bool8 Phase2_Ripple_Func2(struct Task *task) gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3); } - if (++task->data[3] == 81) + if (++task->tData3 == 81) { - task->data[4]++; + task->tData4++; BeginNormalPaletteFade(-1, -2, 0, 0x10, 0); } - if (task->data[4] != 0 && !gPaletteFade.active) + if (task->tData4 != 0 && !gPaletteFade.active) DestroyTask(FindTaskIdByFunc(Phase2Task_Ripple)); sTransitionStructPtr->VBlank_DMA++; @@ -1752,13 +2035,13 @@ bool8 Phase2_Wave_Func2(struct Task *task) sTransitionStructPtr->VBlank_DMA = FALSE; toStore = gUnknown_02038C28[0]; - r5 = task->data[2]; - task->data[2] += 16; - task->data[1] += 8; + r5 = task->tData2; + task->tData2 += 16; + task->tData1 += 8; for (i = 0, nextFunc = TRUE; i < 160; i++, r5 += 4, toStore++) { - s16 value = task->data[1] + Sin(r5, 40); + s16 value = task->tData1 + Sin(r5, 40); if (value < 0) value = 0; if (value > 240) @@ -1837,9 +2120,9 @@ bool8 Phase2_Mugshot_Func1(struct Task *task) dp12_8087EA4(); Mugshots_CreateOpponentPlayerSprites(task); - task->data[1] = 0; - task->data[2] = 1; - task->data[3] = 239; + task->tData1 = 0; + task->tData2 = 1; + task->tData3 = 239; sTransitionStructPtr->WININ = 63; sTransitionStructPtr->WINOUT = 62; sTransitionStructPtr->WIN0V = 160; @@ -1892,12 +2175,12 @@ bool8 Phase2_Mugshot_Func3(struct Task *task) sTransitionStructPtr->VBlank_DMA = FALSE; toStore = gUnknown_02038C28[0]; - r5 = task->data[1]; - task->data[1] += 0x10; + r5 = task->tData1; + task->tData1 += 0x10; for (i = 0; i < 80; i++, toStore++, r5 += 0x10) { - value = task->data[2] + Sin(r5, 0x10); + value = task->tData2 + Sin(r5, 0x10); if (value < 0) value = 1; if (value > 0xF0) @@ -1906,7 +2189,7 @@ bool8 Phase2_Mugshot_Func3(struct Task *task) } for (; i < 160; i++, toStore++, r5 += 0x10) { - value = task->data[3] - Sin(r5, 0x10); + value = task->tData3 - Sin(r5, 0x10); if (value < 0) value = 0; if (value > 0xEF) @@ -1914,13 +2197,13 @@ bool8 Phase2_Mugshot_Func3(struct Task *task) *toStore = (value << 8) | (0xF0); } - task->data[2] += 8; - task->data[3] -= 8; - if (task->data[2] > 0xF0) - task->data[2] = 0xF0; - if (task->data[3] < 0) - task->data[3] = 0; - mergedValue = *(s32*)(&task->data[2]); + task->tData2 += 8; + task->tData3 -= 8; + if (task->tData2 > 0xF0) + task->tData2 = 0xF0; + if (task->tData3 < 0) + task->tData3 = 0; + mergedValue = *(s32*)(&task->tData2); if (mergedValue == 0xF0) task->tState++; @@ -1943,9 +2226,9 @@ bool8 Phase2_Mugshot_Func4(struct Task *task) } task->tState++; - task->data[1] = 0; - task->data[2] = 0; - task->data[3] = 0; + task->tData1 = 0; + task->tData2 = 0; + task->tData3 = 0; sTransitionStructPtr->field_18 -= 8; sTransitionStructPtr->field_1A += 8; @@ -1985,8 +2268,8 @@ bool8 Phase2_Mugshot_Func6(struct Task *task) SetGpuReg(REG_OFFSET_WIN0H, 0xF0); SetGpuReg(REG_OFFSET_BLDY, 0); task->tState++; - task->data[3] = 0; - task->data[4] = 0; + task->tData3 = 0; + task->tData4 = 0; sTransitionStructPtr->BLDCNT = 0xBF; SetVBlankCallback(VBlankCB1_Phase2_Mugshots); } @@ -2002,15 +2285,15 @@ bool8 Phase2_Mugshot_Func7(struct Task *task) sTransitionStructPtr->field_18 -= 8; sTransitionStructPtr->field_1A += 8; - if (task->data[4] < 0x50) - task->data[4] += 2; - if (task->data[4] > 0x50) - task->data[4] = 0x50; + if (task->tData4 < 0x50) + task->tData4 += 2; + if (task->tData4 > 0x50) + task->tData4 = 0x50; - if (++task->data[3] & 1) + if (++task->tData3 & 1) { s16 i; - for (i = 0, r6 = FALSE; i <= task->data[4]; i++) + for (i = 0, r6 = FALSE; i <= task->tData4; i++) { s16 index1 = 0x50 - i; s16 index2 = 0x50 + i; @@ -2027,7 +2310,7 @@ bool8 Phase2_Mugshot_Func7(struct Task *task) } } - if (task->data[4] == 0x50 && !r6) + if (task->tData4 == 0x50 && !r6) task->tState++; sTransitionStructPtr->VBlank_DMA++; @@ -2039,7 +2322,7 @@ bool8 Phase2_Mugshot_Func8(struct Task *task) sTransitionStructPtr->VBlank_DMA = FALSE; BlendPalettes(-1, 0x10, 0x7FFF); sTransitionStructPtr->BLDCNT = 0xFF; - task->data[3] = 0; + task->tData3 = 0; task->tState++; return TRUE; @@ -2049,9 +2332,9 @@ bool8 Phase2_Mugshot_Func9(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; - task->data[3]++; - memset(gUnknown_02038C28[0], task->data[3], 0x140); - if (task->data[3] > 15) + task->tData3++; + memset(gUnknown_02038C28[0], task->tData3, 0x140); + if (task->tData3 > 15) task->tState++; sTransitionStructPtr->VBlank_DMA++; @@ -2216,8 +2499,8 @@ bool8 Phase2_Slice_Func1(struct Task *task) sub_8149F08(); dp12_8087EA4(); - task->data[2] = 256; - task->data[3] = 1; + task->tData2 = 256; + task->tData3 = 1; sTransitionStructPtr->WININ = 63; sTransitionStructPtr->WINOUT = 0; sTransitionStructPtr->WIN0V = 160; @@ -2245,13 +2528,13 @@ bool8 Phase2_Slice_Func2(struct Task *task) sTransitionStructPtr->VBlank_DMA = FALSE; - task->data[1] += (task->data[2] >> 8); - if (task->data[1] > 0xF0) - task->data[1] = 0xF0; - if (task->data[2] <= 0xFFF) - task->data[2] += task->data[3]; - if (task->data[3] < 128) - task->data[3] <<= 1; // multiplying by two + task->tData1 += (task->tData2 >> 8); + if (task->tData1 > 0xF0) + task->tData1 = 0xF0; + if (task->tData2 <= 0xFFF) + task->tData2 += task->tData3; + if (task->tData3 < 128) + task->tData3 <<= 1; // multiplying by two for (i = 0; i < 160; i++) { @@ -2259,17 +2542,17 @@ bool8 Phase2_Slice_Func2(struct Task *task) u16* storeLoc2 = &gUnknown_02038C28[0][i + 160]; if (1 & i) { - *storeLoc1 = sTransitionStructPtr->field_14 + task->data[1]; - *storeLoc2 = 0xF0 - task->data[1]; + *storeLoc1 = sTransitionStructPtr->field_14 + task->tData1; + *storeLoc2 = 0xF0 - task->tData1; } else { - *storeLoc1 = sTransitionStructPtr->field_14 - task->data[1]; - *storeLoc2 = (task->data[1] << 8) | (0xF1); + *storeLoc1 = sTransitionStructPtr->field_14 - task->tData1; + *storeLoc2 = (task->tData1 << 8) | (0xF1); } } - if (task->data[1] > 0xEF) + if (task->tData1 > 0xEF) task->tState++; sTransitionStructPtr->VBlank_DMA++; @@ -2307,12 +2590,12 @@ void HBlankCB_Phase2_Slice(void) } } -void Phase2Task_25(u8 taskId) +void Phase2Task_ShredSplit(u8 taskId) { - while (sPhase2_25_Funcs[gTasks[taskId].tState](&gTasks[taskId])); + while (sPhase2_ShredSplit_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_25_Func1(struct Task *task) +bool8 Phase2_ShredSplit_Func1(struct Task *task) { u16 i; @@ -2334,9 +2617,9 @@ bool8 Phase2_25_Func1(struct Task *task) gUnknown_02038C28[0][0x280 + i] = 1; } - task->data[4] = 0; - task->data[5] = 0; - task->data[6] = 7; + task->tData4 = 0; + task->tData5 = 0; + task->tData6 = 7; EnableInterrupts(INTR_FLAG_HBLANK); @@ -2347,7 +2630,7 @@ bool8 Phase2_25_Func1(struct Task *task) return TRUE; } -bool8 Phase2_25_Func2(struct Task *task) +bool8 Phase2_ShredSplit_Func2(struct Task *task) { u16 i, j, k; u8 arr1[ARRAY_COUNT(gUnknown_085C8C64)]; @@ -2362,7 +2645,7 @@ bool8 Phase2_25_Func2(struct Task *task) sTransitionStructPtr->VBlank_DMA = FALSE; var = 0; - for (i = 0; i <= task->data[5]; i++) + for (i = 0; i <= task->tData5; i++) { for (j = 0; j < 2; j++) { @@ -2433,10 +2716,10 @@ bool8 Phase2_25_Func2(struct Task *task) } } - if (--task->data[4] < 0) - task->data[4] = 0; - if (task->data[4] <= 0 && task->data[5] + 1 <= 20) - task->data[4] = task->data[6], task->data[5]++; + if (--task->tData4 < 0) + task->tData4 = 0; + if (task->tData4 <= 0 && task->tData5 + 1 <= 20) + task->tData4 = task->tData6, task->tData5++; if (var > 0x9F) task->tState++; @@ -2444,7 +2727,7 @@ bool8 Phase2_25_Func2(struct Task *task) return FALSE; } -bool8 Phase2_25_Func3(struct Task *task) +bool8 Phase2_ShredSplit_Func3(struct Task *task) { u16 i; bool32 done = TRUE; @@ -2462,11 +2745,11 @@ bool8 Phase2_25_Func3(struct Task *task) return FALSE; } -bool8 Phase2_25_Func4(struct Task *task) +bool8 Phase2_ShredSplit_Func4(struct Task *task) { DmaStop(0); sub_8149F84(); - DestroyTask(FindTaskIdByFunc(Phase2Task_25)); + DestroyTask(FindTaskIdByFunc(Phase2Task_ShredSplit)); return FALSE; } @@ -2500,16 +2783,16 @@ bool8 Phase2_Blackhole_Func1(struct Task *task) SetVBlankCallback(VBlankCB1_Phase2_BigPokeball); task->tState++; - task->data[1] = 1; - task->data[2] = 0x100; - task->data[7] = 0; + task->tData1 = 1; + task->tData2 = 0x100; + task->tFuncState = 0; return FALSE; } bool8 Phase2_Blackhole1_Func3(struct Task *task) { - if (task->data[7] == 1) + if (task->tFuncState == 1) { DmaStop(0); SetVBlankCallback(NULL); @@ -2518,16 +2801,16 @@ bool8 Phase2_Blackhole1_Func3(struct Task *task) else { sTransitionStructPtr->VBlank_DMA = FALSE; - if (task->data[2] < 0x400) - task->data[2] += 0x80; - if (task->data[1] < 0xA0) - task->data[1] += (task->data[2] >> 8); - if (task->data[1] > 0xA0) - task->data[1] = 0xA0; - sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->data[1]); - if (task->data[1] == 0xA0) + if (task->tData2 < 0x400) + task->tData2 += 0x80; + if (task->tData1 < 0xA0) + task->tData1 += (task->tData2 >> 8); + if (task->tData1 > 0xA0) + task->tData1 = 0xA0; + sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1); + if (task->tData1 == 0xA0) { - task->data[7] = 1; + task->tFuncState = 1; sub_8149F84(); } else @@ -2542,19 +2825,19 @@ bool8 Phase2_Blackhole1_Func3(struct Task *task) bool8 Phase2_Blackhole1_Func2(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; - if (task->data[7] == 0) + if (task->tFuncState == 0) { - task->data[7]++; - task->data[1] = 0x30; - task->data[6] = 0; + task->tFuncState++; + task->tData1 = 0x30; + task->tData6 = 0; } - task->data[1] += gUnknown_085C8C80[task->data[6]]; - task->data[6] = (task->data[6] + 1) % 2; - sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->data[1]); - if (task->data[1] < 9) + task->tData1 += gUnknown_085C8C80[task->tData6]; + task->tData6 = (task->tData6 + 1) % 2; + sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1); + if (task->tData1 < 9) { task->tState++; - task->data[7] = 0; + task->tFuncState = 0; } sTransitionStructPtr->VBlank_DMA++; @@ -2567,40 +2850,40 @@ bool8 Phase2_Blackhole2_Func2(struct Task *task) s16 amplitude; sTransitionStructPtr->VBlank_DMA = FALSE; - if (task->data[7] == 0) + if (task->tFuncState == 0) { - task->data[7]++; - task->data[5] = 2; - task->data[6] = 2; + task->tFuncState++; + task->tData5 = 2; + task->tData6 = 2; } - if (task->data[1] > 0xA0) - task->data[1] = 0xA0; + if (task->tData1 > 0xA0) + task->tData1 = 0xA0; - sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->data[1]); - if (task->data[1] == 0xA0) + sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1); + if (task->tData1 == 0xA0) { DmaStop(0); sub_8149F84(); DestroyTask(FindTaskIdByFunc(task->func)); } - index = task->data[5]; - if ((task->data[5] & 0xFF) <= 128) + index = task->tData5; + if ((task->tData5 & 0xFF) <= 128) { - amplitude = task->data[6]; - task->data[5] += 8; + amplitude = task->tData6; + task->tData5 += 8; } else { - amplitude = task->data[6] - 1; - task->data[5] += 16; + amplitude = task->tData6 - 1; + task->tData5 += 16; } - task->data[1] += Sin(index & 0xFF, amplitude); + task->tData1 += Sin(index & 0xFF, amplitude); - if (task->data[1] <= 0) - task->data[1] = 1; - if (task->data[5] > 0xFE) - task->data[5] >>= 8, task->data[6]++; + if (task->tData1 <= 0) + task->tData1 = 1; + if (task->tData5 > 0xFE) + task->tData5 >>= 8, task->tData6++; sTransitionStructPtr->VBlank_DMA++; return FALSE; @@ -2621,7 +2904,7 @@ bool8 Phase2_RectangularSpiral_Func1(struct Task *task) CpuFill16(0xF000, dst1, 0x800); LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); - task->data[3] = 1; + task->tData3 = 1; task->tState++; sRectangularSpiralTransition[0].field_0 = 0; @@ -2775,21 +3058,21 @@ bool8 Phase2_Groudon_Func3(struct Task *task) LZ77UnCompVram(gUnknown_085BEA88, dst1); task->tState++; - task->data[1] = 0; + task->tData1 = 0; return FALSE; } bool8 Phase2_Groudon_Func4(struct Task *task) { - if (task->data[1] % 3 == 0) + if (task->tData1 % 3 == 0) { - u16 var = (task->data[1] % 30) / 3; + u16 var = (task->tData1 % 30) / 3; LoadPalette(gUnknown_085BF0A0 + (var * 16), 0xF0, 0x20); } - if (++task->data[1] > 58) + if (++task->tData1 > 58) { task->tState++; - task->data[1] = 0; + task->tData1 = 0; } return FALSE; @@ -2797,18 +3080,951 @@ bool8 Phase2_Groudon_Func4(struct Task *task) bool8 Phase2_Groudon_Func5(struct Task *task) { - if (task->data[1] % 5 == 0) + if (task->tData1 % 5 == 0) { - s16 var = task->data[1] / 5; + s16 var = task->tData1 / 5; LoadPalette(gUnknown_085BF2A0 + (var * 16), 0xF0, 0x20); } - if (++task->data[1] > 68) + if (++task->tData1 > 68) { task->tState++; - task->data[1] = 0; + task->tData1 = 0; task->tFrames = 30; } return FALSE; } +void Phase2Task_Rayquaza(u8 taskId) +{ + while (sPhase2_Rayquaza_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Rayquaza_Func3(struct Task *task) +{ + u16 *dst1, *dst2; + u16 i; + + sub_8149F08(); + dp12_8087EA4(); + + SetGpuReg(REG_OFFSET_BG0CNT, 0x9A08); + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + CpuCopy16(gUnknown_085BF6A0, dst2, 0x2000); + + sTransitionStructPtr->field_20 = 0; + task->tState++; + LoadPalette(gUnknown_085BF4A0 + 0x50, 0xF0, 0x20); + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[0][i] = 0; + gUnknown_02038C28[1][i] = 0x100; + } + + SetVBlankCallback(VBlankCB_Phase2_Rayquaza); + return FALSE; +} + +bool8 Phase2_Rayquaza_Func4(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + CpuCopy16(gUnknown_085C6BE0, dst1, 0x1000); + task->tState++; + return FALSE; +} + +bool8 Phase2_Rayquaza_Func5(struct Task *task) +{ + if ((task->tData1 % 4) == 0) + { + u16 value = task->tData1 / 4; + const u16 *palPtr = &gUnknown_085BF4A0[(value + 5) * 16]; + LoadPalette(palPtr, 0xF0, 0x20); + } + if (++task->tData1 > 40) + { + task->tState++; + task->tData1 = 0; + } + + return FALSE; +} + +bool8 Phase2_Rayquaza_Func6(struct Task *task) +{ + if (++task->tData1 > 20) + { + task->tState++; + task->tData1 = 0; + BeginNormalPaletteFade(0xFFFF8000, 2, 0, 0x10, 0); + } + + return FALSE; +} + +bool8 Phase2_Rayquaza_Func7(struct Task *task) +{ + if (!gPaletteFade.active) + { + sTransitionStructPtr->field_20 = 1; + task->tState++; + } + + return FALSE; +} + +bool8 Phase2_Rayquaza_Func8(struct Task *task) +{ + BlendPalettes(0x00007FFF, 8, 0); + BlendPalettes(0xFFFF8000, 0, 0); + + task->tState++; + return FALSE; +} + +bool8 Phase2_Rayquaza_Func9(struct Task *task) +{ + if ((task->tData1 % 3) == 0) + { + u16 value = task->tData1 / 3; + const u16 *palPtr = &gUnknown_085BF4A0[(value + 0) * 16]; + LoadPalette(palPtr, 0xF0, 0x20); + } + if (++task->tData1 >= 40) + { + u16 i; + + sTransitionStructPtr->WININ = 0; + sTransitionStructPtr->WINOUT = 63; + sTransitionStructPtr->field_6 = 240; + sTransitionStructPtr->WIN0V = 160; + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[1][i] = 0; + } + + SetVBlankCallback(VBlankCB1_Phase2_BigPokeball); + task->tState++; + task->tData2 = 0x100; + task->tFuncState = 0; + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG0_ON); + } + + return FALSE; +} + +void VBlankCB_Phase2_Rayquaza(void) +{ + void *dmaSrc; + + DmaStop(0); + VBlankCB_BattleTransition(); + + if (sTransitionStructPtr->field_20 == 0) + dmaSrc = gUnknown_02038C28[0]; + else if (sTransitionStructPtr->field_20 == 1) + dmaSrc = gUnknown_02038C28[1]; + else + dmaSrc = gUnknown_02038C28[0]; + + DmaSet(0, dmaSrc, ®_BG0VOFS, 0xA2400001); +} + +void Phase2Task_WhiteFade(u8 taskId) +{ + while (sPhase2_WhiteFade_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_WhiteFade_Func1(struct Task *task) +{ + u16 i; + + sub_8149F08(); + dp12_8087EA4(); + + sTransitionStructPtr->BLDCNT = 0xBF; + sTransitionStructPtr->BLDY = 0; + sTransitionStructPtr->WININ = 0x1E; + sTransitionStructPtr->WINOUT = 0x3F; + sTransitionStructPtr->WIN0V = 0xA0; + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[1][i] = 0; + gUnknown_02038C28[1][i + 160] = 0xF0; + } + + EnableInterrupts(INTR_FLAG_HBLANK); + SetHBlankCallback(HBlankCB_Phase2_WhiteFade); + SetVBlankCallback(VBlankCB0_Phase2_WhiteFade); + + task->tState++; + return FALSE; +} + +bool8 Phase2_WhiteFade_Func2(struct Task *task) +{ + s16 i, posY; + s16 arr1[ARRAY_COUNT(sUnknown_085C8DA0)]; + struct Sprite *sprite; + + memcpy(arr1, sUnknown_085C8DA0, sizeof(sUnknown_085C8DA0)); + for (i = 0, posY = 0; i < 8; i++, posY += 0x14) + { + sprite = &gSprites[CreateInvisibleSprite(sub_8149864)]; + sprite->pos1.x = 0xF0; + sprite->pos1.y = posY; + sprite->data[5] = arr1[i]; + } + sprite->data[6]++; + + task->tState++; + return FALSE; +} + +bool8 Phase2_WhiteFade_Func3(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + if (sTransitionStructPtr->field_20 > 7) + { + BlendPalettes(-1, 0x10, 0x7FFF); + task->tState++; + } + return FALSE; +} + +bool8 Phase2_WhiteFade_Func4(struct Task *task) +{ + sTransitionStructPtr->VBlank_DMA = 0; + + DmaStop(0); + SetVBlankCallback(0); + SetHBlankCallback(0); + + sTransitionStructPtr->field_6 = 0xF0; + sTransitionStructPtr->BLDY = 0; + sTransitionStructPtr->BLDCNT = 0xFF; + sTransitionStructPtr->WININ = 0x3F; + + SetVBlankCallback(VBlankCB1_Phase2_WhiteFade); + + task->tState++; + return FALSE; +} + +bool8 Phase2_WhiteFade_Func5(struct Task *task) +{ + if (++sTransitionStructPtr->BLDY > 16) + { + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(Phase2Task_WhiteFade)); + } + return FALSE; +} + +void VBlankCB0_Phase2_WhiteFade(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + REG_BLDCNT = sTransitionStructPtr->BLDCNT; + REG_WININ = sTransitionStructPtr->WININ; + REG_WINOUT = sTransitionStructPtr->WINOUT; + REG_WIN0V = sTransitionStructPtr->WIN0V; + if (sTransitionStructPtr->VBlank_DMA) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 640); + DmaSet(0, &gUnknown_02038C28[1][160], ®_WIN0H, 0xA2400001); +} + +void VBlankCB1_Phase2_WhiteFade(void) +{ + VBlankCB_BattleTransition(); + REG_BLDY = sTransitionStructPtr->BLDY; + REG_BLDCNT = sTransitionStructPtr->BLDCNT; + REG_WININ = sTransitionStructPtr->WININ; + REG_WINOUT = sTransitionStructPtr->WINOUT; + REG_WIN0H = sTransitionStructPtr->field_6; + REG_WIN0V = sTransitionStructPtr->WIN0V; +} + +void HBlankCB_Phase2_WhiteFade(void) +{ + REG_BLDY = gUnknown_02038C28[1][REG_VCOUNT]; +} + +void sub_8149864(struct Sprite *sprite) +{ + if (sprite->data[5]) + { + sprite->data[5]--; + if (sprite->data[6]) + sTransitionStructPtr->VBlank_DMA = 1; + } + else + { + u16 i; + u16* ptr1 = &gUnknown_02038C28[0][sprite->pos1.y]; + u16* ptr2 = &gUnknown_02038C28[0][sprite->pos1.y + 160]; + for (i = 0; i < 20; i++) + { + ptr1[i] = sprite->data[0] >> 8; + ptr2[i] = (u8)(sprite->pos1.x); + } + if (sprite->pos1.x == 0 && sprite->data[0] == 0x1000) + sprite->data[1] = 1; + + sprite->pos1.x -= 16; + sprite->data[0] += 0x80; + + if (sprite->pos1.x < 0) + sprite->pos1.x = 0; + if (sprite->data[0] > 0x1000) + sprite->data[0] = 0x1000; + + if (sprite->data[6]) + sTransitionStructPtr->VBlank_DMA = 1; + + if (sprite->data[1]) + { + if (sprite->data[6] == 0 || (sTransitionStructPtr->field_20 > 6 && sprite->data[2]++ > 7)) + { + sTransitionStructPtr->field_20++; + DestroySprite(sprite); + } + } + } +} + +void Phase2Task_GridSquares(u8 taskId) +{ + while (sPhase2_GridSquares_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_GridSquares_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + CpuSet(sShrinkingBoxTileset, dst2, 0x10); + CpuFill16(0xF000, dst1, 0x800); + LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); + + task->tState++; + return FALSE; +} + +bool8 Phase2_GridSquares_Func2(struct Task *task) +{ + u16* dst1; + + if (task->tData1 == 0) + { + sub_8149F40(&dst1); + task->tData1 = 3; + task->tData2++; + CpuSet(sShrinkingBoxTileset + (task->tData2 * 8), dst1, 0x10); + if (task->tData2 > 0xD) + { + task->tState++; + task->tData1 = 16; + } + } + + task->tData1--; + return FALSE; +} + +bool8 Phase2_GridSquares_Func3(struct Task *task) +{ + if (--task->tData1 == 0) + { + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(Phase2Task_GridSquares)); + } + return FALSE; +} + +void Phase2Task_Shards(u8 taskId) +{ + while (sPhase2_Shards_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_Shards_Func1(struct Task *task) +{ + u16 i; + + sub_8149F08(); + dp12_8087EA4(); + + sTransitionStructPtr->WININ = 0x3F; + sTransitionStructPtr->WINOUT = 0; + sTransitionStructPtr->WIN0V = 0xA0; + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[0][i] = 0xF0; + } + + CpuSet(gUnknown_02038C28[0], gUnknown_02038C28[1], 0xA0); + SetVBlankCallback(VBlankCB_Phase2_Shards); + + task->tState++; + return TRUE; +} + +bool8 Phase2_Shards_Func2(struct Task *task) +{ + sub_814A1AC(sTransitionStructPtr->data, + sUnknown_085C8DD0[task->tData1][0], + sUnknown_085C8DD0[task->tData1][1], + sUnknown_085C8DD0[task->tData1][2], + sUnknown_085C8DD0[task->tData1][3], + 1, 1); + task->tData2 = sUnknown_085C8DD0[task->tData1][4]; + task->tState++; + return TRUE; +} + +bool8 Phase2_Shards_Func3(struct Task *task) +{ + s16 i; + bool8 nextFunc; + + sTransitionStructPtr->VBlank_DMA = 0; + + for (i = 0, nextFunc = FALSE; i < 16; i++) + { + s16 r3 = gUnknown_02038C28[0][sTransitionStructPtr->data[3]] >> 8; + s16 r4 = gUnknown_02038C28[0][sTransitionStructPtr->data[3]] & 0xFF; + if (task->tData2 == 0) + { + if (r3 < sTransitionStructPtr->data[2]) + r3 = sTransitionStructPtr->data[2]; + if (r3 > r4) + r3 = r4; + } + else + { + if (r4 > sTransitionStructPtr->data[2]) + r4 = sTransitionStructPtr->data[2]; + if (r4 <= r3) + r4 = r3; + } + gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r4) | (r3 << 8); + if (nextFunc) + { + task->tState++; + break; + } + else + nextFunc = sub_814A228(sTransitionStructPtr->data, 1, 1); + } + + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +bool8 Phase2_Shards_Func4(struct Task *task) +{ + if (++task->tData1 < 7) + { + task->tState++; + task->tData3 = sUnknown_085C8E16[task->tData1 - 1]; + return TRUE; + } + else + { + DmaStop(0); + sub_8149F84(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Shards)); + return FALSE; + } +} + +bool8 Phase2_Shards_Func5(struct Task *task) +{ + if (--task->tData3 == 0) + { + task->tState = 1; + return TRUE; + } + else + return FALSE; +} + +void VBlankCB_Phase2_Shards(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (sTransitionStructPtr->VBlank_DMA) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); + REG_WININ = sTransitionStructPtr->WININ; + REG_WINOUT = sTransitionStructPtr->WINOUT; + REG_WIN0V = sTransitionStructPtr->WIN0V; + REG_WIN0H = gUnknown_02038C28[1][0]; + DmaSet(0, gUnknown_02038C28[1], ®_WIN0H, 0xA2400001); +} + +// sub-task for phase2 +#undef tData1 +#undef tData2 +#undef tData3 +#undef tData4 +#undef tData5 +#undef tData6 +#undef tFuncState +#undef tFrames +#undef tOpponentSpriteId +#undef tPlayerSpriteId +#undef tMugshotId + +// sub-task for sub-task phase +#define tData1 data[1] +#define tData2 data[2] +#define tData3 data[3] +#define tData4 data[4] +#define tData5 data[5] +#define tData6 data[6] +#define tData7 data[7] + +void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4) +{ + u8 taskId = CreateTask(Phase1_Task_RunFuncs, 3); + gTasks[taskId].tData1 = a0; + gTasks[taskId].tData2 = a1; + gTasks[taskId].tData3 = a2; + gTasks[taskId].tData4 = a3; + gTasks[taskId].tData5 = a4; + gTasks[taskId].tData6 = a0; +} + +bool8 IsPhase1Done(void) +{ + if (FindTaskIdByFunc(Phase1_Task_RunFuncs) == 0xFF) + return TRUE; + else + return FALSE; +} + +void Phase1_Task_RunFuncs(u8 taskId) +{ + while (sPhase1_TransitionAll_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase1_TransitionAll_Func1(struct Task *task) +{ + if (task->tData6 == 0 || --task->tData6 == 0) + { + task->tData6 = task->tData1; + task->tData7 += task->tData4; + if (task->tData7 > 16) + task->tData7 = 16; + BlendPalettes(-1, task->tData7, 0x2D6B); + } + if (task->tData7 > 15) + { + task->tState++; + task->tData6 = task->tData2; + } + return FALSE; +} + +bool8 Phase1_TransitionAll_Func2(struct Task *task) +{ + if (task->tData6 == 0 || --task->tData6 == 0) + { + task->tData6 = task->tData2; + task->tData7 -= task->tData5; + if (task->tData7 < 0) + task->tData7 = 0; + BlendPalettes(-1, task->tData7, 0x2D6B); + } + if (task->tData7 == 0) + { + if (--task->tData3 == 0) + DestroyTask(FindTaskIdByFunc(Phase1_Task_RunFuncs)); + else + { + task->tData6 = task->tData1; + task->tState = 0; + } + } + return FALSE; +} + +#undef tData1 +#undef tData2 +#undef tData3 +#undef tData4 +#undef tData5 +#undef tData6 +#undef tData7 + +void sub_8149F08(void) +{ + memset(sTransitionStructPtr, 0, sizeof(*sTransitionStructPtr)); + sub_8089C08(&sTransitionStructPtr->field_14, &sTransitionStructPtr->field_16); +} + +void VBlankCB_BattleTransition(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +void sub_8149F40(u16 **a0) +{ + u16 reg, *vram; + + reg = REG_BG0CNT >> 2; + reg <<= 0xE; + vram = (u16*)(VRAM + reg); + + *a0 = vram; +} + +void sub_8149F58(u16 **a0, u16 **a1) +{ + u16 reg0, reg1, *vram0, *vram1; + + reg0 = REG_BG0CNT >> 8; + reg1 = REG_BG0CNT >> 2; + + reg0 <<= 0xB; + reg1 <<= 0xE; + + vram0 = (u16*)(VRAM + reg0); + *a0 = vram0; + + vram1 = (u16*)(VRAM + reg1); + *a1 = vram1; +} + +void sub_8149F84(void) +{ + BlendPalettes(-1, 0x10, 0); +} + +void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize) +{ + u8 i; + for (i = 0; arrSize > 0; arrSize--, i++, index += indexIncrementer) + { + array[i] = sinAdd + Sin(0xFF & index, amplitude); + } +} + +void sub_814A014(u16 *array, s16 a1, s16 a2, s16 a3) +{ + s16 i; + + memset(array, 0xA, 160 * sizeof(s16)); + for (i = 0; i < 64; i++) + { + s16 sinResult, cosResult; + s16 toStoreOrr, r2, r3, toStore, r7, r8; + + sinResult = Sin(i, a3); + cosResult = Cos(i, a3); + + toStoreOrr = a1 - sinResult; + toStore = a1 + sinResult; + r7 = a2 - cosResult; + r8 = a2 + cosResult; + + if (toStoreOrr < 0) + toStoreOrr = 0; + if (toStore > 0xF0) + toStore = 0xF0; + if (r7 < 0) + r7 = 0; + if (r8 > 0x9F) + r8 = 0x9F; + + toStore |= (toStoreOrr << 8); + array[r7] = toStore; + array[r8] = toStore; + + cosResult = Cos(i + 1, a3); + r3 = a2 - cosResult; + r2 = a2 + cosResult; + + if (r3 < 0) + r3 = 0; + if (r2 > 0x9F) + r2 = 0x9F; + + while (r7 > r3) + array[--r7] = toStore; + while (r7 < r3) + array[++r7] = toStore; + + while (r8 > r2) + array[--r8] = toStore; + while (r8 < r2) + array[++r8] = toStore; + } +} + +void sub_814A1AC(s16 *data, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) +{ + data[0] = a1; + data[1] = a2; + data[2] = a1; + data[3] = a2; + data[4] = a3; + data[5] = a4; + data[6] = a5; + data[7] = a6; + data[8] = a3 - a1; + if (data[8] < 0) + { + data[8] = -data[8]; + data[6] = -a5; + } + data[9] = a4 - a2; + if (data[9] < 0) + { + data[9] = -data[9]; + data[7] = -a6; + } + data[10] = 0; +} + +bool8 sub_814A228(s16 *data, bool8 a1, bool8 a2) +{ + u8 var; + if (data[8] > data[9]) + { + data[2] += data[6]; + data[10] += data[9]; + if (data[10] > data[8]) + { + data[3] += data[7]; + data[10] -= data[8]; + } + } + else + { + data[3] += data[7]; + data[10] += data[8]; + if (data[10] > data[9]) + { + data[2] += data[6]; + data[10] -= data[9]; + } + } + var = 0; + if ((data[6] > 0 && data[2] >= data[4]) || (data[6] < 0 && data[2] <= data[4])) + { + var++; + if (a1) + data[2] = data[4]; + } + if ((data[7] > 0 && data[3] >= data[5]) || (data[7] < 0 && data[3] <= data[5])) + { + var++; + if (a2) + data[3] = data[5]; + } + + if (var == 2) + return TRUE; + else + return FALSE; +} + +// sub-task for phase2 of a couple of new transitions +#define tData1 data[1] +#define tData2 data[2] +#define tData3 data[3] +#define tData4 data[4] +#define tData5 data[5] +#define tData6 data[6] +#define tData7 data[7] + +bool8 Phase2_29_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_814669C(task); + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + LZ77UnCompVram(gUnknown_085C7C00, dst2); + LoadPalette(gUnknown_085C7BE0, 0xF0, 0x20); + + task->tState++; + return FALSE; +} + +bool8 Phase2_29_Func2(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LZ77UnCompVram(gUnknown_085C828C, dst1); + sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 0x84, task->tData5, 160); + + task->tState++; + return TRUE; +} + +void Phase2Task_29(u8 taskId) +{ + while (sPhase2_29_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_30(u8 taskId) +{ + while (sPhase2_30_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +bool8 Phase2_30_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F08(); + dp12_8087EA4(); + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_WIN1_ON); + task->data[2] = 0x2000; + task->data[1] = 0x7FFF; + task->data[5] = 0; + task->data[6] = 16; + task->data[7] = 2560; + sTransitionStructPtr->BLDCNT = 0x3F41; + sTransitionStructPtr->BLDALPHA = (task->tData6 << 8) | (task->tData5); + REG_BLDCNT = sTransitionStructPtr->BLDCNT; + REG_BLDALPHA = sTransitionStructPtr->BLDALPHA; + sub_8149F58(&dst1, &dst2); + CpuFill16(0, dst1, 0x800); + LZ77UnCompVram(gUnknown_085C7C00, dst2); + LoadPalette(gUnknown_085C7BE0, 0xF0, 0x20); + sTransitionStructPtr->field_16 = 0; + + task->tState++; + return FALSE; +} + +bool8 Phase2_30_Func2(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LZ77UnCompVram(gUnknown_085C828C, dst1); + + task->tState++; + return TRUE; +} + +bool8 Phase2_30_Func3(struct Task *task) +{ + u8 i; + + for (i = 0; i < 160; i++) + { + gUnknown_02038C28[1][i] = sTransitionStructPtr->field_16; + } + + SetVBlankCallback(VBlankCB_Phase2_30); + SetHBlankCallback(HBlankCB_Phase2_30); + EnableInterrupts(INTR_FLAG_HBLANK); + + task->tState++; + return TRUE; +} + +bool8 Phase2_30_Func4(struct Task *task) +{ + u8 i; + u16 var6, amplitude, var8; + + sTransitionStructPtr->VBlank_DMA = FALSE; + + amplitude = task->tData2 >> 8; + var6 = task->tData1; + var8 = 384; + + task->tData1 = var6 - task->tData7; + + if (task->tData3 >= 70) + { + if (task->tData2 - 384 >= 0) + task->tData2 -= 384; + else + task->tData2 = 0; + } + + if (task->tData3 >= 0 && task->tData3 % 3 == 0) + { + if (task->tData5 < 16) + task->tData5++; + else if (task->tData6 > 0) + task->tData6--; + + sTransitionStructPtr->BLDALPHA = (task->tData6 << 8) | (task->tData5); + } + + for (i = 0; i < 160; i++, var6 += var8) + { + s16 index = var6 / 256; + asm(""); + gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(index, amplitude); + } + + if (++task->tData3 == 101) + { + task->tData4++; + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + } + + if (task->tData4 != 0 && !gPaletteFade.active) + DestroyTask(FindTaskIdByFunc(Phase2Task_30)); + + task->tData7 -= 17; + sTransitionStructPtr->VBlank_DMA++; + return FALSE; +} + +void VBlankCB_Phase2_30(void) +{ + VBlankCB_BattleTransition(); + REG_BLDCNT = sTransitionStructPtr->BLDCNT; + REG_BLDALPHA = sTransitionStructPtr->BLDALPHA; + + if (sTransitionStructPtr->VBlank_DMA) + DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); +} + +void HBlankCB_Phase2_30(void) +{ + u16 var = gUnknown_02038C28[1][REG_VCOUNT]; + REG_BG0VOFS = var; +} + +void Phase2Task_31(u8 taskId) +{ + while (sPhase2_31_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_33(u8 taskId) +{ + while (sPhase2_33_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +void Phase2Task_32(u8 taskId) +{ + while (sPhase2_32_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +#undef tData1 +#undef tData2 +#undef tData3 +#undef tData4 +#undef tData5 +#undef tData6 +#undef tData7 diff --git a/src/tileset_anims.c b/src/tileset_anims.c index 4ad787e1c..062647202 100644 --- a/src/tileset_anims.c +++ b/src/tileset_anims.c @@ -5,6 +5,7 @@ #include "blend_palette.h" #include "battle_transition.h" #include "task.h" +#include "battle_transition.h" // Static type declarations @@ -1392,7 +1393,7 @@ static void sub_80A1818(u16 a1) { CpuCopy16(gTilesetAnims_BattleDomePals0[a1 & 0x3], gPlttBufferUnfaded + 0x80, 32); BlendPalette(0x80, 0x10, gPaletteFade.y, gPaletteFade.blendColor & 0x7FFF); - if ((u8)FindTaskIdByFunc(sub_8149DFC) != 0xFF ) + if ((u8)FindTaskIdByFunc(Phase1_Task_RunFuncs) != 0xFF ) { sSecondaryTilesetCB = sub_80A1670; sSecondaryTilesetCBBufferSize = 0x20; @@ -1402,7 +1403,7 @@ static void sub_80A1818(u16 a1) static void sub_80A1884(u16 a1) { CpuCopy16(gTilesetAnims_BattleDomePals0[a1 & 0x3], gPlttBufferUnfaded + 0x80, 32); - if ((u8)FindTaskIdByFunc(sub_8149DFC) == 0xFF ) + if ((u8)FindTaskIdByFunc(Phase1_Task_RunFuncs) == 0xFF ) { BlendPalette(0x80, 0x10, gPaletteFade.y, gPaletteFade.blendColor & 0x7FFF); if (!--sSecondaryTilesetCBBufferSize) -- cgit v1.2.3 From d7644cd3d8070cb12c84263a4707ec0211bd434a Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 14 Jan 2018 22:09:35 +0100 Subject: battle transition is decompiled --- src/battle_transition.c | 1390 +++++++++++++++++++++++++++++------------------ src/tileset_anims.c | 4 +- 2 files changed, 855 insertions(+), 539 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index def302889..af156da12 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -18,6 +18,8 @@ #include "malloc.h" #include "gpu_regs.h" #include "decompress.h" +#include "bg.h" +#include "blend_palette.h" struct TransitionData { @@ -56,6 +58,8 @@ typedef bool8 (*TransitionSpriteCallback)(struct Sprite *sprite); extern u16 gUnknown_020393A8[]; extern u16 gUnknown_02038C28[][0x3C0]; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; extern const struct OamData gFieldObjectBaseOam_32x32; @@ -64,206 +68,205 @@ extern void sub_80AC3D0(void); extern void dp12_8087EA4(void); // this file's functions -void LaunchBattleTransitionTask(u8 transitionId); -void Task_BattleTransitionMain(u8 taskId); -void Phase1Task_TransitionAll(u8 taskId); -void Phase2Task_Blur(u8 taskId); -void Phase2Task_Swirl(u8 taskId); -void Phase2Task_Shuffle(u8 taskId); -void Phase2Task_BigPokeball(u8 taskId); -void Phase2Task_PokeballsTrail(u8 taskId); -void Phase2Task_Clockwise_BlackFade(u8 taskId); -void Phase2Task_Ripple(u8 taskId); -void Phase2Task_Wave(u8 taskId); -void Phase2Task_Slice(u8 taskId); -void Phase2Task_WhiteFade(u8 taskId); -void Phase2Task_GridSquares(u8 taskId); -void Phase2Task_Shards(u8 taskId); -void Phase2Task_Sydney(u8 taskId); -void Phase2Task_Phoebe(u8 taskId); -void Phase2Task_Glacia(u8 taskId); -void Phase2Task_Drake(u8 taskId); -void Phase2Task_Champion(u8 taskId); -void Phase2Task_Aqua(u8 taskId); -void Phase2Task_Magma(u8 taskId); -void Phase2Task_Regice(u8 taskId); -void Phase2Task_Registeel(u8 taskId); -void Phase2Task_Regirock(u8 taskId); -void Phase2Task_Kyogre(u8 taskId); -void Phase2Task_Groudon(u8 taskId); -void Phase2Task_Rayquaza(u8 taskId); -void Phase2Task_ShredSplit(u8 taskId); -void Phase2Task_Blackhole1(u8 taskId); -void Phase2Task_Blackhole2(u8 taskId); -void Phase2Task_RectangularSpiral(u8 taskId); -void Phase2Task_29(u8 taskId); -void Phase2Task_30(u8 taskId); -void Phase2Task_31(u8 taskId); -void Phase2Task_32(u8 taskId); -void Phase2Task_33(u8 taskId); -void VBlankCB_BattleTransition(void); -void VBlankCB_Phase2_Swirl(void); -void HBlankCB_Phase2_Swirl(void); -void VBlankCB_Phase2_Shuffle(void); -void HBlankCB_Phase2_Shuffle(void); -void VBlankCB0_Phase2_BigPokeball(void); -void VBlankCB1_Phase2_BigPokeball(void); -void VBlankCB_Phase2_Clockwise_BlackFade(void); -void VBlankCB_Phase2_Ripple(void); -void HBlankCB_Phase2_Ripple(void); -void VBlankCB_Phase2_30(void); -void HBlankCB_Phase2_30(void); -void VBlankCB_Phase2_Wave(void); -void VBlankCB_Phase2_Slice(void); -void HBlankCB_Phase2_Slice(void); -void VBlankCB0_Phase2_WhiteFade(void); -void VBlankCB1_Phase2_WhiteFade(void); -void HBlankCB_Phase2_WhiteFade(void); -void VBlankCB_Phase2_Shards(void); -void VBlankCB_Phase2_Rayquaza(void); -bool8 Phase2_Blur_Func1(struct Task *task); -bool8 Phase2_Blur_Func2(struct Task *task); -bool8 Phase2_Blur_Func3(struct Task *task); -bool8 Phase2_Swirl_Func1(struct Task *task); -bool8 Phase2_Swirl_Func2(struct Task *task); -bool8 Phase2_Shuffle_Func1(struct Task *task); -bool8 Phase2_Shuffle_Func2(struct Task *task); -bool8 Phase2_Aqua_Func1(struct Task *task); -bool8 Phase2_Aqua_Func2(struct Task *task); -bool8 Phase2_Magma_Func1(struct Task *task); -bool8 Phase2_Magma_Func2(struct Task *task); -bool8 Phase2_FramesCountdown(struct Task *task); -bool8 Phase2_Regi_Func1(struct Task *task); -bool8 Phase2_Regice_Func2(struct Task *task); -bool8 Phase2_Registeel_Func2(struct Task *task); -bool8 Phase2_Regirock_Func2(struct Task *task); -bool8 Phase2_WeatherTrio_Func1(struct Task *task); -bool8 Phase2_WaitPaletteFade(struct Task *task); -bool8 Phase2_Kyogre_Func3(struct Task *task); -bool8 Phase2_Kyogre_Func4(struct Task *task); -bool8 Phase2_Kyogre_Func5(struct Task *task); -bool8 Phase2_Groudon_Func3(struct Task *task); -bool8 Phase2_Groudon_Func4(struct Task *task); -bool8 Phase2_Groudon_Func5(struct Task *task); -bool8 Phase2_WeatherDuo_Func6(struct Task *task); -bool8 Phase2_WeatherDuo_Func7(struct Task *task); -bool8 Phase2_BigPokeball_Func1(struct Task *task); -bool8 Phase2_BigPokeball_Func2(struct Task *task); -bool8 Phase2_BigPokeball_Func3(struct Task *task); -bool8 Phase2_BigPokeball_Func4(struct Task *task); -bool8 Phase2_BigPokeball_Func5(struct Task *task); -bool8 Phase2_BigPokeball_Func6(struct Task *task); -bool8 Phase2_PokeballsTrail_Func1(struct Task *task); -bool8 Phase2_PokeballsTrail_Func2(struct Task *task); -bool8 Phase2_PokeballsTrail_Func3(struct Task *task); -bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task); -bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task); -bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task); -bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task); -bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task); -bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task); -bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task); -bool8 Phase2_Ripple_Func1(struct Task *task); -bool8 Phase2_Ripple_Func2(struct Task *task); -bool8 Phase2_Wave_Func1(struct Task *task); -bool8 Phase2_Wave_Func2(struct Task *task); -bool8 Phase2_Wave_Func3(struct Task *task); -bool8 Phase2_Slice_Func1(struct Task *task); -bool8 Phase2_Slice_Func2(struct Task *task); -bool8 Phase2_Slice_Func3(struct Task *task); -bool8 Phase2_WhiteFade_Func1(struct Task *task); -bool8 Phase2_WhiteFade_Func2(struct Task *task); -bool8 Phase2_WhiteFade_Func3(struct Task *task); -bool8 Phase2_WhiteFade_Func4(struct Task *task); -bool8 Phase2_WhiteFade_Func5(struct Task *task); -bool8 Phase2_GridSquares_Func1(struct Task *task); -bool8 Phase2_GridSquares_Func2(struct Task *task); -bool8 Phase2_GridSquares_Func3(struct Task *task); -bool8 Phase2_Shards_Func1(struct Task *task); -bool8 Phase2_Shards_Func2(struct Task *task); -bool8 Phase2_Shards_Func3(struct Task *task); -bool8 Phase2_Shards_Func4(struct Task *task); -bool8 Phase2_Shards_Func5(struct Task *task); -bool8 Phase2_ShredSplit_Func1(struct Task *task); -bool8 Phase2_ShredSplit_Func2(struct Task *task); -bool8 Phase2_ShredSplit_Func3(struct Task *task); -bool8 Phase2_ShredSplit_Func4(struct Task *task); -bool8 Phase2_Blackhole_Func1(struct Task *task); -bool8 Phase2_Blackhole1_Func2(struct Task *task); -bool8 Phase2_Blackhole1_Func3(struct Task *task); -bool8 Phase2_Blackhole2_Func2(struct Task *task); -bool8 Phase2_RectangularSpiral_Func1(struct Task *task); -bool8 Phase2_RectangularSpiral_Func2(struct Task *task); -bool8 Phase2_RectangularSpiral_Func3(struct Task *task); -bool8 Phase2_29_Func1(struct Task *task); -bool8 Phase2_29_Func2(struct Task *task); -bool8 Phase2_30_Func1(struct Task *task); -bool8 Phase2_30_Func2(struct Task *task); -bool8 Phase2_30_Func3(struct Task *task); -bool8 Phase2_30_Func4(struct Task *task); -bool8 Phase2_Rayquaza_Func3(struct Task *task); -bool8 Phase2_Rayquaza_Func4(struct Task *task); -bool8 Phase2_Rayquaza_Func5(struct Task *task); -bool8 Phase2_Rayquaza_Func6(struct Task *task); -bool8 Phase2_Rayquaza_Func7(struct Task *task); -bool8 Phase2_Rayquaza_Func8(struct Task *task); -bool8 Phase2_Rayquaza_Func9(struct Task *task); -bool8 Phase2_31_Func1(struct Task *task); -bool8 Phase2_31_Func2(struct Task *task); -bool8 Phase2_31_Func3(struct Task *task); -bool8 Phase2_31_33_Func5(struct Task *task); -bool8 Phase2_33_Func1(struct Task *task); -bool8 Phase2_33_Func2(struct Task *task); -bool8 Phase2_33_Func3(struct Task *task); -bool8 Phase2_33_Func4(struct Task *task); -bool8 Phase2_32_Func1(struct Task *task); -bool8 Phase2_32_Func2(struct Task *task); -bool8 Phase2_32_Func3(struct Task *task); -bool8 Phase2_32_Func4(struct Task *task); -bool8 Phase2_32_Func5(struct Task *task); -bool8 Phase2_Mugshot_Func1(struct Task *task); -bool8 Phase2_Mugshot_Func2(struct Task *task); -bool8 Phase2_Mugshot_Func3(struct Task *task); -bool8 Phase2_Mugshot_Func4(struct Task *task); -bool8 Phase2_Mugshot_Func5(struct Task *task); -bool8 Phase2_Mugshot_Func6(struct Task *task); -bool8 Phase2_Mugshot_Func7(struct Task *task); -bool8 Phase2_Mugshot_Func8(struct Task *task); -bool8 Phase2_Mugshot_Func9(struct Task *task); -bool8 Phase2_Mugshot_Func10(struct Task *task); -void Phase2Task_MugShotTransition(u8 taskId); -void Mugshots_CreateOpponentPlayerSprites(struct Task *task); -void VBlankCB0_Phase2_Mugshots(void); -void VBlankCB1_Phase2_Mugshots(void); -void HBlankCB_Phase2_Mugshots(void); -bool8 Transition_Phase1(struct Task *task); -bool8 Transition_WaitForPhase1(struct Task *task); -bool8 Transition_Phase2(struct Task *task); -bool8 Transition_WaitForPhase2(struct Task *task); -void sub_8149F08(void); -void sub_8149F84(void); -void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); -void sub_814A014(u16 *a0, s16 a1, s16 a2, s16 a3); -void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize); -void sub_8149F58(u16 **a0, u16 **a1); -void sub_8149F40(u16 **a0); -void sub_814A1AC(s16 *a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); -bool8 sub_814A228(s16 *a0, bool8 a1, bool8 a2); -void sub_8148484(s16 spriteId, s16 value); -void sub_814849C(s16 spriteId); -s16 sub_81484B8(s16 spriteId); -bool8 Phase1_TransitionAll_Func1(struct Task *task); -bool8 Phase1_TransitionAll_Func2(struct Task *task); -bool8 IsPhase1Done(void); -bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1); -void sub_814713C(struct Sprite *sprite); -void sub_8148380(struct Sprite *sprite); -void sub_8149864(struct Sprite *sprite); -bool8 sub_81483A8(struct Sprite *sprite); -bool8 sub_81483AC(struct Sprite *sprite); -bool8 sub_81483F8(struct Sprite *sprite); -bool8 sub_814842C(struct Sprite *sprite); -bool8 sub_8148458(struct Sprite *sprite); +static void LaunchBattleTransitionTask(u8 transitionId); +static void Task_BattleTransitionMain(u8 taskId); +static void Phase1Task_TransitionAll(u8 taskId); +static void Phase2Task_Blur(u8 taskId); +static void Phase2Task_Swirl(u8 taskId); +static void Phase2Task_Shuffle(u8 taskId); +static void Phase2Task_BigPokeball(u8 taskId); +static void Phase2Task_PokeballsTrail(u8 taskId); +static void Phase2Task_Clockwise_BlackFade(u8 taskId); +static void Phase2Task_Ripple(u8 taskId); +static void Phase2Task_Wave(u8 taskId); +static void Phase2Task_Slice(u8 taskId); +static void Phase2Task_WhiteFade(u8 taskId); +static void Phase2Task_GridSquares(u8 taskId); +static void Phase2Task_Shards(u8 taskId); +static void Phase2Task_Sydney(u8 taskId); +static void Phase2Task_Phoebe(u8 taskId); +static void Phase2Task_Glacia(u8 taskId); +static void Phase2Task_Drake(u8 taskId); +static void Phase2Task_Champion(u8 taskId); +static void Phase2Task_Aqua(u8 taskId); +static void Phase2Task_Magma(u8 taskId); +static void Phase2Task_Regice(u8 taskId); +static void Phase2Task_Registeel(u8 taskId); +static void Phase2Task_Regirock(u8 taskId); +static void Phase2Task_Kyogre(u8 taskId); +static void Phase2Task_Groudon(u8 taskId); +static void Phase2Task_Rayquaza(u8 taskId); +static void Phase2Task_ShredSplit(u8 taskId); +static void Phase2Task_Blackhole1(u8 taskId); +static void Phase2Task_Blackhole2(u8 taskId); +static void Phase2Task_RectangularSpiral(u8 taskId); +static void Phase2Task_29(u8 taskId); +static void Phase2Task_30(u8 taskId); +static void Phase2Task_31(u8 taskId); +static void Phase2Task_32(u8 taskId); +static void Phase2Task_33(u8 taskId); +static void VBlankCB_BattleTransition(void); +static void VBlankCB_Phase2_Swirl(void); +static void HBlankCB_Phase2_Swirl(void); +static void VBlankCB_Phase2_Shuffle(void); +static void HBlankCB_Phase2_Shuffle(void); +static void VBlankCB0_Phase2_BigPokeball(void); +static void VBlankCB1_Phase2_BigPokeball(void); +static void VBlankCB_Phase2_Clockwise_BlackFade(void); +static void VBlankCB_Phase2_Ripple(void); +static void HBlankCB_Phase2_Ripple(void); +static void VBlankCB_Phase2_30(void); +static void HBlankCB_Phase2_30(void); +static void VBlankCB_Phase2_Wave(void); +static void VBlankCB_Phase2_Slice(void); +static void HBlankCB_Phase2_Slice(void); +static void VBlankCB0_Phase2_WhiteFade(void); +static void VBlankCB1_Phase2_WhiteFade(void); +static void HBlankCB_Phase2_WhiteFade(void); +static void VBlankCB_Phase2_Shards(void); +static void VBlankCB_Phase2_Rayquaza(void); +static bool8 Phase2_Blur_Func1(struct Task *task); +static bool8 Phase2_Blur_Func2(struct Task *task); +static bool8 Phase2_Blur_Func3(struct Task *task); +static bool8 Phase2_Swirl_Func1(struct Task *task); +static bool8 Phase2_Swirl_Func2(struct Task *task); +static bool8 Phase2_Shuffle_Func1(struct Task *task); +static bool8 Phase2_Shuffle_Func2(struct Task *task); +static bool8 Phase2_Aqua_Func1(struct Task *task); +static bool8 Phase2_Aqua_Func2(struct Task *task); +static bool8 Phase2_Magma_Func1(struct Task *task); +static bool8 Phase2_Magma_Func2(struct Task *task); +static bool8 Phase2_FramesCountdown(struct Task *task); +static bool8 Phase2_Regi_Func1(struct Task *task); +static bool8 Phase2_Regice_Func2(struct Task *task); +static bool8 Phase2_Registeel_Func2(struct Task *task); +static bool8 Phase2_Regirock_Func2(struct Task *task); +static bool8 Phase2_WeatherTrio_Func1(struct Task *task); +static bool8 Phase2_WaitPaletteFade(struct Task *task); +static bool8 Phase2_Kyogre_Func3(struct Task *task); +static bool8 Phase2_Kyogre_Func4(struct Task *task); +static bool8 Phase2_Kyogre_Func5(struct Task *task); +static bool8 Phase2_Groudon_Func3(struct Task *task); +static bool8 Phase2_Groudon_Func4(struct Task *task); +static bool8 Phase2_Groudon_Func5(struct Task *task); +static bool8 Phase2_WeatherDuo_Func6(struct Task *task); +static bool8 Phase2_WeatherDuo_Func7(struct Task *task); +static bool8 Phase2_BigPokeball_Func1(struct Task *task); +static bool8 Phase2_BigPokeball_Func2(struct Task *task); +static bool8 Phase2_BigPokeball_Func3(struct Task *task); +static bool8 Phase2_BigPokeball_Func4(struct Task *task); +static bool8 Phase2_BigPokeball_Func5(struct Task *task); +static bool8 Phase2_BigPokeball_Func6(struct Task *task); +static bool8 Phase2_PokeballsTrail_Func1(struct Task *task); +static bool8 Phase2_PokeballsTrail_Func2(struct Task *task); +static bool8 Phase2_PokeballsTrail_Func3(struct Task *task); +static bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task); +static bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task); +static bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task); +static bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task); +static bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task); +static bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task); +static bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task); +static bool8 Phase2_Ripple_Func1(struct Task *task); +static bool8 Phase2_Ripple_Func2(struct Task *task); +static bool8 Phase2_Wave_Func1(struct Task *task); +static bool8 Phase2_Wave_Func2(struct Task *task); +static bool8 Phase2_Wave_Func3(struct Task *task); +static bool8 Phase2_Slice_Func1(struct Task *task); +static bool8 Phase2_Slice_Func2(struct Task *task); +static bool8 Phase2_Slice_Func3(struct Task *task); +static bool8 Phase2_WhiteFade_Func1(struct Task *task); +static bool8 Phase2_WhiteFade_Func2(struct Task *task); +static bool8 Phase2_WhiteFade_Func3(struct Task *task); +static bool8 Phase2_WhiteFade_Func4(struct Task *task); +static bool8 Phase2_WhiteFade_Func5(struct Task *task); +static bool8 Phase2_GridSquares_Func1(struct Task *task); +static bool8 Phase2_GridSquares_Func2(struct Task *task); +static bool8 Phase2_GridSquares_Func3(struct Task *task); +static bool8 Phase2_Shards_Func1(struct Task *task); +static bool8 Phase2_Shards_Func2(struct Task *task); +static bool8 Phase2_Shards_Func3(struct Task *task); +static bool8 Phase2_Shards_Func4(struct Task *task); +static bool8 Phase2_Shards_Func5(struct Task *task); +static bool8 Phase2_ShredSplit_Func1(struct Task *task); +static bool8 Phase2_ShredSplit_Func2(struct Task *task); +static bool8 Phase2_ShredSplit_Func3(struct Task *task); +static bool8 Phase2_ShredSplit_Func4(struct Task *task); +static bool8 Phase2_Blackhole_Func1(struct Task *task); +static bool8 Phase2_Blackhole1_Func2(struct Task *task); +static bool8 Phase2_Blackhole1_Func3(struct Task *task); +static bool8 Phase2_Blackhole2_Func2(struct Task *task); +static bool8 Phase2_RectangularSpiral_Func1(struct Task *task); +static bool8 Phase2_RectangularSpiral_Func2(struct Task *task); +static bool8 Phase2_RectangularSpiral_Func3(struct Task *task); +static bool8 Phase2_29_Func1(struct Task *task); +static bool8 Phase2_29_Func2(struct Task *task); +static bool8 Phase2_30_Func1(struct Task *task); +static bool8 Phase2_30_Func2(struct Task *task); +static bool8 Phase2_30_Func3(struct Task *task); +static bool8 Phase2_30_Func4(struct Task *task); +static bool8 Phase2_Rayquaza_Func3(struct Task *task); +static bool8 Phase2_Rayquaza_Func4(struct Task *task); +static bool8 Phase2_Rayquaza_Func5(struct Task *task); +static bool8 Phase2_Rayquaza_Func6(struct Task *task); +static bool8 Phase2_Rayquaza_Func7(struct Task *task); +static bool8 Phase2_Rayquaza_Func8(struct Task *task); +static bool8 Phase2_Rayquaza_Func9(struct Task *task); +static bool8 Phase2_31_Func1(struct Task *task); +static bool8 Phase2_31_Func2(struct Task *task); +static bool8 Phase2_31_Func3(struct Task *task); +static bool8 Phase2_31_33_Func5(struct Task *task); +static bool8 Phase2_33_Func1(struct Task *task); +static bool8 Phase2_33_Func2(struct Task *task); +static bool8 Phase2_33_Func3(struct Task *task); +static bool8 Phase2_33_Func4(struct Task *task); +static bool8 Phase2_32_Func1(struct Task *task); +static bool8 Phase2_32_Func2(struct Task *task); +static bool8 Phase2_32_Func3(struct Task *task); +static bool8 Phase2_32_Func4(struct Task *task); +static bool8 Phase2_32_Func5(struct Task *task); +static bool8 Phase2_Mugshot_Func1(struct Task *task); +static bool8 Phase2_Mugshot_Func2(struct Task *task); +static bool8 Phase2_Mugshot_Func3(struct Task *task); +static bool8 Phase2_Mugshot_Func4(struct Task *task); +static bool8 Phase2_Mugshot_Func5(struct Task *task); +static bool8 Phase2_Mugshot_Func6(struct Task *task); +static bool8 Phase2_Mugshot_Func7(struct Task *task); +static bool8 Phase2_Mugshot_Func8(struct Task *task); +static bool8 Phase2_Mugshot_Func9(struct Task *task); +static bool8 Phase2_Mugshot_Func10(struct Task *task); +static void Phase2Task_MugShotTransition(u8 taskId); +static void Mugshots_CreateOpponentPlayerSprites(struct Task *task); +static void VBlankCB0_Phase2_Mugshots(void); +static void VBlankCB1_Phase2_Mugshots(void); +static void HBlankCB_Phase2_Mugshots(void); +static bool8 Transition_Phase1(struct Task *task); +static bool8 Transition_WaitForPhase1(struct Task *task); +static bool8 Transition_Phase2(struct Task *task); +static bool8 Transition_WaitForPhase2(struct Task *task); +static void sub_8149F08(void); +static void sub_8149F84(void); +static void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); +static void sub_814A014(u16 *a0, s16 a1, s16 a2, s16 a3); +static void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize); +static void sub_8149F40(u16 **a0); +static void sub_814A1AC(s16 *a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); +static bool8 sub_814A228(s16 *a0, bool8 a1, bool8 a2); +static void sub_8148484(s16 spriteId, s16 value); +static void sub_814849C(s16 spriteId); +static s16 sub_81484B8(s16 spriteId); +static bool8 Phase1_TransitionAll_Func1(struct Task *task); +static bool8 Phase1_TransitionAll_Func2(struct Task *task); +static bool8 IsPhase1Done(void); +static bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1); +static void sub_814713C(struct Sprite *sprite); +static void sub_8148380(struct Sprite *sprite); +static void sub_8149864(struct Sprite *sprite); +static bool8 sub_81483A8(struct Sprite *sprite); +static bool8 sub_81483AC(struct Sprite *sprite); +static bool8 sub_81483F8(struct Sprite *sprite); +static bool8 sub_814842C(struct Sprite *sprite); +static bool8 sub_8148458(struct Sprite *sprite); // iwram bss vars IWRAM_DATA static s16 sUnusedRectangularSpiralVar; @@ -275,53 +278,53 @@ IWRAM_DATA static struct StructRectangularSpiral sRectangularSpiralTransition[4] EWRAM_DATA static struct TransitionData *sTransitionStructPtr = NULL; // const rom data -const u32 sBigPokeball_Tileset[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp"); -const u32 sPokeballTrail_Tileset[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp"); -const u8 sSpriteImage_85B98F0[] = INCBIN_U8("graphics/battle_transitions/pokeball.4bpp"); -const u32 sUnknown_085B9AF0[] = INCBIN_U32("graphics/battle_transitions/elite_four_bg.4bpp"); -const u8 sSpriteImage_85B9CD0[] = INCBIN_U8("graphics/battle_transitions/unused_brendan.4bpp"); -const u8 sSpriteImage_85BA4D0[] = INCBIN_U8("graphics/battle_transitions/unused_lass.4bpp"); -const u32 sShrinkingBoxTileset[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); -const u32 sEvilTeam_Palette[] = INCBIN_U32("graphics/battle_transitions/evil_team.gbapal"); -const u32 sTeamAqua_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_aqua.4bpp.lz"); -const u32 sTeamAqua_Tilemap[] = INCBIN_U32("graphics/battle_transitions/team_aqua.bin.lz"); -const u32 sTeamMagma_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_magma.4bpp.lz"); -const u32 sTeamMagma_Tilemap[] = INCBIN_U32("graphics/battle_transitions/team_magma.bin.lz"); -const u32 gUnknown_085BBC14[] = INCBIN_U32("graphics/battle_transitions/85BBC14.4bpp"); -const u32 gUnknown_085BC2B4[] = INCBIN_U32("graphics/battle_transitions/85BC2B4.gbapal"); -const u32 gUnknown_085BC2D4[] = INCBIN_U32("graphics/battle_transitions/85BC2D4.gbapal"); -const u32 gUnknown_085BC2F4[] = INCBIN_U32("graphics/battle_transitions/85BC2F4.gbapal"); -const u32 gUnknown_085BC314[] = INCBIN_U32("graphics/battle_transitions/85BC314.bin"); -const u32 gUnknown_085BCB14[] = INCBIN_U32("graphics/battle_transitions/85BCB14.bin"); -const u32 gUnknown_085BD314[] = INCBIN_U32("graphics/battle_transitions/85BD314.bin"); -const u16 gUnknown_085BDB14[] = INCBIN_U16("graphics/battle_transitions/85BDB14.gbapal"); -const u32 gUnknown_085BDB34[] = INCBIN_U32("graphics/battle_transitions/kyogre.4bpp.lz"); -const u32 gUnknown_085BE1E8[] = INCBIN_U32("graphics/battle_transitions/kyogre.bin.lz"); -const u32 gUnknown_085BE51C[] = INCBIN_U32("graphics/battle_transitions/groudon.4bpp.lz"); -const u32 gUnknown_085BEA88[] = INCBIN_U32("graphics/battle_transitions/groudon.bin.lz"); -const u16 gUnknown_085BEDA0[] = INCBIN_U16("graphics/battle_transitions/kyogre_pt1.gbapal"); -const u16 gUnknown_085BEEE0[] = INCBIN_U16("graphics/battle_transitions/kyogre_pt2.gbapal"); -const u16 gUnknown_085BF0A0[] = INCBIN_U16("graphics/battle_transitions/groudon_pt1.gbapal"); -const u16 gUnknown_085BF2A0[] = INCBIN_U16("graphics/battle_transitions/groudon_pt2.gbapal"); -const u16 gUnknown_085BF4A0[] = INCBIN_U16("graphics/battle_transitions/rayquaza.gbapal"); -const u32 gUnknown_085BF6A0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.4bpp"); -const u32 gUnknown_085C6BE0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.bin"); -const u32 gUnknown_085C7BE0[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.gbapal"); -const u32 gUnknown_085C7C00[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.4bpp.lz"); -const u32 gUnknown_085C828C[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.bin.lz"); -const u32 gUnknown_085C8578[] = INCBIN_U32("graphics/battle_transitions/frontier_squares_blanktiles.gbapal"); -const u32 gUnknown_085C8598[] = INCBIN_U32("graphics/battle_transitions/frontier_square_1.4bpp.lz"); -const u32 gUnknown_085C86F4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_2.4bpp.lz"); -const u32 gUnknown_085C87F4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_3.4bpp.lz"); -const u32 gUnknown_085C88A4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_4.4bpp.lz"); -const u32 gUnknown_085C8928[] = INCBIN_U32("graphics/battle_transitions/frontier_squares.bin"); - -const TaskFunc sPhase1_Tasks[B_TRANSITION_COUNT] = +static const u32 sBigPokeball_Tileset[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp"); +static const u32 sPokeballTrail_Tileset[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp"); +static const u8 sSpriteImage_85B98F0[] = INCBIN_U8("graphics/battle_transitions/pokeball.4bpp"); +static const u32 sUnknown_085B9AF0[] = INCBIN_U32("graphics/battle_transitions/elite_four_bg.4bpp"); +static const u8 sSpriteImage_85B9CD0[] = INCBIN_U8("graphics/battle_transitions/unused_brendan.4bpp"); +static const u8 sSpriteImage_85BA4D0[] = INCBIN_U8("graphics/battle_transitions/unused_lass.4bpp"); +static const u32 sShrinkingBoxTileset[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); +static const u32 sEvilTeam_Palette[] = INCBIN_U32("graphics/battle_transitions/evil_team.gbapal"); +static const u32 sTeamAqua_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_aqua.4bpp.lz"); +static const u32 sTeamAqua_Tilemap[] = INCBIN_U32("graphics/battle_transitions/team_aqua.bin.lz"); +static const u32 sTeamMagma_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_magma.4bpp.lz"); +static const u32 sTeamMagma_Tilemap[] = INCBIN_U32("graphics/battle_transitions/team_magma.bin.lz"); +static const u32 gUnknown_085BBC14[] = INCBIN_U32("graphics/battle_transitions/85BBC14.4bpp"); +static const u32 gUnknown_085BC2B4[] = INCBIN_U32("graphics/battle_transitions/85BC2B4.gbapal"); +static const u32 gUnknown_085BC2D4[] = INCBIN_U32("graphics/battle_transitions/85BC2D4.gbapal"); +static const u32 gUnknown_085BC2F4[] = INCBIN_U32("graphics/battle_transitions/85BC2F4.gbapal"); +static const u32 gUnknown_085BC314[] = INCBIN_U32("graphics/battle_transitions/85BC314.bin"); +static const u32 gUnknown_085BCB14[] = INCBIN_U32("graphics/battle_transitions/85BCB14.bin"); +static const u32 gUnknown_085BD314[] = INCBIN_U32("graphics/battle_transitions/85BD314.bin"); +static const u16 gUnknown_085BDB14[] = INCBIN_U16("graphics/battle_transitions/85BDB14.gbapal"); +static const u32 gUnknown_085BDB34[] = INCBIN_U32("graphics/battle_transitions/kyogre.4bpp.lz"); +static const u32 gUnknown_085BE1E8[] = INCBIN_U32("graphics/battle_transitions/kyogre.bin.lz"); +static const u32 gUnknown_085BE51C[] = INCBIN_U32("graphics/battle_transitions/groudon.4bpp.lz"); +static const u32 gUnknown_085BEA88[] = INCBIN_U32("graphics/battle_transitions/groudon.bin.lz"); +static const u16 gUnknown_085BEDA0[] = INCBIN_U16("graphics/battle_transitions/kyogre_pt1.gbapal"); +static const u16 gUnknown_085BEEE0[] = INCBIN_U16("graphics/battle_transitions/kyogre_pt2.gbapal"); +static const u16 gUnknown_085BF0A0[] = INCBIN_U16("graphics/battle_transitions/groudon_pt1.gbapal"); +static const u16 gUnknown_085BF2A0[] = INCBIN_U16("graphics/battle_transitions/groudon_pt2.gbapal"); +static const u16 gUnknown_085BF4A0[] = INCBIN_U16("graphics/battle_transitions/rayquaza.gbapal"); +static const u32 gUnknown_085BF6A0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.4bpp"); +static const u32 gUnknown_085C6BE0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.bin"); +static const u32 gUnknown_085C7BE0[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.gbapal"); +static const u32 gUnknown_085C7C00[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.4bpp.lz"); +static const u32 gUnknown_085C828C[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.bin.lz"); +static const u32 gUnknown_085C8578[] = INCBIN_U32("graphics/battle_transitions/frontier_squares_blanktiles.gbapal"); +static const u32 gUnknown_085C8598[] = INCBIN_U32("graphics/battle_transitions/frontier_square_1.4bpp.lz"); +static const u32 gUnknown_085C86F4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_2.4bpp.lz"); +static const u32 gUnknown_085C87F4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_3.4bpp.lz"); +static const u32 gUnknown_085C88A4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_4.4bpp.lz"); +static const u32 gUnknown_085C8928[] = INCBIN_U32("graphics/battle_transitions/frontier_squares.bin"); + +static const TaskFunc sPhase1_Tasks[B_TRANSITION_COUNT] = { [0 ... B_TRANSITION_COUNT - 1] = &Phase1Task_TransitionAll }; -const TaskFunc sPhase2_Tasks[B_TRANSITION_COUNT] = +static const TaskFunc sPhase2_Tasks[B_TRANSITION_COUNT] = { Phase2Task_Blur, // 0 Phase2Task_Swirl, // 1 @@ -367,7 +370,7 @@ const TaskFunc sPhase2_Tasks[B_TRANSITION_COUNT] = Phase2Task_41, // 41 }; -const TransitionStateFunc sMainTransitionPhases[] = +static const TransitionStateFunc sMainTransitionPhases[] = { &Transition_Phase1, &Transition_WaitForPhase1, @@ -375,26 +378,26 @@ const TransitionStateFunc sMainTransitionPhases[] = &Transition_WaitForPhase2 }; -const TransitionStateFunc sPhase2_Blur_Funcs[] = +static const TransitionStateFunc sPhase2_Blur_Funcs[] = { Phase2_Blur_Func1, Phase2_Blur_Func2, Phase2_Blur_Func3 }; -const TransitionStateFunc sPhase2_Swirl_Funcs[] = +static const TransitionStateFunc sPhase2_Swirl_Funcs[] = { Phase2_Swirl_Func1, Phase2_Swirl_Func2, }; -const TransitionStateFunc sPhase2_Shuffle_Funcs[] = +static const TransitionStateFunc sPhase2_Shuffle_Funcs[] = { Phase2_Shuffle_Func1, Phase2_Shuffle_Func2, }; -const TransitionStateFunc sPhase2_Aqua_Funcs[] = +static const TransitionStateFunc sPhase2_Aqua_Funcs[] = { Phase2_Aqua_Func1, Phase2_Aqua_Func2, @@ -405,7 +408,7 @@ const TransitionStateFunc sPhase2_Aqua_Funcs[] = Phase2_BigPokeball_Func6 }; -const TransitionStateFunc sPhase2_Magma_Funcs[] = +static const TransitionStateFunc sPhase2_Magma_Funcs[] = { Phase2_Magma_Func1, Phase2_Magma_Func2, @@ -416,7 +419,7 @@ const TransitionStateFunc sPhase2_Magma_Funcs[] = Phase2_BigPokeball_Func6 }; -const TransitionStateFunc sPhase2_BigPokeball_Funcs[] = +static const TransitionStateFunc sPhase2_BigPokeball_Funcs[] = { Phase2_BigPokeball_Func1, Phase2_BigPokeball_Func2, @@ -426,7 +429,7 @@ const TransitionStateFunc sPhase2_BigPokeball_Funcs[] = Phase2_BigPokeball_Func6 }; -const TransitionStateFunc sPhase2_Regice_Funcs[] = +static const TransitionStateFunc sPhase2_Regice_Funcs[] = { Phase2_Regi_Func1, Phase2_Regice_Func2, @@ -436,7 +439,7 @@ const TransitionStateFunc sPhase2_Regice_Funcs[] = Phase2_BigPokeball_Func6 }; -const TransitionStateFunc sPhase2_Registeel_Funcs[] = +static const TransitionStateFunc sPhase2_Registeel_Funcs[] = { Phase2_Regi_Func1, Phase2_Registeel_Func2, @@ -446,7 +449,7 @@ const TransitionStateFunc sPhase2_Registeel_Funcs[] = Phase2_BigPokeball_Func6 }; -const TransitionStateFunc sPhase2_Regirock_Funcs[] = +static const TransitionStateFunc sPhase2_Regirock_Funcs[] = { Phase2_Regi_Func1, Phase2_Regirock_Func2, @@ -456,7 +459,7 @@ const TransitionStateFunc sPhase2_Regirock_Funcs[] = Phase2_BigPokeball_Func6 }; -const TransitionStateFunc sPhase2_Kyogre_Funcs[] = +static const TransitionStateFunc sPhase2_Kyogre_Funcs[] = { Phase2_WeatherTrio_Func1, Phase2_WaitPaletteFade, @@ -468,18 +471,18 @@ const TransitionStateFunc sPhase2_Kyogre_Funcs[] = Phase2_WeatherDuo_Func7 }; -const TransitionStateFunc sPhase2_PokeballsTrail_Funcs[] = +static const TransitionStateFunc sPhase2_PokeballsTrail_Funcs[] = { Phase2_PokeballsTrail_Func1, Phase2_PokeballsTrail_Func2, Phase2_PokeballsTrail_Func3 }; -const s16 sUnknown_085C8B88[2] = {-16, 256}; -const s16 sUnknown_085C8B8C[5] = {0, 32, 64, 18, 48}; -const s16 sUnknown_085C8B96[2] = {8, -8}; +static const s16 sUnknown_085C8B88[2] = {-16, 256}; +static const s16 sUnknown_085C8B8C[5] = {0, 32, 64, 18, 48}; +static const s16 sUnknown_085C8B96[2] = {8, -8}; -const TransitionStateFunc sPhase2_Clockwise_BlackFade_Funcs[] = +static const TransitionStateFunc sPhase2_Clockwise_BlackFade_Funcs[] = { Phase2_Clockwise_BlackFade_Func1, Phase2_Clockwise_BlackFade_Func2, @@ -490,20 +493,20 @@ const TransitionStateFunc sPhase2_Clockwise_BlackFade_Funcs[] = Phase2_Clockwise_BlackFade_Func7 }; -const TransitionStateFunc sPhase2_Ripple_Funcs[] = +static const TransitionStateFunc sPhase2_Ripple_Funcs[] = { Phase2_Ripple_Func1, Phase2_Ripple_Func2 }; -const TransitionStateFunc sPhase2_Wave_Funcs[] = +static const TransitionStateFunc sPhase2_Wave_Funcs[] = { Phase2_Wave_Func1, Phase2_Wave_Func2, Phase2_Wave_Func3 }; -const TransitionStateFunc sPhase2_Mugshot_Funcs[] = +static const TransitionStateFunc sPhase2_Mugshot_Funcs[] = { Phase2_Mugshot_Func1, Phase2_Mugshot_Func2, @@ -517,7 +520,7 @@ const TransitionStateFunc sPhase2_Mugshot_Funcs[] = Phase2_Mugshot_Func10 }; -const u8 sMugshotsTrainerPicIDsTable[MUGSHOTS_COUNT] = +static const u8 sMugshotsTrainerPicIDsTable[MUGSHOTS_COUNT] = { TRAINER_PIC_ELITE_FOUR_SIDNEY, TRAINER_PIC_ELITE_FOUR_PHOEBE, @@ -525,7 +528,7 @@ const u8 sMugshotsTrainerPicIDsTable[MUGSHOTS_COUNT] = TRAINER_PIC_ELITE_FOUR_DRAKE, TRAINER_PIC_CHAMPION_WALLACE }; -const s16 sMugshotsOpponentRotationScales[MUGSHOTS_COUNT][2] = +static const s16 sMugshotsOpponentRotationScales[MUGSHOTS_COUNT][2] = { {0x200, 0x200}, {0x200, 0x200}, @@ -533,7 +536,7 @@ const s16 sMugshotsOpponentRotationScales[MUGSHOTS_COUNT][2] = {0x1A0, 0x1A0}, {0x188, 0x188}, }; -const s16 sMugshotsOpponentCoords[MUGSHOTS_COUNT][2] = +static const s16 sMugshotsOpponentCoords[MUGSHOTS_COUNT][2] = { {0, 0}, {0, 0}, @@ -542,7 +545,7 @@ const s16 sMugshotsOpponentCoords[MUGSHOTS_COUNT][2] = {-8, 7}, }; -const TransitionSpriteCallback sUnknown_085C8C24[] = +static const TransitionSpriteCallback sUnknown_085C8C24[] = { sub_81483A8, sub_81483AC, @@ -553,17 +556,17 @@ const TransitionSpriteCallback sUnknown_085C8C24[] = sub_81483A8 }; -const s16 sUnknown_085C8C40[2] = {12, -12}; -const s16 sUnknown_085C8C44[2] = {-1, 1}; +static const s16 sUnknown_085C8C40[2] = {12, -12}; +static const s16 sUnknown_085C8C44[2] = {-1, 1}; -const TransitionStateFunc sPhase2_Slice_Funcs[] = +static const TransitionStateFunc sPhase2_Slice_Funcs[] = { Phase2_Slice_Func1, Phase2_Slice_Func2, Phase2_Slice_Func3 }; -const TransitionStateFunc sPhase2_ShredSplit_Funcs[] = +static const TransitionStateFunc sPhase2_ShredSplit_Funcs[] = { Phase2_ShredSplit_Func1, Phase2_ShredSplit_Func2, @@ -571,49 +574,49 @@ const TransitionStateFunc sPhase2_ShredSplit_Funcs[] = Phase2_ShredSplit_Func4 }; -const u8 gUnknown_085C8C64[] = {39, 119}; -const s16 gUnknown_085C8C66[] = {1, -1}; +static const u8 gUnknown_085C8C64[] = {39, 119}; +static const s16 gUnknown_085C8C66[] = {1, -1}; -const TransitionStateFunc sPhase2_Blackhole1_Funcs[] = +static const TransitionStateFunc sPhase2_Blackhole1_Funcs[] = { Phase2_Blackhole_Func1, Phase2_Blackhole1_Func2, Phase2_Blackhole1_Func3 }; -const TransitionStateFunc sPhase2_Blackhole2_Funcs[] = +static const TransitionStateFunc sPhase2_Blackhole2_Funcs[] = { Phase2_Blackhole_Func1, Phase2_Blackhole2_Func2 }; -const s16 gUnknown_085C8C80[] = {-6, 4}; +static const s16 gUnknown_085C8C80[] = {-6, 4}; -const TransitionStateFunc sPhase2_RectangularSpiral_Funcs[] = +static const TransitionStateFunc sPhase2_RectangularSpiral_Funcs[] = { Phase2_RectangularSpiral_Func1, Phase2_RectangularSpiral_Func2, Phase2_RectangularSpiral_Func3 }; -const s16 gUnknown_085C8C90[] = {1, 27, 275, -1}; -const s16 gUnknown_085C8C98[] = {2, 486, -1}; -const s16 gUnknown_085C8C9E[] = {3, 262, -1}; -const s16 gUnknown_085C8CA4[] = {4, 507, -2}; -const s16 gUnknown_085C8CAA[] = {1, 213, -1}; -const s16 gUnknown_085C8CB0[] = {2, 548, -2}; -const s16 gUnknown_085C8CB6[] = {3, 196, -1}; -const s16 gUnknown_085C8CBC[] = {4, 573, 309, -1}; -const s16 gUnknown_085C8CC4[] = {1, 474, -1}; -const s16 gUnknown_085C8CCA[] = {2, 295, 32, -1}; -const s16 gUnknown_085C8CD2[] = {3, 58, -1}; -const s16 gUnknown_085C8CD8[] = {4, 455, -1}; -const s16 gUnknown_085C8CDE[] = {1, 540, -1}; -const s16 gUnknown_085C8CE4[] = {2, 229, -1}; -const s16 gUnknown_085C8CEA[] = {3, 244, 28, -1}; -const s16 gUnknown_085C8CF2[] = {4, 517, -1}; - -const s16 *const gUnknown_085C8CF8[] = +static const s16 gUnknown_085C8C90[] = {1, 27, 275, -1}; +static const s16 gUnknown_085C8C98[] = {2, 486, -1}; +static const s16 gUnknown_085C8C9E[] = {3, 262, -1}; +static const s16 gUnknown_085C8CA4[] = {4, 507, -2}; +static const s16 gUnknown_085C8CAA[] = {1, 213, -1}; +static const s16 gUnknown_085C8CB0[] = {2, 548, -2}; +static const s16 gUnknown_085C8CB6[] = {3, 196, -1}; +static const s16 gUnknown_085C8CBC[] = {4, 573, 309, -1}; +static const s16 gUnknown_085C8CC4[] = {1, 474, -1}; +static const s16 gUnknown_085C8CCA[] = {2, 295, 32, -1}; +static const s16 gUnknown_085C8CD2[] = {3, 58, -1}; +static const s16 gUnknown_085C8CD8[] = {4, 455, -1}; +static const s16 gUnknown_085C8CDE[] = {1, 540, -1}; +static const s16 gUnknown_085C8CE4[] = {2, 229, -1}; +static const s16 gUnknown_085C8CEA[] = {3, 244, 28, -1}; +static const s16 gUnknown_085C8CF2[] = {4, 517, -1}; + +static const s16 *const gUnknown_085C8CF8[] = { gUnknown_085C8C90, gUnknown_085C8CA4, @@ -625,7 +628,7 @@ const s16 *const gUnknown_085C8CF8[] = gUnknown_085C8CDE }; -const s16 *const gUnknown_085C8D18[] = +static const s16 *const gUnknown_085C8D18[] = { gUnknown_085C8CBC, gUnknown_085C8CB0, @@ -637,13 +640,13 @@ const s16 *const gUnknown_085C8D18[] = gUnknown_085C8CD2 }; -const s16 *const *const gUnknown_085C8D38[] = +static const s16 *const *const gUnknown_085C8D38[] = { gUnknown_085C8CF8, gUnknown_085C8D18 }; -const TransitionStateFunc sPhase2_Groudon_Funcs[] = +static const TransitionStateFunc sPhase2_Groudon_Funcs[] = { Phase2_WeatherTrio_Func1, Phase2_WaitPaletteFade, @@ -655,7 +658,7 @@ const TransitionStateFunc sPhase2_Groudon_Funcs[] = Phase2_WeatherDuo_Func7 }; -const TransitionStateFunc sPhase2_Rayquaza_Funcs[] = +static const TransitionStateFunc sPhase2_Rayquaza_Funcs[] = { Phase2_WeatherTrio_Func1, Phase2_WaitPaletteFade, @@ -670,7 +673,7 @@ const TransitionStateFunc sPhase2_Rayquaza_Funcs[] = Phase2_Blackhole1_Func3 }; -const TransitionStateFunc sPhase2_WhiteFade_Funcs[] = +static const TransitionStateFunc sPhase2_WhiteFade_Funcs[] = { Phase2_WhiteFade_Func1, Phase2_WhiteFade_Func2, @@ -679,16 +682,16 @@ const TransitionStateFunc sPhase2_WhiteFade_Funcs[] = Phase2_WhiteFade_Func5 }; -const s16 sUnknown_085C8DA0[] = {0, 20, 15, 40, 10, 25, 35, 5}; +static const s16 sUnknown_085C8DA0[] = {0, 20, 15, 40, 10, 25, 35, 5}; -const TransitionStateFunc sPhase2_GridSquares_Funcs[] = +static const TransitionStateFunc sPhase2_GridSquares_Funcs[] = { Phase2_GridSquares_Func1, Phase2_GridSquares_Func2, Phase2_GridSquares_Func3 }; -const TransitionStateFunc sPhase2_Shards_Funcs[] = +static const TransitionStateFunc sPhase2_Shards_Funcs[] = { Phase2_Shards_Func1, Phase2_Shards_Func2, @@ -697,7 +700,7 @@ const TransitionStateFunc sPhase2_Shards_Funcs[] = Phase2_Shards_Func5 }; -const s16 sUnknown_085C8DD0[][5] = +static const s16 sUnknown_085C8DD0[][5] = { {56, 0, 0, 160, 0}, {104, 160, 240, 88, 1}, @@ -708,49 +711,49 @@ const s16 sUnknown_085C8DD0[][5] = {168, 160, 48, 0, 1}, }; -const s16 sUnknown_085C8E16[] = {8, 4, 2, 1, 1, 1, 0}; +static const s16 sUnknown_085C8E16[] = {8, 4, 2, 1, 1, 1, 0}; -const TransitionStateFunc sPhase1_TransitionAll_Funcs[] = +static const TransitionStateFunc sPhase1_TransitionAll_Funcs[] = { Phase1_TransitionAll_Func1, Phase1_TransitionAll_Func2 }; -const struct SpriteFrameImage sSpriteImageTable_85C8E2C[] = +static const struct SpriteFrameImage sSpriteImageTable_85C8E2C[] = { sSpriteImage_85B98F0, 0x200 }; -const union AnimCmd sSpriteAnim_85C8E34[] = +static const union AnimCmd sSpriteAnim_85C8E34[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; -const union AnimCmd *const sSpriteAnimTable_85C8E3C[] = +static const union AnimCmd *const sSpriteAnimTable_85C8E3C[] = { sSpriteAnim_85C8E34 }; -const union AffineAnimCmd sSpriteAffineAnim_85C8E40[] = +static const union AffineAnimCmd sSpriteAffineAnim_85C8E40[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 1), AFFINEANIMCMD_JUMP(0) }; -const union AffineAnimCmd sSpriteAffineAnim_85C8E50[] = +static const union AffineAnimCmd sSpriteAffineAnim_85C8E50[] = { AFFINEANIMCMD_FRAME(0, 0, 4, 1), AFFINEANIMCMD_JUMP(0) }; -const union AffineAnimCmd *const sSpriteAffineAnimTable_85C8E60[] = +static const union AffineAnimCmd *const sSpriteAffineAnimTable_85C8E60[] = { sSpriteAffineAnim_85C8E40, sSpriteAffineAnim_85C8E50 }; -const struct SpriteTemplate gUnknown_085C8E68 = +static const struct SpriteTemplate gUnknown_085C8E68 = { .tileTag = 0xFFFF, .paletteTag = 4105, @@ -761,7 +764,7 @@ const struct SpriteTemplate gUnknown_085C8E68 = .callback = sub_814713C }; -const struct OamData gOamData_85C8E80 = +static const struct OamData gOamData_85C8E80 = { .y = 0, .affineMode = 0, @@ -778,28 +781,28 @@ const struct OamData gOamData_85C8E80 = .affineParam = 0, }; -const struct SpriteFrameImage sSpriteImageTable_85C8E88[] = +static const struct SpriteFrameImage sSpriteImageTable_85C8E88[] = { sSpriteImage_85B9CD0, 0x800 }; -const struct SpriteFrameImage sSpriteImageTable_85C8E90[] = +static const struct SpriteFrameImage sSpriteImageTable_85C8E90[] = { sSpriteImage_85BA4D0, 0x800 }; -const union AnimCmd sSpriteAnim_85C8E98[] = +static const union AnimCmd sSpriteAnim_85C8E98[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; -const union AnimCmd *const sSpriteAnimTable_85C8EA0[] = +static const union AnimCmd *const sSpriteAnimTable_85C8EA0[] = { sSpriteAnim_85C8E98 }; -const struct SpriteTemplate sSpriteTemplate_85C8EA4 = +static const struct SpriteTemplate sSpriteTemplate_85C8EA4 = { .tileTag = 0xFFFF, .paletteTag = 4106, @@ -810,7 +813,7 @@ const struct SpriteTemplate sSpriteTemplate_85C8EA4 = .callback = sub_8148380 }; -const struct SpriteTemplate sSpriteTemplate_85C8EBC = +static const struct SpriteTemplate sSpriteTemplate_85C8EBC = { .tileTag = 0xFFFF, .paletteTag = 4106, @@ -821,22 +824,22 @@ const struct SpriteTemplate sSpriteTemplate_85C8EBC = .callback = sub_8148380 }; -const u16 gFieldEffectObjectPalette10[] = INCBIN_U16("graphics/map_objects/palettes/field_effect_object_palette_10.gbapal"); +static const u16 gFieldEffectObjectPalette10[] = INCBIN_U16("graphics/map_objects/palettes/field_effect_object_palette_10.gbapal"); const struct SpritePalette gFieldEffectObjectPaletteInfo10 = { gFieldEffectObjectPalette10, 0x1009 }; -const u16 sMugshotPal_Sydney[] = INCBIN_U16("graphics/battle_transitions/sidney_bg.gbapal"); -const u16 sMugshotPal_Phoebe[] = INCBIN_U16("graphics/battle_transitions/phoebe_bg.gbapal"); -const u16 sMugshotPal_Glacia[] = INCBIN_U16("graphics/battle_transitions/glacia_bg.gbapal"); -const u16 sMugshotPal_Drake[] = INCBIN_U16("graphics/battle_transitions/drake_bg.gbapal"); -const u16 sMugshotPal_Champion[] = INCBIN_U16("graphics/battle_transitions/wallace_bg.gbapal"); -const u16 sMugshotPal_Brendan[] = INCBIN_U16("graphics/battle_transitions/brendan_bg.gbapal"); -const u16 sMugshotPal_May[] = INCBIN_U16("graphics/battle_transitions/may_bg.gbapal"); +static const u16 sMugshotPal_Sydney[] = INCBIN_U16("graphics/battle_transitions/sidney_bg.gbapal"); +static const u16 sMugshotPal_Phoebe[] = INCBIN_U16("graphics/battle_transitions/phoebe_bg.gbapal"); +static const u16 sMugshotPal_Glacia[] = INCBIN_U16("graphics/battle_transitions/glacia_bg.gbapal"); +static const u16 sMugshotPal_Drake[] = INCBIN_U16("graphics/battle_transitions/drake_bg.gbapal"); +static const u16 sMugshotPal_Champion[] = INCBIN_U16("graphics/battle_transitions/wallace_bg.gbapal"); +static const u16 sMugshotPal_Brendan[] = INCBIN_U16("graphics/battle_transitions/brendan_bg.gbapal"); +static const u16 sMugshotPal_May[] = INCBIN_U16("graphics/battle_transitions/may_bg.gbapal"); -const u16 *const sOpponentMugshotsPals[MUGSHOTS_COUNT] = +static const u16 *const sOpponentMugshotsPals[MUGSHOTS_COUNT] = { sMugshotPal_Sydney, sMugshotPal_Phoebe, @@ -845,22 +848,22 @@ const u16 *const sOpponentMugshotsPals[MUGSHOTS_COUNT] = sMugshotPal_Champion }; -const u16 *const sPlayerMugshotsPals[2] = +static const u16 *const sPlayerMugshotsPals[2] = { sMugshotPal_Brendan, sMugshotPal_May }; -const u16 sUnusedTrainerPalette[] = INCBIN_U16("graphics/battle_transitions/unused_trainer.gbapal"); -const struct SpritePalette sSpritePalette_UnusedTrainer = +static const u16 sUnusedTrainerPalette[] = INCBIN_U16("graphics/battle_transitions/unused_trainer.gbapal"); +static const struct SpritePalette sSpritePalette_UnusedTrainer = { sUnusedTrainerPalette, 0x100A }; -const u16 sBigPokeball_Tilemap[] = INCBIN_U16("graphics/battle_transitions/big_pokeball_map.bin"); -const u16 sMugshotsTilemap[] = INCBIN_U16("graphics/battle_transitions/elite_four_bg_map.bin"); +static const u16 sBigPokeball_Tilemap[] = INCBIN_U16("graphics/battle_transitions/big_pokeball_map.bin"); +static const u16 sMugshotsTilemap[] = INCBIN_U16("graphics/battle_transitions/elite_four_bg_map.bin"); -const TransitionStateFunc sPhase2_29_Funcs[] = +static const TransitionStateFunc sPhase2_29_Funcs[] = { Phase2_29_Func1, Phase2_29_Func2, @@ -870,7 +873,7 @@ const TransitionStateFunc sPhase2_29_Funcs[] = Phase2_BigPokeball_Func6 }; -const TransitionStateFunc sPhase2_30_Funcs[] = +static const TransitionStateFunc sPhase2_30_Funcs[] = { Phase2_30_Func1, Phase2_30_Func2, @@ -878,7 +881,7 @@ const TransitionStateFunc sPhase2_30_Funcs[] = Phase2_30_Func4 }; -const TransitionStateFunc sPhase2_31_Funcs[] = +static const TransitionStateFunc sPhase2_31_Funcs[] = { Phase2_31_Func1, Phase2_31_Func2, @@ -886,7 +889,7 @@ const TransitionStateFunc sPhase2_31_Funcs[] = Phase2_31_33_Func5 }; -const TransitionStateFunc sPhase2_33_Funcs[] = +static const TransitionStateFunc sPhase2_33_Funcs[] = { Phase2_33_Func1, Phase2_33_Func2, @@ -895,7 +898,7 @@ const TransitionStateFunc sPhase2_33_Funcs[] = Phase2_31_33_Func5 }; -const TransitionStateFunc sPhase2_32_Funcs[] = +static const TransitionStateFunc sPhase2_32_Funcs[] = { Phase2_32_Func1, Phase2_32_Func2, @@ -904,8 +907,8 @@ const TransitionStateFunc sPhase2_32_Funcs[] = Phase2_32_Func5 }; -const u8 gUnknown_085C9A30[] = {0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x1b, 0x14, 0x0d, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0e, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x13, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x0f, 0x10, 0x11, 0x12}; -const u8 gUnknown_085C9A53[] = {0x00, 0x10, 0x29, 0x16, 0x2c, 0x02, 0x2b, 0x15, 0x2e, 0x1b, 0x09, 0x30, 0x26, 0x05, 0x39, 0x3b, 0x0c, 0x3f, 0x23, 0x1c, 0x0a, 0x35, 0x07, 0x31, 0x27, 0x17, 0x37, 0x01, 0x3e, 0x11, 0x3d, 0x1e, 0x06, 0x22, 0x0f, 0x33, 0x20, 0x3a, 0x0d, 0x2d, 0x25, 0x34, 0x0b, 0x18, 0x3c, 0x13, 0x38, 0x21, 0x1d, 0x32, 0x28, 0x36, 0x0e, 0x03, 0x2f, 0x14, 0x12, 0x19, 0x04, 0x24, 0x1a, 0x2a, 0x1f, 0x08, 0x00}; +static const u8 gUnknown_085C9A30[] = {0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x1b, 0x14, 0x0d, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0e, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x13, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x0f, 0x10, 0x11, 0x12}; +static const u8 gUnknown_085C9A53[] = {0x00, 0x10, 0x29, 0x16, 0x2c, 0x02, 0x2b, 0x15, 0x2e, 0x1b, 0x09, 0x30, 0x26, 0x05, 0x39, 0x3b, 0x0c, 0x3f, 0x23, 0x1c, 0x0a, 0x35, 0x07, 0x31, 0x27, 0x17, 0x37, 0x01, 0x3e, 0x11, 0x3d, 0x1e, 0x06, 0x22, 0x0f, 0x33, 0x20, 0x3a, 0x0d, 0x2d, 0x25, 0x34, 0x0b, 0x18, 0x3c, 0x13, 0x38, 0x21, 0x1d, 0x32, 0x28, 0x36, 0x0e, 0x03, 0x2f, 0x14, 0x12, 0x19, 0x04, 0x24, 0x1a, 0x2a, 0x1f, 0x08, 0x00}; // code static void CB2_TestBattleTransition(void) @@ -970,19 +973,19 @@ bool8 IsBattleTransitionDone(void) } } -void LaunchBattleTransitionTask(u8 transitionId) +static void LaunchBattleTransitionTask(u8 transitionId) { u8 taskId = CreateTask(Task_BattleTransitionMain, 2); gTasks[taskId].tTransitionId = transitionId; sTransitionStructPtr = AllocZeroed(sizeof(*sTransitionStructPtr)); } -void Task_BattleTransitionMain(u8 taskId) +static void Task_BattleTransitionMain(u8 taskId) { while (sMainTransitionPhases[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Transition_Phase1(struct Task *task) +static bool8 Transition_Phase1(struct Task *task) { sub_80AC3D0(); CpuCopy32(gPlttBufferFaded, gPlttBufferUnfaded, 0x400); @@ -999,7 +1002,7 @@ bool8 Transition_Phase1(struct Task *task) } } -bool8 Transition_WaitForPhase1(struct Task *task) +static bool8 Transition_WaitForPhase1(struct Task *task) { if (FindTaskIdByFunc(sPhase1_Tasks[task->tTransitionId]) == 0xFF) { @@ -1012,14 +1015,14 @@ bool8 Transition_WaitForPhase1(struct Task *task) } } -bool8 Transition_Phase2(struct Task *task) +static bool8 Transition_Phase2(struct Task *task) { CreateTask(sPhase2_Tasks[task->tTransitionId], 0); task->tState++; return FALSE; } -bool8 Transition_WaitForPhase2(struct Task *task) +static bool8 Transition_WaitForPhase2(struct Task *task) { task->tTransitionDone = FALSE; if (FindTaskIdByFunc(sPhase2_Tasks[task->tTransitionId]) == 0xFF) @@ -1030,7 +1033,7 @@ bool8 Transition_WaitForPhase2(struct Task *task) #undef tTransitionId #undef tTransitionDone -void Phase1Task_TransitionAll(u8 taskId) +static void Phase1Task_TransitionAll(u8 taskId) { if (gTasks[taskId].tState == 0) { @@ -1056,12 +1059,12 @@ void Phase1Task_TransitionAll(u8 taskId) #define tPlayerSpriteId data[14] #define tMugshotId data[15] -void Phase2Task_Blur(u8 taskId) +static void Phase2Task_Blur(u8 taskId) { while (sPhase2_Blur_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Blur_Func1(struct Task *task) +static bool8 Phase2_Blur_Func1(struct Task *task) { SetGpuReg(REG_OFFSET_MOSAIC, 0); SetGpuRegBits(REG_OFFSET_BG1CNT, BGCNT_MOSAIC); @@ -1071,7 +1074,7 @@ bool8 Phase2_Blur_Func1(struct Task *task) return TRUE; } -bool8 Phase2_Blur_Func2(struct Task *task) +static bool8 Phase2_Blur_Func2(struct Task *task) { if (task->tData1 != 0) { @@ -1089,7 +1092,7 @@ bool8 Phase2_Blur_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Blur_Func3(struct Task *task) +static bool8 Phase2_Blur_Func3(struct Task *task) { if (!gPaletteFade.active) { @@ -1099,12 +1102,12 @@ bool8 Phase2_Blur_Func3(struct Task *task) return FALSE; } -void Phase2Task_Swirl(u8 taskId) +static void Phase2Task_Swirl(u8 taskId) { while (sPhase2_Swirl_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Swirl_Func1(struct Task *task) +static bool8 Phase2_Swirl_Func1(struct Task *task) { sub_8149F08(); dp12_8087EA4(); @@ -1120,7 +1123,7 @@ bool8 Phase2_Swirl_Func1(struct Task *task) return FALSE; } -bool8 Phase2_Swirl_Func2(struct Task *task) +static bool8 Phase2_Swirl_Func2(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; task->tData1 += 4; @@ -1138,14 +1141,14 @@ bool8 Phase2_Swirl_Func2(struct Task *task) return FALSE; } -void VBlankCB_Phase2_Swirl(void) +static void VBlankCB_Phase2_Swirl(void) { VBlankCB_BattleTransition(); if (sTransitionStructPtr->VBlank_DMA) DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); } -void HBlankCB_Phase2_Swirl(void) +static void HBlankCB_Phase2_Swirl(void) { u16 var = gUnknown_02038C28[1][REG_VCOUNT]; REG_BG1HOFS = var; @@ -1153,12 +1156,12 @@ void HBlankCB_Phase2_Swirl(void) REG_BG3HOFS = var; } -void Phase2Task_Shuffle(u8 taskId) +static void Phase2Task_Shuffle(u8 taskId) { while (sPhase2_Shuffle_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Shuffle_Func1(struct Task *task) +static bool8 Phase2_Shuffle_Func1(struct Task *task) { sub_8149F08(); dp12_8087EA4(); @@ -1175,7 +1178,7 @@ bool8 Phase2_Shuffle_Func1(struct Task *task) return FALSE; } -bool8 Phase2_Shuffle_Func2(struct Task *task) +static bool8 Phase2_Shuffle_Func2(struct Task *task) { u8 i; u16 r3, r4; @@ -1199,14 +1202,14 @@ bool8 Phase2_Shuffle_Func2(struct Task *task) return FALSE; } -void VBlankCB_Phase2_Shuffle(void) +static void VBlankCB_Phase2_Shuffle(void) { VBlankCB_BattleTransition(); if (sTransitionStructPtr->VBlank_DMA) DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); } -void HBlankCB_Phase2_Shuffle(void) +static void HBlankCB_Phase2_Shuffle(void) { u16 var = gUnknown_02038C28[1][REG_VCOUNT]; REG_BG1VOFS = var; @@ -1214,42 +1217,42 @@ void HBlankCB_Phase2_Shuffle(void) REG_BG3VOFS = var; } -void Phase2Task_BigPokeball(u8 taskId) +static void Phase2Task_BigPokeball(u8 taskId) { while (sPhase2_BigPokeball_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_Aqua(u8 taskId) +static void Phase2Task_Aqua(u8 taskId) { while (sPhase2_Aqua_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_Magma(u8 taskId) +static void Phase2Task_Magma(u8 taskId) { while (sPhase2_Magma_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_Regice(u8 taskId) +static void Phase2Task_Regice(u8 taskId) { while (sPhase2_Regice_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_Registeel(u8 taskId) +static void Phase2Task_Registeel(u8 taskId) { while (sPhase2_Registeel_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_Regirock(u8 taskId) +static void Phase2Task_Regirock(u8 taskId) { while (sPhase2_Regirock_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_Kyogre(u8 taskId) +static void Phase2Task_Kyogre(u8 taskId) { while (sPhase2_Kyogre_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void sub_814669C(struct Task *task) +static void sub_814669C(struct Task *task) { s32 i; @@ -1275,7 +1278,7 @@ void sub_814669C(struct Task *task) SetVBlankCallback(VBlankCB0_Phase2_BigPokeball); } -bool8 Phase2_Aqua_Func1(struct Task *task) +static bool8 Phase2_Aqua_Func1(struct Task *task) { u16 *dst1, *dst2; @@ -1290,7 +1293,7 @@ bool8 Phase2_Aqua_Func1(struct Task *task) return FALSE; } -bool8 Phase2_Magma_Func1(struct Task *task) +static bool8 Phase2_Magma_Func1(struct Task *task) { u16 *dst1, *dst2; @@ -1305,7 +1308,7 @@ bool8 Phase2_Magma_Func1(struct Task *task) return FALSE; } -bool8 Phase2_Regi_Func1(struct Task *task) +static bool8 Phase2_Regi_Func1(struct Task *task) { u16 *dst1, *dst2; @@ -1319,7 +1322,7 @@ bool8 Phase2_Regi_Func1(struct Task *task) return FALSE; } -bool8 Phase2_BigPokeball_Func1(struct Task *task) +static bool8 Phase2_BigPokeball_Func1(struct Task *task) { u16 *dst1, *dst2; @@ -1333,7 +1336,7 @@ bool8 Phase2_BigPokeball_Func1(struct Task *task) return FALSE; } -bool8 Phase2_BigPokeball_Func2(struct Task *task) +static bool8 Phase2_BigPokeball_Func2(struct Task *task) { s16 i, j; u16 *dst1, *dst2; @@ -1354,7 +1357,7 @@ bool8 Phase2_BigPokeball_Func2(struct Task *task) return TRUE; } -bool8 Phase2_Aqua_Func2(struct Task *task) +static bool8 Phase2_Aqua_Func2(struct Task *task) { u16 *dst1, *dst2; @@ -1366,7 +1369,7 @@ bool8 Phase2_Aqua_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Magma_Func2(struct Task *task) +static bool8 Phase2_Magma_Func2(struct Task *task) { u16 *dst1, *dst2; @@ -1378,7 +1381,7 @@ bool8 Phase2_Magma_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Regice_Func2(struct Task *task) +static bool8 Phase2_Regice_Func2(struct Task *task) { u16 *dst1, *dst2; @@ -1391,7 +1394,7 @@ bool8 Phase2_Regice_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Registeel_Func2(struct Task *task) +static bool8 Phase2_Registeel_Func2(struct Task *task) { u16 *dst1, *dst2; @@ -1404,7 +1407,7 @@ bool8 Phase2_Registeel_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Regirock_Func2(struct Task *task) +static bool8 Phase2_Regirock_Func2(struct Task *task) { u16 *dst1, *dst2; @@ -1417,7 +1420,7 @@ bool8 Phase2_Regirock_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Kyogre_Func3(struct Task *task) +static bool8 Phase2_Kyogre_Func3(struct Task *task) { u16 *dst1, *dst2; @@ -1430,7 +1433,7 @@ bool8 Phase2_Kyogre_Func3(struct Task *task) return FALSE; } -bool8 Phase2_Kyogre_Func4(struct Task *task) +static bool8 Phase2_Kyogre_Func4(struct Task *task) { if (task->tData1 % 3 == 0) { @@ -1447,7 +1450,7 @@ bool8 Phase2_Kyogre_Func4(struct Task *task) return FALSE; } -bool8 Phase2_Kyogre_Func5(struct Task *task) +static bool8 Phase2_Kyogre_Func5(struct Task *task) { if (task->tData1 % 5 == 0) { @@ -1464,14 +1467,14 @@ bool8 Phase2_Kyogre_Func5(struct Task *task) return FALSE; } -bool8 Phase2_WeatherDuo_Func6(struct Task *task) +static bool8 Phase2_WeatherDuo_Func6(struct Task *task) { BeginNormalPaletteFade(0xFFFF8000, 1, 0, 0x10, 0); task->tState++; return FALSE; } -bool8 Phase2_WeatherDuo_Func7(struct Task *task) +static bool8 Phase2_WeatherDuo_Func7(struct Task *task) { if (!gPaletteFade.active) { @@ -1482,7 +1485,7 @@ bool8 Phase2_WeatherDuo_Func7(struct Task *task) return FALSE; } -bool8 Phase2_BigPokeball_Func3(struct Task *task) +static bool8 Phase2_BigPokeball_Func3(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; if (task->tData3 == 0 || --task->tData3 == 0) @@ -1502,7 +1505,7 @@ bool8 Phase2_BigPokeball_Func3(struct Task *task) return FALSE; } -bool8 Phase2_BigPokeball_Func4(struct Task *task) +static bool8 Phase2_BigPokeball_Func4(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; if (task->tData3 == 0 || --task->tData3 == 0) @@ -1522,7 +1525,7 @@ bool8 Phase2_BigPokeball_Func4(struct Task *task) return FALSE; } -bool8 Phase2_BigPokeball_Func5(struct Task *task) +static bool8 Phase2_BigPokeball_Func5(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; task->tData4 += 8; @@ -1542,28 +1545,28 @@ bool8 Phase2_BigPokeball_Func5(struct Task *task) return FALSE; } -bool8 Phase2_FramesCountdown(struct Task *task) +static bool8 Phase2_FramesCountdown(struct Task *task) { if (--task->tFrames == 0) task->tState++; return FALSE; } -bool8 Phase2_WeatherTrio_Func1(struct Task *task) +static bool8 Phase2_WeatherTrio_Func1(struct Task *task) { BeginNormalPaletteFade(0x0000FFFF, 1, 0, 0x10, 0); task->tState++; return FALSE; } -bool8 Phase2_WaitPaletteFade(struct Task *task) +static bool8 Phase2_WaitPaletteFade(struct Task *task) { if (!gPaletteFade.active) task->tState++; return FALSE; } -bool8 Phase2_BigPokeball_Func6(struct Task *task) +static bool8 Phase2_BigPokeball_Func6(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; if (task->tData2 < 1024) @@ -1596,7 +1599,7 @@ bool8 Phase2_BigPokeball_Func6(struct Task *task) return FALSE; } -void Transition_BigPokeball_Vblank(void) +static void Transition_BigPokeball_Vblank(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -1609,24 +1612,24 @@ void Transition_BigPokeball_Vblank(void) REG_BLDALPHA = sTransitionStructPtr->BLDALPHA; } -void VBlankCB0_Phase2_BigPokeball(void) +static void VBlankCB0_Phase2_BigPokeball(void) { Transition_BigPokeball_Vblank(); DmaSet(0, gUnknown_020393A8, ®_BG0HOFS, 0xA2400001); } -void VBlankCB1_Phase2_BigPokeball(void) +static void VBlankCB1_Phase2_BigPokeball(void) { Transition_BigPokeball_Vblank(); DmaSet(0, gUnknown_020393A8, ®_WIN0H, 0xA2400001); } -void Phase2Task_PokeballsTrail(u8 taskId) +static void Phase2Task_PokeballsTrail(u8 taskId) { while (sPhase2_PokeballsTrail_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_PokeballsTrail_Func1(struct Task *task) +static bool8 Phase2_PokeballsTrail_Func1(struct Task *task) { u16 *dst1, *dst2; @@ -1639,7 +1642,7 @@ bool8 Phase2_PokeballsTrail_Func1(struct Task *task) return FALSE; } -bool8 Phase2_PokeballsTrail_Func2(struct Task *task) +static bool8 Phase2_PokeballsTrail_Func2(struct Task *task) { s16 i; s16 rand; @@ -1662,7 +1665,7 @@ bool8 Phase2_PokeballsTrail_Func2(struct Task *task) return FALSE; } -bool8 Phase2_PokeballsTrail_Func3(struct Task *task) +static bool8 Phase2_PokeballsTrail_Func3(struct Task *task) { if (!FieldEffectActiveListContains(FLDEFF_POKEBALL)) { @@ -1691,7 +1694,7 @@ bool8 FldEff_Pokeball(void) ptr[index] = toStore; \ } -void sub_814713C(struct Sprite *sprite) +static void sub_814713C(struct Sprite *sprite) { s16 arr0[ARRAY_COUNT(sUnknown_085C8B96)]; @@ -1728,12 +1731,12 @@ void sub_814713C(struct Sprite *sprite) } } -void Phase2Task_Clockwise_BlackFade(u8 taskId) +static void Phase2Task_Clockwise_BlackFade(u8 taskId) { while (sPhase2_Clockwise_BlackFade_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task) +static bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task) { u16 i; @@ -1757,7 +1760,7 @@ bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task) return TRUE; } -bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task) +static bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; @@ -1778,7 +1781,7 @@ bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task) +static bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task) { s16 r1, r3; vu8 var = 0; @@ -1816,7 +1819,7 @@ bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task) return FALSE; } -bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task) +static bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; @@ -1837,7 +1840,7 @@ bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task) return FALSE; } -bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task) +static bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task) { s16 r1, r2, var4; vu8 var = 0; @@ -1877,7 +1880,7 @@ bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task) return FALSE; } -bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task) +static bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; @@ -1901,7 +1904,7 @@ bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task) return FALSE; } -bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task) +static bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task) { DmaStop(0); sub_8149F84(); @@ -1909,7 +1912,7 @@ bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task) return FALSE; } -void VBlankCB_Phase2_Clockwise_BlackFade(void) +static void VBlankCB_Phase2_Clockwise_BlackFade(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -1922,12 +1925,12 @@ void VBlankCB_Phase2_Clockwise_BlackFade(void) DmaSet(0, gUnknown_02038C28[1], ®_WIN0H, 0xA2400001); } -void Phase2Task_Ripple(u8 taskId) +static void Phase2Task_Ripple(u8 taskId) { while (sPhase2_Ripple_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Ripple_Func1(struct Task *task) +static bool8 Phase2_Ripple_Func1(struct Task *task) { u8 i; @@ -1948,7 +1951,7 @@ bool8 Phase2_Ripple_Func1(struct Task *task) return TRUE; } -bool8 Phase2_Ripple_Func2(struct Task *task) +static bool8 Phase2_Ripple_Func2(struct Task *task) { u8 i; s16 r3; @@ -1984,14 +1987,14 @@ bool8 Phase2_Ripple_Func2(struct Task *task) return FALSE; } -void VBlankCB_Phase2_Ripple(void) +static void VBlankCB_Phase2_Ripple(void) { VBlankCB_BattleTransition(); if (sTransitionStructPtr->VBlank_DMA) DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); } -void HBlankCB_Phase2_Ripple(void) +static void HBlankCB_Phase2_Ripple(void) { u16 var = gUnknown_02038C28[1][REG_VCOUNT]; REG_BG1VOFS = var; @@ -1999,12 +2002,12 @@ void HBlankCB_Phase2_Ripple(void) REG_BG3VOFS = var; } -void Phase2Task_Wave(u8 taskId) +static void Phase2Task_Wave(u8 taskId) { while (sPhase2_Wave_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Wave_Func1(struct Task *task) +static bool8 Phase2_Wave_Func1(struct Task *task) { u8 i; @@ -2027,7 +2030,7 @@ bool8 Phase2_Wave_Func1(struct Task *task) return TRUE; } -bool8 Phase2_Wave_Func2(struct Task *task) +static bool8 Phase2_Wave_Func2(struct Task *task) { u8 i, r5; u16* toStore; @@ -2057,7 +2060,7 @@ bool8 Phase2_Wave_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Wave_Func3(struct Task *task) +static bool8 Phase2_Wave_Func3(struct Task *task) { DmaStop(0); sub_8149F84(); @@ -2065,7 +2068,7 @@ bool8 Phase2_Wave_Func3(struct Task *task) return FALSE; } -void VBlankCB_Phase2_Wave(void) +static void VBlankCB_Phase2_Wave(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -2077,42 +2080,42 @@ void VBlankCB_Phase2_Wave(void) DmaSet(0, gUnknown_02038C28[1], ®_WIN0H, 0xA2400001); } -void Phase2Task_Sydney(u8 taskId) +static void Phase2Task_Sydney(u8 taskId) { gTasks[taskId].tMugshotId = MUGSHOT_SYDNEY; Phase2Task_MugShotTransition(taskId); } -void Phase2Task_Phoebe(u8 taskId) +static void Phase2Task_Phoebe(u8 taskId) { gTasks[taskId].tMugshotId = MUGSHOT_PHOEBE; Phase2Task_MugShotTransition(taskId); } -void Phase2Task_Glacia(u8 taskId) +static void Phase2Task_Glacia(u8 taskId) { gTasks[taskId].tMugshotId = MUGSHOT_GLACIA; Phase2Task_MugShotTransition(taskId); } -void Phase2Task_Drake(u8 taskId) +static void Phase2Task_Drake(u8 taskId) { gTasks[taskId].tMugshotId = MUGSHOT_DRAKE; Phase2Task_MugShotTransition(taskId); } -void Phase2Task_Champion(u8 taskId) +static void Phase2Task_Champion(u8 taskId) { gTasks[taskId].tMugshotId = MUGSHOT_CHAMPION; Phase2Task_MugShotTransition(taskId); } -void Phase2Task_MugShotTransition(u8 taskId) +static void Phase2Task_MugShotTransition(u8 taskId) { while (sPhase2_Mugshot_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Mugshot_Func1(struct Task *task) +static bool8 Phase2_Mugshot_Func1(struct Task *task) { u8 i; @@ -2138,7 +2141,7 @@ bool8 Phase2_Mugshot_Func1(struct Task *task) return FALSE; } -bool8 Phase2_Mugshot_Func2(struct Task *task) +static bool8 Phase2_Mugshot_Func2(struct Task *task) { s16 i, j; u16 *dst1, *dst2; @@ -2165,7 +2168,7 @@ bool8 Phase2_Mugshot_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Mugshot_Func3(struct Task *task) +static bool8 Phase2_Mugshot_Func3(struct Task *task) { u8 i, r5; u16* toStore; @@ -2213,7 +2216,7 @@ bool8 Phase2_Mugshot_Func3(struct Task *task) return FALSE; } -bool8 Phase2_Mugshot_Func4(struct Task *task) +static bool8 Phase2_Mugshot_Func4(struct Task *task) { u8 i; u16* toStore; @@ -2242,7 +2245,7 @@ bool8 Phase2_Mugshot_Func4(struct Task *task) return FALSE; } -bool8 Phase2_Mugshot_Func5(struct Task *task) +static bool8 Phase2_Mugshot_Func5(struct Task *task) { sTransitionStructPtr->field_18 -= 8; sTransitionStructPtr->field_1A += 8; @@ -2254,7 +2257,7 @@ bool8 Phase2_Mugshot_Func5(struct Task *task) return FALSE; } -bool8 Phase2_Mugshot_Func6(struct Task *task) +static bool8 Phase2_Mugshot_Func6(struct Task *task) { sTransitionStructPtr->field_18 -= 8; sTransitionStructPtr->field_1A += 8; @@ -2276,7 +2279,7 @@ bool8 Phase2_Mugshot_Func6(struct Task *task) return FALSE; } -bool8 Phase2_Mugshot_Func7(struct Task *task) +static bool8 Phase2_Mugshot_Func7(struct Task *task) { bool32 r6; @@ -2317,7 +2320,7 @@ bool8 Phase2_Mugshot_Func7(struct Task *task) return FALSE; } -bool8 Phase2_Mugshot_Func8(struct Task *task) +static bool8 Phase2_Mugshot_Func8(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; BlendPalettes(-1, 0x10, 0x7FFF); @@ -2328,7 +2331,7 @@ bool8 Phase2_Mugshot_Func8(struct Task *task) return TRUE; } -bool8 Phase2_Mugshot_Func9(struct Task *task) +static bool8 Phase2_Mugshot_Func9(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; @@ -2341,7 +2344,7 @@ bool8 Phase2_Mugshot_Func9(struct Task *task) return FALSE; } -bool8 Phase2_Mugshot_Func10(struct Task *task) +static bool8 Phase2_Mugshot_Func10(struct Task *task) { DmaStop(0); sub_8149F84(); @@ -2349,7 +2352,7 @@ bool8 Phase2_Mugshot_Func10(struct Task *task) return FALSE; } -void VBlankCB0_Phase2_Mugshots(void) +static void VBlankCB0_Phase2_Mugshots(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -2362,7 +2365,7 @@ void VBlankCB0_Phase2_Mugshots(void) DmaSet(0, gUnknown_02038C28[1], ®_WIN0H, 0xA2400001); } -void VBlankCB1_Phase2_Mugshots(void) +static void VBlankCB1_Phase2_Mugshots(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -2372,7 +2375,7 @@ void VBlankCB1_Phase2_Mugshots(void) DmaSet(0, gUnknown_02038C28[1], ®_BLDY, 0xA2400001); } -void HBlankCB_Phase2_Mugshots(void) +static void HBlankCB_Phase2_Mugshots(void) { if (REG_VCOUNT < 80) REG_BG0HOFS = sTransitionStructPtr->field_18; @@ -2380,7 +2383,7 @@ void HBlankCB_Phase2_Mugshots(void) REG_BG0HOFS = sTransitionStructPtr->field_1A; } -void Mugshots_CreateOpponentPlayerSprites(struct Task *task) +static void Mugshots_CreateOpponentPlayerSprites(struct Task *task) { struct Sprite *opponentSprite, *playerSprite; @@ -2416,17 +2419,17 @@ void Mugshots_CreateOpponentPlayerSprites(struct Task *task) SetOamMatrixRotationScaling(playerSprite->oam.matrixNum, -512, 512, 0); } -void sub_8148380(struct Sprite *sprite) +static void sub_8148380(struct Sprite *sprite) { while (sUnknown_085C8C24[sprite->data[0]](sprite)); } -bool8 sub_81483A8(struct Sprite *sprite) +static bool8 sub_81483A8(struct Sprite *sprite) { return FALSE; } -bool8 sub_81483AC(struct Sprite *sprite) +static bool8 sub_81483AC(struct Sprite *sprite) { s16 arr0[2]; s16 arr1[2]; @@ -2440,7 +2443,7 @@ bool8 sub_81483AC(struct Sprite *sprite) return TRUE; } -bool8 sub_81483F8(struct Sprite *sprite) +static bool8 sub_81483F8(struct Sprite *sprite) { sprite->pos1.x += sprite->data[1]; if (sprite->data[7] && sprite->pos1.x < 133) @@ -2450,7 +2453,7 @@ bool8 sub_81483F8(struct Sprite *sprite) return FALSE; } -bool8 sub_814842C(struct Sprite *sprite) +static bool8 sub_814842C(struct Sprite *sprite) { sprite->data[1] += sprite->data[2]; sprite->pos1.x += sprite->data[1]; @@ -2463,7 +2466,7 @@ bool8 sub_814842C(struct Sprite *sprite) return FALSE; } -bool8 sub_8148458(struct Sprite *sprite) +static bool8 sub_8148458(struct Sprite *sprite) { sprite->data[1] += sprite->data[2]; sprite->pos1.x += sprite->data[1]; @@ -2472,27 +2475,27 @@ bool8 sub_8148458(struct Sprite *sprite) return FALSE; } -void sub_8148484(s16 spriteId, s16 value) +static void sub_8148484(s16 spriteId, s16 value) { gSprites[spriteId].data[7] = value; } -void sub_814849C(s16 spriteId) +static void sub_814849C(s16 spriteId) { gSprites[spriteId].data[0]++; } -s16 sub_81484B8(s16 spriteId) +static s16 sub_81484B8(s16 spriteId) { return gSprites[spriteId].data[6]; } -void Phase2Task_Slice(u8 taskId) +static void Phase2Task_Slice(u8 taskId) { while (sPhase2_Slice_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Slice_Func1(struct Task *task) +static bool8 Phase2_Slice_Func1(struct Task *task) { u16 i; @@ -2522,7 +2525,7 @@ bool8 Phase2_Slice_Func1(struct Task *task) return TRUE; } -bool8 Phase2_Slice_Func2(struct Task *task) +static bool8 Phase2_Slice_Func2(struct Task *task) { u16 i; @@ -2559,7 +2562,7 @@ bool8 Phase2_Slice_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Slice_Func3(struct Task *task) +static bool8 Phase2_Slice_Func3(struct Task *task) { DmaStop(0); sub_8149F84(); @@ -2567,7 +2570,7 @@ bool8 Phase2_Slice_Func3(struct Task *task) return FALSE; } -void VBlankCB_Phase2_Slice(void) +static void VBlankCB_Phase2_Slice(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -2579,7 +2582,7 @@ void VBlankCB_Phase2_Slice(void) DmaSet(0, &gUnknown_02038C28[1][160], ®_WIN0H, 0xA2400001); } -void HBlankCB_Phase2_Slice(void) +static void HBlankCB_Phase2_Slice(void) { if (REG_VCOUNT < 160) { @@ -2590,12 +2593,12 @@ void HBlankCB_Phase2_Slice(void) } } -void Phase2Task_ShredSplit(u8 taskId) +static void Phase2Task_ShredSplit(u8 taskId) { while (sPhase2_ShredSplit_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_ShredSplit_Func1(struct Task *task) +static bool8 Phase2_ShredSplit_Func1(struct Task *task) { u16 i; @@ -2630,7 +2633,7 @@ bool8 Phase2_ShredSplit_Func1(struct Task *task) return TRUE; } -bool8 Phase2_ShredSplit_Func2(struct Task *task) +static bool8 Phase2_ShredSplit_Func2(struct Task *task) { u16 i, j, k; u8 arr1[ARRAY_COUNT(gUnknown_085C8C64)]; @@ -2727,7 +2730,7 @@ bool8 Phase2_ShredSplit_Func2(struct Task *task) return FALSE; } -bool8 Phase2_ShredSplit_Func3(struct Task *task) +static bool8 Phase2_ShredSplit_Func3(struct Task *task) { u16 i; bool32 done = TRUE; @@ -2745,7 +2748,7 @@ bool8 Phase2_ShredSplit_Func3(struct Task *task) return FALSE; } -bool8 Phase2_ShredSplit_Func4(struct Task *task) +static bool8 Phase2_ShredSplit_Func4(struct Task *task) { DmaStop(0); sub_8149F84(); @@ -2753,17 +2756,17 @@ bool8 Phase2_ShredSplit_Func4(struct Task *task) return FALSE; } -void Phase2Task_Blackhole1(u8 taskId) +static void Phase2Task_Blackhole1(u8 taskId) { while (sPhase2_Blackhole1_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_Blackhole2(u8 taskId) +static void Phase2Task_Blackhole2(u8 taskId) { while (sPhase2_Blackhole2_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Blackhole_Func1(struct Task *task) +static bool8 Phase2_Blackhole_Func1(struct Task *task) { s32 i; @@ -2790,7 +2793,7 @@ bool8 Phase2_Blackhole_Func1(struct Task *task) return FALSE; } -bool8 Phase2_Blackhole1_Func3(struct Task *task) +static bool8 Phase2_Blackhole1_Func3(struct Task *task) { if (task->tFuncState == 1) { @@ -2822,7 +2825,7 @@ bool8 Phase2_Blackhole1_Func3(struct Task *task) return FALSE; } -bool8 Phase2_Blackhole1_Func2(struct Task *task) +static bool8 Phase2_Blackhole1_Func2(struct Task *task) { sTransitionStructPtr->VBlank_DMA = FALSE; if (task->tFuncState == 0) @@ -2844,7 +2847,7 @@ bool8 Phase2_Blackhole1_Func2(struct Task *task) return FALSE; } -bool8 Phase2_Blackhole2_Func2(struct Task *task) +static bool8 Phase2_Blackhole2_Func2(struct Task *task) { u16 index; // should be s16 I think s16 amplitude; @@ -2889,12 +2892,12 @@ bool8 Phase2_Blackhole2_Func2(struct Task *task) return FALSE; } -void Phase2Task_RectangularSpiral(u8 taskId) +static void Phase2Task_RectangularSpiral(u8 taskId) { while (sPhase2_RectangularSpiral_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_RectangularSpiral_Func1(struct Task *task) +static bool8 Phase2_RectangularSpiral_Func1(struct Task *task) { u16 *dst1, *dst2; @@ -2934,7 +2937,7 @@ bool8 Phase2_RectangularSpiral_Func1(struct Task *task) return FALSE; } -bool8 Phase2_RectangularSpiral_Func2(struct Task *task) +static bool8 Phase2_RectangularSpiral_Func2(struct Task *task) { u16 *dst1, *dst2; u8 i; @@ -2972,7 +2975,7 @@ bool8 Phase2_RectangularSpiral_Func2(struct Task *task) return FALSE; } -bool8 Phase2_RectangularSpiral_Func3(struct Task *task) +static bool8 Phase2_RectangularSpiral_Func3(struct Task *task) { DmaStop(0); sub_8149F84(); @@ -2980,7 +2983,7 @@ bool8 Phase2_RectangularSpiral_Func3(struct Task *task) return FALSE; } -bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1) +static bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1) { const s16 *array = arg0[arg1->field_0]; if (array[arg1->field_4] == -1) @@ -3043,12 +3046,12 @@ bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1 return TRUE; } -void Phase2Task_Groudon(u8 taskId) +static void Phase2Task_Groudon(u8 taskId) { while (sPhase2_Groudon_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Groudon_Func3(struct Task *task) +static bool8 Phase2_Groudon_Func3(struct Task *task) { u16 *dst1, *dst2; @@ -3062,7 +3065,7 @@ bool8 Phase2_Groudon_Func3(struct Task *task) return FALSE; } -bool8 Phase2_Groudon_Func4(struct Task *task) +static bool8 Phase2_Groudon_Func4(struct Task *task) { if (task->tData1 % 3 == 0) { @@ -3078,7 +3081,7 @@ bool8 Phase2_Groudon_Func4(struct Task *task) return FALSE; } -bool8 Phase2_Groudon_Func5(struct Task *task) +static bool8 Phase2_Groudon_Func5(struct Task *task) { if (task->tData1 % 5 == 0) { @@ -3095,12 +3098,12 @@ bool8 Phase2_Groudon_Func5(struct Task *task) return FALSE; } -void Phase2Task_Rayquaza(u8 taskId) +static void Phase2Task_Rayquaza(u8 taskId) { while (sPhase2_Rayquaza_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Rayquaza_Func3(struct Task *task) +static bool8 Phase2_Rayquaza_Func3(struct Task *task) { u16 *dst1, *dst2; u16 i; @@ -3127,7 +3130,7 @@ bool8 Phase2_Rayquaza_Func3(struct Task *task) return FALSE; } -bool8 Phase2_Rayquaza_Func4(struct Task *task) +static bool8 Phase2_Rayquaza_Func4(struct Task *task) { u16 *dst1, *dst2; @@ -3137,7 +3140,7 @@ bool8 Phase2_Rayquaza_Func4(struct Task *task) return FALSE; } -bool8 Phase2_Rayquaza_Func5(struct Task *task) +static bool8 Phase2_Rayquaza_Func5(struct Task *task) { if ((task->tData1 % 4) == 0) { @@ -3154,7 +3157,7 @@ bool8 Phase2_Rayquaza_Func5(struct Task *task) return FALSE; } -bool8 Phase2_Rayquaza_Func6(struct Task *task) +static bool8 Phase2_Rayquaza_Func6(struct Task *task) { if (++task->tData1 > 20) { @@ -3166,7 +3169,7 @@ bool8 Phase2_Rayquaza_Func6(struct Task *task) return FALSE; } -bool8 Phase2_Rayquaza_Func7(struct Task *task) +static bool8 Phase2_Rayquaza_Func7(struct Task *task) { if (!gPaletteFade.active) { @@ -3177,7 +3180,7 @@ bool8 Phase2_Rayquaza_Func7(struct Task *task) return FALSE; } -bool8 Phase2_Rayquaza_Func8(struct Task *task) +static bool8 Phase2_Rayquaza_Func8(struct Task *task) { BlendPalettes(0x00007FFF, 8, 0); BlendPalettes(0xFFFF8000, 0, 0); @@ -3186,7 +3189,7 @@ bool8 Phase2_Rayquaza_Func8(struct Task *task) return FALSE; } -bool8 Phase2_Rayquaza_Func9(struct Task *task) +static bool8 Phase2_Rayquaza_Func9(struct Task *task) { if ((task->tData1 % 3) == 0) { @@ -3218,7 +3221,7 @@ bool8 Phase2_Rayquaza_Func9(struct Task *task) return FALSE; } -void VBlankCB_Phase2_Rayquaza(void) +static void VBlankCB_Phase2_Rayquaza(void) { void *dmaSrc; @@ -3235,12 +3238,12 @@ void VBlankCB_Phase2_Rayquaza(void) DmaSet(0, dmaSrc, ®_BG0VOFS, 0xA2400001); } -void Phase2Task_WhiteFade(u8 taskId) +static void Phase2Task_WhiteFade(u8 taskId) { while (sPhase2_WhiteFade_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_WhiteFade_Func1(struct Task *task) +static bool8 Phase2_WhiteFade_Func1(struct Task *task) { u16 i; @@ -3267,7 +3270,7 @@ bool8 Phase2_WhiteFade_Func1(struct Task *task) return FALSE; } -bool8 Phase2_WhiteFade_Func2(struct Task *task) +static bool8 Phase2_WhiteFade_Func2(struct Task *task) { s16 i, posY; s16 arr1[ARRAY_COUNT(sUnknown_085C8DA0)]; @@ -3287,7 +3290,7 @@ bool8 Phase2_WhiteFade_Func2(struct Task *task) return FALSE; } -bool8 Phase2_WhiteFade_Func3(struct Task *task) +static bool8 Phase2_WhiteFade_Func3(struct Task *task) { sTransitionStructPtr->VBlank_DMA = 0; if (sTransitionStructPtr->field_20 > 7) @@ -3298,7 +3301,7 @@ bool8 Phase2_WhiteFade_Func3(struct Task *task) return FALSE; } -bool8 Phase2_WhiteFade_Func4(struct Task *task) +static bool8 Phase2_WhiteFade_Func4(struct Task *task) { sTransitionStructPtr->VBlank_DMA = 0; @@ -3317,7 +3320,7 @@ bool8 Phase2_WhiteFade_Func4(struct Task *task) return FALSE; } -bool8 Phase2_WhiteFade_Func5(struct Task *task) +static bool8 Phase2_WhiteFade_Func5(struct Task *task) { if (++sTransitionStructPtr->BLDY > 16) { @@ -3327,7 +3330,7 @@ bool8 Phase2_WhiteFade_Func5(struct Task *task) return FALSE; } -void VBlankCB0_Phase2_WhiteFade(void) +static void VBlankCB0_Phase2_WhiteFade(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -3340,7 +3343,7 @@ void VBlankCB0_Phase2_WhiteFade(void) DmaSet(0, &gUnknown_02038C28[1][160], ®_WIN0H, 0xA2400001); } -void VBlankCB1_Phase2_WhiteFade(void) +static void VBlankCB1_Phase2_WhiteFade(void) { VBlankCB_BattleTransition(); REG_BLDY = sTransitionStructPtr->BLDY; @@ -3351,12 +3354,12 @@ void VBlankCB1_Phase2_WhiteFade(void) REG_WIN0V = sTransitionStructPtr->WIN0V; } -void HBlankCB_Phase2_WhiteFade(void) +static void HBlankCB_Phase2_WhiteFade(void) { REG_BLDY = gUnknown_02038C28[1][REG_VCOUNT]; } -void sub_8149864(struct Sprite *sprite) +static void sub_8149864(struct Sprite *sprite) { if (sprite->data[5]) { @@ -3399,12 +3402,12 @@ void sub_8149864(struct Sprite *sprite) } } -void Phase2Task_GridSquares(u8 taskId) +static void Phase2Task_GridSquares(u8 taskId) { while (sPhase2_GridSquares_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_GridSquares_Func1(struct Task *task) +static bool8 Phase2_GridSquares_Func1(struct Task *task) { u16 *dst1, *dst2; @@ -3417,7 +3420,7 @@ bool8 Phase2_GridSquares_Func1(struct Task *task) return FALSE; } -bool8 Phase2_GridSquares_Func2(struct Task *task) +static bool8 Phase2_GridSquares_Func2(struct Task *task) { u16* dst1; @@ -3438,7 +3441,7 @@ bool8 Phase2_GridSquares_Func2(struct Task *task) return FALSE; } -bool8 Phase2_GridSquares_Func3(struct Task *task) +static bool8 Phase2_GridSquares_Func3(struct Task *task) { if (--task->tData1 == 0) { @@ -3448,12 +3451,12 @@ bool8 Phase2_GridSquares_Func3(struct Task *task) return FALSE; } -void Phase2Task_Shards(u8 taskId) +static void Phase2Task_Shards(u8 taskId) { while (sPhase2_Shards_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_Shards_Func1(struct Task *task) +static bool8 Phase2_Shards_Func1(struct Task *task) { u16 i; @@ -3476,7 +3479,7 @@ bool8 Phase2_Shards_Func1(struct Task *task) return TRUE; } -bool8 Phase2_Shards_Func2(struct Task *task) +static bool8 Phase2_Shards_Func2(struct Task *task) { sub_814A1AC(sTransitionStructPtr->data, sUnknown_085C8DD0[task->tData1][0], @@ -3489,7 +3492,7 @@ bool8 Phase2_Shards_Func2(struct Task *task) return TRUE; } -bool8 Phase2_Shards_Func3(struct Task *task) +static bool8 Phase2_Shards_Func3(struct Task *task) { s16 i; bool8 nextFunc; @@ -3528,7 +3531,7 @@ bool8 Phase2_Shards_Func3(struct Task *task) return FALSE; } -bool8 Phase2_Shards_Func4(struct Task *task) +static bool8 Phase2_Shards_Func4(struct Task *task) { if (++task->tData1 < 7) { @@ -3545,7 +3548,7 @@ bool8 Phase2_Shards_Func4(struct Task *task) } } -bool8 Phase2_Shards_Func5(struct Task *task) +static bool8 Phase2_Shards_Func5(struct Task *task) { if (--task->tData3 == 0) { @@ -3556,7 +3559,7 @@ bool8 Phase2_Shards_Func5(struct Task *task) return FALSE; } -void VBlankCB_Phase2_Shards(void) +static void VBlankCB_Phase2_Shards(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -3591,9 +3594,9 @@ void VBlankCB_Phase2_Shards(void) #define tData6 data[6] #define tData7 data[7] -void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4) +static void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4) { - u8 taskId = CreateTask(Phase1_Task_RunFuncs, 3); + u8 taskId = CreateTask(TransitionPhase1_Task_RunFuncs, 3); gTasks[taskId].tData1 = a0; gTasks[taskId].tData2 = a1; gTasks[taskId].tData3 = a2; @@ -3602,20 +3605,20 @@ void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4) gTasks[taskId].tData6 = a0; } -bool8 IsPhase1Done(void) +static bool8 IsPhase1Done(void) { - if (FindTaskIdByFunc(Phase1_Task_RunFuncs) == 0xFF) + if (FindTaskIdByFunc(TransitionPhase1_Task_RunFuncs) == 0xFF) return TRUE; else return FALSE; } -void Phase1_Task_RunFuncs(u8 taskId) +void TransitionPhase1_Task_RunFuncs(u8 taskId) { while (sPhase1_TransitionAll_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase1_TransitionAll_Func1(struct Task *task) +static bool8 Phase1_TransitionAll_Func1(struct Task *task) { if (task->tData6 == 0 || --task->tData6 == 0) { @@ -3633,7 +3636,7 @@ bool8 Phase1_TransitionAll_Func1(struct Task *task) return FALSE; } -bool8 Phase1_TransitionAll_Func2(struct Task *task) +static bool8 Phase1_TransitionAll_Func2(struct Task *task) { if (task->tData6 == 0 || --task->tData6 == 0) { @@ -3646,7 +3649,7 @@ bool8 Phase1_TransitionAll_Func2(struct Task *task) if (task->tData7 == 0) { if (--task->tData3 == 0) - DestroyTask(FindTaskIdByFunc(Phase1_Task_RunFuncs)); + DestroyTask(FindTaskIdByFunc(TransitionPhase1_Task_RunFuncs)); else { task->tData6 = task->tData1; @@ -3664,20 +3667,20 @@ bool8 Phase1_TransitionAll_Func2(struct Task *task) #undef tData6 #undef tData7 -void sub_8149F08(void) +static void sub_8149F08(void) { memset(sTransitionStructPtr, 0, sizeof(*sTransitionStructPtr)); sub_8089C08(&sTransitionStructPtr->field_14, &sTransitionStructPtr->field_16); } -void VBlankCB_BattleTransition(void) +static void VBlankCB_BattleTransition(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -void sub_8149F40(u16 **a0) +static void sub_8149F40(u16 **a0) { u16 reg, *vram; @@ -3705,12 +3708,12 @@ void sub_8149F58(u16 **a0, u16 **a1) *a1 = vram1; } -void sub_8149F84(void) +static void sub_8149F84(void) { BlendPalettes(-1, 0x10, 0); } -void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize) +static void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize) { u8 i; for (i = 0; arrSize > 0; arrSize--, i++, index += indexIncrementer) @@ -3719,7 +3722,7 @@ void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 am } } -void sub_814A014(u16 *array, s16 a1, s16 a2, s16 a3) +static void sub_814A014(u16 *array, s16 a1, s16 a2, s16 a3) { s16 i; @@ -3771,7 +3774,7 @@ void sub_814A014(u16 *array, s16 a1, s16 a2, s16 a3) } } -void sub_814A1AC(s16 *data, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) +static void sub_814A1AC(s16 *data, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) { data[0] = a1; data[1] = a2; @@ -3796,7 +3799,7 @@ void sub_814A1AC(s16 *data, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) data[10] = 0; } -bool8 sub_814A228(s16 *data, bool8 a1, bool8 a2) +static bool8 sub_814A228(s16 *data, bool8 a1, bool8 a2) { u8 var; if (data[8] > data[9]) @@ -3848,7 +3851,7 @@ bool8 sub_814A228(s16 *data, bool8 a1, bool8 a2) #define tData6 data[6] #define tData7 data[7] -bool8 Phase2_29_Func1(struct Task *task) +static bool8 Phase2_29_Func1(struct Task *task) { u16 *dst1, *dst2; @@ -3862,7 +3865,7 @@ bool8 Phase2_29_Func1(struct Task *task) return FALSE; } -bool8 Phase2_29_Func2(struct Task *task) +static bool8 Phase2_29_Func2(struct Task *task) { u16 *dst1, *dst2; @@ -3874,28 +3877,28 @@ bool8 Phase2_29_Func2(struct Task *task) return TRUE; } -void Phase2Task_29(u8 taskId) +static void Phase2Task_29(u8 taskId) { while (sPhase2_29_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_30(u8 taskId) +static void Phase2Task_30(u8 taskId) { while (sPhase2_30_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -bool8 Phase2_30_Func1(struct Task *task) +static bool8 Phase2_30_Func1(struct Task *task) { u16 *dst1, *dst2; sub_8149F08(); dp12_8087EA4(); ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_WIN1_ON); - task->data[2] = 0x2000; - task->data[1] = 0x7FFF; - task->data[5] = 0; - task->data[6] = 16; - task->data[7] = 2560; + task->tData2 = 0x2000; + task->tData1 = 0x7FFF; + task->tData5 = 0; + task->tData6 = 16; + task->tData7 = 2560; sTransitionStructPtr->BLDCNT = 0x3F41; sTransitionStructPtr->BLDALPHA = (task->tData6 << 8) | (task->tData5); REG_BLDCNT = sTransitionStructPtr->BLDCNT; @@ -3910,7 +3913,7 @@ bool8 Phase2_30_Func1(struct Task *task) return FALSE; } -bool8 Phase2_30_Func2(struct Task *task) +static bool8 Phase2_30_Func2(struct Task *task) { u16 *dst1, *dst2; @@ -3921,7 +3924,7 @@ bool8 Phase2_30_Func2(struct Task *task) return TRUE; } -bool8 Phase2_30_Func3(struct Task *task) +static bool8 Phase2_30_Func3(struct Task *task) { u8 i; @@ -3938,7 +3941,7 @@ bool8 Phase2_30_Func3(struct Task *task) return TRUE; } -bool8 Phase2_30_Func4(struct Task *task) +static bool8 Phase2_30_Func4(struct Task *task) { u8 i; u16 var6, amplitude, var8; @@ -3990,7 +3993,7 @@ bool8 Phase2_30_Func4(struct Task *task) return FALSE; } -void VBlankCB_Phase2_30(void) +static void VBlankCB_Phase2_30(void) { VBlankCB_BattleTransition(); REG_BLDCNT = sTransitionStructPtr->BLDCNT; @@ -4000,27 +4003,340 @@ void VBlankCB_Phase2_30(void) DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); } -void HBlankCB_Phase2_30(void) +static void HBlankCB_Phase2_30(void) { u16 var = gUnknown_02038C28[1][REG_VCOUNT]; REG_BG0VOFS = var; } -void Phase2Task_31(u8 taskId) +static void Phase2Task_31(u8 taskId) { while (sPhase2_31_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_33(u8 taskId) +static void Phase2Task_33(u8 taskId) { while (sPhase2_33_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } -void Phase2Task_32(u8 taskId) +static void Phase2Task_32(u8 taskId) { while (sPhase2_32_Funcs[gTasks[taskId].tState](&gTasks[taskId])); } +static bool8 Phase2_31_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LZ77UnCompVram(gUnknown_085C8598, dst2); + + FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20); + FillBgTilemapBufferRect(0, 1, 0, 0, 1, 0x20, 0xF); + FillBgTilemapBufferRect(0, 1, 0x1D, 0, 1, 0x20, 0xF); + CopyBgTilemapBufferToVram(0); + LoadPalette(gUnknown_085C8578, 0xF0, 0x20); + + task->tData2 = 1; + task->tData3 = 0; + task->tData4 = 0; + task->tData7 = 10; + + task->tState++; + return FALSE; +} + +static bool8 Phase2_31_Func2(struct Task *task) +{ + CopyRectToBgTilemapBufferRect(0, gUnknown_085C8928, 0, 0, 4, 4, task->tData2, task->tData3, 4, 4, 0xF, 0, 0); + CopyBgTilemapBufferToVram(0); + + task->tData2 += 4; + if (++task->tData4 == 7) + { + task->tData2 = 1; + task->tData3 += 4; + task->tData4 = 0; + if (task->tData3 > 19) + task->tState++; + } + + return FALSE; +} + +static bool8 Phase2_31_Func3(struct Task *task) +{ + u8 i; + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + if (task->tData6++ >= task->tData7) + { + switch (task->tData5) + { + case 0: + for (i = 250; i < 255; i++) + { + gPlttBufferUnfaded[i] = 0; + gPlttBufferFaded[i] = 0; + } + break; + case 1: + BlendPalettes(0xFFFF7FFF, 0x10, 0); + LZ77UnCompVram(gUnknown_085C86F4, dst2); + break; + case 2: + LZ77UnCompVram(gUnknown_085C87F4, dst2); + break; + case 3: + LZ77UnCompVram(gUnknown_085C88A4, dst2); + break; + default: + FillBgTilemapBufferRect_Palette0(0, 1, 0, 0, 0x20, 0x20); + CopyBgTilemapBufferToVram(0); + task->tState++; + return FALSE; + } + + task->tData6 = 0; + task->tData5++; + } + + return FALSE; +} + +static bool8 Phase2_33_Func1(struct Task *task) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LZ77UnCompVram(gUnknown_085C8598, dst2); + + FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20); + FillBgTilemapBufferRect(0, 1, 0, 0, 1, 0x20, 0xF); + FillBgTilemapBufferRect(0, 1, 0x1D, 0, 1, 0x20, 0xF); + CopyBgTilemapBufferToVram(0); + LoadPalette(gUnknown_085C8578, 0xE0, 0x20); + LoadPalette(gUnknown_085C8578, 0xF0, 0x20); + BlendPalette(0xE0, 0x10, 8, 0); + + task->tData2 = 34; + task->tData3 = 0; + + task->tState++; + return FALSE; +} + +static bool8 Phase2_33_Func2(struct Task *task) +{ + u8 var = gUnknown_085C9A30[task->tData2]; + u8 varMod = var % 7; + u8 varDiv = var / 7; + CopyRectToBgTilemapBufferRect(0, &gUnknown_085C8928, 0, 0, 4, 4, 4 * varMod + 1, 4 * varDiv, 4, 4, 0xF, 0, 0); + CopyBgTilemapBufferToVram(0); + + if (--task->tData2 < 0) + task->tState++; + return FALSE; +} + +static bool8 Phase2_33_Func3(struct Task *task) +{ + BlendPalette(0xE0, 0x10, 3, 0); + BlendPalettes(0xFFFF3FFF, 0x10, 0); + + task->tData2 = 0; + task->tData3 = 0; + + task->tState++; + return FALSE; +} + +static bool8 Phase2_33_Func4(struct Task *task) +{ + if ((task->tData3 ^= 1)) + { + CopyRectToBgTilemapBufferRect( + 0, + gUnknown_085C8928, + 0, + 0, + 4, + 4, + 4 * (gUnknown_085C9A30[task->tData2] % 7) + 1, + 4 * (gUnknown_085C9A30[task->tData2] / 7), + 4, + 4, + 0xE, + 0, + 0); + } + else + { + if (task->tData2 > 0) + { + FillBgTilemapBufferRect( + 0, + 1, + 4 * (gUnknown_085C9A30[task->tData2 - 1] % 7) + 1, + 4 * (gUnknown_085C9A30[task->tData2 - 1] / 7), + 4, + 4, + 0xF); + } + + task->tData2++; + } + + if (task->tData2 > 34) + task->tState++; + + CopyBgTilemapBufferToVram(0); + return FALSE; +} + +static bool8 Phase2_31_33_Func5(struct Task *task) +{ + FillBgTilemapBufferRect_Palette0(0, 1, 0, 0, 0x20, 0x20); + CopyBgTilemapBufferToVram(0); + BlendPalettes(0xFFFFFFFF, 0x10, 0); + DestroyTask(FindTaskIdByFunc(task->func)); + return FALSE; +} + +// sub task for phase2 32 +#define tSub32_X_delta data[0] +#define tSub32_Y_delta data[1] +#define tSub32_Bool data[2] + +static void sub_814ABE4(u8 taskId) +{ + if (!(gTasks[taskId].tSub32_Bool ^= 1)) + { + SetGpuReg(REG_OFFSET_BG0VOFS, gBattle_BG0_X); + SetGpuReg(REG_OFFSET_BG0HOFS, gBattle_BG0_Y); + gBattle_BG0_X += gTasks[taskId].tSub32_X_delta; + gBattle_BG0_Y += gTasks[taskId].tSub32_Y_delta; + } +} + +static bool8 Phase2_32_Func1(struct Task *task) +{ + u8 taskId = 0; + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LZ77UnCompVram(gUnknown_085C8598, dst2); + FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20); + CopyBgTilemapBufferToVram(0); + LoadPalette(gUnknown_085C8578, 0xF0, 0x20); + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + SetGpuReg(REG_OFFSET_BG0VOFS, gBattle_BG0_X); + SetGpuReg(REG_OFFSET_BG0HOFS, gBattle_BG0_Y); + + task->tData2 = 0; + taskId = CreateTask(sub_814ABE4, 1); + switch (Random() % 4) + { + case 0: + gTasks[taskId].tSub32_X_delta = 1; + gTasks[taskId].tSub32_Y_delta = 1; + break; + case 1: + gTasks[taskId].tSub32_X_delta = -1; + gTasks[taskId].tSub32_Y_delta = -1; + break; + case 2: + gTasks[taskId].tSub32_X_delta = 1; + gTasks[taskId].tSub32_Y_delta = -1; + break; + default: + gTasks[taskId].tSub32_X_delta = -1; + gTasks[taskId].tSub32_Y_delta = 1; + break; + } + + task->tState++; + return FALSE; +} + +static bool8 Phase2_32_Func2(struct Task *task) +{ + u8 var = gUnknown_085C9A53[task->tData2]; + u8 varDiv = var / 8; + u8 varAnd = var & 7; + + CopyRectToBgTilemapBufferRect( + 0, + &gUnknown_085C8928, + 0, + 0, + 4, + 4, + 4 * varDiv + 1, + 4 * varAnd, + 4, + 4, + 0xF, + 0, + 0); + CopyBgTilemapBufferToVram(0); + + if (++task->tData2 > 63) + task->tState++; + return 0; +} + +static bool8 Phase2_32_Func3(struct Task *task) +{ + BlendPalettes(0xFFFF7FFF, 0x10, 0); + + task->tData2 = 0; + + task->tState++; + return FALSE; +} + +static bool8 Phase2_32_Func4(struct Task *task) +{ + u8 var = gUnknown_085C9A53[task->tData2]; + u8 varDiv = var / 8; + u8 varAnd = var & 7; + + FillBgTilemapBufferRect(0, 1, 4 * varDiv + 1, 4 * varAnd, 4, 4, 0xF); + CopyBgTilemapBufferToVram(0); + + if (++task->tData2 > 63) + { + DestroyTask(FindTaskIdByFunc(sub_814ABE4)); + task->tState++; + } + + return FALSE; +} + +#undef tSub32_X_delta +#undef tSub32_Y_delta +#undef tSub32_Bool + +static bool8 Phase2_32_Func5(struct Task *task) +{ + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + SetGpuReg(REG_OFFSET_BG0VOFS, 0); + SetGpuReg(REG_OFFSET_BG0HOFS, gBattle_BG0_Y); + + FillBgTilemapBufferRect_Palette0(0, 1, 0, 0, 0x20, 0x20); + CopyBgTilemapBufferToVram(0); + BlendPalettes(0xFFFFFFFF, 0x10, 0); + + DestroyTask(FindTaskIdByFunc(task->func)); + task->tState++; // UB: changing value of a destroyed task + return FALSE; +} + #undef tData1 #undef tData2 #undef tData3 diff --git a/src/tileset_anims.c b/src/tileset_anims.c index 062647202..f89cfdd2b 100644 --- a/src/tileset_anims.c +++ b/src/tileset_anims.c @@ -1393,7 +1393,7 @@ static void sub_80A1818(u16 a1) { CpuCopy16(gTilesetAnims_BattleDomePals0[a1 & 0x3], gPlttBufferUnfaded + 0x80, 32); BlendPalette(0x80, 0x10, gPaletteFade.y, gPaletteFade.blendColor & 0x7FFF); - if ((u8)FindTaskIdByFunc(Phase1_Task_RunFuncs) != 0xFF ) + if ((u8)FindTaskIdByFunc(TransitionPhase1_Task_RunFuncs) != 0xFF ) { sSecondaryTilesetCB = sub_80A1670; sSecondaryTilesetCBBufferSize = 0x20; @@ -1403,7 +1403,7 @@ static void sub_80A1818(u16 a1) static void sub_80A1884(u16 a1) { CpuCopy16(gTilesetAnims_BattleDomePals0[a1 & 0x3], gPlttBufferUnfaded + 0x80, 32); - if ((u8)FindTaskIdByFunc(Phase1_Task_RunFuncs) == 0xFF ) + if ((u8)FindTaskIdByFunc(TransitionPhase1_Task_RunFuncs) == 0xFF ) { BlendPalette(0x80, 0x10, gPaletteFade.y, gPaletteFade.blendColor & 0x7FFF); if (!--sSecondaryTilesetCBBufferSize) -- cgit v1.2.3 From bc1a957674e84daf181c508afd2b623304de121d Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 14 Jan 2018 22:15:50 +0100 Subject: make battle transition compile --- src/bg.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/bg.c b/src/bg.c index 74e3ea830..b699a0b1f 100644 --- a/src/bg.c +++ b/src/bg.c @@ -1007,7 +1007,7 @@ void CopyToBgTilemapBufferRect_ChangePalette(u8 bg, void *src, u8 destX, u8 dest } // Skipping for now, it probably uses structs passed by value /* -void CopyRectToBgTilemapBufferRect(u8 bg, void* src, u8 srcX, u8 srcY, u8 srcWidth, u8 srcHeight, u8 destX, u8 destY, u8 rectWidth, u8 rectHeight, u8 palette1, u16 tileOffset, u16 palette2) +void CopyRectToBgTilemapBufferRect(u8 bg, const void* src, u8 srcX, u8 srcY, u8 srcWidth, u8 srcHeight, u8 destX, u8 destY, u8 rectWidth, u8 rectHeight, u8 palette1, u16 tileOffset, u16 palette2) { u16 attribute; u16 mode; @@ -1049,7 +1049,7 @@ void CopyRectToBgTilemapBufferRect(u8 bg, void* src, u8 srcX, u8 srcY, u8 srcWid } }*/ __attribute__((naked)) -void CopyRectToBgTilemapBufferRect(u8 bg, void* src, u8 srcX, u8 srcY, u8 srcWidth, u8 srcHeight, u8 destX, u8 destY, u8 rectWidth, u8 rectHeight, u8 palette1, u16 tileOffset, u16 palette2) +void CopyRectToBgTilemapBufferRect(u8 bg, const void* src, u8 srcX, u8 srcY, u8 srcWidth, u8 srcHeight, u8 destX, u8 destY, u8 rectWidth, u8 rectHeight, u8 palette1, u16 tileOffset, u16 palette2) { asm("push {r4-r7,lr}\n\ mov r7, r10\n\ -- cgit v1.2.3 From a6072ae293b0c0c3577b280274a2fd755033ab9f Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 16 Jan 2018 18:59:06 +0100 Subject: decompile option menu --- src/berry_fix_program.c | 2 +- src/diploma.c | 2 +- src/egg_hatch.c | 4 +- src/evolution_scene.c | 2 +- src/hall_of_fame.c | 2 +- src/mail.c | 2 +- src/main.c | 4 +- src/option_menu.c | 630 +++++++++++++++++++++++++++++++++++++++++++ src/pokeblock.c | 2 +- src/pokemon_summary_screen.c | 4 +- src/starter_choose.c | 4 +- src/text_window.c | 8 +- src/wallclock.c | 2 +- 13 files changed, 649 insertions(+), 19 deletions(-) create mode 100644 src/option_menu.c (limited to 'src') diff --git a/src/berry_fix_program.c b/src/berry_fix_program.c index 3b2bfb5f7..f487489d4 100644 --- a/src/berry_fix_program.c +++ b/src/berry_fix_program.c @@ -141,7 +141,7 @@ void InitBerryFixProgram(void) SetVBlankCallback(NULL); ResetSpriteData(); ResetTasks(); - remove_some_task(); + ScanlineEffect_Stop(); SetGpuReg(REG_OFFSET_DISPCNT, 0x0000); berry_fix_mb_manager = AllocZeroed(0x50); berry_fix_mb_manager->state = 0; diff --git a/src/diploma.c b/src/diploma.c index d4a269757..fedc10bd0 100755 --- a/src/diploma.c +++ b/src/diploma.c @@ -72,7 +72,7 @@ void CB2_ShowDiploma(void) DmaFill16(3, 0, VRAM, VRAM_SIZE); DmaFill32(3, 0, OAM, OAM_SIZE); DmaFill16(3, 0, PLTT, PLTT_SIZE); - remove_some_task(); + ScanlineEffect_Stop(); ResetTasks(); ResetSpriteData(); ResetPaletteFade(); diff --git a/src/egg_hatch.c b/src/egg_hatch.c index 1aff894b9..37f2b2e19 100644 --- a/src/egg_hatch.c +++ b/src/egg_hatch.c @@ -66,7 +66,7 @@ extern void overworld_free_bg_tilemaps(void); extern void sub_80AF168(void); extern void AllocateMonSpritesGfx(void); extern void FreeMonSpritesGfx(void); -extern void remove_some_task(void); +extern void ScanlineEffect_Stop(void); extern void reset_temp_tile_data_buffers(void); extern void c2_exit_to_overworld_2_switch(void); extern void play_some_sound(void); @@ -512,7 +512,7 @@ static void CB2_EggHatch_0(void) FreeAllSpritePalettes(); ResetSpriteData(); ResetTasks(); - remove_some_task(); + ScanlineEffect_Stop(); m4aSoundVSyncOn(); gMain.state++; break; diff --git a/src/evolution_scene.c b/src/evolution_scene.c index 4b59147ff..5dfc36cb2 100644 --- a/src/evolution_scene.c +++ b/src/evolution_scene.c @@ -269,7 +269,7 @@ void EvolutionScene(struct Pokemon* mon, u16 speciesToEvolve, bool8 canStopEvo, sub_80356D0(); LoadBattleTextboxAndBackground(); ResetSpriteData(); - remove_some_task(); + ScanlineEffect_Stop(); ResetTasks(); FreeAllSpritePalettes(); diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c index 4465f65a3..3e70e22fa 100644 --- a/src/hall_of_fame.c +++ b/src/hall_of_fame.c @@ -1302,7 +1302,7 @@ static void ClearVramOamPltt_LoadHofPal(void) static void sub_8174F70(void) { - remove_some_task(); + ScanlineEffect_Stop(); ResetTasks(); ResetSpriteData(); reset_temp_tile_data_buffers(); diff --git a/src/mail.c b/src/mail.c index 68a55e242..774e3ec19 100644 --- a/src/mail.c +++ b/src/mail.c @@ -329,7 +329,7 @@ static bool8 MailReadBuildGraphics(void) { case 0: SetVBlankCallback(NULL); - remove_some_task(); + ScanlineEffect_Stop(); SetGpuReg(REG_OFFSET_DISPCNT, 0x0000); break; case 1: diff --git a/src/main.c b/src/main.c index 07b7d9147..d4601293b 100644 --- a/src/main.c +++ b/src/main.c @@ -29,7 +29,7 @@ extern void MapMusicMain(void); extern void EnableInterrupts(u16); extern void sub_8033648(void); extern u16 SetFlashTimerIntr(u8 timerNum, void (**intrFunc)(void)); -extern void remove_some_task(void); +extern void ScanlineEffect_Stop(void); extern struct SoundInfo gSoundInfo; extern u32 gFlashMemoryPresent; @@ -425,7 +425,7 @@ void DoSoftReset(void) { REG_IME = 0; m4aSoundVSyncOff(); - remove_some_task(); + ScanlineEffect_Stop(); DmaStop(1); DmaStop(2); DmaStop(3); diff --git a/src/option_menu.c b/src/option_menu.c new file mode 100644 index 000000000..5b88338ab --- /dev/null +++ b/src/option_menu.c @@ -0,0 +1,630 @@ +#include "global.h" +#include "option_menu.h" +#include "main.h" +#include "menu.h" +#include "unknown_task.h" +#include "palette.h" +#include "sprite.h" +#include "task.h" +#include "bg.h" +#include "gpu_regs.h" +#include "window.h" +#include "text.h" +#include "text_window.h" +#include "international_string_util.h" +#include "strings.h" + +extern void SetPokemonCryStereo(u32 val); + +// Task data +enum +{ + TD_MENUSELECTION, + TD_TEXTSPEED, + TD_BATTLESCENE, + TD_BATTLESTYLE, + TD_SOUND, + TD_BUTTONMODE, + TD_FRAMETYPE, +}; + +// Menu items +enum +{ + MENUITEM_TEXTSPEED, + MENUITEM_BATTLESCENE, + MENUITEM_BATTLESTYLE, + MENUITEM_SOUND, + MENUITEM_BUTTONMODE, + MENUITEM_FRAMETYPE, + MENUITEM_CANCEL, + MENUITEM_COUNT, +}; + +// Window Ids +enum +{ + WIN_TEXT_OPTION, + WIN_OPTIONS +}; + +// this file's functions +static void Task_OptionMenuFadeIn(u8 taskId); +static void Task_OptionMenuProcessInput(u8 taskId); +static void Task_OptionMenuSave(u8 taskId); +static void Task_OptionMenuFadeOut(u8 taskId); +static void HighlightOptionMenuItem(u8 selection); +static u8 TextSpeed_ProcessInput(u8 selection); +static void TextSpeed_DrawChoices(u8 selection); +static u8 BattleScene_ProcessInput(u8 selection); +static void BattleScene_DrawChoices(u8 selection); +static u8 BattleStyle_ProcessInput(u8 selection); +static void BattleStyle_DrawChoices(u8 selection); +static u8 Sound_ProcessInput(u8 selection); +static void Sound_DrawChoices(u8 selection); +static u8 FrameType_ProcessInput(u8 selection); +static void FrameType_DrawChoices(u8 selection); +static u8 ButtonMode_ProcessInput(u8 selection); +static void ButtonMode_DrawChoices(u8 selection); +static void DrawTextOption(void); +static void DrawOptionMenuTexts(void); +static void sub_80BB154(void); + +// EWRAM vars +EWRAM_DATA static bool8 sArrowPressed = FALSE; + +// const rom data +/* +const u16 gUnknown_0839F5FC[] = INCBIN_U16("graphics/misc/option_menu_text.gbapal"); +// note: this is only used in the Japanese release +const static u8 gUnknown_0839F63C[] = INCBIN_U8("graphics/misc/option_menu_equals_sign.4bpp"); +*/ +extern const struct BgTemplate gUnknown_0855C698[2]; +extern const struct WindowTemplate gUnknown_0855C680[]; +extern const u16 gUnknown_0855C6A0[1]; +extern const u16 gUnknown_0855C604[16]; +extern const u8 *const gUnknown_0855C664[MENUITEM_COUNT]; + +// code +static void MainCB2(void) +{ + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +static void VBlankCB(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +void CB2_InitOptionMenu(void) +{ + switch (gMain.state) + { + default: + case 0: + SetVBlankCallback(NULL); + gMain.state++; + break; + case 1: + { + u8 *addr; + u32 size; + + addr = (u8 *)VRAM; + size = 0x18000; + while (1) + { + DmaFill16(3, 0, addr, 0x1000); + addr += 0x1000; + size -= 0x1000; + if (size <= 0x1000) + { + DmaFill16(3, 0, addr, size); + break; + } + } + DmaClear32(3, OAM, OAM_SIZE); + DmaClear16(3, PLTT, PLTT_SIZE); + SetGpuReg(REG_OFFSET_DISPCNT, 0); + ResetBgsAndClearDma3BusyFlags(0); + InitBgsFromTemplates(0, gUnknown_0855C698, ARRAY_COUNT(gUnknown_0855C698)); + 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); + InitWindows(gUnknown_0855C680); + DeactivateAllTextPrinters(); + SetGpuReg(REG_OFFSET_WIN0H, 0); + SetGpuReg(REG_OFFSET_WIN0V, 0); + SetGpuReg(REG_OFFSET_WININ, 1); + SetGpuReg(REG_OFFSET_WINOUT, 35); + SetGpuReg(REG_OFFSET_BLDCNT, 193); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + SetGpuReg(REG_OFFSET_BLDY, 4); + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP); + ShowBg(0); + ShowBg(1); + gMain.state++; + } + break; + case 2: + ResetPaletteFade(); + ScanlineEffect_Stop(); + ResetTasks(); + ResetSpriteData(); + gMain.state++; + break; + case 3: + LoadBgTiles(1, GetWindowFrameTilesPal(gSaveBlock2Ptr->optionsWindowFrameType)->tiles, 0x120, 0x1A2); + gMain.state++; + break; + case 4: + LoadPalette(gUnknown_0855C6A0, 0, sizeof(gUnknown_0855C6A0)); + LoadPalette(GetWindowFrameTilesPal(gSaveBlock2Ptr->optionsWindowFrameType)->pal, 0x70, 0x20); + gMain.state++; + break; + case 5: + LoadPalette(gUnknown_0855C604, 0x10, sizeof(gUnknown_0855C604)); + gMain.state++; + break; + case 6: + PutWindowTilemap(0); + DrawTextOption(); + gMain.state++; + break; + case 7: + gMain.state++; + break; + case 8: + PutWindowTilemap(1); + DrawOptionMenuTexts(); + gMain.state++; + case 9: + sub_80BB154(); + gMain.state++; + break; + case 10: + { + u8 taskId = CreateTask(Task_OptionMenuFadeIn, 0); + + gTasks[taskId].data[TD_MENUSELECTION] = 0; + gTasks[taskId].data[TD_TEXTSPEED] = gSaveBlock2Ptr->optionsTextSpeed; + gTasks[taskId].data[TD_BATTLESCENE] = gSaveBlock2Ptr->optionsBattleSceneOff; + gTasks[taskId].data[TD_BATTLESTYLE] = gSaveBlock2Ptr->optionsBattleStyle; + gTasks[taskId].data[TD_SOUND] = gSaveBlock2Ptr->optionsSound; + gTasks[taskId].data[TD_BUTTONMODE] = gSaveBlock2Ptr->optionsButtonMode; + gTasks[taskId].data[TD_FRAMETYPE] = gSaveBlock2Ptr->optionsWindowFrameType; + + TextSpeed_DrawChoices(gTasks[taskId].data[TD_TEXTSPEED]); + BattleScene_DrawChoices(gTasks[taskId].data[TD_BATTLESCENE]); + BattleStyle_DrawChoices(gTasks[taskId].data[TD_BATTLESTYLE]); + Sound_DrawChoices(gTasks[taskId].data[TD_SOUND]); + ButtonMode_DrawChoices(gTasks[taskId].data[TD_BUTTONMODE]); + FrameType_DrawChoices(gTasks[taskId].data[TD_FRAMETYPE]); + HighlightOptionMenuItem(gTasks[taskId].data[TD_MENUSELECTION]); + + CopyWindowToVram(WIN_OPTIONS, 3); + gMain.state++; + break; + } + case 11: + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); + SetVBlankCallback(VBlankCB); + SetMainCallback2(MainCB2); + return; + } +} + +static void Task_OptionMenuFadeIn(u8 taskId) +{ + if (!gPaletteFade.active) + { + gTasks[taskId].func = Task_OptionMenuProcessInput; + } +} + +static void Task_OptionMenuProcessInput(u8 taskId) +{ + if (gMain.newKeys & A_BUTTON) + { + if (gTasks[taskId].data[TD_MENUSELECTION] == MENUITEM_CANCEL) + gTasks[taskId].func = Task_OptionMenuSave; + } + else if (gMain.newKeys & B_BUTTON) + { + gTasks[taskId].func = Task_OptionMenuSave; + } + else if (gMain.newKeys & DPAD_UP) + { + if (gTasks[taskId].data[TD_MENUSELECTION] > 0) + gTasks[taskId].data[TD_MENUSELECTION]--; + else + gTasks[taskId].data[TD_MENUSELECTION] = 6; + HighlightOptionMenuItem(gTasks[taskId].data[TD_MENUSELECTION]); + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (gTasks[taskId].data[TD_MENUSELECTION] <= 5) + gTasks[taskId].data[TD_MENUSELECTION]++; + else + gTasks[taskId].data[TD_MENUSELECTION] = 0; + HighlightOptionMenuItem(gTasks[taskId].data[TD_MENUSELECTION]); + } + else + { + u8 previousOption; + + switch (gTasks[taskId].data[TD_MENUSELECTION]) + { + case MENUITEM_TEXTSPEED: + previousOption = gTasks[taskId].data[TD_TEXTSPEED]; + gTasks[taskId].data[TD_TEXTSPEED] = TextSpeed_ProcessInput(gTasks[taskId].data[TD_TEXTSPEED]); + + if (previousOption != gTasks[taskId].data[TD_TEXTSPEED]) + TextSpeed_DrawChoices(gTasks[taskId].data[TD_TEXTSPEED]); + break; + case MENUITEM_BATTLESCENE: + previousOption = gTasks[taskId].data[TD_BATTLESCENE]; + gTasks[taskId].data[TD_BATTLESCENE] = BattleScene_ProcessInput(gTasks[taskId].data[TD_BATTLESCENE]); + + if (previousOption != gTasks[taskId].data[TD_BATTLESCENE]) + BattleScene_DrawChoices(gTasks[taskId].data[TD_BATTLESCENE]); + break; + case MENUITEM_BATTLESTYLE: + previousOption = gTasks[taskId].data[TD_BATTLESTYLE]; + gTasks[taskId].data[TD_BATTLESTYLE] = BattleStyle_ProcessInput(gTasks[taskId].data[TD_BATTLESTYLE]); + + if (previousOption != gTasks[taskId].data[TD_BATTLESTYLE]) + BattleStyle_DrawChoices(gTasks[taskId].data[TD_BATTLESTYLE]); + break; + case MENUITEM_SOUND: + previousOption = gTasks[taskId].data[TD_SOUND]; + gTasks[taskId].data[TD_SOUND] = Sound_ProcessInput(gTasks[taskId].data[TD_SOUND]); + + if (previousOption != gTasks[taskId].data[TD_SOUND]) + Sound_DrawChoices(gTasks[taskId].data[TD_SOUND]); + break; + case MENUITEM_BUTTONMODE: + previousOption = gTasks[taskId].data[TD_BUTTONMODE]; + gTasks[taskId].data[TD_BUTTONMODE] = ButtonMode_ProcessInput(gTasks[taskId].data[TD_BUTTONMODE]); + + if (previousOption != gTasks[taskId].data[TD_BUTTONMODE]) + ButtonMode_DrawChoices(gTasks[taskId].data[TD_BUTTONMODE]); + break; + case MENUITEM_FRAMETYPE: + previousOption = gTasks[taskId].data[TD_FRAMETYPE]; + gTasks[taskId].data[TD_FRAMETYPE] = FrameType_ProcessInput(gTasks[taskId].data[TD_FRAMETYPE]); + + if (previousOption != gTasks[taskId].data[TD_FRAMETYPE]) + FrameType_DrawChoices(gTasks[taskId].data[TD_FRAMETYPE]); + break; + default: + return; + } + + if (sArrowPressed) + { + sArrowPressed = FALSE; + CopyWindowToVram(WIN_OPTIONS, 2); + } + } +} + +static void Task_OptionMenuSave(u8 taskId) +{ + gSaveBlock2Ptr->optionsTextSpeed = gTasks[taskId].data[TD_TEXTSPEED]; + gSaveBlock2Ptr->optionsBattleSceneOff = gTasks[taskId].data[TD_BATTLESCENE]; + gSaveBlock2Ptr->optionsBattleStyle = gTasks[taskId].data[TD_BATTLESTYLE]; + gSaveBlock2Ptr->optionsSound = gTasks[taskId].data[TD_SOUND]; + gSaveBlock2Ptr->optionsButtonMode = gTasks[taskId].data[TD_BUTTONMODE]; + gSaveBlock2Ptr->optionsWindowFrameType = gTasks[taskId].data[TD_FRAMETYPE]; + + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + gTasks[taskId].func = Task_OptionMenuFadeOut; +} + +static void Task_OptionMenuFadeOut(u8 taskId) +{ + if (!gPaletteFade.active) + { + DestroyTask(taskId); + FreeAllWindowBuffers(); + SetMainCallback2(gMain.savedCallback); + } +} + +static void HighlightOptionMenuItem(u8 index) +{ + SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(16, 224)); + SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(index * 16 + 40, index * 16 + 56)); +} + +static void DrawOptionMenuChoice(const u8 *text, u8 x, u8 y, u8 style) +{ + u8 dst[16]; + u16 i; + + for (i = 0; *text != EOS && i <= 14; i++) + dst[i] = *(text++); + + if (style != 0) + { + dst[2] = 4; + dst[5] = 5; + } + + dst[i] = EOS; + PrintTextOnWindow(WIN_OPTIONS, 1, dst, x, y + 1, TEXT_SPEED_FF, NULL); +} + +static u8 TextSpeed_ProcessInput(u8 selection) +{ + if (gMain.newKeys & DPAD_RIGHT) + { + if (selection <= 1) + selection++; + else + selection = 0; + + sArrowPressed = TRUE; + } + if (gMain.newKeys & DPAD_LEFT) + { + if (selection != 0) + selection--; + else + selection = 2; + + sArrowPressed = TRUE; + } + return selection; +} + +static void TextSpeed_DrawChoices(u8 selection) +{ + u8 styles[3]; + s32 widthSlow, widthMid, widthFast, xMid; + + styles[0] = 0; + styles[1] = 0; + styles[2] = 0; + styles[selection] = 1; + + DrawOptionMenuChoice(gText_TextSpeedSlow, 104, 0, styles[0]); + + widthSlow = GetStringWidth(1, gText_TextSpeedSlow, 0); + widthMid = GetStringWidth(1, gText_TextSpeedMid, 0); + widthFast = GetStringWidth(1, gText_TextSpeedFast, 0); + + widthMid -= 94; + xMid = (widthSlow - widthMid - widthFast) / 2 + 104; + DrawOptionMenuChoice(gText_TextSpeedMid, xMid, 0, styles[1]); + + DrawOptionMenuChoice(gText_TextSpeedFast, GetStringRightAlignXOffset(1, gText_TextSpeedFast, 198), 0, styles[2]); +} + +static u8 BattleScene_ProcessInput(u8 selection) +{ + if (gMain.newKeys & (DPAD_LEFT | DPAD_RIGHT)) + { + selection ^= 1; + sArrowPressed = TRUE; + } + + return selection; +} + +static void BattleScene_DrawChoices(u8 selection) +{ + u8 styles[2]; + + styles[0] = 0; + styles[1] = 0; + styles[selection] = 1; + + DrawOptionMenuChoice(gText_BattleSceneOn, 104, 16, styles[0]); + DrawOptionMenuChoice(gText_BattleSceneOff, GetStringRightAlignXOffset(1, gText_BattleSceneOff, 198), 16, styles[1]); +} + +static u8 BattleStyle_ProcessInput(u8 selection) +{ + if (gMain.newKeys & (DPAD_LEFT | DPAD_RIGHT)) + { + selection ^= 1; + sArrowPressed = TRUE; + } + + return selection; +} + +static void BattleStyle_DrawChoices(u8 selection) +{ + u8 styles[2]; + + styles[0] = 0; + styles[1] = 0; + styles[selection] = 1; + + DrawOptionMenuChoice(gText_BattleStyleShift, 104, 32, styles[0]); + DrawOptionMenuChoice(gText_BattleStyleSet, GetStringRightAlignXOffset(1, gText_BattleStyleSet, 198), 32, styles[1]); +} + +static u8 Sound_ProcessInput(u8 selection) +{ + if (gMain.newKeys & (DPAD_LEFT | DPAD_RIGHT)) + { + selection ^= 1; + SetPokemonCryStereo(selection); + sArrowPressed = TRUE; + } + + return selection; +} + +static void Sound_DrawChoices(u8 selection) +{ + u8 styles[2]; + + styles[0] = 0; + styles[1] = 0; + styles[selection] = 1; + + DrawOptionMenuChoice(gText_SoundMono, 104, 48, styles[0]); + DrawOptionMenuChoice(gText_SoundStereo, GetStringRightAlignXOffset(1, gText_SoundStereo, 198), 48, styles[1]); +} + +// TODO: 19 should be defined in text_window.h +static u8 FrameType_ProcessInput(u8 selection) +{ + if (gMain.newKeys & DPAD_RIGHT) + { + if (selection < 19) + selection++; + else + selection = 0; + + LoadBgTiles(1, GetWindowFrameTilesPal(selection)->tiles, 0x120, 0x1A2); + LoadPalette(GetWindowFrameTilesPal(selection)->pal, 0x70, 0x20); + sArrowPressed = TRUE; + } + if (gMain.newKeys & DPAD_LEFT) + { + if (selection != 0) + selection--; + else + selection = 19; + + LoadBgTiles(1, GetWindowFrameTilesPal(selection)->tiles, 0x120, 0x1A2); + LoadPalette(GetWindowFrameTilesPal(selection)->pal, 0x70, 0x20); + sArrowPressed = TRUE; + } + return selection; +} + +static void FrameType_DrawChoices(u8 selection) +{ + u8 text[16]; + u8 n = selection + 1; + u16 i; + + for (i = 0; gText_FrameTypeNumber[i] != EOS && i <= 5; i++) + text[i] = gText_FrameTypeNumber[i]; + + // Convert a number to decimal string + if (n / 10 != 0) + { + text[i] = n / 10 + CHAR_0; + i++; + text[i] = n % 10 + CHAR_0; + i++; + } + else + { + text[i] = n % 10 + CHAR_0; + i++; + text[i] = 0x77; + i++; + } + + text[i] = EOS; + + DrawOptionMenuChoice(gText_FrameType, 104, 80, 0); + DrawOptionMenuChoice(text, 128, 80, 1); +} + +static u8 ButtonMode_ProcessInput(u8 selection) +{ + if (gMain.newKeys & DPAD_RIGHT) + { + if (selection <= 1) + selection++; + else + selection = 0; + + sArrowPressed = TRUE; + } + if (gMain.newKeys & DPAD_LEFT) + { + if (selection != 0) + selection--; + else + selection = 2; + + sArrowPressed = TRUE; + } + return selection; +} + +static void ButtonMode_DrawChoices(u8 selection) +{ + s32 widthNormal, widthLR, widthLA, yLR; + u8 styles[3]; + + styles[0] = 0; + styles[1] = 0; + styles[2] = 0; + styles[selection] = 1; + + DrawOptionMenuChoice(gText_ButtonTypeNormal, 104, 64, styles[0]); + + widthNormal = GetStringWidth(1, gText_ButtonTypeNormal, 0); + widthLR = GetStringWidth(1, gText_ButtonTypeLR, 0); + widthLA = GetStringWidth(1, gText_ButtonTypeLEqualsA, 0); + + widthLR -= 94; + yLR = (widthNormal - widthLR - widthLA) / 2 + 104; + DrawOptionMenuChoice(gText_ButtonTypeLR, yLR, 64, styles[1]); + + DrawOptionMenuChoice(gText_ButtonTypeLEqualsA, GetStringRightAlignXOffset(1, gText_ButtonTypeLEqualsA, 198), 64, styles[2]); +} + +static void DrawTextOption(void) +{ + FillWindowPixelBuffer(WIN_TEXT_OPTION, 0x11); + PrintTextOnWindow(WIN_TEXT_OPTION, 1, gText_Option, 8, 1, TEXT_SPEED_FF, NULL); + CopyWindowToVram(WIN_TEXT_OPTION, 3); +} + +static void DrawOptionMenuTexts(void) +{ + u8 i; + + FillWindowPixelBuffer(WIN_OPTIONS, 0x11); + for (i = 0; i < MENUITEM_COUNT; i++) + { + PrintTextOnWindow(WIN_OPTIONS, 1, gUnknown_0855C664[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL); + } + CopyWindowToVram(WIN_OPTIONS, 3); +} + +static void sub_80BB154(void) +{ + // bg, tileNum, x, y, width, height, pal + FillBgTilemapBufferRect(1, 0x1A2, 1, 0, 1, 1, 7); + FillBgTilemapBufferRect(1, 0x1A3, 2, 0, 0x1B, 1, 7); + FillBgTilemapBufferRect(1, 0x1A4, 28, 0, 1, 1, 7); + FillBgTilemapBufferRect(1, 0x1A5, 1, 1, 1, 2, 7); + FillBgTilemapBufferRect(1, 0x1A7, 28, 1, 1, 2, 7); + FillBgTilemapBufferRect(1, 0x1A8, 1, 3, 1, 1, 7); + FillBgTilemapBufferRect(1, 0x1A9, 2, 3, 0x1B, 1, 7); + FillBgTilemapBufferRect(1, 0x1AA, 28, 3, 1, 1, 7); + FillBgTilemapBufferRect(1, 0x1A2, 1, 4, 1, 1, 7); + FillBgTilemapBufferRect(1, 0x1A3, 2, 4, 0x1A, 1, 7); + FillBgTilemapBufferRect(1, 0x1A4, 28, 4, 1, 1, 7); + FillBgTilemapBufferRect(1, 0x1A5, 1, 5, 1, 0x12, 7); + FillBgTilemapBufferRect(1, 0x1A7, 28, 5, 1, 0x12, 7); + FillBgTilemapBufferRect(1, 0x1A8, 1, 19, 1, 1, 7); + FillBgTilemapBufferRect(1, 0x1A9, 2, 19, 0x1A, 1, 7); + FillBgTilemapBufferRect(1, 0x1AA, 28, 19, 1, 1, 7); + + CopyBgTilemapBufferToVram(1); +} diff --git a/src/pokeblock.c b/src/pokeblock.c index 737f2c6f3..573eed52b 100644 --- a/src/pokeblock.c +++ b/src/pokeblock.c @@ -419,7 +419,7 @@ static bool8 InitPokeblockMenu(void) gMain.state++; break; case 1: - remove_some_task(); + ScanlineEffect_Stop(); gMain.state++; break; case 2: diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c index e56448d8b..a900badd1 100755 --- a/src/pokemon_summary_screen.c +++ b/src/pokemon_summary_screen.c @@ -75,7 +75,7 @@ extern u8 sub_81221AC(); extern void SetVBlankHBlankCallbacksToNull(); extern void ResetVramOamAndBgCntRegs(); extern void clear_scheduled_bg_copies_to_vram(); -extern void remove_some_task(); +extern void ScanlineEffect_Stop(); extern void ResetBgsAndClearDma3BusyFlags(u32 leftoverFireRedLeafGreenVariable); extern void ShowBg(u8 a); extern void SetGpuReg(u8 regOffset, u16 value); @@ -455,7 +455,7 @@ bool8 sub_81BFB10(void) gMain.state++; break; case 1: - remove_some_task(); + ScanlineEffect_Stop(); gMain.state++; break; case 2: diff --git a/src/starter_choose.c b/src/starter_choose.c index 2d78af8fb..a47adb4e4 100644 --- a/src/starter_choose.c +++ b/src/starter_choose.c @@ -53,7 +53,7 @@ extern const u8 gUnknown_085B1E0C[]; extern const u8 gUnknown_085B1E28[][2]; extern void sub_809882C(u8, u16, u8); -extern void remove_some_task(void); +extern void ScanlineEffect_Stop(void); extern void clear_scheduled_bg_copies_to_vram(void); extern void dp13_810BB8C(void); extern void do_scheduled_bg_tilemap_copies_to_vram(void); @@ -134,7 +134,7 @@ void CB2_ChooseStarter(void) DeactivateAllTextPrinters(); sub_809882C(0, 0x2A8, 0xD0); clear_scheduled_bg_copies_to_vram(); - remove_some_task(); + ScanlineEffect_Stop(); ResetTasks(); ResetSpriteData(); ResetPaletteFade(); diff --git a/src/text_window.c b/src/text_window.c index 336536c04..67ff309f0 100644 --- a/src/text_window.c +++ b/src/text_window.c @@ -7,14 +7,14 @@ extern u8 LoadBgTiles(u8 bg, const void *src, u16 size, u16 destOffset); extern void FillBgTilemapBufferRect(u8 bg, u16 tileNum, u8 x, u8 y, u8 width, u8 height, u8 palette); -extern const struct TilesPal gUnknown_0851021C[]; +extern const struct TilesPal gUnknown_0851021C[20]; extern const u32 gUnknown_08DDD748[]; extern const u16 gUnknown_0851017C[]; extern const u16 gUnknown_08DDD728[]; -const struct TilesPal* sub_8098758(u8 id) +const struct TilesPal* GetWindowFrameTilesPal(u8 id) { - if (id > 19) + if (id >= ARRAY_COUNT(gUnknown_0851021C)) return &gUnknown_0851021C[0]; else return &gUnknown_0851021C[id]; @@ -121,5 +121,5 @@ const u16* GetOverworldTextboxPalettePtr(void) void sub_8098C6C(u8 bg, u16 destOffset, u8 palOffset) { LoadBgTiles(bg, gUnknown_0851021C[gSaveBlock2Ptr->optionsWindowFrameType].tiles, 0x120, destOffset); - LoadPalette(sub_8098758(gSaveBlock2Ptr->optionsWindowFrameType)->pal, palOffset, 0x20); + LoadPalette(GetWindowFrameTilesPal(gSaveBlock2Ptr->optionsWindowFrameType)->pal, palOffset, 0x20); } diff --git a/src/wallclock.c b/src/wallclock.c index ea6137c5d..dbea24b4c 100644 --- a/src/wallclock.c +++ b/src/wallclock.c @@ -578,7 +578,7 @@ static void LoadWallClockGraphics(void) DeactivateAllTextPrinters(); sub_809882C(0, 0x250, 0xd0); clear_scheduled_bg_copies_to_vram(); - remove_some_task(); + ScanlineEffect_Stop(); ResetTasks(); ResetSpriteData(); ResetPaletteFade(); -- cgit v1.2.3 From 4dd06dbcd327e2af38912e09d31d5c3e00bc93ba Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 16 Jan 2018 19:39:35 +0100 Subject: optiom menu move data to C --- src/option_menu.c | 63 ++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 49 insertions(+), 14 deletions(-) (limited to 'src') diff --git a/src/option_menu.c b/src/option_menu.c index 5b88338ab..07d22eeb0 100644 --- a/src/option_menu.c +++ b/src/option_menu.c @@ -74,16 +74,51 @@ static void sub_80BB154(void); EWRAM_DATA static bool8 sArrowPressed = FALSE; // const rom data -/* -const u16 gUnknown_0839F5FC[] = INCBIN_U16("graphics/misc/option_menu_text.gbapal"); +static const u16 sUnknown_0855C604[] = INCBIN_U16("graphics/misc/option_menu_text.gbapal"); // note: this is only used in the Japanese release -const static u8 gUnknown_0839F63C[] = INCBIN_U8("graphics/misc/option_menu_equals_sign.4bpp"); -*/ -extern const struct BgTemplate gUnknown_0855C698[2]; -extern const struct WindowTemplate gUnknown_0855C680[]; -extern const u16 gUnknown_0855C6A0[1]; -extern const u16 gUnknown_0855C604[16]; -extern const u8 *const gUnknown_0855C664[MENUITEM_COUNT]; +static const u8 sEqualSignGfx[] = INCBIN_U8("graphics/misc/option_menu_equals_sign.4bpp"); + +static const u8 *const OptionMenuItemsNames[MENUITEM_COUNT] = +{ + gText_TextSpeed, + gText_BattleScene, + gText_BattleStyle, + gText_Sound, + gText_ButtonMode, + gText_Frame, + gText_OptionMenuCancel, +}; + +static const struct WindowTemplate sOptionMenuWinTemplates[] = +{ + {1, 2, 1, 0x1A, 2, 1, 2}, + {0, 2, 5, 0x1A, 0xE, 1, 0x36}, + DUMMY_WIN_TEMPLATE +}; + +static const struct BgTemplate sOptionMenuBgTemplates[] = +{ + { + .bg = 1, + .charBaseIndex = 1, + .mapBaseIndex = 30, + .screenSize = 0, + .paletteMode = 0, + .priority = 0, + .baseTile = 0 + }, + { + .bg = 0, + .charBaseIndex = 1, + .mapBaseIndex = 31, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0 + } +}; + +static const u16 sUnknown_0855C6A0[] = {0x7E51}; // code static void MainCB2(void) @@ -132,7 +167,7 @@ void CB2_InitOptionMenu(void) DmaClear16(3, PLTT, PLTT_SIZE); SetGpuReg(REG_OFFSET_DISPCNT, 0); ResetBgsAndClearDma3BusyFlags(0); - InitBgsFromTemplates(0, gUnknown_0855C698, ARRAY_COUNT(gUnknown_0855C698)); + InitBgsFromTemplates(0, sOptionMenuBgTemplates, ARRAY_COUNT(sOptionMenuBgTemplates)); ChangeBgX(0, 0, 0); ChangeBgY(0, 0, 0); ChangeBgX(1, 0, 0); @@ -141,7 +176,7 @@ void CB2_InitOptionMenu(void) ChangeBgY(2, 0, 0); ChangeBgX(3, 0, 0); ChangeBgY(3, 0, 0); - InitWindows(gUnknown_0855C680); + InitWindows(sOptionMenuWinTemplates); DeactivateAllTextPrinters(); SetGpuReg(REG_OFFSET_WIN0H, 0); SetGpuReg(REG_OFFSET_WIN0V, 0); @@ -168,12 +203,12 @@ void CB2_InitOptionMenu(void) gMain.state++; break; case 4: - LoadPalette(gUnknown_0855C6A0, 0, sizeof(gUnknown_0855C6A0)); + LoadPalette(sUnknown_0855C6A0, 0, sizeof(sUnknown_0855C6A0)); LoadPalette(GetWindowFrameTilesPal(gSaveBlock2Ptr->optionsWindowFrameType)->pal, 0x70, 0x20); gMain.state++; break; case 5: - LoadPalette(gUnknown_0855C604, 0x10, sizeof(gUnknown_0855C604)); + LoadPalette(sUnknown_0855C604, 0x10, sizeof(sUnknown_0855C604)); gMain.state++; break; case 6: @@ -601,7 +636,7 @@ static void DrawOptionMenuTexts(void) FillWindowPixelBuffer(WIN_OPTIONS, 0x11); for (i = 0; i < MENUITEM_COUNT; i++) { - PrintTextOnWindow(WIN_OPTIONS, 1, gUnknown_0855C664[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL); + PrintTextOnWindow(WIN_OPTIONS, 1, OptionMenuItemsNames[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL); } CopyWindowToVram(WIN_OPTIONS, 3); } -- cgit v1.2.3 From 77352c7ee480fe3127692ce50a6bdd019de87291 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 16 Jan 2018 19:41:25 +0100 Subject: give the s prefix to a variable --- src/option_menu.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/option_menu.c b/src/option_menu.c index 07d22eeb0..b76d9e0e6 100644 --- a/src/option_menu.c +++ b/src/option_menu.c @@ -78,7 +78,7 @@ static const u16 sUnknown_0855C604[] = INCBIN_U16("graphics/misc/option_menu_tex // note: this is only used in the Japanese release static const u8 sEqualSignGfx[] = INCBIN_U8("graphics/misc/option_menu_equals_sign.4bpp"); -static const u8 *const OptionMenuItemsNames[MENUITEM_COUNT] = +static const u8 *const sOptionMenuItemsNames[MENUITEM_COUNT] = { gText_TextSpeed, gText_BattleScene, @@ -636,7 +636,7 @@ static void DrawOptionMenuTexts(void) FillWindowPixelBuffer(WIN_OPTIONS, 0x11); for (i = 0; i < MENUITEM_COUNT; i++) { - PrintTextOnWindow(WIN_OPTIONS, 1, OptionMenuItemsNames[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL); + PrintTextOnWindow(WIN_OPTIONS, 1, sOptionMenuItemsNames[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL); } CopyWindowToVram(WIN_OPTIONS, 3); } -- cgit v1.2.3 From 50f9615dc9021bc811869a27b5fa400aac25aaf0 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 16 Jan 2018 21:37:46 +0100 Subject: battle transition review changes --- src/battle_transition.c | 60 ++++++++++++++++++++++++------------------------- 1 file changed, 30 insertions(+), 30 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index af156da12..ca2134837 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -23,21 +23,21 @@ struct TransitionData { - vs8 VBlank_DMA; + vu8 VBlank_DMA; u16 WININ; u16 WINOUT; - u16 field_6; + u16 WIN0H; u16 WIN0V; - u16 field_A; - u16 field_C; + u16 field_A; // unused + u16 field_C; // unused u16 BLDCNT; u16 BLDALPHA; u16 BLDY; s16 field_14; s16 field_16; - s16 field_18; - s16 field_1A; - s16 field_1C; + s16 BG0HOFS_1; + s16 BG0HOFS_2; + s16 BG0VOFS; // used but not set s16 field_1E; // unused s16 field_20; s16 field_22; // unused @@ -1265,7 +1265,7 @@ static void sub_814669C(struct Task *task) task->tData5 = 0x4000; sTransitionStructPtr->WININ = 63; sTransitionStructPtr->WINOUT = 0; - sTransitionStructPtr->field_6 = 240; + sTransitionStructPtr->WIN0H = 240; sTransitionStructPtr->WIN0V = 160; sTransitionStructPtr->BLDCNT = 0x3F41; sTransitionStructPtr->BLDALPHA = (task->tData1 << 8) | (task->tData2); @@ -1745,7 +1745,7 @@ static bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task) sTransitionStructPtr->WININ = 0; sTransitionStructPtr->WINOUT = 63; - sTransitionStructPtr->field_6 = -3855; + sTransitionStructPtr->WIN0H = -3855; sTransitionStructPtr->WIN0V = 160; for (i = 0; i < 160; i++) @@ -2016,7 +2016,7 @@ static bool8 Phase2_Wave_Func1(struct Task *task) sTransitionStructPtr->WININ = 63; sTransitionStructPtr->WINOUT = 0; - sTransitionStructPtr->field_6 = 240; + sTransitionStructPtr->WIN0H = 240; sTransitionStructPtr->WIN0V = 160; for (i = 0; i < 160; i++) @@ -2210,8 +2210,8 @@ static bool8 Phase2_Mugshot_Func3(struct Task *task) if (mergedValue == 0xF0) task->tState++; - sTransitionStructPtr->field_18 -= 8; - sTransitionStructPtr->field_1A += 8; + sTransitionStructPtr->BG0HOFS_1 -= 8; + sTransitionStructPtr->BG0HOFS_2 += 8; sTransitionStructPtr->VBlank_DMA++; return FALSE; } @@ -2232,8 +2232,8 @@ static bool8 Phase2_Mugshot_Func4(struct Task *task) task->tData1 = 0; task->tData2 = 0; task->tData3 = 0; - sTransitionStructPtr->field_18 -= 8; - sTransitionStructPtr->field_1A += 8; + sTransitionStructPtr->BG0HOFS_1 -= 8; + sTransitionStructPtr->BG0HOFS_2 += 8; sub_8148484(task->tOpponentSpriteId, 0); sub_8148484(task->tPlayerSpriteId, 1); @@ -2247,8 +2247,8 @@ static bool8 Phase2_Mugshot_Func4(struct Task *task) static bool8 Phase2_Mugshot_Func5(struct Task *task) { - sTransitionStructPtr->field_18 -= 8; - sTransitionStructPtr->field_1A += 8; + sTransitionStructPtr->BG0HOFS_1 -= 8; + sTransitionStructPtr->BG0HOFS_2 += 8; if (sub_81484B8(task->tOpponentSpriteId)) { task->tState++; @@ -2259,8 +2259,8 @@ static bool8 Phase2_Mugshot_Func5(struct Task *task) static bool8 Phase2_Mugshot_Func6(struct Task *task) { - sTransitionStructPtr->field_18 -= 8; - sTransitionStructPtr->field_1A += 8; + sTransitionStructPtr->BG0HOFS_1 -= 8; + sTransitionStructPtr->BG0HOFS_2 += 8; if (sub_81484B8(task->tPlayerSpriteId)) { sTransitionStructPtr->VBlank_DMA = FALSE; @@ -2285,8 +2285,8 @@ static bool8 Phase2_Mugshot_Func7(struct Task *task) sTransitionStructPtr->VBlank_DMA = FALSE; r6 = TRUE; - sTransitionStructPtr->field_18 -= 8; - sTransitionStructPtr->field_1A += 8; + sTransitionStructPtr->BG0HOFS_1 -= 8; + sTransitionStructPtr->BG0HOFS_2 += 8; if (task->tData4 < 0x50) task->tData4 += 2; @@ -2358,7 +2358,7 @@ static void VBlankCB0_Phase2_Mugshots(void) VBlankCB_BattleTransition(); if (sTransitionStructPtr->VBlank_DMA != 0) DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320); - REG_BG0VOFS = sTransitionStructPtr->field_1C; + REG_BG0VOFS = sTransitionStructPtr->BG0VOFS; REG_WININ = sTransitionStructPtr->WININ; REG_WINOUT = sTransitionStructPtr->WINOUT; REG_WIN0V = sTransitionStructPtr->WIN0V; @@ -2378,9 +2378,9 @@ static void VBlankCB1_Phase2_Mugshots(void) static void HBlankCB_Phase2_Mugshots(void) { if (REG_VCOUNT < 80) - REG_BG0HOFS = sTransitionStructPtr->field_18; + REG_BG0HOFS = sTransitionStructPtr->BG0HOFS_1; else - REG_BG0HOFS = sTransitionStructPtr->field_1A; + REG_BG0HOFS = sTransitionStructPtr->BG0HOFS_2; } static void Mugshots_CreateOpponentPlayerSprites(struct Task *task) @@ -2541,9 +2541,9 @@ static bool8 Phase2_Slice_Func2(struct Task *task) for (i = 0; i < 160; i++) { - u16* storeLoc1 = &gUnknown_02038C28[0][i]; - u16* storeLoc2 = &gUnknown_02038C28[0][i + 160]; - if (1 & i) + u16 *storeLoc1 = &gUnknown_02038C28[0][i]; + u16 *storeLoc2 = &gUnknown_02038C28[0][i + 160]; + if (i & 1) { *storeLoc1 = sTransitionStructPtr->field_14 + task->tData1; *storeLoc2 = 0xF0 - task->tData1; @@ -2775,7 +2775,7 @@ static bool8 Phase2_Blackhole_Func1(struct Task *task) sTransitionStructPtr->WININ = 0; sTransitionStructPtr->WINOUT = 63; - sTransitionStructPtr->field_6 = 240; + sTransitionStructPtr->WIN0H = 240; sTransitionStructPtr->WIN0V = 160; for (i = 0; i < 0xA0; i++) @@ -3203,7 +3203,7 @@ static bool8 Phase2_Rayquaza_Func9(struct Task *task) sTransitionStructPtr->WININ = 0; sTransitionStructPtr->WINOUT = 63; - sTransitionStructPtr->field_6 = 240; + sTransitionStructPtr->WIN0H = 240; sTransitionStructPtr->WIN0V = 160; for (i = 0; i < 160; i++) @@ -3309,7 +3309,7 @@ static bool8 Phase2_WhiteFade_Func4(struct Task *task) SetVBlankCallback(0); SetHBlankCallback(0); - sTransitionStructPtr->field_6 = 0xF0; + sTransitionStructPtr->WIN0H = 0xF0; sTransitionStructPtr->BLDY = 0; sTransitionStructPtr->BLDCNT = 0xFF; sTransitionStructPtr->WININ = 0x3F; @@ -3350,7 +3350,7 @@ static void VBlankCB1_Phase2_WhiteFade(void) REG_BLDCNT = sTransitionStructPtr->BLDCNT; REG_WININ = sTransitionStructPtr->WININ; REG_WINOUT = sTransitionStructPtr->WINOUT; - REG_WIN0H = sTransitionStructPtr->field_6; + REG_WIN0H = sTransitionStructPtr->WIN0H; REG_WIN0V = sTransitionStructPtr->WIN0V; } -- cgit v1.2.3 From 295aa96a052d4ab7daecbc9fb5da166dd0d2a0f1 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 16 Jan 2018 23:57:26 +0100 Subject: decompile unk transition --- src/unk_transition.c | 633 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 633 insertions(+) create mode 100644 src/unk_transition.c (limited to 'src') diff --git a/src/unk_transition.c b/src/unk_transition.c new file mode 100644 index 000000000..feaddc8ce --- /dev/null +++ b/src/unk_transition.c @@ -0,0 +1,633 @@ +#include "global.h" +#include "sprite.h" +#include "decompress.h" +#include "unk_transition.h" +#include "battle_transition.h" +#include "task.h" +#include "palette.h" +#include "trig.h" +#include "bg.h" +#include "gpu_regs.h" + +typedef bool8 (*TransitionStateFunc)(struct Task *task); + +// this file's functions +static void sub_81DA848(struct Sprite *sprite); +static void sub_81DA9BC(struct Sprite *sprite); +static bool8 sub_81DAACC(struct Task *task); +static bool8 sub_81DAC14(struct Task *task); +static bool8 sub_81DABBC(struct Task *task); +static bool8 sub_81DAB4C(struct Task *task); +static bool8 sub_81DAC80(struct Task *task); +static bool8 sub_81DACEC(struct Task *task); +static bool8 sub_81DAD58(struct Task *task); +static bool8 sub_81DADC4(struct Task *task); +static bool8 sub_81DAE44(struct Task *task); +static bool8 sub_81DAEB0(struct Task *task); +static bool8 sub_81DAF34(struct Task *task); +static bool8 sub_81DAFA0(struct Task *task); +static bool8 sub_81DB02C(struct Task *task); +static bool8 sub_81DB098(struct Task *task); +static bool8 sub_81DB124(struct Task *task); +static bool8 sub_81DB190(struct Task *task); +static bool8 sub_81DB224(struct Task *task); +static bool8 sub_81DB290(struct Task *task); +static bool8 sub_81DB328(struct Task *task); + +// const rom data +// TODO: move those from .s file to .c +extern const u8 gUnknown_0862AD54[]; +extern const u8 gUnknown_0862AF30[]; +extern const u8 gUnknown_0862B0DC[]; +extern const u16 gUnknown_0862B53C[]; + +static const struct OamData sOamData_862B71C = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 3, + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0 +}; + +static const struct CompressedSpriteSheet sUnknown_0862B724 = +{ + gUnknown_0862B0DC, 0x1800, 11920 +}; + +static const struct SpritePalette sUnknown_0862B72C = +{ + gUnknown_0862B53C, 11920 +}; + +static const union AnimCmd sSpriteAnim_862B734[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_862B73C[] = +{ + ANIMCMD_FRAME(64, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_862B744[] = +{ + ANIMCMD_FRAME(128, 1), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_862B74C[] = +{ + sSpriteAnim_862B734, + sSpriteAnim_862B73C, + sSpriteAnim_862B744 +}; + +static const struct SpriteTemplate sUnknown_0862B758 = +{ + .tileTag = 11920, + .paletteTag = 11920, + .oam = &sOamData_862B71C, + .anims = sSpriteAnimTable_862B74C, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +static const TransitionStateFunc sPhase2_34_Funcs[] = +{ + sub_81DAACC, + sub_81DAC14, + sub_81DABBC, + sub_81DAB4C, + sub_81DAC80 +}; + +static const TransitionStateFunc sPhase2_35_Funcs[] = +{ + sub_81DAACC, + sub_81DACEC, + sub_81DABBC, + sub_81DAB4C, + sub_81DAD58 +}; + +static const TransitionStateFunc sPhase2_36_Funcs[] = +{ + sub_81DAACC, + sub_81DADC4, + sub_81DABBC, + sub_81DAB4C, + sub_81DAE44 +}; + +static const TransitionStateFunc sPhase2_37_Funcs[] = +{ + sub_81DAACC, + sub_81DAEB0, + sub_81DABBC, + sub_81DAB4C, + sub_81DAF34 +}; + +static const TransitionStateFunc sPhase2_38_Funcs[] = +{ + sub_81DAACC, + sub_81DAFA0, + sub_81DABBC, + sub_81DAB4C, + sub_81DB02C +}; + +static const TransitionStateFunc sPhase2_39_Funcs[] = +{ + sub_81DAACC, + sub_81DB098, + sub_81DABBC, + sub_81DAB4C, + sub_81DB124 +}; + +static const TransitionStateFunc sPhase2_40_Funcs[] = +{ + sub_81DAACC, + sub_81DB190, + sub_81DABBC, + sub_81DAB4C, + sub_81DB224 +}; + +static const TransitionStateFunc sPhase2_41_Funcs[] = +{ + sub_81DAACC, + sub_81DB290, + sub_81DABBC, + sub_81DAB4C, + sub_81DB328 +}; + +// code +static void sub_81DA700(void) +{ + u16 *dst1, *dst2; + + sub_8149F58(&dst1, &dst2); + LZ77UnCompVram(gUnknown_0862AD54, dst2); + LZ77UnCompVram(gUnknown_0862AF30, dst1); + LoadPalette(gUnknown_0862B53C, 0xF0, 0x20); + LoadCompressedObjectPic(&sUnknown_0862B724); + LoadSpritePalette(&sUnknown_0862B72C); +} + +static u8 sub_81DA74C(s16 x, s16 y, u8 arg2, u8 arg3, s8 arg4, s8 arg5, u8 spriteAnimNum) +{ + u8 spriteId = CreateSprite(&sUnknown_0862B758, x, y, 0); + + switch (spriteAnimNum) + { + case 0: + gSprites[spriteId].data[0] = 120; + gSprites[spriteId].data[1] = 45; + break; + case 1: + gSprites[spriteId].data[0] = 89; + gSprites[spriteId].data[1] = 97; + break; + case 2: + gSprites[spriteId].data[0] = 151; + gSprites[spriteId].data[1] = 97; + break; + } + + gSprites[spriteId].data[2] = arg4; + gSprites[spriteId].data[3] = arg5; + gSprites[spriteId].data[6] = arg2; + gSprites[spriteId].data[7] = arg3; + gSprites[spriteId].data[4] = 0; + gSprites[spriteId].data[5] = 0; + + StartSpriteAnim(&gSprites[spriteId], spriteAnimNum); + gSprites[spriteId].callback = sub_81DA848; + + return spriteId; +} + +static void sub_81DA848(struct Sprite *sprite) +{ + s16 *data = sprite->data; + + if (sprite->pos1.x == data[0] && sprite->pos1.y == data[1]) + { + sprite->callback = SpriteCallbackDummy; + } + else + { + if (data[4] == data[6]) + { + sprite->pos1.x += data[2]; + data[4] = 0; + } + else + { + data[4]++; + } + + if (data[5] == data[7]) + { + sprite->pos1.y += data[3]; + data[5] = 0; + } + else + { + data[5]++; + } + } +} + +static u8 sub_81DA8BC(s16 x, s16 y, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, u8 spriteAnimNum) +{ + u8 spriteId = CreateSprite(&sUnknown_0862B758, x, y, 0); + + switch (spriteAnimNum) + { + case 0: + gSprites[spriteId].data[0] = 120; + gSprites[spriteId].data[1] = 45; + break; + case 1: + gSprites[spriteId].data[0] = 89; + gSprites[spriteId].data[1] = 97; + break; + case 2: + gSprites[spriteId].data[0] = 151; + gSprites[spriteId].data[1] = 97; + break; + } + + gSprites[spriteId].data[2] = arg2; + gSprites[spriteId].data[3] = arg3; + gSprites[spriteId].data[4] = arg4; + gSprites[spriteId].data[5] = arg5; + gSprites[spriteId].data[6] = arg6; + + StartSpriteAnim(&gSprites[spriteId], spriteAnimNum); + gSprites[spriteId].callback = sub_81DA9BC; + + return spriteId; +} + +static void sub_81DA9BC(struct Sprite *sprite) +{ + sprite->pos2.x = (Sin2(sprite->data[2]) * sprite->data[4]) >> 12; // div by 4096 + sprite->pos2.y = (Cos2(sprite->data[2]) * sprite->data[4]) >> 12; // div by 4096 + + sprite->data[2] = (sprite->data[2] + sprite->data[3]) % 360; + + if (sprite->data[4] != sprite->data[5]) + sprite->data[4] += sprite->data[6]; + else + sprite->callback = SpriteCallbackDummy; +} + +#define tState data[0] + +static void sub_81DAA20(struct Task *task) +{ + FreeSpriteTilesByTag(11920); + FreeSpritePaletteByTag(11920); + + DestroySprite(&gSprites[task->data[4]]); + DestroySprite(&gSprites[task->data[5]]); + DestroySprite(&gSprites[task->data[6]]); +} + +static bool8 sub_81DAA74(struct Task *task) +{ + if (gSprites[task->data[4]].callback == SpriteCallbackDummy + && gSprites[task->data[5]].callback == SpriteCallbackDummy + && gSprites[task->data[6]].callback == SpriteCallbackDummy) + return TRUE; + else + return FALSE; +} + +static bool8 sub_81DAACC(struct Task *task) +{ + if (task->data[1] == 0) + { + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON); + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG0_ON); + + task->data[1]++; + return FALSE; + } + else + { + sub_81DA700(); + SetGpuReg(REG_OFFSET_BLDCNT, 0x3F41); + SetGpuReg(REG_OFFSET_BLDALPHA, 0x1000); + ChangeBgX(0, 0, 0); + ChangeBgY(0, 0, 0); + ChangeBgY(0, 0x500, 2); + + task->data[1] = 0; + task->tState++; + return TRUE; + } +} + +static bool8 sub_81DAB4C(struct Task *task) +{ + if (task->data[2] == 0) + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG0_ON); + + if (task->data[2] == 16) + { + if (task->data[3] == 31) + { + BeginNormalPaletteFade(-1, -1, 0, 0x10, 0); + task->tState++; + } + else + { + task->data[3]++; + } + } + else + { + u16 var; + + task->data[2]++; + var = task->data[2]; + SetGpuReg(REG_OFFSET_BLDALPHA, (var) | ((16 - var) << 8)); + } + + return FALSE; +} + +static bool8 sub_81DABBC(struct Task *task) +{ + if (sub_81DAA74(task) == TRUE) + task->tState++; + + return FALSE; +} + +void Phase2Task_34(u8 taskId) +{ + while (sPhase2_34_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +static bool8 sub_81DAC14(struct Task *task) +{ + task->data[4] = sub_81DA74C(120, -51, 0, 0, 0, 2, 0); + task->data[5] = sub_81DA74C(-7, 193, 0, 0, 2, -2, 1); + task->data[6] = sub_81DA74C(247, 193, 0, 0, -2, -2, 2); + + task->tState++; + return FALSE; +} + +static bool8 sub_81DAC80(struct Task *task) +{ + if (!gPaletteFade.active) + { + sub_81DAA20(task); + DestroyTask(FindTaskIdByFunc(Phase2Task_34)); + } + + return FALSE; +} + +void Phase2Task_35(u8 taskId) +{ + while (sPhase2_35_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +static bool8 sub_81DACEC(struct Task *task) +{ + task->data[4] = sub_81DA74C(120, 197, 0, 0, 0, -4, 0); + task->data[5] = sub_81DA74C(241, 59, 0, 1, -4, 2, 1); + task->data[6] = sub_81DA74C(-1, 59, 0, 1, 4, 2, 2); + + task->tState++; + return FALSE; +} + +static bool8 sub_81DAD58(struct Task *task) +{ + if (!gPaletteFade.active) + { + sub_81DAA20(task); + DestroyTask(FindTaskIdByFunc(Phase2Task_35)); + } + + return FALSE; +} + +void Phase2Task_36(u8 taskId) +{ + while (sPhase2_36_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +static bool8 sub_81DADC4(struct Task *task) +{ + task->data[4] = sub_81DA8BC(120, 45, 12, 4, 128, 0, -4, 0); + task->data[5] = sub_81DA8BC(89, 97, 252, 4, 128, 0, -4, 1); + task->data[6] = sub_81DA8BC(151, 97, 132, 4, 128, 0, -4, 2); + + task->tState++; + return FALSE; +} + +static bool8 sub_81DAE44(struct Task *task) +{ + if (!gPaletteFade.active) + { + sub_81DAA20(task); + DestroyTask(FindTaskIdByFunc(Phase2Task_36)); + } + + return FALSE; +} + +void Phase2Task_37(u8 taskId) +{ + while (sPhase2_37_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +static bool8 sub_81DAEB0(struct Task *task) +{ + task->data[4] = sub_81DA8BC(120, 80, 284, 8, 131, 35, -3, 0); + task->data[5] = sub_81DA8BC(120, 80, 44, 8, 131, 35, -3, 1); + task->data[6] = sub_81DA8BC(121, 80, 164, 8, 131, 35, -3, 2); + + task->tState++; + return FALSE; +} + +static bool8 sub_81DAF34(struct Task *task) +{ + if (!gPaletteFade.active) + { + sub_81DAA20(task); + DestroyTask(FindTaskIdByFunc(Phase2Task_37)); + } + + return FALSE; +} + +void Phase2Task_38(u8 taskId) +{ + while (sPhase2_38_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +static bool8 sub_81DAFA0(struct Task *task) +{ + if (task->data[1] == 0) + { + task->data[4] = sub_81DA74C(120, -51, 0, 0, 0, 4, 0); + } + else if (task->data[1] == 16) + { + task->data[5] = sub_81DA74C(-7, 193, 0, 0, 4, -4, 1); + } + else if (task->data[1] == 32) + { + task->data[6] = sub_81DA74C(247, 193, 0, 0, -4, -4, 2); + task->tState++; + } + + task->data[1]++; + return FALSE; +} + +static bool8 sub_81DB02C(struct Task *task) +{ + if (!gPaletteFade.active) + { + sub_81DAA20(task); + DestroyTask(FindTaskIdByFunc(Phase2Task_38)); + } + + return FALSE; +} + +void Phase2Task_39(u8 taskId) +{ + while (sPhase2_39_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +static bool8 sub_81DB098(struct Task *task) +{ + if (task->data[1] == 0) + { + task->data[4] = sub_81DA74C(120, 197, 0, 0, 0, -8, 0); + } + else if (task->data[1] == 16) + { + task->data[5] = sub_81DA74C(241, 78, 0, 0, -8, 1, 1); + } + else if (task->data[1] == 32) + { + task->data[6] = sub_81DA74C(-1, 78, 0, 0, 8, 1, 2); + task->tState++; + } + + task->data[1]++; + return FALSE; +} + +static bool8 sub_81DB124(struct Task *task) +{ + if (!gPaletteFade.active) + { + sub_81DAA20(task); + DestroyTask(FindTaskIdByFunc(Phase2Task_39)); + } + + return FALSE; +} + +void Phase2Task_40(u8 taskId) +{ + while (sPhase2_40_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +static bool8 sub_81DB190(struct Task *task) +{ + if (task->data[1] == 0) + { + task->data[4] = sub_81DA8BC(120, 45, 12, 4, 128, 0, -4, 0); + } + else if (task->data[1] == 16) + { + task->data[5] = sub_81DA8BC(89, 97, 252, 4, 128, 0, -4, 1); + } + else if (task->data[1] == 32) + { + task->data[6] = sub_81DA8BC(151, 97, 132, 4, 128, 0, -4, 2); + task->tState++; + } + + task->data[1]++; + return FALSE; +} + +static bool8 sub_81DB224(struct Task *task) +{ + if (!gPaletteFade.active) + { + sub_81DAA20(task); + DestroyTask(FindTaskIdByFunc(Phase2Task_40)); + } + + return FALSE; +} + +void Phase2Task_41(u8 taskId) +{ + while (sPhase2_41_Funcs[gTasks[taskId].tState](&gTasks[taskId])); +} + +static bool8 sub_81DB290(struct Task *task) +{ + if (task->data[1] == 0) + { + task->data[4] = sub_81DA8BC(120, 80, 284, 8, 131, 35, -3, 0); + } + else if (task->data[1] == 16) + { + task->data[5] = sub_81DA8BC(120, 80, 44, 8, 131, 35, -3, 1); + } + else if (task->data[1] == 32) + { + task->data[6] = sub_81DA8BC(121, 80, 164, 8, 131, 35, -3, 2); + task->tState++; + } + + task->data[1]++; + return FALSE; +} + +static bool8 sub_81DB328(struct Task *task) +{ + if (!gPaletteFade.active) + { + sub_81DAA20(task); + DestroyTask(FindTaskIdByFunc(Phase2Task_41)); + } + + return FALSE; +} -- cgit v1.2.3 From 6fa557c2ec0999196b0334431573c263e93f9bd3 Mon Sep 17 00:00:00 2001 From: Thomas Winwood Date: Wed, 17 Jan 2018 19:33:23 +0000 Subject: Document sub_814F8F8, sub_814F950 and sUnknownMoveTable These are left over from the Japanese games, which provide more variation to the attack string than the English games. --- src/battle_message.c | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/battle_message.c b/src/battle_message.c index e37a4c30c..3fa3d0563 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -1324,6 +1324,8 @@ const u8 gText_BattleRecordedOnPass[] = _("{B_PLAYER_NAME}’s battle result was const u8 gText_LinkTrainerWantsToBattlePause[] = _("{B_20}\nwants to battle!{PAUSE 49}"); const u8 gText_TwoLinkTrainersWantToBattlePause[] = _("{B_20} and {B_21}\nwant to battle!{PAUSE 49}"); +// This is four lists of moves which use a different attack string in Japanese +// to the default. See the documentation for sub_814F950 for more detail. static const u16 sUnknownMoveTable[] = { MOVE_SWORDS_DANCE, MOVE_STRENGTH, MOVE_GROWTH, @@ -1338,16 +1340,16 @@ static const u16 sUnknownMoveTable[] = MOVE_TRICK, MOVE_ASSIST, MOVE_INGRAIN, MOVE_KNOCK_OFF, MOVE_CAMOUFLAGE, MOVE_ASTONISH, MOVE_ODOR_SLEUTH, MOVE_GRASS_WHISTLE, MOVE_SHEER_COLD, MOVE_MUDDY_WATER, - MOVE_IRON_DEFENSE, MOVE_BOUNCE, MOVE_NONE, + MOVE_IRON_DEFENSE, MOVE_BOUNCE, 0, MOVE_TELEPORT, MOVE_RECOVER, MOVE_BIDE, MOVE_AMNESIA, - MOVE_FLAIL, MOVE_TAUNT, MOVE_BULK_UP, MOVE_NONE, + MOVE_FLAIL, MOVE_TAUNT, MOVE_BULK_UP, 0, MOVE_MEDITATE, MOVE_AGILITY, MOVE_MIMIC, MOVE_DOUBLE_TEAM, MOVE_BARRAGE, MOVE_TRANSFORM, MOVE_STRUGGLE, MOVE_SCARY_FACE, MOVE_CHARGE, MOVE_WISH, MOVE_BRICK_BREAK, MOVE_YAWN, MOVE_FEATHER_DANCE, MOVE_TEETER_DANCE, MOVE_MUD_SPORT, - MOVE_FAKE_TEARS, MOVE_WATER_SPORT, MOVE_CALM_MIND, MOVE_NONE, + MOVE_FAKE_TEARS, MOVE_WATER_SPORT, MOVE_CALM_MIND, 0, MOVE_POUND, MOVE_SCRATCH, MOVE_VICE_GRIP, MOVE_WING_ATTACK, MOVE_FLY, MOVE_BIND, MOVE_SLAM, @@ -1361,7 +1363,7 @@ static const u16 sUnknownMoveTable[] = MOVE_FORESIGHT, MOVE_CHARM, MOVE_ATTRACT, MOVE_ROCK_SMASH, MOVE_UPROAR, MOVE_SPIT_UP, MOVE_SWALLOW, MOVE_TORMENT, MOVE_FLATTER, MOVE_ROLE_PLAY, MOVE_ENDEAVOR, MOVE_TICKLE, - MOVE_COVET, MOVE_NONE + MOVE_COVET, 0 }; static const u8 sDummyWeirdStatusString[] = {EOS, EOS, EOS, EOS, EOS, EOS, EOS, EOS, 0, 0}; @@ -2330,6 +2332,10 @@ static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst) } } +// Loads one of two text strings into the provided buffer. This is functionally +// unused, since the value loaded into the buffer is not read; it loaded one of +// two particles (either "は" or "の") which works in tandem with sub_814F950 +// below to effect changes in the meaning of the line. static void sub_814F8F8(u8* textBuff) { s32 counter = 0; @@ -2337,7 +2343,7 @@ static void sub_814F8F8(u8* textBuff) while (counter != 4) { - if (sUnknownMoveTable[i] == MOVE_NONE) + if (sUnknownMoveTable[i] == 0) counter++; if (sUnknownMoveTable[i++] == gStringInfo->currentMove) break; @@ -2352,6 +2358,24 @@ static void sub_814F8F8(u8* textBuff) } } +// Appends "!" to the text buffer `dst`. In the original Japanese this looked +// into the table of moves at sUnknownMoveTable and varied the line accordingly. +// +// gText_ExclamationMark was a plain "!", used for any attack not on the list. +// It resulted in the translation "'s !". +// +// gText_ExclamationMark2 was "を つかった！". This resulted in the translation +// " used !", which was used for all attacks in English. +// +// gText_ExclamationMark3 was "した！". This was used for those moves whose +// names were verbs, such as Recover, and resulted in translations like " +// recovered itself!". +// +// gText_ExclamationMark4 was "を した！" This resulted in a translation of +// " did an !". +// +// gText_ExclamationMark5 was " こうげき！" This resulted in a translation of +// "'s attack!". static void sub_814F950(u8* dst) { s32 counter = 0; -- cgit v1.2.3 From c74334c26a1565b3cae586efd2f8a07a8bb0f912 Mon Sep 17 00:00:00 2001 From: Diegoisawesome Date: Fri, 19 Jan 2018 12:49:08 -0600 Subject: Fix address of berry struct in item.c --- src/item.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/item.c b/src/item.c index 931027e25..a17599db9 100644 --- a/src/item.c +++ b/src/item.c @@ -1,5 +1,6 @@ #include "global.h" #include "item.h" +#include "berry.h" #include "constants/items.h" #include "string_util.h" #include "text.h" @@ -11,7 +12,6 @@ extern bool8 InBattlePyramid(void); extern const u8 gText_PokeBalls[]; extern const u8 gText_Berries[]; extern const u8 gText_Berry[]; -extern const u8 gUnknown_085897E4[][28]; // not sure what this one is bool8 CheckPyramidBagHasItem(u16 itemId, u16 count); bool8 CheckPyramidBagHasSpace(u16 itemId, u16 count); @@ -96,8 +96,8 @@ void CopyItemNameHandlePlural(u16 itemId, u8 *string, u32 quantity) } else { - if (itemId >= 0x85 && itemId <= 0xAF) - GetBerryCountString(string, gUnknown_085897E4[itemId], quantity); + if (itemId >= ITEM_CHERI_BERRY && itemId <= ITEM_ENIGMA_BERRY) + GetBerryCountString(string, gBerries[itemId - ITEM_CHERI_BERRY].name, quantity); else StringCopy(string, ItemId_GetItem(itemId)->name); } -- cgit v1.2.3 From c408110319885748b4fcc696063242c7002f4d30 Mon Sep 17 00:00:00 2001 From: Devin Date: Fri, 19 Jan 2018 15:06:49 -0500 Subject: Fix file permissions. --- src/braille_puzzles.c | 0 src/clear_save_data_screen.c | 0 src/diploma.c | 0 src/field_map_obj.c | 0 src/field_special_scene.c | 0 src/libisagbprn.c | 0 src/pokemon_summary_screen.c | 0 src/save_failed_screen.c | 0 src/save_location.c | 0 9 files changed, 0 insertions(+), 0 deletions(-) mode change 100755 => 100644 src/braille_puzzles.c mode change 100755 => 100644 src/clear_save_data_screen.c mode change 100755 => 100644 src/diploma.c mode change 100755 => 100644 src/field_map_obj.c mode change 100755 => 100644 src/field_special_scene.c mode change 100755 => 100644 src/libisagbprn.c mode change 100755 => 100644 src/pokemon_summary_screen.c mode change 100755 => 100644 src/save_failed_screen.c mode change 100755 => 100644 src/save_location.c (limited to 'src') diff --git a/src/braille_puzzles.c b/src/braille_puzzles.c old mode 100755 new mode 100644 diff --git a/src/clear_save_data_screen.c b/src/clear_save_data_screen.c old mode 100755 new mode 100644 diff --git a/src/diploma.c b/src/diploma.c old mode 100755 new mode 100644 diff --git a/src/field_map_obj.c b/src/field_map_obj.c old mode 100755 new mode 100644 diff --git a/src/field_special_scene.c b/src/field_special_scene.c old mode 100755 new mode 100644 diff --git a/src/libisagbprn.c b/src/libisagbprn.c old mode 100755 new mode 100644 diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c old mode 100755 new mode 100644 diff --git a/src/save_failed_screen.c b/src/save_failed_screen.c old mode 100755 new mode 100644 diff --git a/src/save_location.c b/src/save_location.c old mode 100755 new mode 100644 -- cgit v1.2.3 From 098671750b2ccc4be5815da7cab6d78c8b7eccc4 Mon Sep 17 00:00:00 2001 From: Diegoisawesome Date: Sat, 20 Jan 2018 00:49:21 -0600 Subject: Extract data from text window --- src/save_failed_screen.c | 8 ++++---- src/text_window.c | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) (limited to 'src') diff --git a/src/save_failed_screen.c b/src/save_failed_screen.c index 218ef68d7..efe38fbae 100755 --- a/src/save_failed_screen.c +++ b/src/save_failed_screen.c @@ -21,9 +21,9 @@ extern const u8 gBirchHelpGfx[]; extern const u8 gBirchBagTilemap[]; extern const u8 gBirchGrassTilemap[]; extern const u16 gBirchBagGrassPal[]; -extern const u16 gUnknown_0850FEFC[]; +extern const u16 gTextWindowFrame1_Pal[]; extern const u16 gUnknown_0860F074[]; -extern const u32 gUnknown_0850E87C[]; +extern const u32 gTextWindowFrame1_Gfx[]; extern struct SaveSection gSaveDataBuffer; extern u8 gText_SaveFailedCheckingBackup[]; @@ -226,7 +226,7 @@ static void CB2_SaveFailedScreen(void) InitBgsFromTemplates(0, gUnknown_085EFD88, 3); SetBgTilemapBuffer(0, (void *)&gDecompressionBuffer[0x2000]); CpuFill32(0, &gDecompressionBuffer[0x2000], 0x800); - LoadBgTiles(0, gUnknown_0850E87C, 0x120, 0x214); + LoadBgTiles(0, gTextWindowFrame1_Gfx, 0x120, 0x214); InitWindows(gUnknown_085EFD94); // AddWindowWithoutTileMap returns a u16/integer, but the info is clobbered into a u8 here resulting in lost info. Bug? gSaveFailedWindowIds[TEXT_WIN_ID] = AddWindowWithoutTileMap(gUnknown_085EFD9C); @@ -239,7 +239,7 @@ static void CB2_SaveFailedScreen(void) ResetPaletteFade(); LoadPalette(gBirchBagGrassPal, 0, 0x40); LoadPalette(sSaveFailedClockPal, 0x100, 0x20); - LoadPalette(gUnknown_0850FEFC, 0xE0, 0x20); + LoadPalette(gTextWindowFrame1_Pal, 0xE0, 0x20); LoadPalette(gUnknown_0860F074, 0xF0, 0x20); SetWindowBorderStyle(gSaveFailedWindowIds[TEXT_WIN_ID], FALSE, 0x214, 0xE); SetWindowBorderStyle(gSaveFailedWindowIds[CLOCK_WIN_ID], FALSE, 0x214, 0xE); diff --git a/src/text_window.c b/src/text_window.c index 336536c04..c5334b11e 100644 --- a/src/text_window.c +++ b/src/text_window.c @@ -8,7 +8,7 @@ extern u8 LoadBgTiles(u8 bg, const void *src, u16 size, u16 destOffset); extern void FillBgTilemapBufferRect(u8 bg, u16 tileNum, u8 x, u8 y, u8 width, u8 height, u8 palette); extern const struct TilesPal gUnknown_0851021C[]; -extern const u32 gUnknown_08DDD748[]; +extern const u32 gMessageBox_Gfx[]; extern const u16 gUnknown_0851017C[]; extern const u16 gUnknown_08DDD728[]; @@ -22,7 +22,7 @@ const struct TilesPal* sub_8098758(u8 id) void copy_textbox_border_tile_patterns_to_vram(u8 windowId, u16 destOffset, u8 palOffset) { - LoadBgTiles(GetWindowAttribute(windowId, WINDOW_PRIORITY), gUnknown_08DDD748, 0x1C0, destOffset); + LoadBgTiles(GetWindowAttribute(windowId, WINDOW_PRIORITY), gMessageBox_Gfx, 0x1C0, destOffset); LoadPalette(GetOverworldTextboxPalettePtr(), palOffset, 0x20); } -- cgit v1.2.3 From b47b9e57589cbe0334a5a370d35bd44592c806e3 Mon Sep 17 00:00:00 2001 From: Diegoisawesome Date: Sat, 20 Jan 2018 16:22:16 -0600 Subject: Extract data from starter_choose --- src/starter_choose.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/starter_choose.c b/src/starter_choose.c index 2d78af8fb..c2c553d46 100644 --- a/src/starter_choose.c +++ b/src/starter_choose.c @@ -74,7 +74,7 @@ static void Task_MoveStarterChooseCursor(u8 taskId); static void sub_8134668(u8 taskId); static void CreateStarterPokemonLabel(u8 selection); static u8 CreatePokemonFrontSprite(u16 species, u8 x, u8 y); -static void StarterPokemonSpriteCallback(struct Sprite *sprite); +void StarterPokemonSpriteCallback(struct Sprite *sprite); static IWRAM_DATA u16 sStarterChooseWindowId; @@ -361,7 +361,7 @@ static u8 CreatePokemonFrontSprite(u16 species, u8 x, u8 y) return spriteId; } -static void sub_81346DC(struct Sprite *sprite) +void sub_81346DC(struct Sprite *sprite) { sprite->pos1.x = gUnknown_085B1E28[gTasks[sprite->data[0]].tStarterSelection][0]; sprite->pos1.y = gUnknown_085B1E28[gTasks[sprite->data[0]].tStarterSelection][1]; @@ -369,7 +369,7 @@ static void sub_81346DC(struct Sprite *sprite) sprite->data[1] = (u8)(sprite->data[1]) + 4; } -static void sub_813473C(struct Sprite *sprite) +void sub_813473C(struct Sprite *sprite) { if (gTasks[sprite->data[0]].tStarterSelection == sprite->data[1]) StartSpriteAnimIfDifferent(sprite, 1); @@ -377,7 +377,7 @@ static void sub_813473C(struct Sprite *sprite) StartSpriteAnimIfDifferent(sprite, 0); } -static void StarterPokemonSpriteCallback(struct Sprite *sprite) +void StarterPokemonSpriteCallback(struct Sprite *sprite) { //Move sprite to upper center of screen if (sprite->pos1.x > STARTER_PKMN_POS_X) -- cgit v1.2.3 From 59e1aacd26207f6bcbd1d0107886627c53950a7c Mon Sep 17 00:00:00 2001 From: golem galvanize Date: Sat, 20 Jan 2018 17:26:30 -0500 Subject: DIEGO SEND HELP --- src/mail.c | 24 ------------------------ 1 file changed, 24 deletions(-) (limited to 'src') diff --git a/src/mail.c b/src/mail.c index 68a55e242..ca3531786 100644 --- a/src/mail.c +++ b/src/mail.c @@ -240,30 +240,6 @@ static const struct MailLayout sUnknown_0859F458[] = { { 0x05, 0x09, 0x60, 0x05, 0x1e, Unknown_0859F444 } }; -// What the heck are these meant to be? Call them u16 for now. - -static const u16 Unknown_0859F4E8[] = { - 0x00, 0x4000, 0x00, 0x00 -}; - -static const u16 Unknown_0859F4F0[] = { - 0x00, 0x00, -1, 0x00 -}; - -static const u16 Unknown_0859F4F8[] = { - 0x04, 0x00, -1, 0x00 -}; - -static const u16 Unknown_0859F500[] = { - 0x00, 0x40, -1, 0x00 -}; - -static const u16 *const sUnknown_0859F508[] = { - Unknown_0859F4F0, - Unknown_0859F4F8, - Unknown_0859F500 -}; - // .text void ReadMail(struct MailStruct *mail, void (*callback)(void), bool8 flag) -- cgit v1.2.3 From 0bc7fb92db8658c461f81ef57bc9bc4f3ee80c7b Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 21 Jan 2018 12:36:11 +0100 Subject: start decompiling mystery event script --- src/mystery_event_msg.c | 13 ++ src/mystery_event_script.c | 396 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 409 insertions(+) create mode 100644 src/mystery_event_msg.c create mode 100644 src/mystery_event_script.c (limited to 'src') diff --git a/src/mystery_event_msg.c b/src/mystery_event_msg.c new file mode 100644 index 000000000..74261179b --- /dev/null +++ b/src/mystery_event_msg.c @@ -0,0 +1,13 @@ +#include "global.h" + +const u8 gText_MysteryGiftBerry[] = _("Obtained a {STR_VAR_2} BERRY!\nDad has it at PETALBURG GYM."); +const u8 gText_MysteryGiftBerryTransform[] = _("The {STR_VAR_1} BERRY transformed into\none {STR_VAR_2} BERRY."); +const u8 gText_MysteryGiftBerryObtained[] = _("The {STR_VAR_1} BERRY has already been\nobtained."); +const u8 gText_MysteryGiftSpecialRibbon[] = _("A special RIBBON was awarded to\nyour party POKéMON."); +const u8 gText_MysteryGiftNationalDex[] = _("The POKéDEX has been upgraded\nwith the NATIONAL MODE."); +const u8 gText_MysteryGiftRareWord[] = _("A rare word has been added."); +const u8 gText_MysteryGiftSentOver[] = _("{STR_VAR_1} was sent over!"); +const u8 gText_MysteryGiftFullParty[] = _("Your party is full.\n{STR_VAR_1} could not be sent over."); +const u8 gText_MysteryGiftNewTrainer[] = _("A new TRAINER has arrived in\nHOENN."); +const u8 gText_MysteryGiftNewAdversaryInBattleTower[] = _("A new adversary has arrived in the\nBATTLE TOWER."); +const u8 gText_MysteryGiftCantBeUsed[] = _("This data can’t be used in\nthis version."); diff --git a/src/mystery_event_script.c b/src/mystery_event_script.c new file mode 100644 index 000000000..d64c2c69e --- /dev/null +++ b/src/mystery_event_script.c @@ -0,0 +1,396 @@ +#include "global.h" +#include "berry.h" +#include "battle_tower.h" +#include "easy_chat.h" +#include "event_data.h" +#include "mail.h" +#include "mystery_event_script.h" +#include "pokedex.h" +#include "pokemon.h" +#include "pokemon_size_record.h" +#include "script.h" +#include "constants/species.h" +#include "strings.h" +#include "string_util.h" +#include "text.h" +#include "util.h" +#include "mystery_event_msg.h" +#include "pokemon_storage_system.h" + +extern void sub_811EFC0(u8); +extern void ValidateEReaderTrainer(void); + +extern ScrCmdFunc gMysteryEventScriptCmdTable[]; +extern ScrCmdFunc gMysteryEventScriptCmdTableEnd[]; + +#define LANGUAGE_MASK 0x1 +#define VERSION_MASK 0x200 + +EWRAM_DATA struct ScriptContext sMysteryEventScriptContext = {0}; + +static bool32 CheckCompatibility(u16 a1, u32 a2, u16 a3, u32 a4) +{ + if (!(a1 & LANGUAGE_MASK)) + return FALSE; + + if (!(a2 & LANGUAGE_MASK)) + return FALSE; + + if (!(a3 & 0x4)) + return FALSE; + + if (!(a4 & VERSION_MASK)) + return FALSE; + + return TRUE; +} + +static void SetIncompatible(void) +{ + StringExpandPlaceholders(gStringVar4, gText_MysteryGiftCantBeUsed); + SetMysteryEventScriptStatus(3); +} + +static void InitMysteryEventScript(struct ScriptContext *ctx, u8 *script) +{ + InitScriptContext(ctx, gMysteryEventScriptCmdTable, gMysteryEventScriptCmdTableEnd); + SetupBytecodeScript(ctx, script); + ctx->data[0] = (u32)script; + ctx->data[1] = 0; + ctx->data[2] = 0; + ctx->data[3] = 0; +} + +static bool32 RunMysteryEventScriptCommand(struct ScriptContext *ctx) +{ + if (RunScriptCommand(ctx) && ctx->data[3]) + return TRUE; + else + return FALSE; +} + +void sub_8153870(u8 *script) +{ + InitMysteryEventScript(&sMysteryEventScriptContext, script); +} + +bool32 sub_8153884(u32 *a0) +{ + bool32 ret = RunMysteryEventScriptCommand(&sMysteryEventScriptContext); + *a0 = sMysteryEventScriptContext.data[2]; + + return ret; +} + +u32 RunMysteryEventScript(u8 *script) +{ + struct ScriptContext *ctx = &sMysteryEventScriptContext; + InitMysteryEventScript(ctx, script); + while (RunMysteryEventScriptCommand(ctx)) + ; + return ctx->data[2]; +} + +void SetMysteryEventScriptStatus(u32 val) +{ + sMysteryEventScriptContext.data[2] = val; +} + +static int CalcRecordMixingGiftChecksum(void) +{ + unsigned int i; + int sum = 0; + u8 *data = (u8*)(&gSaveBlock1Ptr->recordMixingGift.data); + + for (i = 0; i < sizeof(gSaveBlock1Ptr->recordMixingGift.data); i++) + sum += data[i]; + + return sum; +} + +static bool32 IsRecordMixingGiftValid(void) +{ + struct RecordMixingGiftData *data = &gSaveBlock1Ptr->recordMixingGift.data; + int checksum = CalcRecordMixingGiftChecksum(); + + if (data->unk0 == 0 + || data->quantity == 0 + || data->itemId == 0 + || checksum == 0 + || checksum != gSaveBlock1Ptr->recordMixingGift.checksum) + return FALSE; + else + return TRUE; +} + +static void ClearRecordMixingGift(void) +{ + CpuFill16(0, &gSaveBlock1Ptr->recordMixingGift, sizeof(gSaveBlock1Ptr->recordMixingGift)); +} + +static void SetRecordMixingGift(u8 unk, u8 quantity, u16 itemId) +{ + if (!unk || !quantity || !itemId) + { + ClearRecordMixingGift(); + } + else + { + gSaveBlock1Ptr->recordMixingGift.data.unk0 = unk; + gSaveBlock1Ptr->recordMixingGift.data.quantity = quantity; + gSaveBlock1Ptr->recordMixingGift.data.itemId = itemId; + gSaveBlock1Ptr->recordMixingGift.checksum = CalcRecordMixingGiftChecksum(); + } +} + +u16 GetRecordMixingGift(void) +{ + struct RecordMixingGiftData *data = &gSaveBlock1Ptr->recordMixingGift.data; + + if (!IsRecordMixingGiftValid()) + { + ClearRecordMixingGift(); + return 0; + } + else + { + u16 itemId = data->itemId; + data->quantity--; + if (data->quantity == 0) + ClearRecordMixingGift(); + else + gSaveBlock1Ptr->recordMixingGift.checksum = CalcRecordMixingGiftChecksum(); + + return itemId; + } +} + +bool8 MEScrCmd_end(struct ScriptContext *ctx) +{ + StopScript(ctx); + return TRUE; +} + +bool8 MEScrCmd_checkcompat(struct ScriptContext *ctx) +{ + u16 v1; + u32 v2; + u16 v3; + u32 v4; + + ctx->data[1] = ScriptReadWord(ctx); + v1 = ScriptReadHalfword(ctx); + v2 = ScriptReadWord(ctx); + v3 = ScriptReadHalfword(ctx); + v4 = ScriptReadWord(ctx); + + if (CheckCompatibility(v1, v2, v3, v4) == TRUE) + ctx->data[3] = 1; + else + SetIncompatible(); + + return TRUE; +} + +bool8 MEScrCmd_nop(struct ScriptContext *ctx) +{ + return FALSE; +} + +bool8 MEScrCmd_setstatus(struct ScriptContext *ctx) +{ + u8 value = ScriptReadByte(ctx); + ctx->data[2] = value; + return FALSE; +} + +bool8 MEScrCmd_setmsg(struct ScriptContext *ctx) +{ + u8 value = ScriptReadByte(ctx); + u8 *str = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + if (value == 255 || value == ctx->data[2]) + StringExpandPlaceholders(gStringVar4, str); + return FALSE; +} + +bool8 MEScrCmd_runscript(struct ScriptContext *ctx) +{ + u8 *script = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + ScriptContext2_RunNewScript(script); + return FALSE; +} + +bool8 MEScrCmd_setenigmaberry(struct ScriptContext *ctx) +{ + u8 *str; + const u8 *message; + bool32 haveBerry = IsEnigmaBerryValid(); + u8 *berry = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + StringCopyN(gStringVar1, gSaveBlock1Ptr->enigmaBerry.berry.name, BERRY_NAME_COUNT); + SetEnigmaBerry(berry); + StringCopyN(gStringVar2, gSaveBlock1Ptr->enigmaBerry.berry.name, BERRY_NAME_COUNT); + + if (!haveBerry) + { + str = gStringVar4; + message = gText_MysteryGiftBerry; + } + else if (StringCompare(gStringVar1, gStringVar2)) + { + str = gStringVar4; + message = gText_MysteryGiftBerryTransform; + } + else + { + str = gStringVar4; + message = gText_MysteryGiftBerryObtained; + } + + StringExpandPlaceholders(str, message); + + ctx->data[2] = 2; + + if (IsEnigmaBerryValid() == TRUE) + VarSet(VAR_ENIGMA_BERRY_AVAILABLE, 1); + else + ctx->data[2] = 1; + + return FALSE; +} + +bool8 MEScrCmd_giveribbon(struct ScriptContext *ctx) +{ + u8 index = ScriptReadByte(ctx); + u8 ribbonId = ScriptReadByte(ctx); + GiveGiftRibbonToParty(index, ribbonId); + StringExpandPlaceholders(gStringVar4, gText_MysteryGiftSpecialRibbon); + ctx->data[2] = 2; + return FALSE; +} + +bool8 MEScrCmd_initramscript(struct ScriptContext *ctx) +{ + u8 mapGroup = ScriptReadByte(ctx); + u8 mapNum = ScriptReadByte(ctx); + u8 objectId = ScriptReadByte(ctx); + u8 *script = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + u8 *scriptEnd = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + InitRamScript(script, scriptEnd - script, mapGroup, mapNum, objectId); + return FALSE; +} + +bool8 MEScrCmd_givenationaldex(struct ScriptContext *ctx) +{ + EnableNationalPokedex(); + StringExpandPlaceholders(gStringVar4, gText_MysteryGiftNationalDex); + ctx->data[2] = 2; + return FALSE; +} + +bool8 MEScrCmd_addrareword(struct ScriptContext *ctx) +{ + sub_811EFC0(ScriptReadByte(ctx)); + StringExpandPlaceholders(gStringVar4, gText_MysteryGiftRareWord); + ctx->data[2] = 2; + return FALSE; +} + +bool8 MEScrCmd_setrecordmixinggift(struct ScriptContext *ctx) +{ + u8 unk = ScriptReadByte(ctx); + u8 quantity = ScriptReadByte(ctx); + u16 itemId = ScriptReadHalfword(ctx); + SetRecordMixingGift(unk, quantity, itemId); + return FALSE; +} + +bool8 MEScrCmd_givepokemon(struct ScriptContext *ctx) +{ + struct MailStruct mail; + struct Pokemon pokemon; + u16 species; + u16 heldItem; + u32 data = ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]; + void *pokemonPtr = (void *)data; + void *mailPtr = (void *)(data + sizeof(struct Pokemon)); + + pokemon = *(struct Pokemon *)pokemonPtr; + species = GetMonData(&pokemon, MON_DATA_SPECIES2); + + if (species == SPECIES_EGG) + StringCopyN(gStringVar1, gText_EggNickname, POKEMON_NAME_LENGTH + 1); + else + StringCopyN(gStringVar1, gText_Pokemon, POKEMON_NAME_LENGTH + 1); + + if (gPlayerPartyCount == PARTY_SIZE) + { + StringExpandPlaceholders(gStringVar4, gText_MysteryGiftFullParty); + ctx->data[2] = 3; + } + else + { + memcpy(&gPlayerParty[5], pokemonPtr, sizeof(struct Pokemon)); + memcpy(&mail, mailPtr, sizeof(struct MailStruct)); + + if (species != SPECIES_EGG) + { + u16 pokedexNum = SpeciesToNationalPokedexNum(species); + GetSetPokedexFlag(pokedexNum, FLAG_SET_SEEN); + GetSetPokedexFlag(pokedexNum, FLAG_SET_CAUGHT); + } + + heldItem = GetMonData(&gPlayerParty[5], MON_DATA_HELD_ITEM); + if (ItemIsMail(heldItem)) + GiveMailToMon2(&gPlayerParty[5], &mail); + CompactPartySlots(); + CalculatePlayerPartyCount(); + StringExpandPlaceholders(gStringVar4, gText_MysteryGiftSentOver); + ctx->data[2] = 2; + } + + return FALSE; +} + +bool8 MEScrCmd_addtrainer(struct ScriptContext *ctx) +{ + u32 data = ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]; + memcpy((void*)(gSaveBlock2Ptr) + 0xBEC, (void *)data, 0xBC); + ValidateEReaderTrainer(); + StringExpandPlaceholders(gStringVar4, gText_MysteryGiftNewTrainer); + ctx->data[2] = 2; + return FALSE; +} + +bool8 MEScrCmd_enableresetrtc(struct ScriptContext *ctx) +{ + EnableResetRTC(); + StringExpandPlaceholders(gStringVar4, gText_InGameClockUsable); + ctx->data[2] = 2; + return FALSE; +} + +bool8 MEScrCmd_checksum(struct ScriptContext *ctx) +{ + int checksum = ScriptReadWord(ctx); + u8 *data = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + u8 *dataEnd = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + if (checksum != CalcByteArraySum(data, dataEnd - data)) + { + ctx->data[3] = 0; + ctx->data[2] = 1; + } + return TRUE; +} + +bool8 MEScrCmd_crc(struct ScriptContext *ctx) +{ + int crc = ScriptReadWord(ctx); + u8 *data = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + u8 *dataEnd = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); + if (crc != CalcCRC16(data, dataEnd - data)) + { + ctx->data[3] = 0; + ctx->data[2] = 1; + } + return TRUE; +} -- cgit v1.2.3 From e0fbd5daad0646c77d1f587d2763bc707df5d417 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 21 Jan 2018 13:32:11 +0100 Subject: text window cleanup --- src/option_menu.c | 13 +++--- src/save_failed_screen.c | 3 +- src/text_window.c | 112 ++++++++++++++++++++++++++++++++++++++--------- 3 files changed, 98 insertions(+), 30 deletions(-) (limited to 'src') diff --git a/src/option_menu.c b/src/option_menu.c index b76d9e0e6..7f92756ab 100644 --- a/src/option_menu.c +++ b/src/option_menu.c @@ -262,9 +262,7 @@ void CB2_InitOptionMenu(void) static void Task_OptionMenuFadeIn(u8 taskId) { if (!gPaletteFade.active) - { gTasks[taskId].func = Task_OptionMenuProcessInput; - } } static void Task_OptionMenuProcessInput(u8 taskId) @@ -517,12 +515,11 @@ static void Sound_DrawChoices(u8 selection) DrawOptionMenuChoice(gText_SoundStereo, GetStringRightAlignXOffset(1, gText_SoundStereo, 198), 48, styles[1]); } -// TODO: 19 should be defined in text_window.h static u8 FrameType_ProcessInput(u8 selection) { if (gMain.newKeys & DPAD_RIGHT) { - if (selection < 19) + if (selection < WINDOW_FRAMES_COUNT - 1) selection++; else selection = 0; @@ -536,7 +533,7 @@ static u8 FrameType_ProcessInput(u8 selection) if (selection != 0) selection--; else - selection = 19; + selection = WINDOW_FRAMES_COUNT - 1; LoadBgTiles(1, GetWindowFrameTilesPal(selection)->tiles, 0x120, 0x1A2); LoadPalette(GetWindowFrameTilesPal(selection)->pal, 0x70, 0x20); @@ -601,7 +598,7 @@ static u8 ButtonMode_ProcessInput(u8 selection) static void ButtonMode_DrawChoices(u8 selection) { - s32 widthNormal, widthLR, widthLA, yLR; + s32 widthNormal, widthLR, widthLA, xLR; u8 styles[3]; styles[0] = 0; @@ -616,8 +613,8 @@ static void ButtonMode_DrawChoices(u8 selection) widthLA = GetStringWidth(1, gText_ButtonTypeLEqualsA, 0); widthLR -= 94; - yLR = (widthNormal - widthLR - widthLA) / 2 + 104; - DrawOptionMenuChoice(gText_ButtonTypeLR, yLR, 64, styles[1]); + xLR = (widthNormal - widthLR - widthLA) / 2 + 104; + DrawOptionMenuChoice(gText_ButtonTypeLR, xLR, 64, styles[1]); DrawOptionMenuChoice(gText_ButtonTypeLEqualsA, GetStringRightAlignXOffset(1, gText_ButtonTypeLEqualsA, 198), 64, styles[2]); } diff --git a/src/save_failed_screen.c b/src/save_failed_screen.c index efe38fbae..8764daa5f 100755 --- a/src/save_failed_screen.c +++ b/src/save_failed_screen.c @@ -9,6 +9,7 @@ #include "menu.h" #include "save.h" #include "gba/flash_internal.h" +#include "text_window.h" #define MSG_WIN_TOP 12 #define CLOCK_WIN_TOP (MSG_WIN_TOP - 4) @@ -21,9 +22,7 @@ extern const u8 gBirchHelpGfx[]; extern const u8 gBirchBagTilemap[]; extern const u8 gBirchGrassTilemap[]; extern const u16 gBirchBagGrassPal[]; -extern const u16 gTextWindowFrame1_Pal[]; extern const u16 gUnknown_0860F074[]; -extern const u32 gTextWindowFrame1_Gfx[]; extern struct SaveSection gSaveDataBuffer; extern u8 gText_SaveFailedCheckingBackup[]; diff --git a/src/text_window.c b/src/text_window.c index 4c357ec7f..33cd7cffe 100644 --- a/src/text_window.c +++ b/src/text_window.c @@ -3,21 +3,92 @@ #include "text_window.h" #include "window.h" #include "palette.h" - -extern u8 LoadBgTiles(u8 bg, const void *src, u16 size, u16 destOffset); -extern void FillBgTilemapBufferRect(u8 bg, u16 tileNum, u8 x, u8 y, u8 width, u8 height, u8 palette); - -extern const struct TilesPal gUnknown_0851021C[20]; -extern const u32 gMessageBox_Gfx[]; -extern const u16 gUnknown_0851017C[]; -extern const u16 gUnknown_08DDD728[]; - -const struct TilesPal* GetWindowFrameTilesPal(u8 id) +#include "bg.h" +#include "graphics.h" + +// const rom data +const u32 gTextWindowFrame1_Gfx[] = INCBIN_U32("graphics/text_window/1.4bpp"); +static const u32 sTextWindowFrame2_Gfx[] = INCBIN_U32("graphics/text_window/2.4bpp"); +static const u32 sTextWindowFrame3_Gfx[] = INCBIN_U32("graphics/text_window/3.4bpp"); +static const u32 sTextWindowFrame4_Gfx[] = INCBIN_U32("graphics/text_window/4.4bpp"); +static const u32 sTextWindowFrame5_Gfx[] = INCBIN_U32("graphics/text_window/5.4bpp"); +static const u32 sTextWindowFrame6_Gfx[] = INCBIN_U32("graphics/text_window/6.4bpp"); +static const u32 sTextWindowFrame7_Gfx[] = INCBIN_U32("graphics/text_window/7.4bpp"); +static const u32 sTextWindowFrame8_Gfx[] = INCBIN_U32("graphics/text_window/8.4bpp"); +static const u32 sTextWindowFrame9_Gfx[] = INCBIN_U32("graphics/text_window/9.4bpp"); +static const u32 sTextWindowFrame10_Gfx[] = INCBIN_U32("graphics/text_window/10.4bpp"); +static const u32 sTextWindowFrame11_Gfx[] = INCBIN_U32("graphics/text_window/11.4bpp"); +static const u32 sTextWindowFrame12_Gfx[] = INCBIN_U32("graphics/text_window/12.4bpp"); +static const u32 sTextWindowFrame13_Gfx[] = INCBIN_U32("graphics/text_window/13.4bpp"); +static const u32 sTextWindowFrame14_Gfx[] = INCBIN_U32("graphics/text_window/14.4bpp"); +static const u32 sTextWindowFrame15_Gfx[] = INCBIN_U32("graphics/text_window/15.4bpp"); +static const u32 sTextWindowFrame16_Gfx[] = INCBIN_U32("graphics/text_window/16.4bpp"); +static const u32 sTextWindowFrame17_Gfx[] = INCBIN_U32("graphics/text_window/17.4bpp"); +static const u32 sTextWindowFrame18_Gfx[] = INCBIN_U32("graphics/text_window/18.4bpp"); +static const u32 sTextWindowFrame19_Gfx[] = INCBIN_U32("graphics/text_window/19.4bpp"); +static const u32 sTextWindowFrame20_Gfx[] = INCBIN_U32("graphics/text_window/20.4bpp"); + +const u16 gTextWindowFrame1_Pal[] = INCBIN_U16("graphics/text_window/1.gbapal"); +static const u16 sTextWindowFrame2_Pal[] = INCBIN_U16("graphics/text_window/2.gbapal"); +static const u16 sTextWindowFrame3_Pal[] = INCBIN_U16("graphics/text_window/3.gbapal"); +static const u16 sTextWindowFrame4_Pal[] = INCBIN_U16("graphics/text_window/4.gbapal"); +static const u16 sTextWindowFrame5_Pal[] = INCBIN_U16("graphics/text_window/5.gbapal"); +static const u16 sTextWindowFrame6_Pal[] = INCBIN_U16("graphics/text_window/6.gbapal"); +static const u16 sTextWindowFrame7_Pal[] = INCBIN_U16("graphics/text_window/7.gbapal"); +static const u16 sTextWindowFrame8_Pal[] = INCBIN_U16("graphics/text_window/8.gbapal"); +static const u16 sTextWindowFrame9_Pal[] = INCBIN_U16("graphics/text_window/9.gbapal"); +static const u16 sTextWindowFrame10_Pal[] = INCBIN_U16("graphics/text_window/10.gbapal"); +static const u16 sTextWindowFrame11_Pal[] = INCBIN_U16("graphics/text_window/11.gbapal"); +static const u16 sTextWindowFrame12_Pal[] = INCBIN_U16("graphics/text_window/12.gbapal"); +static const u16 sTextWindowFrame13_Pal[] = INCBIN_U16("graphics/text_window/13.gbapal"); +static const u16 sTextWindowFrame14_Pal[] = INCBIN_U16("graphics/text_window/14.gbapal"); +static const u16 sTextWindowFrame15_Pal[] = INCBIN_U16("graphics/text_window/15.gbapal"); +static const u16 sTextWindowFrame16_Pal[] = INCBIN_U16("graphics/text_window/16.gbapal"); +static const u16 sTextWindowFrame17_Pal[] = INCBIN_U16("graphics/text_window/17.gbapal"); +static const u16 sTextWindowFrame18_Pal[] = INCBIN_U16("graphics/text_window/18.gbapal"); +static const u16 sTextWindowFrame19_Pal[] = INCBIN_U16("graphics/text_window/19.gbapal"); +static const u16 sTextWindowFrame20_Pal[] = INCBIN_U16("graphics/text_window/20.gbapal"); + +static const u16 sUnknown_0851017C[][16] = { - if (id >= ARRAY_COUNT(gUnknown_0851021C)) - return &gUnknown_0851021C[0]; + INCBIN_U16("graphics/text_window/message_box.gbapal"), + INCBIN_U16("graphics/text_window/text_pal1.gbapal"), + INCBIN_U16("graphics/text_window/text_pal2.gbapal"), + INCBIN_U16("graphics/text_window/text_pal3.gbapal"), + INCBIN_U16("graphics/text_window/text_pal4.gbapal") +}; + +static const struct TilesPal sWindowFrames[WINDOW_FRAMES_COUNT] = +{ + {gTextWindowFrame1_Gfx, gTextWindowFrame1_Pal}, + {sTextWindowFrame2_Gfx, sTextWindowFrame2_Pal}, + {sTextWindowFrame3_Gfx, sTextWindowFrame3_Pal}, + {sTextWindowFrame4_Gfx, sTextWindowFrame4_Pal}, + {sTextWindowFrame5_Gfx, sTextWindowFrame5_Pal}, + {sTextWindowFrame6_Gfx, sTextWindowFrame6_Pal}, + {sTextWindowFrame7_Gfx, sTextWindowFrame7_Pal}, + {sTextWindowFrame8_Gfx, sTextWindowFrame8_Pal}, + {sTextWindowFrame9_Gfx, sTextWindowFrame9_Pal}, + {sTextWindowFrame10_Gfx, sTextWindowFrame10_Pal}, + {sTextWindowFrame11_Gfx, sTextWindowFrame11_Pal}, + {sTextWindowFrame12_Gfx, sTextWindowFrame12_Pal}, + {sTextWindowFrame13_Gfx, sTextWindowFrame13_Pal}, + {sTextWindowFrame14_Gfx, sTextWindowFrame14_Pal}, + {sTextWindowFrame15_Gfx, sTextWindowFrame15_Pal}, + {sTextWindowFrame16_Gfx, sTextWindowFrame16_Pal}, + {sTextWindowFrame17_Gfx, sTextWindowFrame17_Pal}, + {sTextWindowFrame18_Gfx, sTextWindowFrame18_Pal}, + {sTextWindowFrame19_Gfx, sTextWindowFrame19_Pal}, + {sTextWindowFrame20_Gfx, sTextWindowFrame20_Pal} +}; + +// code +const struct TilesPal *GetWindowFrameTilesPal(u8 id) +{ + if (id >= WINDOW_FRAMES_COUNT) + return &sWindowFrames[0]; else - return &gUnknown_0851021C[id]; + return &sWindowFrames[id]; } void copy_textbox_border_tile_patterns_to_vram(u8 windowId, u16 destOffset, u8 palOffset) @@ -33,8 +104,8 @@ void box_border_load_tiles_and_pal(u8 windowId, u16 destOffset, u8 palOffset) void sub_80987D4(u8 windowId, u8 frameId, u16 destOffset, u8 palOffset) { - LoadBgTiles(GetWindowAttribute(windowId, WINDOW_PRIORITY), gUnknown_0851021C[frameId].tiles, 0x120, destOffset); - LoadPalette(gUnknown_0851021C[frameId].pal, palOffset, 0x20); + LoadBgTiles(GetWindowAttribute(windowId, WINDOW_PRIORITY), sWindowFrames[frameId].tiles, 0x120, destOffset); + LoadPalette(sWindowFrames[frameId].pal, palOffset, 0x20); } void sub_809882C(u8 windowId, u16 destOffset, u8 palOffset) @@ -89,7 +160,7 @@ void rbox_fill_rectangle(u8 windowId) FillBgTilemapBufferRect(bgLayer, 0, tilemapLeft - 1, tilemapTop - 1, width + 2, height + 2, 0x11); } -const u16* stdpal_get(u8 id) +const u16 *stdpal_get(u8 id) { switch (id) { @@ -110,16 +181,17 @@ const u16* stdpal_get(u8 id) id = 0x40; break; } - return &gUnknown_0851017C[id]; + + return (const u16 *)(sUnknown_0851017C) + id; } -const u16* GetOverworldTextboxPalettePtr(void) +const u16 *GetOverworldTextboxPalettePtr(void) { - return gUnknown_08DDD728; + return gMessageBox_Pal; } void sub_8098C6C(u8 bg, u16 destOffset, u8 palOffset) { - LoadBgTiles(bg, gUnknown_0851021C[gSaveBlock2Ptr->optionsWindowFrameType].tiles, 0x120, destOffset); + LoadBgTiles(bg, sWindowFrames[gSaveBlock2Ptr->optionsWindowFrameType].tiles, 0x120, destOffset); LoadPalette(GetWindowFrameTilesPal(gSaveBlock2Ptr->optionsWindowFrameType)->pal, palOffset, 0x20); } -- cgit v1.2.3 From e85d7d5492fb854ba627fb93f4265f1953437327 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 21 Jan 2018 14:23:04 +0100 Subject: Add a comment about one battle transition --- src/battle_transition.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index ca2134837..e003e0fce 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -2730,6 +2730,10 @@ static bool8 Phase2_ShredSplit_Func2(struct Task *task) return FALSE; } +// This function never increments the state counter, because the loop condition +// is always false, resulting in the game being stuck in an infinite loop. +// It's possible this transition is only partially +// done and the second part was left out. static bool8 Phase2_ShredSplit_Func3(struct Task *task) { u16 i; -- cgit v1.2.3 From f59eedb67284b46354b6767d2491b563b63dd809 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 21 Jan 2018 20:45:43 +0100 Subject: decompile hof pc --- src/hof_pc.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 src/hof_pc.c (limited to 'src') diff --git a/src/hof_pc.c b/src/hof_pc.c new file mode 100644 index 000000000..e772f04e8 --- /dev/null +++ b/src/hof_pc.c @@ -0,0 +1,46 @@ +#include "global.h" +#include "hall_of_fame.h" +#include "main.h" +#include "palette.h" +#include "overworld.h" +#include "script.h" +#include "script_menu.h" +#include "task.h" + +extern void (*gFieldCallback)(void); +extern void (*gUnknown_0300485C)(void); + +extern void Overworld_PlaySpecialMapMusic(void); +extern bool16 ScrSpecial_CreatePCMenu(void); +extern void ScriptMenu_DisplayPCStartupPrompt(void); + +static void ReshowPCMenuAfterHallOfFamePC(void); +static void Task_WaitForPaletteFade(u8); + +void AccessHallOfFamePC(void) +{ + SetMainCallback2(CB2_DoHallOfFamePC); + ScriptContext2_Enable(); +} + +void ReturnFromHallOfFamePC(void) +{ + SetMainCallback2(c2_exit_to_overworld_2_switch); + gFieldCallback = ReshowPCMenuAfterHallOfFamePC; +} + +static void ReshowPCMenuAfterHallOfFamePC(void) +{ + ScriptContext2_Enable(); + Overworld_PlaySpecialMapMusic(); + ScrSpecial_CreatePCMenu(); + ScriptMenu_DisplayPCStartupPrompt(); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, 0); + CreateTask(Task_WaitForPaletteFade, 10); +} + +static void Task_WaitForPaletteFade(u8 taskId) +{ + if (!gPaletteFade.active) + DestroyTask(taskId); +} -- cgit v1.2.3 From fbf91fabcf6c3ce07c78a0962754f32994cced9e Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 21 Jan 2018 21:32:30 +0100 Subject: review changes mystery event --- src/mystery_event_script.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/mystery_event_script.c b/src/mystery_event_script.c index 86e7217ef..8822cd05a 100644 --- a/src/mystery_event_script.c +++ b/src/mystery_event_script.c @@ -86,8 +86,8 @@ u32 RunMysteryEventScript(u8 *script) { struct ScriptContext *ctx = &sMysteryEventScriptContext; InitMysteryEventScript(ctx, script); - while (RunMysteryEventScriptCommand(ctx)) - ; + while (RunMysteryEventScriptCommand(ctx)); + return ctx->data[2]; } @@ -208,7 +208,7 @@ bool8 MEScrCmd_setmsg(struct ScriptContext *ctx) { u8 value = ScriptReadByte(ctx); u8 *str = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]); - if (value == 255 || value == ctx->data[2]) + if (value == 0xFF || value == ctx->data[2]) StringExpandPlaceholders(gStringVar4, str); return FALSE; } -- cgit v1.2.3