Merge pull request #7 from pret/master

merging from source repo

3 files changed, 2528 insertions, 93 deletions

diff --git a/src/battle/anim/ghost.c b/src/battle/anim/ghost.c
index 85879c86c..52d9c7e72 100644
--- a/src/battle/anim/ghost.c
+++ b/src/battle/anim/ghost.c
@@ -1,35 +1,53 @@
 #include "global.h"
+#include "battle.h"
+#include "battle_anim.h"
+#include "blend_palette.h"
+#include "palette.h"
+#include "rom_8077ABC.h"
+#include "scanline_effect.h"
 #include "sound.h"
-#include "constants/songs.h"
 #include "trig.h"
-#include "rom_8077ABC.h"
-#include "battle_anim.h"
+#include "constants/battle_constants.h"
+#include "constants/songs.h"
 
 extern s16 gBattleAnimArgs[];
+extern u8 gBankSpriteIds[];
 extern u8 gAnimBankAttacker;
 extern u8 gAnimBankTarget;
 extern u8 gUnknown_0202F7D2;
 
-void sub_80DDB6C(struct Sprite *sprite);
-void sub_80DDBD8(struct Sprite *);
-void sub_80DDC4C(struct Sprite *);
-void sub_80DDCC8(struct Sprite *);
-void sub_80DDD58(struct Sprite *sprite);
-void sub_80DDD78(struct Sprite *);
-void sub_80DDE7C(u8 taskId);
-void sub_80DDED0(u8 taskId);
-void sub_80DDF40(struct Sprite *sprite);
-void sub_80DDFE8(struct Sprite *);
-void sub_80DE0FC(struct Sprite *sprite);
-void sub_80DE114(struct Sprite *);
-void sub_80DE2DC(u8 taskId);
-void sub_80DE3D4(u8 taskId);
-void sub_80DE7B8(struct Sprite *sprite);
-void sub_80DEF3C(struct Sprite *sprite);
-void sub_80DF0B8(struct Sprite *sprite);
-void sub_80DF0B8(struct Sprite *sprite);
-void sub_80DF3D8(struct Sprite *sprite);
-void sub_80DF49C(struct Sprite *sprite);
+static void sub_80DDB6C(struct Sprite *sprite);
+static void sub_80DDBD8(struct Sprite *);
+static void sub_80DDC4C(struct Sprite *);
+static void sub_80DDCC8(struct Sprite *);
+static void sub_80DDD58(struct Sprite *sprite);
+static void sub_80DDD78(struct Sprite *);
+static void sub_80DDE7C(u8 taskId);
+static void sub_80DDED0(u8 taskId);
+static void sub_80DDF40(struct Sprite *sprite);
+static void sub_80DDFE8(struct Sprite *);
+static void sub_80DE0FC(struct Sprite *sprite);
+static void sub_80DE114(struct Sprite *);
+static void sub_80DE2DC(u8 taskId);
+static void sub_80DE3D4(u8 taskId);
+static void sub_80DE7B8(struct Sprite *sprite);
+static void sub_80DEF3C(struct Sprite *sprite);
+static void sub_80DF0B8(struct Sprite *sprite);
+static void sub_80DF3D8(struct Sprite *sprite);
+static void sub_80DF49C(struct Sprite *sprite);
+static void sub_80DE61C(u8 taskId);
+static void sub_80DE6B0(u8 taskId);
+static void sub_80DE8D8(struct Sprite *sprite);
+static void sub_80DEB38(u8 taskId);
+static void sub_80DED60(u8 taskId);
+static void sub_80DEEE8(u8 taskId);
+static void sub_80DEF98(struct Sprite *sprite);
+static void sub_80DF018(struct Sprite *sprite);
+static void sub_80DF090(struct Sprite *sprite);
+static void sub_80DF18C(struct Sprite *sprite);
+static void sub_80DF24C(u8 taskId);
+static void sub_80DF4F4(struct Sprite *sprite);
+
 
 const union AffineAnimCmd gSpriteAffineAnim_83DAE48[] =
 {
@@ -204,7 +222,7 @@ const struct SpriteTemplate gSpriteTemplate_83DAF98 =
     .callback = sub_80DF49C,
 };
 
-void sub_80DDB6C(struct Sprite *sprite)
+static void sub_80DDB6C(struct Sprite *sprite)
 {
     InitAnimSpritePos(sprite, 1);
     sprite->data[0] = gBattleAnimArgs[2];
@@ -219,7 +237,7 @@ void sub_80DDB6C(struct Sprite *sprite)
     REG_BLDALPHA = sprite->data[6];
 }
 
-void sub_80DDBD8(struct Sprite *sprite)
+static void sub_80DDBD8(struct Sprite *sprite)
 {
     s16 r0;
     s16 r2;
@@ -229,6 +247,7 @@ void sub_80DDBD8(struct Sprite *sprite)
         sprite->callback = sub_80DDC4C;
         return;
     }
+
     sprite->pos2.x += Sin(sprite->data[5], 10);
     sprite->pos2.y += Cos(sprite->data[5], 15);
     r2 = sprite->data[5];
@@ -241,24 +260,26 @@ void sub_80DDBD8(struct Sprite *sprite)
     PlaySE12WithPanning(SE_W109, gUnknown_0202F7D2);
 }
 
-void sub_80DDC4C(struct Sprite *sprite)
+static void sub_80DDC4C(struct Sprite *sprite)
 {
     s16 r2;
     s16 r0;
     sprite->data[0] = 1;
     TranslateAnimSpriteByDeltas(sprite);
-    sprite->pos2.x += Sin(sprite->data[5],10);
-    sprite->pos2.y += Cos(sprite->data[5],15);
+    sprite->pos2.x += Sin(sprite->data[5], 10);
+    sprite->pos2.y += Cos(sprite->data[5], 15);
     
     r2 = sprite->data[5];
     sprite->data[5] = (sprite->data[5] + 5) & 0xFF;
     r0 = sprite->data[5];
     
-    if(r2 == 0 || r2 > 196)
-        if(r0 > 0)
+    if (r2 == 0 || r2 > 196)
+    {
+        if (r0 > 0)
             PlaySE(SE_W109);
+    }
     
-    if(sprite->data[6] == 0)
+    if (sprite->data[6] == 0)
     {
         sprite->invisible = TRUE; 
         sprite->callback = sub_807861C;
@@ -267,13 +288,13 @@ void sub_80DDC4C(struct Sprite *sprite)
         sub_80DDCC8(sprite);
 }
 
-void sub_80DDCC8(struct Sprite *sprite)
+static void sub_80DDCC8(struct Sprite *sprite)
 {
     
     s16 r0; 
-    if(sprite->data[6] > 0xFF)
+    if (sprite->data[6] > 0xFF)
     {
-        if(++sprite->data[6] == 0x10d)
+        if (++sprite->data[6] == 0x10d)
             sprite->data[6] = 0;
         return;
     }
@@ -281,32 +302,30 @@ void sub_80DDCC8(struct Sprite *sprite)
     r0 = sprite->data[7];
     sprite->data[7]++;
     
-    if((r0 & 0xFF) == 0)
+    if ((r0 & 0xFF) == 0)
     {
         sprite->data[7] &= 0xff00;
-        if((sprite->data[7] & 0x100) != 0)
+        if ((sprite->data[7] & 0x100) != 0)
             sprite->data[6]++;
         else
             sprite->data[6]--;
+
+        REG_BLDALPHA = BLDALPHA_BLEND(sprite->data[6], 16 - sprite->data[6]);
+        if (sprite->data[6] == 0 || sprite->data[6] == 16)
+            sprite->data[7] ^= 0x100;
+        if (sprite->data[6] == 0)
+            sprite->data[6] = 0x100;
     }
-    else
-        return;
-    
-    REG_BLDALPHA = BLDALPHA_BLEND(sprite->data[6], 16 - sprite->data[6]);
-    if(sprite->data[6] == 0 || sprite->data[6] == 16)
-        sprite->data[7] ^= 0x100;
-    if(sprite->data[6] == 0)
-        sprite->data[6] = 0x100;
 }
 
-void sub_80DDD58(struct Sprite *sprite)
+static void sub_80DDD58(struct Sprite *sprite)
 {
     sub_8078764(sprite, 1);
     sprite->callback = sub_80DDD78;
     sub_80DDD78(sprite);
 }
 
-void sub_80DDD78(struct Sprite *sprite)
+static void sub_80DDD78(struct Sprite *sprite)
 {
     u16 temp1;
     sprite->pos2.x = Sin(sprite->data[0], 32);
@@ -340,7 +359,7 @@ void sub_80DDDF0(u8 taskId)
     gTasks[taskId].func = sub_80DDE7C;
 }
 
-void sub_80DDE7C(u8 taskId)
+static void sub_80DDE7C(u8 taskId)
 {
     gTasks[taskId].data[10] += 1;
     if (gTasks[taskId].data[10] == 3)
@@ -351,11 +370,12 @@ void sub_80DDE7C(u8 taskId)
         REG_BLDALPHA = gTasks[taskId].data[3] << 8 | gTasks[taskId].data[2];
         if (gTasks[taskId].data[2] != 9)
             return;
+
         gTasks[taskId].func = sub_80DDED0;
     }
 }
 
-void sub_80DDED0(u8 taskId)
+static void sub_80DDED0(u8 taskId)
 {
     u8 spriteId;
     if (gTasks[taskId].data[1] > 0)
@@ -363,20 +383,23 @@ void sub_80DDED0(u8 taskId)
         gTasks[taskId].data[1] -= 1;
         return;
     }
+
     spriteId = GetAnimBattlerSpriteId(0);
     gTasks[taskId].data[0] += 8;
     if (gTasks[taskId].data[0] <= 0xFF)
     {
         obj_id_set_rotscale(spriteId, gTasks[taskId].data[0], gTasks[taskId].data[0], 0);
-        return;
     }
-    sub_8078F40(spriteId);
-    DestroyAnimVisualTask(taskId);
-    REG_BLDCNT = 0;
-    REG_BLDALPHA = 0;
+    else
+    {
+        sub_8078F40(spriteId);
+        DestroyAnimVisualTask(taskId);
+        REG_BLDCNT = 0;
+        REG_BLDALPHA = 0;
+    }
 }
 
-void sub_80DDF40(struct Sprite *sprite)
+static void sub_80DDF40(struct Sprite *sprite)
 {
     u16 r5, r6;
     r5 = sprite->pos1.x;
@@ -394,7 +417,7 @@ void sub_80DDF40(struct Sprite *sprite)
     sprite->callback = sub_80DDFE8;
 }
 
-void sub_80DDFE8(struct Sprite *sprite)
+static void sub_80DDFE8(struct Sprite *sprite)
 {
     switch (sprite->data[0])
     {
@@ -438,7 +461,7 @@ void sub_80DDFE8(struct Sprite *sprite)
     }
 }
 
