more work on battle transition

1 files changed, 1988 insertions, 84 deletions

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, &REG_BG0HOFS, 0xA2400001);
+}
+
+void VBlankCB1_Phase2_BigPokeball(void)
+{
+    Transition_BigPokeball_Vblank();
+    DmaSet(0, gUnknown_020393A8, &REG_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], &REG_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], &REG_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], &REG_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], &REG_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], &REG_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;
+    }
+}