emerald file names, part 1

1 files changed, 1605 insertions, 0 deletions

diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c
new file mode 100644
index 000000000..807ec1572
--- /dev/null
+++ b/src/battle_controller_wally.c
@@ -0,0 +1,1605 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_anim.h"
+#include "battle_anim_special.h"
+#include "battle_interface.h"
+#include "battle_message.h"
+#include "data2.h"
+#include "link.h"
+#include "main.h"
+#include "menu_cursor.h"
+#include "palette.h"
+#include "pokemon.h"
+#include "rom3.h"
+#include "constants/songs.h"
+#include "sound.h"
+#include "sprite.h"
+#include "item_use.h"
+#include "string_util.h"
+#include "task.h"
+#include "text.h"
+#include "util.h"
+#include "ewram.h"
+
+struct MovePpInfo
+{
+    u16 moves[4];
+    u8 pp[4];
+    u8 ppBonuses;
+};
+
+extern u8 gActiveBattler;
+extern void (*gBattleBankFunc[])(void);
+extern u32 gBattleExecBuffer;
+extern u8 gBattleBufferA[][0x200];
+extern u8 gBankSpriteIds[];
+extern MainCallback gPreBattleCallback1;
+extern bool8 gDoingBattleAnim;
+extern u16 gBattlerPartyIndexes[];
+extern u8 gHealthboxIDs[];
+extern u16 gBattleTypeFlags;
+extern u16 gAnimMovePower;
+extern s32 gAnimMoveDmg;
+extern u8 gAnimFriendship;
+extern u16 gWeatherMoveAnim;
+extern u32 gTransformedPersonalities[];
+extern void (*gAnimScriptCallback)(void);
+extern bool8 gAnimScriptActive;
+extern u8 gDisplayedStringBattle[];
+extern u8 gBankInMenu;
+extern u8 gBattleMonForms[];
+extern u8 gBattleOutcome;
+extern u16 gUnknown_02024DE8;
+extern u8 gUnknown_02024E68[];
+extern struct SpriteTemplate gUnknown_02024E8C;
+extern u8 gAnimMoveTurn;
+extern struct Window gUnknown_03004210;
+extern u8 gUnknown_0300434C[];
+extern const u8 BattleText_WallyMenu[];
+extern const u8 BattleText_MenuOptions[];
+
+// TODO: include rom3.h when my other PR gets merged
+extern void Emitcmd33(u8, u8, u16);
+extern void Emitcmd35(u8, u16);
+
+extern void nullsub_14(void);
+extern void PrepareBagForWallyTutorial(void);
+extern void sub_8045A5C();
+extern void sub_804777C();
+extern void sub_8043DFC();
+extern bool8 IsDoubleBattle(void);
+extern void c3_0802FDF4(u8);
+extern void PlayerHandlecmd1(void);
+extern void LoadPlayerTrainerBankSprite();
+extern u8 GetBattlerPosition(u8);
+extern void sub_80313A0(struct Sprite *);
+extern u8 GetBattlerAtPosition(u8);
+extern u8 sub_8031720();
+extern void DoMoveAnim();
+extern void sub_80326EC();
+extern void sub_8031F24(void);
+extern void sub_80324BC();
+extern void BufferStringBattle();
+extern u8 GetBattlerSide(u8);
+extern void sub_80304A8(void);
+extern void sub_8047858();
+extern void StartBattleIntroAnim();
+extern void oamt_add_pos2_onto_pos1();
+extern void StartAnimLinearTranslation(struct Sprite *);
+extern void sub_8030E38(struct Sprite *);
+extern void StoreSpriteCallbackInData();
+extern u8 StartSendOutMonAnimation();
+extern u8 GetBattlerSpriteCoord();
+extern u8 sub_8077F68();
+extern u8 GetBattlerSubpriority();
+extern void sub_80312F0(struct Sprite *);
+extern bool8 move_anim_start_t3();
+
+// this file's functions
+
+void WallyBufferRunCommand(void);
+void sub_81374FC(void);
+void sub_81376B8(void);
+void WallyBufferExecCompleted(void);
+u32 sub_8137A84(u8, u8 *);
+void sub_8138294(u8);
+void sub_81390D0(void);
+void sub_8139A2C(u8);
+
+void WallyHandleGetAttributes(void);
+void WallyHandlecmd1(void);
+void WallyHandleSetAttributes(void);
+void WallyHandlecmd3(void);
+void WallyHandleLoadPokeSprite(void);
+void WallyHandleSendOutPoke(void);
+void WallyHandleReturnPokeToBall(void);
+void WallyHandleTrainerThrow(void);
+void WallyHandleTrainerSlide(void);
+void WallyHandleTrainerSlideBack(void);
+void WallyHandlecmd10(void);
+void WallyHandlecmd11(void);
+void WallyHandlecmd12(void);
+void WallyHandleBallThrow(void);
+void WallyHandlePuase(void);
+void WallyHandleMoveAnimation(void);
+void WallyHandlePrintString(void);
+void WallyHandlePrintStringPlayerOnly(void);
+void WallyHandlecmd18(void);
+void WallyHandlecmd19(void);
+void WallyHandlecmd20(void);
+void WallyHandleOpenBag(void);
+void WallyHandlecmd22(void);
+void WallyHandlecmd23(void);
+void WallyHandleHealthBarUpdate(void);
+void WallyHandleExpBarUpdate(void);
+void WallyHandleStatusIconUpdate(void);
+void WallyHandleStatusAnimation(void);
+void WallyHandleStatusXor(void);
+void WallyHandlecmd29(void);
+void WallyHandleDMATransfer(void);
+void WallyHandlecmd31(void);
+void WallyHandlecmd32(void);
+void WallyHandlecmd33(void);
+void WallyHandlecmd34(void);
+void WallyHandlecmd35(void);
+void WallyHandlecmd36(void);
+void WallyHandlecmd37(void);
+void WallyHandlecmd38(void);
+void WallyHandlecmd39(void);
+void WallyHandlecmd40(void);
+void WallyHandleHitAnimation(void);
+void WallyHandlecmd42(void);
+void WallyHandleEffectivenessSound(void);
+void WallyHandlecmd44(void);
+void WallyHandleFaintingCry(void);
+void WallyHandleIntroSlide(void);
+void WallyHandleTrainerBallThrow(void);
+void WallyHandlecmd48(void);
+void WallyHandlecmd49(void);
+void WallyHandlecmd50(void);
+void WallyHandleSpriteInvisibility(void);
+void WallyHandleBattleAnimation(void);
+void WallyHandleLinkStandbyMsg(void);
+void WallyHandleResetActionMoveSelection(void);
+void WallyHandlecmd55(void);
+void WallyHandlecmd56(void);
+
+// const data
+
+typedef void (*BattleBufferCmd) (void);
+static const BattleBufferCmd gWallyBufferCommands[] =
+{
+    WallyHandleGetAttributes,
+    WallyHandlecmd1,
+    WallyHandleSetAttributes,
+    WallyHandlecmd3,
+    WallyHandleLoadPokeSprite,
+    WallyHandleSendOutPoke,
+    WallyHandleReturnPokeToBall,
+    WallyHandleTrainerThrow,
+    WallyHandleTrainerSlide,
+    WallyHandleTrainerSlideBack,
+    WallyHandlecmd10,
+    WallyHandlecmd11,
+    WallyHandlecmd12,
+    WallyHandleBallThrow,
+    WallyHandlePuase,
+    WallyHandleMoveAnimation,
+    WallyHandlePrintString,
+    WallyHandlePrintStringPlayerOnly,
+    WallyHandlecmd18,
+    WallyHandlecmd19,
+    WallyHandlecmd20,
+    WallyHandleOpenBag,
+    WallyHandlecmd22,
+    WallyHandlecmd23,
+    WallyHandleHealthBarUpdate,
+    WallyHandleExpBarUpdate,
+    WallyHandleStatusIconUpdate,
+    WallyHandleStatusAnimation,
+    WallyHandleStatusXor,
+    WallyHandlecmd29,
+    WallyHandleDMATransfer,
+    WallyHandlecmd31,
+    WallyHandlecmd32,
+    WallyHandlecmd33,
+    WallyHandlecmd34,
+    WallyHandlecmd35,
+    WallyHandlecmd36,
+    WallyHandlecmd37,
+    WallyHandlecmd38,
+    WallyHandlecmd39,
+    WallyHandlecmd40,
+    WallyHandleHitAnimation,
+    WallyHandlecmd42,
+    WallyHandleEffectivenessSound,
+    WallyHandlecmd44,
+    WallyHandleFaintingCry,
+    WallyHandleIntroSlide,
+    WallyHandleTrainerBallThrow,
+    WallyHandlecmd48,
+    WallyHandlecmd49,
+    WallyHandlecmd50,
+    WallyHandleSpriteInvisibility,
+    WallyHandleBattleAnimation,
+    WallyHandleLinkStandbyMsg,
+    WallyHandleResetActionMoveSelection,
+    WallyHandlecmd55,
+    WallyHandlecmd56,
+};
+
+// code
+
+void unref_sub_8137220(void)
+{
+}
+
+void SetBankFuncToWallyBufferRunCommand(void)
+{
+    gBattleBankFunc[gActiveBattler] = WallyBufferRunCommand;
+    ewram160A8 = 0;
+    ewram160A9 = 0;
+    ewram160AA = 0;
+    ewram160AB = 0;
+}
+
+void WallyBufferRunCommand(void)
+{
+    if (gBattleExecBuffer & gBitTable[gActiveBattler])
+    {
+        if (gBattleBufferA[gActiveBattler][0] < 0x39)
+            gWallyBufferCommands[gBattleBufferA[gActiveBattler][0]]();
+        else
+            WallyBufferExecCompleted();
+    }
+}
+
+void sub_81372BC(void)
+{
+    u8 r4;
+
+    switch (ewram160A8)
+    {
+    case 0:
+        ewram160AA = 64;
+        ewram160A8++;
+        // fall through
+    case 1:
+        r4 = --ewram160AA;
+        if (r4 == 0)
+        {
+            PlaySE(SE_SELECT);
+            Emitcmd33(1, 0, 0);
+            WallyBufferExecCompleted();
+            ewram160A8++;
+            ewram160A9 = r4;
+            ewram160AA = 64;
+        }
+        break;
+    case 2:
+        r4 = --ewram160AA;
+        if (r4 == 0)
+        {
+            PlaySE(SE_SELECT);
+            Emitcmd33(1, 0, 0);
+            WallyBufferExecCompleted();
+            ewram160A8++;
+            ewram160A9 = r4;
+            ewram160AA = 64;
+        }
+        break;
+    case 3:
+        r4 = --ewram160AA;
+        if (r4 == 0)
+        {
+            Emitcmd33(1, 9, 0);
+            WallyBufferExecCompleted();
+            ewram160A8++;
+            ewram160A9 = r4;
+            ewram160AA = 64;
+        }
+        break;
+    case 4:
+        if (--ewram160AA == 0)
+        {
+            PlaySE(SE_SELECT);
+            nullsub_8(0);
+            sub_802E3E4(1, 0);
+            ewram160AA = 64;
+            ewram160A8++;
+        }
+        break;
+    case 5:
+        if (--ewram160AA == 0)
+        {
+            PlaySE(SE_SELECT);
+            DestroyMenuCursor();
+            Emitcmd33(1, 1, 0);
+            WallyBufferExecCompleted();
+        }
+        break;
+    }
+}
+
+void sub_813741C(void)
+{
+    if (gSprites[gBankSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
+        WallyBufferExecCompleted();
+}
+
+void sub_8137454(void)
+{
+    if (gUnknown_03004210.state == 0)
+        WallyBufferExecCompleted();
+}
+
+void sub_813746C(void)
+{
+    if (!gPaletteFade.active)
+    {
+        gMain.inBattle = FALSE;
+        gMain.callback1 = gPreBattleCallback1;
+        SetMainCallback2(gMain.savedCallback);
+    }
+}
+
+void bx_wait_t5(void)
+{
+    if (!gDoingBattleAnim)
+        WallyBufferExecCompleted();
+}
+
+void sub_81374C4(void)
+{
+    if (!gPaletteFade.active)
+    {
+        gBattleBankFunc[gActiveBattler] = sub_81374FC;
+        nullsub_14();
+        PrepareBagForWallyTutorial();
+    }
+}
+
+void sub_81374FC(void)
+{
+    if (gMain.callback2 == BattleMainCB2
+     && !gPaletteFade.active)
+    {
+        Emitcmd35(1, gSpecialVar_ItemId);
+        WallyBufferExecCompleted();
+    }
+}
+
+void sub_8137538(void)
+{
+    if (!ewram17810[gActiveBattler].unk0_3 && !ewram17810[gActiveBattler].unk0_7)
+        sub_8141828(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]);
+
+    if (!ewram17810[gActiveBattler ^ 2].unk0_3 && !ewram17810[gActiveBattler ^ 2].unk0_7)
+        sub_8141828(gActiveBattler ^ 2, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler ^ 2]]);
+
+    if (!ewram17810[gActiveBattler].unk0_3 && !ewram17810[gActiveBattler ^ 2].unk0_3)
+    {
+        if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+        {
+            DestroySprite(&gSprites[gUnknown_0300434C[gActiveBattler ^ 2]]);
+            sub_8045A5C(gHealthboxIDs[gActiveBattler ^ 2], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler ^ 2]], 0);
+            sub_804777C(gActiveBattler ^ 2);
+            sub_8043DFC(gHealthboxIDs[gActiveBattler ^ 2]);
+        }
+        DestroySprite(&gSprites[gUnknown_0300434C[gActiveBattler]]);
+        sub_8045A5C(gHealthboxIDs[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], 0);
+        sub_804777C(gActiveBattler);
+        sub_8043DFC(gHealthboxIDs[gActiveBattler]);
+        ewram17840.unk9_0 = 0;
+        gBattleBankFunc[gActiveBattler] = sub_81376B8;
+    }
+}
+
+void sub_81376B8(void)
+{
+    bool8 r4 = FALSE;
+
+    if (gSprites[gHealthboxIDs[gActiveBattler]].callback == SpriteCallbackDummy)
+        r4 = TRUE;
+    if (r4 && ewram17810[gActiveBattler].unk1_0 && ewram17810[gActiveBattler ^ 2].unk1_0)
+    {
+        ewram17810[gActiveBattler].unk0_7 = 0;
+        ewram17810[gActiveBattler].unk1_0 = 0;
+        ewram17810[gActiveBattler ^ 2].unk0_7 = 0;
+        ewram17810[gActiveBattler ^ 2].unk1_0 = 0;
+        FreeSpriteTilesByTag(0x27F9);
+        FreeSpritePaletteByTag(0x27F9);
+        CreateTask(c3_0802FDF4, 10);
+        HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
+        WallyBufferExecCompleted();
+    }
+}
+
+void sub_81377B0(void)
+{
+    s16 r4;
+
+    r4 = sub_8045C78(gActiveBattler, gHealthboxIDs[gActiveBattler], 0, 0);
+    sub_8043DFC(gHealthboxIDs[gActiveBattler]);
+    if (r4 != -1)
+    {
+        sub_80440EC(gHealthboxIDs[gActiveBattler], r4, 0);
+    }
+    else
+    {
+        HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
+        WallyBufferExecCompleted();
+    }
+}
+
+void bx_blink_t5(void)
+{
+    u8 spriteId = gBankSpriteIds[gActiveBattler];
+
+    if (gSprites[spriteId].data[1] == 32)
+    {
+        gSprites[spriteId].data[1] = 0;
+        gSprites[spriteId].invisible = FALSE;
+        gDoingBattleAnim = FALSE;
+        WallyBufferExecCompleted();
+    }
+    else
+    {
+        if (((u16)gSprites[spriteId].data[1] % 4) == 0)
+            gSprites[spriteId].invisible ^= 1;
+        gSprites[spriteId].data[1]++;
+    }
+}
+
+void sub_813789C(void)
+{
+    if (!ewram17810[gActiveBattler].unk0_6)
+    {
+        FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBattler]]);
+        DestroySprite(&gSprites[gBankSpriteIds[gActiveBattler]]);
+        sub_8043DB0(gHealthboxIDs[gActiveBattler]);
+        WallyBufferExecCompleted();
+    }
+}
+
+// Duplicate of sub_813741C
+void sub_8137908(void)
+{
+    if (gSprites[gBankSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
+        WallyBufferExecCompleted();
+}
+
+void sub_8137940(void)
+{
+    if (!ewram17810[gActiveBattler].unk0_5)
+        WallyBufferExecCompleted();
+}
+
+void WallyBufferExecCompleted(void)
+{
+    gBattleBankFunc[gActiveBattler] = WallyBufferRunCommand;
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        u8 multiplayerId = GetMultiplayerId();
+
+        PrepareBufferDataTransferLink(2, 4, &multiplayerId);
+        gBattleBufferA[gActiveBattler][0] = 0x38;
+    }
+    else
+    {
+        gBattleExecBuffer &= ~gBitTable[gActiveBattler];
+    }
+}
+
+void unref_sub_81379E4(void)
+{
+    if (!ewram17810[gActiveBattler].unk0_4)
+        WallyBufferExecCompleted();
+}
+
+void WallyHandleGetAttributes(void)
+{
+    u8 arr[0x100];
+    u32 r6 = 0;
+    u8 r4;
+    s32 i;
+
+    if (gBattleBufferA[gActiveBattler][2] == 0)
+    {
+        r6 = sub_8137A84(gBattlerPartyIndexes[gActiveBattler], arr);
+    }
+    else
+    {
+        r4 = gBattleBufferA[gActiveBattler][2];
+        for (i = 0; i < 6; i++)
+        {
+            if (r4 & 1)
+                r6 += sub_8137A84(i, arr + r6);
+            r4 >>= 1;
+        }
+    }
+    Emitcmd29(1, r6, arr);
+    WallyBufferExecCompleted();
+}
+
+u32 sub_8137A84(u8 a, u8 *buffer)
+{
+    struct BattlePokemon battlePokemon;
+    struct MovePpInfo moveData;
+    u8 nickname[20];
+    u8 *src;
+    s16 data16;
+    u32 data32;
+    s32 size = 0;
+
+    switch (gBattleBufferA[gActiveBattler][1])
+    {
+    case 0:
+        battlePokemon.species = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES);
+        battlePokemon.item = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM);
+        for (size = 0; size < 4; size++)
+        {
+            battlePokemon.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size);
+            battlePokemon.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size);
+        }
+        battlePokemon.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES);
+        battlePokemon.friendship = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP);
+        battlePokemon.experience = GetMonData(&gPlayerParty[a], MON_DATA_EXP);
+        battlePokemon.hpIV = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV);
+        battlePokemon.attackIV = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV);
+        battlePokemon.defenseIV = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV);
+        battlePokemon.speedIV = GetMonData(&gPlayerParty[a], MON_DATA_SPEED_IV);
+        battlePokemon.spAttackIV = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV);
+        battlePokemon.spDefenseIV = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV);
+        battlePokemon.personality = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY);
+        battlePokemon.status1 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS);
+        battlePokemon.level = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL);
+        battlePokemon.hp = GetMonData(&gPlayerParty[a], MON_DATA_HP);
+        battlePokemon.maxHP = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP);
+        battlePokemon.attack = GetMonData(&gPlayerParty[a], MON_DATA_ATK);
+        battlePokemon.defense = GetMonData(&gPlayerParty[a], MON_DATA_DEF);
+        battlePokemon.speed = GetMonData(&gPlayerParty[a], MON_DATA_SPEED);
+        battlePokemon.spAttack = GetMonData(&gPlayerParty[a], MON_DATA_SPATK);
+        battlePokemon.spDefense = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF);
+        battlePokemon.isEgg = GetMonData(&gPlayerParty[a], MON_DATA_IS_EGG);
+        battlePokemon.altAbility = GetMonData(&gPlayerParty[a], MON_DATA_ALT_ABILITY);
+        battlePokemon.otId = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID);
+        GetMonData(&gPlayerParty[a], MON_DATA_NICKNAME, nickname);
+        StringCopy10(battlePokemon.nickname, nickname);
+        GetMonData(&gPlayerParty[a], MON_DATA_OT_NAME, battlePokemon.otName);
+        MEMCPY_ALT(&battlePokemon, buffer, sizeof(battlePokemon), size, src);
+        break;
+    case 1:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 2:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 3:
+        for (size = 0; size < 4; size++)
+        {
+            moveData.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size);
+            moveData.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size);
+        }
+        moveData.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES);
+        MEMCPY_ALT(&moveData, buffer, sizeof(moveData), size, src);
+        break;
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBattler][1] - 4);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 8:
+        for (size = 0; size < 4; size++)
+            buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size);
+        buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES);
+        size++;
+        break;
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBattler][1] - 9);
+        size = 1;
+        break;
+    case 17:
+        data32 = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID);
+        buffer[0] = (data32 & 0x000000FF);
+        buffer[1] = (data32 & 0x0000FF00) >> 8;
+        buffer[2] = (data32 & 0x00FF0000) >> 16;
+        size = 3;
+        break;
+    case 18:
+        data32 = GetMonData(&gPlayerParty[a], MON_DATA_EXP);
+        buffer[0] = (data32 & 0x000000FF);
+        buffer[1] = (data32 & 0x0000FF00) >> 8;
+        buffer[2] = (data32 & 0x00FF0000) >> 16;
+        size = 3;
+        break;
+    case 19:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_EV);
+        size = 1;
+        break;
+    case 20:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_EV);
+        size = 1;
+        break;
+    case 21:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_EV);
+        size = 1;
+        break;
+    case 22:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPEED_EV);
+        size = 1;
+        break;
+    case 23:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV);
+        size = 1;
+        break;
+    case 24:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV);
+        size = 1;
+        break;
+    case 25:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP);
+        size = 1;
+        break;
+    case 26:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKERUS);
+        size = 1;
+        break;
+    case 27:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION);
+        size = 1;
+        break;
+    case 28:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL);
+        size = 1;
+        break;
+    case 29:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_GAME);
+        size = 1;
+        break;
+    case 30:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKEBALL);
+        size = 1;
+        break;
+    case 31:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV);
+        buffer[1] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV);
+        buffer[2] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV);
+        buffer[3] = GetMonData(&gPlayerParty[a], MON_DATA_SPEED_IV);
+        buffer[4] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV);
+        buffer[5] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV);
+        size = 6;
+        break;
+    case 32:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV);
+        size = 1;
+        break;
+    case 33:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV);
+        size = 1;
+        break;
+    case 34:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV);
+        size = 1;
+        break;
+    case 35:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPEED_IV);
+        size = 1;
+        break;
+    case 36:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV);
+        size = 1;
+        break;
+    case 37:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV);
+        size = 1;
+        break;
+    case 38:
+        data32 = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY);
+        buffer[0] = (data32 & 0x000000FF);
+        buffer[1] = (data32 & 0x0000FF00) >> 8;
+        buffer[2] = (data32 & 0x00FF0000) >> 16;
+        buffer[3] = (data32 & 0xFF000000) >> 24;
+        size = 4;
+        break;
+    case 39:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 40:
+        data32 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS);
+        buffer[0] = (data32 & 0x000000FF);
+        buffer[1] = (data32 & 0x0000FF00) >> 8;
+        buffer[2] = (data32 & 0x00FF0000) >> 16;
+        buffer[3] = (data32 & 0xFF000000) >> 24;
+        size = 4;
+        break;
+    case 41:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL);
+        size = 1;
+        break;
+    case 42:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_HP);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 43:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 44:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_ATK);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 45:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_DEF);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 46:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPEED);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 47:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPATK);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 48:
+        data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF);
+        buffer[0] = data16;
+        buffer[1] = data16 >> 8;
+        size = 2;
+        break;
+    case 49:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL);
+        size = 1;
+        break;
+    case 50:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY);
+        size = 1;
+        break;
+    case 51:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE);
+        size = 1;
+        break;
+    case 52:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART);
+        size = 1;
+        break;
+    case 53:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH);
+        size = 1;
+        break;
+    case 54:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SHEEN);
+        size = 1;
+        break;
+    case 55:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON);
+        size = 1;
+        break;
+    case 56:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON);
+        size = 1;
+        break;
+    case 57:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON);
+        size = 1;
+        break;
+    case 58:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON);
+        size = 1;
+        break;
+    case 59:
+        buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON);
+        size = 1;
+        break;
+    }
+    return size;
+}
+
+void WallyHandlecmd1(void)
+{
+    PlayerHandlecmd1();
+}
+
+void WallyHandleSetAttributes(void)
+{
+    u8 r4;
+    u8 i;
+
+    if (gBattleBufferA[gActiveBattler][2] == 0)
+    {
+        sub_8138294(gBattlerPartyIndexes[gActiveBattler]);
+    }
+    else
+    {
+        r4 = gBattleBufferA[gActiveBattler][2];
+        for (i = 0; i < 6; i++)
+        {
+            if (r4 & 1)
+                sub_8138294(i);
+            r4 >>= 1;
+        }
+    }
+    WallyBufferExecCompleted();
+}
+
+void sub_8138294(u8 a)
+{
+    struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBattler][3];
+    struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBattler][3];
+    s32 i;
+
+    switch (gBattleBufferA[gActiveBattler][1])
+    {
+    case 0:
+        {
+            u8 iv;
+
+            SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, &battlePokemon->species);
+            SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, &battlePokemon->item);
+            for (i = 0; i < 4; i++)
+            {
+                SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]);
+                SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, &battlePokemon->pp[i]);
+            }
+            SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses);
+            SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, &battlePokemon->friendship);
+            SetMonData(&gPlayerParty[a], MON_DATA_EXP, &battlePokemon->experience);
+            iv = battlePokemon->hpIV;
+            SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &iv);
+            iv = battlePokemon->attackIV;
+            SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &iv);
+            iv = battlePokemon->defenseIV;
+            SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &iv);
+            iv = battlePokemon->speedIV;
+            SetMonData(&gPlayerParty[a], MON_DATA_SPEED_IV, &iv);
+            iv = battlePokemon->spAttackIV;
+            SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &iv);
+            iv = battlePokemon->spDefenseIV;
+            SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &iv);
+            SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, &battlePokemon->personality);
+            SetMonData(&gPlayerParty[a], MON_DATA_STATUS, &battlePokemon->status1);
+            SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, &battlePokemon->level);
+            SetMonData(&gPlayerParty[a], MON_DATA_HP, &battlePokemon->hp);
+            SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, &battlePokemon->maxHP);
+            SetMonData(&gPlayerParty[a], MON_DATA_ATK, &battlePokemon->attack);
+            SetMonData(&gPlayerParty[a], MON_DATA_DEF, &battlePokemon->defense);
+            SetMonData(&gPlayerParty[a], MON_DATA_SPEED, &battlePokemon->speed);
+            SetMonData(&gPlayerParty[a], MON_DATA_SPATK, &battlePokemon->spAttack);
+            SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, &battlePokemon->spDefense);
+        }
+        break;
+    case 1:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 2:
+        SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 3:
+        for (i = 0; i < 4; i++)
+        {
+            SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, &moveData->moves[i]);
+            SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, &moveData->pp[i]);
+        }
+        SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses);
+        break;
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+        SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBattler][1] - 4, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 8:
+        SetMonData(&gPlayerParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBattler][4]);
+        SetMonData(&gPlayerParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBattler][5]);
+        SetMonData(&gPlayerParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBattler][6]);
+        SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBattler][7]);
+        break;
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+        SetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBattler][1] - 9, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 17:
+        SetMonData(&gPlayerParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 18:
+        SetMonData(&gPlayerParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 19:
+        SetMonData(&gPlayerParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 20:
+        SetMonData(&gPlayerParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 21:
+        SetMonData(&gPlayerParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 22:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 23:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 24:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 25:
+        SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 26:
+        SetMonData(&gPlayerParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 27:
+        SetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 28:
+        SetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 29:
+        SetMonData(&gPlayerParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 30:
+        SetMonData(&gPlayerParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 31:
+        SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBattler][4]);
+        SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBattler][5]);
+        SetMonData(&gPlayerParty[a], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBattler][6]);
+        SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBattler][7]);
+        SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBattler][8]);
+        break;
+    case 32:
+        SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 33:
+        SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 34:
+        SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 35:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 36:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 37:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 38:
+        SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 39:
+        SetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 40:
+        SetMonData(&gPlayerParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 41:
+        SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 42:
+        SetMonData(&gPlayerParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 43:
+        SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 44:
+        SetMonData(&gPlayerParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 45:
+        SetMonData(&gPlayerParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 46:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPEED, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 47:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 48:
+        SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 49:
+        SetMonData(&gPlayerParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 50:
+        SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 51:
+        SetMonData(&gPlayerParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 52:
+        SetMonData(&gPlayerParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 53:
+        SetMonData(&gPlayerParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 54:
+        SetMonData(&gPlayerParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 55:
+        SetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 56:
+        SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 57:
+        SetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 58:
+        SetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    case 59:
+        SetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        break;
+    }
+    HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
+}
+
+void WallyHandlecmd3(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleLoadPokeSprite(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleSendOutPoke(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleReturnPokeToBall(void)
+{
+    if (gBattleBufferA[gActiveBattler][1] == 0)
+    {
+        move_anim_start_t4(gActiveBattler, gActiveBattler, gActiveBattler, 1);
+        gBattleBankFunc[gActiveBattler] = sub_813789C;
+    }
+    else
+    {
+        FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBattler]]);
+        DestroySprite(&gSprites[gBankSpriteIds[gActiveBattler]]);
+        sub_8043DB0(gHealthboxIDs[gActiveBattler]);
+        WallyBufferExecCompleted();
+    }
+}
+
+void WallyHandleTrainerThrow(void)
+{
+    LoadPlayerTrainerBankSprite(2, gActiveBattler);
+    GetMonSpriteTemplate_803C5A0(2, GetBattlerPosition(gActiveBattler));
+    gBankSpriteIds[gActiveBattler] = CreateSprite(
+      &gUnknown_02024E8C,
+      80, 80 + 4 * (8 - gTrainerBackPicCoords[2].coords),
+      30);
+    gSprites[gBankSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler;
+    gSprites[gBankSpriteIds[gActiveBattler]].pos2.x = 240;
+    gSprites[gBankSpriteIds[gActiveBattler]].data[0] = -2;
+    gSprites[gBankSpriteIds[gActiveBattler]].callback = sub_80313A0;
+    gBattleBankFunc[gActiveBattler] = sub_813741C;
+}
+
+void WallyHandleTrainerSlide(void)
+{
+    LoadPlayerTrainerBankSprite(2, gActiveBattler);
+    GetMonSpriteTemplate_803C5A0(2, GetBattlerPosition(gActiveBattler));
+    gBankSpriteIds[gActiveBattler] = CreateSprite(
+      &gUnknown_02024E8C,
+      80, 80 + 4 * (8 - gTrainerBackPicCoords[2].coords),
+      30);
+    gSprites[gBankSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler;
+    gSprites[gBankSpriteIds[gActiveBattler]].pos2.x = -96;
+    gSprites[gBankSpriteIds[gActiveBattler]].data[0] = 2;
+    gSprites[gBankSpriteIds[gActiveBattler]].callback = sub_80313A0;
+    gBattleBankFunc[gActiveBattler] = sub_8137908;
+}
+
+void WallyHandleTrainerSlideBack(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd10(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd11(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd12(void)
+{
+    ewram17840.unk8 = 4;
+    gDoingBattleAnim = TRUE;
+    move_anim_start_t4(gActiveBattler, gActiveBattler, GetBattlerAtPosition(1), 4);
+    gBattleBankFunc[gActiveBattler] = bx_wait_t5;
+}
+
+void WallyHandleBallThrow(void)
+{
+    u8 val = gBattleBufferA[gActiveBattler][1];
+
+    ewram17840.unk8 = val;
+    gDoingBattleAnim = TRUE;
+    move_anim_start_t4(gActiveBattler, gActiveBattler, GetBattlerAtPosition(1), 4);
+    gBattleBankFunc[gActiveBattler] = bx_wait_t5;
+}
+
+void WallyHandlePuase(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleMoveAnimation(void)
+{
+    u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
+
+    gAnimMoveTurn = gBattleBufferA[gActiveBattler][3];
+    gAnimMovePower = gBattleBufferA[gActiveBattler][4] | (gBattleBufferA[gActiveBattler][5] << 8);
+    gAnimMoveDmg = gBattleBufferA[gActiveBattler][6] | (gBattleBufferA[gActiveBattler][7] << 8) | (gBattleBufferA[gActiveBattler][8] << 16) | (gBattleBufferA[gActiveBattler][9] << 24);
+    gAnimFriendship = gBattleBufferA[gActiveBattler][10];
+    gWeatherMoveAnim = gBattleBufferA[gActiveBattler][12] | (gBattleBufferA[gActiveBattler][13] << 8);
+    gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBattler][16];
+    gTransformedPersonalities[gActiveBattler] = gAnimDisableStructPtr->transformedMonPersonality;
+    if (sub_8031720(move, gAnimMoveTurn) != 0)
+    {
+        // Dead code. sub_8031720 always returns 0.
+        WallyBufferExecCompleted();
+    }
+    else
+    {
+        ewram17810[gActiveBattler].unk4 = 0;
+        gBattleBankFunc[gActiveBattler] = sub_81390D0;
+    }
+}
+
+void sub_81390D0(void)
+{
+    u16 r4 = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
+
+#ifndef NONMATCHING
+    asm("":::"r6");
+#endif
+
+    switch (ewram17810[gActiveBattler].unk4)
+    {
+    case 0:
+        if (ewram17800[gActiveBattler].substituteSprite == 1)
+            move_anim_start_t4(gActiveBattler, gActiveBattler, gActiveBattler, 5);
+        ewram17810[gActiveBattler].unk4 = 1;
+        break;
+    case 1:
+        if (ewram17810[gActiveBattler].unk0_6 == 0)
+        {
+            sub_80326EC(0);
+            DoMoveAnim(r4);
+            ewram17810[gActiveBattler].unk4 = 2;
+        }
+        break;
+    case 2:
+        gAnimScriptCallback();
+        if (!gAnimScriptActive)
+        {
+            sub_80326EC(1);
+            if (ewram17800[gActiveBattler].substituteSprite == 1)
+                move_anim_start_t4(gActiveBattler, gActiveBattler, gActiveBattler, 6);
+            ewram17810[gActiveBattler].unk4 = 3;
+        }
+        break;
+    case 3:
+        if (ewram17810[gActiveBattler].unk0_6 == 0)
+        {
+            sub_8031F24();
+            sub_80324BC(gActiveBattler, gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
+            ewram17810[gActiveBattler].unk4 = 0;
+            WallyBufferExecCompleted();
+        }
+        break;
+    }
+}
+
+void WallyHandlePrintString(void)
+{
+    u16 *ptr;
+
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+    ptr = (u16 *)&gBattleBufferA[gActiveBattler][2];
+    if (*ptr == 2)
+        DestroyMenuCursor();
+    BufferStringBattle(*ptr);
+    Text_InitWindow8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 0x90, 2, 15);
+    gBattleBankFunc[gActiveBattler] = sub_8137454;
+}
+
+void WallyHandlePrintStringPlayerOnly(void)
+{
+    if (GetBattlerSide(gActiveBattler) == 0)
+        WallyHandlePrintString();
+    else
+        WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd18(void)
+{
+    s32 i;
+
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 160;
+    gUnknown_03004210.paletteNum = 0;
+    Text_FillWindowRectDefPalette(&gUnknown_03004210, 10, 2, 15, 27, 18);
+    Text_FillWindowRectDefPalette(&gUnknown_03004210, 10, 2, 35, 16, 36);
+    gBattleBankFunc[gActiveBattler] = sub_81372BC;
+    Text_InitWindow(&gUnknown_03004210, BattleText_MenuOptions, 400, 18, 35);
+    Text_PrintWindow8002F44(&gUnknown_03004210);
+    MenuCursor_Create814A5C0(0, 0xFFFF, 12, 0x2D9F, 0);
+    for (i = 0; i < 4; i++)
+        nullsub_8(i);
+    sub_802E3E4(0, 0);
+    StrCpyDecodeToDisplayedStringBattle(BattleText_WallyMenu);
+#ifdef ENGLISH
+    Text_InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 440, 2, 35);
+#else
+    Text_InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 444, 2, 35);
+#endif
+    Text_PrintWindow8002F44(&gUnknown_03004210);
+}
+
+void WallyHandlecmd19(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd20(void)
+{
+    switch (ewram160A9)
+    {
+    case 0:
+        sub_80304A8();
+        ewram160A9++;
+        ewram160AB = 80;
+        // fall through
+    case 1:
+        ewram160AB--;
+        if (ewram160AB == 0)
+        {
+            DestroyMenuCursor();
+            PlaySE(SE_SELECT);
+            Emitcmd33(1, 10, 256);
+            WallyBufferExecCompleted();
+        }
+        break;
+    }
+}
+
+void WallyHandleOpenBag(void)
+{
+    BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB(0, 0, 0));
+    gBattleBankFunc[gActiveBattler] = sub_81374C4;
+    gBankInMenu = gActiveBattler;
+}
+
+void WallyHandlecmd22(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd23(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleHealthBarUpdate(void)
+{
+    s16 r7;
+
+    load_gfxc_health_bar(0);
+    r7 = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
+    if (r7 != 0x7FFF)
+    {
+        u32 maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MAX_HP);
+        u32 curHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_HP);
+
+        sub_8043D84(gActiveBattler, gHealthboxIDs[gActiveBattler], maxHP, curHP, r7);
+    }
+    else
+    {
+        u32 maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MAX_HP);
+
+        sub_8043D84(gActiveBattler, gHealthboxIDs[gActiveBattler], maxHP, 0, r7);
+        sub_80440EC(gHealthboxIDs[gActiveBattler], 0, 0);
+    }
+    gBattleBankFunc[gActiveBattler] = sub_81377B0;
+}
+
+void WallyHandleExpBarUpdate(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleStatusIconUpdate(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleStatusAnimation(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleStatusXor(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd29(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleDMATransfer(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd31(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd32(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd33(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd34(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd35(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd36(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd37(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd38(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd39(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd40(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleHitAnimation(void)
+{
+    if (gSprites[gBankSpriteIds[gActiveBattler]].invisible == TRUE)
+    {
+        WallyBufferExecCompleted();
+    }
+    else
+    {
+        gDoingBattleAnim = 1;
+        gSprites[gBankSpriteIds[gActiveBattler]].data[1] = 0;
+        sub_8047858(gActiveBattler);
+        gBattleBankFunc[gActiveBattler] = bx_blink_t5;
+    }
+}
+
+void WallyHandlecmd42(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleEffectivenessSound(void)
+{
+    PlaySE(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd44(void)
+{
+    PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleFaintingCry(void)
+{
+    PlayCry1(GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES), 25);
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleIntroSlide(void)
+{
+    StartBattleIntroAnim(gBattleBufferA[gActiveBattler][1]);
+    gUnknown_02024DE8 |= 1;
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleTrainerBallThrow(void)
+{
+    u8 paletteNum;
+    u8 taskId;
+
+    oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBattler]]);
+    gSprites[gBankSpriteIds[gActiveBattler]].data[0] = 50;
+    gSprites[gBankSpriteIds[gActiveBattler]].data[2] = -40;
+    gSprites[gBankSpriteIds[gActiveBattler]].data[4] = gSprites[gBankSpriteIds[gActiveBattler]].pos1.y;
+    gSprites[gBankSpriteIds[gActiveBattler]].callback = StartAnimLinearTranslation;
+    gSprites[gBankSpriteIds[gActiveBattler]].data[5] = gActiveBattler;
+    StoreSpriteCallbackInData(&gSprites[gBankSpriteIds[gActiveBattler]], sub_8030E38);
+    StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBattler]], 1);
+    paletteNum = AllocSpritePalette(0xD6F8);
+    LoadCompressedPalette(gTrainerBackPicPaletteTable[2].data, 0x100 + paletteNum * 16, 32);
+    gSprites[gBankSpriteIds[gActiveBattler]].oam.paletteNum = paletteNum;
+    taskId = CreateTask(sub_8139A2C, 5);
+    gTasks[taskId].data[0] = gActiveBattler;
+    if (ewram17810[gActiveBattler].unk0_0)
+        gTasks[gUnknown_02024E68[gActiveBattler]].func = sub_8044CA0;
+    ewram17810[4].unk9 |= 1;
+    gBattleBankFunc[gActiveBattler] = nullsub_91;
+}
+
+void sub_81398BC(u8 bank)
+{
+    u16 species;
+
+    ewram17800[bank].transformedSpecies = 0;
+    gBattlerPartyIndexes[bank] = gBattleBufferA[bank][1];
+    species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[bank]], MON_DATA_SPECIES);
+    gUnknown_0300434C[bank] = CreateInvisibleSpriteWithCallback(sub_80312F0);
+    GetMonSpriteTemplate_803C56C(species, GetBattlerPosition(bank));
+    gBankSpriteIds[bank] = CreateSprite(
+      &gUnknown_02024E8C,
+      GetBattlerSpriteCoord(bank, 2),
+      sub_8077F68(bank),
+      GetBattlerSubpriority(bank));
+    gSprites[gUnknown_0300434C[bank]].data[1] = gBankSpriteIds[bank];
+    gSprites[gBankSpriteIds[bank]].data[0] = bank;
+    gSprites[gBankSpriteIds[bank]].data[2] = species;
+    gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank;
+    StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]);
+    gSprites[gBankSpriteIds[bank]].invisible = TRUE;
+    gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy;
+    gSprites[gUnknown_0300434C[bank]].data[0] = StartSendOutMonAnimation(0, 0xFF);
+}
+
+void sub_8139A2C(u8 taskId)
+{
+    if (gTasks[taskId].data[1] < 31)
+    {
+        gTasks[taskId].data[1]++;
+    }
+    else
+    {
+        u8 savedActiveBank = gActiveBattler;
+
+        gActiveBattler = gTasks[taskId].data[0];
+        gBattleBufferA[gActiveBattler][1] = gBattlerPartyIndexes[gActiveBattler];
+        sub_81398BC(gActiveBattler);
+        gBattleBankFunc[gActiveBattler] = sub_8137538;
+        gActiveBattler = savedActiveBank;
+        DestroyTask(taskId);
+    }
+}
+
+void WallyHandlecmd48(void)
+{
+    if (gBattleBufferA[gActiveBattler][1] != 0 && GetBattlerSide(gActiveBattler) == 0)
+    {
+        WallyBufferExecCompleted();
+    }
+    else
+    {
+        ewram17810[gActiveBattler].unk0_0 = 1;
+        gUnknown_02024E68[gActiveBattler] = sub_8044804(gActiveBattler, (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBattler][4], gBattleBufferA[gActiveBattler][1], gBattleBufferA[gActiveBattler][2]);
+        WallyBufferExecCompleted();
+    }
+}
+
+void WallyHandlecmd49(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd50(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleSpriteInvisibility(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleBattleAnimation(void)
+{
+    u8 val2 = gBattleBufferA[gActiveBattler][1];
+    u16 val = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
+
+    if (move_anim_start_t3(gActiveBattler, gActiveBattler, gActiveBattler, val2, val))
+        WallyBufferExecCompleted();
+    else
+        gBattleBankFunc[gActiveBattler] = sub_8137940;
+}
+
+void WallyHandleLinkStandbyMsg(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandleResetActionMoveSelection(void)
+{
+    WallyBufferExecCompleted();
+}
+
+void WallyHandlecmd55(void)
+{
+    gBattleOutcome = gBattleBufferA[gActiveBattler][1];
+    FadeOutMapMusic(5);
+    BeginFastPaletteFade(3);
+    WallyBufferExecCompleted();
+    if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_WILD))
+        gBattleBankFunc[gActiveBattler] = sub_813746C;
+}
+
+void WallyHandlecmd56(void)
+{
+}