-void sub_80DE0FC(struct Sprite *sprite)
+static void sub_80DE0FC(struct Sprite *sprite)
 {
     sub_8078764(sprite, 1);
     sprite->callback = sub_80DE114;
@@ -446,7 +469,7 @@ void sub_80DE0FC(struct Sprite *sprite)
 
 /* NONMATCHING */
 NAKED
-void sub_80DE114(struct Sprite *sprite)
+static void sub_80DE114(struct Sprite *sprite)
 {
     asm_unified("\tpush {r4-r6,lr}\n"
                 "\tadds r3, r0, 0\n"
@@ -570,7 +593,7 @@ void sub_80DE1B0(u8 taskId)
     task->func = sub_80DE2DC;
 }
 
-void sub_80DE2DC(u8 taskId)
+static void sub_80DE2DC(u8 taskId)
 {
     struct Task *task;
 
@@ -613,5 +636,735 @@ void sub_80DE3AC(u8 taskId)
     task = &gTasks[taskId];
     task->data[15] = 0;
     task->func = sub_80DE3D4;
-    sub_80DE3D4(taskId);
+    task->func(taskId);
+}
+
+static void sub_80DE3D4(u8 taskId)
+{
+    s16 startLine;
+    struct Task *task = &gTasks[taskId];
+    u8 position = GetBattlerPosition_permutated(gAnimBankTarget);
+
+    switch (task->data[15])
+    {
+    case 0:
+        task->data[14] = AllocSpritePalette(0x2771);
+        if (task->data[14] == 0xFF)
+        {
+            DestroyAnimVisualTask(taskId);
+        }
+        else
+        {
+            task->data[0] = duplicate_obj_of_side_rel2move_in_transparent_mode(1);
+            if (task->data[0] < 0)
+            {
+                FreeSpritePaletteByTag(0x2771);
+                DestroyAnimVisualTask(taskId);
+            }
+            else
+            {
+                gSprites[task->data[0]].oam.paletteNum = task->data[14];
+                gSprites[task->data[0]].oam.objMode = ST_OAM_OBJ_NORMAL;
+                gSprites[task->data[0]].oam.priority = 3;
+                task->data[1] = 0;
+                task->data[2] = 0;
+                task->data[3] = 16;
+                task->data[13] = GetAnimBattlerSpriteId(1);
+                task->data[4] = (gSprites[task->data[13]].oam.paletteNum + 16) * 16;
+                if (position == 1)
+                    REG_DISPCNT &= 0xFDFF;
+                else
+                    REG_DISPCNT &= 0xFBFF;
+
+                task->data[15]++;
+            }
+        }
+        break;
+    case 1:
+        task->data[14] = (task->data[14] + 16) * 16;
+        CpuSet(&gPlttBufferUnfaded[task->data[4]], &gPlttBufferFaded[task->data[14]], 0x4000008);
+        BlendPalette(task->data[4], 16, 10, RGB(13, 0, 15));
+        task->data[15]++;
+        break;
+    case 2:
+        startLine = gSprites[task->data[13]].pos1.y + gSprites[task->data[13]].pos2.y - 32;
+        if (startLine < 0)
+            startLine = 0;
+
+        if (position == 1)
+            task->data[10] = ScanlineEffect_InitWave(startLine, startLine + 64, 2, 6, 0, 4, 1);
+        else
+            task->data[10] = ScanlineEffect_InitWave(startLine, startLine + 64, 2, 6, 0, 8, 1);
+
+        task->data[15]++;
+        break;
+    case 3:
+        if (position == 1)
+            REG_BLDCNT = 0x3F42;
+        else
+            REG_BLDCNT = 0x3F44;
+
+        REG_BLDALPHA = 0x1000;
+        task->data[15]++;
+        break;
+    case 4:
+        if (position == 1)
+            REG_DISPCNT |= DISPCNT_BG1_ON;
+        else
+            REG_DISPCNT |= DISPCNT_BG2_ON;
+
+        task->func = sub_80DE61C;
+        task->data[15]++;
+        break;
+    default:
+        task->data[15]++;
+        break;
+    }
+}
+
+static void sub_80DE61C(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+    task->data[1]++;
+    task->data[5] = task->data[1] & 1;
+    if (task->data[5] == 0)
+        task->data[2] = gSineTable[task->data[1]] / 18;
+
+    if (task->data[5] == 1)
+        task->data[3] = 16 - (gSineTable[task->data[1]] / 18);
+
+    REG_BLDALPHA = (task->data[3] << 8) | task->data[2];
+    if (task->data[1] == 128)
+    {
+        task->data[15] = 0;
+        task->func = sub_80DE6B0;
+        task->func(taskId);
+    }
+}
+
+static void sub_80DE6B0(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+    u8 position = GetBattlerPosition_permutated(gAnimBankTarget);
+
+    switch (task->data[15])
+    {
+    case 0:
+        gScanlineEffect.state = 3;
+        task->data[14] = GetAnimBattlerSpriteId(1);
+        if (position == 1)
+            REG_DISPCNT &= 0xFDFF;
+        else
+            REG_DISPCNT &= 0xFBFF;
+        break;
+    case 1:
+        BlendPalette(task->data[4], 16, 0, RGB(13, 0, 15));
+        break;
+    case 2:
+        gSprites[task->data[14]].invisible = 1;
+        obj_delete_but_dont_free_vram(&gSprites[task->data[0]]);
+        FreeSpritePaletteByTag(0x2771);
+        REG_BLDCNT = 0;
+        REG_BLDALPHA = 0;
+        if (position == 1)
+            REG_DISPCNT |= DISPCNT_BG1_ON;
+        else
+            REG_DISPCNT |= DISPCNT_BG2_ON;
+
+        DestroyAnimVisualTask(taskId);
+        break;
+    }
+
+    task->data[15]++;
+}
+
+static void sub_80DE7B8(struct Sprite *sprite)
+{
+    s16 battler1X, battler1Y;
+    s16 battler2X, battler2Y;
+    s16 yDiff;
+
+    if (gBattleAnimArgs[0] == 0)
+    {
+        battler1X = GetBattlerSpriteCoord(gAnimBankAttacker, 0);
+        battler1Y = GetBattlerSpriteCoord(gAnimBankAttacker, 1) + 28;
+        battler2X = GetBattlerSpriteCoord(gAnimBankTarget, 0);
+        battler2Y = GetBattlerSpriteCoord(gAnimBankTarget, 1) + 28;
+    }
+    else
+    {
+        battler1X = GetBattlerSpriteCoord(gAnimBankTarget, 0);
+        battler1Y = GetBattlerSpriteCoord(gAnimBankTarget, 1) + 28;
+        battler2X = GetBattlerSpriteCoord(gAnimBankAttacker, 0);
+        battler2Y = GetBattlerSpriteCoord(gAnimBankAttacker, 1) + 28;
+    }
+
+    yDiff = battler2Y - battler1Y;
+    sprite->data[0] = battler1X * 16;
+    sprite->data[1] = battler1Y * 16;
+    sprite->data[2] = ((battler2X - battler1X) * 16) / gBattleAnimArgs[1];
+    sprite->data[3] = (yDiff * 16) / gBattleAnimArgs[1];
+    sprite->data[4] = gBattleAnimArgs[1];
+    sprite->data[5] = battler2X;
+    sprite->data[6] = battler2Y;
+    sprite->data[7] = sprite->data[4] / 2;
+    sprite->oam.priority = 2;
+    sprite->pos1.x = battler1X;
+    sprite->pos1.y = battler1Y;
+    sprite->callback = sub_80DE8D8;
+    sprite->invisible = 1;
+}
+
+static void sub_80DE8D8(struct Sprite *sprite)
+{
+    if (sprite->data[4])
+    {
+        sprite->data[0] += sprite->data[2];
+        sprite->data[1] += sprite->data[3];
+        sprite->pos1.x = sprite->data[0] >> 4;
+        sprite->pos1.y = sprite->data[1] >> 4;
+        if (--sprite->data[4] == 0)
+            sprite->data[0] = 0;
+    }
+}
+
+void sub_80DE918(u8 taskId)
+{
+    struct Task *task;
+    s16 battler;
+    u8 spriteId;
+    s16 baseX, baseY;
+    s16 x, y;
+
+    task = &gTasks[taskId];
+    REG_BLDCNT = 0x3F40;
+    REG_BLDALPHA = 0x1000;
+    task->data[5] = 0;
+    task->data[6] = 0;
+    task->data[7] = 0;
+    task->data[8] = 0;
+    task->data[9] = 16;
+    task->data[10] = gBattleAnimArgs[0];
+
+    baseX = GetBattlerSpriteCoord(gAnimBankAttacker, 2);
+    baseY = sub_807A100(gAnimBankAttacker, 3);
+    if (!IsContest())
+    {
+        for (battler = 0; battler < 4; battler++)
+        {
+            if (battler != gAnimBankAttacker
+             && battler != (gAnimBankAttacker ^ 2)
+             && IsAnimBankSpriteVisible(battler))
+            {
+                spriteId = CreateSprite(&gSpriteTemplate_83DAF08, baseX, baseY, 55);
+                if (spriteId != MAX_SPRITES)
+                {
+                    x = GetBattlerSpriteCoord(battler, 2);
+                    y = sub_807A100(battler, 3);
+                    gSprites[spriteId].data[0] = baseX << 4;
+                    gSprites[spriteId].data[1] = baseY << 4;
+                    gSprites[spriteId].data[2] = ((x - baseX) << 4) / gBattleAnimArgs[1];
+                    gSprites[spriteId].data[3] = ((y - baseY) << 4) / gBattleAnimArgs[1];
+                    gSprites[spriteId].data[4] = gBattleAnimArgs[1];
+                    gSprites[spriteId].data[5] = x;
+                    gSprites[spriteId].data[6] = y;
+                    gSprites[spriteId].callback = sub_80DE8D8;
+
+                    task->data[task->data[12] + 13] = spriteId;
+                    task->data[12]++;
+                }
+            }
+        }
+    }
+    else
+    {
+        spriteId = CreateSprite(&gSpriteTemplate_83DAF08, baseX, baseY, 55);
+        if (spriteId != MAX_SPRITES)
+        {
+            x = 48;
+            y = 40;
+            gSprites[spriteId].data[0] = baseX << 4;
+            gSprites[spriteId].data[1] = baseY << 4;
+            gSprites[spriteId].data[2] = ((x - baseX) << 4) / gBattleAnimArgs[1];
+            gSprites[spriteId].data[3] = ((y - baseY) << 4) / gBattleAnimArgs[1];
+            gSprites[spriteId].data[4] = gBattleAnimArgs[1];
+            gSprites[spriteId].data[5] = x;
+            gSprites[spriteId].data[6] = y;
+            gSprites[spriteId].callback = sub_80DE8D8;
+
+            task->data[13] = spriteId;
+            task->data[12] = 1;
+        }
+    }
+
+    task->func = sub_80DEB38;
+}
+
+static void sub_80DEB38(u8 taskId)
+{
+    u16 i;
+    struct Task *task = &gTasks[taskId];
+
+    switch (task->data[0])
+    {
+    case 0:
+        if (task->data[6] == 0)
+        {
+            if (++task->data[5] > 1)
+            {
+                task->data[5] = 0;
+                task->data[7]++;
+                if (task->data[7] & 1)
+                {
+                    if (task->data[8] < 16)
+                        task->data[8]++;
+                }
+                else
+                {
+                    if (task->data[9])
+                        task->data[9]--;
+                }
+
+                REG_BLDALPHA = (task->data[9] << 8) | task->data[8];
+                if (task->data[7] >= 24)
+                {
+                    task->data[7] = 0;
+                    task->data[6] = 1;
+                }
+            }
+        }
+        
+        if (task->data[10])
+            task->data[10]--;
+        else if (task->data[6])
+            task->data[0]++;
+        break;
+    case 1:
+        if (++task->data[5] > 1)
+        {
+            task->data[5] = 0;
+            task->data[7]++;
+            if (task->data[7] & 1)
+            {
+                if (task->data[8])
+                    task->data[8]--;
+            }
+            else
+            {
+                if (task->data[9] < 16)
+                    task->data[9]++;
+            }
+
+            REG_BLDALPHA = (task->data[9] << 8) | task->data[8];
+            if (task->data[8] == 0 && task->data[9] == 16)
+            {
+                for (i = 0; i < task->data[12]; i++)
+                    DestroySprite(&gSprites[task->data[i + 13]]);
+
+                task->data[0]++;
+            }
+        }
+        break;
+    case 2:
+        if (++task->data[5] > 0)
+            task->data[0]++;
+        break;
+    case 3:
+        REG_BLDCNT = 0;
+        REG_BLDALPHA = 0;
+        DestroyAnimVisualTask(taskId);
+        break;
+    }
+}
+
+void sub_80DECB0(u8 taskId)
+{
+    s16 startX, startY;
+    s16 leftDistance, topDistance, bottomDistance, rightDistance;
+
+    gBattle_WIN0H = 0;
+    gBattle_WIN0V = 0;
+    REG_WININ = 0x3F3F;
+    REG_WINOUT = 0x3F1F;
+    REG_BLDCNT = 0xC8;
+    REG_BLDY = 0x10;
+
+    if (GetBattlerSide(gAnimBankAttacker) != B_SIDE_PLAYER || IsContest())
+        startX = 40;
+    else
+        startX = 200;
+
+    gBattle_WIN0H = (startX << 8) | startX;
+    startY = 40;
+    gBattle_WIN0V = (startY << 8) | startY;
+
+    leftDistance = startX;
+    rightDistance = 240 - startX;
+    topDistance = startY;
+    bottomDistance = 72;
+    gTasks[taskId].data[1] = leftDistance;
+    gTasks[taskId].data[2] = rightDistance;
+    gTasks[taskId].data[3] = topDistance;
+    gTasks[taskId].data[4] = bottomDistance;
+    gTasks[taskId].data[5] = startX;
+    gTasks[taskId].data[6] = startY;
+    gTasks[taskId].func = sub_80DED60;
+}
+
+static void sub_80DED60(u8 taskId)
+{
+    s16 step;
+    s16 leftDistance, rightDistance, topDistance, bottomDistance;
+    s16 startX, startY;
+    u16 left, right, top, bottom;
+    u16 selectedPalettes;
+
+    step = gTasks[taskId].data[0];
+    gTasks[taskId].data[0]++;
+    leftDistance = gTasks[taskId].data[1];
+    rightDistance = gTasks[taskId].data[2];
+    topDistance = gTasks[taskId].data[3];
+    bottomDistance = gTasks[taskId].data[4];
+    startX = gTasks[taskId].data[5];
+    startY = gTasks[taskId].data[6];
+
+    if (step < 16)
+    {
+        left   = startX - (leftDistance   * 0.0625) * step;
+        right  = startX + (rightDistance  * 0.0625) * step;
+        top    = startY - (topDistance    * 0.0625) * step;
+        bottom = startY + (bottomDistance * 0.0625) * step;
+    }
+    else
+    {
+        left = 0;
+        right = 240;
+        top = 0;
+        bottom = 112;
+        selectedPalettes = sub_80791A8(1, 0, 0, 0, 0, 0, 0);
+        BeginNormalPaletteFade(selectedPalettes, 0, 16, 16, RGB(0, 0, 0));
+        gTasks[taskId].func = sub_80DEEE8;
+    }
+
+    gBattle_WIN0H = (left << 8) | right;
+    gBattle_WIN0V = (top  << 8) | bottom;
+}
+
+static void sub_80DEEE8(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        gBattle_WIN0H = 0;
+        gBattle_WIN0V = 0;
+        REG_WININ = 0x3F3F;
+        REG_WINOUT = 0x3F3F;
+        REG_BLDCNT = 0;
+        REG_BLDY = 0;
+        DestroyAnimVisualTask(taskId);
+    }
+}
+
+static void sub_80DEF3C(struct Sprite *sprite)
+{
+    s16 xDelta;
+    s16 xDelta2;
+
+    InitAnimSpritePos(sprite, 1);
+    if (GetBattlerSide(gAnimBankAttacker) == B_SIDE_PLAYER)
+    {
+        xDelta = 24;
+        xDelta2 = -2;
+        sprite->oam.matrixNum = 8;
+    }
+    else
+    {
+        xDelta = -24;
+        xDelta2 = 2;
+    }
+
+    sprite->pos1.x += xDelta;
+    sprite->data[1] = xDelta2;
+    sprite->data[0] = 60;
+    sprite->callback = sub_80DEF98;
+}
+
+static void sub_80DEF98(struct Sprite *sprite)
+{
+    u16 var0;
+
+    if (sprite->data[0] > 0)
+    {
+        sprite->data[0]--;
+    }
+    else
+    {
+        sprite->pos2.x += sprite->data[1];
+        var0 = sprite->pos2.x + 7;
+        if (var0 > 14)
+        {
+            sprite->pos1.x += sprite->pos2.x;
+            sprite->pos2.x = 0;
+            sprite->oam.tileNum += 8;
+            if (++sprite->data[2] == 3)
+            {
+                sprite->data[0] = 30;
+                sprite->callback = WaitAnimForDuration;
+                StoreSpriteCallbackInData(sprite, sub_80DF018);
+            }
+            else
+            {
+                sprite->data[0] = 40;
+            }
+        }
+    }
+}
+
+static void sub_80DF018(struct Sprite *sprite)
+{
+    if (sprite->data[0] == 0)
+    {
+        REG_BLDCNT = 0x3F40;
+        REG_BLDALPHA = 0x0010;
+        sprite->data[0]++;
+        sprite->data[1] = 0;
+        sprite->data[2] = 0;
+    }
+    else if (sprite->data[1] < 2)
+    {
+        sprite->data[1]++;
+    }
+    else
+    {
+        sprite->data[1] = 0;
+        sprite->data[2]++;
+        REG_BLDALPHA = (16 - sprite->data[2]) | (sprite->data[2] << 8);
+        if (sprite->data[2] == 16)
+        {
+            sprite->invisible = 1;
+            sprite->callback = sub_80DF090;
+        }
+    }
+}
+
+static void sub_80DF090(struct Sprite *sprite)
+{
+    REG_BLDCNT = 0;
+    REG_BLDALPHA = 0;
+    gBattle_WIN0H = 0;
+    gBattle_WIN0V = 0;
+    DestroyAnimSprite(sprite);
+}
+
+static void sub_80DF0B8(struct Sprite *sprite)
+{
+    u16 coeffB;
+    u16 coeffA;
+
+    sprite->pos2.x = Sin(sprite->data[0], 12);
+    if (GetBattlerSide(gAnimBankAttacker) != B_SIDE_PLAYER)
+        sprite->pos2.x = -sprite->pos2.x;
+    
+    sprite->data[0] = (sprite->data[0] + 6) & 0xFF;
+    sprite->data[1] += 0x100;
+    sprite->pos2.y = -(sprite->data[1] >> 8);
+
+    sprite->data[7]++;
+    if (sprite->data[7] == 1)
+    {
+        sprite->data[6] = 0x050B;
+        REG_BLDCNT = 0x3F40;
+        REG_BLDALPHA = sprite->data[6];
+    }
+    else if (sprite->data[7] > 30)
+    {
+        sprite->data[2]++;
+        coeffB = sprite->data[6] >> 8;
+        coeffA = sprite->data[6] & 0xFF;
+
+        if (++coeffB > 16)
+            coeffB = 16;
+        if (--(s16)coeffA < 0)
+            coeffA = 0;
+
+        REG_BLDALPHA = (coeffB << 8) | coeffA;
+        sprite->data[6] = (coeffB << 8) | coeffA;
+        if (coeffB == 16 && coeffA == 0)
+        {
+            sprite->invisible = 1;
+            sprite->callback = sub_80DF18C;
+        }
+    }
+}
+
+static void sub_80DF18C(struct Sprite *sprite)
+{
+    REG_BLDCNT = 0;
+    REG_BLDALPHA = 0;
+    DestroyAnimSprite(sprite);
+}
+
+void sub_80DF1A4(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+
+    task->data[0] = 0;
+    task->data[1] = 16;
+    task->data[9] = GetBattlerSpriteCoord(gAnimBankAttacker, 2);
+    task->data[10] = sub_8077FC0(gAnimBankAttacker);
+    task->data[11] = (sub_807A100(gAnimBankAttacker, 1) / 2) + 8;
+    task->data[7] = 0;
+    task->data[5] = sub_8079ED4(gAnimBankAttacker);
+    task->data[6] = sub_8079E90(gAnimBankAttacker) - 2;
+    task->data[3] = 0;
+    task->data[4] = 16;
+    REG_BLDCNT = 0x3F40;
+    REG_BLDALPHA = 0x1000;
+    task->data[8] = 0;
+    task->func = sub_80DF24C;
+}
+
+static void sub_80DF24C(u8 taskId)
+{
+    u16 i;
+    u8 spriteId;
+    struct Task *task = &gTasks[taskId];
+
+    switch (task->data[0])
+    {
+    case 0:
+        for (i = 0; i < 6; i++)
+        {
+            spriteId = CreateSprite(&gSpriteTemplate_83DAF80, task->data[9], task->data[10], task->data[6]);
+            if (spriteId != MAX_SPRITES)
+            {
+                gSprites[spriteId].data[0] = taskId;
+                gSprites[spriteId].data[1] = GetBattlerSide(gAnimBankAttacker) == B_SIDE_PLAYER;
+
+                gSprites[spriteId].data[2] = (i * 42) & 0xFF;
+                gSprites[spriteId].data[3] = task->data[11];
+                gSprites[spriteId].data[5] = i * 6;
+                task->data[7]++;
+            }
+        }
+
+        task->data[0]++;
+        break;
+    case 1:
+        if (++task->data[1] & 1)
+        {
+            if (task->data[3] < 14)
+                task->data[3]++;
+        }
+        else
+        {
+            if (task->data[4] > 4)
+                task->data[4]--;
+        }
+
+        if (task->data[3] == 14 && task->data[4] == 4)
+        {
+            task->data[1] = 0;
+            task->data[0]++;
+        }
+
+        REG_BLDALPHA = (task->data[4] << 8) | task->data[3];
+        break;
+    case 2:
+        if (++task->data[1] > 30)
+        {
+            task->data[1] = 0;
+            task->data[0]++;
+        }
+        break;
+    case 3:
+        if (++task->data[1] & 1)
+        {
+            if (task->data[3] > 0)
+                task->data[3]--;
+        }
+        else
+        {
+            if (task->data[4] < 16)
+                task->data[4]++;
+        }
+
+        if (task->data[3] == 0 && task->data[4] == 16)
+        {
+            task->data[8] = 1;
+            task->data[0]++;
+        }
+
+        REG_BLDALPHA = (task->data[4] << 8) | task->data[3];
+        break;
+    case 4:
+        if (task->data[7] == 0)
+            task->data[0]++;
+        break;
+    case 5:
+        REG_BLDCNT = 0;
+        REG_BLDALPHA = 0;
+        DestroyAnimVisualTask(taskId);
+        break;
+    }
+}
+
+static void sub_80DF3D8(struct Sprite *sprite)
+{
+    u16 index;
+
+    if (sprite->data[1] == 0)
+        sprite->data[2] += 2;
+    else
+        sprite->data[2] -= 2;
+
+    sprite->data[2] &= 0xFF;
+    sprite->pos2.x = Sin(sprite->data[2], sprite->data[3]);
+
+    index = sprite->data[2] - 65;
+    if (index < 127)
+        sprite->oam.priority = gTasks[sprite->data[0]].data[5] + 1;
+    else
+        sprite->oam.priority = gTasks[sprite->data[0]].data[5];
+
+    sprite->data[5]++;
+    sprite->data[6] = (sprite->data[5] * 8) & 0xFF;
+    sprite->pos2.y = Sin(sprite->data[6], 7);
+    if (gTasks[sprite->data[0]].data[8])
+    {
+        gTasks[sprite->data[0]].data[7]--;
+        DestroySprite(sprite);
+    }
+}
+
+static void sub_80DF49C(struct Sprite *sprite)
+{
+    sprite->invisible = 1;
+    sprite->data[5] = gBankSpriteIds[gAnimBankAttacker];
+    sprite->data[0] = 128;
+    sprite->data[1] = 10;
+    sprite->data[2] = gBattleAnimArgs[0];
+    sprite->data[3] = gBattleAnimArgs[1];
+    sprite->callback = sub_80DF4F4;
+
+    gSprites[sprite->data[5]].pos1.y += 8;
+}
+
+static void sub_80DF4F4(struct Sprite *sprite)
+{
+    if (sprite->data[3])
+    {
+        sprite->data[3]--;
+        gSprites[sprite->data[5]].pos2.x = Sin(sprite->data[0], sprite->data[1]);
+        gSprites[sprite->data[5]].pos2.y = Cos(sprite->data[0], sprite->data[1]);
+        sprite->data[0] += sprite->data[2];
+        if (sprite->data[0] > 255)
+            sprite->data[0] -= 256;
+    }
+    else
+    {
+        gSprites[sprite->data[5]].pos2.x = 0;
+        gSprites[sprite->data[5]].pos2.y = 0;
+        gSprites[sprite->data[5]].pos1.y -= 8;
+        sprite->callback = move_anim_8074EE0;
+    }
 }
diff --git a/src/battle/anim/normal.c b/src/battle/anim/normal.c
index 8303e7c68..7564c529c 100644
--- a/src/battle/anim/normal.c
+++ b/src/battle/anim/normal.c
@@ -1,26 +1,89 @@
 #include "global.h"
-#include "rom_8077ABC.h"
+#include "battle.h"
 #include "battle_anim.h"
+#include "blend_palette.h"
+#include "decompress.h"
+#include "ewram.h"
+#include "palette.h"
+#include "random.h"
+#include "rom_8077ABC.h"
+#include "sound.h"
+#include "task.h"
+#include "trig.h"
+#include "constants/battle_constants.h"
+#include "constants/songs.h"
 
 extern s16 gBattleAnimArgs[];
 extern u8 gAnimBankAttacker;
 extern u8 gAnimBankTarget;
+extern u8 gHealthboxIDs[];
+extern u8 gBattlersCount;
+extern u8 gBankSpriteIds[];
+extern u8 gBattleTerrain;
+extern u16 gBattlerPartyIndexes[];
+extern u8 gBankTarget;
+extern u8 gEffectBank;
+extern u8 gBankAttacker;
+extern u8 gAnimVisualTaskCount;
+
+extern const u8 gUnknown_08D20A14[];
+extern const u8 gUnknown_08D20A30[];
+extern const u8 gBattleStatMask1_Tilemap[];
+extern const u8 gBattleStatMask2_Tilemap[];
+extern const u8 gBattleStatMask_Gfx[];
+extern const u16 gBattleStatMask1_Pal[];
+extern const u16 gBattleStatMask2_Pal[];
+extern const u16 gBattleStatMask3_Pal[];
+extern const u16 gBattleStatMask4_Pal[];
+extern const u16 gBattleStatMask5_Pal[];
+extern const u16 gBattleStatMask6_Pal[];
+extern const u16 gBattleStatMask7_Pal[];
+extern const u16 gBattleStatMask8_Pal[];
+
+extern void sub_80DA48C(struct Sprite *);
+
+static void AnimConfusionDuck(struct Sprite *sprite);
+static void AnimSimplePaletteBlend(struct Sprite *sprite);
+static void sub_80E1E2C(struct Sprite *sprite);
+static void sub_80E1F3C(struct Sprite *sprite);
+static void sub_80E24B8(struct Sprite *sprite);
+static void sub_80E27A0(struct Sprite *sprite);
+static void sub_80E2838(struct Sprite *sprite);
+static void sub_80E2870(struct Sprite *sprite);
+static void sub_80E2908(struct Sprite *sprite);
+static void sub_80E2978(struct Sprite *sprite);
+static void sub_80E29C0(struct Sprite *sprite);
+static void sub_80E27E8(struct Sprite *sprite);
+static void AnimConfusionDuckStep(struct Sprite *sprite);
+static u32 UnpackSelectedBattleAnimPalettes(s16);
+static void AnimSimplePaletteBlendStep(struct Sprite *sprite);
+static void sub_80E1E80(struct Sprite *sprite);
+static void sub_80E1F0C(struct Sprite *sprite);
+static void sub_80E1FDC(u8, u8, u8);
+static void sub_80E202C(u8 taskId);
+static void sub_80E20E4(u8, u8, u8);
+static void sub_80E2140(u8 taskId);
+static void sub_80E2214(u8 taskId);
+static void sub_80E22CC(u8 taskId);
+static void sub_80E260C(void);
+static void sub_80E255C(struct Sprite *sprite);
+static void sub_80E2710(u8 taskId);
+static void sub_80E29FC(struct Sprite *sprite);
+static void sub_80E2C8C(u8 taskId, u32 selectedPalettes);
+static void sub_80E2CD0(u8 taskId);
+static void sub_80E2DB8(u8 taskId);
+static void sub_80E2E10(u8 taskId);
+static void sub_80E2EE8(struct Sprite *sprite);
+static void sub_80E3194(u8 taskId);
+static void sub_80E3338(u8 taskId);
+static void sub_80E3704(u8 taskId);
+static void sub_80E38F8(u8 taskId);
+static void sub_80E39BC(u32, u16);
+static void sub_80E3AD0(u8 taskId);
+static void sub_80E3E64(u8 taskId);
+static void sub_80E4368(u8 taskId);
 
-void sub_80E1CB4(struct Sprite *sprite);
-void sub_80E1D84(struct Sprite *sprite);
-void sub_80E1E2C(struct Sprite *sprite);
-void sub_80E1F3C(struct Sprite *sprite);
-void sub_80E24B8(struct Sprite *sprite);
-void sub_80E27A0(struct Sprite *sprite);
-void sub_80E2838(struct Sprite *sprite);
-void sub_80E27A0(struct Sprite *sprite);
-void sub_80E2870(struct Sprite *sprite);
-void sub_80E2908(struct Sprite *sprite);
-void sub_80E2978(struct Sprite *sprite);
-void sub_80E29C0(struct Sprite *sprite);
-void sub_80E27E8(struct Sprite *sprite);
-
-const union AnimCmd gSpriteAnim_83DB37C[] =
+const union AnimCmd gConfusionDuckSpriteAnim1[] =
 {
     ANIMCMD_FRAME(0, 8),
     ANIMCMD_FRAME(4, 8),
@@ -29,7 +92,7 @@ const union AnimCmd gSpriteAnim_83DB37C[] =
     ANIMCMD_JUMP(0),
 };
 
-const union AnimCmd gSpriteAnim_83DB390[] =
+const union AnimCmd gConfusionDuckSpriteAnim2[] =
 {
     ANIMCMD_FRAME(0, 8, .hFlip = TRUE),
     ANIMCMD_FRAME(4, 8),
@@ -38,24 +101,24 @@ const union AnimCmd gSpriteAnim_83DB390[] =
     ANIMCMD_JUMP(0),
 };
 
-const union AnimCmd *const gSpriteAnimTable_83DB3A4[] =
+const union AnimCmd *const gConfusionDuckSpriteAnimTable[] =
 {
-    gSpriteAnim_83DB37C,
-    gSpriteAnim_83DB390,
+    gConfusionDuckSpriteAnim1,
+    gConfusionDuckSpriteAnim2,
 };
 
-const struct SpriteTemplate gBattleAnimSpriteTemplate_83DB3AC =
+const struct SpriteTemplate gConfusionDuckSpriteTemplate =
 {
     .tileTag = 10073,
     .paletteTag = 10073,
     .oam = &gOamData_837DF2C,
-    .anims = gSpriteAnimTable_83DB3A4,
+    .anims = gConfusionDuckSpriteAnimTable,
     .images = NULL,
     .affineAnims = gDummySpriteAffineAnimTable,
-    .callback = sub_80E1CB4,
+    .callback = AnimConfusionDuck,
 };
 
-const struct SpriteTemplate gBattleAnimSpriteTemplate_83DB3C4 =
+const struct SpriteTemplate gSimplePaletteBlendSpriteTemplate =
 {
     .tileTag = 0,
     .paletteTag = 0,
@@ -63,7 +126,7 @@ const struct SpriteTemplate gBattleAnimSpriteTemplate_83DB3C4 =
     .anims = gDummySpriteAnimTable,
     .images = NULL,
     .affineAnims = gDummySpriteAffineAnimTable,
-    .callback = sub_80E1D84,
+    .callback = AnimSimplePaletteBlend,
 };
 
 const struct SpriteTemplate gBattleAnimSpriteTemplate_83DB3DC =
@@ -238,3 +301,1631 @@ const struct SpriteTemplate gBattleAnimSpriteTemplate_83DB550 =
 };
 
 const u16 gUnknown_083DB568 = RGB(31, 31, 31);
