Decompile normal.c (#414)

include/battle_anim.h

@@ -123,6 +123,7 @@ u8 sub_80A89C8(int, u8, int);
 void sub_80A6D60(struct UnknownAnimStruct2*, const void*, u32);
 void sub_80A6CC0(u32, const void*, u32);
 void sub_80A6DAC(bool8);
+void sub_80A634C(struct Sprite *);
 
 enum
 {
@@ -166,7 +167,7 @@ u8 LaunchBallFadeMonTask(bool8 unFadeLater, u8 battlerId, u32 arg2, u8 ballId);
 // battle_anim_utility_funcs.s
 void sub_8116EB4(u8);
 
-u32 sub_811583C(s16);
+u32 UnpackSelectedBattleAnimPalettes(s16);
 
 u8 GetBattlerSpriteFinal_Y(u8, u16, u8);
 

ld_script.txt

@@ -172,7 +172,7 @@ SECTIONS {
         src/dragon.o(.text);
         asm/dark.o(.text);
         src/ground.o(.text);
-        asm/normal.o(.text);
+        src/normal.o(.text);
         src/battle_anim_utility_funcs.o(.text);
         asm/battle_intro.o(.text);
         src/bike.o(.text);

src/battle_anim_utility_funcs.c

@@ -47,7 +47,7 @@ const u8 gUnknown_0859741E[] = {0x08, 0x0a, 0x0c, 0x0e};
 
 void sub_8116620(u8 taskId)
 {
-    u32 selectedPalettes = sub_811583C(gBattleAnimArgs[0]);
+    u32 selectedPalettes = UnpackSelectedBattleAnimPalettes(gBattleAnimArgs[0]);
     selectedPalettes |= sub_80A76C4((gBattleAnimArgs[0] >>  7) & 1,
                                     (gBattleAnimArgs[0] >>  8) & 1,
                                     (gBattleAnimArgs[0] >>  9) & 1,
@@ -62,7 +62,7 @@ void sub_8116664(u8 taskId)
     u8 animBattlers[2];
 
     animBattlers[1] = 0xFF;
-    selectedPalettes = sub_811583C(1);
+    selectedPalettes = UnpackSelectedBattleAnimPalettes(1);
     switch (gBattleAnimArgs[0])
     {
     case 2:
@@ -105,7 +105,7 @@ void sub_8116664(u8 taskId)
 
 void AnimTask_SetCamouflageBlend(u8 taskId)
 {
-    u32 selectedPalettes = sub_811583C(gBattleAnimArgs[0]);
+    u32 selectedPalettes = UnpackSelectedBattleAnimPalettes(gBattleAnimArgs[0]);
     switch (gBattleTerrain)
     {
     case BATTLE_TERRAIN_GRASS:

src/normal.c

@@ -1,19 +1,42 @@
 #include "global.h"
 #include "battle_anim.h"
+#include "palette.h"
+#include "random.h"
+#include "task.h"
+#include "trig.h"
 #include "constants/rgb.h"
 
-extern void sub_811572C(struct Sprite *);
+void AnimConfusionDuck(struct Sprite *);
-extern void sub_81157FC(struct Sprite *);
+void AnimSimplePaletteBlend(struct Sprite *);
-extern void sub_81158A4(struct Sprite *);
+u32 UnpackSelectedBattleAnimPalettes(s16);
-extern void sub_81159B4(struct Sprite *);
+void sub_81158A4(struct Sprite *);
-extern void sub_81160A4(struct Sprite *);
+void sub_81159B4(struct Sprite *);
-extern void sub_8116388(struct Sprite *);
+void sub_81160A4(struct Sprite *);
-extern void sub_8116420(struct Sprite *);
+void sub_8116388(struct Sprite *);
-extern void sub_8116458(struct Sprite *);
+void sub_8116420(struct Sprite *);
-extern void sub_81164F0(struct Sprite *);
+void sub_8116458(struct Sprite *);
-extern void sub_8116560(struct Sprite *);
+void sub_81164F0(struct Sprite *);
-extern void sub_81165A8(struct Sprite *);
+void sub_8116560(struct Sprite *);
-extern void sub_81163D0(struct Sprite *);
+void sub_81165A8(struct Sprite *);
+static void AnimConfusionDuckStep(struct Sprite *);
+static void AnimSimplePaletteBlendStep(struct Sprite *);
+static void sub_81158F8(struct Sprite *);
+static void sub_8115984(struct Sprite *);
+static void sub_8115A54(u8, u8, u8);
+static void sub_8115AA4(u8);
+static void sub_8115BC8(u8, u8, u8);
+static void sub_8115C18(u8);
+static void sub_8115CD0(u8, u8, u8);
+static void sub_8115D2C(u8);
+static void sub_8115E00(u8);
+static void sub_8115EB8(u8);
+static void sub_8116148(struct Sprite *);
+static void sub_81161F4(void);
+static void sub_81162F8(u8);
+static void sub_81163D0(struct Sprite *);
+static void sub_81165E4(struct Sprite *);
+
+extern void sub_810E2C8(struct Sprite *);
 
 const union AnimCmd gUnknown_0859722C[] =
 {
@@ -47,7 +70,7 @@ const struct SpriteTemplate gConfusionDuckSpriteTemplate =
     .anims = gUnknown_08597254,
     .images = NULL,
     .affineAnims = gDummySpriteAffineAnimTable,
-    .callback = sub_811572C,
+    .callback = AnimConfusionDuck,
 };
 
 const struct SpriteTemplate gSimplePaletteBlendSpriteTemplate =
@@ -58,7 +81,7 @@ const struct SpriteTemplate gSimplePaletteBlendSpriteTemplate =
     .anims = gDummySpriteAnimTable,
     .images = NULL,
     .affineAnims = gDummySpriteAffineAnimTable,
-    .callback = sub_81157FC,
+    .callback = AnimSimplePaletteBlend,
 };
 
 const struct SpriteTemplate gComplexPaletteBlendSpriteTemplate =
@@ -231,3 +254,717 @@ const struct SpriteTemplate gUnknown_08597400 =
     .affineAnims = gUnknown_08597348,
     .callback = sub_81163D0,
 };
+
+// Moves a spinning duck around the mon's head.
+// arg 0: initial x pixel offset
+// arg 1: initial y pixel offset
+// arg 2: initial wave offset
+// arg 3: wave period (higher means faster wave)
+// arg 4: duration
+void AnimConfusionDuck(struct Sprite *sprite)
+{
+    sprite->pos1.x += gBattleAnimArgs[0];
+    sprite->pos1.y += gBattleAnimArgs[1];
+    sprite->data[0] = gBattleAnimArgs[2];
+    if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
+    {
+        sprite->data[1] = -gBattleAnimArgs[3];
+        sprite->data[4] = 1;
+    }
+    else
+    {
+        sprite->data[1] = gBattleAnimArgs[3];
+        sprite->data[4] = 0;
+        StartSpriteAnim(sprite, 1);
+    }
+
+    sprite->data[3] = gBattleAnimArgs[4];
+    sprite->callback = AnimConfusionDuckStep;
+    sprite->callback(sprite);
+}
+
+static void AnimConfusionDuckStep(struct Sprite *sprite)
+{
+    sprite->pos2.x = Cos(sprite->data[0], 30);
+    sprite->pos2.y = Sin(sprite->data[0], 10);
+
+    if ((u16)sprite->data[0] < 128)
+        sprite->oam.priority = 1;
+    else
+        sprite->oam.priority = 3;
+
+    sprite->data[0] = (sprite->data[0] + sprite->data[1]) & 0xFF;
+    if (++sprite->data[2] == sprite->data[3])
+        DestroyAnimSprite(sprite);
+}
+
+// Performs a simple color blend on a specified sprite.
+// arg 0: palette selector
+// arg 1: delay
+// arg 2: start blend amount
+// arg 3: end blend amount
+// arg 4: blend color
+void AnimSimplePaletteBlend(struct Sprite *sprite)
+{
+    u32 selectedPalettes = UnpackSelectedBattleAnimPalettes(gBattleAnimArgs[0]);
+    BeginNormalPaletteFade(selectedPalettes, gBattleAnimArgs[1], gBattleAnimArgs[2], gBattleAnimArgs[3], gBattleAnimArgs[4]);
+    sprite->invisible = 1;
+    sprite->callback = AnimSimplePaletteBlendStep;
+}
+
+// Unpacks a bitfield and returns a bitmask of its selected palettes.
+// Bits 0-6 of the selector parameter result in the following palettes being selected:
+//   0: battle background palettes (BG palettes 1, 2, and 3)
+//   1: gBattleAnimAttacker OBJ palette
+//   2: gBattleAnimTarget OBJ palette
+//   3: gBattleAnimAttacker partner OBJ palette
+//   4: gBattleAnimTarget partner OBJ palette
+//   5: BG palette 4
+//   6: BG palette 5
+u32 UnpackSelectedBattleAnimPalettes(s16 selector)
+{
+    u8 arg0 = selector & 1;
+    u8 arg1 = (selector >> 1) & 1;
+    u8 arg2 = (selector >> 2) & 1;
+    u8 arg3 = (selector >> 3) & 1;
+    u8 arg4 = (selector >> 4) & 1;
+    u8 arg5 = (selector >> 5) & 1;
+    u8 arg6 = (selector >> 6) & 1;
+    return sub_80A75AC(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+static void AnimSimplePaletteBlendStep(struct Sprite *sprite)
+{
+    if (!gPaletteFade.active)
+        DestroyAnimSprite(sprite);
+}
+
+void sub_81158A4(struct Sprite *sprite)
+{
+    u32 selectedPalettes;
+
+    sprite->data[0] = gBattleAnimArgs[1];
+    sprite->data[1] = gBattleAnimArgs[1];
+    sprite->data[2] = gBattleAnimArgs[2];
+    sprite->data[3] = gBattleAnimArgs[3];
+    sprite->data[4] = gBattleAnimArgs[4];
+    sprite->data[5] = gBattleAnimArgs[5];
+    sprite->data[6] = gBattleAnimArgs[6];
+    sprite->data[7] = gBattleAnimArgs[0];
+
+    selectedPalettes = UnpackSelectedBattleAnimPalettes(sprite->data[7]);
+    BlendPalettes(selectedPalettes, gBattleAnimArgs[4], gBattleAnimArgs[3]);
+    sprite->invisible = 1;
+    sprite->callback = sub_81158F8;
+}
+
+static void sub_81158F8(struct Sprite *sprite)
+{
+    u32 selectedPalettes;
+
+    if (sprite->data[0] > 0)
+    {
+        sprite->data[0]--;
+        return;
+    }
+
+    if (gPaletteFade.active)
+        return;
+
+    if (sprite->data[2] == 0)
+    {
+        sprite->callback = sub_8115984;
+        return;
+    }
+
+    selectedPalettes = UnpackSelectedBattleAnimPalettes(sprite->data[7]);
+    if (sprite->data[1] & 0x100)
+        BlendPalettes(selectedPalettes, sprite->data[4], sprite->data[3]);
+    else
+        BlendPalettes(selectedPalettes, sprite->data[6], sprite->data[5]);
+
+    sprite->data[1] ^= 0x100;
+    sprite->data[0] = sprite->data[1] & 0xFF;
+    sprite->data[2]--;
+}
+
+static void sub_8115984(struct Sprite *sprite)
+{
+    u32 selectedPalettes;
+
+    if (!gPaletteFade.active)
+    {
+        selectedPalettes = UnpackSelectedBattleAnimPalettes(sprite->data[7]);
+        BlendPalettes(selectedPalettes, 0, 0);
+        DestroyAnimSprite(sprite);
+    }
+}
+
+void sub_81159B4(struct Sprite *sprite)
+{
+    sprite->pos1.x += gBattleAnimArgs[0];
+    sprite->pos1.y += gBattleAnimArgs[1];
+    sprite->data[0] = 0;
+    sprite->data[1] = 10;
+    sprite->data[2] = 8;
+    sprite->data[3] = 40;
+    sprite->data[4] = 112;
+    sprite->data[5] = 0;
+    StoreSpriteCallbackInData6(sprite, move_anim_8074EE0);
+    sprite->callback = sub_80A634C;
+    sprite->callback(sprite);
+}
+
+void sub_8115A04(u8 taskId)
+{
+    gTasks[taskId].data[0] = gBattleAnimArgs[0];
+    gTasks[taskId].data[1] = gBattleAnimArgs[1];
+    gTasks[taskId].data[2] = gBattleAnimArgs[2];
+    gTasks[taskId].data[3] = gBattleAnimArgs[3];
+    gTasks[taskId].data[4] = gBattleAnimArgs[4];
+    gTasks[taskId].data[5] = gBattleAnimArgs[5];
+    gTasks[taskId].data[8] = 0;
+    sub_8115A54(taskId, 0, gTasks[taskId].data[4]);
+    gTasks[taskId].func = sub_8115AA4;
+}
+
+static void sub_8115A54(u8 taskId, u8 initialBlendAmount, u8 targetBlendAmount)
+{
+    u32 selectedPalettes = UnpackSelectedBattleAnimPalettes(gTasks[taskId].data[0]);
+    BeginNormalPaletteFade(
+        selectedPalettes,
+        gTasks[taskId].data[1],
+        initialBlendAmount,
+        targetBlendAmount,
+        gTasks[taskId].data[5]);
+
+    gTasks[taskId].data[2]--;
+    gTasks[taskId].data[8] ^= 1;
+}
+
+static void sub_8115AA4(u8 taskId)
+{
+    u8 initialBlendAmount, targetBlendAmount;
+    if (!gPaletteFade.active)
+    {
+        if (gTasks[taskId].data[2] > 0)
+        {
+            if (gTasks[taskId].data[8] == 0)
+            {
+                initialBlendAmount = gTasks[taskId].data[3];
+                targetBlendAmount = gTasks[taskId].data[4];
+            }
+            else
+            {
+                initialBlendAmount = gTasks[taskId].data[4];
+                targetBlendAmount = gTasks[taskId].data[3];
+            }
+
+            if (gTasks[taskId].data[2] == 1)
+                targetBlendAmount = 0;
+
+            sub_8115A54(taskId, initialBlendAmount, targetBlendAmount);
+        }
+        else
+        {
+            DestroyAnimVisualTask(taskId);
+        }
+    }
+}
+
+void sub_8115B0C(u8 taskId)
+{
+    int battler;
+    u32 selectedPalettes = 0;
+
+    gTasks[taskId].data[0] = gBattleAnimArgs[0];
+    gTasks[taskId].data[1] = gBattleAnimArgs[1];
+    gTasks[taskId].data[2] = gBattleAnimArgs[2];
+    gTasks[taskId].data[3] = gBattleAnimArgs[3];
+    gTasks[taskId].data[4] = gBattleAnimArgs[4];
+    gTasks[taskId].data[5] = gBattleAnimArgs[5];
+    gTasks[taskId].data[8] = 0;
+
+    for (battler = 0; battler < gBattlersCount; battler++)
+    {
+        if (battler != gBattleAnimAttacker && battler != gBattleAnimTarget)
+            selectedPalettes |= 1 << (battler + 16);
+    }
+
+    if (gBattleAnimArgs[0] == 1)
+        selectedPalettes |= 0xE;
+
+    gTasks[taskId].data[9] = selectedPalettes >> 16;
+    gTasks[taskId].data[10] = selectedPalettes & 0xFF;
+    sub_8115BC8(taskId, 0, gTasks[taskId].data[4]);
+    gTasks[taskId].func = sub_8115C18;
+}
+
+static void sub_8115BC8(u8 taskId, u8 initialBlendAmount, u8 targetBlendAmount)
+{
+    u32 selectedPalettes = ((u16)gTasks[taskId].data[9] << 16) | (u16)gTasks[taskId].data[10];
+    BeginNormalPaletteFade(
+        selectedPalettes,
+        gTasks[taskId].data[1],
+        initialBlendAmount,
+        targetBlendAmount,
+        gTasks[taskId].data[5]);
+
+    gTasks[taskId].data[2]--;
+    gTasks[taskId].data[8] ^= 1;
+}
+
+static void sub_8115C18(u8 taskId)
+{
+    u8 initialBlendAmount, targetBlendAmount;
+    if (!gPaletteFade.active)
+    {
+        if (gTasks[taskId].data[2] > 0)
+        {
+            if (gTasks[taskId].data[8] == 0)
+            {
+                initialBlendAmount = gTasks[taskId].data[3];
+                targetBlendAmount = gTasks[taskId].data[4];
+            }
+            else
+            {
+                initialBlendAmount = gTasks[taskId].data[4];
+                targetBlendAmount = gTasks[taskId].data[3];
+            }
+
+            if (gTasks[taskId].data[2] == 1)
+                targetBlendAmount = 0;
+
+            sub_8115BC8(taskId, initialBlendAmount, targetBlendAmount);
+        }
+        else
+        {
+            DestroyAnimVisualTask(taskId);
+        }
+    }
+}
+
+void sub_8115C80(u8 taskId)
+{
+    u8 paletteIndex;
+
+    gTasks[taskId].data[0] = gBattleAnimArgs[0];
+    gTasks[taskId].data[1] = gBattleAnimArgs[1];
+    gTasks[taskId].data[2] = gBattleAnimArgs[2];
+    gTasks[taskId].data[3] = gBattleAnimArgs[3];
+    gTasks[taskId].data[4] = gBattleAnimArgs[4];
+    gTasks[taskId].data[5] = gBattleAnimArgs[5];
+    gTasks[taskId].data[8] = 0;
+
+    sub_8115CD0(taskId, 0, gTasks[taskId].data[4]);
+    gTasks[taskId].func = sub_8115D2C;
+}
+
+static void sub_8115CD0(u8 taskId, u8 initialBlendAmount, u8 targetBlendAmount)
+{
+    u8 paletteIndex = IndexOfSpritePaletteTag(gTasks[taskId].data[0]);
+    BeginNormalPaletteFade(
+        1 << (paletteIndex + 16),
+        gTasks[taskId].data[1],
+        initialBlendAmount,
+        targetBlendAmount,
+        gTasks[taskId].data[5]);
+
+    gTasks[taskId].data[2]--;
+    gTasks[taskId].data[8] ^= 1;
+}
+
+static void sub_8115D2C(u8 taskId)
+{
+    u8 initialBlendAmount, targetBlendAmount;
+    if (!gPaletteFade.active)
+    {
+        if (gTasks[taskId].data[2] > 0)
+        {
+            if (gTasks[taskId].data[8] == 0)
+            {
+                initialBlendAmount = gTasks[taskId].data[3];
+                targetBlendAmount = gTasks[taskId].data[4];
+            }
+            else
+            {
+                initialBlendAmount = gTasks[taskId].data[4];
+                targetBlendAmount = gTasks[taskId].data[3];
+            }
+
+            if (gTasks[taskId].data[2] == 1)
+                targetBlendAmount = 0;
+
+            sub_8115CD0(taskId, initialBlendAmount, targetBlendAmount);
+        }
+        else
+        {
+            DestroyAnimVisualTask(taskId);
+        }
+    }
+}
+
+void sub_8115D94(u8 taskId)
+{
+    u8 paletteIndex;
+
+    gTasks[taskId].data[0] = gBattleAnimArgs[1];
+    gTasks[taskId].data[1] = gBattleAnimArgs[1];
+    gTasks[taskId].data[2] = gBattleAnimArgs[2];
+    gTasks[taskId].data[3] = gBattleAnimArgs[3];
+    gTasks[taskId].data[4] = gBattleAnimArgs[4];
+    gTasks[taskId].data[5] = gBattleAnimArgs[5];
+    gTasks[taskId].data[6] = gBattleAnimArgs[6];
+    gTasks[taskId].data[7] = gBattleAnimArgs[0];
+
+    paletteIndex = IndexOfSpritePaletteTag(gBattleAnimArgs[0]);
+    BeginNormalPaletteFade(
+        1 << (paletteIndex + 16),
+        0,
+        gBattleAnimArgs[4],
+        gBattleAnimArgs[4],
+        gBattleAnimArgs[3]);
+
+    gTasks[taskId].func = sub_8115E00;
+}
+
+static void sub_8115E00(u8 taskId)
+{
+    u32 selectedPalettes;
+
+    if (gTasks[taskId].data[0] > 0)
+    {
+        gTasks[taskId].data[0]--;
+        return;
+    }
+
+    if (gPaletteFade.active)
+        return;
+
+    if (gTasks[taskId].data[2] == 0)
+    {
+        gTasks[taskId].func = sub_8115EB8;
+        return;
+    }
+
+    selectedPalettes = 1 << (IndexOfSpritePaletteTag(gTasks[taskId].data[7]) + 16);
+    if (gTasks[taskId].data[1] & 0x100)
+    {
+        BeginNormalPaletteFade(
+            selectedPalettes,
+            0,
+            gTasks[taskId].data[4],
+            gTasks[taskId].data[4],
+            gTasks[taskId].data[3]);
+    }
+    else
+    {
+        BeginNormalPaletteFade(
+            selectedPalettes,
+            0,
+            gTasks[taskId].data[6],
+            gTasks[taskId].data[6],
+            gTasks[taskId].data[5]);
+    }
+
+    gTasks[taskId].data[1] ^= 0x100;
+    gTasks[taskId].data[0] = gTasks[taskId].data[1] & 0xFF;
+    gTasks[taskId].data[2]--;
+}
+
+static void sub_8115EB8(u8 taskId)
+{
+    u32 selectedPalettes;
+
+    if (!gPaletteFade.active)
+    {
+        selectedPalettes = 1 << (IndexOfSpritePaletteTag(gTasks[taskId].data[7]) + 16);
+        BeginNormalPaletteFade(selectedPalettes, 0, 0, 0, RGB(0, 0, 0));
+        DestroyAnimVisualTask(taskId);
+    }
+}
+
+void sub_8115F10(u8 taskId)
+{
+    u32 selectedPalettes = 0;
+    u8 attackerBattler = gBattleAnimAttacker;
+    u8 targetBattler = gBattleAnimTarget;
+
+    if (gBattleAnimArgs[0] & 0x100)
+        selectedPalettes = sub_80A75AC(1, 0, 0, 0, 0, 0, 0);
+
+    if (gBattleAnimArgs[1] & 0x100)
+        selectedPalettes |= (0x10000 << attackerBattler);
+
+    if (gBattleAnimArgs[2] & 0x100)
+        selectedPalettes |= (0x10000 << targetBattler);
+
+    InvertPlttBuffer(selectedPalettes);
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_8115F94(u8 taskId)
+{
+    u8 attackerBattler;
+    u8 targetBattler;
+    u8 paletteIndex;
+    u32 selectedPalettes = 0;
+
+    if (gTasks[taskId].data[0] == 0)
+    {
+        gTasks[taskId].data[2] = gBattleAnimArgs[0];
+        gTasks[taskId].data[3] = gBattleAnimArgs[1];
+        gTasks[taskId].data[4] = gBattleAnimArgs[2];
+        gTasks[taskId].data[1] = gBattleAnimArgs[3];
+        gTasks[taskId].data[5] = gBattleAnimArgs[4];
+        gTasks[taskId].data[6] = gBattleAnimArgs[5];
+        gTasks[taskId].data[7] = gBattleAnimArgs[6];
+    }
+
+    gTasks[taskId].data[0]++;
+    attackerBattler = gBattleAnimAttacker;
+    targetBattler = gBattleAnimTarget;
+
+    if (gTasks[taskId].data[2] & 0x100)
+        selectedPalettes = 0x0000FFFF;
+
+    if (gTasks[taskId].data[2] & 0x1)
+    {
+        paletteIndex = IndexOfSpritePaletteTag(gSprites[gHealthboxSpriteIds[attackerBattler]].template->paletteTag);
+        selectedPalettes |= (1 << paletteIndex) << 16;
+    }
+    
+    if (gTasks[taskId].data[3] & 0x100)
+        selectedPalettes |= (1 << attackerBattler) << 16;
+
+    if (gTasks[taskId].data[4] & 0x100)
+        selectedPalettes |= (1 << targetBattler) << 16;
+
+    TintPlttBuffer(selectedPalettes, gTasks[taskId].data[5], gTasks[taskId].data[6], gTasks[taskId].data[7]);
+    if (gTasks[taskId].data[0] == gTasks[taskId].data[1])
+    {
+        UnfadePlttBuffer(selectedPalettes);
+        DestroyAnimVisualTask(taskId);
+    }
+}
+
+void sub_81160A4(struct Sprite *sprite)
+{
+    u16 var0;
+
+    sprite->invisible = 1;
+    sprite->data[0] = -gBattleAnimArgs[0];
+    sprite->data[1] = gBattleAnimArgs[1];
+    sprite->data[2] = gBattleAnimArgs[1];
+    sprite->data[3] = gBattleAnimArgs[2];
+
+    switch (gBattleAnimArgs[3])
+    {
+    case 0:
+        StoreSpriteCallbackInData6(sprite, (void *)&gBattle_BG3_X);
+        break;
+    case 1:
+        StoreSpriteCallbackInData6(sprite, (void *)&gBattle_BG3_Y);
+        break;
+    case 2:
+        StoreSpriteCallbackInData6(sprite, (void *)&gSpriteCoordOffsetX);
+        break;
+    default:
+        StoreSpriteCallbackInData6(sprite, (void *)&gSpriteCoordOffsetY);
+        break;
+    }
+
+    sprite->data[4] = *(u16 *)(sprite->data[6] | (sprite->data[7] << 16));
+    sprite->data[5] = gBattleAnimArgs[3];
+    var0 = sprite->data[5] - 2;
+    if (var0 < 2)
+        sub_81161F4();
+
+    sprite->callback = sub_8116148;
+}
+
+static void sub_8116148(struct Sprite *sprite)
+{
+    u8 i;
+    u16 var0;
+
+    if (sprite->data[3] > 0)
+    {
+        sprite->data[3]--;
+        if (sprite->data[1] > 0)
+        {
+            sprite->data[1]--;
+        }
+        else
+        {
+            sprite->data[1] = sprite->data[2];
+            *(u16 *)(sprite->data[6] | (sprite->data[7] << 16)) += sprite->data[0];
+            sprite->data[0] = -sprite->data[0];
+        }
+    }
+    else
+    {
+        *(u16 *)(sprite->data[6] | (sprite->data[7] << 16)) = sprite->data[4];
+        var0 = sprite->data[5] - 2;
+        if (var0 < 2)
+        {
+            for (i = 0; i < gBattlersCount; i++)
+                gSprites[gBattlerSpriteIds[i]].coordOffsetEnabled = 0;
+        }
+
+        DestroyAnimSprite(sprite);
+    }
+}
+
+static void sub_81161F4(void)
+{
+    gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].coordOffsetEnabled = 0;
+    gSprites[gBattlerSpriteIds[gBattleAnimTarget]].coordOffsetEnabled = 0;
+
+    if (gBattleAnimArgs[4] == 2)
+    {
+        gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].coordOffsetEnabled = 1;
+        gSprites[gBattlerSpriteIds[gBattleAnimTarget]].coordOffsetEnabled = 1;
+    }
+    else
+    {
+        if (gBattleAnimArgs[4] == 0)
+            gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].coordOffsetEnabled = 1;
+        else
+            gSprites[gBattlerSpriteIds[gBattleAnimTarget]].coordOffsetEnabled = 1;
+    }
+}
+
+void sub_81162A4(u8 taskId)
+{
+    gTasks[taskId].data[0] = gBattleAnimArgs[0];
+    gTasks[taskId].data[1] = gBattleAnimArgs[1];
+    gTasks[taskId].data[2] = gBattleAnimArgs[2];
+    gTasks[taskId].data[3] = gBattleAnimArgs[3];
+    gTasks[taskId].data[8] = gBattleAnimArgs[3];
+    gBattle_BG3_X = gBattleAnimArgs[0];
+    gBattle_BG3_Y = gBattleAnimArgs[1];
+    gTasks[taskId].func = sub_81162F8;
+    gTasks[taskId].func(taskId);
+}
+
+static void sub_81162F8(u8 taskId)
+{
+    if (gTasks[taskId].data[3] == 0)
+    {
+        if (gBattle_BG3_X == gTasks[taskId].data[0])
+            gBattle_BG3_X = -gTasks[taskId].data[0];
+        else
+            gBattle_BG3_X = gTasks[taskId].data[0];
+
+        if (gBattle_BG3_Y == -gTasks[taskId].data[1])
+            gBattle_BG3_Y = 0;
+        else
+            gBattle_BG3_Y = -gTasks[taskId].data[1];
+
+        gTasks[taskId].data[3] = gTasks[taskId].data[8];
+        if (--gTasks[taskId].data[2] == 0)
+        {
+            gBattle_BG3_X = 0;
+            gBattle_BG3_Y = 0;
+            DestroyAnimVisualTask(taskId);
+        }
+    }
+    else
+    {
+        gTasks[taskId].data[3]--;
+    }
+}
+
+void sub_8116388(struct Sprite *sprite)
+{
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
+    if (gBattleAnimArgs[2] == 0)
+        InitAnimSpritePos(sprite, 1);
+    else
+        sub_80A6980(sprite, TRUE);
+
+    sprite->callback = sub_80A67BC;
+    StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
+}
+
+static void sub_81163D0(struct Sprite *sprite)
+{
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
+    if (gBattleAnimArgs[2] == 0)
+        InitAnimSpritePos(sprite, 1);
+    else
+        sub_80A6980(sprite, TRUE);
+
+    sprite->data[0] = gBattleAnimArgs[4];
+    sprite->callback = sub_80A67BC;
+    StoreSpriteCallbackInData6(sprite, sub_810E2C8);
+}
+
+void sub_8116420(struct Sprite *sprite)
+{
+    if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER && !IsContest())
+        gBattleAnimArgs[1] = -gBattleAnimArgs[1];
+    
+    sub_8116388(sprite);
+}
+
+void sub_8116458(struct Sprite *sprite)
+{
+    if (gBattleAnimArgs[1] == -1)
+        gBattleAnimArgs[1] = Random2() & 3;
+
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[1]);
+    if (gBattleAnimArgs[0] == 0)
+        InitAnimSpritePos(sprite, 0);
+    else
+        sub_80A6980(sprite, FALSE);
+
+    sprite->pos2.x += (Random2() % 48) - 24;
+    sprite->pos2.y += (Random2() % 24) - 12;
+
+    StoreSpriteCallbackInData6(sprite, move_anim_8074EE0);
+    sprite->callback = sub_80A67BC;
+}
+
+void sub_81164F0(struct Sprite *sprite)
+{
+    sprite->data[0] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]);
+    sprite->pos1.x = gSprites[sprite->data[0]].pos1.x + gSprites[sprite->data[0]].pos2.x;
+    sprite->pos1.y = gSprites[sprite->data[0]].pos1.y + gSprites[sprite->data[0]].pos2.y;
+    sprite->pos2.x = gBattleAnimArgs[1];
+    sprite->pos2.y = gBattleAnimArgs[2];
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
+    StoreSpriteCallbackInData6(sprite, move_anim_8074EE0);
+    sprite->callback = sub_80A67BC;
+}
+
+void sub_8116560(struct Sprite *sprite)
+{
+    if (gBattleAnimArgs[2] == 0)
+        InitAnimSpritePos(sprite, 1);
+    else
+        sub_80A6980(sprite, TRUE);
+
+    sprite->data[0] = gBattleAnimArgs[3];
+    StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
+    sprite->callback = WaitAnimForDuration;
+}
+
+void sub_81165A8(struct Sprite *sprite)
+{
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
+    if (gBattleAnimArgs[2] == 0)
+        InitAnimSpritePos(sprite, 1);
+    else
+        sub_80A6980(sprite, TRUE);
+
+    sprite->callback = sub_81165E4;
+}
+
+static void sub_81165E4(struct Sprite *sprite)
+{
+    sprite->invisible ^= 1;
+    if (sprite->data[0]++ > 12)
+        DestroyAnimSprite(sprite);
+}