port all to c

1 files changed, 1579 insertions, 20 deletions

diff --git a/src/battle_anim.c b/src/battle_anim.c
index 64f01beb1..a92cf98de 100644
--- a/src/battle_anim.c
+++ b/src/battle_anim.c
@@ -3,6 +3,20 @@
 #include "battle_anim.h"
 #include "battle_controllers.h"
 #include "battle_interface.h"
+#include "bg.h"
+#include "contest.h"
+#include "decompress.h"
+#include "dma3.h"
+#include "gpu_regs.h"
+#include "graphics.h"
+#include "main.h"
+#include "m4a.h"
+#include "palette.h"
+#include "pokemon.h"
+#include "sound.h"
+#include "sprite.h"
+#include "task.h"
+#include "constants/battle_anim.h"
 
 // Defines
 #define ANIM_SPRITE_INDEX_COUNT 8
@@ -32,11 +46,114 @@ EWRAM_DATA u8 gBattleAnimTarget = 0;
 EWRAM_DATA u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT] = {0};
 EWRAM_DATA u8 gUnknown_2037F24 = 0;
 
-// Data
-
 // Function Declarations
+static void AddSpriteIndex(u16 index);
+static void ClearSpriteIndex(u16 index);
+static void WaitAnimFrameCount(void);
+static void RunAnimScriptCommand(void);
+static void ScriptCmd_loadspritegfx(void);
+static void ScriptCmd_unloadspritegfx(void);
+static void ScriptCmd_createsprite(void);
+static void ScriptCmd_createvisualtask(void);
+static void ScriptCmd_delay(void);
+static void ScriptCmd_waitforvisualfinish(void);
+static void ScriptCmd_hang1(void);
+static void ScriptCmd_hang2(void);
+static void ScriptCmd_end(void);
+static void ScriptCmd_playse(void);
+static void ScriptCmd_monbg(void);
+static void ScriptCmd_clearmonbg(void);
+static void ScriptCmd_setalpha(void);
+static void ScriptCmd_blendoff(void);
+static void ScriptCmd_call(void);
+static void ScriptCmd_return(void);
+static void ScriptCmd_setarg(void);
+static void ScriptCmd_choosetwoturnanim(void);
+static void ScriptCmd_jumpifmoveturn(void);
+static void ScriptCmd_goto(void);
+static void ScriptCmd_fadetobg(void);
+static void ScriptCmd_restorebg(void);
+static void ScriptCmd_waitbgfadeout(void);
+static void ScriptCmd_waitbgfadein(void);
+static void ScriptCmd_changebg(void);
+static void ScriptCmd_playsewithpan(void);
+static void ScriptCmd_setpan(void);
+static void ScriptCmd_panse_1B(void);
+static void ScriptCmd_loopsewithpan(void);
+static void ScriptCmd_waitplaysewithpan(void);
+static void ScriptCmd_setbldcnt(void);
+static void ScriptCmd_createsoundtask(void);
+static void ScriptCmd_waitsound(void);
+static void ScriptCmd_jumpargeq(void);
+static void ScriptCmd_monbg_22(void);
+static void ScriptCmd_clearmonbg_23(void);
+static void ScriptCmd_jumpifcontest(void);
+static void ScriptCmd_fadetobgfromset(void);
+static void ScriptCmd_panse_26(void);
+static void ScriptCmd_panse_27(void);
+static void ScriptCmd_monbgprio_28(void);
+static void ScriptCmd_monbgprio_29(void);
+static void ScriptCmd_monbgprio_2A(void);
+static void ScriptCmd_invisible(void);
+static void ScriptCmd_visible(void);
+static void ScriptCmd_doublebattle_2D(void);
+static void ScriptCmd_doublebattle_2E(void);
+static void ScriptCmd_stopsound(void);
 
+// Data
+static void (* const sScriptCmdTable[])(void) =	//83ADF5C
+{
+    ScriptCmd_loadspritegfx,
+    ScriptCmd_unloadspritegfx,
+    ScriptCmd_createsprite,
+    ScriptCmd_createvisualtask,
+    ScriptCmd_delay,
+    ScriptCmd_waitforvisualfinish,
+    ScriptCmd_hang1,
+    ScriptCmd_hang2,
+    ScriptCmd_end,
+    ScriptCmd_playse,
+    ScriptCmd_monbg,
+    ScriptCmd_clearmonbg,
+    ScriptCmd_setalpha,
+    ScriptCmd_blendoff,
+    ScriptCmd_call,
+    ScriptCmd_return,
+    ScriptCmd_setarg,
+    ScriptCmd_choosetwoturnanim,
+    ScriptCmd_jumpifmoveturn,
+    ScriptCmd_goto,
+    ScriptCmd_fadetobg,
+    ScriptCmd_restorebg,
+    ScriptCmd_waitbgfadeout,
+    ScriptCmd_waitbgfadein,
+    ScriptCmd_changebg,
+    ScriptCmd_playsewithpan,
+    ScriptCmd_setpan,
+    ScriptCmd_panse_1B,
+    ScriptCmd_loopsewithpan,
+    ScriptCmd_waitplaysewithpan,
+    ScriptCmd_setbldcnt,
+    ScriptCmd_createsoundtask,
+    ScriptCmd_waitsound,
+    ScriptCmd_jumpargeq,
+    ScriptCmd_monbg_22,
+    ScriptCmd_clearmonbg_23,
+    ScriptCmd_jumpifcontest,
+    ScriptCmd_fadetobgfromset,
+    ScriptCmd_panse_26,
+    ScriptCmd_panse_27,
+    ScriptCmd_monbgprio_28,
+    ScriptCmd_monbgprio_29,
+    ScriptCmd_monbgprio_2A,
+    ScriptCmd_invisible,
+    ScriptCmd_visible,
+    ScriptCmd_doublebattle_2D,
+    ScriptCmd_doublebattle_2E,
+    ScriptCmd_stopsound
+};
 