+
+// 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
+static void AnimConfusionDuck(struct Sprite *sprite)
+{
+    sprite->pos1.x += gBattleAnimArgs[0];
+    sprite->pos1.y += gBattleAnimArgs[1];
+    sprite->data[0] = gBattleAnimArgs[2];
+    if (GetBattlerSide(gAnimBankAttacker) != 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
+static 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: gAnimBankAttacker OBJ palette
+//   2: gAnimBankTarget OBJ palette
+//   3: gAnimBankAttacker partner OBJ palette
+//   4: gAnimBankTarget partner OBJ palette
+//   5: BG palette 4
+//   6: BG palette 5
+static 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_80791A8(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+static void AnimSimplePaletteBlendStep(struct Sprite *sprite)
+{
+    if (!gPaletteFade.active)
+        DestroyAnimSprite(sprite);
+}
+
+static void sub_80E1E2C(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_80E1E80;
+}
+
+static void sub_80E1E80(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_80E1F0C;
+        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_80E1F0C(struct Sprite *sprite)
+{
+    u32 selectedPalettes;
+
+    if (!gPaletteFade.active)
+    {
+        selectedPalettes = UnpackSelectedBattleAnimPalettes(sprite->data[7]);
+        BlendPalettes(selectedPalettes, 0, 0);
+        DestroyAnimSprite(sprite);
+    }
+}
+
+static void sub_80E1F3C(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;
+    StoreSpriteCallbackInData(sprite, move_anim_8074EE0);
+    sprite->callback = sub_8078174;
+    sprite->callback(sprite);
+}
+
+void sub_80E1F8C(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_80E1FDC(taskId, 0, gTasks[taskId].data[4]);
+    gTasks[taskId].func = sub_80E202C;
+}
+
+static void sub_80E1FDC(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_80E202C(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_80E1FDC(taskId, initialBlendAmount, targetBlendAmount);
+        }
+        else
+        {
+            DestroyAnimVisualTask(taskId);
+        }
+    }
+}
+
+void sub_80E2094(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_80E20E4(taskId, 0, gTasks[taskId].data[4]);
+    gTasks[taskId].func = sub_80E2140;
+}
+
+static void sub_80E20E4(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_80E2140(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_80E20E4(taskId, initialBlendAmount, targetBlendAmount);
+        }
+        else
+        {
+            DestroyAnimVisualTask(taskId);
+        }
+    }
+}
+
+void sub_80E21A8(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_80E2214;
+}
+
+static void sub_80E2214(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_80E22CC;
+        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_80E22CC(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_80E2324(u8 taskId)
+{
+    u32 selectedPalettes = 0;
+    u8 attackerBattler = gAnimBankAttacker;
+    u8 targetBattler = gAnimBankTarget;
+
+    if (gBattleAnimArgs[0] & 0x100)
+        selectedPalettes = sub_80791A8(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 unref_sub_80E23A8(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 = gAnimBankAttacker;
+    targetBattler = gAnimBankTarget;
+
+    if (gTasks[taskId].data[2] & 0x100)
+        selectedPalettes = 0x0000FFFF;
+
+    if (gTasks[taskId].data[2] & 0x1)
+    {
+        paletteIndex = IndexOfSpritePaletteTag(gSprites[gHealthboxIDs[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);
+    }
+}
+
+static void sub_80E24B8(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:
+        StoreSpriteCallbackInData(sprite, (void *)&gBattle_BG3_X);
+        break;
+    case 1:
+        StoreSpriteCallbackInData(sprite, (void *)&gBattle_BG3_Y);
+        break;
+    case 2:
+        StoreSpriteCallbackInData(sprite, (void *)&gSpriteCoordOffsetX);
+        break;
+    default:
+        StoreSpriteCallbackInData(sprite, (void *)&gSpriteCoordOffsetY);
+        break;
+    }
+
+    sprite->data[4] = *(u32 *)(sprite->data[6] | (sprite->data[7] << 16));
+    sprite->data[5] = gBattleAnimArgs[3];
+    var0 = sprite->data[5] - 2;
+    if (var0 < 2)
+        sub_80E260C();
+
+    sprite->callback = sub_80E255C;
+}
+
+static void sub_80E255C(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];
+            *(u32 *)(sprite->data[6] | (sprite->data[7] << 16)) += sprite->data[0];
+            sprite->data[0] = -sprite->data[0];
+        }
+    }
+    else
+    {
+        *(u32 *)(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[gBankSpriteIds[i]].coordOffsetEnabled = 0;
+        }
+
+        DestroyAnimSprite(sprite);
+    }
+}
+
+static void sub_80E260C(void)
+{
+    gSprites[gBankSpriteIds[gAnimBankAttacker]].coordOffsetEnabled = 0;
+    gSprites[gBankSpriteIds[gAnimBankTarget]].coordOffsetEnabled = 0;
+
+    if (gBattleAnimArgs[4] == 2)
+    {
+        gSprites[gBankSpriteIds[gAnimBankAttacker]].coordOffsetEnabled = 1;
+        gSprites[gBankSpriteIds[gAnimBankTarget]].coordOffsetEnabled = 1;
+    }
+    else
+    {
+        if (gBattleAnimArgs[4] == 0)
+            gSprites[gBankSpriteIds[gAnimBankAttacker]].coordOffsetEnabled = 1;
+        else
+            gSprites[gBankSpriteIds[gAnimBankTarget]].coordOffsetEnabled = 1;
+    }
+}
+
+void sub_80E26BC(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_80E2710;
+    gTasks[taskId].func(taskId);
+}
+
+static void sub_80E2710(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]--;
+    }
+}
+
+static void sub_80E27A0(struct Sprite *sprite)
+{
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
+    if (gBattleAnimArgs[2] == 0)
+        InitAnimSpritePos(sprite, 1);
+    else
+        sub_8078764(sprite, 1);
+
+    sprite->callback = sub_80785E4;
+    StoreSpriteCallbackInData(sprite, DestroyAnimSprite);
+}
+
+static void sub_80E27E8(struct Sprite *sprite)
+{
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
+    if (gBattleAnimArgs[2] == 0)
+        InitAnimSpritePos(sprite, 1);
+    else
+        sub_8078764(sprite, 1);
+
+    sprite->data[0] = gBattleAnimArgs[4];
+    sprite->callback = sub_80785E4;
+    StoreSpriteCallbackInData(sprite, sub_80DA48C);
+}
+
+static void sub_80E2838(struct Sprite *sprite)
+{
+    if (GetBattlerSide(gAnimBankAttacker) != B_SIDE_PLAYER && !IsContest())
+        gBattleAnimArgs[1] = -gBattleAnimArgs[1];
+    
+    sub_80E27A0(sprite);
+}
+
+static void sub_80E2870(struct Sprite *sprite)
+{
+    if (gBattleAnimArgs[1] == -1)
+        gBattleAnimArgs[1] = Random() & 3;
+
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[1]);
+    if (gBattleAnimArgs[0] == 0)
+        InitAnimSpritePos(sprite, 0);
+    else
+        sub_8078764(sprite, 0);
+
+    sprite->pos2.x += (Random() % 48) - 24;
+    sprite->pos2.y += (Random() % 24) - 12;
+
+    StoreSpriteCallbackInData(sprite, move_anim_8074EE0);
+    sprite->callback = sub_80785E4;
+}
+
+static void sub_80E2908(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]);
+    StoreSpriteCallbackInData(sprite, move_anim_8074EE0);
+    sprite->callback = sub_80785E4;
+}
+
+static void sub_80E2978(struct Sprite *sprite)
+{
+    if (gBattleAnimArgs[2] == 0)
+        InitAnimSpritePos(sprite, 1);
+    else
+        sub_8078764(sprite, 1);
+
+    sprite->data[0] = gBattleAnimArgs[3];
+    StoreSpriteCallbackInData(sprite, DestroyAnimSprite);
+    sprite->callback = WaitAnimForDuration;
+}
+
+static void sub_80E29C0(struct Sprite *sprite)
+{
+    StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
+    if (gBattleAnimArgs[2] == 0)
+        InitAnimSpritePos(sprite, 1);
+    else
+        sub_8078764(sprite, 1);
+
+    sprite->callback = sub_80E29FC;
+}
+
+static void sub_80E29FC(struct Sprite *sprite)
+{
+    sprite->invisible ^= 1;
+    if (sprite->data[0]++ > 12)
+        DestroyAnimSprite(sprite);
+}
+
+void sub_80E2A38(u8 taskId)
+{
+    u32 selectedPalettes = UnpackSelectedBattleAnimPalettes(gBattleAnimArgs[0]);
+    selectedPalettes |= sub_80792C0(
+        (gBattleAnimArgs[0] >> 7)  & 1,
+        (gBattleAnimArgs[0] >> 8)  & 1,
+        (gBattleAnimArgs[0] >> 9)  & 1,
+        (gBattleAnimArgs[0] >> 10) & 1);
+
+    sub_80E2C8C(taskId, selectedPalettes);
+}
+
+void sub_80E2A7C(u8 taskId)
+{
+    u8 battler;
+    u32 selectedPalettes;
+    u8 sp[2];
+
+    sp[1] = 0xFF;
+    selectedPalettes = UnpackSelectedBattleAnimPalettes(1);
+    switch (gBattleAnimArgs[0])
+    {
+    case 2:
+        selectedPalettes = 0;
+        // fall through
+    case 0:
+        sp[0] = gAnimBankAttacker;
+        break;
+    case 3:
+        selectedPalettes = 0;
+        // fall through
+    case 1:
+        sp[0] = gAnimBankTarget;
+        break;
+    case 4:
+        sp[0] = gAnimBankAttacker;
+        sp[1] = gAnimBankTarget;
+        break;
+    case 5:
+        sp[0] = 0xFF;
+        break;
+    case 6:
+        selectedPalettes = 0;
+        sp[0] = gAnimBankAttacker ^ 2;
+        break;
+    case 7:
+        selectedPalettes = 0;
+        sp[0] = gAnimBankTarget ^ 2;
+        break;
+    }
+
+    for (battler = 0; battler < 4; battler++)
+    {
+        if (battler != sp[0] && battler != sp[1] && IsAnimBankSpriteVisible(battler))
+        {
+            u8 paletteIndex = sub_80793A8(battler);
+            selectedPalettes |= (0x10000 << paletteIndex);
+        }
+    }
+
+    sub_80E2C8C(taskId, selectedPalettes);
+}
+
+void sub_80E2B74(u8 taskId)
+{
+    u32 selectedPalettes = UnpackSelectedBattleAnimPalettes(gBattleAnimArgs[0]);
+
+    switch (gBattleTerrain)
+    {
+    case BATTLE_TERRAIN_GRASS:
+        gBattleAnimArgs[4] = 0x0B0C;
+        break;
+    case BATTLE_TERRAIN_LONG_GRASS:
+        gBattleAnimArgs[4] = 0x09E0;
+        break;
+    case BATTLE_TERRAIN_SAND:
+        gBattleAnimArgs[4] = 0x2F1E;
+        break;
+    case BATTLE_TERRAIN_UNDERWATER:
+        gBattleAnimArgs[4] = 0x4800;
+        break;
+    case BATTLE_TERRAIN_WATER:
+        gBattleAnimArgs[4] = 0x7ECB;
+        break;
+    case BATTLE_TERRAIN_POND:
+        gBattleAnimArgs[4] = 0x7ECB;
+        break;
+    case BATTLE_TERRAIN_MOUNTAIN:
+        gBattleAnimArgs[4] = 0x2A16;
+        break;
+    case BATTLE_TERRAIN_CAVE:
+        gBattleAnimArgs[4] = 0x0D2E;
+        break;
+    case BATTLE_TERRAIN_BUILDING:
+        gBattleAnimArgs[4] = 0x7FFF;
+        break;
+    case BATTLE_TERRAIN_PLAIN:
+        gBattleAnimArgs[4] = 0x7FFF;
+        break;
+    }
+
+    sub_80E2C8C(taskId, selectedPalettes);
+}
+
+void sub_80E2C60(u8 taskId)
+{
+    u8 paletteIndex = IndexOfSpritePaletteTag(gBattleAnimArgs[0]);
+    sub_80E2C8C(taskId, 1 << (paletteIndex + 16));
+}
+
+static void sub_80E2C8C(u8 taskId, u32 selectedPalettes)
+{
+    gTasks[taskId].data[0] = selectedPalettes;
+    gTasks[taskId].data[1] = selectedPalettes >> 16;
+    gTasks[taskId].data[2] = gBattleAnimArgs[1];
+    gTasks[taskId].data[3] = gBattleAnimArgs[2];
+    gTasks[taskId].data[4] = gBattleAnimArgs[3];
+    gTasks[taskId].data[5] = gBattleAnimArgs[4];
+    gTasks[taskId].data[10] = gBattleAnimArgs[2];
+    gTasks[taskId].func = sub_80E2CD0;
+    gTasks[taskId].func(taskId);
+}
+
+static void sub_80E2CD0(u8 taskId)
+{
+    u32 selectedPalettes;
+    u16 singlePaletteMask = 0;
+
+    if (gTasks[taskId].data[9] == gTasks[taskId].data[2])
+    {
+        gTasks[taskId].data[9] = 0;
+        selectedPalettes = gTasks[taskId].data[0] | (gTasks[taskId].data[1] << 16);
+        while (selectedPalettes != 0)
+        {
+            if (selectedPalettes & 1)
+                BlendPalette(singlePaletteMask, 16, gTasks[taskId].data[10], gTasks[taskId].data[5]);
+            singlePaletteMask += 0x10;
+            selectedPalettes >>= 1;
+        }
+
+        if (gTasks[taskId].data[10] < gTasks[taskId].data[4])
+            gTasks[taskId].data[10]++;
+        else if (gTasks[taskId].data[10] > gTasks[taskId].data[4])
+            gTasks[taskId].data[10]--;
+        else
+            DestroyAnimVisualTask(taskId);
+    }
+    else
+    {
+        gTasks[taskId].data[9]++;
+    }
+}
+
+void sub_80E2D78(u8 taskId)
+{
+    BeginHardwarePaletteFade(
+        gBattleAnimArgs[0],
+        gBattleAnimArgs[1],
+        gBattleAnimArgs[2],
+        gBattleAnimArgs[3],
+        gBattleAnimArgs[4]);
+
+    gTasks[taskId].func = sub_80E2DB8;
+}
+
+static void sub_80E2DB8(u8 taskId)
+{
+    if (!gPaletteFade.active)
+        DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E2DD8(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+
+    task->data[0] = gBattleAnimArgs[0];
+    task->data[1] = 0;
+    task->data[2] = gBattleAnimArgs[1];
+    task->data[3] = gBattleAnimArgs[2];
+    task->data[4] = gBattleAnimArgs[3];
+    task->data[5] = 0;
+    task->func = sub_80E2E10;
+}
+
+static void sub_80E2E10(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+
+    if (task->data[4])
+    {
+        if (task->data[1])
+        {
+            task->data[1]--;
+        }
+        else
+        {
+            task->data[6] = duplicate_obj_of_side_rel2move_in_transparent_mode(task->data[0]);
+            if (task->data[6] >= 0)
+            {
+                gSprites[task->data[6]].oam.priority = task->data[0] ? 1 : 2;
+                gSprites[task->data[6]].data[0] = task->data[3];
+                gSprites[task->data[6]].data[1] = taskId;
+                gSprites[task->data[6]].data[2] = 5;
+                gSprites[task->data[6]].callback = sub_80E2EE8;
+                task->data[5]++;
+            }
+
+            task->data[4]--;
+            task->data[1] = task->data[2];
+        }
+    }
+    else if (task->data[5] == 0)
+    {
+        DestroyAnimVisualTask(taskId);
+    }
+}
+
+static void sub_80E2EE8(struct Sprite *sprite)
+{
+    if (sprite->data[0])
+    {
+        sprite->data[0]--;
+    }
+    else
+    {
+        gTasks[sprite->data[1]].data[sprite->data[2]]--;
+        obj_delete_but_dont_free_vram(sprite);
+    }
+}
+
+void sub_80E2F2C(u8 taskId)
+{
+    u16 species;
+    int spriteId, newSpriteId;
+    u16 var0;
+    struct Struct_sub_8078914 subStruct;
+
+    var0 = 0;
+    gBattle_WIN0H = 0;
+    gBattle_WIN0V = 0;
+    REG_WININ = 0x3F3F;
+    REG_WINOUT = 0x3F3D;
+    REG_DISPCNT |= DISPCNT_OBJWIN_ON;
+    REG_BLDCNT = 0x3F42;
+    REG_BLDALPHA = 0x0C08;
+    REG_BG1CNT_BITFIELD.priority = 0;
+    REG_BG1CNT_BITFIELD.screenSize = 0;
+    REG_BG1CNT_BITFIELD.areaOverflowMode = 1;
+
+    if (!IsContest())
+        REG_BG1CNT_BITFIELD.charBaseBlock = 1;
+
+    if (IsDoubleBattle() && !IsContest())
+    {
+        if (GetBattlerPosition(gAnimBankAttacker) == B_POSITION_OPPONENT_RIGHT
+         || GetBattlerPosition(gAnimBankAttacker) == B_POSITION_PLAYER_LEFT)
+        {
+            if (IsAnimBankSpriteVisible(gAnimBankAttacker ^ 2) == TRUE)
+            {
+                gSprites[gBankSpriteIds[gAnimBankAttacker ^ 2]].oam.priority -= 1;
+                REG_BG1CNT_BITFIELD.priority = 1;
+                var0 = 1;
+            }
+        }
+    }
+
+    if (IsContest())
+    {
+        species = eWRAM_19348Struct->species2;
+    }
+    else
+    {
+        if (GetBattlerSide(gAnimBankAttacker) != B_SIDE_PLAYER)
+            species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gAnimBankAttacker]], MON_DATA_SPECIES);
+        else
+            species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gAnimBankAttacker]], MON_DATA_SPECIES);
+    }
+
+    spriteId = GetAnimBattlerSpriteId(0);
+    newSpriteId = sub_807A4A0(gAnimBankAttacker, spriteId, species);
+    sub_8078914(&subStruct);
+    DmaFill32Defvars(3, 0, subStruct.field_4, 0x1000);
+    LZDecompressVram(&gUnknown_08D20A30, subStruct.field_4);
+    if (IsContest())
+        sub_80763FC(subStruct.field_8, (u16 *)subStruct.field_4, 0, 0);
+    
+    LZDecompressVram(&gUnknown_08D20A14, subStruct.field_0);
+    LoadPalette(&gUnknown_083DB568, subStruct.field_8 * 16 + 1, 2);
+
+    gBattle_BG1_X = -gSprites[spriteId].pos1.x + 32;
+    gBattle_BG1_Y = -gSprites[spriteId].pos1.y + 32;
+    gTasks[taskId].data[0] = newSpriteId;
+    gTasks[taskId].data[6] = var0;
+    gTasks[taskId].func = sub_80E3194;
+}
+
+static void sub_80E3194(u8 taskId)
+{
+    struct Struct_sub_8078914 subStruct;
+    struct Sprite *sprite;
+
+    gTasks[taskId].data[10] += 4;
+    gBattle_BG1_Y -= 4;
+    if (gTasks[taskId].data[10] == 64)
+    {
+        gTasks[taskId].data[10] = 0;
+        gBattle_BG1_Y += 64;
+        if (++gTasks[taskId].data[11] == 4)
+        {
+            sub_8076464(0);
+            gBattle_WIN0H = 0;
+            gBattle_WIN0V = 0;
+            REG_WININ = 0x3F3F;
+            REG_WINOUT = 0x3F3F;
+
+            if (!IsContest())
+                REG_BG1CNT_BITFIELD.charBaseBlock = 0;
+
+            REG_DISPCNT ^= DISPCNT_OBJWIN_ON;
+            REG_BLDCNT = 0;
+            REG_BLDALPHA = 0;
+            sprite = &gSprites[GetAnimBattlerSpriteId(0)]; // unused
+            sprite = &gSprites[gTasks[taskId].data[0]];
+            DestroySprite(sprite);
+
+            sub_8078914(&subStruct);
+            DmaFill32Defvars(3, 0, subStruct.field_4, 0x800);
+            if (gTasks[taskId].data[6] == 1)
+                gSprites[gBankSpriteIds[gAnimBankAttacker ^ 2]].oam.priority++;
+
+            REG_BG1CNT_BITFIELD.areaOverflowMode = 0;
+            do {} while(0); // needed to match. perhaps part of a debug macro
+            gBattle_BG1_Y = 0;
+            DestroyAnimVisualTask(taskId);
+        }
+    }
+}
+
+void sub_80E32E0(u8 taskId)
+{
+    u8 i;
+
+    for (i = 0; i < 8; i++)
+        gTasks[taskId].data[i] = gBattleAnimArgs[i];
+
+    gTasks[taskId].func = sub_80E3338;
+}
+
+static void sub_80E3338(u8 taskId)
+{
+    int i;
+    u8 battler1, battler2;
+    u16 species;
+    u8 spriteId, spriteId2;
+    u16 var0;
+    struct Struct_sub_8078914 subStruct;
+    s16 taskData[8];
+
+    spriteId2 = 0;
+    var0 = 0;
+
+    for (i = 0; i < 8; i++)
+    {
+        taskData[i] = gTasks[taskId].data[i]; 
+        gTasks[taskId].data[i] = 0;
+    }
+
+    if (taskData[2] == 0)
+        battler1 = gAnimBankAttacker;
+    else
+        battler1 = gAnimBankTarget;
+
+    battler2 = battler1 ^ 2;
+    if (IsContest() || (taskData[3] && !IsAnimBankSpriteVisible(battler2)))
+        taskData[3] = 0;
+
+    gBattle_WIN0H = 0;
+    gBattle_WIN0V = 0;
+    REG_WININ = 0x3F3F;
+    REG_WINOUT = 0x3F3D;
+    REG_DISPCNT |= DISPCNT_OBJWIN_ON;
+    REG_BLDCNT = 0x3F42;
+    REG_BLDALPHA = 0x1000;
+    REG_BG1CNT_BITFIELD.priority = 0;
+    REG_BG1CNT_BITFIELD.screenSize = 0;
+    REG_BG1CNT_BITFIELD.areaOverflowMode = 1;
+    if (!IsContest())
+        REG_BG1CNT_BITFIELD.charBaseBlock = 1;
+
+    if (IsDoubleBattle() && taskData[3] == 0)
+    {
+        if (GetBattlerPosition(battler1) == B_POSITION_OPPONENT_RIGHT
+         || GetBattlerPosition(battler1) == B_POSITION_PLAYER_LEFT)
+        {
+            if (IsAnimBankSpriteVisible(battler2) == TRUE)
+            {
+                gSprites[gBankSpriteIds[battler2]].oam.priority -= 1;
+                REG_BG1CNT_BITFIELD.priority = 1;
+                var0 = 1;
+            }
+        }
+    }
+
+    if (IsContest())
+    {
+        species = eWRAM_19348Struct->species2;
+    }
+    else
+    {
+        if (GetBattlerSide(battler1) != B_SIDE_PLAYER)
+            species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler1]], MON_DATA_SPECIES);
+        else
+            species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler1]], MON_DATA_SPECIES);
+    }
+
+    spriteId = sub_807A4A0(battler1, gBankSpriteIds[battler1], species);
+    if (taskData[3])
+        spriteId2 = sub_807A4A0(battler2, gBankSpriteIds[battler2], species);
+    
+    sub_8078914(&subStruct);
+    if (taskData[0] == 0)
+        LZDecompressVram(&gBattleStatMask1_Tilemap, subStruct.field_4);
+    else
+        LZDecompressVram(&gBattleStatMask2_Tilemap, subStruct.field_4);
+
+    if (IsContest())
+        sub_80763FC(subStruct.field_8, (u16 *)subStruct.field_4, 0, 0);
+
+    LZDecompressVram(&gBattleStatMask_Gfx, subStruct.field_0);
+
+    if (taskData[1] == 0)
+        LoadCompressedPalette(gBattleStatMask2_Pal, subStruct.field_8 << 4, 32);
+    else if (taskData[1] == 1)
+        LoadCompressedPalette(gBattleStatMask1_Pal, subStruct.field_8 << 4, 32);
+    else if (taskData[1] == 2)
+        LoadCompressedPalette(gBattleStatMask3_Pal, subStruct.field_8 << 4, 32);
+    else if (taskData[1] == 3)
+        LoadCompressedPalette(gBattleStatMask4_Pal, subStruct.field_8 << 4, 32);
+    else if (taskData[1] == 4)
+        LoadCompressedPalette(gBattleStatMask6_Pal, subStruct.field_8 << 4, 32);
+    else if (taskData[1] == 5)
+        LoadCompressedPalette(gBattleStatMask7_Pal, subStruct.field_8 << 4, 32);
+    else if (taskData[1] == 6)
+        LoadCompressedPalette(gBattleStatMask8_Pal, subStruct.field_8 << 4, 32);
+    else
+        LoadCompressedPalette(gBattleStatMask5_Pal, subStruct.field_8 << 4, 32);
+
+    gBattle_BG1_X = 0;
+    gBattle_BG1_Y = 0;
+
+    if (taskData[0] == 1)
+    {
+        gBattle_BG1_X = 64;
+        gTasks[taskId].data[1] = -3;
+    }
+    else
+    {
+        gTasks[taskId].data[1] = 3;
+    }
+
+    if (taskData[4] == 0)
+    {
+        gTasks[taskId].data[4] = 10;
+        gTasks[taskId].data[5] = 20;
+    }
+    else
+    {
+        gTasks[taskId].data[4] = 13;
+        gTasks[taskId].data[5] = 30;
+    }
+
+    gTasks[taskId].data[0] = spriteId;
+    gTasks[taskId].data[2] = taskData[3];
+    gTasks[taskId].data[3] = spriteId2;
+    gTasks[taskId].data[6] = var0;
+    gTasks[taskId].data[7] = gBankSpriteIds[battler2];
+    gTasks[taskId].func = sub_80E3704;
+
+    if (taskData[0] == 0)
+        PlaySE12WithPanning(SE_W287, BattleAnimAdjustPanning2(-64));
+    else
+        PlaySE12WithPanning(SE_W287B, BattleAnimAdjustPanning2(-64));
+}
+
+static void sub_80E3704(u8 taskId)
+{
+    gBattle_BG1_Y += gTasks[taskId].data[1];
+
+    switch (gTasks[taskId].data[15])
+    {
+    case 0:
+        if (gTasks[taskId].data[11]++ > 0)
+        {
+            gTasks[taskId].data[11] = 0;
+            gTasks[taskId].data[12]++;
+            REG_BLDALPHA = ((16 - gTasks[taskId].data[12]) << 8) | gTasks[taskId].data[12];
+            if (gTasks[taskId].data[12] == gTasks[taskId].data[4])
+                gTasks[taskId].data[15]++;
+        }
+        break;
+    case 1:
+        if (++gTasks[taskId].data[10] == gTasks[taskId].data[5])
+            gTasks[taskId].data[15]++;
+        break;
+    case 2:
+        if (gTasks[taskId].data[11]++ > 0)
+        {
+            gTasks[taskId].data[11] = 0;
+            gTasks[taskId].data[12]--;
+            REG_BLDALPHA = ((16 - gTasks[taskId].data[12]) << 8) | gTasks[taskId].data[12];
+            if (gTasks[taskId].data[12] == 0)
+            {
+                sub_8076464(0);
+                gBattle_WIN0H = 0;
+                gBattle_WIN0V = 0;
+                REG_WININ = 0x3F3F;
+                REG_WINOUT = 0x3F3F;
+
+                if (!IsContest())
+                    REG_BG1CNT_BITFIELD.charBaseBlock = 0;
+
+                REG_DISPCNT ^= DISPCNT_OBJWIN_ON;
+                REG_BLDCNT = 0;
+                REG_BLDALPHA = 0;
+                DestroySprite(&gSprites[gTasks[taskId].data[0]]);
+                if (gTasks[taskId].data[2])
+                    DestroySprite(&gSprites[gTasks[taskId].data[3]]);
+
+                if (gTasks[taskId].data[6] == 1)
+                    gSprites[gTasks[taskId].data[7]].oam.priority++;
+
+                REG_BG1CNT_BITFIELD.areaOverflowMode = 0;
+                DestroyAnimVisualTask(taskId);
+            }
+        }
+        break;
+    }
+}
+
+void sub_80E388C(u8 taskId)
+{
+    u32 selectedPalettes = sub_80792C0(1, 1, 1, 1);
+    sub_80E39BC(selectedPalettes, 0);
+    gTasks[taskId].data[14] = selectedPalettes >> 16;
+
+    selectedPalettes = sub_80791A8(1, 0, 0, 0, 0, 0, 0) & 0xFFFF;
+    sub_80E39BC(selectedPalettes, 0xFFFF);
+    gTasks[taskId].data[15] = selectedPalettes;
+
+    gTasks[taskId].data[0] = 0;
+    gTasks[taskId].data[1] = 0;
+    gTasks[taskId].func = sub_80E38F8;
+}
+
+static void sub_80E38F8(u8 taskId)
+{
+    u16 i;
+    struct Task *task = &gTasks[taskId];
+
+    switch (task->data[0])
+    {
+    case 0:
+        if (++task->data[1] > 6)
+        {
+            task->data[1] = 0;
+            task->data[2] = 16;
+            task->data[0]++;
+        }
+        break;
+    case 1:
+        if (++task->data[1] > 1)
+        {
+            task->data[1] = 0;
+            task->data[2]--;
+
+            for (i = 0; i < 16; i++)
+            {
+                if ((task->data[15] >> i) & 1)
+                {
+                    u16 paletteOffset = i * 16;
+                    BlendPalette(paletteOffset, 16, task->data[2], 0xFFFF);
+                }
+
+                if ((task->data[14] >> i) & 1)
+                {
+                    u16 paletteOffset = i * 16 + 0x100;
+                    BlendPalette(paletteOffset, 16, task->data[2], 0);
+                }
+            }
+
+            if (task->data[2] == 0)
+                task->data[0]++;
+        }
+        break;
+    case 2:
+        DestroyAnimVisualTask(taskId);
+        break;
+    }
+}
+
+static void sub_80E39BC(u32 selectedPalettes, u16 color)
+{
+    u16 i;
+
+    for (i = 0; i < 32; i++)
+    {
+        if (selectedPalettes & 1)
+        {
+            u16 curOffset = i * 16;
+            u16 paletteOffset = curOffset;
+            while (curOffset < paletteOffset + 16)
+            {
+                gPlttBufferFaded[curOffset] = color;
+                curOffset++;
+            }
+        }
+
+        selectedPalettes >>= 1;
+    }
+}
+
+void sub_80E3A08(u8 taskId)
+{
+    u32 i;
+    int j;
+    u32 selectedPalettes = 0;
+
+    for (i = 0; i < 4; i++)
+    {
+        if (gAnimBankAttacker != i)
+            selectedPalettes |= 1 << (i + 16);
+    }
+
+    for (j = 5; j != 0; j--)
+        gBattleAnimArgs[j] = gBattleAnimArgs[j - 1];
+
+    sub_80E2C8C(taskId, selectedPalettes);
+}
+
+void sub_80E3A58(u8 taskId)
+{
+    u8 newTaskId;
+
+    sub_80789D4(0);
+    newTaskId = CreateTask(sub_80E3AD0, 5);
+    if (gBattleAnimArgs[2] && GetBattlerSide(gAnimBankAttacker) != B_SIDE_PLAYER)
+    {
+        gBattleAnimArgs[0] = -gBattleAnimArgs[0];
+        gBattleAnimArgs[1] = -gBattleAnimArgs[1];
+    }
+
+    gTasks[newTaskId].data[1] = gBattleAnimArgs[0];
+    gTasks[newTaskId].data[2] = gBattleAnimArgs[1];
+    gTasks[newTaskId].data[3] = gBattleAnimArgs[3];
+    gTasks[newTaskId].data[0]++;
+    DestroyAnimVisualTask(taskId);
+}
+
+static void sub_80E3AD0(u8 taskId)
+{
+    gTasks[taskId].data[10] += gTasks[taskId].data[1];
+    gTasks[taskId].data[11] += gTasks[taskId].data[2];
+    gBattle_BG3_X += gTasks[taskId].data[10] >> 8;
+    gBattle_BG3_Y += gTasks[taskId].data[11] >> 8;
+    gTasks[taskId].data[10] &= 0xFF;
+    gTasks[taskId].data[11] &= 0xFF;
+
+    if (gBattleAnimArgs[7] == gTasks[taskId].data[3])
+    {
+        gBattle_BG3_X = 0;
+        gBattle_BG3_Y = 0;
+        sub_80789D4(1);
+        DestroyTask(taskId);
+    }
+}
+
+void sub_80E3B4C(u8 taskId)
+{
+    gBattleAnimArgs[7] = GetBattlerSide(gAnimBankAttacker);
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E3B78(u8 taskId)
+{
+    gBattleAnimArgs[7] = GetBattlerSide(gAnimBankTarget);
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E3BA4(u8 taskId)
+{
+    gBattleAnimArgs[7] = (gAnimBankAttacker ^ 2) == gAnimBankTarget;
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E3BDC(u8 taskId)
+{
+    u16 i;
+
+    for (i = 0; i < 4; i++)
+    {
+        if (i != gAnimBankAttacker && IsAnimBankSpriteVisible(i))
+            gSprites[gBankSpriteIds[i]].invisible = gBattleAnimArgs[0];
+    }
+
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E3C4C(u8 taskId, int unused, u16 arg2, u8 battler1, u8 arg4, u8 arg5, u8 arg6, u8 arg7, const u8 *arg8, const u8 *arg9, const u16 *palette)
+{
+    u16 species;
+    u8 spriteId, spriteId2;
+    struct Struct_sub_8078914 subStruct;
+    u8 battler2;
+
+    spriteId2 = 0;
+    battler2 = battler1 ^ 2;
+
+    if (IsContest() || (arg4 && !IsAnimBankSpriteVisible(battler2)))
+        arg4 = 0;
+
+    gBattle_WIN0H = 0;
+    gBattle_WIN0V = 0;
+    REG_WININ = 0x3F3F;
+    REG_WINOUT = 0x3F3D;
+    REG_DISPCNT |= DISPCNT_OBJWIN_ON;
+    REG_BLDCNT = 0x3F42;
+    REG_BLDALPHA = 0x1000;
+    REG_BG1CNT_BITFIELD.priority = 0;
+    REG_BG1CNT_BITFIELD.screenSize = 0;
+    REG_BG1CNT_BITFIELD.areaOverflowMode = 1;
+    if (!IsContest())
+        REG_BG1CNT_BITFIELD.charBaseBlock = 1;
+
+    if (IsContest())
+    {
+        species = eWRAM_19348Struct->species2;
+    }
+    else
+    {
+        if (GetBattlerSide(battler1) != B_SIDE_PLAYER)
+            species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler1]], MON_DATA_SPECIES);
+        else
+            species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler1]], MON_DATA_SPECIES);
+    }
+
+    spriteId = sub_807A4A0(battler1, gBankSpriteIds[battler1], species);
+    if (arg4)
+        spriteId2 = sub_807A4A0(battler2, gBankSpriteIds[battler2], species);
+
+    sub_8078914(&subStruct);
+    LZDecompressVram(arg9, subStruct.field_4);
+    if (IsContest())
+        sub_80763FC(subStruct.field_8, (u16 *)subStruct.field_4, 0, 0);
+
+    LZDecompressVram(arg8, subStruct.field_0);
+    LoadCompressedPalette(palette, subStruct.field_8 << 4, 32);
+    gBattle_BG1_X = 0;
+    gBattle_BG1_Y = 0;
+    gTasks[taskId].data[1] = arg2;
+    gTasks[taskId].data[4] = arg5;
+    gTasks[taskId].data[5] = arg7;
+    gTasks[taskId].data[6] = arg6;
+    gTasks[taskId].data[0] = spriteId;
+    gTasks[taskId].data[2] = arg4;
+    gTasks[taskId].data[3] = spriteId2;
+    gTasks[taskId].func = sub_80E3E64;
+}
+
+static void sub_80E3E64(u8 taskId)
+{
+    gTasks[taskId].data[13] += gTasks[taskId].data[1] < 0 ? -gTasks[taskId].data[1] : gTasks[taskId].data[1];
+    if (gTasks[taskId].data[1] < 0)
+        gBattle_BG1_Y -= gTasks[taskId].data[13] >> 8;
+    else
+        gBattle_BG1_Y += gTasks[taskId].data[13] >> 8;
+
+    gTasks[taskId].data[13] &= 0xFF;
+    switch (gTasks[taskId].data[15])
+    {
+    case 0:
+        if (gTasks[taskId].data[11]++ >= gTasks[taskId].data[6])
+        {
+            gTasks[taskId].data[11] = 0;
+            gTasks[taskId].data[12]++;
+            REG_BLDALPHA = ((16 - gTasks[taskId].data[12]) << 8) | gTasks[taskId].data[12];
+            if (gTasks[taskId].data[12] == gTasks[taskId].data[4])
+                gTasks[taskId].data[15]++;
+        }
+        break;
+    case 1:
+        if (++gTasks[taskId].data[10] == gTasks[taskId].data[5])
+            gTasks[taskId].data[15]++;
+        break;
+    case 2:
+        if (gTasks[taskId].data[11]++ >= gTasks[taskId].data[6])
+        {
+            gTasks[taskId].data[11] = 0;
+            gTasks[taskId].data[12]--;
+            REG_BLDALPHA = ((16 - gTasks[taskId].data[12]) << 8) | gTasks[taskId].data[12];
+            if (gTasks[taskId].data[12] == 0)
+            {
+                sub_8076464(0);
+                gBattle_WIN0H = 0;
+                gBattle_WIN0V = 0;
+                REG_WININ = 0x3F3F;
+                REG_WINOUT = 0x3F3F;
+
+                if (!IsContest())
+                    REG_BG1CNT_BITFIELD.charBaseBlock = 0;
+
+                REG_DISPCNT ^= DISPCNT_OBJWIN_ON;
+                REG_BLDCNT = 0;
+                REG_BLDALPHA = 0;
+                DestroySprite(&gSprites[gTasks[taskId].data[0]]);
+                if (gTasks[taskId].data[2])
+                    DestroySprite(&gSprites[gTasks[taskId].data[3]]);
+
+                REG_BG1CNT_BITFIELD.areaOverflowMode = 0;
+                DestroyAnimVisualTask(taskId);
+            }
+        }
+        break;
+    }
+}
+
+void sub_80E4008(u8 taskId)
+{
+    gBattleAnimArgs[0] = gBattleTerrain;
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E4028(u8 taskId)
+{
+    u32 selectedPalettes;
+    u8 *dest;
+    int offset;
+    int i = 0;
+
+    if (gBattleAnimArgs[0] == 0)
+    {
+        selectedPalettes = sub_80791A8(1, 0, 0, 0, 0, 0, 0);
+        while ((selectedPalettes & 1) == 0)
+        {
+            selectedPalettes >>= 1;
+            i++;
+        }
+    }
+    else if (gBattleAnimArgs[0] == 1)
+    {
+        i = gAnimBankAttacker + 16;
+    }
+    else if (gBattleAnimArgs[0] == 2)
+    {
+        i = gAnimBankTarget + 16;
+    }
+
+    offset = gBattleAnimArgs[1] * 32;
+    dest = IsContest() ? &ewram14800[offset] : &ewram18000_2[offset];
+    // This doesn't match when u16* is used.
+    memcpy(dest, &((u8 *)gPlttBufferUnfaded)[i * 32], 32);
+    DestroyAnimVisualTask(taskId);
+}
+
+
+void sub_80E40D0(u8 taskId)
+{
+    u32 selectedPalettes;
+    u8 *src;
+    u8 *dest;
+    int offset;
+    int i = 0;
+
+    if (gBattleAnimArgs[0] == 0)
+    {
+        selectedPalettes = sub_80791A8(1, 0, 0, 0, 0, 0, 0);
+        while ((selectedPalettes & 1) == 0)
+        {
+            selectedPalettes >>= 1;
+            i++;
+        }
+    }
+    else if (gBattleAnimArgs[0] == 1)
+    {
+        i = gAnimBankAttacker + 16;
+    }
+    else if (gBattleAnimArgs[0] == 2)
+    {
+        i = gAnimBankTarget + 16;
+    }
+
+    dest = &((u8 *)gPlttBufferUnfaded)[i * 32];
+    offset = gBattleAnimArgs[1] * 32;
+    src = IsContest() ? &ewram14800[offset] : &ewram18000_2[offset];
+    // This doesn't match when u16* is used.
+    memcpy(dest, src, 32);
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E4178(u8 taskId)
+{
+    u32 selectedPalettes;
+    int i = 0;
+
+    if (gBattleAnimArgs[0] == 0)
+    {
+        selectedPalettes = sub_80791A8(1, 0, 0, 0, 0, 0, 0);
+        while ((selectedPalettes & 1) == 0)
+        {
+            selectedPalettes >>= 1;
+            i++;
+        }
+    }
+    else if (gBattleAnimArgs[0] == 1)
+    {
+        i = gAnimBankAttacker + 16;
+    }
+    else if (gBattleAnimArgs[0] == 2)
+    {
+        i = gAnimBankTarget + 16;
+    }
+
+    memcpy(&gPlttBufferUnfaded[i * 16], &gPlttBufferFaded[i * 16], 32);
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E4200(u8 taskId)
+{
+    if (IsContest())
+        gBattleAnimArgs[7] = 1;
+    else
+        gBattleAnimArgs[7] = 0;
+
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E4234(u8 taskId)
+{
+    gAnimBankAttacker = gBankTarget;
+    gAnimBankTarget = gEffectBank;
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E4264(u8 taskId)
+{
+    if (GetBattlerSide(gAnimBankAttacker) == GetBattlerSide(gAnimBankTarget))
+        gBattleAnimArgs[7] = 1;
+    else
+        gBattleAnimArgs[7] = 0;
+
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E42B0(u8 taskId)
+{
+    gAnimBankTarget = gBankTarget;
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E42D0(u8 taskId)
+{
+    gAnimBankAttacker = gBankAttacker;
+    gAnimBankTarget = gEffectBank;
+    DestroyAnimVisualTask(taskId);
+}
+
+void sub_80E4300(u8 taskId)
+{
+    if (IsContest())
+    {
+        DestroyAnimVisualTask(taskId);
+    }
+    else
+    {
+        gTasks[taskId].data[0] = ewram17800[gAnimBankAttacker].invisible;
+        ewram17800[gAnimBankAttacker].invisible = 1;
+        gTasks[taskId].func = sub_80E4368;
+        gAnimVisualTaskCount--;
+    }
+}
+
+static void sub_80E4368(u8 taskId)
+{
+    if (gBattleAnimArgs[7] == 0x1000)
+    {
+        ewram17800[gAnimBankAttacker].invisible = gTasks[taskId].data[0] & 1;
+        DestroyTask(taskId);
+    }
+}
diff --git a/src/battle/battle_anim_812C144.c b/src/battle/battle_anim_812C144.c
index 2175f7d2a..bcdd2b693 100644
--- a/src/battle/battle_anim_812C144.c
+++ b/src/battle/battle_anim_812C144.c
@@ -14,15 +14,6 @@
 #include "constants/songs.h"
 #include "constants/species.h"
 
-struct EWRAM_19348_Struct
-{
-    /*0x00*/ u8 filler0[0x2];
-    /*0x02*/ u16 species;
-    /*0x04*/ u8 filler4[0x8];
-    /*0x0C*/ u32 otId;
-    /*0x10*/ u32 personality;
-};
-
 extern s16 gBattleAnimArgs[];
 extern u8 gAnimBankAttacker;
 extern u8 gAnimBankTarget;