+// Functions
 void ClearBattleAnimationVars(void)
 {
     s32 i;
@@ -79,23 +196,15 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo
 {
     s32 i;
 
-    if (!IsContest())
-    {
-        sub_80A8278();
-        UpdateOamPriorityInAllHealthboxes(0);
-        for (i = 0; i < MAX_BATTLERS_COUNT; i++)
-        {
-            if (GetBattlerSide(i) != B_SIDE_PLAYER)
-                gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
-            else
-                gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
-        }
-    }
-    else
-    {
-        for (i = 0; i < 4; i++)
-            gAnimBattlerSpecies[i] = gContestResources->field_18->species;
-    }
+	sub_80767F0();
+	UpdateOamPriorityInAllHealthboxes(0);
+	for (i = 0; i < MAX_BATTLERS_COUNT; i++)
+	{
+		if (GetBattlerSide(i) != B_SIDE_PLAYER)
+			gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
+		else
+			gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
+	}
 
     if (!isMoveAnim)
         sAnimMoveIndex = 0;
@@ -106,7 +215,7 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo
         gBattleAnimArgs[i] = 0;
 
     sMonAnimTaskIdArray[0] = 0xFF;
-    sMonAnimTaskIdArray[1] = 0xFF;
+    sMonAnimTaskIdArray[1] = (s8)-1;
     sBattleAnimScriptPtr = animsTable[tableId];
     gAnimScriptActive = TRUE;
     gAnimFramesToWait = 0;
@@ -133,4 +242,1454 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo
     gBattle_WIN1V = 0;
 }
 
+void DestroyAnimSprite(struct Sprite *sprite)
+{
+    FreeSpriteOamMatrix(sprite);
+    DestroySprite(sprite);
+    gAnimVisualTaskCount--;
+}
+
+void DestroyAnimVisualTask(u8 taskId)
+{
+    DestroyTask(taskId);
+    gAnimVisualTaskCount--;
+}
+
+void DestroyAnimSoundTask(u8 taskId)
+{
+    DestroyTask(taskId);
+    gAnimSoundTaskCount--;
+}
+
+static void AddSpriteIndex(u16 index)
+{
+    s32 i;
+
+    for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++)
+    {
+        if (sAnimSpriteIndexArray[i] == 0xFFFF)
+        {
+            sAnimSpriteIndexArray[i] = index;
+            return;
+        }
+    }
+}
+
+static void ClearSpriteIndex(u16 index)
+{
+    s32 i;
+
+    for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++)
+    {
+        if (sAnimSpriteIndexArray[i] == index)
+        {
+            sAnimSpriteIndexArray[i] = 0xFFFF;
+            return;
+        }
+    }
+}
+
+static void WaitAnimFrameCount(void)
+{
+    if (gAnimFramesToWait <= 0)
+    {
+        gAnimScriptCallback = RunAnimScriptCommand;
+        gAnimFramesToWait = 0;
+    }
+    else
+    {
+        gAnimFramesToWait--;
+    }
+}
+
+static void RunAnimScriptCommand(void)
+{
+    do
+    {
+        sScriptCmdTable[sBattleAnimScriptPtr[0]]();
+    } while (gAnimFramesToWait == 0 && gAnimScriptActive);
+}
+
+static void ScriptCmd_loadspritegfx(void)
+{
+    u16 index;
+
+    sBattleAnimScriptPtr++;
+    index = T1_READ_16(sBattleAnimScriptPtr);
+    LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)]);
+    LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(index)]);
+    sBattleAnimScriptPtr += 2;
+    AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index));
+    gAnimFramesToWait = 1;
+    gAnimScriptCallback = WaitAnimFrameCount;
+}
+
+static void ScriptCmd_unloadspritegfx(void)
+{
+    u16 index;
+
+    sBattleAnimScriptPtr++;
+    index = T1_READ_16(sBattleAnimScriptPtr);
+    FreeSpriteTilesByTag(gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)].tag);
+    FreeSpritePaletteByTag(gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)].tag);
+    sBattleAnimScriptPtr += 2;
+    ClearSpriteIndex(GET_TRUE_SPRITE_INDEX(index));
+}
+
+static void ScriptCmd_createsprite(void)
+{
+    s32 i;
+    const struct SpriteTemplate *template;
+    u8 argVar;
+    u8 argsCount;
+    s16 subpriority;
+
+    sBattleAnimScriptPtr++;
+    template = (const struct SpriteTemplate *)(T2_READ_32(sBattleAnimScriptPtr));
+    sBattleAnimScriptPtr += 4;
+
+    argVar = sBattleAnimScriptPtr[0];
+    sBattleAnimScriptPtr++;
+
+    argsCount = sBattleAnimScriptPtr[0];
+    sBattleAnimScriptPtr++;
+    for (i = 0; i < argsCount; i++)
+    {
+        gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr);
+        sBattleAnimScriptPtr += 2;
+    }
+
+    if (argVar & 0x80)
+    {
+        argVar ^= 0x80;
+        if (argVar >= 0x40)
+            argVar -= 0x40;
+        else
+            argVar *= -1;
+
+        subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + (s8)(argVar);
+    }
+    else
+    {
+        if (argVar >= 0x40)
+            argVar -= 0x40;
+        else
+            argVar *= -1;
+
+        subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) + (s8)(argVar);
+    }
+
+    if (subpriority < 3)
+        subpriority = 3;
+
+    CreateSpriteAndAnimate(
+        template,
+        GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2),
+        GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET),
+        subpriority);
+    gAnimVisualTaskCount++;
+}
+
+static void ScriptCmd_createvisualtask(void)
+{
+    TaskFunc taskFunc;
+    u8 taskPriority;
+    u8 taskId;
+    u8 numArgs;
+    s32 i;
+
+    sBattleAnimScriptPtr++;
+
+    taskFunc = (TaskFunc)T2_READ_32(sBattleAnimScriptPtr);
+    sBattleAnimScriptPtr += 4;
+
+    taskPriority = sBattleAnimScriptPtr[0];
+    sBattleAnimScriptPtr++;
+
+    numArgs = sBattleAnimScriptPtr[0];
+    sBattleAnimScriptPtr++;
+
+    for (i = 0; i < numArgs; i++)
+    {
+        gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr);
+        sBattleAnimScriptPtr += 2;
+    }
+
+    taskId = CreateTask(taskFunc, taskPriority);
+    taskFunc(taskId);
+    gAnimVisualTaskCount++;
+}
+
+static void ScriptCmd_delay(void)
+{
+    sBattleAnimScriptPtr++;
+    gAnimFramesToWait = sBattleAnimScriptPtr[0];
+    if (gAnimFramesToWait == 0)
+        gAnimFramesToWait = -1;
+    sBattleAnimScriptPtr++;
+    gAnimScriptCallback = WaitAnimFrameCount;
+}
+
+// Wait for visual tasks to finish.
+static void ScriptCmd_waitforvisualfinish(void)
+{
+    if (gAnimVisualTaskCount == 0)
+    {
+        sBattleAnimScriptPtr++;
+        gAnimFramesToWait = 0;
+    }
+    else
+    {
+        gAnimFramesToWait = 1;
+    }
+}
+
+static void ScriptCmd_end(void)
+{
+    s32 i;
+    bool32 continuousAnim = FALSE;
+
+    // Keep waiting as long as there are animations to be done.
+    if (gAnimVisualTaskCount != 0 || gAnimSoundTaskCount != 0
+     || sMonAnimTaskIdArray[0] != 0xFF || sMonAnimTaskIdArray[1] != 0xFF)
+    {
+        sSoundAnimFramesToWait = 0;
+        gAnimFramesToWait = 1;
+        return;
+    }
+
+    // Finish the sound effects.
+    if (IsSEPlaying())
+    {
+        if (++sSoundAnimFramesToWait <= 90) // Wait 90 frames, then halt the sound effect.
+        {
+            gAnimFramesToWait = 1;
+            return;
+        }
+        else
+        {
+            m4aMPlayStop(&gMPlayInfo_SE1);
+            m4aMPlayStop(&gMPlayInfo_SE2);
+        }
+    }
+
+    // The SE has halted, so set the SE Frame Counter to 0 and continue.
+    sSoundAnimFramesToWait = 0;
+
+    for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++)
+    {
+        if (sAnimSpriteIndexArray[i] != 0xFFFF)
+        {
+            FreeSpriteTilesByTag(gBattleAnimPicTable[sAnimSpriteIndexArray[i]].tag);
+            FreeSpritePaletteByTag(gBattleAnimPicTable[sAnimSpriteIndexArray[i]].tag);
+            sAnimSpriteIndexArray[i] = 0xFFFF; // set terminator.
+        }
+    }
+
+    if (!continuousAnim) // May have been used for debug?
+    {
+        m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256);
+        if (!IsContest())
+        {
+            sub_80A8278();
+            UpdateOamPriorityInAllHealthboxes(1);
+        }
+        gAnimScriptActive = FALSE;
+    }
+}
+
+static void ScriptCmd_playse(void)
+{
+    sBattleAnimScriptPtr++;
+    PlaySE(T1_READ_16(sBattleAnimScriptPtr));
+    sBattleAnimScriptPtr += 2;
+}
+
+#define t1_MONBG_BATTLER        0
+#define t1_MON_IN_BG2           1
+#define t1_CREATE_ANOTHER_TASK  2
+#define t1_IS_SECONDMON_BG      3
+
+#define t2_BATTLER_SPRITE_ID    0
+#define t2_MON_IN_BG2           5
+#define t2_MONBG_BATTLER        6
+
+static void ScriptCmd_monbg(void)
+{
+    bool8 toBG_2;
+    u8 taskId;
+    u8 battlerId;
+    u8 animBattler;
+
+    sBattleAnimScriptPtr++;
+
+    animBattler = sBattleAnimScriptPtr[0];
+    if (animBattler & ANIM_TARGET)
+        battlerId = gBattleAnimTarget;
+    else
+        battlerId = gBattleAnimAttacker;
+
+    if (IsBattlerSpriteVisible(battlerId))
+    {
+        u8 position = GetBattlerPosition(battlerId);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
+            toBG_2 = FALSE;
+        else
+            toBG_2 = TRUE;
+
+        MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE);
+        taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10);
+        gAnimVisualTaskCount++;
+        gTasks[taskId].data[t1_MONBG_BATTLER] = battlerId;
+        gTasks[taskId].data[t1_MON_IN_BG2] = toBG_2;
+        gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE;
+        gTasks[taskId].data[t1_IS_SECONDMON_BG] = 0;
+
+    }
+
+    battlerId ^= BIT_FLANK;
+    if (IsBattlerSpriteVisible(battlerId))
+    {
+        u8 position = GetBattlerPosition(battlerId);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
+            toBG_2 = FALSE;
+        else
+            toBG_2 = TRUE;
+
+        MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE);
+        taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10);
+        gAnimVisualTaskCount++;
+        gTasks[taskId].data[0] = battlerId;
+        gTasks[taskId].data[1] = toBG_2;
+        gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE;
+        gTasks[taskId].data[t1_IS_SECONDMON_BG] = 1;
+    }
+
+    sBattleAnimScriptPtr++;
+    gAnimFramesToWait = 1;
+    gAnimScriptCallback = WaitAnimFrameCount;
+}
+
+bool8 IsBattlerSpriteVisible(u8 battlerId)
+{
+    if (!IsBattlerSpritePresent(battlerId))
+        return FALSE;
+
+    if (!gBattleSpritesDataPtr->battlerData[battlerId].invisible || !gSprites[gBattlerSpriteIds[battlerId]].invisible)
+        return TRUE;
+
+    return FALSE;
+}
+
+void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2)
+{
+    struct BattleAnimBgData animBg;
+    u8 battlerSpriteId;
+
+    if (!toBG_2)
+    {
+        u8 battlerPosition;
+
+		RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(16)), 0x2000, 1);
+		RequestDma3Fill(0xFF, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 0);
+        sub_80752A0(&animBg);
+        CpuFill16(0, animBg.bgTiles, 0x1000);
+        CpuFill16(0xFF, animBg.bgTilemap, 0x800);
+
+        SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 2);
+        SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 1);
+        SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0);
+
+        battlerSpriteId = gBattlerSpriteIds[battlerId];
+
+        SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X);
+        SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y);
+
+        LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], animBg.paletteId * 16, 0x20);
+        CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + animBg.paletteId * 32), 0x20);
+
+		battlerPosition = GetBattlerPosition(battlerId);
+
+        sub_80BCEF4(1, 0, 0, battlerPosition, animBg.paletteId, animBg.bgTiles, animBg.bgTilemap, animBg.tilesOffset);
+    }
+    else
+    {
+        RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(12)), 0x2000, 1);
+        RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 1);
+        sub_80752C8(&animBg, 2);
+        CpuFill16(0, animBg.bgTiles + 0x1000, 0x1000);
+        CpuFill16(0, animBg.bgTilemap + 0x400, 0x800);
+        SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
+        SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1);
+        SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0);
+
+        battlerSpriteId = gBattlerSpriteIds[battlerId];
+
+        gBattle_BG2_X =  -(gSprites[battlerSpriteId].pos1.x + gSprites[battlerSpriteId].pos2.x) + 0x20;
+        gBattle_BG2_Y =  -(gSprites[battlerSpriteId].pos1.y + gSprites[battlerSpriteId].pos2.y) + 0x20;
+
+        SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X);
+        SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y);
+
+        LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], 0x90, 0x20);
+        CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + 0x120), 0x20);
+
+        sub_80BCEF4(2, 0, 0, GetBattlerPosition(battlerId), animBg.paletteId, animBg.bgTiles + 0x1000, animBg.bgTilemap + 0x400, animBg.tilesOffset);
+    }
+}
+
+void sub_80730C0(u16 a, u16 *b, u32 c, u8 d)
+{
+    s32 i, j;
+    s32 var;
+
+    if (d == 0)
+        var = 32;
+    else
+        var = 64;
+    a <<= 12;
+    for (i = 0; i < var; i++)
+    {
+        for (j = 0; j < 32; j++)
+            b[j + i * 32] = ((b[j + i * 32] & 0xFFF) | a) + c;
+    }
+}
+
+void sub_8073128(bool8 to_BG2)
+{
+    struct BattleAnimBgData animBg;
+    sub_80752A0(&animBg);
+
+    if (!to_BG2))
+    {
+        sub_8075358(1);
+        gBattle_BG1_X = NULL;
+        gBattle_BG1_Y = NULL;
+    }
+    else
+    {
+        sub_8075358(2);
+        gBattle_BG2_X = NULL;
+        gBattle_BG2_Y = NULL;
+    }
+}
+
+static void task_pA_ma0A_obj_to_bg_pal(u8 taskId)
+{
+    u8 spriteId, palIndex;
+    s16 x, y;
+    struct BattleAnimBgData animBg;
+
+    spriteId = gTasks[taskId].data[0];
+    palIndex = gTasks[taskId].data[6];
+    sub_80752A0(&animBg);
+    x = gTasks[taskId].data[1] - (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x);
+    y = gTasks[taskId].data[2] - (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y);
+
+    if (gTasks[taskId].data[5] == 0)
+    {
+        u16 *src;
+        u16 *dst;
+
+        gBattle_BG1_X = x + gTasks[taskId].data[3];
+        gBattle_BG1_Y = y + gTasks[taskId].data[4];
+        src = gPlttBufferFaded + 0x100 + palIndex * 16;
+        dst = gPlttBufferFaded + 0x100 + animBg.paletteId * 16 - 256;
+        CpuCopy32(src, dst, 0x20);
+    }
+    else
+    {
+        u16 *src;
+        u16 *dst;
+
+        gBattle_BG2_X = x + gTasks[taskId].data[3];
+        gBattle_BG2_Y = y + gTasks[taskId].data[4];
+        src = gPlttBufferFaded + 0x100 + palIndex * 16;
+        dst = gPlttBufferFaded + 0x100 - 112;
+        CpuCopy32(src, dst, 0x20);
+    }
+}
+
+static void ScriptCmd_clearmonbg(void)
+{
+    u8 animBattlerId;
+    u8 battlerId;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    animBattlerId = sBattleAnimScriptPtr[0];
+
+    if (animBattlerId == ANIM_ATTACKER)
+        animBattlerId = ANIM_ATK_PARTNER;
+    else if (animBattlerId == ANIM_TARGET)
+        animBattlerId = ANIM_DEF_PARTNER;
+
+    if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER)
+        battlerId = gBattleAnimAttacker;
+    else
+        battlerId = gBattleAnimTarget;
+
+    if (sMonAnimTaskIdArray[0] != 0xFF)
+        gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE;
+    if (animBattlerId > 1 && sMonAnimTaskIdArray[1] != 0xFF)
+        gSprites[gBattlerSpriteIds[battlerId ^ BIT_FLANK]].invisible = FALSE;
+    else
+        animBattlerId = 0;
+
+    taskId = CreateTask(sub_807331C, 5);
+    gTasks[taskId].data[0] = animBattlerId;
+    gTasks[taskId].data[2] = battlerId;
+
+    sBattleAnimScriptPtr++;
+}
+
+static void sub_807331C(u8 taskId)
+{
+    gTasks[taskId].data[1]++;
+    if (gTasks[taskId].data[1] != 1)
+    {
+        u8 to_BG2;
+        u8 position = GetBattlerPosition(gTasks[taskId].data[2]);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
+            to_BG2 = FALSE;
+        else
+            to_BG2 = TRUE;
+
+        if (sMonAnimTaskIdArray[0] != 0xFF)
+        {
+            sub_8073128(to_BG2);
+            DestroyTask(sMonAnimTaskIdArray[0]);
+            sMonAnimTaskIdArray[0] = 0xFF;
+        }
+        if (gTasks[taskId].data[0] > 1)
+        {
+            sub_8073128(to_BG2 ^ 1);
+            DestroyTask(sMonAnimTaskIdArray[1]);
+            sMonAnimTaskIdArray[1] = 0xFF;
+        }
+        DestroyTask(taskId);
+    }
+}
+
+static void ScriptCmd_monbg_22(void)
+{
+    bool8 toBG_2;
+    u8 battlerId;
+    u8 animBattlerId;
+
+    sBattleAnimScriptPtr++;
+
+    animBattlerId = sBattleAnimScriptPtr[0];
+
+    if (animBattlerId == ANIM_ATTACKER)
+        animBattlerId = ANIM_ATK_PARTNER;
+    else if (animBattlerId == ANIM_TARGET)
+        animBattlerId = ANIM_DEF_PARTNER;
+
+    if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER)
+        battlerId = gBattleAnimAttacker;
+    else
+        battlerId = gBattleAnimTarget;
+
+    if (IsBattlerSpriteVisible(battlerId))
+    {
+        u8 position = GetBattlerPosition(battlerId);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
+            toBG_2 = FALSE;
+        else
+            toBG_2 = TRUE;
+
+        MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE);
+    }
+
+    battlerId ^= BIT_FLANK;
+    if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId))
+    {
+        u8 position = GetBattlerPosition(battlerId);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
+            toBG_2 = FALSE;
+        else
+            toBG_2 = TRUE;
+
+        MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE);
+    }
+
+    sBattleAnimScriptPtr++;
+}
+
+static void ScriptCmd_clearmonbg_23(void)
+{
+    u8 animBattlerId;
+    u8 battlerId;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    animBattlerId = sBattleAnimScriptPtr[0];
 
+    if (animBattlerId == ANIM_ATTACKER)
+        animBattlerId = ANIM_ATK_PARTNER;
+    else if (animBattlerId == ANIM_TARGET)
+        animBattlerId = ANIM_DEF_PARTNER;
+
+    if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER)
+        battlerId = gBattleAnimAttacker;
+    else
+        battlerId = gBattleAnimTarget;
+
+    if (IsBattlerSpriteVisible(battlerId))
+        gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE;
+    if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK))
+        gSprites[gBattlerSpriteIds[battlerId ^ BIT_FLANK]].invisible = FALSE;
+    else
+        animBattlerId = 0;
+
+    taskId = CreateTask(sub_8073558, 5);
+    gTasks[taskId].data[0] = animBattlerId;
+    gTasks[taskId].data[2] = battlerId;
+
+    sBattleAnimScriptPtr++;
+}
+
+static void sub_8073558(u8 taskId)
+{
+    gTasks[taskId].data[1]++;
+    if (gTasks[taskId].data[1] != 1)
+    {
+        bool8 toBG_2;
+        u8 battlerId = gTasks[taskId].data[2];
+        u8 position = GetBattlerPosition(battlerId);
+        if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
+            toBG_2 = FALSE;
+        else
+            toBG_2 = TRUE;
+
+        if (IsBattlerSpriteVisible(battlerId))
+            sub_8073128(toBG_2);
+        if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK))
+            sub_8073128(toBG_2 ^ 1);
+
+        DestroyTask(taskId);
+    }
+}
+
+#undef t1_MONBG_BATTLER
+#undef t1_MON_IN_BG2
+#undef t1_CREATE_ANOTHER_TASK
+#undef t1_IS_SECONDMON_BG
+
+#undef t2_BATTLER_SPRITE_ID
+#undef t2_MON_IN_BG2
+#undef t2_MONBG_BATTLER
+
+static void ScriptCmd_setalpha(void)
+{
+    u16 half1, half2;
+
+    sBattleAnimScriptPtr++;
+    half1 = *(sBattleAnimScriptPtr++);
+    half2 = *(sBattleAnimScriptPtr++) << 8;
+    SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL);
+    SetGpuReg(REG_OFFSET_BLDALPHA, half1 | half2);
+}
+
+static void ScriptCmd_setbldcnt(void)
+{
+    u16 half1, half2;
+
+    sBattleAnimScriptPtr++;
+    half1 = *(sBattleAnimScriptPtr++);
+    half2 = *(sBattleAnimScriptPtr++) << 8;
+    SetGpuReg(REG_OFFSET_BLDCNT, half1 | half2);
+}
+
+static void ScriptCmd_blendoff(void)
+{
+    sBattleAnimScriptPtr++;
+    SetGpuReg(REG_OFFSET_BLDCNT, 0);
+    SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+}
+
+static void ScriptCmd_call(void)
+{
+    sBattleAnimScriptPtr++;
+    sBattleAnimScriptRetAddr = sBattleAnimScriptPtr + 4;
+    sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr);
+}
+
+static void ScriptCmd_return(void)
+{
+    sBattleAnimScriptPtr = sBattleAnimScriptRetAddr;
+}
+
+static void ScriptCmd_setarg(void)
+{
+    const u8 *addr = sBattleAnimScriptPtr;
+    u16 value;
+    u8 argId;
+
+    sBattleAnimScriptPtr++;
+    argId = sBattleAnimScriptPtr[0];
+    sBattleAnimScriptPtr++;
+    value = T1_READ_16(sBattleAnimScriptPtr);
+    sBattleAnimScriptPtr = addr + 4;
+    gBattleAnimArgs[argId] = value;
+}
+
+static void ScriptCmd_choosetwoturnanim(void)
+{
+    sBattleAnimScriptPtr++;
+    if (gAnimMoveTurn & 1)
+        sBattleAnimScriptPtr += 4;
+    sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr);
+}
+
+static void ScriptCmd_jumpifmoveturn(void)
+{
+    u8 toCheck;
+    sBattleAnimScriptPtr++;
+    toCheck = sBattleAnimScriptPtr[0];
+    sBattleAnimScriptPtr++;
+
+    if (toCheck == gAnimMoveTurn)
+        sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr);
+    else
+        sBattleAnimScriptPtr += 4;
+}
+
+static void ScriptCmd_goto(void)
+{
+    sBattleAnimScriptPtr++;
+    sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr);
+}
+
+//unused
+bool8 IsContest(void)
+{
+    if (!gMain.inBattle)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+#define tBackgroundId   data[0]
+#define tState          data[10]
+
+static void ScriptCmd_fadetobg(void)
+{
+    u8 backgroundId;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    backgroundId = sBattleAnimScriptPtr[0];
+    sBattleAnimScriptPtr++;
+    taskId = CreateTask(Task_FadeToBg, 5);
+    gTasks[taskId].tBackgroundId = backgroundId;
+    sAnimBackgroundFadeState = 1;
+}
+
+static void ScriptCmd_fadetobgfromset(void)
+{
+    u8 bg1, bg2, bg3;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    bg1 = sBattleAnimScriptPtr[0];
+    bg2 = sBattleAnimScriptPtr[1];
+    bg3 = sBattleAnimScriptPtr[2];
+    sBattleAnimScriptPtr += 3;
+    taskId = CreateTask(Task_FadeToBg, 5);
+
+    if (IsContest())
+        gTasks[taskId].tBackgroundId = bg3;
+    else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER)
+        gTasks[taskId].tBackgroundId = bg2;
+    else
+        gTasks[taskId].tBackgroundId = bg1;
+
+    sAnimBackgroundFadeState = 1;
+}
+
+static void Task_FadeToBg(u8 taskId)
+{
+    if (gTasks[taskId].tState == 0)
+    {
+        BeginHardwarePaletteFade(0xE8, 0, 0, 16, 0);
+        gTasks[taskId].tState++;
+        return;
+    }
+    if (gPaletteFade.active)
+        return;
+    if (gTasks[taskId].tState == 1)
+    {
+        gTasks[taskId].tState++;
+        sAnimBackgroundFadeState = 2;
+    }
+    else if (gTasks[taskId].tState == 2)
+    {
+        s16 bgId = gTasks[taskId].tBackgroundId;
+
+        if (bgId == -1)
+            LoadDefaultBg();
+        else
+            LoadMoveBg(bgId);
+
+        BeginHardwarePaletteFade(0xE8, 0, 16, 0, 1);
+        gTasks[taskId].tState++;
+        return;
+    }
+    if (gPaletteFade.active)
+        return;
+    if (gTasks[taskId].tState == 3)
+    {
+        DestroyTask(taskId);
+        sAnimBackgroundFadeState = 0;
+    }
+}
+
+static void LoadMoveBg(u16 bgId)
+{
+    if (IsContest())
+    {
+        const u32 *tilemap = gBattleAnimBackgroundTable[bgId].tilemap;
+        void *dmaSrc;
+        void *dmaDest;
+
+        LZDecompressWram(tilemap, gDecompressionBuffer);
+        sub_80730C0(sub_80A6D94(), (void*)(gDecompressionBuffer), 0x100, 0);
+        dmaSrc = gDecompressionBuffer;
+        dmaDest = (void *)(BG_SCREEN_ADDR(26));
+        DmaCopy32(3, dmaSrc, dmaDest, 0x800);
+        LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_SCREEN_ADDR(4)));
+        LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, sub_80A6D94() * 16, 32);
+    }
+    else
+    {
+        LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26)));
+        LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2)));
+        LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32);
+    }
+}
+
+static void LoadDefaultBg(void)
+{
+    if (IsContest())
+        LoadContestBgAfterMoveAnim();
+    else
+        DrawMainBattleBackground();
+}
+
+static void ScriptCmd_restorebg(void)
+{
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    taskId = CreateTask(Task_FadeToBg, 5);
+    gTasks[taskId].tBackgroundId = -1;
+    sAnimBackgroundFadeState = 1;
+}
+
+#undef tBackgroundId
+#undef tState
+
+static void ScriptCmd_waitbgfadeout(void)
+{
+    if (sAnimBackgroundFadeState == 2)
+    {
+        sBattleAnimScriptPtr++;
+        gAnimFramesToWait = 0;
+    }
+    else
+    {
+        gAnimFramesToWait = 1;
+    }
+}
+
+static void ScriptCmd_waitbgfadein(void)
+{
+    if (sAnimBackgroundFadeState == 0)
+    {
+        sBattleAnimScriptPtr++;
+        gAnimFramesToWait = 0;
+    }
+    else
+    {
+        gAnimFramesToWait = 1;
+    }
+}
+
+static void ScriptCmd_changebg(void)
+{
+    sBattleAnimScriptPtr++;
+    LoadMoveBg(sBattleAnimScriptPtr[0]);
+    sBattleAnimScriptPtr++;
+}
+
+s8 BattleAnimAdjustPanning(s8 pan)
+{
+    if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive)
+    {
+        if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
+            pan = SOUND_PAN_TARGET;
+        else
+            pan = SOUND_PAN_ATTACKER;
+    }
+    else if (IsContest())
+    {
+        if (gBattleAnimAttacker != gBattleAnimTarget || gBattleAnimAttacker != 2 || pan != SOUND_PAN_TARGET)
+            pan *= -1;
+    }
+    else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER)
+    {
+        if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER)
+        {
+            if (pan == SOUND_PAN_TARGET)
+                pan = SOUND_PAN_ATTACKER;
+            else if (pan != SOUND_PAN_ATTACKER)
+                pan *= -1;
+        }
+    }
+    else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT)
+    {
+        if (pan == SOUND_PAN_ATTACKER)
+            pan = SOUND_PAN_TARGET;
+    }
+    else
+    {
+        pan *= -1;
+    }
+
+    if (pan > SOUND_PAN_TARGET)
+        pan = SOUND_PAN_TARGET;
+    else if (pan < SOUND_PAN_ATTACKER)
+        pan = SOUND_PAN_ATTACKER;
+
+    return pan;
+}
+
+s8 BattleAnimAdjustPanning2(s8 pan)
+{
+    if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive)
+    {
+        if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
+            pan = SOUND_PAN_TARGET;
+        else
+            pan = SOUND_PAN_ATTACKER;
+    }
+    else
+    {
+        if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER || IsContest())
+            pan = -pan;
+    }
+    return pan;
+}
+
+s16 KeepPanInRange(s16 panArg, int oldPan)
+{
+    s16 pan = panArg;
+
+    if (pan > SOUND_PAN_TARGET)
+        pan = SOUND_PAN_TARGET;
+    else if (pan < SOUND_PAN_ATTACKER)
+        pan = SOUND_PAN_ATTACKER;
+
+    return pan;
+}
+
+s16 CalculatePanIncrement(s16 sourcePan, s16 targetPan, s16 incrementPan)
+{
+    s16 ret;
+
+    if (sourcePan < targetPan)
+        ret = ((incrementPan < 0) ? -incrementPan : incrementPan);
+    else if (sourcePan > targetPan)
+        ret = -((incrementPan < 0) ? -incrementPan : incrementPan);
+    else
+        ret = 0;
+
+    return ret;
+}
+
+static void ScriptCmd_playsewithpan(void)
+{
+    u16 songId;
+    s8 pan;
+
+    sBattleAnimScriptPtr++;
+    songId = T1_READ_16(sBattleAnimScriptPtr);
+    pan = sBattleAnimScriptPtr[2];
+    PlaySE12WithPanning(songId, BattleAnimAdjustPanning(pan));
+    sBattleAnimScriptPtr += 3;
+}
+
+static void ScriptCmd_setpan(void)
+{
+    s8 pan;
+
+    sBattleAnimScriptPtr++;
+    pan = sBattleAnimScriptPtr[0];
+    SE12PanpotControl(BattleAnimAdjustPanning(pan));
+    sBattleAnimScriptPtr++;
+}
+
+#define tInitialPan     data[0]
+#define tTargetPan      data[1]
+#define tIncrementPan   data[2]
+#define tFramesToWait   data[3]
+#define tCurrentPan     data[4]
+#define tFrameCounter   data[8]
+
+static void ScriptCmd_panse_1B(void)
+{
+    u16 songNum;
+    s8 currentPanArg, incrementPan, incrementPanArg, currentPan, targetPan;
+    u8 framesToWait;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    songNum = T1_READ_16(sBattleAnimScriptPtr);
+    currentPanArg = sBattleAnimScriptPtr[2];
+    incrementPan = sBattleAnimScriptPtr[3];
+    incrementPanArg = sBattleAnimScriptPtr[4];
+    framesToWait = sBattleAnimScriptPtr[5];
+
+    currentPan = BattleAnimAdjustPanning(currentPanArg);
+    targetPan = BattleAnimAdjustPanning(incrementPan);
+    incrementPan = CalculatePanIncrement(currentPan, targetPan, incrementPanArg);
+    taskId = CreateTask(Task_PanFromInitialToTarget, 1);
+    gTasks[taskId].tInitialPan = currentPan;
+    gTasks[taskId].tTargetPan = targetPan;
+    gTasks[taskId].tIncrementPan = incrementPan;
+    gTasks[taskId].tFramesToWait = framesToWait;
+    gTasks[taskId].tCurrentPan = currentPan;
+
+    PlaySE12WithPanning(songNum, currentPan);
+
+    gAnimSoundTaskCount++;
+    sBattleAnimScriptPtr += 6;
+}
+
+void Task_PanFromInitialToTarget(u8 taskId)
+{
+    bool32 destroyTask = FALSE;
+    if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait)
+    {
+        s16 pan;
+        s16 initialPanning, targetPanning, currentPan, incrementPan;
+
+        gTasks[taskId].tFrameCounter = 0;
+        initialPanning = gTasks[taskId].tInitialPan;
+        targetPanning = gTasks[taskId].tTargetPan;
+        currentPan = gTasks[taskId].tCurrentPan;
+        incrementPan = gTasks[taskId].tIncrementPan;
+        pan = currentPan + incrementPan;
+        gTasks[taskId].tCurrentPan = pan;
+
+        if (incrementPan == 0) // If we're not incrementing, just cancel the task immediately.
+        {
+            destroyTask = TRUE;
+        }
+        else if (initialPanning < targetPanning) // Panning increasing.
+        {
+            if (pan >= targetPanning) // Target reached.
+                destroyTask = TRUE;
+        }
+        else // Panning decreasing.
+        {
+            if (pan <= targetPanning) // Target reached.
+                destroyTask = TRUE;
+        }
+
+        if (destroyTask)
+        {
+            pan = targetPanning;
+            DestroyTask(taskId);
+            gAnimSoundTaskCount--;
+        }
+
+        SE12PanpotControl(pan);
+    }
+}
+
+static void ScriptCmd_panse_26(void)
+{
+    u16 songId;
+    s8 currentPan, targetPan, incrementPan;
+    u8 framesToWait;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    songId = T1_READ_16(sBattleAnimScriptPtr);
+    currentPan = sBattleAnimScriptPtr[2];
+    targetPan = sBattleAnimScriptPtr[3];
+    incrementPan = sBattleAnimScriptPtr[4];
+    framesToWait = sBattleAnimScriptPtr[5];
+
+    taskId = CreateTask(Task_PanFromInitialToTarget, 1);
+    gTasks[taskId].tInitialPan = currentPan;
+    gTasks[taskId].tTargetPan = targetPan;
+    gTasks[taskId].tIncrementPan = incrementPan;
+    gTasks[taskId].tFramesToWait = framesToWait;
+    gTasks[taskId].tCurrentPan = currentPan;
+
+    PlaySE12WithPanning(songId, currentPan);
+
+    gAnimSoundTaskCount++;
+    sBattleAnimScriptPtr += 6;
+}
+
+static void ScriptCmd_panse_27(void)
+{
+    u16 songId;
+    s8 targetPanArg, incrementPanArg, currentPanArg, currentPan, targetPan, incrementPan;
+    u8 framesToWait;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    songId = T1_READ_16(sBattleAnimScriptPtr);
+    currentPanArg = sBattleAnimScriptPtr[2];
+    targetPanArg = sBattleAnimScriptPtr[3];
+    incrementPanArg = sBattleAnimScriptPtr[4];
+    framesToWait = sBattleAnimScriptPtr[5];
+
+    currentPan = BattleAnimAdjustPanning2(currentPanArg);
+    targetPan = BattleAnimAdjustPanning2(targetPanArg);
+    incrementPan = BattleAnimAdjustPanning2(incrementPanArg);
+
+    taskId = CreateTask(Task_PanFromInitialToTarget, 1);
+    gTasks[taskId].tInitialPan = currentPan;
+    gTasks[taskId].tTargetPan = targetPan;
+    gTasks[taskId].tIncrementPan = incrementPan;
+    gTasks[taskId].tFramesToWait = framesToWait;
+    gTasks[taskId].tCurrentPan = currentPan;
+
+    PlaySE12WithPanning(songId, currentPan);
+
+    gAnimSoundTaskCount++;
+    sBattleAnimScriptPtr += 6;
+}
+
+#undef tInitialPan
+#undef tTargetPan
+#undef tIncrementPan
+#undef tFramesToWait
+#undef tCurrentPan
+#undef tFrameCounter
+
+#define tSongId         data[0]
+#define tPanning        data[1]
+#define tFramesToWait   data[2]
+#define tNumberOfPlays  data[3]
+#define tFrameCounter   data[8]
+
+static void ScriptCmd_loopsewithpan(void)
+{
+    u16 songId;
+    s8 panningArg, panning;
+    u8 framesToWait, numberOfPlays;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    songId = T1_READ_16(sBattleAnimScriptPtr);
+    panningArg = sBattleAnimScriptPtr[2];
+    framesToWait = sBattleAnimScriptPtr[3];
+    numberOfPlays = sBattleAnimScriptPtr[4];
+    panning = BattleAnimAdjustPanning(panningArg);
+
+    taskId = CreateTask(Task_LoopAndPlaySE, 1);
+    gTasks[taskId].tSongId = songId;
+    gTasks[taskId].tPanning = panning;
+    gTasks[taskId].tFramesToWait = framesToWait;
+    gTasks[taskId].tNumberOfPlays = numberOfPlays;
+    gTasks[taskId].tFrameCounter = framesToWait;
+    gTasks[taskId].func(taskId);
+
+    gAnimSoundTaskCount++;
+    sBattleAnimScriptPtr += 5;
+}
+
+static void Task_LoopAndPlaySE(u8 taskId)
+{
+    if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait)
+    {
+        u16 songId;
+        s8 panning;
+        u8 numberOfPlays;
+
+        gTasks[taskId].tFrameCounter = 0;
+        songId = gTasks[taskId].tSongId;
+        panning = gTasks[taskId].tPanning;
+        numberOfPlays = --gTasks[taskId].tNumberOfPlays;
+        PlaySE12WithPanning(songId, panning);
+        if (numberOfPlays == 0)
+        {
+            DestroyTask(taskId);
+            gAnimSoundTaskCount--;
+        }
+    }
+}
+
+#undef tSongId
+#undef tPanning
+#undef tFramesToWait
+#undef tNumberOfPlays
+#undef tFrameCounter
+
+#define tSongId         data[0]
+#define tPanning        data[1]
+#define tFramesToWait   data[2]
+
+static void ScriptCmd_waitplaysewithpan(void)
+{
+    u16 songId;
+    s8 panningArg, panning;
+    u8 framesToWait;
+    u8 taskId;
+
+    sBattleAnimScriptPtr++;
+    songId = T1_READ_16(sBattleAnimScriptPtr);
+    panningArg = sBattleAnimScriptPtr[2];
+    framesToWait = sBattleAnimScriptPtr[3];
+    panning = BattleAnimAdjustPanning(panningArg);
+
+    taskId = CreateTask(Task_WaitAndPlaySE, 1);
+    gTasks[taskId].tSongId = songId;
+    gTasks[taskId].tPanning = panning;
+    gTasks[taskId].tFramesToWait = framesToWait;
+
+    gAnimSoundTaskCount++;
+    sBattleAnimScriptPtr += 4;
+}
+
+static void Task_WaitAndPlaySE(u8 taskId)
+{
+    if (gTasks[taskId].tFramesToWait-- <= 0)
+    {
+        PlaySE12WithPanning(gTasks[taskId].tSongId, gTasks[taskId].tPanning);
+        DestroyTask(taskId);
+        gAnimSoundTaskCount--;
+    }
+}
+
+#undef tSongId
+#undef tPanning
+#undef tFramesToWait
+
+static void ScriptCmd_createsoundtask(void)
+{
+    TaskFunc func;
+    u8 numArgs, taskId;
+    s32 i;
+
+    sBattleAnimScriptPtr++;
+    func = (TaskFunc)T2_READ_32(sBattleAnimScriptPtr);
+    sBattleAnimScriptPtr += 4;
+    numArgs = sBattleAnimScriptPtr[0];
+    sBattleAnimScriptPtr++;
+    for (i = 0; i < numArgs; i++)
+    {
+        gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr);
+        sBattleAnimScriptPtr += 2;
+    }
+    taskId = CreateTask(func, 1);
+    func(taskId);
+    gAnimSoundTaskCount++;
+}
+
+static void ScriptCmd_waitsound(void)
+{
+    if (gAnimSoundTaskCount != 0)
+    {
+        sSoundAnimFramesToWait = 0;
+        gAnimFramesToWait = 1;
+    }
+    else if (IsSEPlaying())
+    {
+        if (++sSoundAnimFramesToWait > 90)
+        {
+            m4aMPlayStop(&gMPlayInfo_SE1);
+            m4aMPlayStop(&gMPlayInfo_SE2);
+            sSoundAnimFramesToWait = 0;
+        }
+        else
+        {
+            gAnimFramesToWait = 1;
+        }
+    }
+    else
+    {
+        sSoundAnimFramesToWait = 0;
+        sBattleAnimScriptPtr++;
+        gAnimFramesToWait = 0;
+    }
+}
+
+static void ScriptCmd_jumpargeq(void)
+{
+    u8 argId;
+    s16 valueToCheck;
+
+    sBattleAnimScriptPtr++;
+    argId = sBattleAnimScriptPtr[0];
+    valueToCheck = T1_READ_16(sBattleAnimScriptPtr + 1);
+
+    if (valueToCheck == gBattleAnimArgs[argId])
+        sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr + 3);
+    else
+        sBattleAnimScriptPtr += 7;
+}
+
+static void ScriptCmd_jumpifcontest(void)
+{
+    sBattleAnimScriptPtr++;
+    if (IsContest())
+        sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr);
+    else
+        sBattleAnimScriptPtr += 4;
+}
+
+static void ScriptCmd_monbgprio_28(void)
+{
+    u8 wantedBattler;
+    u8 battlerId;
+    u8 battlerPosition;
+
+    wantedBattler = sBattleAnimScriptPtr[1];
+    sBattleAnimScriptPtr += 2;
+
+    if (wantedBattler != ANIM_ATTACKER)
+        battlerId = gBattleAnimTarget;
+    else
+        battlerId = gBattleAnimAttacker;
+
+    battlerPosition = GetBattlerPosition(battlerId);
+    if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT))
+    {
+        SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
+        SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
+    }
+}
+
+static void ScriptCmd_monbgprio_29(void)
+{
+    sBattleAnimScriptPtr++;
+    if (!IsContest())
+    {
+        SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
+        SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
+    }
+}
+
+static void ScriptCmd_monbgprio_2A(void)
+{
+    u8 wantedBattler;
+    u8 battlerPosition;
+    u8 battlerId;
+
+    wantedBattler = sBattleAnimScriptPtr[1];
+    sBattleAnimScriptPtr += 2;
+    if (GetBattlerSide(gBattleAnimAttacker) != GetBattlerSide(gBattleAnimTarget))
+    {
+        if (wantedBattler != ANIM_ATTACKER)
+            battlerId = gBattleAnimTarget;
+        else
+            battlerId = gBattleAnimAttacker;
+
+        battlerPosition = GetBattlerPosition(battlerId);
+        if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT))
+        {
+            SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
+            SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
+        }
+    }
+}
+
+static void ScriptCmd_invisible(void)
+{
+    u8 spriteId;
+
+    spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]);
+    if (spriteId != 0xFF)
+        gSprites[spriteId].invisible = TRUE;
+
+    sBattleAnimScriptPtr += 2;
+}
+
+static void ScriptCmd_visible(void)
+{
+    u8 spriteId;
+
+    spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]);
+    if (spriteId != 0xFF)
+        gSprites[spriteId].invisible = FALSE;
+
+    sBattleAnimScriptPtr += 2;
+}
+
+static void ScriptCmd_doublebattle_2D(void)
+{
+    u8 wantedBattler;
+    u8 r4;
+    u8 spriteId;
+
+    wantedBattler = sBattleAnimScriptPtr[1];
+    sBattleAnimScriptPtr += 2;
+    if (!IsContest() && IsDoubleBattle()
+     && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget))
+    {
+        if (wantedBattler == ANIM_ATTACKER)
+        {
+            r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker);
+            spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER);
+        }
+        else
+        {
+            r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget);
+            spriteId = GetAnimBattlerSpriteId(ANIM_TARGET);
+        }
+        if (spriteId != 0xFF)
+        {
+            gSprites[spriteId].invisible = FALSE;
+            if (r4 == 2)
+                gSprites[spriteId].oam.priority = 3;
+
+            if (r4 == 1)
+                sub_8073128(FALSE);
+            else
+                sub_8073128(TRUE);
+        }
+    }
+}
+
+static void ScriptCmd_doublebattle_2E(void)
+{
+    u8 wantedBattler;
+    u8 r4;
+    u8 spriteId;
+
+    wantedBattler = sBattleAnimScriptPtr[1];
+    sBattleAnimScriptPtr += 2;
+    if (!IsContest() && IsDoubleBattle()
+     && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget))
+    {
+        if (wantedBattler == ANIM_ATTACKER)
+        {
+            r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker);
+            spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER);
+        }
+        else
+        {
+            r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget);
+            spriteId = GetAnimBattlerSpriteId(ANIM_TARGET);
+        }
+
+        if (spriteId != 0xFF && r4 == 2)
+            gSprites[spriteId].oam.priority = 2;
+    }
+}
+
+static void ScriptCmd_stopsound(void)
+{
+    m4aMPlayStop(&gMPlayInfo_SE1);
+    m4aMPlayStop(&gMPlayInfo_SE2);
+    sBattleAnimScriptPtr++;
+}