From f3ec101b4678d80a72e114ec09b8d7e3bf90f411 Mon Sep 17 00:00:00 2001 From: Evan Date: Sat, 30 Nov 2019 11:36:22 -0500 Subject: start decompilation --- src/battle_anim.c | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 src/battle_anim.c (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c new file mode 100644 index 000000000..64f01beb1 --- /dev/null +++ b/src/battle_anim.c @@ -0,0 +1,136 @@ +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "battle_controllers.h" +#include "battle_interface.h" + +// Defines +#define ANIM_SPRITE_INDEX_COUNT 8 + +// RAM +EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; +EWRAM_DATA static const u8 *sBattleAnimScriptRetAddr = NULL; +EWRAM_DATA void (*gAnimScriptCallback)(void) = NULL; +EWRAM_DATA static s8 gAnimFramesToWait = 0; +EWRAM_DATA bool8 gAnimScriptActive = FALSE; +EWRAM_DATA u8 gAnimVisualTaskCount = 0; +EWRAM_DATA u8 gAnimSoundTaskCount = 0; +EWRAM_DATA struct DisableStruct *gAnimDisableStructPtr = NULL; +EWRAM_DATA s32 gAnimMoveDmg = 0; +EWRAM_DATA u16 gAnimMovePower = 0; +EWRAM_DATA static u16 sAnimSpriteIndexArray[ANIM_SPRITE_INDEX_COUNT] = {0}; +EWRAM_DATA u8 gAnimFriendship = 0; +EWRAM_DATA u16 gWeatherMoveAnim = 0; +EWRAM_DATA s16 gBattleAnimArgs[ANIM_ARGS_COUNT] = {0}; +EWRAM_DATA static u16 sSoundAnimFramesToWait = 0; +EWRAM_DATA static u8 sMonAnimTaskIdArray[2] = {0}; +EWRAM_DATA u8 gAnimMoveTurn = 0; +EWRAM_DATA static u8 sAnimBackgroundFadeState = 0; +EWRAM_DATA static u16 sAnimMoveIndex = 0; // Set but unused. +EWRAM_DATA u8 gBattleAnimAttacker = 0; +EWRAM_DATA u8 gBattleAnimTarget = 0; +EWRAM_DATA u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT] = {0}; +EWRAM_DATA u8 gUnknown_2037F24 = 0; + +// Data + +// Function Declarations + + +void ClearBattleAnimationVars(void) +{ + s32 i; + + gAnimFramesToWait = 0; + gAnimScriptActive = FALSE; + gAnimVisualTaskCount = 0; + gAnimSoundTaskCount = 0; + gAnimDisableStructPtr = NULL; + gAnimMoveDmg = 0; + gAnimMovePower = 0; + gAnimFriendship = 0; + + // Clear index array. + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + sAnimSpriteIndexArray[i] |= 0xFFFF; + + // Clear anim args. + for (i = 0; i < ANIM_ARGS_COUNT; i++) + gBattleAnimArgs[i] = 0; + + sMonAnimTaskIdArray[0] = 0xFF; + sMonAnimTaskIdArray[1] = (s8)0xFF; + gAnimMoveTurn = 0; + sAnimBackgroundFadeState = 0; + sAnimMoveIndex = 0; + gBattleAnimAttacker = 0; + gBattleAnimTarget = 0; + gUnknown_2037F24 = 0; +} + +void DoMoveAnim(u16 move) +{ + gBattleAnimAttacker = gBattlerAttacker; + gBattleAnimTarget = gBattlerTarget; + LaunchBattleAnimation(gBattleAnims_Moves, move, TRUE); +} + +void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMoveAnim) +{ + s32 i; + + if (!IsContest()) + { + sub_80A8278(); + UpdateOamPriorityInAllHealthboxes(0); + for (i = 0; i < MAX_BATTLERS_COUNT; i++) + { + if (GetBattlerSide(i) != B_SIDE_PLAYER) + gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + else + gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + } + } + else + { + for (i = 0; i < 4; i++) + gAnimBattlerSpecies[i] = gContestResources->field_18->species; + } + + if (!isMoveAnim) + sAnimMoveIndex = 0; + else + sAnimMoveIndex = tableId; + + for (i = 0; i < ANIM_ARGS_COUNT; i++) + gBattleAnimArgs[i] = 0; + + sMonAnimTaskIdArray[0] = 0xFF; + sMonAnimTaskIdArray[1] = 0xFF; + sBattleAnimScriptPtr = animsTable[tableId]; + gAnimScriptActive = TRUE; + gAnimFramesToWait = 0; + gAnimScriptCallback = RunAnimScriptCommand; + + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + sAnimSpriteIndexArray[i] = 0xFFFF; + + if (isMoveAnim) + { + for (i = 0; gMovesWithQuietBGM[i] != 0xFFFF; i++) + { + if (tableId == gMovesWithQuietBGM[i]) + { + m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 128); + break; + } + } + } + + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + gBattle_WIN1H = 0; + gBattle_WIN1V = 0; +} + + -- cgit v1.2.3 From 98c3bb201f2519383eda190acca93afaec977c59 Mon Sep 17 00:00:00 2001 From: Evan Date: Sat, 30 Nov 2019 15:09:08 -0500 Subject: port all to c --- src/battle_anim.c | 1599 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1579 insertions(+), 20 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index 64f01beb1..a92cf98de 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -3,6 +3,20 @@ #include "battle_anim.h" #include "battle_controllers.h" #include "battle_interface.h" +#include "bg.h" +#include "contest.h" +#include "decompress.h" +#include "dma3.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "main.h" +#include "m4a.h" +#include "palette.h" +#include "pokemon.h" +#include "sound.h" +#include "sprite.h" +#include "task.h" +#include "constants/battle_anim.h" // Defines #define ANIM_SPRITE_INDEX_COUNT 8 @@ -32,11 +46,114 @@ EWRAM_DATA u8 gBattleAnimTarget = 0; EWRAM_DATA u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA u8 gUnknown_2037F24 = 0; -// Data - // Function Declarations +static void AddSpriteIndex(u16 index); +static void ClearSpriteIndex(u16 index); +static void WaitAnimFrameCount(void); +static void RunAnimScriptCommand(void); +static void ScriptCmd_loadspritegfx(void); +static void ScriptCmd_unloadspritegfx(void); +static void ScriptCmd_createsprite(void); +static void ScriptCmd_createvisualtask(void); +static void ScriptCmd_delay(void); +static void ScriptCmd_waitforvisualfinish(void); +static void ScriptCmd_hang1(void); +static void ScriptCmd_hang2(void); +static void ScriptCmd_end(void); +static void ScriptCmd_playse(void); +static void ScriptCmd_monbg(void); +static void ScriptCmd_clearmonbg(void); +static void ScriptCmd_setalpha(void); +static void ScriptCmd_blendoff(void); +static void ScriptCmd_call(void); +static void ScriptCmd_return(void); +static void ScriptCmd_setarg(void); +static void ScriptCmd_choosetwoturnanim(void); +static void ScriptCmd_jumpifmoveturn(void); +static void ScriptCmd_goto(void); +static void ScriptCmd_fadetobg(void); +static void ScriptCmd_restorebg(void); +static void ScriptCmd_waitbgfadeout(void); +static void ScriptCmd_waitbgfadein(void); +static void ScriptCmd_changebg(void); +static void ScriptCmd_playsewithpan(void); +static void ScriptCmd_setpan(void); +static void ScriptCmd_panse_1B(void); +static void ScriptCmd_loopsewithpan(void); +static void ScriptCmd_waitplaysewithpan(void); +static void ScriptCmd_setbldcnt(void); +static void ScriptCmd_createsoundtask(void); +static void ScriptCmd_waitsound(void); +static void ScriptCmd_jumpargeq(void); +static void ScriptCmd_monbg_22(void); +static void ScriptCmd_clearmonbg_23(void); +static void ScriptCmd_jumpifcontest(void); +static void ScriptCmd_fadetobgfromset(void); +static void ScriptCmd_panse_26(void); +static void ScriptCmd_panse_27(void); +static void ScriptCmd_monbgprio_28(void); +static void ScriptCmd_monbgprio_29(void); +static void ScriptCmd_monbgprio_2A(void); +static void ScriptCmd_invisible(void); +static void ScriptCmd_visible(void); +static void ScriptCmd_doublebattle_2D(void); +static void ScriptCmd_doublebattle_2E(void); +static void ScriptCmd_stopsound(void); +// Data +static void (* const sScriptCmdTable[])(void) = //83ADF5C +{ + ScriptCmd_loadspritegfx, + ScriptCmd_unloadspritegfx, + ScriptCmd_createsprite, + ScriptCmd_createvisualtask, + ScriptCmd_delay, + ScriptCmd_waitforvisualfinish, + ScriptCmd_hang1, + ScriptCmd_hang2, + ScriptCmd_end, + ScriptCmd_playse, + ScriptCmd_monbg, + ScriptCmd_clearmonbg, + ScriptCmd_setalpha, + ScriptCmd_blendoff, + ScriptCmd_call, + ScriptCmd_return, + ScriptCmd_setarg, + ScriptCmd_choosetwoturnanim, + ScriptCmd_jumpifmoveturn, + ScriptCmd_goto, + ScriptCmd_fadetobg, + ScriptCmd_restorebg, + ScriptCmd_waitbgfadeout, + ScriptCmd_waitbgfadein, + ScriptCmd_changebg, + ScriptCmd_playsewithpan, + ScriptCmd_setpan, + ScriptCmd_panse_1B, + ScriptCmd_loopsewithpan, + ScriptCmd_waitplaysewithpan, + ScriptCmd_setbldcnt, + ScriptCmd_createsoundtask, + ScriptCmd_waitsound, + ScriptCmd_jumpargeq, + ScriptCmd_monbg_22, + ScriptCmd_clearmonbg_23, + ScriptCmd_jumpifcontest, + ScriptCmd_fadetobgfromset, + ScriptCmd_panse_26, + ScriptCmd_panse_27, + ScriptCmd_monbgprio_28, + ScriptCmd_monbgprio_29, + ScriptCmd_monbgprio_2A, + ScriptCmd_invisible, + ScriptCmd_visible, + ScriptCmd_doublebattle_2D, + ScriptCmd_doublebattle_2E, + ScriptCmd_stopsound +}; +// Functions void ClearBattleAnimationVars(void) { s32 i; @@ -79,23 +196,15 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo { s32 i; - if (!IsContest()) - { - sub_80A8278(); - UpdateOamPriorityInAllHealthboxes(0); - for (i = 0; i < MAX_BATTLERS_COUNT; i++) - { - if (GetBattlerSide(i) != B_SIDE_PLAYER) - gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); - else - gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); - } - } - else - { - for (i = 0; i < 4; i++) - gAnimBattlerSpecies[i] = gContestResources->field_18->species; - } + sub_80767F0(); + UpdateOamPriorityInAllHealthboxes(0); + for (i = 0; i < MAX_BATTLERS_COUNT; i++) + { + if (GetBattlerSide(i) != B_SIDE_PLAYER) + gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + else + gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + } if (!isMoveAnim) sAnimMoveIndex = 0; @@ -106,7 +215,7 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo gBattleAnimArgs[i] = 0; sMonAnimTaskIdArray[0] = 0xFF; - sMonAnimTaskIdArray[1] = 0xFF; + sMonAnimTaskIdArray[1] = (s8)-1; sBattleAnimScriptPtr = animsTable[tableId]; gAnimScriptActive = TRUE; gAnimFramesToWait = 0; @@ -133,4 +242,1454 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo gBattle_WIN1V = 0; } +void DestroyAnimSprite(struct Sprite *sprite) +{ + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); + gAnimVisualTaskCount--; +} + +void DestroyAnimVisualTask(u8 taskId) +{ + DestroyTask(taskId); + gAnimVisualTaskCount--; +} + +void DestroyAnimSoundTask(u8 taskId) +{ + DestroyTask(taskId); + gAnimSoundTaskCount--; +} + +static void AddSpriteIndex(u16 index) +{ + s32 i; + + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + { + if (sAnimSpriteIndexArray[i] == 0xFFFF) + { + sAnimSpriteIndexArray[i] = index; + return; + } + } +} + +static void ClearSpriteIndex(u16 index) +{ + s32 i; + + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + { + if (sAnimSpriteIndexArray[i] == index) + { + sAnimSpriteIndexArray[i] = 0xFFFF; + return; + } + } +} + +static void WaitAnimFrameCount(void) +{ + if (gAnimFramesToWait <= 0) + { + gAnimScriptCallback = RunAnimScriptCommand; + gAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait--; + } +} + +static void RunAnimScriptCommand(void) +{ + do + { + sScriptCmdTable[sBattleAnimScriptPtr[0]](); + } while (gAnimFramesToWait == 0 && gAnimScriptActive); +} + +static void ScriptCmd_loadspritegfx(void) +{ + u16 index; + + sBattleAnimScriptPtr++; + index = T1_READ_16(sBattleAnimScriptPtr); + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(index)]); + sBattleAnimScriptPtr += 2; + AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); + gAnimFramesToWait = 1; + gAnimScriptCallback = WaitAnimFrameCount; +} + +static void ScriptCmd_unloadspritegfx(void) +{ + u16 index; + + sBattleAnimScriptPtr++; + index = T1_READ_16(sBattleAnimScriptPtr); + FreeSpriteTilesByTag(gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)].tag); + FreeSpritePaletteByTag(gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)].tag); + sBattleAnimScriptPtr += 2; + ClearSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); +} + +static void ScriptCmd_createsprite(void) +{ + s32 i; + const struct SpriteTemplate *template; + u8 argVar; + u8 argsCount; + s16 subpriority; + + sBattleAnimScriptPtr++; + template = (const struct SpriteTemplate *)(T2_READ_32(sBattleAnimScriptPtr)); + sBattleAnimScriptPtr += 4; + + argVar = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + + argsCount = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + for (i = 0; i < argsCount; i++) + { + gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 2; + } + + if (argVar & 0x80) + { + argVar ^= 0x80; + if (argVar >= 0x40) + argVar -= 0x40; + else + argVar *= -1; + + subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + (s8)(argVar); + } + else + { + if (argVar >= 0x40) + argVar -= 0x40; + else + argVar *= -1; + + subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) + (s8)(argVar); + } + + if (subpriority < 3) + subpriority = 3; + + CreateSpriteAndAnimate( + template, + GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2), + GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET), + subpriority); + gAnimVisualTaskCount++; +} + +static void ScriptCmd_createvisualtask(void) +{ + TaskFunc taskFunc; + u8 taskPriority; + u8 taskId; + u8 numArgs; + s32 i; + + sBattleAnimScriptPtr++; + + taskFunc = (TaskFunc)T2_READ_32(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 4; + + taskPriority = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + + numArgs = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + + for (i = 0; i < numArgs; i++) + { + gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 2; + } + + taskId = CreateTask(taskFunc, taskPriority); + taskFunc(taskId); + gAnimVisualTaskCount++; +} + +static void ScriptCmd_delay(void) +{ + sBattleAnimScriptPtr++; + gAnimFramesToWait = sBattleAnimScriptPtr[0]; + if (gAnimFramesToWait == 0) + gAnimFramesToWait = -1; + sBattleAnimScriptPtr++; + gAnimScriptCallback = WaitAnimFrameCount; +} + +// Wait for visual tasks to finish. +static void ScriptCmd_waitforvisualfinish(void) +{ + if (gAnimVisualTaskCount == 0) + { + sBattleAnimScriptPtr++; + gAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait = 1; + } +} + +static void ScriptCmd_end(void) +{ + s32 i; + bool32 continuousAnim = FALSE; + + // Keep waiting as long as there are animations to be done. + if (gAnimVisualTaskCount != 0 || gAnimSoundTaskCount != 0 + || sMonAnimTaskIdArray[0] != 0xFF || sMonAnimTaskIdArray[1] != 0xFF) + { + sSoundAnimFramesToWait = 0; + gAnimFramesToWait = 1; + return; + } + + // Finish the sound effects. + if (IsSEPlaying()) + { + if (++sSoundAnimFramesToWait <= 90) // Wait 90 frames, then halt the sound effect. + { + gAnimFramesToWait = 1; + return; + } + else + { + m4aMPlayStop(&gMPlayInfo_SE1); + m4aMPlayStop(&gMPlayInfo_SE2); + } + } + + // The SE has halted, so set the SE Frame Counter to 0 and continue. + sSoundAnimFramesToWait = 0; + + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + { + if (sAnimSpriteIndexArray[i] != 0xFFFF) + { + FreeSpriteTilesByTag(gBattleAnimPicTable[sAnimSpriteIndexArray[i]].tag); + FreeSpritePaletteByTag(gBattleAnimPicTable[sAnimSpriteIndexArray[i]].tag); + sAnimSpriteIndexArray[i] = 0xFFFF; // set terminator. + } + } + + if (!continuousAnim) // May have been used for debug? + { + m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256); + if (!IsContest()) + { + sub_80A8278(); + UpdateOamPriorityInAllHealthboxes(1); + } + gAnimScriptActive = FALSE; + } +} + +static void ScriptCmd_playse(void) +{ + sBattleAnimScriptPtr++; + PlaySE(T1_READ_16(sBattleAnimScriptPtr)); + sBattleAnimScriptPtr += 2; +} + +#define t1_MONBG_BATTLER 0 +#define t1_MON_IN_BG2 1 +#define t1_CREATE_ANOTHER_TASK 2 +#define t1_IS_SECONDMON_BG 3 + +#define t2_BATTLER_SPRITE_ID 0 +#define t2_MON_IN_BG2 5 +#define t2_MONBG_BATTLER 6 + +static void ScriptCmd_monbg(void) +{ + bool8 toBG_2; + u8 taskId; + u8 battlerId; + u8 animBattler; + + sBattleAnimScriptPtr++; + + animBattler = sBattleAnimScriptPtr[0]; + if (animBattler & ANIM_TARGET) + battlerId = gBattleAnimTarget; + else + battlerId = gBattleAnimAttacker; + + if (IsBattlerSpriteVisible(battlerId)) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + + MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); + gAnimVisualTaskCount++; + gTasks[taskId].data[t1_MONBG_BATTLER] = battlerId; + gTasks[taskId].data[t1_MON_IN_BG2] = toBG_2; + gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE; + gTasks[taskId].data[t1_IS_SECONDMON_BG] = 0; + + } + + battlerId ^= BIT_FLANK; + if (IsBattlerSpriteVisible(battlerId)) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + + MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); + gAnimVisualTaskCount++; + gTasks[taskId].data[0] = battlerId; + gTasks[taskId].data[1] = toBG_2; + gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE; + gTasks[taskId].data[t1_IS_SECONDMON_BG] = 1; + } + + sBattleAnimScriptPtr++; + gAnimFramesToWait = 1; + gAnimScriptCallback = WaitAnimFrameCount; +} + +bool8 IsBattlerSpriteVisible(u8 battlerId) +{ + if (!IsBattlerSpritePresent(battlerId)) + return FALSE; + + if (!gBattleSpritesDataPtr->battlerData[battlerId].invisible || !gSprites[gBattlerSpriteIds[battlerId]].invisible) + return TRUE; + + return FALSE; +} + +void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) +{ + struct BattleAnimBgData animBg; + u8 battlerSpriteId; + + if (!toBG_2) + { + u8 battlerPosition; + + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(16)), 0x2000, 1); + RequestDma3Fill(0xFF, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 0); + sub_80752A0(&animBg); + CpuFill16(0, animBg.bgTiles, 0x1000); + CpuFill16(0xFF, animBg.bgTilemap, 0x800); + + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 2); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 1); + SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0); + + battlerSpriteId = gBattlerSpriteIds[battlerId]; + + SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); + SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); + + LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], animBg.paletteId * 16, 0x20); + CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + animBg.paletteId * 32), 0x20); + + battlerPosition = GetBattlerPosition(battlerId); + + sub_80BCEF4(1, 0, 0, battlerPosition, animBg.paletteId, animBg.bgTiles, animBg.bgTilemap, animBg.tilesOffset); + } + else + { + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(12)), 0x2000, 1); + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 1); + sub_80752C8(&animBg, 2); + CpuFill16(0, animBg.bgTiles + 0x1000, 0x1000); + CpuFill16(0, animBg.bgTilemap + 0x400, 0x800); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); + SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1); + SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0); + + battlerSpriteId = gBattlerSpriteIds[battlerId]; + + gBattle_BG2_X = -(gSprites[battlerSpriteId].pos1.x + gSprites[battlerSpriteId].pos2.x) + 0x20; + gBattle_BG2_Y = -(gSprites[battlerSpriteId].pos1.y + gSprites[battlerSpriteId].pos2.y) + 0x20; + + SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X); + SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y); + + LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], 0x90, 0x20); + CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + 0x120), 0x20); + + sub_80BCEF4(2, 0, 0, GetBattlerPosition(battlerId), animBg.paletteId, animBg.bgTiles + 0x1000, animBg.bgTilemap + 0x400, animBg.tilesOffset); + } +} + +void sub_80730C0(u16 a, u16 *b, u32 c, u8 d) +{ + s32 i, j; + s32 var; + + if (d == 0) + var = 32; + else + var = 64; + a <<= 12; + for (i = 0; i < var; i++) + { + for (j = 0; j < 32; j++) + b[j + i * 32] = ((b[j + i * 32] & 0xFFF) | a) + c; + } +} + +void sub_8073128(bool8 to_BG2) +{ + struct BattleAnimBgData animBg; + sub_80752A0(&animBg); + + if (!to_BG2)) + { + sub_8075358(1); + gBattle_BG1_X = NULL; + gBattle_BG1_Y = NULL; + } + else + { + sub_8075358(2); + gBattle_BG2_X = NULL; + gBattle_BG2_Y = NULL; + } +} + +static void task_pA_ma0A_obj_to_bg_pal(u8 taskId) +{ + u8 spriteId, palIndex; + s16 x, y; + struct BattleAnimBgData animBg; + + spriteId = gTasks[taskId].data[0]; + palIndex = gTasks[taskId].data[6]; + sub_80752A0(&animBg); + x = gTasks[taskId].data[1] - (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x); + y = gTasks[taskId].data[2] - (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y); + + if (gTasks[taskId].data[5] == 0) + { + u16 *src; + u16 *dst; + + gBattle_BG1_X = x + gTasks[taskId].data[3]; + gBattle_BG1_Y = y + gTasks[taskId].data[4]; + src = gPlttBufferFaded + 0x100 + palIndex * 16; + dst = gPlttBufferFaded + 0x100 + animBg.paletteId * 16 - 256; + CpuCopy32(src, dst, 0x20); + } + else + { + u16 *src; + u16 *dst; + + gBattle_BG2_X = x + gTasks[taskId].data[3]; + gBattle_BG2_Y = y + gTasks[taskId].data[4]; + src = gPlttBufferFaded + 0x100 + palIndex * 16; + dst = gPlttBufferFaded + 0x100 - 112; + CpuCopy32(src, dst, 0x20); + } +} + +static void ScriptCmd_clearmonbg(void) +{ + u8 animBattlerId; + u8 battlerId; + u8 taskId; + + sBattleAnimScriptPtr++; + animBattlerId = sBattleAnimScriptPtr[0]; + + if (animBattlerId == ANIM_ATTACKER) + animBattlerId = ANIM_ATK_PARTNER; + else if (animBattlerId == ANIM_TARGET) + animBattlerId = ANIM_DEF_PARTNER; + + if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + battlerId = gBattleAnimAttacker; + else + battlerId = gBattleAnimTarget; + + if (sMonAnimTaskIdArray[0] != 0xFF) + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; + if (animBattlerId > 1 && sMonAnimTaskIdArray[1] != 0xFF) + gSprites[gBattlerSpriteIds[battlerId ^ BIT_FLANK]].invisible = FALSE; + else + animBattlerId = 0; + + taskId = CreateTask(sub_807331C, 5); + gTasks[taskId].data[0] = animBattlerId; + gTasks[taskId].data[2] = battlerId; + + sBattleAnimScriptPtr++; +} + +static void sub_807331C(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] != 1) + { + u8 to_BG2; + u8 position = GetBattlerPosition(gTasks[taskId].data[2]); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + to_BG2 = FALSE; + else + to_BG2 = TRUE; + + if (sMonAnimTaskIdArray[0] != 0xFF) + { + sub_8073128(to_BG2); + DestroyTask(sMonAnimTaskIdArray[0]); + sMonAnimTaskIdArray[0] = 0xFF; + } + if (gTasks[taskId].data[0] > 1) + { + sub_8073128(to_BG2 ^ 1); + DestroyTask(sMonAnimTaskIdArray[1]); + sMonAnimTaskIdArray[1] = 0xFF; + } + DestroyTask(taskId); + } +} + +static void ScriptCmd_monbg_22(void) +{ + bool8 toBG_2; + u8 battlerId; + u8 animBattlerId; + + sBattleAnimScriptPtr++; + + animBattlerId = sBattleAnimScriptPtr[0]; + + if (animBattlerId == ANIM_ATTACKER) + animBattlerId = ANIM_ATK_PARTNER; + else if (animBattlerId == ANIM_TARGET) + animBattlerId = ANIM_DEF_PARTNER; + + if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + battlerId = gBattleAnimAttacker; + else + battlerId = gBattleAnimTarget; + + if (IsBattlerSpriteVisible(battlerId)) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + + MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + } + + battlerId ^= BIT_FLANK; + if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId)) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + + MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + } + + sBattleAnimScriptPtr++; +} + +static void ScriptCmd_clearmonbg_23(void) +{ + u8 animBattlerId; + u8 battlerId; + u8 taskId; + + sBattleAnimScriptPtr++; + animBattlerId = sBattleAnimScriptPtr[0]; + + if (animBattlerId == ANIM_ATTACKER) + animBattlerId = ANIM_ATK_PARTNER; + else if (animBattlerId == ANIM_TARGET) + animBattlerId = ANIM_DEF_PARTNER; + + if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + battlerId = gBattleAnimAttacker; + else + battlerId = gBattleAnimTarget; + + if (IsBattlerSpriteVisible(battlerId)) + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; + if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) + gSprites[gBattlerSpriteIds[battlerId ^ BIT_FLANK]].invisible = FALSE; + else + animBattlerId = 0; + + taskId = CreateTask(sub_8073558, 5); + gTasks[taskId].data[0] = animBattlerId; + gTasks[taskId].data[2] = battlerId; + + sBattleAnimScriptPtr++; +} + +static void sub_8073558(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] != 1) + { + bool8 toBG_2; + u8 battlerId = gTasks[taskId].data[2]; + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + if (IsBattlerSpriteVisible(battlerId)) + sub_8073128(toBG_2); + if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) + sub_8073128(toBG_2 ^ 1); + + DestroyTask(taskId); + } +} + +#undef t1_MONBG_BATTLER +#undef t1_MON_IN_BG2 +#undef t1_CREATE_ANOTHER_TASK +#undef t1_IS_SECONDMON_BG + +#undef t2_BATTLER_SPRITE_ID +#undef t2_MON_IN_BG2 +#undef t2_MONBG_BATTLER + +static void ScriptCmd_setalpha(void) +{ + u16 half1, half2; + + sBattleAnimScriptPtr++; + half1 = *(sBattleAnimScriptPtr++); + half2 = *(sBattleAnimScriptPtr++) << 8; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, half1 | half2); +} + +static void ScriptCmd_setbldcnt(void) +{ + u16 half1, half2; + + sBattleAnimScriptPtr++; + half1 = *(sBattleAnimScriptPtr++); + half2 = *(sBattleAnimScriptPtr++) << 8; + SetGpuReg(REG_OFFSET_BLDCNT, half1 | half2); +} + +static void ScriptCmd_blendoff(void) +{ + sBattleAnimScriptPtr++; + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); +} + +static void ScriptCmd_call(void) +{ + sBattleAnimScriptPtr++; + sBattleAnimScriptRetAddr = sBattleAnimScriptPtr + 4; + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); +} + +static void ScriptCmd_return(void) +{ + sBattleAnimScriptPtr = sBattleAnimScriptRetAddr; +} + +static void ScriptCmd_setarg(void) +{ + const u8 *addr = sBattleAnimScriptPtr; + u16 value; + u8 argId; + + sBattleAnimScriptPtr++; + argId = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + value = T1_READ_16(sBattleAnimScriptPtr); + sBattleAnimScriptPtr = addr + 4; + gBattleAnimArgs[argId] = value; +} + +static void ScriptCmd_choosetwoturnanim(void) +{ + sBattleAnimScriptPtr++; + if (gAnimMoveTurn & 1) + sBattleAnimScriptPtr += 4; + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); +} + +static void ScriptCmd_jumpifmoveturn(void) +{ + u8 toCheck; + sBattleAnimScriptPtr++; + toCheck = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + + if (toCheck == gAnimMoveTurn) + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); + else + sBattleAnimScriptPtr += 4; +} + +static void ScriptCmd_goto(void) +{ + sBattleAnimScriptPtr++; + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); +} + +//unused +bool8 IsContest(void) +{ + if (!gMain.inBattle) + return TRUE; + else + return FALSE; +} + +#define tBackgroundId data[0] +#define tState data[10] + +static void ScriptCmd_fadetobg(void) +{ + u8 backgroundId; + u8 taskId; + + sBattleAnimScriptPtr++; + backgroundId = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + taskId = CreateTask(Task_FadeToBg, 5); + gTasks[taskId].tBackgroundId = backgroundId; + sAnimBackgroundFadeState = 1; +} + +static void ScriptCmd_fadetobgfromset(void) +{ + u8 bg1, bg2, bg3; + u8 taskId; + + sBattleAnimScriptPtr++; + bg1 = sBattleAnimScriptPtr[0]; + bg2 = sBattleAnimScriptPtr[1]; + bg3 = sBattleAnimScriptPtr[2]; + sBattleAnimScriptPtr += 3; + taskId = CreateTask(Task_FadeToBg, 5); + + if (IsContest()) + gTasks[taskId].tBackgroundId = bg3; + else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + gTasks[taskId].tBackgroundId = bg2; + else + gTasks[taskId].tBackgroundId = bg1; + + sAnimBackgroundFadeState = 1; +} + +static void Task_FadeToBg(u8 taskId) +{ + if (gTasks[taskId].tState == 0) + { + BeginHardwarePaletteFade(0xE8, 0, 0, 16, 0); + gTasks[taskId].tState++; + return; + } + if (gPaletteFade.active) + return; + if (gTasks[taskId].tState == 1) + { + gTasks[taskId].tState++; + sAnimBackgroundFadeState = 2; + } + else if (gTasks[taskId].tState == 2) + { + s16 bgId = gTasks[taskId].tBackgroundId; + + if (bgId == -1) + LoadDefaultBg(); + else + LoadMoveBg(bgId); + + BeginHardwarePaletteFade(0xE8, 0, 16, 0, 1); + gTasks[taskId].tState++; + return; + } + if (gPaletteFade.active) + return; + if (gTasks[taskId].tState == 3) + { + DestroyTask(taskId); + sAnimBackgroundFadeState = 0; + } +} + +static void LoadMoveBg(u16 bgId) +{ + if (IsContest()) + { + const u32 *tilemap = gBattleAnimBackgroundTable[bgId].tilemap; + void *dmaSrc; + void *dmaDest; + + LZDecompressWram(tilemap, gDecompressionBuffer); + sub_80730C0(sub_80A6D94(), (void*)(gDecompressionBuffer), 0x100, 0); + dmaSrc = gDecompressionBuffer; + dmaDest = (void *)(BG_SCREEN_ADDR(26)); + DmaCopy32(3, dmaSrc, dmaDest, 0x800); + LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_SCREEN_ADDR(4))); + LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, sub_80A6D94() * 16, 32); + } + else + { + LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26))); + LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2))); + LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32); + } +} + +static void LoadDefaultBg(void) +{ + if (IsContest()) + LoadContestBgAfterMoveAnim(); + else + DrawMainBattleBackground(); +} + +static void ScriptCmd_restorebg(void) +{ + u8 taskId; + + sBattleAnimScriptPtr++; + taskId = CreateTask(Task_FadeToBg, 5); + gTasks[taskId].tBackgroundId = -1; + sAnimBackgroundFadeState = 1; +} + +#undef tBackgroundId +#undef tState + +static void ScriptCmd_waitbgfadeout(void) +{ + if (sAnimBackgroundFadeState == 2) + { + sBattleAnimScriptPtr++; + gAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait = 1; + } +} + +static void ScriptCmd_waitbgfadein(void) +{ + if (sAnimBackgroundFadeState == 0) + { + sBattleAnimScriptPtr++; + gAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait = 1; + } +} + +static void ScriptCmd_changebg(void) +{ + sBattleAnimScriptPtr++; + LoadMoveBg(sBattleAnimScriptPtr[0]); + sBattleAnimScriptPtr++; +} + +s8 BattleAnimAdjustPanning(s8 pan) +{ + if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + pan = SOUND_PAN_TARGET; + else + pan = SOUND_PAN_ATTACKER; + } + else if (IsContest()) + { + if (gBattleAnimAttacker != gBattleAnimTarget || gBattleAnimAttacker != 2 || pan != SOUND_PAN_TARGET) + pan *= -1; + } + else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + if (pan == SOUND_PAN_TARGET) + pan = SOUND_PAN_ATTACKER; + else if (pan != SOUND_PAN_ATTACKER) + pan *= -1; + } + } + else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) + { + if (pan == SOUND_PAN_ATTACKER) + pan = SOUND_PAN_TARGET; + } + else + { + pan *= -1; + } + + if (pan > SOUND_PAN_TARGET) + pan = SOUND_PAN_TARGET; + else if (pan < SOUND_PAN_ATTACKER) + pan = SOUND_PAN_ATTACKER; + + return pan; +} + +s8 BattleAnimAdjustPanning2(s8 pan) +{ + if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + pan = SOUND_PAN_TARGET; + else + pan = SOUND_PAN_ATTACKER; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER || IsContest()) + pan = -pan; + } + return pan; +} + +s16 KeepPanInRange(s16 panArg, int oldPan) +{ + s16 pan = panArg; + + if (pan > SOUND_PAN_TARGET) + pan = SOUND_PAN_TARGET; + else if (pan < SOUND_PAN_ATTACKER) + pan = SOUND_PAN_ATTACKER; + + return pan; +} + +s16 CalculatePanIncrement(s16 sourcePan, s16 targetPan, s16 incrementPan) +{ + s16 ret; + + if (sourcePan < targetPan) + ret = ((incrementPan < 0) ? -incrementPan : incrementPan); + else if (sourcePan > targetPan) + ret = -((incrementPan < 0) ? -incrementPan : incrementPan); + else + ret = 0; + + return ret; +} + +static void ScriptCmd_playsewithpan(void) +{ + u16 songId; + s8 pan; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + pan = sBattleAnimScriptPtr[2]; + PlaySE12WithPanning(songId, BattleAnimAdjustPanning(pan)); + sBattleAnimScriptPtr += 3; +} + +static void ScriptCmd_setpan(void) +{ + s8 pan; + + sBattleAnimScriptPtr++; + pan = sBattleAnimScriptPtr[0]; + SE12PanpotControl(BattleAnimAdjustPanning(pan)); + sBattleAnimScriptPtr++; +} + +#define tInitialPan data[0] +#define tTargetPan data[1] +#define tIncrementPan data[2] +#define tFramesToWait data[3] +#define tCurrentPan data[4] +#define tFrameCounter data[8] + +static void ScriptCmd_panse_1B(void) +{ + u16 songNum; + s8 currentPanArg, incrementPan, incrementPanArg, currentPan, targetPan; + u8 framesToWait; + u8 taskId; + + sBattleAnimScriptPtr++; + songNum = T1_READ_16(sBattleAnimScriptPtr); + currentPanArg = sBattleAnimScriptPtr[2]; + incrementPan = sBattleAnimScriptPtr[3]; + incrementPanArg = sBattleAnimScriptPtr[4]; + framesToWait = sBattleAnimScriptPtr[5]; + + currentPan = BattleAnimAdjustPanning(currentPanArg); + targetPan = BattleAnimAdjustPanning(incrementPan); + incrementPan = CalculatePanIncrement(currentPan, targetPan, incrementPanArg); + taskId = CreateTask(Task_PanFromInitialToTarget, 1); + gTasks[taskId].tInitialPan = currentPan; + gTasks[taskId].tTargetPan = targetPan; + gTasks[taskId].tIncrementPan = incrementPan; + gTasks[taskId].tFramesToWait = framesToWait; + gTasks[taskId].tCurrentPan = currentPan; + + PlaySE12WithPanning(songNum, currentPan); + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 6; +} + +void Task_PanFromInitialToTarget(u8 taskId) +{ + bool32 destroyTask = FALSE; + if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait) + { + s16 pan; + s16 initialPanning, targetPanning, currentPan, incrementPan; + + gTasks[taskId].tFrameCounter = 0; + initialPanning = gTasks[taskId].tInitialPan; + targetPanning = gTasks[taskId].tTargetPan; + currentPan = gTasks[taskId].tCurrentPan; + incrementPan = gTasks[taskId].tIncrementPan; + pan = currentPan + incrementPan; + gTasks[taskId].tCurrentPan = pan; + + if (incrementPan == 0) // If we're not incrementing, just cancel the task immediately. + { + destroyTask = TRUE; + } + else if (initialPanning < targetPanning) // Panning increasing. + { + if (pan >= targetPanning) // Target reached. + destroyTask = TRUE; + } + else // Panning decreasing. + { + if (pan <= targetPanning) // Target reached. + destroyTask = TRUE; + } + + if (destroyTask) + { + pan = targetPanning; + DestroyTask(taskId); + gAnimSoundTaskCount--; + } + + SE12PanpotControl(pan); + } +} + +static void ScriptCmd_panse_26(void) +{ + u16 songId; + s8 currentPan, targetPan, incrementPan; + u8 framesToWait; + u8 taskId; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + currentPan = sBattleAnimScriptPtr[2]; + targetPan = sBattleAnimScriptPtr[3]; + incrementPan = sBattleAnimScriptPtr[4]; + framesToWait = sBattleAnimScriptPtr[5]; + + taskId = CreateTask(Task_PanFromInitialToTarget, 1); + gTasks[taskId].tInitialPan = currentPan; + gTasks[taskId].tTargetPan = targetPan; + gTasks[taskId].tIncrementPan = incrementPan; + gTasks[taskId].tFramesToWait = framesToWait; + gTasks[taskId].tCurrentPan = currentPan; + + PlaySE12WithPanning(songId, currentPan); + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 6; +} + +static void ScriptCmd_panse_27(void) +{ + u16 songId; + s8 targetPanArg, incrementPanArg, currentPanArg, currentPan, targetPan, incrementPan; + u8 framesToWait; + u8 taskId; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + currentPanArg = sBattleAnimScriptPtr[2]; + targetPanArg = sBattleAnimScriptPtr[3]; + incrementPanArg = sBattleAnimScriptPtr[4]; + framesToWait = sBattleAnimScriptPtr[5]; + + currentPan = BattleAnimAdjustPanning2(currentPanArg); + targetPan = BattleAnimAdjustPanning2(targetPanArg); + incrementPan = BattleAnimAdjustPanning2(incrementPanArg); + + taskId = CreateTask(Task_PanFromInitialToTarget, 1); + gTasks[taskId].tInitialPan = currentPan; + gTasks[taskId].tTargetPan = targetPan; + gTasks[taskId].tIncrementPan = incrementPan; + gTasks[taskId].tFramesToWait = framesToWait; + gTasks[taskId].tCurrentPan = currentPan; + + PlaySE12WithPanning(songId, currentPan); + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 6; +} + +#undef tInitialPan +#undef tTargetPan +#undef tIncrementPan +#undef tFramesToWait +#undef tCurrentPan +#undef tFrameCounter + +#define tSongId data[0] +#define tPanning data[1] +#define tFramesToWait data[2] +#define tNumberOfPlays data[3] +#define tFrameCounter data[8] + +static void ScriptCmd_loopsewithpan(void) +{ + u16 songId; + s8 panningArg, panning; + u8 framesToWait, numberOfPlays; + u8 taskId; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + panningArg = sBattleAnimScriptPtr[2]; + framesToWait = sBattleAnimScriptPtr[3]; + numberOfPlays = sBattleAnimScriptPtr[4]; + panning = BattleAnimAdjustPanning(panningArg); + + taskId = CreateTask(Task_LoopAndPlaySE, 1); + gTasks[taskId].tSongId = songId; + gTasks[taskId].tPanning = panning; + gTasks[taskId].tFramesToWait = framesToWait; + gTasks[taskId].tNumberOfPlays = numberOfPlays; + gTasks[taskId].tFrameCounter = framesToWait; + gTasks[taskId].func(taskId); + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 5; +} + +static void Task_LoopAndPlaySE(u8 taskId) +{ + if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait) + { + u16 songId; + s8 panning; + u8 numberOfPlays; + + gTasks[taskId].tFrameCounter = 0; + songId = gTasks[taskId].tSongId; + panning = gTasks[taskId].tPanning; + numberOfPlays = --gTasks[taskId].tNumberOfPlays; + PlaySE12WithPanning(songId, panning); + if (numberOfPlays == 0) + { + DestroyTask(taskId); + gAnimSoundTaskCount--; + } + } +} + +#undef tSongId +#undef tPanning +#undef tFramesToWait +#undef tNumberOfPlays +#undef tFrameCounter + +#define tSongId data[0] +#define tPanning data[1] +#define tFramesToWait data[2] + +static void ScriptCmd_waitplaysewithpan(void) +{ + u16 songId; + s8 panningArg, panning; + u8 framesToWait; + u8 taskId; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + panningArg = sBattleAnimScriptPtr[2]; + framesToWait = sBattleAnimScriptPtr[3]; + panning = BattleAnimAdjustPanning(panningArg); + + taskId = CreateTask(Task_WaitAndPlaySE, 1); + gTasks[taskId].tSongId = songId; + gTasks[taskId].tPanning = panning; + gTasks[taskId].tFramesToWait = framesToWait; + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 4; +} + +static void Task_WaitAndPlaySE(u8 taskId) +{ + if (gTasks[taskId].tFramesToWait-- <= 0) + { + PlaySE12WithPanning(gTasks[taskId].tSongId, gTasks[taskId].tPanning); + DestroyTask(taskId); + gAnimSoundTaskCount--; + } +} + +#undef tSongId +#undef tPanning +#undef tFramesToWait + +static void ScriptCmd_createsoundtask(void) +{ + TaskFunc func; + u8 numArgs, taskId; + s32 i; + + sBattleAnimScriptPtr++; + func = (TaskFunc)T2_READ_32(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 4; + numArgs = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + for (i = 0; i < numArgs; i++) + { + gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 2; + } + taskId = CreateTask(func, 1); + func(taskId); + gAnimSoundTaskCount++; +} + +static void ScriptCmd_waitsound(void) +{ + if (gAnimSoundTaskCount != 0) + { + sSoundAnimFramesToWait = 0; + gAnimFramesToWait = 1; + } + else if (IsSEPlaying()) + { + if (++sSoundAnimFramesToWait > 90) + { + m4aMPlayStop(&gMPlayInfo_SE1); + m4aMPlayStop(&gMPlayInfo_SE2); + sSoundAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait = 1; + } + } + else + { + sSoundAnimFramesToWait = 0; + sBattleAnimScriptPtr++; + gAnimFramesToWait = 0; + } +} + +static void ScriptCmd_jumpargeq(void) +{ + u8 argId; + s16 valueToCheck; + + sBattleAnimScriptPtr++; + argId = sBattleAnimScriptPtr[0]; + valueToCheck = T1_READ_16(sBattleAnimScriptPtr + 1); + + if (valueToCheck == gBattleAnimArgs[argId]) + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr + 3); + else + sBattleAnimScriptPtr += 7; +} + +static void ScriptCmd_jumpifcontest(void) +{ + sBattleAnimScriptPtr++; + if (IsContest()) + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); + else + sBattleAnimScriptPtr += 4; +} + +static void ScriptCmd_monbgprio_28(void) +{ + u8 wantedBattler; + u8 battlerId; + u8 battlerPosition; + + wantedBattler = sBattleAnimScriptPtr[1]; + sBattleAnimScriptPtr += 2; + + if (wantedBattler != ANIM_ATTACKER) + battlerId = gBattleAnimTarget; + else + battlerId = gBattleAnimAttacker; + + battlerPosition = GetBattlerPosition(battlerId); + if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT)) + { + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); + } +} + +static void ScriptCmd_monbgprio_29(void) +{ + sBattleAnimScriptPtr++; + if (!IsContest()) + { + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); + } +} + +static void ScriptCmd_monbgprio_2A(void) +{ + u8 wantedBattler; + u8 battlerPosition; + u8 battlerId; + + wantedBattler = sBattleAnimScriptPtr[1]; + sBattleAnimScriptPtr += 2; + if (GetBattlerSide(gBattleAnimAttacker) != GetBattlerSide(gBattleAnimTarget)) + { + if (wantedBattler != ANIM_ATTACKER) + battlerId = gBattleAnimTarget; + else + battlerId = gBattleAnimAttacker; + + battlerPosition = GetBattlerPosition(battlerId); + if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT)) + { + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); + } + } +} + +static void ScriptCmd_invisible(void) +{ + u8 spriteId; + + spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]); + if (spriteId != 0xFF) + gSprites[spriteId].invisible = TRUE; + + sBattleAnimScriptPtr += 2; +} + +static void ScriptCmd_visible(void) +{ + u8 spriteId; + + spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]); + if (spriteId != 0xFF) + gSprites[spriteId].invisible = FALSE; + + sBattleAnimScriptPtr += 2; +} + +static void ScriptCmd_doublebattle_2D(void) +{ + u8 wantedBattler; + u8 r4; + u8 spriteId; + + wantedBattler = sBattleAnimScriptPtr[1]; + sBattleAnimScriptPtr += 2; + if (!IsContest() && IsDoubleBattle() + && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) + { + if (wantedBattler == ANIM_ATTACKER) + { + r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + } + else + { + r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); + spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + } + if (spriteId != 0xFF) + { + gSprites[spriteId].invisible = FALSE; + if (r4 == 2) + gSprites[spriteId].oam.priority = 3; + + if (r4 == 1) + sub_8073128(FALSE); + else + sub_8073128(TRUE); + } + } +} + +static void ScriptCmd_doublebattle_2E(void) +{ + u8 wantedBattler; + u8 r4; + u8 spriteId; + + wantedBattler = sBattleAnimScriptPtr[1]; + sBattleAnimScriptPtr += 2; + if (!IsContest() && IsDoubleBattle() + && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) + { + if (wantedBattler == ANIM_ATTACKER) + { + r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + } + else + { + r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); + spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + } + + if (spriteId != 0xFF && r4 == 2) + gSprites[spriteId].oam.priority = 2; + } +} + +static void ScriptCmd_stopsound(void) +{ + m4aMPlayStop(&gMPlayInfo_SE1); + m4aMPlayStop(&gMPlayInfo_SE2); + sBattleAnimScriptPtr++; +} -- cgit v1.2.3 From 7de43f724952e43ed638e1584e3d7eceb1e3f276 Mon Sep 17 00:00:00 2001 From: Evan Date: Sun, 1 Dec 2019 11:49:27 -0500 Subject: anim particle gfx graphics names --- src/battle_anim.c | 625 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 622 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index a92cf98de..fc22231bc 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -4,7 +4,6 @@ #include "battle_controllers.h" #include "battle_interface.h" #include "bg.h" -#include "contest.h" #include "decompress.h" #include "dma3.h" #include "gpu_regs.h" @@ -21,6 +20,9 @@ // Defines #define ANIM_SPRITE_INDEX_COUNT 8 +extern const u16 gMovesWithQuietBGM[]; +extern const u8 *const gBattleAnims_Moves[]; + // RAM EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; EWRAM_DATA static const u8 *sBattleAnimScriptRetAddr = NULL; @@ -40,7 +42,7 @@ EWRAM_DATA static u16 sSoundAnimFramesToWait = 0; EWRAM_DATA static u8 sMonAnimTaskIdArray[2] = {0}; EWRAM_DATA u8 gAnimMoveTurn = 0; EWRAM_DATA static u8 sAnimBackgroundFadeState = 0; -EWRAM_DATA static u16 sAnimMoveIndex = 0; // Set but unused. +EWRAM_DATA static u16 sAnimMoveIndex = 0; EWRAM_DATA u8 gBattleAnimAttacker = 0; EWRAM_DATA u8 gBattleAnimTarget = 0; EWRAM_DATA u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT] = {0}; @@ -101,7 +103,624 @@ static void ScriptCmd_doublebattle_2E(void); static void ScriptCmd_stopsound(void); // Data -static void (* const sScriptCmdTable[])(void) = //83ADF5C +const struct CompressedSpriteSheet gBattleAnimPicTable[] = // 83ACC08 +{ + {gBattleAnimSpriteGfx_Bone, 0x0200, ANIM_TAG_BONE}, + {gBattleAnimSpriteGfx_Spark, 0x0300, ANIM_TAG_SPARK}, + {gBattleAnimSpriteGfx_Pencil, 0x0200, ANIM_TAG_PENCIL}, + {gBattleAnimSpriteGfx_AirWave, 0x0100, ANIM_TAG_AIR_WAVE}, + {gBattleAnimSpriteGfx_Orb, 0x0200, ANIM_TAG_ORB}, + {gBattleAnimSpriteGfx_Sword, 0x0400, ANIM_TAG_SWORD}, + {gBattleAnimSpriteGfx_Seed, 0x0180, ANIM_TAG_SEED}, + {gBattleAnimSpriteGfx_Explosion6, 0x0800, ANIM_TAG_EXPLOSION_6}, + {gBattleAnimSpriteGfx_PinkOrb, 0x0020, ANIM_TAG_PINK_ORB}, + {gBattleAnimSpriteGfx_Gust, 0x0400, ANIM_TAG_GUST}, + {gBattleAnimSpriteGfx_IceCube, 0x1200, ANIM_TAG_ICE_CUBE}, + {gBattleAnimSpriteGfx_Spark2, 0x0180, ANIM_TAG_SPARK_2}, + {gBattleAnimSpriteGfx_Orange, 0x0080, ANIM_TAG_ORANGE}, + {gBattleAnimSpriteGfx_YellowBall, 0x0080, ANIM_TAG_YELLOW_BALL}, + {gBattleAnimSpriteGfx_LockOn, 0x0280, ANIM_TAG_LOCK_ON}, + {gBattleAnimSpriteGfx_TiedBag, 0x0080, ANIM_TAG_TIED_BAG}, + {gBattleAnimSpriteGfx_BlackSmoke, 0x0100, ANIM_TAG_BLACK_SMOKE}, + {gBattleAnimSpriteGfx_BlackBall, 0x0020, ANIM_TAG_BLACK_BALL}, + {gBattleAnimSpriteGfx_Conversion, 0x0080, ANIM_TAG_CONVERSION}, + {gBattleAnimSpriteGfx_Glass, 0x0400, ANIM_TAG_GLASS}, + {gBattleAnimSpriteGfx_HornHit, 0x0200, ANIM_TAG_HORN_HIT}, + {gBattleAnimSpriteGfx_Hit, 0x0A00, ANIM_TAG_HIT}, + {gBattleAnimSpriteGfx_Hit, 0x0A00, ANIM_TAG_HIT_2}, + {gBattleAnimSpriteGfx_BlueShards, 0x0380, ANIM_TAG_BLUE_SHARDS}, + {gBattleAnimSpriteGfx_ClosingEye, 0x0300, ANIM_TAG_CLOSING_EYE}, + {gBattleAnimSpriteGfx_WavingHand, 0x0A00, ANIM_TAG_WAVING_HAND}, + {gBattleAnimSpriteGfx_HitDuplicate, 0x0A00, ANIM_TAG_HIT_DUPLICATE}, + {gBattleAnimSpriteGfx_Leer, 0x0A00, ANIM_TAG_LEER}, + {gBattleAnimSpriteGfx_BlueBurst, 0x0A00, ANIM_TAG_BLUE_BURST}, + {gBattleAnimSpriteGfx_SmallEmber, 0x0A00, ANIM_TAG_SMALL_EMBER}, + {gBattleAnimSpriteGfx_GraySmoke, 0x0A00, ANIM_TAG_GRAY_SMOKE}, + {gBattleAnimSpriteGfx_BlueStar, 0x0E00, ANIM_TAG_BLUE_STAR}, + {gBattleAnimSpriteGfx_BubbleBurst, 0x0380, ANIM_TAG_BUBBLE_BURST}, + {gBattleAnimSpriteGfx_Fire, 0x1000, ANIM_TAG_FIRE}, + {gBattleAnimSpriteGfx_SpinningFire, 0x0800, ANIM_TAG_SPINNING_FIRE}, + {gBattleAnimSpriteGfx_FirePlume, 0x0A00, ANIM_TAG_FIRE_PLUME}, + {gBattleAnimSpriteGfx_Lightning2, 0x0800, ANIM_TAG_LIGHTNING_2}, + {gBattleAnimSpriteGfx_Lightning, 0x0A00, ANIM_TAG_LIGHTNING}, + {gBattleAnimSpriteGfx_ClawSlash2, 0x0A00, ANIM_TAG_CLAW_SLASH_2}, + {gBattleAnimSpriteGfx_ClawSlash, 0x0A00, ANIM_TAG_CLAW_SLASH}, + {gBattleAnimSpriteGfx_Scratch3, 0x0A00, ANIM_TAG_SCRATCH_3}, + {gBattleAnimSpriteGfx_Scratch2, 0x0A00, ANIM_TAG_SCRATCH_2}, + {gBattleAnimSpriteGfx_BubbleBurst2, 0x0A00, ANIM_TAG_BUBBLE_BURST_2}, + {gBattleAnimSpriteGfx_IceChunk, 0x0A00, ANIM_TAG_ICE_CHUNK}, + {gBattleAnimSpriteGfx_Glass2, 0x0A00, ANIM_TAG_GLASS_2}, + {gBattleAnimSpriteGfx_PinkHeart2, 0x0A00, ANIM_TAG_PINK_HEART_2}, + {gBattleAnimSpriteGfx_SapDrip, 0x1000, ANIM_TAG_SAP_DRIP}, + {gBattleAnimSpriteGfx_SapDrip, 0x1000, ANIM_TAG_SAP_DRIP_2}, + {gBattleAnimSpriteGfx_Sparkle1, 0x1000, ANIM_TAG_SPARKLE_1}, + {gBattleAnimSpriteGfx_Sparkle1, 0x1000, ANIM_TAG_SPARKLE_2}, + {gBattleAnimSpriteGfx_HumanoidFoot, 0x0200, ANIM_TAG_HUMANOID_FOOT}, + {gBattleAnimSpriteGfx_MonsterFoot, 0x0200, ANIM_TAG_MONSTER_FOOT}, + {gBattleAnimSpriteGfx_HumanoidHand, 0x0200, ANIM_TAG_HUMANOID_HAND}, + {gBattleAnimSpriteGfx_NoiseLine, 0x0800, ANIM_TAG_NOISE_LINE}, + {gBattleAnimSpriteGfx_YellowUnk, 0x0080, ANIM_TAG_YELLOW_UNK}, + {gBattleAnimSpriteGfx_RedFist, 0x0200, ANIM_TAG_RED_FIST}, + {gBattleAnimSpriteGfx_SlamHit, 0x1000, ANIM_TAG_SLAM_HIT}, + {gBattleAnimSpriteGfx_Ring, 0x0180, ANIM_TAG_RING}, + {gBattleAnimSpriteGfx_Rocks, 0x0C00, ANIM_TAG_ROCKS}, + {gBattleAnimSpriteGfx_Z, 0x0100, ANIM_TAG_Z}, + {gBattleAnimSpriteGfx_YellowUnk2, 0x0040, ANIM_TAG_YELLOW_UNK_2}, + {gBattleAnimSpriteGfx_AirSlash, 0x0180, ANIM_TAG_AIR_SLASH}, + {gBattleAnimSpriteGfx_SpinningGreenOrbs, 0x0800, ANIM_TAG_SPINNING_GREEN_ORBS}, + {gBattleAnimSpriteGfx_Leaf, 0x0480, ANIM_TAG_LEAF}, + {gBattleAnimSpriteGfx_Finger, 0x0200, ANIM_TAG_FINGER}, + {gBattleAnimSpriteGfx_PoisonPowder, 0x0200, ANIM_TAG_POISON_POWDER}, + {gBattleAnimSpriteGfx_BrownTriangle, 0x0100, ANIM_TAG_BROWN_TRIANGLE}, + {gBattleAnimSpriteGfx_PoisonPowder, 0x0200, ANIM_TAG_SLEEP_POWDER}, + {gBattleAnimSpriteGfx_PoisonPowder, 0x0200, ANIM_TAG_STUN_SPORE}, + {gBattleAnimSpriteGfx_PoisonPowder, 0x0200, ANIM_TAG_POWDER}, + {gBattleAnimSpriteGfx_Sparkle3, 0x0200, ANIM_TAG_SPARKLE_3}, + {gBattleAnimSpriteGfx_Sparkle4, 0x0A00, ANIM_TAG_SPARKLE_4}, + {gBattleAnimSpriteGfx_MusicNotes, 0x0300, ANIM_TAG_MUSIC_NOTES}, + {gBattleAnimSpriteGfx_Duck, 0x0180, ANIM_TAG_DUCK}, + {gBattleAnimSpriteGfx_MudSand, 0x00A0, ANIM_TAG_MUD_SAND}, + {gBattleAnimSpriteGfx_Alert, 0x0700, ANIM_TAG_ALERT}, + {gBattleAnimSpriteGfx_BlueFlames, 0x0400, ANIM_TAG_BLUE_FLAMES}, + {gBattleAnimSpriteGfx_BlueFlames2, 0x0200, ANIM_TAG_BLUE_FLAMES_2}, + {gBattleAnimSpriteGfx_Shock4, 0x0300, ANIM_TAG_SHOCK_4}, + {gBattleAnimSpriteGfx_Shock, 0x0C00, ANIM_TAG_SHOCK}, + {gBattleAnimSpriteGfx_Bell2, 0x0A00, ANIM_TAG_BELL_2}, + {gBattleAnimSpriteGfx_PinkGlove, 0x0080, ANIM_TAG_PINK_GLOVE}, + {gBattleAnimSpriteGfx_BlueLines, 0x0040, ANIM_TAG_BLUE_LINES}, + {gBattleAnimSpriteGfx_Impact3, 0x0E00, ANIM_TAG_IMPACT_3}, + {gBattleAnimSpriteGfx_Impact2, 0x0E00, ANIM_TAG_IMPACT_2}, + {gBattleAnimSpriteGfx_Reticle, 0x0280, ANIM_TAG_RETICLE}, + {gBattleAnimSpriteGfx_Breath, 0x0200, ANIM_TAG_BREATH}, + {gBattleAnimSpriteGfx_Anger, 0x0080, ANIM_TAG_ANGER}, + {gBattleAnimSpriteGfx_Snowball, 0x00C0, ANIM_TAG_SNOWBALL}, + {gBattleAnimSpriteGfx_Vine, 0x0A00, ANIM_TAG_VINE}, + {gBattleAnimSpriteGfx_Sword2, 0x0200, ANIM_TAG_SWORD_2}, + {gBattleAnimSpriteGfx_Clapping, 0x0180, ANIM_TAG_CLAPPING}, + {gBattleAnimSpriteGfx_RedTube, 0x0080, ANIM_TAG_RED_TUBE}, + {gBattleAnimSpriteGfx_Amnesia, 0x1000, ANIM_TAG_AMNESIA}, + {gBattleAnimSpriteGfx_String2, 0x0A00, ANIM_TAG_STRING_2}, + {gBattleAnimSpriteGfx_Pencil2, 0x0180, ANIM_TAG_PENCIL_2}, + {gBattleAnimSpriteGfx_Petal, 0x0380, ANIM_TAG_PETAL}, + {gBattleAnimSpriteGfx_BentSpoon, 0x0C00, ANIM_TAG_BENT_SPOON}, + {gBattleAnimSpriteGfx_Web, 0x0200, ANIM_TAG_WEB}, + {gBattleAnimSpriteGfx_MilkBottle, 0x0200, ANIM_TAG_MILK_BOTTLE}, + {gBattleAnimSpriteGfx_Coin, 0x0200, ANIM_TAG_COIN}, + {gBattleAnimSpriteGfx_CrackedEgg, 0x0200, ANIM_TAG_CRACKED_EGG}, + {gBattleAnimSpriteGfx_HatchedEgg, 0x0400, ANIM_TAG_HATCHED_EGG}, + {gBattleAnimSpriteGfx_FreshEgg, 0x0080, ANIM_TAG_FRESH_EGG}, + {gBattleAnimSpriteGfx_Fangs, 0x0400, ANIM_TAG_FANGS}, + {gBattleAnimSpriteGfx_Explosion2, 0x0c00, ANIM_TAG_EXPLOSION_2}, + {gBattleAnimSpriteGfx_Explosion3, 0x0200, ANIM_TAG_EXPLOSION_3}, + {gBattleAnimSpriteGfx_WaterDroplet, 0x1000, ANIM_TAG_WATER_DROPLET}, + {gBattleAnimSpriteGfx_WaterDroplet2, 0x0a00, ANIM_TAG_WATER_DROPLET_2}, + {gBattleAnimSpriteGfx_Seed2, 0x0020, ANIM_TAG_SEED_2}, + {gBattleAnimSpriteGfx_Sprout, 0x0e00, ANIM_TAG_SPROUT}, + {gBattleAnimSpriteGfx_RedWand, 0x0080, ANIM_TAG_RED_WAND}, + {gBattleAnimSpriteGfx_PurpleGreenUnk, 0x0a00, ANIM_TAG_PURPLE_GREEN_UNK}, + {gBattleAnimSpriteGfx_WaterColumn, 0x0400, ANIM_TAG_WATER_COLUMN}, + {gBattleAnimSpriteGfx_MudUnk, 0x0200, ANIM_TAG_MUD_UNK}, + {gBattleAnimSpriteGfx_RainDrops, 0x0700, ANIM_TAG_RAIN_DROPS}, + {gBattleAnimSpriteGfx_FurySwipes, 0x0800, ANIM_TAG_FURY_SWIPES}, + {gBattleAnimSpriteGfx_Vine2, 0x0a00, ANIM_TAG_VINE_2}, + {gBattleAnimSpriteGfx_Teeth, 0x0600, ANIM_TAG_TEETH}, + {gBattleAnimSpriteGfx_Bone2, 0x0800, ANIM_TAG_BONE_2}, + {gBattleAnimSpriteGfx_WhiteBag, 0x0200, ANIM_TAG_WHITE_BAG}, + {gBattleAnimSpriteGfx_Unknown, 0x0040, ANIM_TAG_UNKNOWN}, + {gBattleAnimSpriteGfx_PurpleCoral, 0x0180, ANIM_TAG_PURPLE_CORAL}, + {gBattleAnimSpriteGfx_PurpleDroplet, 0x0600, ANIM_TAG_PURPLE_DROPLET}, + {gBattleAnimSpriteGfx_Shock2, 0x0600, ANIM_TAG_SHOCK_2}, + {gBattleAnimSpriteGfx_ClosingEye2, 0x0200, ANIM_TAG_CLOSING_EYE_2}, + {gBattleAnimSpriteGfx_MetalBall, 0x0080, ANIM_TAG_METAL_BALL}, + {gBattleAnimSpriteGfx_MonsterDoll, 0x0200, ANIM_TAG_MONSTER_DOLL}, + {gBattleAnimSpriteGfx_Whirlwind, 0x0800, ANIM_TAG_WHIRLWIND}, + {gBattleAnimSpriteGfx_Whirlwind2, 0x0080, ANIM_TAG_WHIRLWIND_2}, + {gBattleAnimSpriteGfx_Explosion4, 0x0a00, ANIM_TAG_EXPLOSION_4}, + {gBattleAnimSpriteGfx_Explosion5, 0x0280, ANIM_TAG_EXPLOSION_5}, + {gBattleAnimSpriteGfx_Tongue, 0x0280, ANIM_TAG_TONGUE}, + {gBattleAnimSpriteGfx_Smoke, 0x0100, ANIM_TAG_SMOKE}, + {gBattleAnimSpriteGfx_Smoke2, 0x0200, ANIM_TAG_SMOKE_2}, + {gBattleAnimSpriteGfx_Impact, 0x0200, ANIM_TAG_IMPACT}, + {gBattleAnimSpriteGfx_CircleImpact, 0x0020, ANIM_TAG_CIRCLE_IMPACT}, + {gBattleAnimSpriteGfx_Scratch, 0x0a00, ANIM_TAG_SCRATCH}, + {gBattleAnimSpriteGfx_Cut, 0x0800, ANIM_TAG_CUT}, + {gBattleAnimSpriteGfx_SharpTeeth, 0x0800, ANIM_TAG_SHARP_TEETH}, + {gBattleAnimSpriteGfx_RainbowRings, 0x00c0, ANIM_TAG_RAINBOW_RINGS}, + {gBattleAnimSpriteGfx_IceCrystals, 0x01c0, ANIM_TAG_ICE_CRYSTALS}, + {gBattleAnimSpriteGfx_IceSpikes, 0x0100, ANIM_TAG_ICE_SPIKES}, + {gBattleAnimSpriteGfx_HandsAndFeet, 0x0800, ANIM_TAG_HANDS_AND_FEET}, + {gBattleAnimSpriteGfx_MistCloud, 0x0200, ANIM_TAG_MIST_CLOUD}, + {gBattleAnimSpriteGfx_Clamp, 0x0800, ANIM_TAG_CLAMP}, + {gBattleAnimSpriteGfx_Bubble, 0x0180, ANIM_TAG_BUBBLE}, + {gBattleAnimSpriteGfx_Orbs, 0x0180, ANIM_TAG_ORBS}, + {gBattleAnimSpriteGfx_WaterImpact, 0x0200, ANIM_TAG_WATER_IMPACT}, + {gBattleAnimSpriteGfx_WaterOrb, 0x0200, ANIM_TAG_WATER_ORB}, + {gBattleAnimSpriteGfx_PoisonBubble, 0x0180, ANIM_TAG_POISON_BUBBLE}, + {gBattleAnimSpriteGfx_ToxicBubble, 0x0400, ANIM_TAG_TOXIC_BUBBLE}, + {gBattleAnimSpriteGfx_Spikes, 0x0080, ANIM_TAG_SPIKES}, + {gBattleAnimSpriteGfx_HornHit2, 0x0100, ANIM_TAG_HORN_HIT_2}, + {gBattleAnimSpriteGfx_AirWave2, 0x0100, ANIM_TAG_AIR_WAVE_2}, + {gBattleAnimSpriteGfx_SmallBubbles, 0x0140, ANIM_TAG_SMALL_BUBBLES}, + {gBattleAnimSpriteGfx_RoundShadow, 0x0800, ANIM_TAG_ROUND_SHADOW}, + {gBattleAnimSpriteGfx_Sunlight, 0x0200, ANIM_TAG_SUNLIGHT}, + {gBattleAnimSpriteGfx_Spore, 0x0100, ANIM_TAG_SPORE}, + {gBattleAnimSpriteGfx_Flower, 0x00a0, ANIM_TAG_FLOWER}, + {gBattleAnimSpriteGfx_RazorLeaf, 0x0100, ANIM_TAG_RAZOR_LEAF}, + {gBattleAnimSpriteGfx_Needle, 0x0080, ANIM_TAG_NEEDLE}, + {gBattleAnimSpriteGfx_WhirlwindLines, 0x0300, ANIM_TAG_WHIRLWIND_LINES}, + {gBattleAnimSpriteGfx_GoldRing, 0x0100, ANIM_TAG_GOLD_RING}, + {gBattleAnimSpriteGfx_GoldRing, 0x0100, ANIM_TAG_PURPLE_RING}, + {gBattleAnimSpriteGfx_GoldRing, 0x0100, ANIM_TAG_BLUE_RING}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_GREEN_LIGHT_WALL}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_BLUE_LIGHT_WALL}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_RED_LIGHT_WALL}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_GRAY_LIGHT_WALL}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_ORANGE_LIGHT_WALL}, + {gBattleAnimSpriteGfx_BlackBall2, 0x0080, ANIM_TAG_BLACK_BALL_2}, + {gBattleAnimSpriteGfx_MistCloud, 0x0200, ANIM_TAG_PURPLE_GAS_CLOUD}, + {gBattleAnimSpriteGfx_SparkH, 0x0200, ANIM_TAG_SPARK_H}, + {gBattleAnimSpriteGfx_YellowStar, 0x0200, ANIM_TAG_YELLOW_STAR}, + {gBattleAnimSpriteGfx_LargeFreshEgg, 0x0080, ANIM_TAG_LARGE_FRESH_EGG}, + {gBattleAnimSpriteGfx_ShadowBall, 0x0200, ANIM_TAG_SHADOW_BALL}, + {gBattleAnimSpriteGfx_Lick, 0x0500, ANIM_TAG_LICK}, + {gBattleAnimSpriteGfx_VoidLines, 0x0800, ANIM_TAG_VOID_LINES}, + {gBattleAnimSpriteGfx_String, 0x0400, ANIM_TAG_STRING}, + {gBattleAnimSpriteGfx_WebThread, 0x0020, ANIM_TAG_WEB_THREAD}, + {gBattleAnimSpriteGfx_SpiderWeb, 0x0800, ANIM_TAG_SPIDER_WEB}, + {gBattleAnimSpriteGfx_Lightbulb, 0x0100, ANIM_TAG_LIGHTBULB}, + {gBattleAnimSpriteGfx_Slash, 0x0800, ANIM_TAG_SLASH}, + {gBattleAnimSpriteGfx_FocusEnergy, 0x0400, ANIM_TAG_FOCUS_ENERGY}, + {gBattleAnimSpriteGfx_SphereToCube, 0x0a00, ANIM_TAG_SPHERE_TO_CUBE}, + {gBattleAnimSpriteGfx_Tendrils, 0x1000, ANIM_TAG_TENDRILS}, + {gBattleAnimSpriteGfx_Eye, 0x0800, ANIM_TAG_EYE}, + {gBattleAnimSpriteGfx_WhiteShadow, 0x0400, ANIM_TAG_WHITE_SHADOW}, + {gBattleAnimSpriteGfx_TealAlert, 0x0200, ANIM_TAG_TEAL_ALERT}, + {gBattleAnimSpriteGfx_OpeningEye, 0x0800, ANIM_TAG_OPENING_EYE}, + {gBattleAnimSpriteGfx_RoundWhiteHalo, 0x0800, ANIM_TAG_ROUND_WHITE_HALO}, + {gBattleAnimSpriteGfx_FangAttack, 0x0800, ANIM_TAG_FANG_ATTACK}, + {gBattleAnimSpriteGfx_PurpleHandOutline, 0x0200, ANIM_TAG_PURPLE_HAND_OUTLINE}, + {gBattleAnimSpriteGfx_Moon, 0x0800, ANIM_TAG_MOON}, + {gBattleAnimSpriteGfx_GreenSparkle, 0x0200, ANIM_TAG_GREEN_SPARKLE}, + {gBattleAnimSpriteGfx_Spiral, 0x0800, ANIM_TAG_SPIRAL}, + {gBattleAnimSpriteGfx_SnoreZ, 0x0200, ANIM_TAG_SNORE_Z}, + {gBattleAnimSpriteGfx_Explosion, 0x0800, ANIM_TAG_EXPLOSION}, + {gBattleAnimSpriteGfx_Nail, 0x0400, ANIM_TAG_NAIL}, + {gBattleAnimSpriteGfx_GhostlySpirit, 0x0200, ANIM_TAG_GHOSTLY_SPIRIT}, + {gBattleAnimSpriteGfx_WarmRock, 0x0a80, ANIM_TAG_WARM_ROCK}, + {gBattleAnimSpriteGfx_BreakingEgg, 0x0600, ANIM_TAG_BREAKING_EGG}, + {gBattleAnimSpriteGfx_ThinRing, 0x0800, ANIM_TAG_THIN_RING}, + {gBattleAnimSpriteGfx_PunchImpact, 0x0200, ANIM_TAG_PUNCH_IMPACT}, + {gBattleAnimSpriteGfx_Bell, 0x0600, ANIM_TAG_BELL}, + {gBattleAnimSpriteGfx_MusicNotes2, 0x0800, ANIM_TAG_MUSIC_NOTES_2}, + {gBattleAnimSpriteGfx_SpeedDust, 0x0180, ANIM_TAG_SPEED_DUST}, + {gBattleAnimSpriteGfx_TornMetal, 0x0800, ANIM_TAG_TORN_METAL}, + {gBattleAnimSpriteGfx_ThoughtBubble, 0x0800, ANIM_TAG_THOUGHT_BUBBLE}, + {gBattleAnimSpriteGfx_MagentaHeart, 0x0080, ANIM_TAG_MAGENTA_HEART}, + {gBattleAnimSpriteGfx_ElectricOrbs, 0x0080, ANIM_TAG_ELECTRIC_ORBS}, + {gBattleAnimSpriteGfx_CircleOfLight, 0x0800, ANIM_TAG_CIRCLE_OF_LIGHT}, + {gBattleAnimSpriteGfx_Electricity, 0x0800, ANIM_TAG_ELECTRICITY}, + {gBattleAnimSpriteGfx_Finger2, 0x0600, ANIM_TAG_FINGER_2}, + {gBattleAnimSpriteGfx_MovementWaves, 0x0600, ANIM_TAG_MOVEMENT_WAVES}, + {gBattleAnimSpriteGfx_MagentaHeart, 0x0080, ANIM_TAG_RED_HEART}, + {gBattleAnimSpriteGfx_RedOrb, 0x0080, ANIM_TAG_RED_ORB}, + {gBattleAnimSpriteGfx_EyeSparkle, 0x0180, ANIM_TAG_EYE_SPARKLE}, + {gBattleAnimSpriteGfx_MagentaHeart, 0x0080, ANIM_TAG_PINK_HEART}, + {gBattleAnimSpriteGfx_Angel, 0x0200, ANIM_TAG_ANGEL}, + {gBattleAnimSpriteGfx_Devil, 0x0400, ANIM_TAG_DEVIL}, + {gBattleAnimSpriteGfx_Swipe, 0x0a00, ANIM_TAG_SWIPE}, + {gBattleAnimSpriteGfx_Roots, 0x0800, ANIM_TAG_ROOTS}, + {gBattleAnimSpriteGfx_ItemBag, 0x0200, ANIM_TAG_ITEM_BAG}, + {gBattleAnimSpriteGfx_JaggedMusicNote, 0x0400, ANIM_TAG_JAGGED_MUSIC_NOTE}, + {gBattleAnimSpriteGfx_Pokeball, 0x0080, ANIM_TAG_POKEBALL}, + {gBattleAnimSpriteGfx_Spotlight, 0x0800, ANIM_TAG_SPOTLIGHT}, + {gBattleAnimSpriteGfx_LetterZ, 0x0200, ANIM_TAG_LETTER_Z}, + {gBattleAnimSpriteGfx_RapidSpin, 0x0300, ANIM_TAG_RAPID_SPIN}, + {gBattleAnimSpriteGfx_TriForceTriangle, 0x0800, ANIM_TAG_TRI_FORCE_TRIANGLE}, + {gBattleAnimSpriteGfx_WispOrb, 0x0380, ANIM_TAG_WISP_ORB}, + {gBattleAnimSpriteGfx_WispFire, 0x0800, ANIM_TAG_WISP_FIRE}, + {gBattleAnimSpriteGfx_GoldStars, 0x00c0, ANIM_TAG_GOLD_STARS}, + {gBattleAnimSpriteGfx_EclipsingOrb, 0x0800, ANIM_TAG_ECLIPSING_ORB}, + {gBattleAnimSpriteGfx_GrayOrb, 0x0060, ANIM_TAG_GRAY_ORB}, + {gBattleAnimSpriteGfx_GrayOrb, 0x0060, ANIM_TAG_BLUE_ORB}, + {gBattleAnimSpriteGfx_GrayOrb, 0x0060, ANIM_TAG_RED_ORB_2}, + {gBattleAnimSpriteGfx_PinkPetal, 0x0080, ANIM_TAG_PINK_PETAL}, + {gBattleAnimSpriteGfx_PainSplit, 0x0180, ANIM_TAG_PAIN_SPLIT}, + {gBattleAnimSpriteGfx_Confetti, 0x0180, ANIM_TAG_CONFETTI}, + {gBattleAnimSpriteGfx_GreenStar, 0x0200, ANIM_TAG_GREEN_STAR}, + {gBattleAnimSpriteGfx_PinkCloud, 0x0200, ANIM_TAG_PINK_CLOUD}, + {gBattleAnimSpriteGfx_SweatDrop, 0x0020, ANIM_TAG_SWEAT_DROP}, + {gBattleAnimSpriteGfx_GuardRing, 0x0400, ANIM_TAG_GUARD_RING}, + {gBattleAnimSpriteGfx_PurpleScratch, 0x0600, ANIM_TAG_PURPLE_SCRATCH}, + {gBattleAnimSpriteGfx_PurpleSwipe, 0x1000, ANIM_TAG_PURPLE_SWIPE}, + {gBattleAnimSpriteGfx_TagHand, 0x0400, ANIM_TAG_TAG_HAND}, + {gBattleAnimSpriteGfx_SmallRedEye, 0x0020, ANIM_TAG_SMALL_RED_EYE}, + {gBattleAnimSpriteGfx_HollowOrb, 0x0080, ANIM_TAG_HOLLOW_ORB}, + {gBattleAnimSpriteGfx_XSign, 0x0800, ANIM_TAG_X_SIGN}, + {gBattleAnimSpriteGfx_BluegreenOrb, 0x0080, ANIM_TAG_BLUEGREEN_ORB}, + {gBattleAnimSpriteGfx_PawPrint, 0x0200, ANIM_TAG_PAW_PRINT}, + {gBattleAnimSpriteGfx_PurpleFlame, 0x0400, ANIM_TAG_PURPLE_FLAME}, + {gBattleAnimSpriteGfx_RedBall, 0x0200, ANIM_TAG_RED_BALL}, + {gBattleAnimSpriteGfx_SmellingsaltEffect, 0x0200, ANIM_TAG_SMELLINGSALT_EFFECT}, + {gBattleAnimSpriteGfx_Meteor, 0x0800, ANIM_TAG_METEOR}, + {gBattleAnimSpriteGfx_FlatRock, 0x0280, ANIM_TAG_FLAT_ROCK}, + {gBattleAnimSpriteGfx_MagnifyingGlass, 0x0200, ANIM_TAG_MAGNIFYING_GLASS}, + {gBattleAnimSpriteGfx_WaterOrb, 0x0200, ANIM_TAG_BROWN_ORB}, + {gBattleAnimSpriteGfx_MetalSoundWaves, 0x0400, ANIM_TAG_METAL_SOUND_WAVES}, + {gBattleAnimSpriteGfx_FlyingDirt, 0x0200, ANIM_TAG_FLYING_DIRT}, + {gBattleAnimSpriteGfx_IcicleSpear, 0x0200, ANIM_TAG_ICICLE_SPEAR}, + {gBattleAnimSpriteGfx_Hail, 0x0080, ANIM_TAG_HAIL}, + {gBattleAnimSpriteGfx_GlowyRedOrb, 0x0020, ANIM_TAG_GLOWY_RED_ORB}, + {gBattleAnimSpriteGfx_GlowyRedOrb, 0x0020, ANIM_TAG_GLOWY_GREEN_ORB}, + {gBattleAnimSpriteGfx_GreenSpike, 0x0080, ANIM_TAG_GREEN_SPIKE}, + {gBattleAnimSpriteGfx_CircleOfLight, 0x0800, ANIM_TAG_WHITE_CIRCLE_OF_LIGHT}, + {gBattleAnimSpriteGfx_GlowyRedOrb, 0x0020, ANIM_TAG_GLOWY_BLUE_ORB}, + {gBattleAnimSpriteGfx_Pokeblock, 0x0080, ANIM_TAG_POKEBLOCK}, + {gBattleAnimSpriteGfx_WhiteFeather, 0x0400, ANIM_TAG_WHITE_FEATHER}, + {gBattleAnimSpriteGfx_Sparkle6, 0x0080, ANIM_TAG_SPARKLE_6}, + {gBattleAnimSpriteGfx_Splash, 0x0800, ANIM_TAG_SPLASH}, + {gBattleAnimSpriteGfx_SweatBead, 0x0020, ANIM_TAG_SWEAT_BEAD}, + {gBattleAnimSpriteGfx_Gem1, 0x0800, ANIM_TAG_GEM_1}, + {gBattleAnimSpriteGfx_Gem2, 0x0800, ANIM_TAG_GEM_2}, + {gBattleAnimSpriteGfx_Gem3, 0x0800, ANIM_TAG_GEM_3}, + {gBattleAnimSpriteGfx_SlamHit2, 0x1000, ANIM_TAG_SLAM_HIT_2}, + {gBattleAnimSpriteGfx_Recycle, 0x0800, ANIM_TAG_RECYCLE}, + {gBattleAnimSpriteGfx_RedParticles, 0x00a0, ANIM_TAG_RED_PARTICLES}, + {gBattleAnimSpriteGfx_Protect, 0x0800, ANIM_TAG_PROTECT}, + {gBattleAnimSpriteGfx_DirtMound, 0x0200, ANIM_TAG_DIRT_MOUND}, + {gBattleAnimSpriteGfx_Shock3, 0x0600, ANIM_TAG_SHOCK_3}, + {gBattleAnimSpriteGfx_WeatherBall, 0x0200, ANIM_TAG_WEATHER_BALL}, + {gBattleAnimSpriteGfx_Bird, 0x0800, ANIM_TAG_BIRD}, + {gBattleAnimSpriteGfx_CrossImpact, 0x0200, ANIM_TAG_CROSS_IMPACT}, + {gBattleAnimSpriteGfx_Slash, 0x0800, ANIM_TAG_SLASH_2}, + {gBattleAnimSpriteGfx_SlamHit, 0x1000, ANIM_TAG_WHIP_HIT}, + {gBattleAnimSpriteGfx_GoldRing, 0x0100, ANIM_TAG_BLUE_RING_2}, +}; + +const struct CompressedSpritePalette gBattleAnimPaletteTable[] = +{ + {gBattleAnimSpritePal_Bone, ANIM_TAG_BONE}, + {gBattleAnimSpritePal_Spark, ANIM_TAG_SPARK}, + {gBattleAnimSpritePal_Pencil, ANIM_TAG_PENCIL}, + {gBattleAnimSpritePal_AirWave, ANIM_TAG_AIR_WAVE}, + {gBattleAnimSpritePal_Orb, ANIM_TAG_ORB}, + {gBattleAnimSpritePal_Sword, ANIM_TAG_SWORD}, + {gBattleAnimSpritePal_Seed, ANIM_TAG_SEED}, + {gBattleAnimSpritePal_Explosion6, ANIM_TAG_EXPLOSION_6}, + {gBattleAnimSpritePal_PinkOrb, ANIM_TAG_PINK_ORB}, + {gBattleAnimSpritePal_Gust, ANIM_TAG_GUST}, + {gBattleAnimSpritePal_IceCube, ANIM_TAG_ICE_CUBE}, + {gBattleAnimSpritePal_Spark2, ANIM_TAG_SPARK_2}, + {gBattleAnimSpritePal_Orange, ANIM_TAG_ORANGE}, + {gBattleAnimSpritePal_YellowBall, ANIM_TAG_YELLOW_BALL}, + {gBattleAnimSpritePal_LockOn, ANIM_TAG_LOCK_ON}, + {gBattleAnimSpritePal_TiedBag, ANIM_TAG_TIED_BAG}, + {gBattleAnimSpritePal_BlackSmoke, ANIM_TAG_BLACK_SMOKE}, + {gBattleAnimSpritePal_BlackSmoke, ANIM_TAG_BLACK_BALL}, + {gBattleAnimSpritePal_Conversion, ANIM_TAG_CONVERSION}, + {gBattleAnimSpritePal_Glass, ANIM_TAG_GLASS}, + {gBattleAnimSpritePal_HornHit, ANIM_TAG_HORN_HIT}, + {gBattleAnimSpritePal_Hit, ANIM_TAG_HIT}, + {gBattleAnimSpritePal_Hit2, ANIM_TAG_HIT_2}, + {gBattleAnimSpritePal_BlueShards, ANIM_TAG_BLUE_SHARDS}, + {gBattleAnimSpritePal_ClosingEye, ANIM_TAG_CLOSING_EYE}, + {gBattleAnimSpritePal_WavingHand, ANIM_TAG_WAVING_HAND}, + {gBattleAnimSpritePal_HitDuplicate, ANIM_TAG_HIT_DUPLICATE}, + {gBattleAnimSpritePal_Leer, ANIM_TAG_LEER}, + {gBattleAnimSpritePal_BlueBurst, ANIM_TAG_BLUE_BURST}, + {gBattleAnimSpritePal_SmallEmber, ANIM_TAG_SMALL_EMBER}, + {gBattleAnimSpritePal_GraySmoke, ANIM_TAG_GRAY_SMOKE}, + {gBattleAnimSpritePal_BlueStar, ANIM_TAG_BLUE_STAR}, + {gBattleAnimSpritePal_BubbleBurst, ANIM_TAG_BUBBLE_BURST}, + {gBattleAnimSpritePal_Fire, ANIM_TAG_FIRE}, + {gBattleAnimSpritePal_Fire, ANIM_TAG_SPINNING_FIRE}, + {gBattleAnimSpritePal_Fire, ANIM_TAG_FIRE_PLUME}, + {gBattleAnimSpritePal_Lightning2, ANIM_TAG_LIGHTNING_2}, + {gBattleAnimSpritePal_Lightning2, ANIM_TAG_LIGHTNING}, + {gBattleAnimSpritePal_ClawSlash2, ANIM_TAG_CLAW_SLASH_2}, + {gBattleAnimSpritePal_ClawSlash, ANIM_TAG_CLAW_SLASH}, + {gBattleAnimSpritePal_ClawSlash2, ANIM_TAG_SCRATCH_3}, + {gBattleAnimSpritePal_ClawSlash2, ANIM_TAG_SCRATCH_2}, + {gBattleAnimSpritePal_BubbleBurst2, ANIM_TAG_BUBBLE_BURST_2}, + {gBattleAnimSpritePal_IceChunk, ANIM_TAG_ICE_CHUNK}, + {gBattleAnimSpritePal_Glass2, ANIM_TAG_GLASS_2}, + {gBattleAnimSpritePal_PinkHeart2, ANIM_TAG_PINK_HEART_2}, + {gBattleAnimSpritePal_SapDrip, ANIM_TAG_SAP_DRIP}, + {gBattleAnimSpritePal_SapDrip2, ANIM_TAG_SAP_DRIP}, + {gBattleAnimSpritePal_Sparkle1, ANIM_TAG_SPARKLE_1}, + {gBattleAnimSpritePal_Sparkle2, ANIM_TAG_SPARKLE_2}, + {gBattleAnimSpritePal_HumanoidFoot, ANIM_TAG_HUMANOID_FOOT}, + {gBattleAnimSpritePal_HumanoidFoot, ANIM_TAG_MONSTER_FOOT}, + {gBattleAnimSpritePal_HumanoidFoot, ANIM_TAG_HUMANOID_HAND}, + {gBattleAnimSpritePal_HitDuplicate, ANIM_TAG_NOISE_LINE}, + {gBattleAnimSpritePal_YellowUnk, ANIM_TAG_YELLOW_UNK}, + {gBattleAnimSpritePal_HumanoidFoot, ANIM_TAG_RED_FIST}, + {gBattleAnimSpritePal_SlamHit, ANIM_TAG_SLAM_HIT}, + {gBattleAnimSpritePal_Ring, ANIM_TAG_RING}, + {gBattleAnimSpritePal_Rocks, ANIM_TAG_ROCKS}, + {gBattleAnimSpritePal_Z, ANIM_TAG_Z}, + {gBattleAnimSpritePal_YellowUnk2, ANIM_TAG_YELLOW_UNK_2}, + {gBattleAnimSpritePal_AirSlash, ANIM_TAG_AIR_SLASH}, + {gBattleAnimSpritePal_SpinningGreenOrbs, ANIM_TAG_SPINNING_GREEN_ORBS}, + {gBattleAnimSpritePal_Leaf, ANIM_TAG_LEAF}, + {gBattleAnimSpritePal_Finger, ANIM_TAG_FINGER}, + {gBattleAnimSpritePal_PoisonPowder, ANIM_TAG_POISON_POWDER}, + {gBattleAnimSpritePal_BrownTriangle, ANIM_TAG_BROWN_TRIANGLE}, + {gBattleAnimSpritePal_SleepPowder, ANIM_TAG_SLEEP_POWDER}, + {gBattleAnimSpritePal_StunSpore, ANIM_TAG_STUN_SPORE}, + {gBattleAnimSpritePal_PoisonPowder, ANIM_TAG_POWDER}, + {gBattleAnimSpritePal_Sparkle3, ANIM_TAG_SPARKLE_3}, + {gBattleAnimSpritePal_Sparkle3, ANIM_TAG_SPARKLE_4}, + {gBattleAnimSpritePal_MusicNotes, ANIM_TAG_MUSIC_NOTES}, + {gBattleAnimSpritePal_Duck, ANIM_TAG_DUCK}, + {gBattleAnimSpritePal_MudSand, ANIM_TAG_MUD_SAND}, + {gBattleAnimSpritePal_Alert, ANIM_TAG_ALERT}, + {gBattleAnimSpritePal_BlueFlames, ANIM_TAG_BLUE_FLAMES}, + {gBattleAnimSpritePal_BlueFlames, ANIM_TAG_BLUE_FLAMES_2}, + {gBattleAnimSpritePal_Shock4, ANIM_TAG_SHOCK_4}, + {gBattleAnimSpritePal_Shock4, ANIM_TAG_SHOCK}, + {gBattleAnimSpritePal_Bell2, ANIM_TAG_BELL_2}, + {gBattleAnimSpritePal_PinkGlove, ANIM_TAG_PINK_GLOVE}, + {gBattleAnimSpritePal_BlueLines, ANIM_TAG_BLUE_LINES}, + {gBattleAnimSpritePal_Impact3, ANIM_TAG_IMPACT_3}, + {gBattleAnimSpritePal_Impact2, ANIM_TAG_IMPACT_2}, + {gBattleAnimSpritePal_Reticle, ANIM_TAG_RETICLE}, + {gBattleAnimSpritePal_Breath, ANIM_TAG_BREATH}, + {gBattleAnimSpritePal_Anger, ANIM_TAG_ANGER}, + {gBattleAnimSpritePal_Snowball, ANIM_TAG_SNOWBALL}, + {gBattleAnimSpritePal_Vine, ANIM_TAG_VINE}, + {gBattleAnimSpritePal_Sword2, ANIM_TAG_SWORD_2}, + {gBattleAnimSpritePal_Clapping, ANIM_TAG_CLAPPING}, + {gBattleAnimSpritePal_RedTube, ANIM_TAG_RED_TUBE}, + {gBattleAnimSpritePal_Amnesia, ANIM_TAG_AMNESIA}, + {gBattleAnimSpritePal_String2, ANIM_TAG_STRING_2}, + {gBattleAnimSpritePal_Pencil2, ANIM_TAG_PENCIL_2}, + {gBattleAnimSpritePal_Petal, ANIM_TAG_PETAL}, + {gBattleAnimSpritePal_BentSpoon, ANIM_TAG_BENT_SPOON}, + {gBattleAnimSpritePal_String2, ANIM_TAG_WEB}, + {gBattleAnimSpritePal_MilkBottle, ANIM_TAG_MILK_BOTTLE}, + {gBattleAnimSpritePal_Coin, ANIM_TAG_COIN}, + {gBattleAnimSpritePal_CrackedEgg, ANIM_TAG_CRACKED_EGG}, + {gBattleAnimSpritePal_CrackedEgg, ANIM_TAG_HATCHED_EGG}, + {gBattleAnimSpritePal_FreshEgg, ANIM_TAG_FRESH_EGG}, + {gBattleAnimSpritePal_Fangs, ANIM_TAG_FANGS}, + {gBattleAnimSpritePal_Explosion2, ANIM_TAG_EXPLOSION_2}, + {gBattleAnimSpritePal_Explosion2, ANIM_TAG_EXPLOSION_3}, + {gBattleAnimSpritePal_WaterDroplet, ANIM_TAG_WATER_DROPLET}, + {gBattleAnimSpritePal_WaterDroplet, ANIM_TAG_WATER_DROPLET_2}, + {gBattleAnimSpritePal_Seed2, ANIM_TAG_SEED_2}, + {gBattleAnimSpritePal_Seed2, ANIM_TAG_SPROUT}, + {gBattleAnimSpritePal_RedWand, ANIM_TAG_RED_WAND}, + {gBattleAnimSpritePal_PurpleGreenUnk, ANIM_TAG_PURPLE_GREEN_UNK}, + {gBattleAnimSpritePal_WaterColumn, ANIM_TAG_WATER_COLUMN}, + {gBattleAnimSpritePal_MudUnk, ANIM_TAG_MUD_UNK}, + {gBattleAnimSpritePal_RainDrops, ANIM_TAG_RAIN_DROPS}, + {gBattleAnimSpritePal_FurySwipes, ANIM_TAG_FURY_SWIPES}, + {gBattleAnimSpritePal_Vine2, ANIM_TAG_VINE_2}, + {gBattleAnimSpritePal_Teeth, ANIM_TAG_TEETH}, + {gBattleAnimSpritePal_Bone2, ANIM_TAG_BONE_2}, + {gBattleAnimSpritePal_WhiteBag, ANIM_TAG_WHITE_BAG}, + {gBattleAnimSpritePal_Unknown, ANIM_TAG_UNKNOWN}, + {gBattleAnimSpritePal_PurpleCoral, ANIM_TAG_PURPLE_CORAL}, + {gBattleAnimSpritePal_PurpleCoral, ANIM_TAG_PURPLE_DROPLET}, + {gBattleAnimSpritePal_Shock2, ANIM_TAG_SHOCK_2}, + {gBattleAnimSpritePal_ClosingEye2, ANIM_TAG_CLOSING_EYE_2}, + {gBattleAnimSpritePal_MetalBall, ANIM_TAG_METAL_BALL}, + {gBattleAnimSpritePal_MonsterDoll, ANIM_TAG_MONSTER_DOLL}, + {gBattleAnimSpritePal_Whirlwind, ANIM_TAG_WHIRLWIND}, + {gBattleAnimSpritePal_Whirlwind, ANIM_TAG_WHIRLWIND_2}, + {gBattleAnimSpritePal_Explosion4, ANIM_TAG_EXPLOSION_4}, + {gBattleAnimSpritePal_Explosion4, ANIM_TAG_EXPLOSION_5}, + {gBattleAnimSpritePal_Tongue, ANIM_TAG_TONGUE}, + {gBattleAnimSpritePal_Smoke, ANIM_TAG_SMOKE}, + {gBattleAnimSpritePal_Smoke, ANIM_TAG_SMOKE_2}, + {gBattleAnimSpritePal_Impact, ANIM_TAG_IMPACT}, + {gBattleAnimSpritePal_CircleImpact, ANIM_TAG_CIRCLE_IMPACT}, + {gBattleAnimSpritePal_Impact, ANIM_TAG_SCRATCH}, + {gBattleAnimSpritePal_Impact, ANIM_TAG_CUT}, + {gBattleAnimSpritePal_SharpTeeth, ANIM_TAG_SHARP_TEETH}, + {gBattleAnimSpritePal_RainbowRings, ANIM_TAG_RAINBOW_RINGS}, + {gBattleAnimSpritePal_IceCrystals, ANIM_TAG_ICE_CRYSTALS}, + {gBattleAnimSpritePal_IceCrystals, ANIM_TAG_ICE_SPIKES}, + {gBattleAnimSpritePal_HandsAndFeet, ANIM_TAG_HANDS_AND_FEET}, + {gBattleAnimSpritePal_MistCloud, ANIM_TAG_MIST_CLOUD}, + {gBattleAnimSpritePal_SharpTeeth, ANIM_TAG_CLAMP}, + {gBattleAnimSpritePal_RainDrops, ANIM_TAG_BUBBLE}, + {gBattleAnimSpritePal_Orbs, ANIM_TAG_ORBS}, + {gBattleAnimSpritePal_WaterImpact, ANIM_TAG_WATER_IMPACT}, + {gBattleAnimSpritePal_WaterImpact, ANIM_TAG_WATER_ORB}, + {gBattleAnimSpritePal_PoisonBubble, ANIM_TAG_POISON_BUBBLE}, + {gBattleAnimSpritePal_PoisonBubble, ANIM_TAG_TOXIC_BUBBLE}, + {gBattleAnimSpritePal_Spikes, ANIM_TAG_SPIKES}, + {gBattleAnimSpritePal_HornHit2, ANIM_TAG_HORN_HIT_2}, + {gBattleAnimSpritePal_AirWave2, ANIM_TAG_AIR_WAVE_2}, + {gBattleAnimSpritePal_SmallBubbles, ANIM_TAG_SMALL_BUBBLES}, + {gBattleAnimSpritePal_RoundShadow, ANIM_TAG_ROUND_SHADOW}, + {gBattleAnimSpritePal_Sunlight, ANIM_TAG_SUNLIGHT}, + {gBattleAnimSpritePal_Spore, ANIM_TAG_SPORE}, + {gBattleAnimSpritePal_Flower, ANIM_TAG_FLOWER}, + {gBattleAnimSpritePal_RazorLeaf, ANIM_TAG_RAZOR_LEAF}, + {gBattleAnimSpritePal_Needle, ANIM_TAG_NEEDLE}, + {gBattleAnimSpritePal_WhirlwindLines, ANIM_TAG_WHIRLWIND_LINES}, + {gBattleAnimSpritePal_GoldRing, ANIM_TAG_GOLD_RING}, + {gBattleAnimSpritePal_PurpleRing, ANIM_TAG_PURPLE_RING}, + {gBattleAnimSpritePal_BlueRing, ANIM_TAG_BLUE_RING}, + {gBattleAnimSpritePal_GreenLightWall, ANIM_TAG_GREEN_LIGHT_WALL}, + {gBattleAnimSpritePal_BlueLightWall, ANIM_TAG_BLUE_LIGHT_WALL}, + {gBattleAnimSpritePal_RedLightWall, ANIM_TAG_RED_LIGHT_WALL}, + {gBattleAnimSpritePal_GrayLightWall, ANIM_TAG_GRAY_LIGHT_WALL}, + {gBattleAnimSpritePal_OrangeLightWall, ANIM_TAG_ORANGE_LIGHT_WALL}, + {gBattleAnimSpritePal_BlackBall2, ANIM_TAG_BLACK_BALL_2}, + {gBattleAnimSpritePal_PurpleGasCloud, ANIM_TAG_PURPLE_GAS_CLOUD}, + {gBattleAnimSpritePal_Spark, ANIM_TAG_SPARK_H}, + {gBattleAnimSpritePal_YellowStar, ANIM_TAG_YELLOW_STAR}, + {gBattleAnimSpritePal_LargeFreshEgg, ANIM_TAG_LARGE_FRESH_EGG}, + {gBattleAnimSpritePal_ShadowBall, ANIM_TAG_SHADOW_BALL}, + {gBattleAnimSpritePal_Lick, ANIM_TAG_LICK}, + {gBattleAnimSpritePal_VoidLines, ANIM_TAG_VOID_LINES}, + {gBattleAnimSpritePal_String, ANIM_TAG_STRING}, + {gBattleAnimSpritePal_String, ANIM_TAG_WEB_THREAD}, + {gBattleAnimSpritePal_String, ANIM_TAG_SPIDER_WEB}, + {gBattleAnimSpritePal_Lightbulb, ANIM_TAG_LIGHTBULB}, + {gBattleAnimSpritePal_Slash, ANIM_TAG_SLASH}, + {gBattleAnimSpritePal_FocusEnergy, ANIM_TAG_FOCUS_ENERGY}, + {gBattleAnimSpritePal_SphereToCube, ANIM_TAG_SPHERE_TO_CUBE}, + {gBattleAnimSpritePal_Tendrils, ANIM_TAG_TENDRILS}, + {gBattleAnimSpritePal_Eye, ANIM_TAG_EYE}, + {gBattleAnimSpritePal_WhiteShadow, ANIM_TAG_WHITE_SHADOW}, + {gBattleAnimSpritePal_TealAlert, ANIM_TAG_TEAL_ALERT}, + {gBattleAnimSpritePal_OpeningEye, ANIM_TAG_OPENING_EYE}, + {gBattleAnimSpritePal_RoundWhiteHalo, ANIM_TAG_ROUND_WHITE_HALO}, + {gBattleAnimSpritePal_FangAttack, ANIM_TAG_FANG_ATTACK}, + {gBattleAnimSpritePal_PurpleHandOutline, ANIM_TAG_PURPLE_HAND_OUTLINE}, + {gBattleAnimSpritePal_Moon, ANIM_TAG_MOON}, + {gBattleAnimSpritePal_GreenSparkle, ANIM_TAG_GREEN_SPARKLE}, + {gBattleAnimSpritePal_Spiral, ANIM_TAG_SPIRAL}, + {gBattleAnimSpritePal_SnoreZ, ANIM_TAG_SNORE_Z}, + {gBattleAnimSpritePal_Explosion, ANIM_TAG_EXPLOSION}, + {gBattleAnimSpritePal_Nail, ANIM_TAG_NAIL}, + {gBattleAnimSpritePal_GhostlySpirit, ANIM_TAG_GHOSTLY_SPIRIT}, + {gBattleAnimSpritePal_WarmRock, ANIM_TAG_WARM_ROCK}, + {gBattleAnimSpritePal_BreakingEgg, ANIM_TAG_BREAKING_EGG}, + {gBattleAnimSpritePal_ThinRing, ANIM_TAG_THIN_RING}, + {gBattleAnimSpritePal_PunchImpact, ANIM_TAG_PUNCH_IMPACT}, + {gBattleAnimSpritePal_Bell, ANIM_TAG_BELL}, + {gBattleAnimSpritePal_MusicNotes2, ANIM_TAG_MUSIC_NOTES_2}, + {gBattleAnimSpritePal_SpeedDust, ANIM_TAG_SPEED_DUST}, + {gBattleAnimSpritePal_BlueLightWall, ANIM_TAG_TORN_METAL}, + {gBattleAnimSpritePal_ThoughtBubble, ANIM_TAG_THOUGHT_BUBBLE}, + {gBattleAnimSpritePal_MagentaHeart, ANIM_TAG_MAGENTA_HEART}, + {gBattleAnimSpritePal_ElectricOrbs, ANIM_TAG_ELECTRIC_ORBS}, + {gBattleAnimSpritePal_ElectricOrbs, ANIM_TAG_CIRCLE_OF_LIGHT}, + {gBattleAnimSpritePal_ElectricOrbs, ANIM_TAG_ELECTRICITY}, + {gBattleAnimSpritePal_Finger, ANIM_TAG_FINGER_2}, + {gBattleAnimSpritePal_MovementWaves, ANIM_TAG_MOVEMENT_WAVES}, + {gBattleAnimSpritePal_RedHeart, ANIM_TAG_RED_HEART}, + {gBattleAnimSpritePal_RedOrb, ANIM_TAG_RED_ORB}, + {gBattleAnimSpritePal_EyeSparkle, ANIM_TAG_EYE_SPARKLE}, + {gBattleAnimSpritePal_PinkHeart, ANIM_TAG_PINK_HEART}, + {gBattleAnimSpritePal_Angel, ANIM_TAG_ANGEL}, + {gBattleAnimSpritePal_Devil, ANIM_TAG_DEVIL}, + {gBattleAnimSpritePal_Swipe, ANIM_TAG_SWIPE}, + {gBattleAnimSpritePal_Roots, ANIM_TAG_ROOTS}, + {gBattleAnimSpritePal_ItemBag, ANIM_TAG_ITEM_BAG}, + {gBattleAnimSpritePal_JaggedMusicNote, ANIM_TAG_JAGGED_MUSIC_NOTE}, + {gBattleAnimSpritePal_Pokeball, ANIM_TAG_POKEBALL}, + {gBattleAnimSpritePal_Pokeball, ANIM_TAG_SPOTLIGHT}, + {gBattleAnimSpritePal_LetterZ, ANIM_TAG_LETTER_Z}, + {gBattleAnimSpritePal_RapidSpin, ANIM_TAG_RAPID_SPIN}, + {gBattleAnimSpritePal_TriForceTriangle, ANIM_TAG_TRI_FORCE_TRIANGLE}, + {gBattleAnimSpritePal_WispOrb, ANIM_TAG_WISP_ORB}, + {gBattleAnimSpritePal_WispOrb, ANIM_TAG_WISP_FIRE}, + {gBattleAnimSpritePal_GoldStars, ANIM_TAG_GOLD_STARS}, + {gBattleAnimSpritePal_EclipsingOrb, ANIM_TAG_ECLIPSING_ORB}, + {gBattleAnimSpritePal_GrayOrb, ANIM_TAG_GRAY_ORB}, + {gBattleAnimSpritePal_BlueOrb, ANIM_TAG_BLUE_ORB}, + {gBattleAnimSpritePal_RedOrb2, ANIM_TAG_RED_ORB_2}, + {gBattleAnimSpritePal_PinkPetal, ANIM_TAG_PINK_PETAL}, + {gBattleAnimSpritePal_PainSplit, ANIM_TAG_PAIN_SPLIT}, + {gBattleAnimSpritePal_Confetti, ANIM_TAG_CONFETTI}, + {gBattleAnimSpritePal_GreenStar, ANIM_TAG_GREEN_STAR}, + {gBattleAnimSpritePal_PinkCloud, ANIM_TAG_PINK_CLOUD}, + {gBattleAnimSpritePal_SweatDrop, ANIM_TAG_SWEAT_DROP}, + {gBattleAnimSpritePal_GuardRing, ANIM_TAG_GUARD_RING}, + {gBattleAnimSpritePal_PurpleScratch, ANIM_TAG_PURPLE_SCRATCH}, + {gBattleAnimSpritePal_PurpleScratch, ANIM_TAG_PURPLE_SWIPE}, + {gBattleAnimSpritePal_Finger, ANIM_TAG_TAG_HAND}, + {gBattleAnimSpritePal_SmallRedEye, ANIM_TAG_SMALL_RED_EYE}, + {gBattleAnimSpritePal_HollowOrb, ANIM_TAG_HOLLOW_ORB}, + {gBattleAnimSpritePal_HollowOrb, ANIM_TAG_X_SIGN}, + {gBattleAnimSpritePal_BluegreenOrb, ANIM_TAG_BLUEGREEN_ORB}, + {gBattleAnimSpritePal_PawPrint, ANIM_TAG_PAW_PRINT}, + {gBattleAnimSpritePal_PurpleFlame, ANIM_TAG_PURPLE_FLAME}, + {gBattleAnimSpritePal_RedBall, ANIM_TAG_RED_BALL}, + {gBattleAnimSpritePal_SmellingsaltEffect, ANIM_TAG_SMELLINGSALT_EFFECT}, + {gBattleAnimSpritePal_Meteor, ANIM_TAG_METEOR}, + {gBattleAnimSpritePal_FlatRock, ANIM_TAG_FLAT_ROCK}, + {gBattleAnimSpritePal_MagnifyingGlass, ANIM_TAG_MAGNIFYING_GLASS}, + {gBattleAnimSpritePal_BrownOrb, ANIM_TAG_BROWN_ORB}, + {gBattleAnimSpritePal_MetalSoundWaves, ANIM_TAG_METAL_SOUND_WAVES}, + {gBattleAnimSpritePal_FlyingDirt, ANIM_TAG_FLYING_DIRT}, + {gBattleAnimSpritePal_IcicleSpear, ANIM_TAG_ICICLE_SPEAR}, + {gBattleAnimSpritePal_Hail, ANIM_TAG_HAIL}, + {gBattleAnimSpritePal_GlowyRedOrb, ANIM_TAG_GLOWY_RED_ORB}, + {gBattleAnimSpritePal_GlowyGreenOrb, ANIM_TAG_GLOWY_GREEN_ORB}, + {gBattleAnimSpritePal_GreenSpike, ANIM_TAG_GREEN_SPIKE}, + {gBattleAnimSpritePal_WhiteCircleOfLight, ANIM_TAG_WHITE_CIRCLE_OF_LIGHT}, + {gBattleAnimSpritePal_GlowyBlueOrb, ANIM_TAG_GLOWY_BLUE_ORB}, + {gBattleAnimSpritePal_Pokeblock, ANIM_TAG_POKEBLOCK}, + {gBattleAnimSpritePal_WhiteFeather, ANIM_TAG_WHITE_FEATHER}, + {gBattleAnimSpritePal_Sparkle6, ANIM_TAG_SPARKLE_6}, + {gBattleAnimSpritePal_Splash, ANIM_TAG_SPLASH}, + {gBattleAnimSpritePal_Splash, ANIM_TAG_SWEAT_BEAD}, + {gBattleAnimSpritePal_Gem1, ANIM_TAG_GEM_1}, + {gBattleAnimSpritePal_Gem1, ANIM_TAG_GEM_2}, + {gBattleAnimSpritePal_Gem1, ANIM_TAG_GEM_3}, + {gBattleAnimSpritePal_SlamHit2, ANIM_TAG_SLAM_HIT_2}, + {gBattleAnimSpritePal_Recycle, ANIM_TAG_RECYCLE}, + {gBattleAnimSpritePal_RedParticles, ANIM_TAG_RED_PARTICLES}, + {gBattleAnimSpritePal_Protect, ANIM_TAG_PROTECT}, + {gBattleAnimSpritePal_DirtMound, ANIM_TAG_DIRT_MOUND}, + {gBattleAnimSpritePal_Shock3, ANIM_TAG_SHOCK_3}, + {gBattleAnimSpritePal_WeatherBall, ANIM_TAG_WEATHER_BALL}, + {gBattleAnimSpritePal_Bird, ANIM_TAG_BIRD}, + {gBattleAnimSpritePal_CrossImpact, ANIM_TAG_CROSS_IMPACT}, + {gBattleAnimSpritePal_Slash2, ANIM_TAG_SLASH_2}, + {gBattleAnimSpritePal_WhipHit, ANIM_TAG_WHIP_HIT}, + {gBattleAnimSpritePal_BlueRing2, ANIM_TAG_BLUE_RING_2}, +}; + +const struct BattleAnimBackground gBattleAnimBackgroundTable[] = // 83ADE18 +{ + [BG_DARK_] = {gBattleAnimBgImage_Dark, gBattleAnimBgPalette_Dark, gBattleAnimBgTilemap_Dark}, + [BG_DARK] = {gBattleAnimBgImage_Dark, gBattleAnimBgPalette_Dark, gBattleAnimBgTilemap_Dark}, + [BG_GHOST] = {gBattleAnimBgImage_Ghost, gBattleAnimBgPalette_Ghost, gBattleAnimBgTilemap_Ghost}, + [BG_PSYCHIC] = {gBattleAnimBgImage_Psychic, gBattleAnimBgPalette_Psychic, gBattleAnimBgTilemap_Psychic}, + [BG_IMPACT_OPPONENT] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Impact, gBattleAnimBgTilemap_ImpactOpponent}, + [BG_IMPACT_PLAYER] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Impact, gBattleAnimBgTilemap_ImpactPlayer}, + [BG_IMPACT_CONTESTS] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Impact, gBattleAnimBgTilemap_ImpactContests}, + [BG_DRILL] = {gBattleAnimBgImage_Drill, gBattleAnimBgPalette_Drill, gBattleAnimBgTilemap_Drill}, + [BG_DRILL_CONTESTS] = {gBattleAnimBgImage_Drill, gBattleAnimBgPalette_Drill, gBattleAnimBgTilemap_DrillContests}, + [BG_HIGHSPEED_OPPONENT] = {gBattleAnimBgImage_Highspeed, gBattleAnimBgPalette_Highspeed, gBattleAnimBgTilemap_HighspeedOpponent}, + [BG_HIGHSPEED_PLAYER] = {gBattleAnimBgImage_Highspeed, gBattleAnimBgPalette_Highspeed, gBattleAnimBgTilemap_HighspeedPlayer}, + [BG_THUNDER] = {gBattleAnimBgImage_Thunder, gBattleAnimBgPalette_Thunder, gBattleAnimBgTilemap_Thunder}, + [BG_GUILLOTINE_OPPONENT] = {gBattleAnimBgImage_Guillotine, gBattleAnimBgPalette_Guillotine, gBattleAnimBgTilemap_GuillotineOpponent}, + [BG_GUILLOTINE_PLAYER] = {gBattleAnimBgImage_Guillotine, gBattleAnimBgPalette_Guillotine, gBattleAnimBgTilemap_GuillotinePlayer}, + [BG_GUILLOTINE_CONTESTS] = {gBattleAnimBgImage_Guillotine, gBattleAnimBgPalette_Guillotine, gBattleAnimBgTilemap_GuillotineContests}, + [BG_ICE] = {gBattleAnimBgImage_Ice, gBattleAnimBgPalette_Ice, gBattleAnimBgTilemap_Ice}, + [BG_COSMIC] = {gBattleAnimBgImage_Cosmic, gBattleAnimBgPalette_Cosmic, gBattleAnimBgTilemap_Cosmic}, + [BG_IN_AIR] = {gBattleAnimBgImage_InAir, gBattleAnimBgPalette_InAir, gBattleAnimBgTilemap_InAir}, + [BG_SKY] = {gBattleAnimBgImage_Drill, gBattleAnimBgPalette_Sky, gBattleAnimBgTilemap_Drill}, + [BG_SKY_CONTESTS] = {gBattleAnimBgImage_Drill, gBattleAnimBgPalette_Sky, gBattleAnimBgTilemap_DrillContests}, + [BG_AURORA] = {gBattleAnimBgImage_Aurora, gBattleAnimBgPalette_Aurora, gBattleAnimBgTilemap_Aurora}, + [BG_FISSURE] = {gBattleAnimBgImage_Fissure, gBattleAnimBgPalette_Fissure, gBattleAnimBgTilemap_Fissure}, + [BG_BUG_OPPONENT] = {gBattleAnimBgImage_Highspeed, gBattleAnimBgPalette_Bug, gBattleAnimBgTilemap_HighspeedOpponent}, + [BG_BUG_PLAYER] = {gBattleAnimBgImage_Highspeed, gBattleAnimBgPalette_Bug, gBattleAnimBgTilemap_HighspeedPlayer}, + [BG_SOLARBEAM_OPPONENT] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Solarbeam, gBattleAnimBgTilemap_ImpactOpponent}, + [BG_SOLARBEAM_PLAYER] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Solarbeam, gBattleAnimBgTilemap_ImpactPlayer}, + [BG_SOLARBEAM_CONTESTS] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Solarbeam, gBattleAnimBgTilemap_ImpactContests}, +}; + +static void (* const sScriptCmdTable[])(void) = // 83ADF5C { ScriptCmd_loadspritegfx, ScriptCmd_unloadspritegfx, -- cgit v1.2.3 From 1bdeb05793c6dedc195f6f85d3597ac52e168e6e Mon Sep 17 00:00:00 2001 From: Evan Date: Sun, 1 Dec 2019 13:00:24 -0500 Subject: resolve data/battle_anim.s --- src/battle_anim.c | 1009 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1009 insertions(+) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index fc22231bc..be78558ca 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -103,6 +103,1015 @@ static void ScriptCmd_doublebattle_2E(void); static void ScriptCmd_stopsound(void); // Data +const struct OamData gOamData_AffineOff_ObjNormal_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + + +const struct OamData gOamData_AffineOff_ObjNormal_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + const struct CompressedSpriteSheet gBattleAnimPicTable[] = // 83ACC08 { {gBattleAnimSpriteGfx_Bone, 0x0200, ANIM_TAG_BONE}, -- cgit v1.2.3 From 86e62e24c1fe9d7fe39f6ece5412ef24a7c2c9e5 Mon Sep 17 00:00:00 2001 From: Evan Date: Sun, 1 Dec 2019 20:23:36 -0500 Subject: start anim objtemplates --- src/battle_anim.c | 298 ++- src/battle_anim_effects_1.c | 5617 +++++++++++++++++++++++++++++++++++++++++++ src/battle_anim_mons.c | 4 +- src/bug.c | 18 +- src/dark.c | 10 +- src/dragon.c | 12 +- src/electric.c | 36 +- src/fighting.c | 40 +- src/fire.c | 38 +- src/flying.c | 32 +- src/ghost.c | 18 +- src/ground.c | 14 +- src/ice.c | 38 +- src/mevent_8145654.c | 4 +- src/normal.c | 20 +- src/oak_speech.c | 20 +- src/poison.c | 14 +- src/psychic.c | 32 +- src/rock.c | 28 +- src/text.c | 4 +- 20 files changed, 5948 insertions(+), 349 deletions(-) create mode 100644 src/battle_anim_effects_1.c (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index be78558ca..de5f08f38 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -3,6 +3,7 @@ #include "battle_anim.h" #include "battle_controllers.h" #include "battle_interface.h" +#include "battle_bg.h" #include "bg.h" #include "decompress.h" #include "dma3.h" @@ -22,6 +23,8 @@ extern const u16 gMovesWithQuietBGM[]; extern const u8 *const gBattleAnims_Moves[]; +extern const struct CompressedSpriteSheet gUnknown_8399388[]; +extern const struct CompressedSpritePalette gUnknown_8399C90[]; // RAM EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; @@ -53,6 +56,16 @@ static void AddSpriteIndex(u16 index); static void ClearSpriteIndex(u16 index); static void WaitAnimFrameCount(void); static void RunAnimScriptCommand(void); +static void sub_8073558(u8 taskId); +static void Task_FadeToBg(u8 taskId); +static void Task_PanFromInitialToTarget(u8 taskId); +static void task_pA_ma0A_obj_to_bg_pal(u8 taskId); +static void LoadMoveBg(u16 bgId); +static void LoadDefaultBg(void); +static void Task_LoopAndPlaySE(u8 taskId); +static void Task_WaitAndPlaySE(u8 taskId); +static void sub_807331C(u8 taskId); + static void ScriptCmd_loadspritegfx(void); static void ScriptCmd_unloadspritegfx(void); static void ScriptCmd_createsprite(void); @@ -103,7 +116,7 @@ static void ScriptCmd_doublebattle_2E(void); static void ScriptCmd_stopsound(void); // Data -const struct OamData gOamData_AffineOff_ObjNormal_8x8 = +const struct OamData gOamData_AffineOff_ObjNormal_8x8 = //gOamData_83AC9C8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -118,7 +131,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x8 = }; -const struct OamData gOamData_AffineOff_ObjNormal_16x16 = +const struct OamData gOamData_AffineOff_ObjNormal_16x16 = //gOamData_83AC9D0 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -132,7 +145,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x32 = +const struct OamData gOamData_AffineOff_ObjNormal_32x32 = //gOamData_83AC9D8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -146,7 +159,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_64x64 = +const struct OamData gOamData_AffineOff_ObjNormal_64x64 = //gOamData_83AC9E0 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -160,7 +173,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_16x8 = +const struct OamData gOamData_AffineOff_ObjNormal_16x8 = //gOamData_83AC9E8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -174,7 +187,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x8 = +const struct OamData gOamData_AffineOff_ObjNormal_32x8 = //gOamData_83AC9F0 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -188,7 +201,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x16 = +const struct OamData gOamData_AffineOff_ObjNormal_32x16 = //gOamData_83AC9F8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -202,7 +215,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_64x32 = +const struct OamData gOamData_AffineOff_ObjNormal_64x32 = //gOamData_83ACA00 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -216,7 +229,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_8x16 = +const struct OamData gOamData_AffineOff_ObjNormal_8x16 = //gOamData_83ACA08 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -230,7 +243,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_8x32 = +const struct OamData gOamData_AffineOff_ObjNormal_8x32 = //gOamData_83ACA10 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -244,7 +257,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_16x32 = +const struct OamData gOamData_AffineOff_ObjNormal_16x32 = //gOamData_83ACA18 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -258,7 +271,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x64 = +const struct OamData gOamData_AffineOff_ObjNormal_32x64 = //gOamData_83ACA20 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -272,7 +285,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = +const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = //gOamData_83ACA28 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -286,7 +299,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = +const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = //gOamData_83ACA30 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -300,7 +313,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = +const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = //gOamData_83ACA38 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -314,7 +327,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = +const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = //gOamData_83ACA40 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -328,7 +341,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = +const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = //gOamData_83ACA48 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -342,7 +355,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = +const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = //gOamData_83ACA50 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -356,7 +369,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = +const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = //gOamData_83ACA58 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -370,7 +383,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = +const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = //gOamData_83ACA60 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -384,7 +397,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = +const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = //gOamData_83ACA68 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -398,7 +411,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = +const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = //gOamData_83ACA70 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -412,7 +425,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = +const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = //gOamData_83ACA78 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -426,7 +439,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = +const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = //gOamData_83ACA80 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -440,7 +453,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = +const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = //gOamData_83ACA88 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -454,7 +467,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = +const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = //gOamData_83ACA90 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -468,7 +481,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = +const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = //gOamData_83ACA98 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -482,7 +495,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = +const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = //gOamData_83ACAA0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -496,7 +509,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = +const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = //gOamData_83ACAA8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -510,7 +523,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = +const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = //gOamData_83ACAB0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -524,7 +537,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = +const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = //gOamData_83ACAB8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -538,7 +551,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = +const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = //gOamData_83ACAC0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -552,7 +565,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = +const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = //gOamData_83ACAC8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -566,7 +579,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = +const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = //gOamData_83ACAD0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -580,7 +593,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = +const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = //gOamData_83ACAD8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -594,7 +607,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = +const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = //gOamData_83ACAE0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -608,7 +621,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x8 = +const struct OamData gOamData_AffineOff_ObjBlend_8x8 = //gOamData_83ACAE8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -622,7 +635,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x16 = +const struct OamData gOamData_AffineOff_ObjBlend_16x16 = //gOamData_83ACAF0 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -636,7 +649,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x32 = +const struct OamData gOamData_AffineOff_ObjBlend_32x32 = //gOamData_83ACAF8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -650,7 +663,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_64x64 = +const struct OamData gOamData_AffineOff_ObjBlend_64x64 = //gOamData_83ACB00 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -664,7 +677,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x8 = +const struct OamData gOamData_AffineOff_ObjBlend_16x8 = //gOamData_83ACB08 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -678,7 +691,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x8 = +const struct OamData gOamData_AffineOff_ObjBlend_32x8 = //gOamData_83ACB10 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -692,7 +705,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x16 = +const struct OamData gOamData_AffineOff_ObjBlend_32x16 = //gOamData_83ACB18 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -706,7 +719,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_64x32 = +const struct OamData gOamData_AffineOff_ObjBlend_64x32 = //gOamData_83ACB20 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -720,7 +733,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x16 = +const struct OamData gOamData_AffineOff_ObjBlend_8x16 = //gOamData_83ACB28 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -734,7 +747,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x32 = +const struct OamData gOamData_AffineOff_ObjBlend_8x32 = //gOamData_83ACB30 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -748,7 +761,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x32 = +const struct OamData gOamData_AffineOff_ObjBlend_16x32 = //gOamData_83ACB38 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -762,7 +775,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x64 = +const struct OamData gOamData_AffineOff_ObjBlend_32x64 = //gOamData_83ACB40 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -776,7 +789,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = +const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = //gOamData_83ACB48 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -790,7 +803,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = +const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = //gOamData_83ACB50 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -804,7 +817,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = +const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = //gOamData_83ACB58 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -818,7 +831,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = +const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = //gOamData_83ACB60 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -832,7 +845,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = +const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = //gOamData_83ACB68 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -846,7 +859,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = +const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = //gOamData_83ACB70 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -860,7 +873,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = +const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = //gOamData_83ACB78 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -874,7 +887,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = +const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = //gOamData_83ACB80 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -888,7 +901,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = +const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = //gOamData_83ACB88 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -902,7 +915,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = +const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = //gOamData_83ACB90 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -916,7 +929,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = +const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = //gOamData_83ACB98 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -930,7 +943,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = +const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = //gOamData_83ACBA0 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -944,7 +957,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = +const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = //gOamData_83ACBA8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -958,7 +971,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = +const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = //gOamData_83ACBB0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -972,7 +985,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = +const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = //gOamData_83ACBB8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -986,7 +999,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = +const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = //gOamData_83ACBC0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1000,7 +1013,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = +const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = //gOamData_83ACBC8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1014,7 +1027,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = +const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = //gOamData_83ACBD0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1028,7 +1041,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = +const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = //gOamData_83ACBD8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1042,7 +1055,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = +const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = //gOamData_83ACBE0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1056,7 +1069,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = +const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = //gOamData_83ACBE8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1070,7 +1083,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = +const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = //gOamData_83ACBF0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1084,7 +1097,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = +const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = //gOamData_83ACBF8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1098,7 +1111,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = +const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = //gOamData_83ACC00 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1944,8 +1957,8 @@ static void ScriptCmd_loadspritegfx(void) sBattleAnimScriptPtr++; index = T1_READ_16(sBattleAnimScriptPtr); - LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)]); - LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(index)]); + LoadCompressedSpriteSheetUsingHeap(&gUnknown_8399388[GET_TRUE_SPRITE_INDEX(index)]); + LoadCompressedSpritePaletteUsingHeap(&gUnknown_8399C90[GET_TRUE_SPRITE_INDEX(index)]); sBattleAnimScriptPtr += 2; AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); gAnimFramesToWait = 1; @@ -2072,6 +2085,13 @@ static void ScriptCmd_waitforvisualfinish(void) } } +static void ScriptCmd_hang1(void) +{ +} +static void ScriptCmd_hang2(void) +{ +} + static void ScriptCmd_end(void) { s32 i; @@ -2117,11 +2137,8 @@ static void ScriptCmd_end(void) if (!continuousAnim) // May have been used for debug? { m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256); - if (!IsContest()) - { - sub_80A8278(); - UpdateOamPriorityInAllHealthboxes(1); - } + sub_80767F0(); + UpdateOamPriorityInAllHealthboxes(1); gAnimScriptActive = FALSE; } } @@ -2160,12 +2177,11 @@ static void ScriptCmd_monbg(void) if (IsBattlerSpriteVisible(battlerId)) { u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) // || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; - else - toBG_2 = TRUE; - MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + MoveBattlerSpriteToBG(battlerId, toBG_2); taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); gAnimVisualTaskCount++; gTasks[taskId].data[t1_MONBG_BATTLER] = battlerId; @@ -2179,12 +2195,11 @@ static void ScriptCmd_monbg(void) if (IsBattlerSpriteVisible(battlerId)) { u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) // || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; - else - toBG_2 = TRUE; - MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + MoveBattlerSpriteToBG(battlerId, toBG_2); taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); gAnimVisualTaskCount++; gTasks[taskId].data[0] = battlerId; @@ -2266,7 +2281,7 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) } } -void sub_80730C0(u16 a, u16 *b, u32 c, u8 d) +void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) { s32 i, j; s32 var; @@ -2275,6 +2290,7 @@ void sub_80730C0(u16 a, u16 *b, u32 c, u8 d) var = 32; else var = 64; + a <<= 12; for (i = 0; i < var; i++) { @@ -2288,17 +2304,17 @@ void sub_8073128(bool8 to_BG2) struct BattleAnimBgData animBg; sub_80752A0(&animBg); - if (!to_BG2)) + if (!to_BG2) { sub_8075358(1); - gBattle_BG1_X = NULL; - gBattle_BG1_Y = NULL; + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; } else { sub_8075358(2); - gBattle_BG2_X = NULL; - gBattle_BG2_Y = NULL; + gBattle_BG2_X = 0; + gBattle_BG2_Y = 0; } } @@ -2378,10 +2394,9 @@ static void sub_807331C(u8 taskId) { u8 to_BG2; u8 position = GetBattlerPosition(gTasks[taskId].data[2]); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + to_BG2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) to_BG2 = FALSE; - else - to_BG2 = TRUE; if (sMonAnimTaskIdArray[0] != 0xFF) { @@ -2422,24 +2437,22 @@ static void ScriptCmd_monbg_22(void) if (IsBattlerSpriteVisible(battlerId)) { u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; - else - toBG_2 = TRUE; - MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + MoveBattlerSpriteToBG(battlerId, toBG_2); } battlerId ^= BIT_FLANK; if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId)) { u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; - else - toBG_2 = TRUE; - MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + MoveBattlerSpriteToBG(battlerId, toBG_2); } sBattleAnimScriptPtr++; @@ -2480,19 +2493,21 @@ static void ScriptCmd_clearmonbg_23(void) static void sub_8073558(u8 taskId) { - gTasks[taskId].data[1]++; + bool8 to_BG2; + + gTasks[taskId].data[1]++; if (gTasks[taskId].data[1] != 1) { bool8 toBG_2; u8 battlerId = gTasks[taskId].data[2]; u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) - toBG_2 = FALSE; - else - toBG_2 = TRUE; + to_BG2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) + to_BG2 = FALSE; if (IsBattlerSpriteVisible(battlerId)) sub_8073128(toBG_2); + if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) sub_8073128(toBG_2 ^ 1); @@ -2627,9 +2642,7 @@ static void ScriptCmd_fadetobgfromset(void) sBattleAnimScriptPtr += 3; taskId = CreateTask(Task_FadeToBg, 5); - if (IsContest()) - gTasks[taskId].tBackgroundId = bg3; - else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) gTasks[taskId].tBackgroundId = bg2; else gTasks[taskId].tBackgroundId = bg1; @@ -2676,34 +2689,14 @@ static void Task_FadeToBg(u8 taskId) static void LoadMoveBg(u16 bgId) { - if (IsContest()) - { - const u32 *tilemap = gBattleAnimBackgroundTable[bgId].tilemap; - void *dmaSrc; - void *dmaDest; - - LZDecompressWram(tilemap, gDecompressionBuffer); - sub_80730C0(sub_80A6D94(), (void*)(gDecompressionBuffer), 0x100, 0); - dmaSrc = gDecompressionBuffer; - dmaDest = (void *)(BG_SCREEN_ADDR(26)); - DmaCopy32(3, dmaSrc, dmaDest, 0x800); - LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_SCREEN_ADDR(4))); - LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, sub_80A6D94() * 16, 32); - } - else - { - LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26))); - LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2))); - LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32); - } + LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26))); + LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2))); + LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32); } static void LoadDefaultBg(void) { - if (IsContest()) - LoadContestBgAfterMoveAnim(); - else - DrawMainBattleBackground(); + DrawMainBattleBackground(); } static void ScriptCmd_restorebg(void) @@ -2754,18 +2747,13 @@ static void ScriptCmd_changebg(void) s8 BattleAnimAdjustPanning(s8 pan) { - if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) + if (gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) { if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) pan = SOUND_PAN_TARGET; else pan = SOUND_PAN_ATTACKER; } - else if (IsContest()) - { - if (gBattleAnimAttacker != gBattleAnimTarget || gBattleAnimAttacker != 2 || pan != SOUND_PAN_TARGET) - pan *= -1; - } else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) { if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) @@ -2796,7 +2784,7 @@ s8 BattleAnimAdjustPanning(s8 pan) s8 BattleAnimAdjustPanning2(s8 pan) { - if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) + if (gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) { if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) pan = SOUND_PAN_TARGET; @@ -2805,7 +2793,7 @@ s8 BattleAnimAdjustPanning2(s8 pan) } else { - if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER || IsContest()) + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) pan = -pan; } return pan; @@ -2896,7 +2884,7 @@ static void ScriptCmd_panse_1B(void) sBattleAnimScriptPtr += 6; } -void Task_PanFromInitialToTarget(u8 taskId) +static void Task_PanFromInitialToTarget(u8 taskId) { bool32 destroyTask = FALSE; if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait) @@ -3169,10 +3157,7 @@ static void ScriptCmd_jumpargeq(void) static void ScriptCmd_jumpifcontest(void) { sBattleAnimScriptPtr++; - if (IsContest()) - sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); - else - sBattleAnimScriptPtr += 4; + sBattleAnimScriptPtr += 5; } static void ScriptCmd_monbgprio_28(void) @@ -3190,7 +3175,7 @@ static void ScriptCmd_monbgprio_28(void) battlerId = gBattleAnimAttacker; battlerPosition = GetBattlerPosition(battlerId); - if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT)) + if (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT) { SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); @@ -3200,11 +3185,8 @@ static void ScriptCmd_monbgprio_28(void) static void ScriptCmd_monbgprio_29(void) { sBattleAnimScriptPtr++; - if (!IsContest()) - { - SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); - SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); - } + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); } static void ScriptCmd_monbgprio_2A(void) @@ -3223,7 +3205,7 @@ static void ScriptCmd_monbgprio_2A(void) battlerId = gBattleAnimAttacker; battlerPosition = GetBattlerPosition(battlerId); - if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT)) + if (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT) { SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); @@ -3261,7 +3243,7 @@ static void ScriptCmd_doublebattle_2D(void) wantedBattler = sBattleAnimScriptPtr[1]; sBattleAnimScriptPtr += 2; - if (!IsContest() && IsDoubleBattle() + if (IsDoubleBattle() && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) { if (wantedBattler == ANIM_ATTACKER) @@ -3296,7 +3278,7 @@ static void ScriptCmd_doublebattle_2E(void) wantedBattler = sBattleAnimScriptPtr[1]; sBattleAnimScriptPtr += 2; - if (!IsContest() && IsDoubleBattle() + if (IsDoubleBattle() && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) { if (wantedBattler == ANIM_ATTACKER) diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c new file mode 100644 index 000000000..a02125d6d --- /dev/null +++ b/src/battle_anim_effects_1.c @@ -0,0 +1,5617 @@ +#include "global.h" +#include "malloc.h" +#include "battle_anim.h" +#include "battle_interface.h" +#include "decompress.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "main.h" +#include "math_util.h" +#include "palette.h" +#include "random.h" +#include "scanline_effect.h" +#include "sound.h" +#include "trig.h" +#include "util.h" +#include "constants/rgb.h" +#include "constants/songs.h" + +EWRAM_DATA s16 gUnknown_0203A0F8[4] = {0}; + +void AnimMovePowderParticle(struct Sprite *); +void AnimPowerAbsorptionOrb(struct Sprite *); +void AnimSolarbeamBigOrb(struct Sprite *); +void AnimSolarbeamSmallOrb(struct Sprite *); +void AnimAbsorptionOrb(struct Sprite *); +void AnimHyperBeamOrb(struct Sprite *); +void AnimSporeParticle(struct Sprite *); +void AnimPetalDanceBigFlower(struct Sprite *); +void AnimPetalDanceSmallFlower(struct Sprite *); +void AnimRazorLeafParticle(struct Sprite *); +void AnimLeechSeed(struct Sprite *); +void AnimTranslateLinearSingleSineWave(struct Sprite *); +void AnimMoveTwisterParticle(struct Sprite *); +void AnimConstrictBinding(struct Sprite *); +void AnimMimicOrb(struct Sprite *); +void AnimIngrainRoot(struct Sprite *); +void AnimFrenzyPlantRoot(struct Sprite *); +void AnimIngrainOrb(struct Sprite *); +void AnimPresent(struct Sprite *); +void AnimKnockOffItem(struct Sprite *); +void AnimPresentHealParticle(struct Sprite *); +void AnimItemSteal(struct Sprite *); +void AnimTrickBag(struct Sprite *); +void AnimFlyingParticle(struct Sprite *); +void AnimNeedleArmSpike(struct Sprite *); +void sub_80A43F8(struct Sprite *); +void AnimWhipHit(struct Sprite *); +void sub_80A4494(struct Sprite *); +void AnimCuttingSlice(struct Sprite *); +void AnimAirCutterSlice(struct Sprite *); +void sub_80A481C(struct Sprite *); +void AnimProtect(struct Sprite *); +void AnimMilkBottle(struct Sprite *); +void AnimGrantingStars(struct Sprite *); +void AnimSparkingStars(struct Sprite *); +void sub_80A4E40(struct Sprite *); +void AnimSleepLetterZ(struct Sprite *); +void AnimLockOnTarget(struct Sprite *); +void AnimLockOnMoveTarget(struct Sprite *); +void AnimBowMon(struct Sprite *); +void sub_80A5590(struct Sprite *); +void AnimSlashSlice(struct Sprite *); +void AnimFalseSwipeSlice(struct Sprite *); +void AnimFalseSwipePositionedSlice(struct Sprite *); +void AnimEndureEnergy(struct Sprite *); +void AnimSharpenSphere(struct Sprite *); +void AnimConversion(struct Sprite *); +void AnimConversion2(struct Sprite *); +void AnimMoon(struct Sprite *); +void AnimMoonlightSparkle(struct Sprite *); +void AnimHornHit(struct Sprite *); +void AnimSuperFang(struct Sprite *); +void AnimWavyMusicNotes(struct Sprite *); +void AnimFlyingMusicNotes(struct Sprite *); +void AnimBellyDrumHand(struct Sprite *); +void AnimSlowFlyingMusicNotes(struct Sprite *); +void AnimThoughtBubble(struct Sprite *); +void AnimMetronomeFinger(struct Sprite *); +void AnimFollowMeFinger(struct Sprite *); +void AnimTauntFinger(struct Sprite *); +static void AnimMovePowderParticleStep(struct Sprite *); +static void AnimSolarbeamSmallOrbStep(struct Sprite *); +static void AnimAbsorptionOrbStep(struct Sprite *); +static void AnimHyperBeamOrbStep(struct Sprite *); +static void AnimLeechSeedStep(struct Sprite *); +static void AnimLeechSeedSprouts(struct Sprite *); +static void AnimSporeParticleStep(struct Sprite *); +static void AnimPetalDanceBigFlowerStep(struct Sprite *); +static void AnimPetalDanceSmallFlowerStep(struct Sprite *); +static void AnimRazorLeafParticleStep1(struct Sprite *); +static void AnimRazorLeafParticleStep2(struct Sprite *); +static void AnimTranslateLinearSingleSineWaveStep(struct Sprite *); +static void AnimMoveTwisterParticleStep(struct Sprite *); +static void AnimConstrictBindingStep1(struct Sprite *); +static void AnimConstrictBindingStep2(struct Sprite *); +static void AnimTask_DuplicateAndShrinkToPosStep1(u8); +static void AnimTask_DuplicateAndShrinkToPosStep2(u8); +static void AnimItemStealStep3(struct Sprite *); +static void AnimRootFlickerOut(struct Sprite *); +static void AnimTrickBagStep1(struct Sprite *); +static void AnimTrickBagStep2(struct Sprite *); +static void AnimTrickBagStep3(struct Sprite *); +static void AnimTask_LeafBladeStep(u8); +static s16 LeafBladeGetPosFactor(struct Sprite *); +static void AnimTask_LeafBladeStep2(struct Task *, u8); +static void AnimTask_LeafBladeStep2_Callback(struct Sprite *); +static void AnimFlyingParticleStep(struct Sprite *); +static void AnimNeedleArmSpikeStep(struct Sprite *); +static void AnimSliceStep(struct Sprite *); +static void sub_80A4880(struct Sprite *); +static void AnimProtectStep(struct Sprite *); +static void AnimMilkBottleStep1(struct Sprite *); +static void AnimMilkBottleStep2(struct Sprite *, int, int); +static void sub_80A4EA0(struct Sprite *); +static void AnimSleepLetterZStep(struct Sprite *); +static void AnimLockOnTargetStep1(struct Sprite *); +static void AnimLockOnTargetStep2(struct Sprite *); +static void AnimLockOnTargetStep3(struct Sprite *); +static void AnimLockOnTargetStep4(struct Sprite *); +static void AnimLockOnTargetStep5(struct Sprite *); +static void AnimLockOnTargetStep6(struct Sprite *); +static void AnimBowMonStep1(struct Sprite *); +static void AnimBowMonStep1_Callback(struct Sprite *); +static void AnimBowMonStep2(struct Sprite *); +static void AnimBowMonStep3(struct Sprite *); +static void AnimBowMonStep4(struct Sprite *); +static void AnimBowMonStep3_Callback(struct Sprite *); +static void sub_80A55A0(struct Sprite *); +static void AnimTask_SkullBashPositionSet(u8); +static void AnimTask_SkullBashPositionReset(u8); +static void AnimFalseSwipeSliceStep1(struct Sprite *); +static void AnimFalseSwipeSliceStep2(struct Sprite *); +static void AnimFalseSwipeSliceStep3(struct Sprite *); +static void AnimEndureEnergyStep(struct Sprite *); +static void AnimSharpenSphereStep(struct Sprite *); +static void AnimConversion2Step(struct Sprite *); +static void AnimMoonStep(struct Sprite *); +static void AnimMoonlightSparkleStep(struct Sprite *); +static void AnimHornHitStep(struct Sprite *); +static void AnimTask_DoubleTeamStep(u8); +static void AnimTask_DoubleTeamCallback(struct Sprite *); +static void AnimWavyMusicNotesGetNextPos(s16, s16, s16 *, s16 *, s8); +static void AnimWavyMusicNotesStep(struct Sprite *); +static void AnimFlyingMusicNotesStep(struct Sprite *); +static void AnimSlowFlyingMusicNotesStep(struct Sprite *); +static void AnimThoughtBubbleStep(struct Sprite *); +static void AnimMetronomeFingerStep(struct Sprite *); +static void AnimFollowMeFingerStep1(struct Sprite *); +static void AnimFollowMeFingerStep2(struct Sprite *); +static void AnimTauntFingerStep1(struct Sprite *); +static void AnimTauntFingerStep2(struct Sprite *); + +const union AnimCmd gPowderParticlesAnimCmds[] = //gUnknown_83E2968 +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(2, 5), + ANIMCMD_FRAME(4, 5), + ANIMCMD_FRAME(6, 5), + ANIMCMD_FRAME(8, 5), + ANIMCMD_FRAME(10, 5), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(14, 5), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gPowderParticlesAnimTable[] = //gUnknown_83E298C +{ + gPowderParticlesAnimCmds, +}; + +const struct SpriteTemplate gSleepPowderParticleSpriteTemplate = //gUnknown_83E2990 +{ + .tileTag = ANIM_TAG_SLEEP_POWDER, + .paletteTag = ANIM_TAG_SLEEP_POWDER, + .oam = &gOamData_AffineOff_ObjNormal_8x16, + .anims = gPowderParticlesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMovePowderParticle, +}; + +const struct SpriteTemplate gStunSporeParticleSpriteTemplate = //gUnknown_83E29A8 +{ + .tileTag = ANIM_TAG_STUN_SPORE, + .paletteTag = ANIM_TAG_STUN_SPORE, + .oam = &gOamData_AffineOff_ObjNormal_8x16, + .anims = gPowderParticlesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMovePowderParticle, +}; + +const struct SpriteTemplate gPoisonPowderParticleSpriteTemplate = //gUnknown_83E29C0 +{ + .tileTag = ANIM_TAG_POISON_POWDER, + .paletteTag = ANIM_TAG_POISON_POWDER, + .oam = &gOamData_AffineOff_ObjNormal_8x16, + .anims = gPowderParticlesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMovePowderParticle, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds1[] = //gUnknown_83E29D8 +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds2[] = +{ + ANIMCMD_FRAME(1, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds3[] = +{ + ANIMCMD_FRAME(2, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds4[] = +{ + ANIMCMD_FRAME(3, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds5[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds6[] = +{ + ANIMCMD_FRAME(5, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds7[] = +{ + ANIMCMD_FRAME(6, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamSmallOrbAnimCms[] = +{ + ANIMCMD_FRAME(7, 1), + ANIMCMD_END, +}; + +const union AnimCmd gPowerAbsorptionOrbAnimCmds[] = +{ + ANIMCMD_FRAME(8, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = //gUnknown_83E2A20 +{ + gSolarbeamBigOrbAnimCmds1, + gSolarbeamBigOrbAnimCmds2, + gSolarbeamBigOrbAnimCmds3, + gSolarbeamBigOrbAnimCmds4, + gSolarbeamBigOrbAnimCmds5, + gSolarbeamBigOrbAnimCmds6, + gSolarbeamBigOrbAnimCmds7, +}; + +const union AnimCmd *const gSolarbeamSmallOrbAnimTable[] = //gUnknown_83E2A3C +{ + gSolarbeamSmallOrbAnimCms, +}; + +const union AnimCmd *const gPowerAbsorptionOrbAnimTable[] = //gUnknown_83E2A40 +{ + gPowerAbsorptionOrbAnimCmds, +}; + +const union AffineAnimCmd gPowerAbsorptionOrbAffineAnimCmds[] = //gUnknown_83E2A44 +{ + AFFINEANIMCMD_FRAME(-5, -5, 0, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gPowerAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2A54 +{ + gPowerAbsorptionOrbAffineAnimCmds, +}; + +const struct SpriteTemplate gPowerAbsorptionOrbSpriteTemplate = //gUnknown_83E2A58 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineNormal_ObjBlend_16x16, + .anims = gPowerAbsorptionOrbAnimTable, + .images = NULL, + .affineAnims = gPowerAbsorptionOrbAffineAnimTable, + .callback = AnimPowerAbsorptionOrb, +}; + +const struct SpriteTemplate gSolarbeamBigOrbSpriteTemplate = //gUnknown_83E2A70 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gSolarbeamBigOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSolarbeamBigOrb, +}; + +const struct SpriteTemplate gSolarbeamSmallOrbSpriteTemplate = //gUnknown_83E2A88 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gSolarbeamSmallOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSolarbeamSmallOrb, +}; + +const union AffineAnimCmd gStockpileAbsorptionOrbAffineCmds[] = //gUnknown_83E2AA0 +{ + AFFINEANIMCMD_FRAME(320, 320, 0, 0), + AFFINEANIMCMD_FRAME(-14, -14, 0, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gStockpileAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2AB8 +{ + gStockpileAbsorptionOrbAffineCmds, +}; + +const struct SpriteTemplate gStockpileAbsorptionOrbSpriteTemplate = //gUnknown_83E2ABC +{ + .tileTag = ANIM_TAG_GRAY_ORB, + .paletteTag = ANIM_TAG_GRAY_ORB, + .oam = &gOamData_AffineDouble_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gStockpileAbsorptionOrbAffineAnimTable, + .callback = AnimPowerAbsorptionOrb, +}; + +const union AffineAnimCmd gAbsorptionOrbAffineAnimCmds[] = //gUnknown_83E2AD4 +{ + AFFINEANIMCMD_FRAME(-5, -5, 0, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2AE4 +{ + gAbsorptionOrbAffineAnimCmds, +}; + +const struct SpriteTemplate gAbsorptionOrbSpriteTemplate = //gUnknown_83E2AE8 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineNormal_ObjBlend_16x16, + .anims = gPowerAbsorptionOrbAnimTable, + .images = NULL, + .affineAnims = gAbsorptionOrbAffineAnimTable, + .callback = AnimAbsorptionOrb, +}; + +const struct SpriteTemplate gHyperBeamOrbSpriteTemplate = //gUnknown_83E2B00 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gSolarbeamBigOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimHyperBeamOrb, +}; + +const union AnimCmd gLeechSeedAnimCmds1[] = //gUnknown_83E2B18 +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeechSeedAnimCmds2[] = //gUnknown_83E2B20 +{ + ANIMCMD_FRAME(4, 7), + ANIMCMD_FRAME(8, 7), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gLeechSeedAnimTable[] = //gUnknown_83E2B2C +{ + gLeechSeedAnimCmds1, + gLeechSeedAnimCmds2, +}; + +const struct SpriteTemplate gLeechSeedSpriteTemplate = //gUnknown_83E2B34 +{ + .tileTag = ANIM_TAG_SEED, + .paletteTag = ANIM_TAG_SEED, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gLeechSeedAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimLeechSeed, +}; + +const union AnimCmd gSporeParticleAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSporeParticleAnimCmds2[] = +{ + ANIMCMD_FRAME(4, 7), + ANIMCMD_END, +}; + +const union AnimCmd *const gSporeParticleAnimTable[] = +{ + gSporeParticleAnimCmds1, + gSporeParticleAnimCmds2, +}; + +const struct SpriteTemplate gSporeParticleSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPORE, + .paletteTag = ANIM_TAG_SPORE, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gSporeParticleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSporeParticle, +}; + +const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = +{ + gPetalDanceBigFlowerAnimCmds, +}; + +const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = +{ + gPetalDanceSmallFlowerAnimCmds, +}; + +const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FLOWER, + .paletteTag = ANIM_TAG_FLOWER, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gPetalDanceBigFlowerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPetalDanceBigFlower, +}; + +const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FLOWER, + .paletteTag = ANIM_TAG_FLOWER, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gPetalDanceSmallFlowerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPetalDanceSmallFlower, +}; + +const union AnimCmd gRazorLeafParticleAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(4, 5), + ANIMCMD_FRAME(8, 5), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(20, 5), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(8, 5), + ANIMCMD_FRAME(4, 5), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gRazorLeafParticleAnimCmds2[] = +{ + ANIMCMD_FRAME(24, 5), + ANIMCMD_FRAME(28, 5), + ANIMCMD_FRAME(32, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gRazorLeafParticleAnimTable[] = +{ + gRazorLeafParticleAnimCmds1, + gRazorLeafParticleAnimCmds2, +}; + +const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = +{ + .tileTag = ANIM_TAG_LEAF, + .paletteTag = ANIM_TAG_LEAF, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gRazorLeafParticleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRazorLeafParticle, +}; + +const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = +{ + .tileTag = ANIM_TAG_LEAF, + .paletteTag = ANIM_TAG_LEAF, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gRazorLeafParticleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMoveTwisterParticle, +}; + +const union AnimCmd gRazorLeafCutterAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(0, 3, .hFlip = TRUE), + ANIMCMD_FRAME(0, 3, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(0, 3, .vFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gRazorLeafCutterAnimTable[] = +{ + gRazorLeafCutterAnimCmds, +}; + +const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = +{ + .tileTag = ANIM_TAG_RAZOR_LEAF, + .paletteTag = ANIM_TAG_RAZOR_LEAF, + .oam = &gOamData_AffineOff_ObjNormal_32x16, + .anims = gRazorLeafCutterAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimTranslateLinearSingleSineWave, +}; + +const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(0, 0, 0, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = { + gSwiftStarAffineAnimCmds, +}; + +const struct SpriteTemplate gSwiftStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_YELLOW_STAR, + .paletteTag = ANIM_TAG_YELLOW_STAR, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSwiftStarAffineAnimTable, + .callback = AnimTranslateLinearSingleSineWave, +}; + +const union AnimCmd gConstrictBindingAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(64, 4), + ANIMCMD_FRAME(96, 4), + ANIMCMD_END, +}; + +const union AnimCmd gConstrictBindingAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_FRAME(64, 4, .hFlip = TRUE), + ANIMCMD_FRAME(96, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gConstrictBindingAnimTable[] = +{ + gConstrictBindingAnimCmds1, + gConstrictBindingAnimCmds2, +}; + +const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = { + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-11, 0, 0, 6), + AFFINEANIMCMD_FRAME(11, 0, 0, 6), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = { + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(11, 0, 0, 6), + AFFINEANIMCMD_FRAME(-11, 0, 0, 6), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = { + gConstrictBindingAffineAnimCmds1, + gConstrictBindingAffineAnimCmds2, +}; + +const struct SpriteTemplate gConstrictBindingSpriteTemplate = +{ + .tileTag = ANIM_TAG_TENDRILS, + .paletteTag = ANIM_TAG_TENDRILS, + .oam = &gOamData_AffineNormal_ObjNormal_64x32, + .anims = gConstrictBindingAnimTable, + .images = NULL, + .affineAnims = gConstrictBindingAffineAnimTable, + .callback = AnimConstrictBinding, +}; + +const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = { + AFFINEANIMCMD_FRAME(0, 0, 0, 0), + AFFINEANIMCMD_FRAME(48, 48, 0, 14), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = { + AFFINEANIMCMD_FRAME(-16, -16, 0, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = { + gMimicOrbAffineAnimCmds1, + gMimicOrbAffineAnimCmds2, +}; + +const struct SpriteTemplate gMimicOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gPowerAbsorptionOrbAnimTable, + .images = NULL, + .affineAnims = gMimicOrbAffineAnimTable, + .callback = AnimMimicOrb, +}; + +const union AnimCmd gIngrainRootAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 7), + ANIMCMD_FRAME(16, 7), + ANIMCMD_FRAME(32, 7), + ANIMCMD_FRAME(48, 7), + ANIMCMD_END, +}; + +const union AnimCmd gIngrainRootAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 7, .hFlip = TRUE), + ANIMCMD_FRAME(16, 7, .hFlip = TRUE), + ANIMCMD_FRAME(32, 7, .hFlip = TRUE), + ANIMCMD_FRAME(48, 7, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gIngrainRootAnimCmds3[] = +{ + ANIMCMD_FRAME(0, 7), + ANIMCMD_FRAME(16, 7), + ANIMCMD_FRAME(32, 7), + ANIMCMD_END, +}; + +const union AnimCmd gIngrainRootAnimCmds4[] = +{ + ANIMCMD_FRAME(0, 7, .hFlip = TRUE), + ANIMCMD_FRAME(16, 7, .hFlip = TRUE), + ANIMCMD_FRAME(32, 7, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gIngrainRootAnimTable[] = +{ + gIngrainRootAnimCmds1, + gIngrainRootAnimCmds2, + gIngrainRootAnimCmds3, + gIngrainRootAnimCmds4, +}; + +const struct SpriteTemplate gIngrainRootSpriteTemplate = +{ + .tileTag = ANIM_TAG_ROOTS, + .paletteTag = ANIM_TAG_ROOTS, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gIngrainRootAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimIngrainRoot, +}; + +const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = +{ + .tileTag = ANIM_TAG_ROOTS, + .paletteTag = ANIM_TAG_ROOTS, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gIngrainRootAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFrenzyPlantRoot, +}; + +const union AnimCmd gIngrainOrbAnimCmds[] = +{ + ANIMCMD_FRAME(3, 3), + ANIMCMD_FRAME(0, 5), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gIngrainOrbAnimTable[] = +{ + gIngrainOrbAnimCmds, +}; + +const struct SpriteTemplate gIngrainOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gIngrainOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimIngrainOrb, +}; + +const union AnimCmd gFallingBagAnimCmds[] = +{ + ANIMCMD_FRAME(0, 30), + ANIMCMD_END, +}; + +const union AnimCmd *const gFallingBagAnimTable[] = +{ + gFallingBagAnimCmds, +}; + +const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = { + AFFINEANIMCMD_FRAME(0, 0, -4, 10), + AFFINEANIMCMD_FRAME(0, 0, 4, 20), + AFFINEANIMCMD_FRAME(0, 0, -4, 10), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = { + AFFINEANIMCMD_FRAME(0, 0, -1, 2), + AFFINEANIMCMD_FRAME(0, 0, 1, 4), + AFFINEANIMCMD_FRAME(0, 0, -1, 4), + AFFINEANIMCMD_FRAME(0, 0, 1, 4), + AFFINEANIMCMD_FRAME(0, 0, -1, 4), + AFFINEANIMCMD_FRAME(0, 0, 1, 2), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = { + gFallingBagAffineAnimCmds1, + gFallingBagAffineAnimCmds2, +}; + +const struct SpriteTemplate gPresentSpriteTemplate = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gFallingBagAnimTable, + .images = NULL, + .affineAnims = gFallingBagAffineAnimTable, + .callback = AnimPresent, +}; + +const struct SpriteTemplate gKnockOffItemSpriteTemplate = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gFallingBagAnimTable, + .images = NULL, + .affineAnims = gFallingBagAffineAnimTable, + .callback = AnimKnockOffItem, +}; + +const union AnimCmd gPresentHealParticleAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(12, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gPresentHealParticleAnimTable[] = +{ + gPresentHealParticleAnimCmds, +}; + +const struct SpriteTemplate gPresentHealParticleSpriteTemplate = +{ + .tileTag = ANIM_TAG_GREEN_SPARKLE, + .paletteTag = ANIM_TAG_GREEN_SPARKLE, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gPresentHealParticleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPresentHealParticle, +}; + +const struct SpriteTemplate gItemStealSpriteTemplate = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gFallingBagAnimTable, + .images = NULL, + .affineAnims = gFallingBagAffineAnimTable, + .callback = AnimItemSteal, +}; + +const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = { + AFFINEANIMCMD_FRAME(0, 0, 0, 3), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = { + AFFINEANIMCMD_FRAME(0, -10, 0, 3), + AFFINEANIMCMD_FRAME(0, -6, 0, 3), + AFFINEANIMCMD_FRAME(0, -2, 0, 3), + AFFINEANIMCMD_FRAME(0, 0, 0, 3), + AFFINEANIMCMD_FRAME(0, 2, 0, 3), + AFFINEANIMCMD_FRAME(0, 6, 0, 3), + AFFINEANIMCMD_FRAME(0, 10, 0, 3), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = { + gTrickBagAffineAnimCmds1, + gTrickBagAffineAnimCmds2, + gFallingBagAffineAnimCmds1, + gFallingBagAffineAnimCmds2, +}; + +const struct SpriteTemplate gTrickBagSpriteTemplate = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gFallingBagAnimTable, + .images = NULL, + .affineAnims = gTrickBagAffineAnimTable, + .callback = AnimTrickBag, +}; + +const s8 gTrickBagCoordinates[][3] = +{ + {5, 24, 1}, + {0, 4, 0}, + {8, 16, -1}, + {0, 2, 0}, + {8, 16, 1}, + {0, 2, 0}, + {8, 16, 1}, + {0, 2, 0}, + {8, 16, 1}, + {0, 16, 0}, + {0, 0, 127}, +}; + +const union AnimCmd gLeafBladeAnimCmds1[] = +{ + ANIMCMD_FRAME(28, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds2[] = +{ + ANIMCMD_FRAME(32, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds3[] = +{ + ANIMCMD_FRAME(20, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds4[] = +{ + ANIMCMD_FRAME(28, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds5[] = +{ + ANIMCMD_FRAME(16, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds6[] = +{ + ANIMCMD_FRAME(16, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds7[] = +{ + ANIMCMD_FRAME(28, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gLeafBladeAnimTable[] = +{ + gLeafBladeAnimCmds1, + gLeafBladeAnimCmds2, + gLeafBladeAnimCmds3, + gLeafBladeAnimCmds4, + gLeafBladeAnimCmds5, + gLeafBladeAnimCmds6, + gLeafBladeAnimCmds7, +}; + +const struct SpriteTemplate gLeafBladeSpriteTemplate = +{ + .tileTag = ANIM_TAG_LEAF, + .paletteTag = ANIM_TAG_LEAF, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gLeafBladeAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(256, 256, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, 4, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = { + gAromatherapyBigFlowerAffineAnimCmds, +}; + +const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FLOWER, + .paletteTag = ANIM_TAG_FLOWER, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gPetalDanceSmallFlowerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FLOWER, + .paletteTag = ANIM_TAG_FLOWER, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gPetalDanceBigFlowerAnimTable, + .images = NULL, + .affineAnims = gAromatherapyBigFlowerAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(256, 256, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, -10, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(192, 192, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, -12, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(143, 143, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, -15, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = { + gSilverWindBigSparkAffineAnimCmds, +}; + +const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = { + gSilverWindMediumSparkAffineAnimCmds, +}; + +const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = { + gSilverWindSmallSparkAffineAnimCmds, +}; + +const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_6, + .paletteTag = ANIM_TAG_SPARKLE_6, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSilverWindBigSparkAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_6, + .paletteTag = ANIM_TAG_SPARKLE_6, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSilverWindMediumSparkAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_6, + .paletteTag = ANIM_TAG_SPARKLE_6, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSilverWindSmallSparkAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const u16 gMagicalLeafBlendColors[] = +{ + RGB(31, 0, 0), + RGB(31, 19, 0), + RGB(31, 31, 0), + RGB(0, 31, 0), + RGB(5, 14, 31), + RGB(22, 10, 31), + RGB(22, 21, 31), +}; + +const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = +{ + .tileTag = ANIM_TAG_GREEN_SPIKE, + .paletteTag = ANIM_TAG_GREEN_SPIKE, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimNeedleArmSpike, +}; + +const union AnimCmd gWhipAnimCmds1[] = +{ + ANIMCMD_FRAME(64, 3), + ANIMCMD_FRAME(80, 3), + ANIMCMD_FRAME(96, 3), + ANIMCMD_FRAME(112, 6), + ANIMCMD_END, +}; + +const union AnimCmd gWhipAnimCmds2[] = +{ + ANIMCMD_FRAME(64, 3, .hFlip = TRUE), + ANIMCMD_FRAME(80, 3, .hFlip = TRUE), + ANIMCMD_FRAME(96, 3, .hFlip = TRUE), + ANIMCMD_FRAME(112, 6, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gWhipAnimTable[] = +{ + gWhipAnimCmds1, + gWhipAnimCmds2, +}; + +const struct SpriteTemplate gSlamHitSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLAM_HIT, + .paletteTag = ANIM_TAG_SLAM_HIT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gWhipAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWhipHit, +}; + +const struct SpriteTemplate gVineWhipSpriteTemplate = +{ + .tileTag = ANIM_TAG_WHIP_HIT, + .paletteTag = ANIM_TAG_WHIP_HIT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gWhipAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWhipHit, +}; + +const union AnimCmd gUnknown_08592900[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_FRAME(64, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_08592918[] = +{ + gUnknown_08592900, +}; + +// Unused +const struct SpriteTemplate gUnknown_0859291C = +{ + .tileTag = ANIM_TAG_HIT, + .paletteTag = ANIM_TAG_HIT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gUnknown_08592918, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A43F8, +}; + +// Unused +const struct SpriteTemplate gUnknown_08592934 = +{ + .tileTag = ANIM_TAG_HIT_2, + .paletteTag = ANIM_TAG_HIT_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gUnknown_08592918, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A43F8, +}; + +const union AffineAnimCmd gUnknown_0859294C[] = { + AFFINEANIMCMD_FRAME(256, 256, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859295C[] = { + AFFINEANIMCMD_FRAME(256, 256, 32, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859296C[] = { + AFFINEANIMCMD_FRAME(256, 256, 64, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859297C[] = { + AFFINEANIMCMD_FRAME(256, 256, 96, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859298C[] = { + AFFINEANIMCMD_FRAME(256, 256, -128, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859299C[] = { + AFFINEANIMCMD_FRAME(256, 256, -96, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_085929AC[] = { + AFFINEANIMCMD_FRAME(256, 256, -64, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_085929BC[] = { + AFFINEANIMCMD_FRAME(256, 256, -32, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gUnknown_085929CC[] = { + gUnknown_0859294C, + gUnknown_0859295C, + gUnknown_0859296C, + gUnknown_0859297C, + gUnknown_0859298C, + gUnknown_0859299C, + gUnknown_085929AC, + gUnknown_085929BC, +}; + +// Unused +const struct SpriteTemplate gUnknown_085929EC = +{ + .tileTag = ANIM_TAG_HANDS_AND_FEET, + .paletteTag = ANIM_TAG_HANDS_AND_FEET, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gUnknown_085929CC, + .callback = sub_80A4494, +}; + +const union AnimCmd gCuttingSliceAnimCmds[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(32, 5), + ANIMCMD_FRAME(48, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gCuttingSliceAnimTable[] = +{ + gCuttingSliceAnimCmds, +}; + +const struct SpriteTemplate gCuttingSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_CUT, + .paletteTag = ANIM_TAG_CUT, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gCuttingSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimCuttingSlice, +}; + +const struct SpriteTemplate gAirCutterSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_CUT, + .paletteTag = ANIM_TAG_CUT, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gCuttingSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimAirCutterSlice, +}; + +const union AnimCmd gUnknown_08592A4C[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A54[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A5C[] = +{ + ANIMCMD_FRAME(8, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A64[] = +{ + ANIMCMD_FRAME(12, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A6C[] = +{ + ANIMCMD_FRAME(16, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A74[] = +{ + ANIMCMD_FRAME(20, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A7C[] = +{ + ANIMCMD_FRAME(0, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A84[] = +{ + ANIMCMD_FRAME(4, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A8C[] = +{ + ANIMCMD_FRAME(8, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A94[] = +{ + ANIMCMD_FRAME(12, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_08592A9C[] = +{ + gUnknown_08592A4C, + gUnknown_08592A54, + gUnknown_08592A5C, + gUnknown_08592A64, + gUnknown_08592A6C, + gUnknown_08592A74, + gUnknown_08592A7C, + gUnknown_08592A84, + gUnknown_08592A8C, + gUnknown_08592A94, +}; + +// Unused +const struct SpriteTemplate gUnknown_08592AC4 = +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gUnknown_08592A9C, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A481C, +}; + +const struct SpriteTemplate gUnknown_08592ADC = +{ + .tileTag = ANIM_TAG_PROTECT, + .paletteTag = ANIM_TAG_PROTECT, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimProtect, +}; + +const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), + AFFINEANIMCMD_FRAME(0x0, 0x0, -2, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), + AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] = +{ + gMilkBottleAffineAnimCmds1, + gMilkBottleAffineAnimCmds2, +}; + +const struct SpriteTemplate gMilkBottleSpriteTemplate = +{ + .tileTag = ANIM_TAG_MILK_BOTTLE, + .paletteTag = ANIM_TAG_MILK_BOTTLE, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gMilkBottleAffineAnimTable, + .callback = AnimMilkBottle, +}; + +const union AnimCmd gGrantingStarsAnimCmds[] = +{ + ANIMCMD_FRAME(0, 7), + ANIMCMD_FRAME(16, 7), + ANIMCMD_FRAME(32, 7), + ANIMCMD_FRAME(48, 7), + ANIMCMD_FRAME(64, 7), + ANIMCMD_FRAME(80, 7), + ANIMCMD_FRAME(96, 7), + ANIMCMD_FRAME(112, 7), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gGrantingStarsAnimTable[] = +{ + gGrantingStarsAnimCmds, +}; + +const struct SpriteTemplate gGrantingStarsSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_2, + .paletteTag = ANIM_TAG_SPARKLE_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gGrantingStarsAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimGrantingStars, +}; + +const struct SpriteTemplate gSparklingStarsSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_2, + .paletteTag = ANIM_TAG_SPARKLE_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gGrantingStarsAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSparkingStars, +}; + +const union AnimCmd gUnknown_08592BAC[] = +{ + ANIMCMD_FRAME(0, 10), + ANIMCMD_FRAME(4, 10), + ANIMCMD_FRAME(8, 10), + ANIMCMD_FRAME(12, 10), + ANIMCMD_FRAME(16, 26), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(20, 5), + ANIMCMD_FRAME(24, 15), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592BD0[] = +{ + ANIMCMD_FRAME(0, 10, .hFlip = TRUE), + ANIMCMD_FRAME(4, 10, .hFlip = TRUE), + ANIMCMD_FRAME(8, 10, .hFlip = TRUE), + ANIMCMD_FRAME(12, 10, .hFlip = TRUE), + ANIMCMD_FRAME(16, 26, .hFlip = TRUE), + ANIMCMD_FRAME(16, 5, .hFlip = TRUE), + ANIMCMD_FRAME(20, 5, .hFlip = TRUE), + ANIMCMD_FRAME(24, 15, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_08592BF4[] = +{ + gUnknown_08592BAC, + gUnknown_08592BD0, +}; + +// Unused +const struct SpriteTemplate gUnknown_08592BFC = +{ + .tileTag = ANIM_TAG_BUBBLE_BURST, + .paletteTag = ANIM_TAG_BUBBLE_BURST, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gUnknown_08592BF4, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A4E40, +}; + +const union AnimCmd gSleepLetterZAnimCmds[] = +{ + ANIMCMD_FRAME(0, 40), + ANIMCMD_END, +}; + +const union AnimCmd *const gSleepLetterZAnimTable[] = +{ + gSleepLetterZAnimCmds, +}; + +const union AffineAnimCmd gSleepLetterZAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x14, 0x14, -30, 0), + AFFINEANIMCMD_FRAME(0x8, 0x8, 1, 24), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSleepLetterZAffineAnimCmds1_2[] = +{ + AFFINEANIMCMD_LOOP(0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), + AFFINEANIMCMD_LOOP(10), +}; + +const union AffineAnimCmd gSleepLetterZAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x14, 0x14, 30, 0), + AFFINEANIMCMD_FRAME(0x8, 0x8, -1, 24), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSleepLetterZAffineAnimCmds2_2[] = +{ + AFFINEANIMCMD_LOOP(0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 24), + AFFINEANIMCMD_LOOP(10), +}; + +const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] = +{ + gSleepLetterZAffineAnimCmds1, + gSleepLetterZAffineAnimCmds2, +}; + +const struct SpriteTemplate gSleepLetterZSpriteTemplate = +{ + .tileTag = ANIM_TAG_LETTER_Z, + .paletteTag = ANIM_TAG_LETTER_Z, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gSleepLetterZAnimTable, + .images = NULL, + .affineAnims = gSleepLetterZAffineAnimTable, + .callback = AnimSleepLetterZ, +}; + +const struct SpriteTemplate gLockOnTargetSpriteTemplate = +{ + .tileTag = ANIM_TAG_LOCK_ON, + .paletteTag = ANIM_TAG_LOCK_ON, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimLockOnTarget, +}; + +const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = +{ + .tileTag = ANIM_TAG_LOCK_ON, + .paletteTag = ANIM_TAG_LOCK_ON, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimLockOnMoveTarget, +}; + +const s8 gInclineMonCoordTable[][2] = +{ + { 64, 64}, + { 0, -64}, + {-64, 64}, + { 32, -32}, +}; + +const struct SpriteTemplate gBowMonSpriteTemplate = +{ + .tileTag = 0, + .paletteTag = 0, + .oam = &gDummyOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBowMon, +}; + +// Unused +const struct SpriteTemplate gUnknown_08592CF0 = +{ + .tileTag = 0, + .paletteTag = 0, + .oam = &gDummyOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A5590, +}; + +const union AnimCmd gSlashSliceAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_END, +}; + +const union AnimCmd gSlashSliceAnimCmds2[] = +{ + ANIMCMD_FRAME(48, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gSlashSliceAnimTable[] = +{ + gSlashSliceAnimCmds1, + gSlashSliceAnimCmds2, +}; + +const struct SpriteTemplate gSlashSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLASH, + .paletteTag = ANIM_TAG_SLASH, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSlashSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSlashSlice, +}; + +const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLASH_2, + .paletteTag = ANIM_TAG_SLASH_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSlashSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFalseSwipeSlice, +}; + +const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLASH_2, + .paletteTag = ANIM_TAG_SLASH_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSlashSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFalseSwipePositionedSlice, +}; + +const union AnimCmd gEndureEnergyAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(8, 12), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(24, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gEndureEnergyAnimTable[] = +{ + gEndureEnergyAnimCmds, +}; + +const struct SpriteTemplate gEndureEnergySpriteTemplate = +{ + .tileTag = ANIM_TAG_FOCUS_ENERGY, + .paletteTag = ANIM_TAG_FOCUS_ENERGY, + .oam = &gOamData_AffineOff_ObjNormal_16x32, + .anims = gEndureEnergyAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimEndureEnergy, +}; + +const union AnimCmd gSharpenSphereAnimCmds[] = +{ + ANIMCMD_FRAME(0, 18), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 18), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(32, 18), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(32, 6), + ANIMCMD_FRAME(48, 18), + ANIMCMD_FRAME(32, 6), + ANIMCMD_FRAME(48, 6), + ANIMCMD_FRAME(64, 18), + ANIMCMD_FRAME(48, 6), + ANIMCMD_FRAME(64, 54), + ANIMCMD_END, +}; + +const union AnimCmd *const gSharpenSphereAnimTable[] = +{ + gSharpenSphereAnimCmds, +}; + +const struct SpriteTemplate gSharpenSphereSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPHERE_TO_CUBE, + .paletteTag = ANIM_TAG_SPHERE_TO_CUBE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSharpenSphereAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSharpenSphere, +}; + +const struct SpriteTemplate gOctazookaBallSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLACK_BALL, + .paletteTag = ANIM_TAG_BLACK_BALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = TranslateAnimSpriteToTargetMonLocation, +}; + +const union AnimCmd gOctazookaAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(64, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gOctazookaAnimTable[] = +{ + gOctazookaAnimCmds, +}; + +const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = +{ + .tileTag = ANIM_TAG_GRAY_SMOKE, + .paletteTag = ANIM_TAG_GRAY_SMOKE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gOctazookaAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const union AnimCmd gConversionAnimCmds[] = +{ + ANIMCMD_FRAME(3, 5), + ANIMCMD_FRAME(2, 5), + ANIMCMD_FRAME(1, 5), + ANIMCMD_FRAME(0, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gConversionAnimTable[] = +{ + gConversionAnimCmds, +}; + +const union AffineAnimCmd gConversionAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gConversionAffineAnimTable[] = +{ + gConversionAffineAnimCmds, +}; + +const struct SpriteTemplate gConversionSpriteTemplate = +{ + .tileTag = ANIM_TAG_CONVERSION, + .paletteTag = ANIM_TAG_CONVERSION, + .oam = &gOamData_AffineDouble_ObjBlend_8x8, + .anims = gConversionAnimTable, + .images = NULL, + .affineAnims = gConversionAffineAnimTable, + .callback = AnimConversion, +}; + +const union AnimCmd gConversion2AnimCmds[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(1, 5), + ANIMCMD_FRAME(2, 5), + ANIMCMD_FRAME(3, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gConversion2AnimTable[] = +{ + gConversion2AnimCmds, +}; + +const struct SpriteTemplate gConversion2SpriteTemplate = +{ + .tileTag = ANIM_TAG_CONVERSION, + .paletteTag = ANIM_TAG_CONVERSION, + .oam = &gOamData_AffineDouble_ObjBlend_8x8, + .anims = gConversion2AnimTable, + .images = NULL, + .affineAnims = gConversionAffineAnimTable, + .callback = AnimConversion2, +}; + +const struct SpriteTemplate gMoonSpriteTemplate = +{ + .tileTag = ANIM_TAG_MOON, + .paletteTag = ANIM_TAG_MOON, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMoon, +}; + +const union AnimCmd gMoonlightSparkleAnimCmds[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(4, 8), + ANIMCMD_FRAME(8, 8), + ANIMCMD_FRAME(12, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gMoonlightSparkleAnimTable[] = +{ + gMoonlightSparkleAnimCmds, +}; + +const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = +{ + .tileTag = ANIM_TAG_GREEN_SPARKLE, + .paletteTag = ANIM_TAG_GREEN_SPARKLE, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gMoonlightSparkleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMoonlightSparkle, +}; + +const union AnimCmd gHealingBlueStarAnimCmds[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(32, 2), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(64, 5), + ANIMCMD_FRAME(80, 3), + ANIMCMD_FRAME(96, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_END, +}; + +const union AnimCmd *const gHealingBlueStarAnimTable[] = +{ + gHealingBlueStarAnimCmds, +}; + +const struct SpriteTemplate gHealingBlueStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLUE_STAR, + .paletteTag = ANIM_TAG_BLUE_STAR, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gHealingBlueStarAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const struct SpriteTemplate gHornHitSpriteTemplate = +{ + .tileTag = ANIM_TAG_HORN_HIT, + .paletteTag = ANIM_TAG_HORN_HIT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimHornHit, +}; + +const union AnimCmd gSuperFangAnimCmds[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(32, 2), + ANIMCMD_FRAME(48, 2), + ANIMCMD_END, +}; + +const union AnimCmd *const gSuperFangAnimTable[] = +{ + gSuperFangAnimCmds, +}; + +const struct SpriteTemplate gSuperFangSpriteTemplate = +{ + .tileTag = ANIM_TAG_FANG_ATTACK, + .paletteTag = ANIM_TAG_FANG_ATTACK, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSuperFangAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSuperFang, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds2[] = +{ + ANIMCMD_FRAME(4, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds3[] = +{ + ANIMCMD_FRAME(8, 41), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds4[] = +{ + ANIMCMD_FRAME(12, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds5[] = +{ + ANIMCMD_FRAME(16, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds6[] = +{ + ANIMCMD_FRAME(20, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds7[] = +{ + ANIMCMD_FRAME(0, 10, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds8[] = +{ + ANIMCMD_FRAME(4, 10, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gMusicNotesAnimTable[] = +{ + gWavyMusicNotesAnimCmds1, + gWavyMusicNotesAnimCmds2, + gWavyMusicNotesAnimCmds3, + gWavyMusicNotesAnimCmds4, + gWavyMusicNotesAnimCmds5, + gWavyMusicNotesAnimCmds6, + gWavyMusicNotesAnimCmds7, + gWavyMusicNotesAnimCmds8, +}; + +const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0xC, 0xC, 0, 16), + AFFINEANIMCMD_FRAME(0xFFF4, 0xFFF4, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = +{ + gWavyMusicNotesAffineAnimCmds, +}; + +const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gMusicNotesAffineAnimTable, + .callback = AnimWavyMusicNotes, +}; + +const u16 gParticlesColorBlendTable[][6] = +{ + {ANIM_TAG_MUSIC_NOTES, RGB(31, 31, 31), RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, + {ANIM_TAG_BENT_SPOON, RGB(31, 31, 31), RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, + {ANIM_TAG_SPHERE_TO_CUBE, RGB(31, 31, 31), RGB(31, 31, 24), RGB(31, 31, 17), RGB(31, 31, 10), RGB(31, 31, 3)}, + {ANIM_TAG_LARGE_FRESH_EGG, RGB(31, 31, 31), RGB(26, 28, 31), RGB(21, 26, 31), RGB(16, 24, 31), RGB(12, 22, 31)}, +}; + +const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gMusicNotesAffineAnimTable, + .callback = AnimFlyingMusicNotes, +}; + +const struct SpriteTemplate gBellyDrumHandSpriteTemplate = +{ + .tileTag = ANIM_TAG_PURPLE_HAND_OUTLINE, + .paletteTag = ANIM_TAG_PURPLE_HAND_OUTLINE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBellyDrumHand, +}; + +const union AffineAnimCmd gSlowFlyingMusicNotesAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0xA0, 0xA0, 0, 0), + AFFINEANIMCMD_FRAME(0x4, 0x4, 0, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gSlowFlyingMusicNotesAffineAnimTable[] = +{ + gSlowFlyingMusicNotesAffineAnimCmds, +}; + +const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gSlowFlyingMusicNotesAffineAnimTable, + .callback = AnimSlowFlyingMusicNotes, +}; + +const union AnimCmd gMetronomeThroughtBubbleAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 2, .hFlip = TRUE), + ANIMCMD_FRAME(16, 2, .hFlip = TRUE), + ANIMCMD_FRAME(32, 2, .hFlip = TRUE), + ANIMCMD_FRAME(48, 2, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gMetronomeThroughtBubbleAnimCmds3[] = +{ + ANIMCMD_FRAME(48, 2, .hFlip = TRUE), + ANIMCMD_FRAME(32, 2, .hFlip = TRUE), + ANIMCMD_FRAME(16, 2, .hFlip = TRUE), + ANIMCMD_FRAME(0, 2, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gMetronomeThroughtBubbleAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(32, 2), + ANIMCMD_FRAME(48, 2), + ANIMCMD_END, +}; + +const union AnimCmd gMetronomeThroughtBubbleAnimCmds4[] = +{ + ANIMCMD_FRAME(48, 2), + ANIMCMD_FRAME(32, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_END, +}; + +const union AnimCmd *const gMetronomeThroughtBubbleAnimTable[] = +{ + gMetronomeThroughtBubbleAnimCmds1, + gMetronomeThroughtBubbleAnimCmds2, + gMetronomeThroughtBubbleAnimCmds3, + gMetronomeThroughtBubbleAnimCmds4, +}; + +const struct SpriteTemplate gThoughtBubbleSpriteTemplate = +{ + .tileTag = ANIM_TAG_THOUGHT_BUBBLE, + .paletteTag = ANIM_TAG_THOUGHT_BUBBLE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gMetronomeThroughtBubbleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimThoughtBubble, +}; + +const union AffineAnimCmd gMetronomeFingerAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), + AFFINEANIMCMD_FRAME(0x1E, 0x1E, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 11), + AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 11), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_FRAME(0xFFE2, 0xFFE2, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2_2[] = +{ + AFFINEANIMCMD_FRAME(16, 16, 0, 0), + AFFINEANIMCMD_FRAME(30, 30, 0, 8), + AFFINEANIMCMD_FRAME(0, 0, 0, 16), + AFFINEANIMCMD_LOOP(0), + AFFINEANIMCMD_FRAME(0, 0, 4, 11), + AFFINEANIMCMD_FRAME(0, 0, -4, 11), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_FRAME(-30, -30, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gMetronomeFingerAffineAnimTable[] = +{ + gMetronomeFingerAffineAnimCmds1, + gMetronomeFingerAffineAnimCmds2, +}; + +const struct SpriteTemplate gMetronomeFingerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FINGER, + .paletteTag = ANIM_TAG_FINGER, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gMetronomeFingerAffineAnimTable, + .callback = AnimMetronomeFinger, +}; + +const struct SpriteTemplate gFollowMeFingerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FINGER, + .paletteTag = ANIM_TAG_FINGER, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gMetronomeFingerAffineAnimTable, + .callback = AnimFollowMeFinger, +}; + +const union AnimCmd gTauntFingerAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gTauntFingerAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gTauntFingerAnimCmds3[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_END, +}; + +const union AnimCmd gTauntFingerAnimCmds4[] = +{ + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(16, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_FRAME(16, 4, .hFlip = TRUE), + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(16, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gTauntFingerAnimTable[] = +{ + gTauntFingerAnimCmds1, + gTauntFingerAnimCmds2, + gTauntFingerAnimCmds3, + gTauntFingerAnimCmds4, +}; + +const struct SpriteTemplate gTauntFingerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FINGER_2, + .paletteTag = ANIM_TAG_FINGER_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gTauntFingerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimTauntFinger, +}; + +// Animates the falling particles that horizontally wave back and forth. +// Used by Sleep Powder, Stun Spore, and Poison Powder. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: total duration in frames +// arg 3: vertical movement speed (sub-pixel value) +// arg 4: wave amplitude +// arg 5: wave speed +void AnimMovePowderParticle(struct Sprite* sprite) +{ + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + + if (GetBattlerSide(gBattleAnimAttacker)) + { + sprite->data[3] = -gBattleAnimArgs[4]; + } + else + { + sprite->data[3] = gBattleAnimArgs[4]; + } + + sprite->data[4] = gBattleAnimArgs[5]; + sprite->callback = AnimMovePowderParticleStep; +} + +static void AnimMovePowderParticleStep(struct Sprite* sprite) +{ + if (sprite->data[0] > 0) + { + sprite->data[0]--; + sprite->pos2.y = sprite->data[2] >> 8; + sprite->data[2] += sprite->data[1]; + sprite->pos2.x = Sin(sprite->data[5], sprite->data[3]); + sprite->data[5] = (sprite->data[5] + sprite->data[4]) & 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +// Moves an energy orb towards the center of the mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: duration +void AnimPowerAbsorptionOrb(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); +} + +// Moves an orb in a straight line towards the target mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: duration +// arg 3: sprite anim number +void AnimSolarbeamBigOrb(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + StartSpriteAnim(sprite, gBattleAnimArgs[3]); + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Moves a small orb in a wavy pattern towards the target mon. +// The small orb "circles" the big orbs in AnimSolarbeamBigOrb. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: duration +// arg 3: initial wave offset +void AnimSolarbeamSmallOrb(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + InitAnimLinearTranslation(sprite); + sprite->data[5] = gBattleAnimArgs[3]; + sprite->callback = AnimSolarbeamSmallOrbStep; + sprite->callback(sprite); +} + +static void AnimSolarbeamSmallOrbStep(struct Sprite* sprite) +{ + if (AnimTranslateLinear(sprite)) + { + DestroySprite(sprite); + } + else + { + if (sprite->data[5] > 0x7F) + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + 1; + else + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + 6; + + sprite->pos2.x += Sin(sprite->data[5], 5); + sprite->pos2.y += Cos(sprite->data[5], 14); + sprite->data[5] = (sprite->data[5] + 15) & 0xFF; + } +} + +// Creates 15 small secondary orbs used in the solarbeam anim effect. +// There is a 7-frame delay between each of them. +// No args. +void AnimTask_CreateSmallSolarbeamOrbs(u8 taskId) +{ + if (--gTasks[taskId].data[0] == -1) + { + gTasks[taskId].data[1]++; + gTasks[taskId].data[0] = 6; + gBattleAnimArgs[0] = 15; + gBattleAnimArgs[1] = 0; + gBattleAnimArgs[2] = 80; + gBattleAnimArgs[3] = 0; + CreateSpriteAndAnimate(&gSolarbeamSmallOrbSpriteTemplate, 0, 0, GetBattlerSpriteSubpriority(gBattleAnimTarget) + 1); + } + + if (gTasks[taskId].data[1] == 15) + DestroyAnimVisualTask(taskId); +} + +// Moves an orb from the target mon to the attacking mon in an arc-like fashion. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: wave amplitude +// arg 3: wave period (lower means faster wave) +void AnimAbsorptionOrb(struct Sprite* sprite) +{ + InitSpritePosToAnimTarget(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[3]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->data[5] = gBattleAnimArgs[2]; + InitAnimArcTranslation(sprite); + sprite->callback = AnimAbsorptionOrbStep; +} + +static void AnimAbsorptionOrbStep(struct Sprite* sprite) +{ + if (TranslateAnimHorizontalArc(sprite)) + DestroyAnimSprite(sprite); +} + +// Moves an orb in a wave-like fashion towards the target mon. The wave's +// properties and the sprite anim are randomly determined. +void AnimHyperBeamOrb(struct Sprite* sprite) +{ + u16 speed; + u16 animNum = Random2(); + + StartSpriteAnim(sprite, animNum % 8); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x -= 20; + else + sprite->pos1.x += 20; + + speed = Random2(); + sprite->data[0] = (speed & 31) + 64; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + InitAnimFastLinearTranslationWithSpeed(sprite); + sprite->data[5] = Random2() & 0xFF; + sprite->data[6] = sprite->subpriority; + sprite->callback = AnimHyperBeamOrbStep; + sprite->callback(sprite); +} + +static void AnimHyperBeamOrbStep(struct Sprite* sprite) +{ + if (AnimFastTranslateLinear(sprite)) + { + DestroyAnimSprite(sprite); + } + else + { + sprite->pos2.y += Cos(sprite->data[5], 12); + if (sprite->data[5] < 0x7F) + sprite->subpriority = sprite->data[6]; + else + sprite->subpriority = sprite->data[6] + 1; + + sprite->data[5] += 24; + sprite->data[5] &= 0xFF; + } +} + +// seed (sprouts a sapling from a seed.) +// Used by Leech Seed. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: target x pixel offset +// arg 3: target y pixel offset +// arg 4: duration +// arg 5: wave amplitude +void AnimLeechSeed(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + gBattleAnimArgs[3]; + sprite->data[5] = gBattleAnimArgs[5]; + InitAnimArcTranslation(sprite); + sprite->callback = AnimLeechSeedStep; +} + +static void AnimLeechSeedStep(struct Sprite* sprite) +{ + if (TranslateAnimHorizontalArc(sprite)) + { + sprite->invisible = 1; + sprite->data[0] = 10; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLeechSeedSprouts); + } +} + +static void AnimLeechSeedSprouts(struct Sprite* sprite) +{ + sprite->invisible = 0; + StartSpriteAnim(sprite, 1); + sprite->data[0] = 60; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Moves a spore particle in a halo around the target mon. +// The sprite's priority is updated to give the effect of going +// behind the mon's sprite. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: initial wave offset +// arg 3: duration +// arg 4: blend (0 = off, 1 = on) +void AnimSporeParticle(struct Sprite* sprite) +{ + InitSpritePosToAnimTarget(sprite, TRUE); + StartSpriteAnim(sprite, gBattleAnimArgs[4]); + if (gBattleAnimArgs[4] == 1) + sprite->oam.objMode = ST_OAM_OBJ_BLEND; + + sprite->data[0] = gBattleAnimArgs[3]; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->callback = AnimSporeParticleStep; + sprite->callback(sprite); +} + +static void AnimSporeParticleStep(struct Sprite* sprite) +{ + sprite->pos2.x = Sin(sprite->data[1], 32); + sprite->pos2.y = Cos(sprite->data[1], -3) + ((sprite->data[2] += 24) >> 8); + if ((u16)(sprite->data[1] - 0x40) < 0x80) + { + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget); + } + else + { + u8 priority = GetBattlerSpriteBGPriority(gBattleAnimTarget) + 1; + if (priority > 3) + priority = 3; + + sprite->oam.priority = priority; + } + + sprite->data[1] += 2; + sprite->data[1] &= 0xFF; + if (--sprite->data[0] == -1) + DestroyAnimSprite(sprite); +} + +// In a double battle, Updates the mon sprite background priorities to allow +// the circling effect controlled by AnimSporeParticle. +// No args. +void AnimTask_SporeDoubleBattle(u8 taskId) +{ + if (IsContest() || !IsDoubleBattle()) + { + DestroyAnimVisualTask(taskId); + } + else + { + if (GetBattlerSpriteBGPriorityRank(gBattleAnimTarget) == 1) + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 3); + else + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + + DestroyAnimVisualTask(taskId); + } +} + +// Rotates a big flower around the attacking mon, and slowly floats +// downward. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: target y pixel offset +// arg 3: duration +void AnimPetalDanceBigFlower(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + sprite->data[0] = gBattleAnimArgs[3]; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; + InitAnimLinearTranslation(sprite); + sprite->data[5] = 0x40; + sprite->callback = AnimPetalDanceBigFlowerStep; + sprite->callback(sprite); +} + +static void AnimPetalDanceBigFlowerStep(struct Sprite* sprite) +{ + if (!AnimTranslateLinear(sprite)) + { + sprite->pos2.x += Sin(sprite->data[5], 32); + sprite->pos2.y += Cos(sprite->data[5], -5); + if ((u16)(sprite->data[5] - 0x40) < 0x80) + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) - 1; + else + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) + 1; + + sprite->data[5] = (sprite->data[5] + 5) & 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +// Slowly floats a small flower downard, while swaying from right to left. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: target y pixel offset +// arg 3: duration +void AnimPetalDanceSmallFlower(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[3]; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + InitAnimLinearTranslation(sprite); + sprite->data[5] = 0x40; + sprite->callback = AnimPetalDanceSmallFlowerStep; + sprite->callback(sprite); +} + +static void AnimPetalDanceSmallFlowerStep(struct Sprite* sprite) +{ + if (!AnimTranslateLinear(sprite)) + { + sprite->pos2.x += Sin(sprite->data[5], 8); + if ((u16)(sprite->data[5] - 59) < 5 || (u16)(sprite->data[5] - 187) < 5) + sprite->oam.matrixNum ^= ST_OAM_HFLIP; + + sprite->data[5] += 5; + sprite->data[5] &= 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +// Shoots a leaf upward, then floats it downward while swaying back and forth. +// arg 0: upward x delta per frame +// arg 1: upward y delta per frame +// arg 2: upward duration +void AnimRazorLeafParticle(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[2] = gBattleAnimArgs[2]; + sprite->callback = AnimRazorLeafParticleStep1; +} + +static void AnimRazorLeafParticleStep1(struct Sprite* sprite) +{ + if (!sprite->data[2]) + { + if (sprite->data[1] & 1) + { + sprite->data[0] = 0x80; + sprite->data[1] = 0; + sprite->data[2] = 0; + } + else + { + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2] = 0; + } + sprite->callback = AnimRazorLeafParticleStep2; + } + else + { + sprite->data[2]--; + sprite->pos1.x += sprite->data[0]; + sprite->pos1.y += sprite->data[1]; + } +} + +static void AnimRazorLeafParticleStep2(struct Sprite* sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker)) + sprite->pos2.x = -Sin(sprite->data[0], 25); + else + sprite->pos2.x = Sin(sprite->data[0], 25); + + sprite->data[0] += 2; + sprite->data[0] &= 0xFF; + sprite->data[1]++; + if (!(sprite->data[1] & 1)) + sprite->pos2.y++; + + if (sprite->data[1] > 80) + DestroyAnimSprite(sprite); +} + +// Animates a sprite that moves linearly from one location to another, with a +// single-cycle sine wave added to the y position along the way. +// Used by Razor Leaf and Magical Leaf. +// arg 0: initial x offset +// arg 1: initial y offset +// arg 2: target x offset +// arg 3: target y offset +// arg 4: translation duration +// arg 5: wave amplitude +// arg 6: target between double battle opponents (boolean) +void AnimTranslateLinearSingleSineWave(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + if (!gBattleAnimArgs[6]) + { + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[3]; + } + else + { + SetAverageBattlerPositions(gBattleAnimTarget, TRUE, &sprite->data[2], &sprite->data[4]); + sprite->data[2] += gBattleAnimArgs[2]; + sprite->data[4] += gBattleAnimArgs[3]; + } + + sprite->data[5] = gBattleAnimArgs[5]; + InitAnimArcTranslation(sprite); + if (GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) + sprite->data[0] = 1; + else + sprite->data[0] = 0; + + sprite->callback = AnimTranslateLinearSingleSineWaveStep; +} + +static void AnimTranslateLinearSingleSineWaveStep(struct Sprite* sprite) +{ + bool8 destroy = FALSE; + s16 a = sprite->data[0]; + s16 b = sprite->data[7]; + s16 r0; + + sprite->data[0] = 1; + TranslateAnimHorizontalArc(sprite); + r0 = sprite->data[7]; + sprite->data[0] = a; + if (b > 200 && r0 < 56 && sprite->oam.affineParam == 0) + sprite->oam.affineParam++; + + if (sprite->oam.affineParam && sprite->data[0]) + { + sprite->invisible ^= 1; + sprite->oam.affineParam++; + if (sprite->oam.affineParam == 30) + destroy = TRUE; + } + + if (sprite->pos1.x + sprite->pos2.x > 256 + || sprite->pos1.x + sprite->pos2.x < -16 + || sprite->pos1.y + sprite->pos2.y > 160 + || sprite->pos1.y + sprite->pos2.y < -16) + destroy = TRUE; + + if (destroy) + DestroyAnimSprite(sprite); +} + +// Animates particles in the Twister move animation. +// arg 0: duration +// arg 1: total y delta (the particles rise upward) +// arg 2: wave period (higher means faster wave) +// arg 3: wave amplitude +// arg 4: speedup frame (particles move faster at the end of the animation) +void AnimMoveTwisterParticle(struct Sprite* sprite) +{ + if (IsDoubleBattle() == TRUE) + SetAverageBattlerPositions(gBattleAnimTarget, 1, &sprite->pos1.x, &sprite->pos1.y); + + sprite->pos1.y += 32; + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[2] = gBattleAnimArgs[2]; + sprite->data[3] = gBattleAnimArgs[3]; + sprite->data[4] = gBattleAnimArgs[4]; + sprite->callback = AnimMoveTwisterParticleStep; +} + +static void AnimMoveTwisterParticleStep(struct Sprite* sprite) +{ + if (sprite->data[1] == 0xFF) + { + sprite->pos1.y -= 2; + } + else if (sprite->data[1] > 0) + { + sprite->pos1.y -= 2; + sprite->data[1] -= 2; + } + + sprite->data[5] += sprite->data[2]; + if (sprite->data[0] < sprite->data[4]) + sprite->data[5] += sprite->data[2]; + + sprite->data[5] &= 0xFF; + sprite->pos2.x = Cos(sprite->data[5], sprite->data[3]); + sprite->pos2.y = Sin(sprite->data[5], 5); + if (sprite->data[5] < 0x80) + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget) - 1; + else + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget) + 1; + + if (--sprite->data[0] == 0) + DestroyAnimSprite(sprite); +} + +// Squeezes a constricting "rope" several times via affine animations. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: affine anim num +// arg 3: num squeezes +void AnimConstrictBinding(struct Sprite* sprite) +{ + InitSpritePosToAnimTarget(sprite, FALSE); + sprite->affineAnimPaused = 1; + StartSpriteAffineAnim(sprite, gBattleAnimArgs[2]); + sprite->data[6] = gBattleAnimArgs[2]; + sprite->data[7] = gBattleAnimArgs[3]; + sprite->callback = AnimConstrictBindingStep1; +} + +static void AnimConstrictBindingStep1(struct Sprite* sprite) +{ + u8 spriteId; + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + { + sprite->affineAnimPaused = 0; + spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + sprite->data[0] = 0x100; + sprite->callback = AnimConstrictBindingStep2; + } +} + +static void AnimConstrictBindingStep2(struct Sprite* sprite) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (!sprite->data[2]) + sprite->data[0] += 11; + else + sprite->data[0] -= 11; + + if (++sprite->data[1] == 6) + { + sprite->data[1] = 0; + sprite->data[2] ^= 1; + } + + if (sprite->affineAnimEnded) + { + if (--sprite->data[7] > 0) + StartSpriteAffineAnim(sprite, sprite->data[6]); + else + DestroyAnimSprite(sprite); + } +} + +void sub_80FF458(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (gSprites[spriteId].invisible) + { + DestroyAnimVisualTask(taskId); + } + else + { + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_BLEND); + gTasks[taskId].data[14] = gSprites[spriteId].oam.priority; + gSprites[spriteId].oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget); + spriteId = GetAnimBattlerSpriteId(ANIM_DEF_PARTNER); + gTasks[taskId].data[15] = gSprites[spriteId].oam.priority; + gSprites[spriteId].oam.priority = GetBattlerSpriteBGPriority(BATTLE_PARTNER(gBattleAnimTarget)); + gTasks[taskId].data[0] = gBattleAnimArgs[0]; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + gTasks[taskId].data[11] = 0x100; + gTasks[taskId].func = AnimTask_DuplicateAndShrinkToPosStep1; + } +} + +static void AnimTask_DuplicateAndShrinkToPosStep1(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + gTasks[taskId].data[10] += gTasks[taskId].data[0]; + gSprites[spriteId].pos2.x = gTasks[taskId].data[10] >> 8; + if (GetBattlerSide(gBattleAnimTarget) != B_SIDE_PLAYER) + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos2.x; + + gTasks[taskId].data[11] += 16; + SetSpriteRotScale(spriteId, gTasks[taskId].data[11], gTasks[taskId].data[11], 0); + SetBattlerSpriteYOffsetFromYScale(spriteId); + if (--gTasks[taskId].data[1] == 0) + { + gTasks[taskId].data[0] = 0; + gTasks[taskId].func = AnimTask_DuplicateAndShrinkToPosStep2; + } +} + +static void AnimTask_DuplicateAndShrinkToPosStep2(u8 taskId) +{ + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + { + if (gTasks[taskId].data[0] == 0) + { + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + ResetSpriteRotScale(spriteId); + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + gSprites[spriteId].oam.priority = gTasks[taskId].data[14]; + spriteId = GetAnimBattlerSpriteId(ANIM_DEF_PARTNER); + gSprites[spriteId].oam.priority = gTasks[taskId].data[15]; + gTasks[taskId].data[0]++; + return; + } + } + else + { + if (gTasks[taskId].data[0] == 0) + return; + } + + gTasks[taskId].data[0]++; + if (gTasks[taskId].data[0] == 3) + DestroyAnimVisualTask(taskId); +} + +// Moves an orb from the target mon to the attacking mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +void AnimMimicOrb(struct Sprite* sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + gBattleAnimArgs[0] *= -1; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + gBattleAnimArgs[1]; + sprite->invisible = 1; + sprite->data[0]++; + break; + case 1: + sprite->invisible = 0; + if (sprite->affineAnimEnded) + { + ChangeSpriteAffineAnim(sprite, 1); + sprite->data[0] = 25; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->callback = InitAndRunAnimFastLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + break; + } + } +} + +// Animates a root that flickers away after some time. +// arg 0: x pixel offset +// arg 1: y pixel offset +// arg 2: sprite subpriority offset +// arg 3: sprite anim num +// arg 4: duration +void AnimIngrainRoot(struct Sprite* sprite) +{ + if (!sprite->data[0]) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); + sprite->pos2.x = gBattleAnimArgs[0]; + sprite->pos2.y = gBattleAnimArgs[1]; + sprite->subpriority = gBattleAnimArgs[2] + 30; + StartSpriteAnim(sprite, gBattleAnimArgs[3]); + sprite->data[2] = gBattleAnimArgs[4]; + sprite->data[0]++; + if (sprite->pos1.y + sprite->pos2.y > 120) + sprite->pos1.y += sprite->pos2.y + sprite->pos1.y - 120; + } + sprite->callback = AnimRootFlickerOut; +} + +// Places a root on the path to the target mon that flickers away after some time. +// arg 0: percent along the path to the target mon +// arg 1: x pixel offset +// arg 2: y pixel offset +// arg 3: sprite subpriority offset +// arg 4: sprite anum num +// arg 5: duration +void AnimFrenzyPlantRoot(struct Sprite *sprite) +{ + s16 attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + s16 attackerY = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + s16 targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + s16 targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + + targetX -= attackerX; + targetY -= attackerY; + sprite->pos1.x = attackerX + targetX * gBattleAnimArgs[0] / 100; + sprite->pos1.y = attackerY + targetY * gBattleAnimArgs[0] / 100; + sprite->pos2.x = gBattleAnimArgs[1]; + sprite->pos2.y = gBattleAnimArgs[2]; + sprite->subpriority = gBattleAnimArgs[3] + 30; + StartSpriteAnim(sprite, gBattleAnimArgs[4]); + sprite->data[2] = gBattleAnimArgs[5]; + sprite->callback = AnimRootFlickerOut; + gUnknown_0203A0F8[0] = sprite->pos1.x; + gUnknown_0203A0F8[1] = sprite->pos1.y; + gUnknown_0203A0F8[2] = targetX; + gUnknown_0203A0F8[3] = targetY; +} + +static void AnimRootFlickerOut(struct Sprite* sprite) +{ + if (++sprite->data[0] > (sprite->data[2] - 10)) + sprite->invisible = sprite->data[0] % 2; + + if (sprite->data[0] > sprite->data[2]) + DestroyAnimSprite(sprite); +} + +// Moves an orb in a fast wavy path. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: horizontal velocity +// arg 3: wave amplitude +// arg 4: duration +void AnimIngrainOrb(struct Sprite* sprite) +{ + if (!sprite->data[0]) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[3]; + sprite->data[3] = gBattleAnimArgs[4]; + } + + sprite->data[0]++; + sprite->pos2.x = sprite->data[1] * sprite->data[0]; + sprite->pos2.y = Sin((sprite->data[0] * 20) & 0xFF, sprite->data[2]); + if (sprite->data[0] > sprite->data[3]) + DestroyAnimSprite(sprite); +} + +static void sub_80FF9B8(struct Sprite* sprite, s16 c) +{ + int a = (sprite->pos1.x << 8) | sprite->pos1.y; + int b = (sprite->data[6] << 8) | sprite->data[7]; + c <<= 8; + sprite->data[5] = a; + sprite->data[6] = b; + sprite->data[7] = c; +} + +bool8 moveAlongLinearPath(struct Sprite* sprite) +{ + u16 xStartPos = (u8)(sprite->data[5] >> 8); + u16 yStartPos = (u8)sprite->data[5]; + s32 xEndPos = (u8)(sprite->data[6] >> 8); + s32 yEndPos = (u8)sprite->data[6]; + s16 totalTime = sprite->data[7] >> 8; + s16 currentTime = sprite->data[7] & 0xFF; + s16 yEndPos_2; + s16 r0; + s32 var1; + s32 vaxEndPos; + + if (xEndPos == 0) + xEndPos = -32; + else if (xEndPos == 255) + xEndPos = 272; + + yEndPos_2 = yEndPos - yStartPos; + r0 = xEndPos - xStartPos; + var1 = r0 * currentTime / totalTime; + vaxEndPos = yEndPos_2 * currentTime / totalTime; + sprite->pos1.x = var1 + xStartPos; + sprite->pos1.y = vaxEndPos + yStartPos; + if (++currentTime == totalTime) + return TRUE; + + sprite->data[7] = (totalTime << 8) | currentTime; + return FALSE; +} + +void AnimItemStealStep2(struct Sprite* sprite) +{ + if (sprite->data[0] == 10) + StartSpriteAffineAnim(sprite, 1); + + sprite->data[0]++; + if (sprite->data[0] > 50) + DestroyAnimSprite(sprite); +} + +static void AnimItemStealStep1(struct Sprite* sprite) +{ + sprite->data[0] += sprite->data[3] * 128 / sprite->data[4]; + if (sprite->data[0] >= 128) + { + sprite->data[1]++; + sprite->data[0] = 0; + } + + sprite->pos2.y = Sin(sprite->data[0] + 128, 30 - sprite->data[1] * 8); + if (moveAlongLinearPath(sprite)) + { + sprite->pos2.y = 0; + sprite->data[0] = 0; + sprite->callback = AnimItemStealStep2; + } +} + +void AnimPresent(struct Sprite* sprite) +{ + s16 targetX; + s16 targetY; + InitSpritePosToAnimAttacker(sprite, FALSE); + targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); + if (BATTLE_PARTNER(gBattleAnimAttacker) == gBattleAnimTarget) + { + sprite->data[6] = targetX; + sprite->data[7] = targetY + 10; + sub_80FF9B8(sprite, 60); + sprite->data[3] = 1; + } + else + { + sprite->data[6] = targetX; + sprite->data[7] = targetY + 10; + sub_80FF9B8(sprite, 60); + sprite->data[3] = 3; + } + + sprite->data[4] = 60; + sprite->callback = AnimItemStealStep1; +} + +static void sub_80FFB90(struct Sprite* sprite) +{ + int zero; + sprite->data[0] += ((sprite->data[3] * 128) / sprite->data[4]); + zero = 0; + if (sprite->data[0] > 0x7F) + { + sprite->data[1]++; + sprite->data[0] = zero; + } + + sprite->pos2.y = Sin(sprite->data[0] + 0x80, 30 - sprite->data[1] * 8); + if (moveAlongLinearPath(sprite)) + { + sprite->pos2.y = zero; + sprite->data[0] = zero; + DestroyAnimSprite(sprite); + } +} + +void AnimKnockOffItem(struct Sprite* sprite) +{ + s16 targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + sprite->data[6] = 0; + sprite->data[7] = targetY + 10; + sub_80FF9B8(sprite, 40); + sprite->data[3] = 3; + sprite->data[4] = 60; + sprite->callback = AnimItemStealStep1; + } + else + { + sprite->data[6] = 255; + sprite->data[7] = targetY + 10; + if (IsContest()) + sprite->data[6] = 0; + + sub_80FF9B8(sprite, 40); + sprite->data[3] = 3; + sprite->data[4] = 60; + sprite->callback = sub_80FFB90; + } +} + +// Animates a heal particle upward. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: vertical velocity +// arg 3: unused +void AnimPresentHealParticle(struct Sprite* sprite) +{ + if (!sprite->data[0]) + { + InitSpritePosToAnimTarget(sprite, FALSE); + sprite->data[1] = gBattleAnimArgs[2]; + } + + sprite->data[0]++; + sprite->pos2.y = sprite->data[1] * sprite->data[0]; + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimItemSteal(struct Sprite* sprite) +{ + s16 attackerX; + s16 attackerY; + InitSpritePosToAnimTarget(sprite, FALSE); + attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + attackerY = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); + if (BATTLE_PARTNER(gBattleAnimTarget) == gBattleAnimAttacker) + { + sprite->data[6] = attackerX; + sprite->data[7] = attackerY + 10; + sub_80FF9B8(sprite, 60); + sprite->data[3] = 1; + } + else + { + sprite->data[6] = attackerX; + sprite->data[7] = attackerY + 10; + sub_80FF9B8(sprite, 60); + sprite->data[3] = 3; + } + + sprite->data[4] = 60; + sprite->callback = AnimItemStealStep3; +} + +static void AnimItemStealStep3(struct Sprite* sprite) +{ + int zero; + sprite->data[0] += ((sprite->data[3] * 128) / sprite->data[4]); + zero = 0; + if (sprite->data[0] > 127) + { + sprite->data[1]++; + sprite->data[0] = zero; + } + + sprite->pos2.y = Sin(sprite->data[0] + 0x80, 30 - sprite->data[1] * 8); + if (sprite->pos2.y == 0) + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(63)); + + if (moveAlongLinearPath(sprite)) + { + sprite->pos2.y = 0; + sprite->data[0] = 0; + sprite->callback = AnimItemStealStep2; + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + } +} + +// Moves a bag in a circular motion. +// arg 0: y position +// arg 1: initial wave offset +void AnimTrickBag(struct Sprite* sprite) +{ + int a; + int b; + + if (!sprite->data[0]) + { + if (!IsContest()) + { + sprite->data[1] = gBattleAnimArgs[1]; + sprite->pos1.x = 120; + } + else + { + a = gBattleAnimArgs[1] - 32; + if (a < 0) + b = gBattleAnimArgs[1] + 0xDF; + else + b = a; + + sprite->data[1] = a - ((b >> 8) << 8); + sprite->pos1.x = 70; + } + + sprite->pos1.y = gBattleAnimArgs[0]; + sprite->data[2] = gBattleAnimArgs[0]; + sprite->data[4] = 20; + sprite->pos2.x = Cos(sprite->data[1], 60); + sprite->pos2.y = Sin(sprite->data[1], 20); + sprite->callback = AnimTrickBagStep1; + if (sprite->data[1] > 0 && sprite->data[1] < 192) + sprite->subpriority = 31; + else + sprite->subpriority = 29; + } +} + +static void AnimTrickBagStep1(struct Sprite* sprite) +{ + switch (sprite->data[3]) + { + case 0: + if (sprite->data[2] > 78) + { + sprite->data[3] = 1; + StartSpriteAffineAnim(sprite, 1); + break; + } + else + { + sprite->data[2] += sprite->data[4] / 10; + sprite->data[4] += 3; + sprite->pos1.y = sprite->data[2]; + break; + } + break; + case 1: + if (sprite->data[3] && sprite->affineAnimEnded) + { + sprite->data[0] = 0; + sprite->data[2] = 0; + sprite->callback = AnimTrickBagStep2; + } + break; + } +} + +static void AnimTrickBagStep2(struct Sprite* sprite) +{ + if (sprite->data[2] == gTrickBagCoordinates[sprite->data[0]][1]) + { + if (gTrickBagCoordinates[sprite->data[0]][2] == 127) + { + sprite->data[0] = 0; + sprite->callback = AnimTrickBagStep3; + } + + sprite->data[2] = 0; + sprite->data[0]++; + } + else + { + sprite->data[2]++; + sprite->data[1] = (gTrickBagCoordinates[sprite->data[0]][0] * gTrickBagCoordinates[sprite->data[0]][2] + sprite->data[1]) & 0xFF; + if (!IsContest()) + { + if ((u16)(sprite->data[1] - 1) < 191) + sprite->subpriority = 31; + else + sprite->subpriority = 29; + } + + sprite->pos2.x = Cos(sprite->data[1], 60); + sprite->pos2.y = Sin(sprite->data[1], 20); + } +} + +static void AnimTrickBagStep3(struct Sprite* sprite) +{ + if (sprite->data[0] > 20) + DestroyAnimSprite(sprite); + + sprite->invisible = sprite->data[0] % 2; + sprite->data[0]++; +} + +void AnimTask_LeafBlade(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[4] = GetBattlerSpriteSubpriority(gBattleAnimTarget) - 1; + task->data[6] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + task->data[7] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + task->data[10] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_WIDTH); + task->data[11] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT); + task->data[5] = (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) ? 1 : -1; + task->data[9] = 56 - (task->data[5] * 64); + task->data[8] = task->data[7] - task->data[9] + task->data[6]; + task->data[2] = CreateSprite(&gLeafBladeSpriteTemplate, task->data[8], task->data[9], task->data[4]); + if (task->data[2] == MAX_SPRITES) + DestroyAnimVisualTask(taskId); + + gSprites[task->data[2]].data[0] = 10; + gSprites[task->data[2]].data[1] = task->data[8]; + gSprites[task->data[2]].data[2] = task->data[6] - (task->data[10] / 2 + 10) * task->data[5]; + gSprites[task->data[2]].data[3] = task->data[9]; + gSprites[task->data[2]].data[4] = task->data[7] + (task->data[11] / 2 + 10) * task->data[5]; + gSprites[task->data[2]].data[5] = LeafBladeGetPosFactor(&gSprites[task->data[2]]); + InitAnimArcTranslation(&gSprites[task->data[2]]); + task->func = AnimTask_LeafBladeStep; +} + +static void AnimTask_LeafBladeStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + struct Sprite* sprite = &gSprites[task->data[2]]; + int a = task->data[0]; + switch (a) + { + case 4: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 5; + task->data[0] = 0xFF; + } + break; + case 8: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 9; + task->data[0] = 0xFF; + } + break; + case 0: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 1; + task->data[0] = 0xFF; + } + break; + case 1: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[4] += 2; + task->data[3] = a; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 2: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 3; + task->data[0] = 0xFF; + } + break; + case 3: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6] - ((task->data[10] / 2) + 10) * task->data[5]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7] - ((task->data[11] / 2) + 10) * task->data[5]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[3] = 2; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 5: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6] + ((task->data[10] / 2) + 10) * task->data[5]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7] + ((task->data[11] / 2) + 10) * task->data[5]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[4] -= 2; + task->data[3] = 3; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 6: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 7; + task->data[0] = 0xFF; + } + break; + case 7: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[4] += 2; + task->data[3] = 4; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 9: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6] - ((task->data[10] / 2) + 10) * task->data[5]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7] + ((task->data[11] / 2) + 10) * task->data[5]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[3] = 5; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 10: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 11; + task->data[0] = 0xFF; + } + break; + case 11: + { + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[8]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[9]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[4] -= 2; + task->data[3] = 6; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + } + case 12: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + DestroySprite(sprite); + task->data[0]++; + } + break; + case 13: + if (task->data[12] == 0) + DestroyAnimVisualTask(taskId); + break; + case 0xFF: + if (++task->data[1] > 5) + { + task->data[1] = 0; + task->data[0] = task->data[15]; + } + break; + } +} + +static s16 LeafBladeGetPosFactor(struct Sprite* sprite) +{ + s16 var = 8; + if (sprite->data[4] < sprite->pos1.y) + var = -var; + + return var; +} + +static void AnimTask_LeafBladeStep2(struct Task* task, u8 taskId) +{ + task->data[14]++; + if (task->data[14] > 0) + { + u8 spriteId; + s16 spriteX; + s16 spriteY; + task->data[14] = 0; + spriteX = gSprites[task->data[2]].pos1.x + gSprites[task->data[2]].pos2.x; + spriteY = gSprites[task->data[2]].pos1.y + gSprites[task->data[2]].pos2.y; + spriteId = CreateSprite(&gLeafBladeSpriteTemplate, spriteX, spriteY, task->data[4]); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].data[6] = taskId; + gSprites[spriteId].data[7] = 12; + gTasks[taskId].data[12]++; + gSprites[spriteId].data[0] = task->data[13] & 1; + gTasks[taskId].data[13]++; + StartSpriteAnim(&gSprites[spriteId], task->data[3]); + gSprites[spriteId].subpriority = task->data[4]; + gSprites[spriteId].callback = AnimTask_LeafBladeStep2_Callback; + } + } +} + +static void AnimTask_LeafBladeStep2_Callback(struct Sprite* sprite) +{ + sprite->data[0]++; + if (sprite->data[0] > 1) + { + sprite->data[0] = 0; + sprite->invisible ^= 1; + sprite->data[1]++; + if (sprite->data[1] > 8) + { + gTasks[sprite->data[6]].data[sprite->data[7]]--; + DestroySprite(sprite); + } + } +} + +void AnimFlyingParticle(struct Sprite* sprite) +{ + u8 battler; + if (!gBattleAnimArgs[6]) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + if (GetBattlerSide(battler) != B_SIDE_PLAYER) + { + sprite->data[4] = 0; + sprite->data[2] = gBattleAnimArgs[3]; + sprite->pos1.x = 0xFFF0; + } + else + { + sprite->data[4] = 1; + sprite->data[2] = -gBattleAnimArgs[3]; + sprite->pos1.x = 0x100; + } + + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[3] = gBattleAnimArgs[4]; + switch (gBattleAnimArgs[5]) + { + case 0: + sprite->pos1.y = gBattleAnimArgs[0]; + sprite->oam.priority = GetBattlerSpriteBGPriority(battler); + break; + case 1: + sprite->pos1.y = gBattleAnimArgs[0]; + sprite->oam.priority = GetBattlerSpriteBGPriority(battler) + 1; + break; + case 2: + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[0]; + sprite->oam.priority = GetBattlerSpriteBGPriority(battler); + break; + case 3: + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[0]; + GetAnimBattlerSpriteId(ANIM_TARGET); + sprite->oam.priority = GetBattlerSpriteBGPriority(battler) + 1; + break; + } + + sprite->callback = AnimFlyingParticleStep; +} + +static void AnimFlyingParticleStep(struct Sprite* sprite) +{ + int a = sprite->data[7]; + sprite->data[7]++; + sprite->pos2.y = (sprite->data[1] * gSineTable[sprite->data[0]]) >> 8; + sprite->pos2.x = sprite->data[2] * a; + sprite->data[0] = (sprite->data[3] * a) & 0xFF; + if (!sprite->data[4]) + { + if (sprite->pos2.x + sprite->pos1.x <= 0xF7) + return; + } + else + { + if (sprite->pos2.x + sprite->pos1.x > -16) + return; + } + + DestroySpriteAndMatrix(sprite); +} + +void sub_80A41C4(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[0]) + { + case 0: + task->data[8] = IndexOfSpritePaletteTag(ANIM_TAG_LEAF) * 16 + 256; + task->data[12] = IndexOfSpritePaletteTag(ANIM_TAG_RAZOR_LEAF) * 16 + 256; + task->data[0]++; + break; + case 1: + if (++task->data[9] >= 0) + { + task->data[9] = 0; + BlendPalette(task->data[8], 16, task->data[10], gMagicalLeafBlendColors[task->data[11]]); + BlendPalette(task->data[12], 16, task->data[10], gMagicalLeafBlendColors[task->data[11]]); + if (++task->data[10] == 17) + { + task->data[10] = 0; + if (++task->data[11] == 7) + task->data[11] = 0; + } + } + break; + } + + if (gBattleAnimArgs[7] == -1) + DestroyAnimVisualTask(taskId); +} + +void AnimNeedleArmSpike(struct Sprite* sprite) +{ + u8 a; + u8 b; + u16 c; + u16 x; + u16 y; + + if (gBattleAnimArgs[4] == 0) + { + DestroyAnimSprite(sprite); + } + else + { + if (gBattleAnimArgs[0] == 0) + { + a = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + b = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + } + else + { + a = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + b = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + } + + sprite->data[0] = gBattleAnimArgs[4]; + if (gBattleAnimArgs[1] == 0) + { + sprite->pos1.x = gBattleAnimArgs[2] + a; + sprite->pos1.y = gBattleAnimArgs[3] + b; + sprite->data[5] = a; + sprite->data[6] = b; + } + else + { + sprite->pos1.x = a; + sprite->pos1.y = b; + sprite->data[5] = gBattleAnimArgs[2] + a; + sprite->data[6] = gBattleAnimArgs[3] + b; + } + + x = sprite->pos1.x; + sprite->data[1] = x * 16; + y = sprite->pos1.y; + sprite->data[2] = y * 16; + sprite->data[3] = (sprite->data[5] - sprite->pos1.x) * 16 / gBattleAnimArgs[4]; + sprite->data[4] = (sprite->data[6] - sprite->pos1.y) * 16 / gBattleAnimArgs[4]; + c = ArcTan2Neg(sprite->data[5] - x, sprite->data[6] - y); + if (IsContest()) + c -= 0x8000; + + TrySetSpriteRotScale(sprite, 0, 0x100, 0x100, c); + sprite->callback = AnimNeedleArmSpikeStep; + } +} + +static void AnimNeedleArmSpikeStep(struct Sprite* sprite) +{ + if (sprite->data[0]) + { + sprite->data[1] += sprite->data[3]; + sprite->data[2] += sprite->data[4]; + sprite->pos1.x = sprite->data[1] >> 4 ; + sprite->pos1.y = sprite->data[2] >> 4 ; + sprite->data[0]--; + } + else + { + DestroySpriteAndMatrix(sprite); + } +} + +static void sub_80A43DC(struct Sprite* sprite) +{ + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void sub_80A43F8(struct Sprite* sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + else + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + + sprite->callback = RunStoredCallbackWhenAnimEnds; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimWhipHit(struct Sprite* sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + StartSpriteAnim(sprite, 1); + + sprite->callback = sub_80A43DC; + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; +} + +void sub_80A4494(struct Sprite* sprite) +{ + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[3] = gBattleAnimArgs[4]; + sprite->data[5] = gBattleAnimArgs[5]; + StartSpriteAffineAnim(sprite, gBattleAnimArgs[6]); + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); + sprite->callback = TranslateSpriteLinearAndFlicker; +} + +// Moves the sprite in a diagonally slashing motion across the target mon. +// Used by moves such as MOVE_CUT and MOVE_AERIAL_ACE. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: slice direction; 0 = right-to-left, 1 = left-to-right +void AnimCuttingSlice(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + sprite->pos1.y += 8; + + sprite->callback = AnimSliceStep; + if (gBattleAnimArgs[2] == 0) + { + sprite->pos1.x += gBattleAnimArgs[0]; + } + else + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->hFlip = 1; + } + + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[1] -= 0x400; + sprite->data[2] += 0x400; + sprite->data[5] = gBattleAnimArgs[2]; + if (sprite->data[5] == 1) + sprite->data[1] = -sprite->data[1]; +} + +void AnimAirCutterSlice(struct Sprite* sprite) +{ + u8 a; + u8 b; + switch (gBattleAnimArgs[3]) + { + case 1: + a = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 0); + b = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 1); + break; + case 2: + a = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + b = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget))) + { + a = (GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 0) + a) / 2; + b = (GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 1) + b) / 2; + } + break; + case 0: + default: + a = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + b = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + break; + } + + sprite->pos1.x = a; + sprite->pos1.y = b; + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + sprite->pos1.y += 8; + + sprite->callback = AnimSliceStep; + if (gBattleAnimArgs[2] == 0) + { + sprite->pos1.x += gBattleAnimArgs[0]; + } + else + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->hFlip = 1; + } + + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[1] -= 0x400; + sprite->data[2] += 0x400; + sprite->data[5] = gBattleAnimArgs[2]; + if (sprite->data[5] == 1) + sprite->data[1] = -sprite->data[1]; +} + +static void AnimSliceStep(struct Sprite* sprite) +{ + sprite->data[3] += sprite->data[1]; + sprite->data[4] += sprite->data[2]; + if (sprite->data[5] == 0) + sprite->data[1] += 0x18; + else + sprite->data[1] -= 0x18; + + sprite->data[2] -= 0x18; + sprite->pos2.x = sprite->data[3] >> 8; + sprite->pos2.y = sprite->data[4] >> 8; + sprite->data[0]++; + if (sprite->data[0] == 20) + { + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->data[0] = 3; + sprite->callback = WaitAnimForDuration; + } +} + +void sub_80A4738(struct Sprite* sprite) +{ + if (sprite->data[2] > 1) + { + if (sprite->data[3] & 1) + { + sprite->invisible = 0; + gSprites[sprite->data[0]].invisible = 0; + gSprites[sprite->data[1]].invisible = 0; + } + else + { + sprite->invisible = 1; + gSprites[sprite->data[0]].invisible = 1; + gSprites[sprite->data[1]].invisible = 1; + } + + sprite->data[2] = 0; + sprite->data[3]++; + } + else + { + sprite->data[2]++; + } + + if (sprite->data[3] == 10) + { + DestroySprite(&gSprites[sprite->data[0]]); + DestroySprite(&gSprites[sprite->data[1]]); + DestroyAnimSprite(sprite); + } +} + +void sub_80A481C(struct Sprite* sprite) +{ + sprite->data[0] = gBattleAnimArgs[2]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x -= gBattleAnimArgs[0]; + else + sprite->pos1.x += gBattleAnimArgs[0]; + + StartSpriteAnim(sprite, gBattleAnimArgs[5]); + sprite->data[1] = -gBattleAnimArgs[3]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[3] = gBattleAnimArgs[4]; + sprite->callback = sub_80A4880; + sprite->callback(sprite); +} + +static void sub_80A4880(struct Sprite* sprite) +{ + sprite->pos2.x = Cos(sprite->data[0], 100); + sprite->pos2.y = Sin(sprite->data[0], 20); + if (sprite->data[0] < 128) + sprite->subpriority = 0; + else + sprite->subpriority = 14; + + sprite->data[0] = (sprite->data[0] + sprite->data[1]) & 0xFF; + sprite->data[5] += 0x82; + sprite->pos2.y += sprite->data[5] >> 8; + sprite->data[2]++; + if (sprite->data[2] == sprite->data[3]) + DestroyAnimSprite(sprite); +} + +void AnimProtect(struct Sprite* sprite) +{ + if (IsContest()) + gBattleAnimArgs[1] += 8; + + sprite->pos1.x = GetBattlerSpriteCoord2(gBattleAnimAttacker, 0) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord2(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER || IsContest()) + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker) + 1; + else + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = (IndexOfSpritePaletteTag(ANIM_TAG_PROTECT) << 4) + 0x100; + sprite->data[7] = 16; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[7], sprite->data[7])); + sprite->callback = AnimProtectStep; +} + +static void AnimProtectStep(struct Sprite *sprite) +{ + int a; + int i; + sprite->data[5] += 96; + sprite->pos2.x = -(sprite->data[5] >> 8); + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + a = gPlttBufferFaded[sprite->data[2] + 1]; + i = 0; + do + { + gPlttBufferFaded[sprite->data[2] + ++i] = gPlttBufferFaded[sprite->data[2] + i + 1]; + } while (i < 6); + + gPlttBufferFaded[sprite->data[2] + 7] = a; + } + + if (sprite->data[7] > 6 && sprite->data[0] >0 && ++sprite->data[6] > 1) + { + sprite->data[6] = 0; + sprite->data[7] -= 1; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[7], sprite->data[7])); + } + + if (sprite->data[0] > 0) + { + sprite->data[0] -= 1; + } + else if (++sprite->data[6] > 1) + { + sprite->data[6] = 0; + sprite->data[7]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[7], sprite->data[7])); + if (sprite->data[7] == 16) + { + sprite->invisible = 1; + sprite->callback = DestroyAnimSpriteAndDisableBlend; + } + } +} + +void AnimMilkBottle(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + 0xFFE8; + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = 0; + sprite->data[6] = 0; + sprite->data[7] = 16; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + sprite->callback = AnimMilkBottleStep1; +} + +static void AnimMilkBottleStep1(struct Sprite* sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (++sprite->data[2] > 0) + { + sprite->data[2] = 0; + if (((++sprite->data[1]) & 1) != 0) + { + if (sprite->data[6] <= 15) + sprite->data[6]++; + } + else if (sprite->data[7] > 0) + sprite->data[7]--; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + if (sprite->data[6] == 16 && sprite->data[7] == 0) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + } + break; + case 1: + if (++sprite->data[1] > 8) + { + sprite->data[1] = 0; + StartSpriteAffineAnim(sprite, 1); + sprite->data[0]++; + } + break; + case 2: + AnimMilkBottleStep2(sprite, 16, 4); + if (++sprite->data[1] > 2) + { + sprite->data[1] = 0; + sprite->pos1.y++; + } + + if (++sprite->data[2] <= 29) + break; + + if (sprite->data[2] & 1) + { + if (sprite->data[6] > 0) + sprite->data[6]--; + } + else if (sprite->data[7] <= 15) + { + sprite->data[7]++; + } + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + if (sprite->data[6] == 0 && sprite->data[7] == 16) + { + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 3: + sprite->invisible = 1; + sprite->data[0]++; + break; + case 4: + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 0)); + DestroyAnimSprite(sprite); + break; + } +} + +static void AnimMilkBottleStep2(struct Sprite* sprite, int unk1, int unk2) +{ + if (sprite->data[3] <= 11) + sprite->data[4] += 2; + + if ((u16)(sprite->data[3] - 0x12) <= 0x17) + sprite->data[4] -= 2; + + if ((sprite->data[3]) > 0x2F) + sprite->data[4] += 2; + + sprite->pos2.x = sprite->data[4] / 9; + sprite->pos2.y = sprite->data[4] / 14; + if (sprite->pos2.y < 0) + sprite->pos2.y *= -1; + + sprite->data[3]++; + if (sprite->data[3] > 0x3B) + sprite->data[3] = 0; +} + +void AnimGrantingStars(struct Sprite* sprite) +{ + if (!gBattleAnimArgs[2]) + SetSpriteCoordsToAnimAttackerCoords(sprite); + + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[5]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[2] = gBattleAnimArgs[4]; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = TranslateSpriteLinearFixedPoint; +} + +void AnimSparkingStars(struct Sprite* sprite) +{ + u8 battler; + if (!gBattleAnimArgs[2]) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + if (IsDoubleBattle() && IsBattlerSpriteVisible(BATTLE_PARTNER(battler))) + { + SetAverageBattlerPositions(battler, gBattleAnimArgs[6], &sprite->pos1.x, &sprite->pos1.y); + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; + } + else + { + if (!gBattleAnimArgs[6]) + { + sprite->pos1.x = GetBattlerSpriteCoord(battler, 0); + sprite->pos1.y = GetBattlerSpriteCoord(battler, 1) + gBattleAnimArgs[1]; + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(battler, 2); + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[1]; + } + + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + } + + sprite->data[0] = gBattleAnimArgs[5]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[2] = gBattleAnimArgs[4]; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = TranslateSpriteLinearFixedPoint; +} + +void sub_80A4E40(struct Sprite* sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + else + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + StartSpriteAnim(sprite, 1); + } + + sprite->callback = sub_80A4EA0; +} + +static void sub_80A4EA0(struct Sprite* sprite) +{ + if (++sprite->data[0] > 30) + { + sprite->pos2.y = (30 - sprite->data[0]) / 3; + sprite->pos2.x = Sin(sprite->data[1] * 4, 3); + sprite->data[1]++; + } + + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimSleepLetterZ(struct Sprite* sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[3] = 1; + } + else + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[3] = 0xFFFF; + StartSpriteAffineAnim(sprite, 1); + } + + sprite->callback = AnimSleepLetterZStep; +} + +static void AnimSleepLetterZStep(struct Sprite* sprite) +{ + sprite->pos2.y = -(sprite->data[0] / 0x28); + sprite->pos2.x = sprite->data[4] / 10; + sprite->data[4] += sprite->data[3] * 2; + sprite->data[0] += sprite->data[1]; + if (++sprite->data[1] > 60) + DestroySpriteAndMatrix(sprite); +} + +void AnimLockOnTarget(struct Sprite* sprite) +{ + sprite->pos1.x -= 32; + sprite->pos1.y -= 32; + sprite->data[0] = 20; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep1); +} + +static void AnimLockOnTargetStep1(struct Sprite* sprite) +{ + switch (sprite->data[5] & 1) + { + case 0: + sprite->data[0] = 1; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep1); + break; + case 1: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[0] = 8; + sprite->data[2] = sprite->pos1.x + gInclineMonCoordTable[sprite->data[5] >> 8][0]; + sprite->data[4] = sprite->pos1.y + gInclineMonCoordTable[sprite->data[5] >> 8][1]; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep2); + sprite->data[5] += 0x100; + PlaySE12WithPanning(SE_W199, BattleAnimAdjustPanning(63)); + break; + } + + sprite->data[5] ^= 1; +} + +static void AnimLockOnTargetStep2(struct Sprite* sprite) +{ + if ((sprite->data[5] >> 8) == 4) + { + sprite->data[0] = 10; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep3); + } + else + { + sprite->callback = AnimLockOnTargetStep1; + } +} + +static void AnimLockOnTargetStep3(struct Sprite* sprite) +{ + s16 a; + s16 b; + if (sprite->oam.affineParam == 0) + { + sprite->data[0] = 3; + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep4); + } + else + { + switch (sprite->oam.affineParam) + { + case 1: + a = -8; + b = -8; + break; + case 2: + a = -8; + b = 8; + break; + case 3: + a = 8; + b = -8; + break; + default: + a = 8; + b = 8; + break; + } + + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[0] = 6; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + a; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + b; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep5); + } +} + +static void AnimLockOnTargetStep4(struct Sprite* sprite) +{ + if (sprite->data[2] == 0) + { + if ((sprite->data[1] += 3) > 16) + sprite->data[1] = 16; + } + else if ((sprite->data[1] -= 3) < 0) + { + sprite->data[1] = 0; + } + + BlendPalettes(sub_80A75AC(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB(31, 31, 31)); + if (sprite->data[1] == 16) + { + int pal; + sprite->data[2]++; + pal = sprite->oam.paletteNum; + LoadPalette(&gPlttBufferUnfaded[0x108 + pal * 16], pal * 16 | 0x101, 4); + PlaySE12WithPanning(SE_W043, BattleAnimAdjustPanning(63)); + } + else if (sprite->data[1] == 0) + { + sprite->callback = AnimLockOnTargetStep5; + } +} + +static void AnimLockOnTargetStep5(struct Sprite* sprite) +{ + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + { + sprite->data[1] = 0; + sprite->data[0] = 0; + sprite->callback = AnimLockOnTargetStep6; + } +} + +static void AnimLockOnTargetStep6(struct Sprite* sprite) +{ + if (sprite->data[0] % 3 == 0) + { + sprite->data[1]++; + sprite->invisible ^= 1; + } + + sprite->data[0]++; + if (sprite->data[1] == 8) + DestroyAnimSprite(sprite); +} + +void AnimLockOnMoveTarget(struct Sprite* sprite) +{ + sprite->oam.affineParam = gBattleAnimArgs[0]; + if ((s16)sprite->oam.affineParam == 1) + { + sprite->pos1.x -= 0x18; + sprite->pos1.y -= 0x18; + } + else if ((s16)sprite->oam.affineParam == 2) + { + sprite->pos1.x -= 0x18; + sprite->pos1.y += 0x18; + sprite->oam.matrixNum = ST_OAM_VFLIP; + } + else if ((s16)sprite->oam.affineParam == 3) + { + sprite->pos1.x += 0x18; + sprite->pos1.y -= 0x18; + sprite->oam.matrixNum = ST_OAM_HFLIP; + } + else + { + sprite->pos1.x += 0x18; + sprite->pos1.y += 0x18; + sprite->oam.matrixNum = ST_OAM_HFLIP | ST_OAM_VFLIP; + } + + sprite->oam.tileNum = (sprite->oam.tileNum + 16); + sprite->callback = AnimLockOnTarget; + sprite->callback(sprite); +} + +void AnimBowMon(struct Sprite* sprite) +{ + sprite->invisible = 1; + sprite->data[0] = 0; + switch (gBattleAnimArgs[0]) + { + case 0: + sprite->callback = AnimBowMonStep1; + break; + case 1: + sprite->callback = AnimBowMonStep2; + break; + case 2: + sprite->callback = AnimBowMonStep3; + break; + default: + sprite->callback = AnimBowMonStep4; + break; + } +} + +static void AnimBowMonStep1(struct Sprite* sprite) +{ + sprite->data[0] = 6; + sprite->data[1] = (GetBattlerSide(gBattleAnimAttacker)) ? 2 : -2; + sprite->data[2] = 0; + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + StoreSpriteCallbackInData6(sprite, AnimBowMonStep1_Callback); + sprite->callback = TranslateMonSpriteLinear; +} + +static void AnimBowMonStep1_Callback(struct Sprite* sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + PrepareBattlerSpriteForRotScale(sprite->data[3], ST_OAM_OBJ_NORMAL); + sprite->data[4] = (sprite->data[6] = GetBattlerSide(gBattleAnimAttacker)) ? 0x300 : 0xFFFFFD00; + sprite->data[5] = 0; + } + + sprite->data[5] += sprite->data[4]; + SetSpriteRotScale(sprite->data[3], 0x100, 0x100, sprite->data[5]); + SetBattlerSpriteYOffsetFromRotation(sprite->data[3]); + if (++sprite->data[0] > 3) + { + sprite->data[0] = 0; + sprite->callback = AnimBowMonStep4; + } +} + +static void AnimBowMonStep2(struct Sprite* sprite) +{ + sprite->data[0] = 4; + sprite->data[1] = (GetBattlerSide(gBattleAnimAttacker)) ? -3 : 3; + sprite->data[2] = 0; + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + StoreSpriteCallbackInData6(sprite, AnimBowMonStep4); + sprite->callback = TranslateMonSpriteLinear; +} + +static void AnimBowMonStep3(struct Sprite* sprite) +{ + if (++sprite->data[0] > 8) + { + sprite->data[0] = 0; + sprite->callback = AnimBowMonStep3_Callback; + } +} + +static void AnimBowMonStep3_Callback(struct Sprite* sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + sprite->data[6] = GetBattlerSide(gBattleAnimAttacker); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->data[4] = 0xFC00; + sprite->data[5] = 0xC00; + } + else + { + sprite->data[4] = 0x400; + sprite->data[5] = 0xF400; + } + } + + sprite->data[5] += sprite->data[4]; + SetSpriteRotScale(sprite->data[3], 0x100, 0x100, sprite->data[5]); + SetBattlerSpriteYOffsetFromRotation(sprite->data[3]); + if (++sprite->data[0] > 2) + { + ResetSpriteRotScale(sprite->data[3]); + sprite->callback = AnimBowMonStep4; + } +} + +static void AnimBowMonStep4(struct Sprite* sprite) +{ + DestroyAnimSprite(sprite); +} + +void sub_80A5590(struct Sprite *sprite) +{ + sprite->data[0] = 0; + sprite->callback = sub_80A55A0; +} + +static void sub_80A55A0(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->data[1] = 0; + sprite->data[2] = gBattlerSpriteIds[gBattleAnimAttacker]; + sprite->data[3] = GetBattlerSide(gBattleAnimAttacker); + sprite->data[4] = (sprite->data[3] != B_SIDE_PLAYER) ? 0x200 : -0x200; + sprite->data[5] = 0; + PrepareBattlerSpriteForRotScale(sprite->data[2], ST_OAM_OBJ_NORMAL); + sprite->data[0]++; + // fall through + case 1: + sprite->data[5] += sprite->data[4]; + SetSpriteRotScale(sprite->data[2], 0x100, 0x100, sprite->data[5]); + SetBattlerSpriteYOffsetFromRotation(sprite->data[2]); + if (++sprite->data[1] > 3) + { + sprite->data[1] = 0; + sprite->data[4] *= -1; + sprite->data[0]++; + } + break; + case 2: + sprite->data[5] += sprite->data[4]; + SetSpriteRotScale(sprite->data[2], 0x100, 0x100, sprite->data[5]); + SetBattlerSpriteYOffsetFromRotation(sprite->data[2]); + if (++sprite->data[1] > 3) + { + ResetSpriteRotScale(sprite->data[2]); + DestroyAnimSprite(sprite); + } + break; + } +} + +void AnimTask_SkullBashPosition(u8 taskId) +{ + u8 a; + + gTasks[taskId].data[0] = gBattlerSpriteIds[gBattleAnimAttacker]; + a = GetBattlerSide(gBattleAnimAttacker); + gTasks[taskId].data[1] = a; + gTasks[taskId].data[2] = 0; + switch (gBattleAnimArgs[0]) + { + default: + DestroyAnimVisualTask(taskId); + break; + case 0: + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[3] = 8; + gTasks[taskId].data[4] = 0; + gTasks[taskId].data[5] = 3; + if (a == 0) + gTasks[taskId].data[5] *= -1; + + gTasks[taskId].func = AnimTask_SkullBashPositionSet; + break; + case 1: + gTasks[taskId].data[3] = 8; + gTasks[taskId].data[4] = 0x600; + gTasks[taskId].data[5] = 0xC0; + if (a == 0) + { + gTasks[taskId].data[4] = -gTasks[taskId].data[4]; + gTasks[taskId].data[5] = -gTasks[taskId].data[5]; + } + + gTasks[taskId].func = AnimTask_SkullBashPositionReset; + break; + } +} + +static void AnimTask_SkullBashPositionSet(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + switch (task->data[2]) + { + case 0: + if (task->data[3]) + { + task->data[4] += task->data[5]; + gSprites[task->data[0]].pos2.x = task->data[4]; + task->data[3]--; + } + else + { + task->data[3] = 8; + task->data[4] = 0; + task->data[5] = (task->data[1] == 0) ? -0xC0 : 0xC0; + PrepareBattlerSpriteForRotScale(task->data[0], ST_OAM_OBJ_NORMAL); + task->data[2]++; + } + break; + case 1: + if (task->data[3]) + { + task->data[4] += task->data[5]; + SetSpriteRotScale(task->data[0], 0x100, 0x100, task->data[4]); + SetBattlerSpriteYOffsetFromRotation(task->data[0]); + task->data[3]--; + } + else + { + task->data[3] = 8; + task->data[4] = gSprites[task->data[0]].pos2.x; + task->data[5] = (task->data[1] == 0) ? 0x2 : -0x2; + task->data[6] = 1; + task->data[2]++; + } + break; + case 2: + if (task->data[3]) + { + if (task->data[6]) + { + task->data[6]--; + } + else + { + if (task->data[3] & 1) + gSprites[task->data[0]].pos2.x = task->data[4] + task->data[5]; + else + gSprites[task->data[0]].pos2.x = task->data[4] - task->data[5]; + + task->data[6] = 1; + task->data[3]--; + } + } + else + { + gSprites[task->data[0]].pos2.x = task->data[4]; + task->data[3] = 12; + task->data[2]++; + } + break; + case 3: + if (task->data[3]) + { + task->data[3]--; + } + else + { + task->data[3] = 3; + task->data[4] = gSprites[task->data[0]].pos2.x; + task->data[5] = (task->data[1] == 0) ? 8 : -8; + task->data[2]++; + } + break; + case 4: + if (task->data[3]) + { + task->data[4] += task->data[5]; + gSprites[task->data[0]].pos2.x = task->data[4]; + task->data[3]--; + } + else + { + DestroyAnimVisualTask(taskId); + } + break; + } +} + +static void AnimTask_SkullBashPositionReset(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (task->data[3]) + { + task->data[4] -= task->data[5]; + SetSpriteRotScale(task->data[0], 0x100, 0x100, task->data[4]); + SetBattlerSpriteYOffsetFromRotation(task->data[0]); + task->data[3]--; + } + else + { + ResetSpriteRotScale(task->data[0]); + DestroyAnimVisualTask(taskId); + } +} + +void AnimSlashSlice(struct Sprite* sprite) +{ + if (gBattleAnimArgs[0] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[2]; + } + + sprite->data[0] = 0; + sprite->data[1] = 0; + StoreSpriteCallbackInData6(sprite, AnimFalseSwipeSliceStep3); + sprite->callback = RunStoredCallbackWhenAnimEnds; +} + +void AnimFalseSwipeSlice(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 0xFFD0; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + StoreSpriteCallbackInData6(sprite, AnimFalseSwipeSliceStep1); + sprite->callback = RunStoredCallbackWhenAnimEnds; +} + +void AnimFalseSwipePositionedSlice(struct Sprite* sprite) +{ + sprite->pos1.x = sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 0xFFD0 + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + StartSpriteAnim(sprite, 1); + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->callback = AnimFalseSwipeSliceStep3; +} + +static void AnimFalseSwipeSliceStep1(struct Sprite* sprite) +{ + if (++sprite->data[0] > 8) + { + sprite->data[0] = 12; + sprite->data[1] = 8; + sprite->data[2] = 0; + StoreSpriteCallbackInData6(sprite, AnimFalseSwipeSliceStep2); + sprite->callback = TranslateSpriteLinear; + } +} + +static void AnimFalseSwipeSliceStep2(struct Sprite* sprite) +{ + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->callback = AnimFalseSwipeSliceStep3; +} + +static void AnimFalseSwipeSliceStep3(struct Sprite* sprite) +{ + if (++sprite->data[0] > 1) + { + sprite->data[0] = 0; + sprite->invisible = !sprite->invisible; + if (++sprite->data[1] > 8) + DestroyAnimSprite(sprite); + } +} + +void AnimEndureEnergy(struct Sprite* sprite) +{ + if (gBattleAnimArgs[0] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[2]; + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1) + gBattleAnimArgs[2]; + } + + sprite->data[0] = 0; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->callback = AnimEndureEnergyStep; +} + +static void AnimEndureEnergyStep(struct Sprite* sprite) +{ + if (++sprite->data[0] > sprite->data[1]) + { + sprite->data[0] = 0; + sprite->pos1.y--; + } + + sprite->pos1.y -= sprite->data[0]; + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimSharpenSphere(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) - 12; + sprite->data[0] = 0; + sprite->data[1] = 2; + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = 0; + sprite->data[5] = BattleAnimAdjustPanning(-64); + sprite->callback = AnimSharpenSphereStep; +} + +static void AnimSharpenSphereStep(struct Sprite* sprite) +{ + if (++sprite->data[0] >= sprite->data[1]) + { + sprite->invisible = !sprite->invisible; + if (!sprite->invisible) + { + sprite->data[4]++; + if (!(sprite->data[4] & 1)) + PlaySE12WithPanning(SE_W207B, sprite->data[5]); + } + + sprite->data[0] = 0; + if (++sprite->data[2] > 1) + { + sprite->data[2] = 0; + sprite->data[1]++; + } + } + + if (sprite->animEnded && sprite->data[1] > 16 && sprite->invisible) + DestroyAnimSprite(sprite); +} + +void AnimConversion(struct Sprite* sprite) +{ + if (sprite->data[0] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + if (IsContest()) + sprite->pos1.y += 10; + + sprite->data[0]++; + } + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + DestroyAnimSprite(sprite); +} + +void AnimTask_ConversionAlphaBlend(u8 taskId) +{ + if (gTasks[taskId].data[2] == 1) + { + gBattleAnimArgs[7] = 0xFFFF; + gTasks[taskId].data[2]++; + } + else if (gTasks[taskId].data[2] == 2) + { + DestroyAnimVisualTask(taskId); + } + else + { + if (++gTasks[taskId].data[0] == 4) + { + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - gTasks[taskId].data[1], gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 16) + gTasks[taskId].data[2]++; + } + } +} + +void AnimConversion2(struct Sprite* sprite) +{ + InitSpritePosToAnimTarget(sprite, FALSE); + sprite->animPaused = 1; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->callback = AnimConversion2Step; +} + +static void AnimConversion2Step(struct Sprite* sprite) +{ + if (sprite->data[0]) + { + sprite->data[0]--; + } + else + { + sprite->animPaused = 0; + sprite->data[0] = 30; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + } +} + +void AnimTask_Conversion2AlphaBlend(u8 taskId) +{ + if (++gTasks[taskId].data[0] == 4) + { + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 16) + DestroyAnimVisualTask(taskId); + } +} + +void sub_80A5E34(u8 taskId) +{ + u8 i; + for (i = 0; i < gBattlersCount; i++) + { + if (gBattleAnimArgs[0] == 1 && GetBattlerSide(i) == B_SIDE_PLAYER) + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[i]); + + if (gBattleAnimArgs[1] == 1 && GetBattlerSide(i) == B_SIDE_OPPONENT) + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[i]); + } + + DestroyAnimVisualTask(taskId); +} + +void sub_80A5EA8(u8 taskId) +{ + u8 i; + for (i = 0; i < gBattlersCount; i++) + SetHealthboxSpriteVisible(gHealthboxSpriteIds[i]); + + DestroyAnimVisualTask(taskId); +} + +void AnimMoon(struct Sprite* sprite) +{ + if (IsContest()) + { + sprite->pos1.x = 48; + sprite->pos1.y = 40; + } + else + { + sprite->pos1.x = gBattleAnimArgs[0]; + sprite->pos1.y = gBattleAnimArgs[1]; + } + + sprite->oam.shape = 0; + sprite->oam.size = 3; + sprite->data[0] = 0; + sprite->callback = AnimMoonStep; +} + +static void AnimMoonStep(struct Sprite* sprite) +{ + if (sprite->data[0]) + DestroyAnimSprite(sprite); +} + +void AnimMoonlightSparkle(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[0]; + sprite->pos1.y = gBattleAnimArgs[1]; + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = 1; + sprite->callback = AnimMoonlightSparkleStep; +} + +static void AnimMoonlightSparkleStep(struct Sprite* sprite) +{ + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + if (sprite->data[2] < 120) + { + sprite->pos1.y++; + sprite->data[2]++; + } + } + + if (sprite->data[0]) + DestroyAnimSprite(sprite); +} + +void AnimTask_FadeScreenBlueStep(u8); + + +void AnimTask_FadeScreenBlue(u8 taskId) +{ + int a = sub_80A75AC(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; + int b; + int c; + int d; + + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[3] = a; + gTasks[taskId].data[4] = 0; + gTasks[taskId].data[5] = 0; + gTasks[taskId].data[6] = 0; + gTasks[taskId].data[7] = 13; + gTasks[taskId].data[8] = 14; + gTasks[taskId].data[9] = 15; + b = sub_80A76C4(1, 1, 1, 1); + c = a | b; + StorePointerInVars(&gTasks[taskId].data[14], &gTasks[taskId].data[15], (void*)c); + b = b | (0x10000 << IndexOfSpritePaletteTag(ANIM_TAG_MOON)); + d = IndexOfSpritePaletteTag(ANIM_TAG_GREEN_SPARKLE); + BeginNormalPaletteFade((0x10000 << d) | b, 0, 0, 16, RGB(27, 29, 31)); + gTasks[taskId].func = AnimTask_FadeScreenBlueStep; + gTasks[taskId].func(taskId); +} + +void AnimTask_FadeScreenBlueStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[0]) + { + case 0: + if (++task->data[1] > 0) + { + u16 color; + u16 bitmask; + u16 r3; + u16 i; + u16 j; + task->data[1] = 0; + if (++task->data[2] <= 15) + { + u16 red; + u16 green; + u16 blue; + task->data[4] += task->data[7]; + task->data[5] += task->data[8]; + task->data[6] += task->data[9]; + red = task->data[4] >> 3; + green = task->data[5] >> 3; + blue = task->data[6] >> 3; + color = RGB(red, green, blue); + } + else + { + color = RGB(27, 29, 31); + task->data[0]++; + } + + bitmask = 1; + r3 = 0; + for (i = 0; i <= 15; i++) + { + if (task->data[3] & bitmask) + { + for (j = 1; j <= 15; j++) + { + gPlttBufferFaded[r3 + j] = color; + } + } + + bitmask <<= 1; + r3 += 16; + } + } + break; + case 1: + if (!gPaletteFade.active) + { + u8 spriteId; + for (spriteId = 0; spriteId < MAX_SPRITES; spriteId++) + { + if (gSprites[spriteId].template == &gMoonSpriteTemplate || gSprites[spriteId].template == &gMoonlightSparkleSpriteTemplate) + gSprites[spriteId].data[0] = 1; + } + + task->data[1] = 0; + task->data[0]++; + } + break; + case 2: + if (++task->data[1] > 30) + { + BeginNormalPaletteFade((u32)LoadPointerFromVars(task->data[14], task->data[15]), 0, 16, 0, RGB(27, 29, 31)); + task->data[0]++; + } + break; + case 3: + if (!gPaletteFade.active) + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimHornHit(struct Sprite* sprite) +{ + if (gBattleAnimArgs[2] < 2) + gBattleAnimArgs[2] = 2; + + if (gBattleAnimArgs[2] > 0x7F) + gBattleAnimArgs[2] = 0x7F; + + sprite->data[0] = 0; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[1]; + sprite->data[6] = sprite->pos1.x; + sprite->data[7] = sprite->pos1.y; + if (IsContest()) + { + sprite->oam.matrixNum = ST_OAM_HFLIP; + sprite->pos1.x += 40; + sprite->pos1.y += 20; + sprite->data[2] = sprite->pos1.x << 7; + sprite->data[3] = -0x1400 / sprite->data[1]; + sprite->data[4] = sprite->pos1.y << 7; + sprite->data[5] = -0xA00 / sprite->data[1]; + } + else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x -= 40; + sprite->pos1.y += 20; + sprite->data[2] = sprite->pos1.x << 7; + sprite->data[3] = 0x1400 / sprite->data[1]; + sprite->data[4] = sprite->pos1.y << 7; + sprite->data[5] = -0xA00 / sprite->data[1]; + } + else + { + sprite->pos1.x += 40; + sprite->pos1.y -= 20; + sprite->data[2] = sprite->pos1.x << 7; + sprite->data[3] = -0x1400 / sprite->data[1]; + sprite->data[4] = sprite->pos1.y << 7; + sprite->data[5] = 0xA00 / sprite->data[1]; + sprite->oam.matrixNum = (ST_OAM_HFLIP | ST_OAM_VFLIP); + } + + sprite->callback = AnimHornHitStep; +} + +static void AnimHornHitStep(struct Sprite* sprite) +{ + sprite->data[2] += sprite->data[3]; + sprite->data[4] += sprite->data[5]; + sprite->pos1.x = sprite->data[2] >> 7; + sprite->pos1.y = sprite->data[4] >> 7; + if (--sprite->data[1] == 1) + { + sprite->pos1.x = sprite->data[6]; + sprite->pos1.y = sprite->data[7]; + } + + if (sprite->data[1] == 0) + DestroyAnimSprite(sprite); +} + +void AnimTask_DoubleTeam(u8 taskId) +{ + u16 i; + int obj; + u16 r3; + u16 r4; + struct Task* task = &gTasks[taskId]; + task->data[0] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[1] = AllocSpritePalette(ANIM_TAG_BENT_SPOON); + r3 = (task->data[1] * 16) + 0x100; + r4 = (gSprites[task->data[0]].oam.paletteNum + 16) << 4; + for (i = 1; i < 16; i++) + gPlttBufferUnfaded[r3 + i] = gPlttBufferUnfaded[r4 + i]; + + BlendPalette(r3, 16, 11, RGB(0, 0, 0)); + task->data[3] = 0; + i = 0; + while (i < 2 && (obj = CloneBattlerSpriteWithBlend(0)) >= 0) + { + gSprites[obj].oam.paletteNum = task->data[1]; + gSprites[obj].data[0] = 0; + gSprites[obj].data[1] = i << 7; + gSprites[obj].data[2] = taskId; + gSprites[obj].callback = AnimTask_DoubleTeamCallback; + task->data[3]++; + i++; + } + + task->func = AnimTask_DoubleTeamStep; + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG1_ON); + else + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG2_ON); +} + +static void AnimTask_DoubleTeamStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (!task->data[3]) + { + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG1_ON); + else + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG2_ON); + + FreeSpritePaletteByTag(ANIM_TAG_BENT_SPOON); + DestroyAnimVisualTask(taskId); + } +} + +static void AnimTask_DoubleTeamCallback(struct Sprite* sprite) +{ + if (++sprite->data[3] > 1) + { + sprite->data[3] = 0; + sprite->data[0]++; + } + + if (sprite->data[0] > 64) + { + gTasks[sprite->data[2]].data[3]--; + obj_delete_but_dont_free_vram(sprite); + } + else + { + sprite->data[4] = gSineTable[sprite->data[0]] / 6; + sprite->data[5] = gSineTable[sprite->data[0]] / 13; + sprite->data[1] = (sprite->data[1] + sprite->data[5]) & 0xFF; + sprite->pos2.x = Sin(sprite->data[1], sprite->data[4]); + } +} + +void AnimSuperFang(struct Sprite* sprite) +{ + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = RunStoredCallbackWhenAnimEnds; +} + +void AnimTask_MusicNotesRainbowBlend(u8 taskId) +{ + u16 i; + u16 j; + u16 index; + + index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[0][0]); + if (index != 0xFF) + { + index = (index << 4) + 0x100; + for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable[0]); i++) + gPlttBufferFaded[index + i] = gParticlesColorBlendTable[0][i]; + } + + for (j = 1; j < ARRAY_COUNT(gParticlesColorBlendTable); j++) + { + index = AllocSpritePalette(gParticlesColorBlendTable[j][0]); + if (index != 0xFF) + { + index = (index << 4) + 0x100; + for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable[0]); i++) + gPlttBufferFaded[index + i] = gParticlesColorBlendTable[j][i]; + } + } + DestroyAnimVisualTask(taskId); +} + +// clears the rainbow effect for musical notes. +void AnimTask_MusicNotesClearRainbowBlend(u8 taskId) +{ + u16 i; + for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable); i++) + FreeSpritePaletteByTag(gParticlesColorBlendTable[i][0]); + + DestroyAnimVisualTask(taskId); +} + +void AnimWavyMusicNotes(struct Sprite* sprite) +{ + u8 index; + u8 a; + u8 b; + SetSpriteCoordsToAnimAttackerCoords(sprite); + StartSpriteAnim(sprite, gBattleAnimArgs[0]); + if ((index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[gBattleAnimArgs[1]][0])) != 0xFF) + sprite->oam.paletteNum = index; + + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[2] = 0; + sprite->data[3] = gBattleAnimArgs[2]; + if (IsContest()) + { + a = 48; + b = 40; + } + else + { + a = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + b = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + } + + sprite->data[4] = sprite->pos1.x << 4; + sprite->data[5] = sprite->pos1.y << 4; + AnimWavyMusicNotesGetNextPos(a - sprite->pos1.x, b - sprite->pos1.y, &sprite->data[6], &sprite->data[7], 40); + sprite->callback = AnimWavyMusicNotesStep; +} + +static void AnimWavyMusicNotesGetNextPos(s16 a, s16 b, s16* c, s16* d, s8 e) +{ + int f; + int g; + if (a < 0) + e = -e; + + f = a << 8; + g = f / e; + if (g == 0) + g = 1; + + *c = f / g; + *d = (b << 8) / g; +} + +static void AnimWavyMusicNotesStep(struct Sprite* sprite) +{ + s16 y, yDelta; + u8 index; + + sprite->data[0]++; + yDelta = sprite->data[0] * 5 - ((sprite->data[0] * 5 / 256) << 8); + sprite->data[4] += sprite->data[6]; + sprite->data[5] += sprite->data[7]; + sprite->pos1.x = sprite->data[4] >> 4; + sprite->pos1.y = sprite->data[5] >> 4; + sprite->pos2.y = Sin(yDelta, 15); + + y = sprite->pos1.y; + if (sprite->pos1.x < -16 || sprite->pos1.x > 256 || y < -16 || y > 128) + { + DestroySpriteAndMatrix(sprite); + } + else + { + if (sprite->data[3] && ++sprite->data[2] > sprite->data[3]) + { + sprite->data[2] = 0; + if (++sprite->data[1] > 3) + sprite->data[1] = 0; + + index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[sprite->data[1]][0]); + if (index != 0xFF) + sprite->oam.paletteNum = index; + } + } +} + +void AnimFlyingMusicNotes(struct Sprite* sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + gBattleAnimArgs[1] *= -1; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + StartSpriteAnim(sprite, gBattleAnimArgs[0]); + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = sprite->pos1.x << 4; + sprite->data[5] = sprite->pos1.y << 4; + sprite->data[6] = (gBattleAnimArgs[1] << 4) / 5; + sprite->data[7] = (gBattleAnimArgs[2] << 7) / 5; + sprite->callback = AnimFlyingMusicNotesStep; +} + +static void AnimFlyingMusicNotesStep(struct Sprite* sprite) +{ + sprite->data[4] += sprite->data[6]; + sprite->data[5] += sprite->data[7]; + sprite->pos1.x = sprite->data[4] >> 4; + sprite->pos1.y = sprite->data[5] >> 4; + if (sprite->data[0] > 5 && sprite->data[3] == 0) + { + sprite->data[2] = (sprite->data[2] + 16) & 0xFF; + sprite->pos2.x = Cos(sprite->data[2], 18); + sprite->pos2.y = Sin(sprite->data[2], 18); + if (sprite->data[2] == 0) + sprite->data[3] = 1; + } + + if (++sprite->data[0] == 48) + DestroySpriteAndMatrix(sprite); +} + +void AnimBellyDrumHand(struct Sprite* sprite) +{ + s16 a; + if (gBattleAnimArgs[0] == 1) + { + sprite->oam.matrixNum = ST_OAM_HFLIP; + a = 16; + } + else + { + a = -16; + } + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + a; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + 8; + sprite->data[0] = 8; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimSlowFlyingMusicNotes(struct Sprite* sprite) +{ + s16 xDiff; + u8 index; + SetSpriteCoordsToAnimAttackerCoords(sprite); + sprite->pos1.y += 8; + StartSpriteAnim(sprite, gBattleAnimArgs[1]); + index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[gBattleAnimArgs[2]][0]); + if (index != 0xFF) + sprite->oam.paletteNum = index; + + xDiff = (gBattleAnimArgs[0] == 0) ? -32 : 32; + sprite->data[0] = 40; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = xDiff + sprite->data[1]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = sprite->data[3] - 40; + InitAnimLinearTranslation(sprite); + sprite->data[5] = gBattleAnimArgs[3]; + sprite->callback = AnimSlowFlyingMusicNotesStep; +} + +static void AnimSlowFlyingMusicNotesStep(struct Sprite* sprite) +{ + if (AnimTranslateLinear(sprite) == 0) + { + s16 xDiff; + xDiff = Sin(sprite->data[5], 8); + if (sprite->pos2.x < 0) + xDiff = -xDiff; + + sprite->pos2.x += xDiff; + sprite->pos2.y += Sin(sprite->data[5], 4); + sprite->data[5] = (sprite->data[5] + 8) & 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +void SetSpriteNextToMonHead(u8 battler, struct Sprite* sprite) +{ + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_RIGHT) + 8; + else + sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_LEFT) - 8; + + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) - (s16)GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_HEIGHT) / 4; +} + +void AnimThoughtBubble(struct Sprite* sprite) +{ + u8 a; + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + SetSpriteNextToMonHead(battler, sprite); + a = (GetBattlerSide(battler) == B_SIDE_PLAYER) ? 0 : 1; + sprite->data[0] = gBattleAnimArgs[1]; + sprite->data[1] = a + 2; + StartSpriteAnim(sprite, a); + StoreSpriteCallbackInData6(sprite, AnimThoughtBubbleStep); + sprite->callback = RunStoredCallbackWhenAnimEnds; +} + +static void AnimThoughtBubbleStep(struct Sprite* sprite) +{ + if (--sprite->data[0] == 0) + { + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + StartSpriteAnim(sprite, sprite->data[1]); + sprite->callback = RunStoredCallbackWhenAnimEnds; + } +} + +void AnimMetronomeFinger(struct Sprite* sprite) +{ + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + SetSpriteNextToMonHead(battler, sprite); + sprite->data[0] = 0; + StoreSpriteCallbackInData6(sprite, AnimMetronomeFingerStep); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; +} + +static void AnimMetronomeFingerStep(struct Sprite* sprite) +{ + if (++sprite->data[0] > 16) + { + StartSpriteAffineAnim(sprite, 1); + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; + } +} + +void AnimFollowMeFinger(struct Sprite* sprite) +{ + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + sprite->pos1.x = GetBattlerSpriteCoord(battler, 0); + sprite->pos1.y = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_TOP); + if (sprite->pos1.y <= 9) + sprite->pos1.y = 10; + + sprite->data[0] = 1; + sprite->data[1] = 0; + sprite->data[2] = sprite->subpriority; + sprite->data[3] = sprite->subpriority + 4; + sprite->data[4] = 0; + StoreSpriteCallbackInData6(sprite, AnimFollowMeFingerStep1); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; +} + +static void AnimFollowMeFingerStep1(struct Sprite* sprite) +{ + if (++sprite->data[4] > 12) + sprite->callback = AnimFollowMeFingerStep2; +} + +static void AnimFollowMeFingerStep2(struct Sprite* sprite) +{ + s16 x1, x2; + + sprite->data[1] += 4; + if (sprite->data[1] > 254) + { + if (--sprite->data[0] == 0) + { + sprite->pos2.x = 0; + sprite->callback = AnimMetronomeFingerStep; + return; + } + else + { + sprite->data[1] &= 0xFF; + } + } + + if (sprite->data[1] > 0x4F) + sprite->subpriority = sprite->data[3]; + + if (sprite->data[1] > 0x9F) + sprite->subpriority = sprite->data[2]; + + x1 = gSineTable[sprite->data[1]]; + x2 = x1 >> 3; + sprite->pos2.x = (x1 >> 3) + (x2 >> 1); +} + +void AnimTauntFinger(struct Sprite* sprite) +{ + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + SetSpriteNextToMonHead(battler, sprite); + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + { + StartSpriteAnim(sprite, 0); + sprite->data[0] = 2; + } + else + { + StartSpriteAnim(sprite, 1); + sprite->data[0] = 3; + } + + sprite->callback = AnimTauntFingerStep1; +} + +static void AnimTauntFingerStep1(struct Sprite* sprite) +{ + if (++sprite->data[1] > 10) + { + sprite->data[1] = 0; + StartSpriteAnim(sprite, sprite->data[0]); + StoreSpriteCallbackInData6(sprite, AnimTauntFingerStep2); + sprite->callback = RunStoredCallbackWhenAnimEnds; + } +} + +static void AnimTauntFingerStep2(struct Sprite* sprite) +{ + if (++sprite->data[1] > 5) + DestroyAnimSprite(sprite); +} + diff --git a/src/battle_anim_mons.c b/src/battle_anim_mons.c index a3bd26898..bdba7ae3b 100644 --- a/src/battle_anim_mons.c +++ b/src/battle_anim_mons.c @@ -88,7 +88,7 @@ static const struct SpriteTemplate gUnknown_83AE054[] = { .tileTag = 0xD755, .paletteTag = 0xD755, - .oam = &gOamData_83ACA40, + .oam = &gOamData_AffineNormal_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -97,7 +97,7 @@ static const struct SpriteTemplate gUnknown_83AE054[] = { .tileTag = 0xD756, .paletteTag = 0xD756, - .oam = &gOamData_83ACA40, + .oam = &gOamData_AffineNormal_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/bug.c b/src/bug.c index b9f1795ab..e3bcb68ab 100644 --- a/src/bug.c +++ b/src/bug.c @@ -46,7 +46,7 @@ const struct SpriteTemplate gUnknown_83E7224 = { .tileTag = ANIM_TAG_HORN_HIT_2, .paletteTag = ANIM_TAG_HORN_HIT_2, - .oam = &gOamData_83ACAB8, + .oam = &gOamData_AffineDouble_ObjNormal_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7218, @@ -82,7 +82,7 @@ const struct SpriteTemplate gUnknown_83E7278 = { .tileTag = ANIM_TAG_NEEDLE, .paletteTag = ANIM_TAG_NEEDLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E726C, @@ -93,7 +93,7 @@ const struct SpriteTemplate gWebThreadSpriteTemplate = { .tileTag = ANIM_TAG_WEB_THREAD, .paletteTag = ANIM_TAG_WEB_THREAD, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -104,7 +104,7 @@ const struct SpriteTemplate gUnknown_83E72A8 = { .tileTag = ANIM_TAG_STRING, .paletteTag = ANIM_TAG_STRING, - .oam = &gOamData_83ACA00, + .oam = &gOamData_AffineOff_ObjNormal_64x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -127,7 +127,7 @@ const struct SpriteTemplate gSpiderWebSpriteTemplate = { .tileTag = ANIM_TAG_SPIDER_WEB, .paletteTag = ANIM_TAG_SPIDER_WEB, - .oam = &gOamData_83ACBC0, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E72D8, @@ -138,7 +138,7 @@ const struct SpriteTemplate gLinearStingerSpriteTemplate = { .tileTag = ANIM_TAG_NEEDLE, .paletteTag = ANIM_TAG_NEEDLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -149,7 +149,7 @@ const struct SpriteTemplate gPinMissileSpriteTemplate = { .tileTag = ANIM_TAG_NEEDLE, .paletteTag = ANIM_TAG_NEEDLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -160,7 +160,7 @@ const struct SpriteTemplate gIcicleSpearSpriteTemplate = { .tileTag = ANIM_TAG_ICICLE_SPEAR, .paletteTag = ANIM_TAG_ICICLE_SPEAR, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -187,7 +187,7 @@ const struct SpriteTemplate gUnknown_83E7378 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7374, diff --git a/src/dark.c b/src/dark.c index 368f5cbd5..e13227316 100644 --- a/src/dark.c +++ b/src/dark.c @@ -27,7 +27,7 @@ const struct SpriteTemplate gUnknown_83E7878 = { .tileTag = ANIM_TAG_TIED_BAG, .paletteTag = ANIM_TAG_TIED_BAG, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -98,7 +98,7 @@ const struct SpriteTemplate gUnknown_83E7930 = { .tileTag = ANIM_TAG_SHARP_TEETH, .paletteTag = ANIM_TAG_SHARP_TEETH, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7910, @@ -109,7 +109,7 @@ const struct SpriteTemplate gUnknown_83E7948 = { .tileTag = ANIM_TAG_CLAMP, .paletteTag = ANIM_TAG_CLAMP, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7910, @@ -140,7 +140,7 @@ const struct SpriteTemplate gUnknown_83E7998 = { .tileTag = ANIM_TAG_SMALL_BUBBLES, .paletteTag = ANIM_TAG_SMALL_BUBBLES, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7990, @@ -177,7 +177,7 @@ const struct SpriteTemplate gUnknown_83E79E8 = { .tileTag = ANIM_TAG_CLAW_SLASH, .paletteTag = ANIM_TAG_CLAW_SLASH, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E79E0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/dragon.c b/src/dragon.c index 34f97ba74..d18cf25df 100644 --- a/src/dragon.c +++ b/src/dragon.c @@ -35,7 +35,7 @@ const struct SpriteTemplate gUnknown_83E772C = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E7728, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -88,7 +88,7 @@ const struct SpriteTemplate gUnknown_83E77A4 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E7764, .images = NULL, .affineAnims = gUnknown_83E779C, @@ -114,7 +114,7 @@ const struct SpriteTemplate gUnknown_83E77D8 = { .tileTag = ANIM_TAG_FIRE_PLUME, .paletteTag = ANIM_TAG_FIRE_PLUME, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E77D4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -157,7 +157,7 @@ const struct SpriteTemplate gUnknown_83E7830 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E7800, .images = NULL, .affineAnims = gUnknown_83E7828, @@ -168,7 +168,7 @@ const struct SpriteTemplate gUnknown_83E7848 = { .tileTag = ANIM_TAG_HOLLOW_ORB, .paletteTag = ANIM_TAG_HOLLOW_ORB, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -179,7 +179,7 @@ const struct SpriteTemplate gUnknown_83E7860 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E7728, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/electric.c b/src/electric.c index 025eac48b..908ce60a4 100644 --- a/src/electric.c +++ b/src/electric.c @@ -53,7 +53,7 @@ const struct SpriteTemplate gUnknown_83E5F38 = { .tileTag = ANIM_TAG_LIGHTNING, .paletteTag = ANIM_TAG_LIGHTNING, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5F34, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -77,7 +77,7 @@ const struct SpriteTemplate gUnknown_83E5F74 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E5F70, @@ -104,7 +104,7 @@ const struct SpriteTemplate gUnknown_83E5FAC = { .tileTag = ANIM_TAG_SHOCK, .paletteTag = ANIM_TAG_SHOCK, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5FA8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -115,7 +115,7 @@ const struct SpriteTemplate gUnknown_83E5FC4 = { .tileTag = ANIM_TAG_SPARK_2, .paletteTag = ANIM_TAG_SPARK_2, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -126,7 +126,7 @@ const struct SpriteTemplate gUnknown_83E5FDC = { .tileTag = ANIM_TAG_BLACK_BALL_2, .paletteTag = ANIM_TAG_BLACK_BALL_2, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -148,7 +148,7 @@ const struct SpriteTemplate gUnknown_83E6008 = { .tileTag = ANIM_TAG_SPARK_2, .paletteTag = ANIM_TAG_SPARK_2, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6004, @@ -185,7 +185,7 @@ const struct SpriteTemplate gUnknown_83E6058 = { .tileTag = ANIM_TAG_SHOCK_3, .paletteTag = ANIM_TAG_SHOCK_3, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E6030, .images = NULL, .affineAnims = gUnknown_83E6054, @@ -196,7 +196,7 @@ const struct SpriteTemplate gUnknown_83E6070 = { .tileTag = ANIM_TAG_SPARK_2, .paletteTag = ANIM_TAG_SPARK_2, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6004, @@ -207,7 +207,7 @@ const struct SpriteTemplate gElectricitySpriteTemplate = { .tileTag = ANIM_TAG_SPARK_2, .paletteTag = ANIM_TAG_SPARK_2, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -218,7 +218,7 @@ static const struct SpriteTemplate gUnknown_83E60A0 = { .tileTag = ANIM_TAG_SPARK, .paletteTag = ANIM_TAG_SPARK, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -229,7 +229,7 @@ const struct SpriteTemplate gUnknown_83E60B8 = { .tileTag = ANIM_TAG_SPARK_H, .paletteTag = ANIM_TAG_SPARK_H, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -284,7 +284,7 @@ static const struct SpriteTemplate gUnknown_83E6120 = { .tileTag = ANIM_TAG_ELECTRIC_ORBS, .paletteTag = ANIM_TAG_ELECTRIC_ORBS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gUnknown_83E6118, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -332,7 +332,7 @@ const struct SpriteTemplate gUnknown_83E61D4 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E61C8, @@ -357,7 +357,7 @@ const struct SpriteTemplate gUnknown_83E6204 = { .tileTag = ANIM_TAG_ELECTRICITY, .paletteTag = ANIM_TAG_ELECTRICITY, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E6200, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -368,7 +368,7 @@ const struct SpriteTemplate gUnknown_83E621C = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E61C8, @@ -422,7 +422,7 @@ static const struct SpriteTemplate gUnknown_83E6278 = { .tileTag = ANIM_TAG_SPARK, .paletteTag = ANIM_TAG_SPARK, - .oam = &gOamData_83ACAC8, + .oam = &gOamData_AffineDouble_ObjNormal_8x16, .anims = gUnknown_83E6254, .images = NULL, .affineAnims = gUnknown_83E6274, @@ -433,7 +433,7 @@ const struct SpriteTemplate gUnknown_83E6290 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E61C8, @@ -444,7 +444,7 @@ static const struct SpriteTemplate gUnknown_83E62A8 = { .tileTag = ANIM_TAG_SPARK, .paletteTag = ANIM_TAG_SPARK, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/fighting.c b/src/fighting.c index 496f752ef..7b826594d 100644 --- a/src/fighting.c +++ b/src/fighting.c @@ -39,7 +39,7 @@ const struct SpriteTemplate gUnknown_83E668C = { .tileTag = ANIM_TAG_HUMANOID_FOOT, .paletteTag = ANIM_TAG_HUMANOID_FOOT, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -97,7 +97,7 @@ const struct SpriteTemplate gUnknown_83E66E0 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -108,7 +108,7 @@ const struct SpriteTemplate gUnknown_83E66F8 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -119,7 +119,7 @@ const struct SpriteTemplate gFistFootSpriteTemplate = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -130,7 +130,7 @@ const struct SpriteTemplate gUnknown_83E6728 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -141,7 +141,7 @@ const struct SpriteTemplate gUnknown_83E6740 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66D8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -152,7 +152,7 @@ const struct SpriteTemplate gUnknown_83E6758 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66D0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -175,7 +175,7 @@ const struct SpriteTemplate gUnknown_83E678C = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gUnknown_83E6788, @@ -198,7 +198,7 @@ const struct SpriteTemplate gMegaPunchKickSpriteTemplate = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gUnknown_83E67BC, @@ -209,7 +209,7 @@ const struct SpriteTemplate gUnknown_83E67D8 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66D0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -220,7 +220,7 @@ const struct SpriteTemplate gUnknown_83E67F0 = { .tileTag = ANIM_TAG_DUCK, .paletteTag = ANIM_TAG_DUCK, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -231,7 +231,7 @@ const struct SpriteTemplate gUnknown_83E6808 = { .tileTag = ANIM_TAG_BLUE_LIGHT_WALL, .paletteTag = ANIM_TAG_BLUE_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -242,7 +242,7 @@ const struct SpriteTemplate gUnknown_83E6820 = { .tileTag = ANIM_TAG_TORN_METAL, .paletteTag = ANIM_TAG_TORN_METAL, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -267,7 +267,7 @@ const struct SpriteTemplate gUnknown_83E6864 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACBC0, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6860, @@ -278,7 +278,7 @@ const struct SpriteTemplate gUnknown_83E687C = { .tileTag = ANIM_TAG_FLAT_ROCK, .paletteTag = ANIM_TAG_FLAT_ROCK, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -289,7 +289,7 @@ const struct SpriteTemplate gUnknown_83E6894 = { .tileTag = ANIM_TAG_METEOR, .paletteTag = ANIM_TAG_METEOR, - .oam = &gOamData_83AC9E0, + .oam = &gOamData_AffineOff_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -300,7 +300,7 @@ const struct SpriteTemplate gUnknown_83E68AC = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -342,7 +342,7 @@ const struct SpriteTemplate gUnknown_83E6900 = { .tileTag = ANIM_TAG_PURPLE_SCRATCH, .paletteTag = ANIM_TAG_PURPLE_SCRATCH, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E68F4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -381,7 +381,7 @@ const struct SpriteTemplate gUnknown_83E6948 = { .tileTag = ANIM_TAG_PURPLE_SWIPE, .paletteTag = ANIM_TAG_PURPLE_SWIPE, - .oam = &gOamData_83AC9E0, + .oam = &gOamData_AffineOff_ObjNormal_64x64, .anims = gUnknown_83E693C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -404,7 +404,7 @@ const struct SpriteTemplate gUnknown_83E697C = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gUnknown_83E6978, diff --git a/src/fire.c b/src/fire.c index 014413f5b..a5a2ee5f6 100644 --- a/src/fire.c +++ b/src/fire.c @@ -64,7 +64,7 @@ const struct SpriteTemplate gUnknown_83E5BE0 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5BD8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -75,7 +75,7 @@ const struct SpriteTemplate gUnknown_83E5BF8 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5BD8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -131,7 +131,7 @@ const struct SpriteTemplate gUnknown_83E5C70 = { .tileTag = ANIM_TAG_FIRE, .paletteTag = ANIM_TAG_FIRE, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E5C34, .images = NULL, .affineAnims = gUnknown_83E5C6C, @@ -142,7 +142,7 @@ const struct SpriteTemplate gUnknown_83E5C88 = { .tileTag = ANIM_TAG_FIRE, .paletteTag = ANIM_TAG_FIRE, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5C34, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -153,7 +153,7 @@ const struct SpriteTemplate gUnknown_83E5CA0 = { .tileTag = ANIM_TAG_FIRE_PLUME, .paletteTag = ANIM_TAG_FIRE_PLUME, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5C50, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -164,7 +164,7 @@ const struct SpriteTemplate gUnknown_83E5CB8 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5C50, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -188,7 +188,7 @@ const struct SpriteTemplate gUnknown_83E5CE4 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5CE0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -211,7 +211,7 @@ const struct SpriteTemplate gUnknown_83E5D18 = { .tileTag = ANIM_TAG_SUNLIGHT, .paletteTag = ANIM_TAG_SUNLIGHT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E5D14, @@ -237,7 +237,7 @@ const struct SpriteTemplate gEmberSpriteTemplate = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -248,7 +248,7 @@ const struct SpriteTemplate gEmberFlareSpriteTemplate = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -259,7 +259,7 @@ const struct SpriteTemplate gUnknown_83E5D7C = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -270,7 +270,7 @@ const struct SpriteTemplate gUnknown_83E5D94 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -311,7 +311,7 @@ const struct SpriteTemplate gUnknown_83E5DE4 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5DB8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -322,7 +322,7 @@ const struct SpriteTemplate gUnknown_83E5DFC = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -333,7 +333,7 @@ const struct SpriteTemplate gUnknown_83E5E14 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -344,7 +344,7 @@ static const struct SpriteTemplate gUnknown_83E5E2C = { .tileTag = ANIM_TAG_WARM_ROCK, .paletteTag = ANIM_TAG_WARM_ROCK, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -366,7 +366,7 @@ const struct SpriteTemplate gUnknown_83E5E60 = { .tileTag = ANIM_TAG_WARM_ROCK, .paletteTag = ANIM_TAG_WARM_ROCK, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -412,7 +412,7 @@ const struct SpriteTemplate gUnknown_83E5EB4 = { .tileTag = ANIM_TAG_WISP_ORB, .paletteTag = ANIM_TAG_WISP_ORB, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E5EA4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -437,7 +437,7 @@ const struct SpriteTemplate gUnknown_83E5EE4 = { .tileTag = ANIM_TAG_WISP_FIRE, .paletteTag = ANIM_TAG_WISP_FIRE, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5EE0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/flying.c b/src/flying.c index 59378c2f1..6d4a1eb56 100644 --- a/src/flying.c +++ b/src/flying.c @@ -39,7 +39,7 @@ const struct SpriteTemplate gUnknown_83E6AE8 = { .tileTag = ANIM_TAG_GUST, .paletteTag = ANIM_TAG_GUST, - .oam = &gOamData_83ACA20, + .oam = &gOamData_AffineOff_ObjNormal_32x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -62,7 +62,7 @@ const struct SpriteTemplate gUnknown_83E6B1C = { .tileTag = ANIM_TAG_GUST, .paletteTag = ANIM_TAG_GUST, - .oam = &gOamData_83ACA80, + .oam = &gOamData_AffineNormal_ObjNormal_32x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6B18, @@ -87,7 +87,7 @@ const struct SpriteTemplate gUnknown_83E6B4C = { .tileTag = ANIM_TAG_AIR_WAVE_2, .paletteTag = ANIM_TAG_AIR_WAVE_2, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gUnknown_83E6B48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -130,7 +130,7 @@ const struct SpriteTemplate gUnknown_83E6BB8 = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6B8C, @@ -141,7 +141,7 @@ const struct SpriteTemplate gUnknown_83E6BD0 = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACA40, + .oam = &gOamData_AffineNormal_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6BB0, @@ -170,7 +170,7 @@ const struct SpriteTemplate gUnknown_83E6C00 = { .tileTag = ANIM_TAG_WHITE_FEATHER, .paletteTag = ANIM_TAG_WHITE_FEATHER, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E6BF8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -184,7 +184,7 @@ const struct SpriteTemplate gUnknown_83E6C38 = { .tileTag = ANIM_TAG_SMALL_BUBBLES, .paletteTag = ANIM_TAG_SMALL_BUBBLES, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -195,7 +195,7 @@ const struct SpriteTemplate gUnknown_83E6C50 = { .tileTag = ANIM_TAG_WHITE_FEATHER, .paletteTag = ANIM_TAG_WHITE_FEATHER, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E6BF8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -221,7 +221,7 @@ const struct SpriteTemplate gUnknown_83E6C84 = { .tileTag = ANIM_TAG_WHIRLWIND_LINES, .paletteTag = ANIM_TAG_WHIRLWIND_LINES, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gUnknown_83E6C80, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -247,7 +247,7 @@ const struct SpriteTemplate gUnknown_83E6CD0 = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6CCC, @@ -269,7 +269,7 @@ const struct SpriteTemplate gUnknown_83E6CFC = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6CF8, @@ -294,7 +294,7 @@ const struct SpriteTemplate gUnknown_83E6D40 = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6D3C, @@ -320,7 +320,7 @@ const struct SpriteTemplate gUnknown_83E6D7C = { .tileTag = ANIM_TAG_SPLASH, .paletteTag = ANIM_TAG_SPLASH, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -331,7 +331,7 @@ const struct SpriteTemplate gUnknown_83E6D94 = { .tileTag = ANIM_TAG_SWEAT_BEAD, .paletteTag = ANIM_TAG_SWEAT_BEAD, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -342,7 +342,7 @@ const struct SpriteTemplate gUnknown_83E6DAC = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -353,7 +353,7 @@ const struct SpriteTemplate gUnknown_83E6DB4 = { .tileTag = ANIM_TAG_BIRD, .paletteTag = ANIM_TAG_BIRD, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/ghost.c b/src/ghost.c index 30430309e..643cc3b0d 100644 --- a/src/ghost.c +++ b/src/ghost.c @@ -63,7 +63,7 @@ const struct SpriteTemplate gUnknown_83E75C4 = { .tileTag = ANIM_TAG_YELLOW_BALL, .paletteTag = ANIM_TAG_YELLOW_BALL, - .oam = &gOamData_83ACA90, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E75C0, @@ -74,7 +74,7 @@ const struct SpriteTemplate gUnknown_83E75DC = { .tileTag = ANIM_TAG_YELLOW_BALL, .paletteTag = ANIM_TAG_YELLOW_BALL, - .oam = &gOamData_83ACAF0, + .oam = &gOamData_AffineOff_ObjBlend_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -96,7 +96,7 @@ const struct SpriteTemplate gShadowBallSpriteTemplate = { .tileTag = ANIM_TAG_SHADOW_BALL, .paletteTag = ANIM_TAG_SHADOW_BALL, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7604, @@ -122,7 +122,7 @@ const struct SpriteTemplate gUnknown_83E763C = { .tileTag = ANIM_TAG_LICK, .paletteTag = ANIM_TAG_LICK, - .oam = &gOamData_83ACA18, + .oam = &gOamData_AffineOff_ObjNormal_16x32, .anims = gUnknown_83E7638, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -146,7 +146,7 @@ const struct SpriteTemplate gUnknown_83E7668 = { .tileTag = ANIM_TAG_WHITE_SHADOW, .paletteTag = ANIM_TAG_WHITE_SHADOW, - .oam = &gOamData_83ACB20, + .oam = &gOamData_AffineOff_ObjBlend_64x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -157,7 +157,7 @@ const struct SpriteTemplate gUnknown_83E7680 = { .tileTag = ANIM_TAG_NAIL, .paletteTag = ANIM_TAG_NAIL, - .oam = &gOamData_83ACB18, + .oam = &gOamData_AffineOff_ObjBlend_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -168,7 +168,7 @@ const struct SpriteTemplate gUnknown_83E7698 = { .tileTag = ANIM_TAG_GHOSTLY_SPIRIT, .paletteTag = ANIM_TAG_GHOSTLY_SPIRIT, - .oam = &gOamData_83ACAF8, + .oam = &gOamData_AffineOff_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -179,7 +179,7 @@ const struct SpriteTemplate gUnknown_83E76B0 = { .tileTag = ANIM_TAG_DEVIL, .paletteTag = ANIM_TAG_DEVIL, - .oam = &gOamData_83ACAF8, + .oam = &gOamData_AffineOff_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -204,7 +204,7 @@ const struct SpriteTemplate gUnknown_83E76E0 = { .tileTag = ANIM_TAG_PURPLE_FLAME, .paletteTag = ANIM_TAG_PURPLE_FLAME, - .oam = &gOamData_83ACB38, + .oam = &gOamData_AffineOff_ObjBlend_16x32, .anims = gUnknown_83E76DC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/ground.c b/src/ground.c index 7ab6b6e95..423671112 100644 --- a/src/ground.c +++ b/src/ground.c @@ -52,7 +52,7 @@ const struct SpriteTemplate gUnknown_83E7A28 = { .tileTag = ANIM_TAG_BONE, .paletteTag = ANIM_TAG_BONE, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7A20, @@ -63,7 +63,7 @@ const struct SpriteTemplate gUnknown_83E7A40 = { .tileTag = ANIM_TAG_BONE, .paletteTag = ANIM_TAG_BONE, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7A24, @@ -74,7 +74,7 @@ const struct SpriteTemplate gUnknown_83E7A58 = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -96,7 +96,7 @@ const struct SpriteTemplate gUnknown_83E7A7C = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E7A78, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -107,7 +107,7 @@ const struct SpriteTemplate gUnknown_83E7A94 = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -118,7 +118,7 @@ const struct SpriteTemplate gUnknown_83E7AAC = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -129,7 +129,7 @@ const struct SpriteTemplate gUnknown_83E7AC4 = { .tileTag = ANIM_TAG_DIRT_MOUND, .paletteTag = ANIM_TAG_DIRT_MOUND, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/ice.c b/src/ice.c index 79966e597..4ed6e0ece 100644 --- a/src/ice.c +++ b/src/ice.c @@ -66,7 +66,7 @@ static const struct SpriteTemplate gUnknown_83E62D0 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -155,7 +155,7 @@ const struct SpriteTemplate gUnknown_83E6348 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACBE8, + .oam = &gOamData_AffineDouble_ObjBlend_8x16, .anims = gUnknown_83E6320, .images = NULL, .affineAnims = gUnknown_83E6344, @@ -166,7 +166,7 @@ const struct SpriteTemplate gUnknown_83E6360 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACAE8, + .oam = &gOamData_AffineOff_ObjBlend_8x8, .anims = gUnknown_83E6324, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -188,7 +188,7 @@ const struct SpriteTemplate gUnknown_83E638C = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACB88, + .oam = &gOamData_AffineNormal_ObjBlend_8x16, .anims = gUnknown_83E6320, .images = NULL, .affineAnims = gUnknown_83E6388, @@ -199,7 +199,7 @@ const struct SpriteTemplate gUnknown_83E63A4 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACAE8, + .oam = &gOamData_AffineOff_ObjBlend_8x8, .anims = gUnknown_83E6324, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -223,7 +223,7 @@ const struct SpriteTemplate gUnknown_83E63E0 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACB88, + .oam = &gOamData_AffineNormal_ObjBlend_8x16, .anims = gUnknown_83E6320, .images = NULL, .affineAnims = gUnknown_83E63DC, @@ -234,7 +234,7 @@ const struct SpriteTemplate gUnknown_83E63F8 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACB48, + .oam = &gOamData_AffineNormal_ObjBlend_8x8, .anims = gUnknown_83E6324, .images = NULL, .affineAnims = gUnknown_83E63DC, @@ -245,7 +245,7 @@ const struct SpriteTemplate gUnknown_83E6410 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gUnknown_83E6328, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -256,7 +256,7 @@ const struct SpriteTemplate gUnknown_83E6428 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E632C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -267,7 +267,7 @@ const struct SpriteTemplate gUnknown_83E6440 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gUnknown_83E6328, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -295,7 +295,7 @@ const struct SpriteTemplate gUnknown_83E647C = { .tileTag = ANIM_TAG_ICE_SPIKES, .paletteTag = ANIM_TAG_ICE_SPIKES, - .oam = &gOamData_83ACB28, + .oam = &gOamData_AffineOff_ObjBlend_8x16, .anims = gUnknown_83E6478, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -318,7 +318,7 @@ const struct SpriteTemplate gUnknown_83E64A4 = { .tileTag = ANIM_TAG_MIST_CLOUD, .paletteTag = ANIM_TAG_MIST_CLOUD, - .oam = &gOamData_83ACB18, + .oam = &gOamData_AffineOff_ObjBlend_32x16, .anims = gUnknown_83E64A0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -329,7 +329,7 @@ const struct SpriteTemplate gUnknown_83E64BC = { .tileTag = ANIM_TAG_PURPLE_GAS_CLOUD, .paletteTag = ANIM_TAG_PURPLE_GAS_CLOUD, - .oam = &gOamData_83ACB18, + .oam = &gOamData_AffineOff_ObjBlend_32x16, .anims = gUnknown_83E64A0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -345,7 +345,7 @@ const struct SpriteTemplate gUnknown_83E64E8 = { .tileTag = ANIM_TAG_SMALL_BUBBLES, .paletteTag = ANIM_TAG_SMALL_BUBBLES, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -361,7 +361,7 @@ const struct SpriteTemplate gUnknown_83E6514 = { .tileTag = ANIM_TAG_PURPLE_GAS_CLOUD, .paletteTag = ANIM_TAG_PURPLE_GAS_CLOUD, - .oam = &gOamData_83ACB18, + .oam = &gOamData_AffineOff_ObjBlend_32x16, .anims = gUnknown_83E64A0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -422,7 +422,7 @@ static const struct SpriteTemplate gUnknown_83E65A4 = { .tileTag = ANIM_TAG_HAIL, .paletteTag = ANIM_TAG_HAIL, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6594, @@ -433,7 +433,7 @@ const struct SpriteTemplate gUnknown_83E65BC = { .tileTag = ANIM_TAG_HAIL, .paletteTag = ANIM_TAG_HAIL, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E65A0, @@ -504,7 +504,7 @@ const struct SpriteTemplate gUnknown_83E665C = { .tileTag = ANIM_TAG_ICE_CHUNK, .paletteTag = ANIM_TAG_ICE_CHUNK, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E65F0, .images = NULL, .affineAnims = gUnknown_83E6648, @@ -515,7 +515,7 @@ const struct SpriteTemplate gUnknown_83E6674 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gUnknown_83E6324, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/mevent_8145654.c b/src/mevent_8145654.c index 44a40c6ec..a35e9e9f8 100644 --- a/src/mevent_8145654.c +++ b/src/mevent_8145654.c @@ -59,7 +59,7 @@ void sub_8145D18(u8 whichWindow); void sub_8146060(void); void sub_81461D8(void); -extern const struct OamData gOamData_83AC9F8; +extern const struct OamData gOamData_AffineOff_ObjNormal_32x16; const u8 gUnknown_8467068[][3] = { {0, 2, 3}, @@ -114,7 +114,7 @@ const struct SpritePalette gUnknown_8467F60[] = { {gUnknown_8467ED4, 0x8000} }; const struct SpriteTemplate gUnknown_8467FA0 = { - 0x8000, 0x8000, &gOamData_83AC9F8, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy + 0x8000, 0x8000, &gOamData_AffineOff_ObjNormal_32x16, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }; const struct UnkStruct_8467FB8 gUnknown_8467FB8[8] = { {1, 0, 0, 0, gUnknown_846718C, gUnknown_8467288, gUnknown_846708C}, diff --git a/src/normal.c b/src/normal.c index 4d86b55a6..4e045340f 100644 --- a/src/normal.c +++ b/src/normal.c @@ -63,7 +63,7 @@ const struct SpriteTemplate gConfusionDuckSpriteTemplate = { .tileTag = ANIM_TAG_DUCK, .paletteTag = ANIM_TAG_DUCK, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E7B04, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -111,7 +111,7 @@ const struct SpriteTemplate gUnknown_83E7B70 = { .tileTag = ANIM_TAG_SPARKLE_4, .paletteTag = ANIM_TAG_SPARKLE_4, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E7B6C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -168,7 +168,7 @@ const struct SpriteTemplate gBasicHitSplatSpriteTemplate = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -179,7 +179,7 @@ const struct SpriteTemplate gUnknown_83E7C20 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -190,7 +190,7 @@ const struct SpriteTemplate gUnknown_83E7C38 = { .tileTag = ANIM_TAG_WATER_IMPACT, .paletteTag = ANIM_TAG_WATER_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -201,7 +201,7 @@ const struct SpriteTemplate gUnknown_83E7C50 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -212,7 +212,7 @@ const struct SpriteTemplate gUnknown_83E7C68 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -223,7 +223,7 @@ const struct SpriteTemplate gUnknown_83E7C80 = { .tileTag = ANIM_TAG_CROSS_IMPACT, .paletteTag = ANIM_TAG_CROSS_IMPACT, - .oam = &gOamData_83ACAF8, + .oam = &gOamData_AffineOff_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -234,7 +234,7 @@ const struct SpriteTemplate gUnknown_83E7C98 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -245,7 +245,7 @@ const struct SpriteTemplate gUnknown_83E7CB0 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, diff --git a/src/oak_speech.c b/src/oak_speech.c index 3f946e13f..79f8b18c7 100644 --- a/src/oak_speech.c +++ b/src/oak_speech.c @@ -328,12 +328,12 @@ static const union AnimCmd *const sGrassPlatformAnims3[] = { sGrassPlatformAnim3 }; -extern const struct OamData gOamData_83ACAF8; +extern const struct OamData gOamData_AffineOff_ObjBlend_32x32; static const struct SpriteTemplate sOakSpeech_GrassPlatformSpriteTemplates[3] = { - { 0x1000, 0x1000, &gOamData_83ACAF8, sGrassPlatformAnims1, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, - { 0x1000, 0x1000, &gOamData_83ACAF8, sGrassPlatformAnims2, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, - { 0x1000, 0x1000, &gOamData_83ACAF8, sGrassPlatformAnims3, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1000, 0x1000, &gOamData_AffineOff_ObjBlend_32x32, sGrassPlatformAnims1, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1000, 0x1000, &gOamData_AffineOff_ObjBlend_32x32, sGrassPlatformAnims2, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1000, 0x1000, &gOamData_AffineOff_ObjBlend_32x32, sGrassPlatformAnims3, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, }; static const union AnimCmd sPikaAnim1[] = { @@ -389,14 +389,14 @@ static const union AnimCmd *const sPikaAnims3[] = { sPikaAnim3 }; -extern const struct OamData gOamData_83AC9D8; -extern const struct OamData gOamData_83AC9F8; -extern const struct OamData gOamData_83AC9E8; +extern const struct OamData gOamData_AffineOff_ObjNormal_32x32; +extern const struct OamData gOamData_AffineOff_ObjNormal_32x16; +extern const struct OamData gOamData_AffineOff_ObjNormal_16x8; static const struct SpriteTemplate sOakSpeech_PikaSpriteTemplates[3] = { - { 0x1001, 0x1001, &gOamData_83AC9D8, sPikaAnims1, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, - { 0x1002, 0x1001, &gOamData_83AC9F8, sPikaAnims2, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, - { 0x1003, 0x1001, &gOamData_83AC9E8, sPikaAnims3, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy } + { 0x1001, 0x1001, &gOamData_AffineOff_ObjNormal_32x32, sPikaAnims1, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1002, 0x1001, &gOamData_AffineOff_ObjNormal_32x16, sPikaAnims2, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1003, 0x1001, &gOamData_AffineOff_ObjNormal_16x8, sPikaAnims3, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy } }; static const u8 *const sHelpDocsPtrs[] = { diff --git a/src/poison.c b/src/poison.c index 7a0788c29..af7f8ee86 100644 --- a/src/poison.c +++ b/src/poison.c @@ -30,7 +30,7 @@ const struct SpriteTemplate gUnknown_83E69AC = { .tileTag = ANIM_TAG_TOXIC_BUBBLE, .paletteTag = ANIM_TAG_TOXIC_BUBBLE, - .oam = &gOamData_83ACA18, + .oam = &gOamData_AffineOff_ObjNormal_16x32, .anims = gUnknown_83E69A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -98,7 +98,7 @@ const struct SpriteTemplate gUnknown_83E6A20 = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA90, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gUnknown_83E69DC, .images = NULL, .affineAnims = gUnknown_83E6A18, @@ -109,7 +109,7 @@ const struct SpriteTemplate gUnknown_83E6A38 = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA90, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gUnknown_83E69DC, .images = NULL, .affineAnims = gUnknown_83E6A18, @@ -120,7 +120,7 @@ const struct SpriteTemplate gUnknown_83E6A50 = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gUnknown_83E69E4, .images = NULL, .affineAnims = gUnknown_83E6A1C, @@ -143,7 +143,7 @@ const struct SpriteTemplate gUnknown_83E6A84 = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA90, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gUnknown_83E69E0, .images = NULL, .affineAnims = gUnknown_83E6A80, @@ -166,7 +166,7 @@ const struct SpriteTemplate gPoisonBubbleSpriteTemplate = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gUnknown_83E69DC, .images = NULL, .affineAnims = gUnknown_83E6AB4, @@ -177,7 +177,7 @@ const struct SpriteTemplate gWaterBubbleSpriteTemplate = { .tileTag = ANIM_TAG_SMALL_BUBBLES, .paletteTag = ANIM_TAG_SMALL_BUBBLES, - .oam = &gOamData_83ACB50, + .oam = &gOamData_AffineNormal_ObjBlend_16x16, .anims = gUnknown_83E5A78, .images = NULL, .affineAnims = gUnknown_83E6AB4, diff --git a/src/psychic.c b/src/psychic.c index bbb6c3ed5..722ea014f 100644 --- a/src/psychic.c +++ b/src/psychic.c @@ -43,7 +43,7 @@ const struct SpriteTemplate gUnknown_83E6DF8 = { .tileTag = ANIM_TAG_SPIRAL, .paletteTag = ANIM_TAG_SPIRAL, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6DF4, @@ -54,7 +54,7 @@ const struct SpriteTemplate gUnknown_83E6E10 = { .tileTag = ANIM_TAG_GREEN_LIGHT_WALL, .paletteTag = ANIM_TAG_GREEN_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -65,7 +65,7 @@ const struct SpriteTemplate gUnknown_83E6E28 = { .tileTag = ANIM_TAG_BLUE_LIGHT_WALL, .paletteTag = ANIM_TAG_BLUE_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -76,7 +76,7 @@ const struct SpriteTemplate gUnknown_83E6E40 = { .tileTag = ANIM_TAG_RED_LIGHT_WALL, .paletteTag = ANIM_TAG_RED_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -87,7 +87,7 @@ const struct SpriteTemplate gUnknown_83E6E58 = { .tileTag = ANIM_TAG_GRAY_LIGHT_WALL, .paletteTag = ANIM_TAG_GRAY_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -98,7 +98,7 @@ const struct SpriteTemplate gUnknown_83E6E70 = { .tileTag = ANIM_TAG_ORANGE_LIGHT_WALL, .paletteTag = ANIM_TAG_ORANGE_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -124,7 +124,7 @@ const struct SpriteTemplate gUnknown_83E6EA4 = { .tileTag = ANIM_TAG_SPARKLE_4, .paletteTag = ANIM_TAG_SPARKLE_4, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E6EA0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -149,7 +149,7 @@ const struct SpriteTemplate gUnknown_83E6ED4 = { .tileTag = ANIM_TAG_SPARKLE_3, .paletteTag = ANIM_TAG_SPARKLE_3, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E6ED0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -160,7 +160,7 @@ const struct SpriteTemplate gUnknown_83E6EEC = { .tileTag = ANIM_TAG_GOLD_RING, .paletteTag = ANIM_TAG_GOLD_RING, - .oam = &gOamData_83ACA18, + .oam = &gOamData_AffineOff_ObjNormal_16x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -217,7 +217,7 @@ const struct SpriteTemplate gUnknown_83E6F8C = { .tileTag = ANIM_TAG_BENT_SPOON, .paletteTag = ANIM_TAG_BENT_SPOON, - .oam = &gOamData_83ACA18, + .oam = &gOamData_AffineOff_ObjNormal_16x32, .anims = gUnknown_83E6F84, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -259,7 +259,7 @@ const struct SpriteTemplate gUnknown_83E6FF4 = { .tileTag = ANIM_TAG_AMNESIA, .paletteTag = ANIM_TAG_AMNESIA, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E6FC4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -285,7 +285,7 @@ static const struct SpriteTemplate gUnknown_83E7044 = { .tileTag = ANIM_TAG_HOLLOW_ORB, .paletteTag = ANIM_TAG_HOLLOW_ORB, - .oam = &gOamData_83ACAF0, + .oam = &gOamData_AffineOff_ObjBlend_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -296,7 +296,7 @@ const struct SpriteTemplate gUnknown_83E705C = { .tileTag = 0x280A, .paletteTag = 0x280A, - .oam = &gOamData_83AC9E0, + .oam = &gOamData_AffineOff_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -349,7 +349,7 @@ static const struct SpriteTemplate gUnknown_83E7114 = { .tileTag = ANIM_TAG_BLUEGREEN_ORB, .paletteTag = ANIM_TAG_BLUEGREEN_ORB, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7104, @@ -372,7 +372,7 @@ const struct SpriteTemplate gUnknown_83E7148 = { .tileTag = ANIM_TAG_WHITE_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_WHITE_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACBC0, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7144, @@ -410,7 +410,7 @@ const struct SpriteTemplate gUnknown_83E71D0 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACBC0, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E71C8, diff --git a/src/rock.c b/src/rock.c index c4b668941..b0809fade 100644 --- a/src/rock.c +++ b/src/rock.c @@ -55,7 +55,7 @@ const struct SpriteTemplate gUnknown_83E73B4 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E73A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -66,7 +66,7 @@ const struct SpriteTemplate gUnknown_83E73CC = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E73A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -77,7 +77,7 @@ const struct SpriteTemplate gUnknown_83E73E4 = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -101,7 +101,7 @@ const struct SpriteTemplate gUnknown_83E7420 = { .tileTag = ANIM_TAG_WATER_ORB, .paletteTag = ANIM_TAG_WATER_ORB, - .oam = &gOamData_83ACB50, + .oam = &gOamData_AffineNormal_ObjBlend_16x16, .anims = gUnknown_83E5958, .images = NULL, .affineAnims = gUnknown_83E741C, @@ -112,7 +112,7 @@ const struct SpriteTemplate gUnknown_83E7438 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -123,7 +123,7 @@ const struct SpriteTemplate gUnknown_83E7450 = { .tileTag = ANIM_TAG_FLYING_DIRT, .paletteTag = ANIM_TAG_FLYING_DIRT, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -213,7 +213,7 @@ const struct SpriteTemplate gUnknown_83E74C0 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E74A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -224,7 +224,7 @@ const struct SpriteTemplate gUnknown_83E74D8 = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -235,7 +235,7 @@ const struct SpriteTemplate gUnknown_83E74F0 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -246,7 +246,7 @@ const struct SpriteTemplate gUnknown_83E7508 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E74A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -275,7 +275,7 @@ const struct SpriteTemplate gUnknown_83E7548 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E74A8, .images = NULL, .affineAnims = gUnknown_83E7540, @@ -286,7 +286,7 @@ const struct SpriteTemplate gUnknown_83E7560 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E74A8, .images = NULL, .affineAnims = gUnknown_83E7540, @@ -297,7 +297,7 @@ const struct SpriteTemplate gUnknown_83E7578 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E74B8, .images = NULL, .affineAnims = gUnknown_83E7540, @@ -308,7 +308,7 @@ const struct SpriteTemplate gUnknown_83E7590 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E74B0, .images = NULL, .affineAnims = gUnknown_83E7540, diff --git a/src/text.c b/src/text.c index b61713ee2..93a35a07d 100644 --- a/src/text.c +++ b/src/text.c @@ -15,7 +15,7 @@ #include "constants/songs.h" extern u8 gGlyphInfo[0x90]; -extern const struct OamData gOamData_83AC9D0; +extern const struct OamData gOamData_AffineOff_ObjNormal_16x16; static void DecompressGlyphFont3(u16 glyphId, bool32 isJapanese); static void DecompressGlyphFont4(u16 glyphId, bool32 isJapanese); @@ -59,7 +59,7 @@ const struct SpriteTemplate gUnknown_81EA6B4 = { .tileTag = 0x8000, .paletteTag = 0x8000, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, -- cgit v1.2.3 From 4454ef35e861cf18ce6e43033f551538366bfb51 Mon Sep 17 00:00:00 2001 From: Evan Date: Mon, 2 Dec 2019 12:32:56 -0700 Subject: b_anim_eff_3 --- src/battle_anim_effects_1.c | 463 ++-- src/battle_anim_effects_2.c | 3818 ++++++++++++++++++++++++++++++ src/battle_anim_effects_3.c | 5495 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 9560 insertions(+), 216 deletions(-) create mode 100644 src/battle_anim_effects_2.c create mode 100644 src/battle_anim_effects_3.c (limited to 'src') diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index a02125d6d..9d820b628 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -16,8 +16,10 @@ #include "constants/rgb.h" #include "constants/songs.h" -EWRAM_DATA s16 gUnknown_0203A0F8[4] = {0}; +// RAM +EWRAM_DATA s16 gUnknown_203999C[4] = {0}; +// Function Declarations void AnimMovePowderParticle(struct Sprite *); void AnimPowerAbsorptionOrb(struct Sprite *); void AnimSolarbeamBigOrb(struct Sprite *); @@ -150,6 +152,8 @@ static void AnimFollowMeFingerStep2(struct Sprite *); static void AnimTauntFingerStep1(struct Sprite *); static void AnimTauntFingerStep2(struct Sprite *); +static const u8 gUnknown_83E2964[] = {0x02, 0x04, 0x01, 0x03}; + const union AnimCmd gPowderParticlesAnimCmds[] = //gUnknown_83E2968 { ANIMCMD_FRAME(0, 5), @@ -406,25 +410,25 @@ const struct SpriteTemplate gLeechSeedSpriteTemplate = //gUnknown_83E2B34 .callback = AnimLeechSeed, }; -const union AnimCmd gSporeParticleAnimCmds1[] = +const union AnimCmd gSporeParticleAnimCmds1[] = //gUnknown_83E2B4C { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gSporeParticleAnimCmds2[] = +const union AnimCmd gSporeParticleAnimCmds2[] = //gUnknown_83E2B54 { ANIMCMD_FRAME(4, 7), ANIMCMD_END, }; -const union AnimCmd *const gSporeParticleAnimTable[] = +const union AnimCmd *const gSporeParticleAnimTable[] = //gUnknown_83E2B5C { gSporeParticleAnimCmds1, gSporeParticleAnimCmds2, }; -const struct SpriteTemplate gSporeParticleSpriteTemplate = +const struct SpriteTemplate gSporeParticleSpriteTemplate = //gUnknown_83E2B64 { .tileTag = ANIM_TAG_SPORE, .paletteTag = ANIM_TAG_SPORE, @@ -435,29 +439,29 @@ const struct SpriteTemplate gSporeParticleSpriteTemplate = .callback = AnimSporeParticle, }; -const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = +const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = //gUnknown_83E2B7C { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = +const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = //gUnknown_83E2B84 { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = +const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = //gUnknown_83E2B8C { gPetalDanceBigFlowerAnimCmds, }; -const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = +const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = //gUnknown_83E2B90 { gPetalDanceSmallFlowerAnimCmds, }; -const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = +const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = //gUnknown_83E2B94 { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -468,7 +472,7 @@ const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = .callback = AnimPetalDanceBigFlower, }; -const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = +const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = //gUnknown_83E2BAC { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -479,7 +483,7 @@ const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = .callback = AnimPetalDanceSmallFlower, }; -const union AnimCmd gRazorLeafParticleAnimCmds1[] = +const union AnimCmd gRazorLeafParticleAnimCmds1[] = //gUnknown_83E2BC4 { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 5), @@ -494,7 +498,7 @@ const union AnimCmd gRazorLeafParticleAnimCmds1[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gRazorLeafParticleAnimCmds2[] = +const union AnimCmd gRazorLeafParticleAnimCmds2[] = //gUnknown_83E2BF0 { ANIMCMD_FRAME(24, 5), ANIMCMD_FRAME(28, 5), @@ -502,13 +506,13 @@ const union AnimCmd gRazorLeafParticleAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gRazorLeafParticleAnimTable[] = +const union AnimCmd *const gRazorLeafParticleAnimTable[] = //gUnknown_83E2C00 { gRazorLeafParticleAnimCmds1, gRazorLeafParticleAnimCmds2, }; -const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = +const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = //gUnknown_83E2C08 { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -519,7 +523,7 @@ const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = .callback = AnimRazorLeafParticle, }; -const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = +const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = //gUnknown_83E2C20 { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -530,7 +534,7 @@ const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = .callback = AnimMoveTwisterParticle, }; -const union AnimCmd gRazorLeafCutterAnimCmds[] = +const union AnimCmd gRazorLeafCutterAnimCmds[] = //gUnknown_83E2C38 { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(0, 3, .hFlip = TRUE), @@ -539,12 +543,12 @@ const union AnimCmd gRazorLeafCutterAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRazorLeafCutterAnimTable[] = +const union AnimCmd *const gRazorLeafCutterAnimTable[] = //gUnknown_83E2C4C { gRazorLeafCutterAnimCmds, }; -const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = +const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = //gUnknown_83E2C50 { .tileTag = ANIM_TAG_RAZOR_LEAF, .paletteTag = ANIM_TAG_RAZOR_LEAF, @@ -555,16 +559,18 @@ const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = .callback = AnimTranslateLinearSingleSineWave, }; -const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = { +const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = //gUnknown_83E2C68 +{ AFFINEANIMCMD_FRAME(0, 0, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = { +const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = //gUnknown_83E2C78 +{ gSwiftStarAffineAnimCmds, }; -const struct SpriteTemplate gSwiftStarSpriteTemplate = +const struct SpriteTemplate gSwiftStarSpriteTemplate = //gUnknown_83E2C7C { .tileTag = ANIM_TAG_YELLOW_STAR, .paletteTag = ANIM_TAG_YELLOW_STAR, @@ -575,7 +581,7 @@ const struct SpriteTemplate gSwiftStarSpriteTemplate = .callback = AnimTranslateLinearSingleSineWave, }; -const union AnimCmd gConstrictBindingAnimCmds1[] = +const union AnimCmd gConstrictBindingAnimCmds1[] = //gUnknown_83E2C94 { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(32, 4), @@ -584,7 +590,7 @@ const union AnimCmd gConstrictBindingAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gConstrictBindingAnimCmds2[] = +const union AnimCmd gConstrictBindingAnimCmds2[] = //gUnknown_83E2CA8 { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(32, 4, .hFlip = TRUE), @@ -593,32 +599,35 @@ const union AnimCmd gConstrictBindingAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gConstrictBindingAnimTable[] = +const union AnimCmd *const gConstrictBindingAnimTable[] = //gUnknown_83E2CBC { gConstrictBindingAnimCmds1, gConstrictBindingAnimCmds2, }; -const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = { +const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = //gUnknown_83E2CC4 +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(-11, 0, 0, 6), AFFINEANIMCMD_FRAME(11, 0, 0, 6), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = { +const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = //gUnknown_83E2CE4 +{ AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(11, 0, 0, 6), AFFINEANIMCMD_FRAME(-11, 0, 0, 6), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = { +const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = //gUnknown_83E2D04 +{ gConstrictBindingAffineAnimCmds1, gConstrictBindingAffineAnimCmds2, }; -const struct SpriteTemplate gConstrictBindingSpriteTemplate = +const struct SpriteTemplate gConstrictBindingSpriteTemplate = //gUnknown_83E2D0C { .tileTag = ANIM_TAG_TENDRILS, .paletteTag = ANIM_TAG_TENDRILS, @@ -629,23 +638,26 @@ const struct SpriteTemplate gConstrictBindingSpriteTemplate = .callback = AnimConstrictBinding, }; -const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = { +const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = //gUnknown_83E2D24 +{ AFFINEANIMCMD_FRAME(0, 0, 0, 0), AFFINEANIMCMD_FRAME(48, 48, 0, 14), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = { +const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = //gUnknown_83E2D3C +{ AFFINEANIMCMD_FRAME(-16, -16, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = { +const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = //gUnknown_83E2D4C +{ gMimicOrbAffineAnimCmds1, gMimicOrbAffineAnimCmds2, }; -const struct SpriteTemplate gMimicOrbSpriteTemplate = +const struct SpriteTemplate gMimicOrbSpriteTemplate = //gUnknown_83E2D54 { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -656,7 +668,7 @@ const struct SpriteTemplate gMimicOrbSpriteTemplate = .callback = AnimMimicOrb, }; -const union AnimCmd gIngrainRootAnimCmds1[] = +const union AnimCmd gIngrainRootAnimCmds1[] = //gUnknown_83E2D6C { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -665,7 +677,7 @@ const union AnimCmd gIngrainRootAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds2[] = +const union AnimCmd gIngrainRootAnimCmds2[] = //gUnknown_83E2D80 { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -674,7 +686,7 @@ const union AnimCmd gIngrainRootAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds3[] = +const union AnimCmd gIngrainRootAnimCmds3[] = //gUnknown_83E2D94 { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -682,7 +694,7 @@ const union AnimCmd gIngrainRootAnimCmds3[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds4[] = +const union AnimCmd gIngrainRootAnimCmds4[] = //gUnknown_83E2DA4 { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -690,7 +702,7 @@ const union AnimCmd gIngrainRootAnimCmds4[] = ANIMCMD_END, }; -const union AnimCmd *const gIngrainRootAnimTable[] = +const union AnimCmd *const gIngrainRootAnimTable[] = //gUnknown_83E2DB4 { gIngrainRootAnimCmds1, gIngrainRootAnimCmds2, @@ -698,7 +710,7 @@ const union AnimCmd *const gIngrainRootAnimTable[] = gIngrainRootAnimCmds4, }; -const struct SpriteTemplate gIngrainRootSpriteTemplate = +const struct SpriteTemplate gIngrainRootSpriteTemplate = //gUnknown_83E2DC4 { .tileTag = ANIM_TAG_ROOTS, .paletteTag = ANIM_TAG_ROOTS, @@ -709,7 +721,7 @@ const struct SpriteTemplate gIngrainRootSpriteTemplate = .callback = AnimIngrainRoot, }; -const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = +const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = //gUnknown_83E2DDC { .tileTag = ANIM_TAG_ROOTS, .paletteTag = ANIM_TAG_ROOTS, @@ -720,19 +732,19 @@ const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = .callback = AnimFrenzyPlantRoot, }; -const union AnimCmd gIngrainOrbAnimCmds[] = +const union AnimCmd gIngrainOrbAnimCmds[] = //gUnknown_83E2DF4 { ANIMCMD_FRAME(3, 3), ANIMCMD_FRAME(0, 5), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gIngrainOrbAnimTable[] = +const union AnimCmd *const gIngrainOrbAnimTable[] = //gUnknown_83E2E00 { gIngrainOrbAnimCmds, }; -const struct SpriteTemplate gIngrainOrbSpriteTemplate = +const struct SpriteTemplate gIngrainOrbSpriteTemplate = //gUnknown_83E2E04 { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -743,25 +755,27 @@ const struct SpriteTemplate gIngrainOrbSpriteTemplate = .callback = AnimIngrainOrb, }; -const union AnimCmd gFallingBagAnimCmds[] = +const union AnimCmd gFallingBagAnimCmds[] = //gUnknown_83E2E1C { ANIMCMD_FRAME(0, 30), ANIMCMD_END, }; -const union AnimCmd *const gFallingBagAnimTable[] = +const union AnimCmd *const gFallingBagAnimTable[] = //gUnknown_83E2E24 { gFallingBagAnimCmds, }; -const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = { +const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = //gUnknown_83E2E28 +{ AFFINEANIMCMD_FRAME(0, 0, -4, 10), AFFINEANIMCMD_FRAME(0, 0, 4, 20), AFFINEANIMCMD_FRAME(0, 0, -4, 10), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = { +const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = //gUnknown_83E2E48 +{ AFFINEANIMCMD_FRAME(0, 0, -1, 2), AFFINEANIMCMD_FRAME(0, 0, 1, 4), AFFINEANIMCMD_FRAME(0, 0, -1, 4), @@ -771,12 +785,13 @@ const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = { AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = { +const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = //gUnknown_83E2E80 +{ gFallingBagAffineAnimCmds1, gFallingBagAffineAnimCmds2, }; -const struct SpriteTemplate gPresentSpriteTemplate = +const struct SpriteTemplate gPresentSpriteTemplate = //gUnknown_83E2E88 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -787,7 +802,7 @@ const struct SpriteTemplate gPresentSpriteTemplate = .callback = AnimPresent, }; -const struct SpriteTemplate gKnockOffItemSpriteTemplate = +const struct SpriteTemplate gKnockOffItemSpriteTemplate = //gUnknown_83E2EA0 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -798,7 +813,7 @@ const struct SpriteTemplate gKnockOffItemSpriteTemplate = .callback = AnimKnockOffItem, }; -const union AnimCmd gPresentHealParticleAnimCmds[] = +const union AnimCmd gPresentHealParticleAnimCmds[] = //gUnknown_83E2EB8 { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 4), @@ -807,12 +822,12 @@ const union AnimCmd gPresentHealParticleAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gPresentHealParticleAnimTable[] = +const union AnimCmd *const gPresentHealParticleAnimTable[] = //gUnknown_83E2ECC { gPresentHealParticleAnimCmds, }; -const struct SpriteTemplate gPresentHealParticleSpriteTemplate = +const struct SpriteTemplate gPresentHealParticleSpriteTemplate = //gUnknown_83E2ED0 { .tileTag = ANIM_TAG_GREEN_SPARKLE, .paletteTag = ANIM_TAG_GREEN_SPARKLE, @@ -823,7 +838,7 @@ const struct SpriteTemplate gPresentHealParticleSpriteTemplate = .callback = AnimPresentHealParticle, }; -const struct SpriteTemplate gItemStealSpriteTemplate = +const struct SpriteTemplate gItemStealSpriteTemplate = //gUnknown_83E2EE8 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -834,12 +849,14 @@ const struct SpriteTemplate gItemStealSpriteTemplate = .callback = AnimItemSteal, }; -const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = { +const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = //gUnknown_83E2F00 +{ AFFINEANIMCMD_FRAME(0, 0, 0, 3), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = { +const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = //gUnknown_83E2F10 +{ AFFINEANIMCMD_FRAME(0, -10, 0, 3), AFFINEANIMCMD_FRAME(0, -6, 0, 3), AFFINEANIMCMD_FRAME(0, -2, 0, 3), @@ -850,14 +867,15 @@ const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = { AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = { +const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = //gUnknown_83E2F50 +{ gTrickBagAffineAnimCmds1, gTrickBagAffineAnimCmds2, gFallingBagAffineAnimCmds1, gFallingBagAffineAnimCmds2, }; -const struct SpriteTemplate gTrickBagSpriteTemplate = +const struct SpriteTemplate gTrickBagSpriteTemplate = //gUnknown_83E2F60 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -868,7 +886,7 @@ const struct SpriteTemplate gTrickBagSpriteTemplate = .callback = AnimTrickBag, }; -const s8 gTrickBagCoordinates[][3] = +const s8 gTrickBagCoordinates[][3] = //gUnknown_83E2F78 { {5, 24, 1}, {0, 4, 0}, @@ -883,49 +901,49 @@ const s8 gTrickBagCoordinates[][3] = {0, 0, 127}, }; -const union AnimCmd gLeafBladeAnimCmds1[] = +const union AnimCmd gLeafBladeAnimCmds1[] = //gUnknown_83E2F9C { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds2[] = +const union AnimCmd gLeafBladeAnimCmds2[] = //gUnknown_83E2FA4 { ANIMCMD_FRAME(32, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds3[] = +const union AnimCmd gLeafBladeAnimCmds3[] = //gUnknown_83E2FAC { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds4[] = +const union AnimCmd gLeafBladeAnimCmds4[] = //gUnknown_83E2FB4 { ANIMCMD_FRAME(28, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds5[] = +const union AnimCmd gLeafBladeAnimCmds5[] = //gUnknown_83E2FBC { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds6[] = +const union AnimCmd gLeafBladeAnimCmds6[] = //gUnknown_83E2FC4 { ANIMCMD_FRAME(16, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds7[] = +const union AnimCmd gLeafBladeAnimCmds7[] = //gUnknown_83E2FCC { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -const union AnimCmd *const gLeafBladeAnimTable[] = +const union AnimCmd *const gLeafBladeAnimTable[] = //gUnknown_83E2FD4 { gLeafBladeAnimCmds1, gLeafBladeAnimCmds2, @@ -936,7 +954,7 @@ const union AnimCmd *const gLeafBladeAnimTable[] = gLeafBladeAnimCmds7, }; -const struct SpriteTemplate gLeafBladeSpriteTemplate = +const struct SpriteTemplate gLeafBladeSpriteTemplate = //gUnknown_83E2FF0 { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -947,17 +965,19 @@ const struct SpriteTemplate gLeafBladeSpriteTemplate = .callback = SpriteCallbackDummy, }; -const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = { +const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = //gUnknown_83E3008 +{ AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = { +const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = //gUnknown_83E3020 +{ gAromatherapyBigFlowerAffineAnimCmds, }; -const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = +const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = //gUnknown_83E3024 { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -968,7 +988,7 @@ const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = +const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = //gUnknown_83E303C { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -979,37 +999,43 @@ const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = .callback = AnimFlyingParticle, }; -const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = { +const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = //gUnknown_83E3054 +{ AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -10, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = { +const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = //gUnknown_83E306C +{ AFFINEANIMCMD_FRAME(192, 192, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -12, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = { +const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = //gUnknown_83E3084 +{ AFFINEANIMCMD_FRAME(143, 143, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -15, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = { +const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = //gUnknown_83E309C +{ gSilverWindBigSparkAffineAnimCmds, }; -const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = { +const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = //gUnknown_83E30A0 +{ gSilverWindMediumSparkAffineAnimCmds, }; -const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = { +const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = //gUnknown_83E30A4 +{ gSilverWindSmallSparkAffineAnimCmds, }; -const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = +const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = //gUnknown_83E30A8 { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1020,7 +1046,7 @@ const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = +const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = //gUnknown_83E30C0 { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1031,7 +1057,7 @@ const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = +const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = //gUnknown_83E30D8 { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1042,7 +1068,7 @@ const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = .callback = AnimFlyingParticle, }; -const u16 gMagicalLeafBlendColors[] = +const u16 gMagicalLeafBlendColors[] = //gUnknown_83E30F0 { RGB(31, 0, 0), RGB(31, 19, 0), @@ -1053,7 +1079,7 @@ const u16 gMagicalLeafBlendColors[] = RGB(22, 21, 31), }; -const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = +const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = //gUnknown_83E3100 { .tileTag = ANIM_TAG_GREEN_SPIKE, .paletteTag = ANIM_TAG_GREEN_SPIKE, @@ -1064,7 +1090,7 @@ const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = .callback = AnimNeedleArmSpike, }; -const union AnimCmd gWhipAnimCmds1[] = +const union AnimCmd gWhipAnimCmds1[] = //gUnknown_83E3118 { ANIMCMD_FRAME(64, 3), ANIMCMD_FRAME(80, 3), @@ -1073,7 +1099,7 @@ const union AnimCmd gWhipAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gWhipAnimCmds2[] = +const union AnimCmd gWhipAnimCmds2[] = //gUnknown_83E312C { ANIMCMD_FRAME(64, 3, .hFlip = TRUE), ANIMCMD_FRAME(80, 3, .hFlip = TRUE), @@ -1082,13 +1108,13 @@ const union AnimCmd gWhipAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gWhipAnimTable[] = +const union AnimCmd *const gWhipAnimTable[] = //gUnknown_83E3140 { gWhipAnimCmds1, gWhipAnimCmds2, }; -const struct SpriteTemplate gSlamHitSpriteTemplate = +const struct SpriteTemplate gSlamHitSpriteTemplate = //gUnknown_83E3148 { .tileTag = ANIM_TAG_SLAM_HIT, .paletteTag = ANIM_TAG_SLAM_HIT, @@ -1099,7 +1125,7 @@ const struct SpriteTemplate gSlamHitSpriteTemplate = .callback = AnimWhipHit, }; -const struct SpriteTemplate gVineWhipSpriteTemplate = +const struct SpriteTemplate gVineWhipSpriteTemplate = //gUnknown_83E3160 { .tileTag = ANIM_TAG_WHIP_HIT, .paletteTag = ANIM_TAG_WHIP_HIT, @@ -1110,7 +1136,7 @@ const struct SpriteTemplate gVineWhipSpriteTemplate = .callback = AnimWhipHit, }; -const union AnimCmd gUnknown_08592900[] = +const union AnimCmd gUnknown_83E3178[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1120,99 +1146,105 @@ const union AnimCmd gUnknown_08592900[] = ANIMCMD_END, }; -const union AnimCmd *const gUnknown_08592918[] = +const union AnimCmd *const gUnknown_83E3190[] = { - gUnknown_08592900, + gUnknown_83E3178, }; -// Unused -const struct SpriteTemplate gUnknown_0859291C = +const struct SpriteTemplate gUnknown_83E3194 = // Unused { .tileTag = ANIM_TAG_HIT, .paletteTag = ANIM_TAG_HIT, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gUnknown_08592918, + .anims = gUnknown_83E3190, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A43F8, }; -// Unused -const struct SpriteTemplate gUnknown_08592934 = +const struct SpriteTemplate gUnknown_83E31AC = // Unused { .tileTag = ANIM_TAG_HIT_2, .paletteTag = ANIM_TAG_HIT_2, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gUnknown_08592918, + .anims = gUnknown_83E3190, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A43F8, }; -const union AffineAnimCmd gUnknown_0859294C[] = { +const union AffineAnimCmd gUnknown_83E31C4[] = +{ AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859295C[] = { +const union AffineAnimCmd gUnknown_83E31D4[] = +{ AFFINEANIMCMD_FRAME(256, 256, 32, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859296C[] = { +const union AffineAnimCmd gUnknown_83E31E4[] = +{ AFFINEANIMCMD_FRAME(256, 256, 64, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859297C[] = { +const union AffineAnimCmd gUnknown_83E31F4[] = +{ AFFINEANIMCMD_FRAME(256, 256, 96, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859298C[] = { +const union AffineAnimCmd gUnknown_83E3204[] = +{ AFFINEANIMCMD_FRAME(256, 256, -128, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859299C[] = { +const union AffineAnimCmd gUnknown_83E3214[] = +{ AFFINEANIMCMD_FRAME(256, 256, -96, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_085929AC[] = { +const union AffineAnimCmd gUnknown_83E3224[] = +{ AFFINEANIMCMD_FRAME(256, 256, -64, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_085929BC[] = { +const union AffineAnimCmd gUnknown_83E3234[] = +{ AFFINEANIMCMD_FRAME(256, 256, -32, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gUnknown_085929CC[] = { - gUnknown_0859294C, - gUnknown_0859295C, - gUnknown_0859296C, - gUnknown_0859297C, - gUnknown_0859298C, - gUnknown_0859299C, - gUnknown_085929AC, - gUnknown_085929BC, +const union AffineAnimCmd *const gUnknown_83E3244[] = +{ + gUnknown_83E31C4, + gUnknown_83E31D4, + gUnknown_83E31E4, + gUnknown_83E31F4, + gUnknown_83E3204, + gUnknown_83E3214, + gUnknown_83E3224, + gUnknown_83E3234, }; -// Unused -const struct SpriteTemplate gUnknown_085929EC = +const struct SpriteTemplate gUnknown_83E3264 = // Unused { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gUnknown_085929CC, + .affineAnims = gUnknown_83E3244, .callback = sub_80A4494, }; -const union AnimCmd gCuttingSliceAnimCmds[] = +const union AnimCmd gCuttingSliceAnimCmds[] = //gUnknown_83E327C { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(16, 5), @@ -1221,12 +1253,12 @@ const union AnimCmd gCuttingSliceAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gCuttingSliceAnimTable[] = +const union AnimCmd *const gCuttingSliceAnimTable[] = //gUnknown_83E3290 { gCuttingSliceAnimCmds, }; -const struct SpriteTemplate gCuttingSliceSpriteTemplate = +const struct SpriteTemplate gCuttingSliceSpriteTemplate = //gUnknown_83E3294 { .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, @@ -1237,7 +1269,7 @@ const struct SpriteTemplate gCuttingSliceSpriteTemplate = .callback = AnimCuttingSlice, }; -const struct SpriteTemplate gAirCutterSliceSpriteTemplate = +const struct SpriteTemplate gAirCutterSliceSpriteTemplate = //gUnknown_83E32AC { .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, @@ -1248,93 +1280,92 @@ const struct SpriteTemplate gAirCutterSliceSpriteTemplate = .callback = AnimAirCutterSlice, }; -const union AnimCmd gUnknown_08592A4C[] = +const union AnimCmd gUnknown_83E32C4[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A54[] = +const union AnimCmd gUnknown_83E32CC[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A5C[] = +const union AnimCmd gUnknown_83E32D4[] = { ANIMCMD_FRAME(8, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A64[] = +const union AnimCmd gUnknown_83E32DC[] = { ANIMCMD_FRAME(12, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A6C[] = +const union AnimCmd gUnknown_83E32E4[] = { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A74[] = +const union AnimCmd gUnknown_83E32EC[] = { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A7C[] = +const union AnimCmd gUnknown_83E32F4[] = { ANIMCMD_FRAME(0, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A84[] = +const union AnimCmd gUnknown_83E32FC[] = { ANIMCMD_FRAME(4, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A8C[] = +const union AnimCmd gUnknown_83E3304[] = { ANIMCMD_FRAME(8, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A94[] = +const union AnimCmd gUnknown_83E330C[] = { ANIMCMD_FRAME(12, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd *const gUnknown_08592A9C[] = +const union AnimCmd *const gUnknown_83E3314[] = { - gUnknown_08592A4C, - gUnknown_08592A54, - gUnknown_08592A5C, - gUnknown_08592A64, - gUnknown_08592A6C, - gUnknown_08592A74, - gUnknown_08592A7C, - gUnknown_08592A84, - gUnknown_08592A8C, - gUnknown_08592A94, + gUnknown_83E32C4, + gUnknown_83E32CC, + gUnknown_83E32D4, + gUnknown_83E32DC, + gUnknown_83E32E4, + gUnknown_83E32EC, + gUnknown_83E32F4, + gUnknown_83E32FC, + gUnknown_83E3304, + gUnknown_83E330C, }; -// Unused -const struct SpriteTemplate gUnknown_08592AC4 = +const struct SpriteTemplate gUnknown_83E333C = // Unused { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gUnknown_08592A9C, + .anims = gUnknown_83E3314, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A481C, }; -const struct SpriteTemplate gUnknown_08592ADC = +const struct SpriteTemplate gProtectWallSpriteTemplate = //gUnknown_83E3354 { .tileTag = ANIM_TAG_PROTECT, .paletteTag = ANIM_TAG_PROTECT, @@ -1345,13 +1376,13 @@ const struct SpriteTemplate gUnknown_08592ADC = .callback = AnimProtect, }; -const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = +const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = //gUnknown_83E336C { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = +const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] =//gUnknown_83E337C { AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), @@ -1361,13 +1392,13 @@ const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] = +const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] =//gUnknown_83E33AC { gMilkBottleAffineAnimCmds1, gMilkBottleAffineAnimCmds2, }; -const struct SpriteTemplate gMilkBottleSpriteTemplate = +const struct SpriteTemplate gMilkBottleSpriteTemplate =//gUnknown_83E33B4 { .tileTag = ANIM_TAG_MILK_BOTTLE, .paletteTag = ANIM_TAG_MILK_BOTTLE, @@ -1378,7 +1409,7 @@ const struct SpriteTemplate gMilkBottleSpriteTemplate = .callback = AnimMilkBottle, }; -const union AnimCmd gGrantingStarsAnimCmds[] = +const union AnimCmd gGrantingStarsAnimCmds[] =//gUnknown_83E33CC { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -1391,12 +1422,12 @@ const union AnimCmd gGrantingStarsAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gGrantingStarsAnimTable[] = +const union AnimCmd *const gGrantingStarsAnimTable[] =//gUnknown_83E33F0 { gGrantingStarsAnimCmds, }; -const struct SpriteTemplate gGrantingStarsSpriteTemplate = +const struct SpriteTemplate gGrantingStarsSpriteTemplate = //gUnknown_83E33F4 { .tileTag = ANIM_TAG_SPARKLE_2, .paletteTag = ANIM_TAG_SPARKLE_2, @@ -1407,7 +1438,7 @@ const struct SpriteTemplate gGrantingStarsSpriteTemplate = .callback = AnimGrantingStars, }; -const struct SpriteTemplate gSparklingStarsSpriteTemplate = +const struct SpriteTemplate gSparklingStarsSpriteTemplate = //gUnknown_83E340C { .tileTag = ANIM_TAG_SPARKLE_2, .paletteTag = ANIM_TAG_SPARKLE_2, @@ -1418,7 +1449,7 @@ const struct SpriteTemplate gSparklingStarsSpriteTemplate = .callback = AnimSparkingStars, }; -const union AnimCmd gUnknown_08592BAC[] = +const union AnimCmd gUnknown_83E3424[] = { ANIMCMD_FRAME(0, 10), ANIMCMD_FRAME(4, 10), @@ -1431,7 +1462,7 @@ const union AnimCmd gUnknown_08592BAC[] = ANIMCMD_END, }; -const union AnimCmd gUnknown_08592BD0[] = +const union AnimCmd gUnknown_83E3448[] = { ANIMCMD_FRAME(0, 10, .hFlip = TRUE), ANIMCMD_FRAME(4, 10, .hFlip = TRUE), @@ -1444,31 +1475,30 @@ const union AnimCmd gUnknown_08592BD0[] = ANIMCMD_END, }; -const union AnimCmd *const gUnknown_08592BF4[] = +const union AnimCmd *const gUnknown_83E346C[] = { - gUnknown_08592BAC, - gUnknown_08592BD0, + gUnknown_83E3424, + gUnknown_83E3448, }; -// Unused -const struct SpriteTemplate gUnknown_08592BFC = +const struct SpriteTemplate gUnknown_83E3474 = // Unused { .tileTag = ANIM_TAG_BUBBLE_BURST, .paletteTag = ANIM_TAG_BUBBLE_BURST, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gUnknown_08592BF4, + .anims = gUnknown_83E346C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A4E40, }; -const union AnimCmd gSleepLetterZAnimCmds[] = +const union AnimCmd gSleepLetterZAnimCmds[] =//gUnknown_83E348C { ANIMCMD_FRAME(0, 40), ANIMCMD_END, }; -const union AnimCmd *const gSleepLetterZAnimTable[] = +const union AnimCmd *const gSleepLetterZAnimTable[] =//gUnknown_83E3494 { gSleepLetterZAnimCmds, }; @@ -1501,13 +1531,13 @@ const union AffineAnimCmd gSleepLetterZAffineAnimCmds2_2[] = AFFINEANIMCMD_LOOP(10), }; -const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] = +const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] =//gUnknown_83E34F8 { gSleepLetterZAffineAnimCmds1, gSleepLetterZAffineAnimCmds2, }; -const struct SpriteTemplate gSleepLetterZSpriteTemplate = +const struct SpriteTemplate gSleepLetterZSpriteTemplate = //gUnknown_83E3500 { .tileTag = ANIM_TAG_LETTER_Z, .paletteTag = ANIM_TAG_LETTER_Z, @@ -1518,7 +1548,7 @@ const struct SpriteTemplate gSleepLetterZSpriteTemplate = .callback = AnimSleepLetterZ, }; -const struct SpriteTemplate gLockOnTargetSpriteTemplate = +const struct SpriteTemplate gLockOnTargetSpriteTemplate = //gUnknown_83E3518 { .tileTag = ANIM_TAG_LOCK_ON, .paletteTag = ANIM_TAG_LOCK_ON, @@ -1529,7 +1559,7 @@ const struct SpriteTemplate gLockOnTargetSpriteTemplate = .callback = AnimLockOnTarget, }; -const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = +const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = //gUnknown_83E3530 { .tileTag = ANIM_TAG_LOCK_ON, .paletteTag = ANIM_TAG_LOCK_ON, @@ -1548,7 +1578,7 @@ const s8 gInclineMonCoordTable[][2] = { 32, -32}, }; -const struct SpriteTemplate gBowMonSpriteTemplate = +const struct SpriteTemplate gBowMonSpriteTemplate = //gUnknown_83E3550 { .tileTag = 0, .paletteTag = 0, @@ -1559,8 +1589,7 @@ const struct SpriteTemplate gBowMonSpriteTemplate = .callback = AnimBowMon, }; -// Unused -const struct SpriteTemplate gUnknown_08592CF0 = +const struct SpriteTemplate gUnknown_83E3568 = // Unused { .tileTag = 0, .paletteTag = 0, @@ -1571,7 +1600,7 @@ const struct SpriteTemplate gUnknown_08592CF0 = .callback = sub_80A5590, }; -const union AnimCmd gSlashSliceAnimCmds1[] = +const union AnimCmd gSlashSliceAnimCmds1[] = //gUnknown_83E3580 { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1592,7 +1621,7 @@ const union AnimCmd *const gSlashSliceAnimTable[] = gSlashSliceAnimCmds2, }; -const struct SpriteTemplate gSlashSliceSpriteTemplate = +const struct SpriteTemplate gSlashSliceSpriteTemplate = //gUnknown_83E35A4 { .tileTag = ANIM_TAG_SLASH, .paletteTag = ANIM_TAG_SLASH, @@ -1603,7 +1632,7 @@ const struct SpriteTemplate gSlashSliceSpriteTemplate = .callback = AnimSlashSlice, }; -const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = +const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = //gUnknown_83E35BC { .tileTag = ANIM_TAG_SLASH_2, .paletteTag = ANIM_TAG_SLASH_2, @@ -1614,7 +1643,7 @@ const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = .callback = AnimFalseSwipeSlice, }; -const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = +const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = //gUnknown_83E35D4 { .tileTag = ANIM_TAG_SLASH_2, .paletteTag = ANIM_TAG_SLASH_2, @@ -1639,7 +1668,7 @@ const union AnimCmd *const gEndureEnergyAnimTable[] = gEndureEnergyAnimCmds, }; -const struct SpriteTemplate gEndureEnergySpriteTemplate = +const struct SpriteTemplate gEndureEnergySpriteTemplate = //gUnknown_83E3604 { .tileTag = ANIM_TAG_FOCUS_ENERGY, .paletteTag = ANIM_TAG_FOCUS_ENERGY, @@ -1674,7 +1703,7 @@ const union AnimCmd *const gSharpenSphereAnimTable[] = gSharpenSphereAnimCmds, }; -const struct SpriteTemplate gSharpenSphereSpriteTemplate = +const struct SpriteTemplate gSharpenSphereSpriteTemplate = //gUnknown_83E365C { .tileTag = ANIM_TAG_SPHERE_TO_CUBE, .paletteTag = ANIM_TAG_SPHERE_TO_CUBE, @@ -1685,7 +1714,7 @@ const struct SpriteTemplate gSharpenSphereSpriteTemplate = .callback = AnimSharpenSphere, }; -const struct SpriteTemplate gOctazookaBallSpriteTemplate = +const struct SpriteTemplate gOctazookaBallSpriteTemplate = //gUnknown_83E3674 { .tileTag = ANIM_TAG_BLACK_BALL, .paletteTag = ANIM_TAG_BLACK_BALL, @@ -1711,7 +1740,7 @@ const union AnimCmd *const gOctazookaAnimTable[] = gOctazookaAnimCmds, }; -const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = +const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = //gUnknown_83E36A8 { .tileTag = ANIM_TAG_GRAY_SMOKE, .paletteTag = ANIM_TAG_GRAY_SMOKE, @@ -1747,7 +1776,7 @@ const union AffineAnimCmd *const gConversionAffineAnimTable[] = gConversionAffineAnimCmds, }; -const struct SpriteTemplate gConversionSpriteTemplate = +const struct SpriteTemplate gConversionSpriteTemplate = //gUnknown_83E36EC { .tileTag = ANIM_TAG_CONVERSION, .paletteTag = ANIM_TAG_CONVERSION, @@ -1772,7 +1801,7 @@ const union AnimCmd *const gConversion2AnimTable[] = gConversion2AnimCmds, }; -const struct SpriteTemplate gConversion2SpriteTemplate = +const struct SpriteTemplate gConversion2SpriteTemplate = //gUnknown_83E371C { .tileTag = ANIM_TAG_CONVERSION, .paletteTag = ANIM_TAG_CONVERSION, @@ -1783,7 +1812,7 @@ const struct SpriteTemplate gConversion2SpriteTemplate = .callback = AnimConversion2, }; -const struct SpriteTemplate gMoonSpriteTemplate = +const struct SpriteTemplate gMoonSpriteTemplate = //gUnknown_83E3734 { .tileTag = ANIM_TAG_MOON, .paletteTag = ANIM_TAG_MOON, @@ -1808,7 +1837,7 @@ const union AnimCmd *const gMoonlightSparkleAnimTable[] = gMoonlightSparkleAnimCmds, }; -const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = +const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = //gUnknown_83E3764 { .tileTag = ANIM_TAG_GREEN_SPARKLE, .paletteTag = ANIM_TAG_GREEN_SPARKLE, @@ -1837,7 +1866,7 @@ const union AnimCmd *const gHealingBlueStarAnimTable[] = gHealingBlueStarAnimCmds, }; -const struct SpriteTemplate gHealingBlueStarSpriteTemplate = +const struct SpriteTemplate gHealingBlueStarSpriteTemplate = //gUnknown_83E37A4 { .tileTag = ANIM_TAG_BLUE_STAR, .paletteTag = ANIM_TAG_BLUE_STAR, @@ -1848,7 +1877,7 @@ const struct SpriteTemplate gHealingBlueStarSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gHornHitSpriteTemplate = +const struct SpriteTemplate gHornHitSpriteTemplate = //gUnknown_83E37BC { .tileTag = ANIM_TAG_HORN_HIT, .paletteTag = ANIM_TAG_HORN_HIT, @@ -1873,7 +1902,7 @@ const union AnimCmd *const gSuperFangAnimTable[] = gSuperFangAnimCmds, }; -const struct SpriteTemplate gSuperFangSpriteTemplate = +const struct SpriteTemplate gSuperFangSpriteTemplate = //gUnknown_83E37EC { .tileTag = ANIM_TAG_FANG_ATTACK, .paletteTag = ANIM_TAG_FANG_ATTACK, @@ -1932,7 +1961,7 @@ const union AnimCmd gWavyMusicNotesAnimCmds8[] = ANIMCMD_END, }; -const union AnimCmd *const gMusicNotesAnimTable[] = +const union AnimCmd *const gMusicNotesAnimTable[] = //gUnknown_83E3844 { gWavyMusicNotesAnimCmds1, gWavyMusicNotesAnimCmds2, @@ -1944,19 +1973,19 @@ const union AnimCmd *const gMusicNotesAnimTable[] = gWavyMusicNotesAnimCmds8, }; -const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = +const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = //gUnknown_83E3864 { AFFINEANIMCMD_FRAME(0xC, 0xC, 0, 16), AFFINEANIMCMD_FRAME(0xFFF4, 0xFFF4, 0, 16), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = +const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = //gUnknown_83E387C { gWavyMusicNotesAffineAnimCmds, }; -const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = +const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = //gUnknown_83E3880 { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -1967,7 +1996,7 @@ const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = .callback = AnimWavyMusicNotes, }; -const u16 gParticlesColorBlendTable[][6] = +const u16 gParticlesColorBlendTable[][6] = //gUnknown_83E3898 { {ANIM_TAG_MUSIC_NOTES, RGB(31, 31, 31), RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, {ANIM_TAG_BENT_SPOON, RGB(31, 31, 31), RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, @@ -1975,7 +2004,7 @@ const u16 gParticlesColorBlendTable[][6] = {ANIM_TAG_LARGE_FRESH_EGG, RGB(31, 31, 31), RGB(26, 28, 31), RGB(21, 26, 31), RGB(16, 24, 31), RGB(12, 22, 31)}, }; -const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = +const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = //gUnknown_83E38C8 { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -1986,7 +2015,7 @@ const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = .callback = AnimFlyingMusicNotes, }; -const struct SpriteTemplate gBellyDrumHandSpriteTemplate = +const struct SpriteTemplate gBellyDrumHandSpriteTemplate = // gUnknown_83E38E0 { .tileTag = ANIM_TAG_PURPLE_HAND_OUTLINE, .paletteTag = ANIM_TAG_PURPLE_HAND_OUTLINE, @@ -2009,7 +2038,7 @@ const union AffineAnimCmd *const gSlowFlyingMusicNotesAffineAnimTable[] = gSlowFlyingMusicNotesAffineAnimCmds, }; -const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = +const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = //gUnknown_83E3914 { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -2064,7 +2093,7 @@ const union AnimCmd *const gMetronomeThroughtBubbleAnimTable[] = gMetronomeThroughtBubbleAnimCmds4, }; -const struct SpriteTemplate gThoughtBubbleSpriteTemplate = +const struct SpriteTemplate gThoughtBubbleSpriteTemplate = //gUnknown_83E398C { .tileTag = ANIM_TAG_THOUGHT_BUBBLE, .paletteTag = ANIM_TAG_THOUGHT_BUBBLE, @@ -2110,7 +2139,7 @@ const union AffineAnimCmd *const gMetronomeFingerAffineAnimTable[] = gMetronomeFingerAffineAnimCmds2, }; -const struct SpriteTemplate gMetronomeFingerSpriteTemplate = +const struct SpriteTemplate gMetronomeFingerSpriteTemplate = //gUnknown_83E3A34 { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -2121,7 +2150,7 @@ const struct SpriteTemplate gMetronomeFingerSpriteTemplate = .callback = AnimMetronomeFinger, }; -const struct SpriteTemplate gFollowMeFingerSpriteTemplate = +const struct SpriteTemplate gFollowMeFingerSpriteTemplate = //gUnknown_83E3A4C { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -2176,7 +2205,7 @@ const union AnimCmd *const gTauntFingerAnimTable[] = gTauntFingerAnimCmds4, }; -const struct SpriteTemplate gTauntFingerSpriteTemplate = +const struct SpriteTemplate gTauntFingerSpriteTemplate = //gUnknown_83E3AC4 { .tileTag = ANIM_TAG_FINGER_2, .paletteTag = ANIM_TAG_FINGER_2, @@ -2797,7 +2826,8 @@ static void AnimConstrictBindingStep2(struct Sprite* sprite) } } -void sub_80FF458(u8 taskId) +// Unused +void sub_80A2F0C(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); if (gSprites[spriteId].invisible) @@ -2927,6 +2957,7 @@ void AnimIngrainRoot(struct Sprite* sprite) // arg 3: sprite subpriority offset // arg 4: sprite anum num // arg 5: duration +//sub_80A31EC void AnimFrenzyPlantRoot(struct Sprite *sprite) { s16 attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); @@ -2944,10 +2975,10 @@ void AnimFrenzyPlantRoot(struct Sprite *sprite) StartSpriteAnim(sprite, gBattleAnimArgs[4]); sprite->data[2] = gBattleAnimArgs[5]; sprite->callback = AnimRootFlickerOut; - gUnknown_0203A0F8[0] = sprite->pos1.x; - gUnknown_0203A0F8[1] = sprite->pos1.y; - gUnknown_0203A0F8[2] = targetX; - gUnknown_0203A0F8[3] = targetY; + gUnknown_203999C[0] = sprite->pos1.x; + gUnknown_203999C[1] = sprite->pos1.y; + gUnknown_203999C[2] = targetX; + gUnknown_203999C[3] = targetY; } static void AnimRootFlickerOut(struct Sprite* sprite) @@ -2983,7 +3014,7 @@ void AnimIngrainOrb(struct Sprite* sprite) DestroyAnimSprite(sprite); } -static void sub_80FF9B8(struct Sprite* sprite, s16 c) +static void sub_80A33B8(struct Sprite* sprite, s16 c) { int a = (sprite->pos1.x << 8) | sprite->pos1.y; int b = (sprite->data[6] << 8) | sprite->data[7]; @@ -2993,7 +3024,7 @@ static void sub_80FF9B8(struct Sprite* sprite, s16 c) sprite->data[7] = c; } -bool8 moveAlongLinearPath(struct Sprite* sprite) +bool8 MoveAlongLinearPath(struct Sprite* sprite) { u16 xStartPos = (u8)(sprite->data[5] >> 8); u16 yStartPos = (u8)sprite->data[5]; @@ -3044,7 +3075,7 @@ static void AnimItemStealStep1(struct Sprite* sprite) } sprite->pos2.y = Sin(sprite->data[0] + 128, 30 - sprite->data[1] * 8); - if (moveAlongLinearPath(sprite)) + if (MoveAlongLinearPath(sprite)) { sprite->pos2.y = 0; sprite->data[0] = 0; @@ -3063,14 +3094,14 @@ void AnimPresent(struct Sprite* sprite) { sprite->data[6] = targetX; sprite->data[7] = targetY + 10; - sub_80FF9B8(sprite, 60); + sub_80A33B8(sprite, 60); sprite->data[3] = 1; } else { sprite->data[6] = targetX; sprite->data[7] = targetY + 10; - sub_80FF9B8(sprite, 60); + sub_80A33B8(sprite, 60); sprite->data[3] = 3; } @@ -3078,7 +3109,7 @@ void AnimPresent(struct Sprite* sprite) sprite->callback = AnimItemStealStep1; } -static void sub_80FFB90(struct Sprite* sprite) +static void sub_80A3590(struct Sprite* sprite) { int zero; sprite->data[0] += ((sprite->data[3] * 128) / sprite->data[4]); @@ -3090,7 +3121,7 @@ static void sub_80FFB90(struct Sprite* sprite) } sprite->pos2.y = Sin(sprite->data[0] + 0x80, 30 - sprite->data[1] * 8); - if (moveAlongLinearPath(sprite)) + if (MoveAlongLinearPath(sprite)) { sprite->pos2.y = zero; sprite->data[0] = zero; @@ -3105,7 +3136,7 @@ void AnimKnockOffItem(struct Sprite* sprite) { sprite->data[6] = 0; sprite->data[7] = targetY + 10; - sub_80FF9B8(sprite, 40); + sub_80A33B8(sprite, 40); sprite->data[3] = 3; sprite->data[4] = 60; sprite->callback = AnimItemStealStep1; @@ -3117,10 +3148,10 @@ void AnimKnockOffItem(struct Sprite* sprite) if (IsContest()) sprite->data[6] = 0; - sub_80FF9B8(sprite, 40); + sub_80A33B8(sprite, 40); sprite->data[3] = 3; sprite->data[4] = 60; - sprite->callback = sub_80FFB90; + sprite->callback = sub_80A3590; } } @@ -3154,14 +3185,14 @@ void AnimItemSteal(struct Sprite* sprite) { sprite->data[6] = attackerX; sprite->data[7] = attackerY + 10; - sub_80FF9B8(sprite, 60); + sub_80A33B8(sprite, 60); sprite->data[3] = 1; } else { sprite->data[6] = attackerX; sprite->data[7] = attackerY + 10; - sub_80FF9B8(sprite, 60); + sub_80A33B8(sprite, 60); sprite->data[3] = 3; } @@ -3184,7 +3215,7 @@ static void AnimItemStealStep3(struct Sprite* sprite) if (sprite->pos2.y == 0) PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(63)); - if (moveAlongLinearPath(sprite)) + if (MoveAlongLinearPath(sprite)) { sprite->pos2.y = 0; sprite->data[0] = 0; diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c new file mode 100644 index 000000000..32ed2fba9 --- /dev/null +++ b/src/battle_anim_effects_2.c @@ -0,0 +1,3818 @@ +#include "global.h" +#include "malloc.h" +#include "battle_anim.h" +#include "battle_interface.h" +#include "decompress.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "main.h" +#include "math_util.h" +#include "palette.h" +#include "random.h" +#include "scanline_effect.h" +#include "sound.h" +#include "trig.h" +#include "util.h" +#include "constants/rgb.h" +#include "constants/songs.h" + +void sub_80A6E48(struct Sprite *); +void sub_80A6E98(struct Sprite *); +void sub_80A6F8C(struct Sprite *); +void sub_80A7020(struct Sprite *); +void Anim_KinesisZapEnergy(struct Sprite *); +void Anim_SwordsDanceBlade(struct Sprite *); +void AnimSonicBoomProjectile(struct Sprite *); +void AnimAirWaveProjectile(struct Sprite *); +void sub_80A79E8(struct Sprite *); +void AnimCoinThrow(struct Sprite *); +void AnimFallingCoin(struct Sprite *); +void AnimBulletSeed(struct Sprite *); +void AnimRazorWindTornado(struct Sprite *); +void AnimViceGripPincer(struct Sprite *); +void AnimGuillotinePincer(struct Sprite *); +void AnimBreathPuff(struct Sprite *); +void AnimAngerMark(struct Sprite *); +void AnimPencil(struct Sprite *); +void AnimBlendThinRing(struct Sprite *); +void AnimHyperVoiceRing(struct Sprite *); +void AnimUproarRing(struct Sprite *); +void AnimSoftBoiledEgg(struct Sprite *); +void AnimSpeedDust(struct Sprite *); +void AnimHealBellMusicNote(struct Sprite *); +void AnimMagentaHeart(struct Sprite *); +void AnimRedHeartProjectile(struct Sprite *); +void AnimParticuleBurst(struct Sprite *); +void AnimRedHeartRising(struct Sprite *); +void AnimOrbitFast(struct Sprite *); +void AnimOrbitScatter(struct Sprite *); +void AnimSpitUpOrb(struct Sprite *); +void AnimEyeSparkle(struct Sprite *); +void AnimAngel(struct Sprite *); +void AnimPinkHeart(struct Sprite *); +void AnimDevil(struct Sprite *); +void AnimFurySwipes(struct Sprite *); +void AnimMovmentWaves(struct Sprite *); +void AnimJaggedMusicNote(struct Sprite *); +void AnimPerishSongMusicNote2(struct Sprite *); +void AnimPerishSongMusicNote(struct Sprite *); +void AnimGuardRing(struct Sprite *); +static void sub_80A6ED8(struct Sprite *); +static void sub_80A7058(struct Sprite *); +static void sub_80A7080(struct Sprite *); +static void AnimTask_WithdrawStep(u8); +static void AnimSwordsDanceBladeStep(struct Sprite *); +static void sub_80A7A18(struct Sprite *); +static void AnimFallingCoin_Step(struct Sprite *); +static void AnimBulletSeed_Step1(struct Sprite *); +static void AnimBulletSeed_Step2(struct Sprite *); +static void AnimViceGripPincerStep(struct Sprite *); +static void AnimGuillotinePincerStep1(struct Sprite *); +static void AnimGuillotinePincerStep2(struct Sprite *); +static void AnimGuillotinePincerStep3(struct Sprite *); +static void AnimTask_GrowAndGreyscaleStep(u8); +static void AnimTask_MinimizeStep1(u8); +static void CreateMinimizeSprite(struct Task *, u8); +static void ClonedMinizeSprite_Step(struct Sprite *); +static void AnimTask_SplashStep(u8); +static void AnimTask_GrowAndShrinkStep(u8); +static void ThrashMoveMonStep(u8); +static void ThrashMoveMon(u8); +static void AnimTask_SketchDrawMon(u8); +static void AnimPencil_Step(struct Sprite *); +static void AnimSoftBoiledEgg_Step1(struct Sprite *); +static void AnimSoftBoiledEgg_Step2(struct Sprite *); +static void AnimSoftBoiledEgg_Step3(struct Sprite *); +static void AnimSoftBoiledEgg_Step3_Callback1(struct Sprite *); +static void AnimSoftBoiledEgg_Step3_Callback2(struct Sprite *); +static void AnimSoftBoiledEgg_Step4(struct Sprite *); +static void AnimSoftBoiledEgg_Step4_Callback(struct Sprite *); +static void StretchAttacker_Step(u8); +static void ExtremeSpeedImpact_Step(u8); +static void ExtremeSpeedMonReappear_Step(u8); +static void SpeedDust_Step1(u8); +static void FakeOutStep1(u8); +static void FakeOutStep2(u8); +static void AnimRedHeartProjectile_Step(struct Sprite *); +static void AnimRedHeartRising_Step(struct Sprite *); +static void HeartsBackground_Step(u8); +static void ScaryFace_Step(u8); +static void AnimOrbitFastStep(struct Sprite *); +static void AnimOrbitScatterStep(struct Sprite *); +static void AnimMovmentWaves_Step(struct Sprite *); +static void UproarDistortion_Step(u8); +static void AnimJaggedMusicNote_Step(struct Sprite *); +static void AnimPerishSongMusicNote_Step1(struct Sprite *); +static void AnimPerishSongMusicNote_Step2(struct Sprite *); + +// Data +const struct SpriteTemplate gUnknown_83E3ADC = // Unused +{ + .tileTag = ANIM_TAG_FINGER, + .paletteTag = ANIM_TAG_FINGER, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A6E48, +}; + +const union AnimCmd gUnknown_83E3AF4[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83E3AFC[] = +{ + gUnknown_83E3AF4, +}; + +const struct SpriteTemplate gUnknown_83E3B00 = // Unused +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A6E98, +}; + +const struct SpriteTemplate gUnknown_83E3B18 = // Unused +{ + .tileTag = 0, + .paletteTag = 0, + .oam = &gDummyOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A6F8C, +}; + +extern const union AffineAnimCmd *const gUnknown_83E7910[]; +const struct SpriteTemplate gUnknown_83E3B30 = // Unused +{ + .tileTag = ANIM_TAG_CLAMP, + .paletteTag = ANIM_TAG_CLAMP, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gUnknown_83E7910, + .callback = sub_80A7020, +}; + +const union AnimCmd gUnknown_83E3B48[] = +{ + ANIMCMD_FRAME(0, 9), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83E3B5C[] = +{ + gUnknown_83E3B48, +}; + +const union AffineAnimCmd gUnknown_83E3B60[] = +{ + AFFINEANIMCMD_FRAME(0x50, 0x50, 0, 0), + AFFINEANIMCMD_FRAME(0x9, 0x9, 0, 18), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gUnknown_83E3B78[] = +{ + gUnknown_83E3B60, +}; + +const struct SpriteTemplate gUnknown_83E3B7C = // Unused +{ + .tileTag = ANIM_TAG_EXPLOSION_6, + .paletteTag = ANIM_TAG_EXPLOSION_6, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gUnknown_83E3B5C, + .images = NULL, + .affineAnims = gUnknown_83E3B78, + .callback = AnimSpriteOnMonPos, +}; + +const union AnimCmd gKinesisZapEnergyAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3, .hFlip = TRUE), + ANIMCMD_FRAME(8, 3, .hFlip = TRUE), + ANIMCMD_FRAME(16, 3, .hFlip = TRUE), + ANIMCMD_FRAME(24, 3, .hFlip = TRUE), + ANIMCMD_FRAME(32, 3, .hFlip = TRUE), + ANIMCMD_FRAME(40, 3, .hFlip = TRUE), + ANIMCMD_FRAME(48, 3, .hFlip = TRUE), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd *const gKinesisZapEnergyAnimTable[] = +{ + gKinesisZapEnergyAnimCmds, +}; + +const struct SpriteTemplate gKinesisZapEnergySpriteTemplate = //gUnknown_83E3BBC +{ + .tileTag = ANIM_TAG_ALERT, + .paletteTag = ANIM_TAG_ALERT, + .oam = &gOamData_AffineOff_ObjNormal_32x16, + .anims = gKinesisZapEnergyAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = Anim_KinesisZapEnergy, +}; + +const union AffineAnimCmd gSwordsDanceBladeAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x14, 0x0, 0, 12), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gSwordsDanceBladeAffineAnimTable[] = +{ + gSwordsDanceBladeAffineAnimCmds, +}; + +const struct SpriteTemplate gSwordsDanceBladeSpriteTemplate = //gUnknown_83E3BF8 +{ + .tileTag = ANIM_TAG_SWORD, + .paletteTag = ANIM_TAG_SWORD, + .oam = &gOamData_AffineNormal_ObjBlend_32x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSwordsDanceBladeAffineAnimTable, + .callback = Anim_SwordsDanceBlade, +}; + +const struct SpriteTemplate gSonicBoomSpriteTemplate = //gUnknown_83E3C10 +{ + .tileTag = ANIM_TAG_AIR_WAVE, + .paletteTag = ANIM_TAG_AIR_WAVE, + .oam = &gOamData_AffineDouble_ObjBlend_32x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSonicBoomProjectile, +}; + +const struct SpriteTemplate gAirWaveProjectileSpriteTemplate = //gUnknown_83E3C28 +{ + .tileTag = ANIM_TAG_AIR_WAVE, + .paletteTag = ANIM_TAG_AIR_WAVE, + .oam = &gOamData_AffineOff_ObjBlend_32x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimAirWaveProjectile, +}; + +const union AffineAnimCmd gGrowingRingAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 0), + AFFINEANIMCMD_FRAME(0x7, 0x7, 0, -56), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x5, 0x5, 0, 10), + AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = +{ + gGrowingRingAffineAnimCmds, +}; + +const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = +{ + gWaterPulseRingAffineAnimCmds, +}; + +const struct SpriteTemplate gSupersonicWaveSpriteTemplate = //gUnknown_83E3CA0 +{ + .tileTag = ANIM_TAG_GOLD_RING, + .paletteTag = ANIM_TAG_GOLD_RING, + .oam = &gOamData_AffineDouble_ObjNormal_16x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gGrowingRingAffineAnimTable, + .callback = TranslateAnimSpriteToTargetMonLocation, +}; + +const struct SpriteTemplate gScreechWaveSpriteTemplate = //gUnknown_83E3CB8 +{ + .tileTag = ANIM_TAG_PURPLE_RING, + .paletteTag = ANIM_TAG_PURPLE_RING, + .oam = &gOamData_AffineDouble_ObjNormal_16x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gGrowingRingAffineAnimTable, + .callback = TranslateAnimSpriteToTargetMonLocation, +}; + +const struct SpriteTemplate gMetalSoundSpriteTemplate = //gUnknown_83E3CD0 +{ + .tileTag = ANIM_TAG_METAL_SOUND_WAVES, + .paletteTag = ANIM_TAG_METAL_SOUND_WAVES, + .oam = &gOamData_AffineDouble_ObjNormal_32x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gGrowingRingAffineAnimTable, + .callback = TranslateAnimSpriteToTargetMonLocation, +}; + +const struct SpriteTemplate gWaterPulseRingSpriteTemplate = //gUnknown_83E3CE8 +{ + .tileTag = ANIM_TAG_BLUE_RING_2, + .paletteTag = ANIM_TAG_BLUE_RING_2, + .oam = &gOamData_AffineDouble_ObjNormal_16x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gWaterPulseRingAffineAnimTable, + .callback = AnimWaterPulseRing, +}; + +const struct SpriteTemplate gEggThrowSpriteTemplate = //gUnknown_83E3D00 +{ + .tileTag = ANIM_TAG_LARGE_FRESH_EGG, + .paletteTag = ANIM_TAG_LARGE_FRESH_EGG, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimThrowProjectile, +}; + +const struct SpriteTemplate gUnknown_83E3D18 = +{ + .tileTag = ANIM_TAG_VOID_LINES, + .paletteTag = ANIM_TAG_VOID_LINES, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A79E8, +}; + +const union AnimCmd gCoinAnimCmds[] = +{ + ANIMCMD_FRAME(8, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gCoinAnimTable[] = +{ + gCoinAnimCmds, +}; + +const union AffineAnimCmd gFallingCoinAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 10, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gFallingCoinAffineAnimTable[] = +{ + gFallingCoinAffineAnimCmds, +}; + +const struct SpriteTemplate gCoinThrowSpriteTemplate = //gUnknown_83E3D50 +{ + .tileTag = ANIM_TAG_COIN, + .paletteTag = ANIM_TAG_COIN, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gCoinAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimCoinThrow, +}; + +const struct SpriteTemplate gFallingCoinSpriteTemplate = //gUnknown_83E3D68 +{ + .tileTag = ANIM_TAG_COIN, + .paletteTag = ANIM_TAG_COIN, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gCoinAnimTable, + .images = NULL, + .affineAnims = gFallingCoinAffineAnimTable, + .callback = AnimFallingCoin, +}; + +const union AffineAnimCmd gBulletSeedAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 20, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gBulletSeedAffineAnimTable[] = +{ + gBulletSeedAffineAnimCmds, +}; + +const struct SpriteTemplate gBulletSeedSpriteTemplate = //gUnknown_83E3D94 +{ + .tileTag = ANIM_TAG_SEED, + .paletteTag = ANIM_TAG_SEED, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gBulletSeedAffineAnimTable, + .callback = AnimBulletSeed, +}; + +const union AffineAnimCmd gRazorWindTornadoAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x4, 0x0, 0, 40), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gRazorWindTornadoAffineAnimTable[] = +{ + gRazorWindTornadoAffineAnimCmds, +}; + +const struct SpriteTemplate gRazorWindTornadoSpriteTemplate = //gUnknown_83E3DC8 +{ + .tileTag = ANIM_TAG_GUST, + .paletteTag = ANIM_TAG_GUST, + .oam = &gOamData_AffineNormal_ObjNormal_32x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gRazorWindTornadoAffineAnimTable, + .callback = AnimRazorWindTornado, +}; + +const union AnimCmd gViceGripAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 20), + ANIMCMD_END, +}; + +const union AnimCmd gViceGripAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 3, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(16, 3, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(32, 20, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gViceGripAnimTable[] = +{ + gViceGripAnimCmds1, + gViceGripAnimCmds2, +}; + +const struct SpriteTemplate gViceGripSpriteTemplate = //gUnknown_83E3E08 +{ + .tileTag = ANIM_TAG_CUT, + .paletteTag = ANIM_TAG_CUT, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gViceGripAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimViceGripPincer, +}; + +const union AnimCmd gGuillotineAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(32, 1), + ANIMCMD_END, +}; + +const union AnimCmd gGuillotineAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 2, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(16, 2, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(32, 1, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gGuillotineAnimTable[] = +{ + gGuillotineAnimCmds1, + gGuillotineAnimCmds2, +}; + +const struct SpriteTemplate gGuillotineSpriteTemplate = //gUnknown_83E3E48 +{ + .tileTag = ANIM_TAG_CUT, + .paletteTag = ANIM_TAG_CUT, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gGuillotineAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimGuillotinePincer, +}; + +const union AffineAnimCmd gSplashEffectAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-6, 4, 0, 8), + AFFINEANIMCMD_FRAME(10, -10, 0, 8), + AFFINEANIMCMD_FRAME(-4, 6, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gGrowAndShrinkAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-4, -5, 0, 12), + AFFINEANIMCMD_FRAME(0, 0, 0, 24), + AFFINEANIMCMD_FRAME(4, 5, 0, 12), + AFFINEANIMCMD_END, +}; + +const union AnimCmd gBreathPuffAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(4, 40, .hFlip = TRUE), + ANIMCMD_FRAME(8, 4, .hFlip = TRUE), + ANIMCMD_FRAME(12, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gBreathPuffAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(4, 40), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(12, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gBreathPuffAnimTable[] = +{ + gBreathPuffAnimCmds1, + gBreathPuffAnimCmds2, +}; + +const struct SpriteTemplate gBreathPuffSpriteTemplate = //gUnknown_83E3ED0 +{ + .tileTag = ANIM_TAG_BREATH, + .paletteTag = ANIM_TAG_BREATH, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gBreathPuffAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBreathPuff, +}; + +const union AffineAnimCmd gAngerMarkAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0xB, 0xB, 0, 8), + AFFINEANIMCMD_FRAME(0xFFF5, 0xFFF5, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gAngerMarkAffineAnimTable[] = +{ + gAngerMarkAffineAnimCmds, +}; + +const struct SpriteTemplate gAngerMarkSpriteTemplate = //gUnknown_83E3F04 +{ + .tileTag = ANIM_TAG_ANGER, + .paletteTag = ANIM_TAG_ANGER, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gAngerMarkAffineAnimTable, + .callback = AnimAngerMark, +}; + +const union AffineAnimCmd gThrashMoveMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-10, 9, 0, 7), + AFFINEANIMCMD_FRAME(20, -20, 0, 7), + AFFINEANIMCMD_FRAME(-20, 20, 0, 7), + AFFINEANIMCMD_FRAME(10, -9, 0, 7), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gPencilSpriteTemplate = //gUnknown_83E3F4C +{ + .tileTag = ANIM_TAG_PENCIL, + .paletteTag = ANIM_TAG_PENCIL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPencil, +}; + +const struct SpriteTemplate gSnoreZSpriteTemplate = //gUnknown_83E3F64 +{ + .tileTag = ANIM_TAG_SNORE_Z, + .paletteTag = ANIM_TAG_SNORE_Z, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSnoreZ, +}; + +const union AnimCmd gExplosionAnimCmds[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(32, 5), + ANIMCMD_FRAME(48, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gExplosionAnimTable[] = +{ + gExplosionAnimCmds, +}; + +const struct SpriteTemplate gExplosionSpriteTemplate = //gUnknown_83E3F94 +{ + .tileTag = ANIM_TAG_EXPLOSION, + .paletteTag = ANIM_TAG_EXPLOSION, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gExplosionAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 2), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 4), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 2), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = +{ + AFFINEANIMCMD_FRAME(0xFFF8, 0x4, 0, 8), + AFFINEANIMCMD_LOOP(0), + AFFINEANIMCMD_FRAME(0x10, 0xFFF8, 0, 8), + AFFINEANIMCMD_FRAME(0xFFF0, 0x8, 0, 8), + AFFINEANIMCMD_LOOP(1), + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 15), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gSoftBoiledEggAffineAnimTable[] = +{ + gSoftBoiledEggAffineAnimCmds1, + gSoftBoiledEggAffineAnimCmds2, + gSoftBoiledEggAffineAnimCmds3, +}; + +const struct SpriteTemplate gSoftBoiledEggSpriteTemplate = //gUnknown_83E4028 +{ + .tileTag = ANIM_TAG_BREAKING_EGG, + .paletteTag = ANIM_TAG_BREAKING_EGG, + .oam = &gOamData_AffineDouble_ObjBlend_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSoftBoiledEggAffineAnimTable, + .callback = AnimSoftBoiledEgg, +}; + +const union AffineAnimCmd gThinRingExpandingAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 30), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd gThinRingExpandingAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), + AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 15), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd gHyperVoiceRingAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), + AFFINEANIMCMD_FRAME(0xB, 0xB, 0, 45), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd *const gThinRingExpandingAffineAnimTable[] = +{ + gThinRingExpandingAffineAnimCmds1, + gThinRingExpandingAffineAnimCmds2, +}; + +const union AffineAnimCmd *const gHyperVoiceRingAffineAnimTable[] = +{ + gHyperVoiceRingAffineAnimCmds, +}; + +const struct SpriteTemplate gThinRingExpandingSpriteTemplate = //gUnknown_83E4094 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gThinRingExpandingAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const union AffineAnimCmd gThinRingShrinkingAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), + AFFINEANIMCMD_FRAME(0xFFF0, 0xFFF0, 0, 30), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd *const gThinRingShrinkingAffineAnimTable[] = +{ + gThinRingShrinkingAffineAnimCmds, +}; + +const struct SpriteTemplate gThinRingShrinkingSpriteTemplate = //gUnknown_83E40C8 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gThinRingShrinkingAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const struct SpriteTemplate gBlendThinRingExpandingSpriteTemplate = //gUnknown_83E40E0 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gThinRingExpandingAffineAnimTable, + .callback = AnimBlendThinRing, +}; + +const struct SpriteTemplate gHyperVoiceRingSpriteTemplate = //gUnknown_83E40F8 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gHyperVoiceRingAffineAnimTable, + .callback = AnimHyperVoiceRing, +}; + +const struct SpriteTemplate gUproarRingSpriteTemplate = //gUnknown_83E4110 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gThinRingExpandingAffineAnimTable, + .callback = AnimUproarRing, +}; + +const union AffineAnimCmd gStretchAttackerAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(96, -13, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AnimCmd gSpeedDustAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(4, 3), + ANIMCMD_FRAME(8, 3), + ANIMCMD_FRAME(4, 3), + ANIMCMD_FRAME(0, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gSpeedDustAnimTable[] = +{ + gSpeedDustAnimCmds, +}; + +const struct SpriteTemplate gSpeedDustSpriteTemplate = //gUnknown_83E4154 +{ + .tileTag = ANIM_TAG_SPEED_DUST, + .paletteTag = ANIM_TAG_SPEED_DUST, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gSpeedDustAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpeedDust, +}; + +const s8 gSpeedDustPosTable[][2] = +{ + {30, 28}, + {-20, 24}, + {16, 26}, + {-10, 28}, +}; + +const union AnimCmd gBellAnimCmds[] = +{ + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(32, 15), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 6, .hFlip = TRUE), + ANIMCMD_FRAME(32, 15, .hFlip = TRUE), + ANIMCMD_FRAME(16, 6, .hFlip = TRUE), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(32, 15), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(0, 6), + ANIMCMD_END, +}; + +const union AnimCmd *const gBellAnimTable[] = +{ + gBellAnimCmds, +}; + +const struct SpriteTemplate gBellSpriteTemplate = //gUnknown_83E41B0 +{ + .tileTag = ANIM_TAG_BELL, + .paletteTag = ANIM_TAG_BELL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gBellAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const u16 gMusicNotePaletteTagsTable[] = +{ + ANIM_TAG_MUSIC_NOTES_2, + ANIM_SPRITES_START - 1, + ANIM_SPRITES_START - 2, +}; + +const struct SpriteTemplate gHealBellMusicNoteSpriteTemplate = //gUnknown_83E41D0 +{ + .tileTag = ANIM_TAG_MUSIC_NOTES_2, + .paletteTag = ANIM_TAG_MUSIC_NOTES_2, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimHealBellMusicNote, +}; + +const struct SpriteTemplate gMagentaHeartSpriteTemplate = //gUnknown_83E41E8 +{ + .tileTag = ANIM_TAG_MAGENTA_HEART, + .paletteTag = ANIM_TAG_MAGENTA_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMagentaHeart, +}; + +const union AffineAnimCmd gUnknown_83E4200[] = +{ + AFFINEANIMCMD_FRAME(0x000A, 0xFFF3, 0x00, 0x0A), + AFFINEANIMCMD_FRAME(0xFFF6, 0x000D, 0x00, 0x0A), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gRedHeartProjectileSpriteTemplate = //gUnknown_83E4218 +{ + .tileTag = ANIM_TAG_RED_HEART, + .paletteTag = ANIM_TAG_RED_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRedHeartProjectile, +}; + +const struct SpriteTemplate gRedHeartBurstSpriteTemplate = //gUnknown_83E4230 +{ + .tileTag = ANIM_TAG_RED_HEART, + .paletteTag = ANIM_TAG_RED_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimParticuleBurst, +}; + +const struct SpriteTemplate gRedHeartRisingSpriteTemplate = //gUnknown_83E4248 +{ + .tileTag = ANIM_TAG_RED_HEART, + .paletteTag = ANIM_TAG_RED_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRedHeartRising, +}; + +const union AffineAnimCmd gHiddenPowerOrbAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), + AFFINEANIMCMD_FRAME(0x8, 0x8, 0, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gHiddenPowerOrbAffineAnimTable[] = +{ + gHiddenPowerOrbAffineAnimCmds, +}; + +const struct SpriteTemplate gHiddenPowerOrbSpriteTemplate = //gUnknown_83E427C +{ + .tileTag = ANIM_TAG_RED_ORB, + .paletteTag = ANIM_TAG_RED_ORB, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gHiddenPowerOrbAffineAnimTable, + .callback = AnimOrbitFast, +}; + +const struct SpriteTemplate gHiddenPowerOrbScatterSpriteTemplate = //gUnknown_83E4294 +{ + .tileTag = ANIM_TAG_RED_ORB, + .paletteTag = ANIM_TAG_RED_ORB, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gHiddenPowerOrbAffineAnimTable, + .callback = AnimOrbitScatter, +}; + +const union AffineAnimCmd gSpitUpOrbAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), + AFFINEANIMCMD_FRAME(0x8, 0x8, 0, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gSpitUpOrbAffineAnimTable[] = +{ + gSpitUpOrbAffineAnimCmds, +}; + +const struct SpriteTemplate gSpitUpOrbSpriteTemplate = //gUnknown_83E42C8 +{ + .tileTag = ANIM_TAG_RED_ORB_2, + .paletteTag = ANIM_TAG_RED_ORB_2, + .oam = &gOamData_AffineDouble_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSpitUpOrbAffineAnimTable, + .callback = AnimSpitUpOrb, +}; + +const union AnimCmd gEyeSparkleAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gEyeSparkleAnimTable[] = +{ + gEyeSparkleAnimCmds, +}; + +const struct SpriteTemplate gEyeSparkleSpriteTemplate = //gUnknown_83E42FC +{ + .tileTag = ANIM_TAG_EYE_SPARKLE, + .paletteTag = ANIM_TAG_EYE_SPARKLE, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gEyeSparkleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimEyeSparkle, +}; + +const union AnimCmd gAngelSpriteAnimCmds[] = +{ + ANIMCMD_FRAME(0, 24), + ANIMCMD_END, +}; + +const union AnimCmd *const gAngelSpriteAnimTable[] = +{ + gAngelSpriteAnimCmds, +}; + +const struct SpriteTemplate gAngelSpriteTemplate = //gUnknown_83E4320 +{ + .tileTag = ANIM_TAG_ANGEL, + .paletteTag = ANIM_TAG_ANGEL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gAngelSpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimAngel, +}; + +const struct SpriteTemplate gPinkHeartSpriteTemplate = //gUnknown_83E4338 +{ + .tileTag = ANIM_TAG_PINK_HEART, + .paletteTag = ANIM_TAG_PINK_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPinkHeart, +}; + +const union AnimCmd gDevilAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gDevilAnimCmds2[] = +{ + ANIMCMD_FRAME(16, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gDevilAnimTable[] = +{ + gDevilAnimCmds1, + gDevilAnimCmds2, +}; + +const struct SpriteTemplate gDevilSpriteTemplate = //gUnknown_83E4368 +{ + .tileTag = ANIM_TAG_DEVIL, + .paletteTag = ANIM_TAG_DEVIL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDevilAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimDevil, +}; + +const union AnimCmd gUnknown_08593B08[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08593B1C[] = +{ + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(16, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_FRAME(48, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gFurySwipesAnimTable[] = +{ + gUnknown_08593B08, + gUnknown_08593B1C, +}; + +const struct SpriteTemplate gFurySwipesSpriteTemplate = //gUnknown_83E43B0 +{ + .tileTag = ANIM_TAG_SWIPE, + .paletteTag = ANIM_TAG_SWIPE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gFurySwipesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFurySwipes, +}; + +const union AnimCmd gMovementWavesAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(16, 8), + ANIMCMD_FRAME(32, 8), + ANIMCMD_FRAME(16, 8), + ANIMCMD_END, +}; + +const union AnimCmd gMovementWavesAnimCmds2[] = +{ + ANIMCMD_FRAME(16, 8, .hFlip = TRUE), + ANIMCMD_FRAME(32, 8, .hFlip = TRUE), + ANIMCMD_FRAME(16, 8, .hFlip = TRUE), + ANIMCMD_FRAME(0, 8, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gMovementWavesAnimTable[] = +{ + gMovementWavesAnimCmds1, + gMovementWavesAnimCmds2, +}; + +const struct SpriteTemplate gMovementWavesSpriteTemplate = //gUnknown_83E43F8 +{ + .tileTag = ANIM_TAG_MOVEMENT_WAVES, + .paletteTag = ANIM_TAG_MOVEMENT_WAVES, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gMovementWavesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMovmentWaves, +}; + +const union AffineAnimCmd gUnknown_08593B98[] = +{ + AFFINEANIMCMD_FRAME(-12, 8, 0, 4), + AFFINEANIMCMD_FRAME(20, -20, 0, 4), + AFFINEANIMCMD_FRAME(-8, 12, 0, 4), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gJaggedMusicNoteSpriteTemplate = //gUnknown_83E4430 +{ + .tileTag = ANIM_TAG_JAGGED_MUSIC_NOTE, + .paletteTag = ANIM_TAG_JAGGED_MUSIC_NOTE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimJaggedMusicNote, +}; + +const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 5), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 16), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds3[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 16), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd *const gPerishSongMusicNoteAffineAnimTable[] = +{ + gPerishSongMusicNoteAffineAnimCmds1, + gPerishSongMusicNoteAffineAnimCmds2, + gPerishSongMusicNoteAffineAnimCmds3, +}; + +extern const union AnimCmd *const gMusicNotesAnimTable[]; +const struct SpriteTemplate gPerishSongMusicNoteSpriteTemplate = //gUnknown_83E4484 +{ + .tileTag = ANIM_TAG_MUSIC_NOTES_2, + .paletteTag = ANIM_TAG_MUSIC_NOTES_2, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gPerishSongMusicNoteAffineAnimTable, + .callback = AnimPerishSongMusicNote, +}; + +const struct SpriteTemplate gPerishSongMusicNote2SpriteTemplate = //gUnknown_83E449C +{ + .tileTag = ANIM_TAG_MUSIC_NOTES_2, + .paletteTag = ANIM_TAG_MUSIC_NOTES_2, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gPerishSongMusicNoteAffineAnimTable, + .callback = AnimPerishSongMusicNote2, +}; + +const union AffineAnimCmd gGuardRingAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gGuardRingAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x200, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gGuardRingAffineAnimTable[] = +{ + gGuardRingAffineAnimCmds1, + gGuardRingAffineAnimCmds2, +}; + +const struct SpriteTemplate gGuardRingSpriteTemplate = //gUnknown_83E44DC +{ + .tileTag = ANIM_TAG_GUARD_RING, + .paletteTag = ANIM_TAG_GUARD_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gGuardRingAffineAnimTable, + .callback = AnimGuardRing, +}; + +// Functions +void sub_80A6E48(struct Sprite *sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[4]; + sprite->data[3] = gBattleAnimArgs[5]; + sprite->data[4] = gBattleAnimArgs[3]; + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); + sprite->callback = TranslateSpriteInEllipseOverDuration; + sprite->callback(sprite); +} + +void sub_80A6E98(struct Sprite *sprite) +{ + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + SetSpriteNextToMonHead(battler, sprite); + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->callback = sub_80A6ED8; +} + +static void sub_80A6ED8(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->pos2.y -= 3; + if (++sprite->data[1] == 6) + sprite->data[0]++; + break; + case 1: + sprite->pos2.y += 3; + if (--sprite->data[1] == 0) + sprite->data[0]++; + break; + case 2: + if (++sprite->data[1] == 64) + DestroyAnimSprite(sprite); + break; + } +} + +static void sub_80A6F3C(struct Sprite *sprite) +{ + s16 temp; + gSprites[sprite->data[2]].pos2.x += sprite->data[1]; + temp = sprite->data[1]; + sprite->data[1] = -temp; + if (sprite->data[0] == 0) + { + gSprites[sprite->data[2]].pos2.x = 0; + DestroySpriteAndMatrix(sprite); + } + + sprite->data[0]--; +} + +void sub_80A6F8C(struct Sprite *sprite) +{ + u8 spriteId; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + spriteId = gBattlerSpriteIds[gBattleAnimTarget]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x -= gBattleAnimArgs[0]; + else + sprite->pos1.x += gBattleAnimArgs[0]; + + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[2] = spriteId; + sprite->callback = sub_80A6F3C; + sprite->invisible = 1; +} + +void sub_80A7020(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[5] = gBattleAnimArgs[4]; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, sub_80A7058); +} + +static void sub_80A7058(struct Sprite *sprite) +{ + sprite->data[0] = sprite->data[1]; + sprite->data[2] = sprite->pos1.x; + sprite->data[4] = sprite->pos1.y + 15; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, sub_80A7080); +} + +static void sub_80A7080(struct Sprite *sprite) +{ + if (sprite->data[5] == 0) + DestroyAnimSprite(sprite); + else + sprite->data[5]--; +} + +// Rotates the attacking mon sprite downwards and then back upwards to its original position. +// No args. +void AnimTask_Withdraw(u8 taskId) +{ + PrepareBattlerSpriteForRotScale(gBattlerSpriteIds[gBattleAnimAttacker], ST_OAM_OBJ_NORMAL); + gTasks[taskId].func = AnimTask_WithdrawStep; +} + +static void AnimTask_WithdrawStep(u8 taskId) +{ + u8 spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + s16 rotation; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + rotation = -gTasks[taskId].data[0]; + else + rotation = gTasks[taskId].data[0]; + + SetSpriteRotScale(spriteId, 0x100, 0x100, rotation); + if (gTasks[taskId].data[1] == 0) + { + gTasks[taskId].data[0] += 0xB0; + // this y position update gets overwritten by SetBattlerSpriteYOffsetFromRotation() + gSprites[spriteId].pos2.y++; + } + else if (gTasks[taskId].data[1] == 1) + { + if (++gTasks[taskId].data[3] == 30) + gTasks[taskId].data[1] = 2; + + return; + } + else + { + gTasks[taskId].data[0] -= 0xB0; + // this y position update gets overwritten by SetBattlerSpriteYOffsetFromRotation() + gSprites[spriteId].pos2.y--; + } + + SetBattlerSpriteYOffsetFromRotation(spriteId); + if (gTasks[taskId].data[0] == 0xF20 || gTasks[taskId].data[0] == 0) + { + if (gTasks[taskId].data[1] == 2) + { + ResetSpriteRotScale(spriteId); + DestroyAnimVisualTask(taskId); + } + else + { + gTasks[taskId].data[1]++; + } + } +} + +// Animates a "zap of energy" used in KINESIS. +// arg 0: x pixel offset +// arg 1: y pixel offset +// arg 2: vertical flip +void Anim_KinesisZapEnergy(struct Sprite *sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x -= gBattleAnimArgs[0]; + else + sprite->pos1.x += gBattleAnimArgs[0]; + + sprite->pos1.y += gBattleAnimArgs[1]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->hFlip = 1; + if (gBattleAnimArgs[2]) + sprite->vFlip = 1; + } + else + { + if (gBattleAnimArgs[2]) + sprite->vFlip = 1; + } + + sprite->callback = RunStoredCallbackWhenAnimEnds; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Animates a sword that rises into the air after a brief pause. +// arg 0: x pixel offset +// arg 1: y pixel offset +void Anim_SwordsDanceBlade(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; + StoreSpriteCallbackInData6(sprite, AnimSwordsDanceBladeStep); +} + +static void AnimSwordsDanceBladeStep(struct Sprite *sprite) +{ + sprite->data[0] = 6; + sprite->data[2] = sprite->pos1.x; + sprite->data[4] = sprite->pos1.y - 32; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Moves a projectile towards the target mon. The sprite is rotated to be pointing +// in the same direction it's moving. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: target x pixel offset +// arg 3: target y pixel offset +// arg 4: duration +void AnimSonicBoomProjectile(struct Sprite *sprite) +{ + s16 targetXPos; + s16 targetYPos; + u16 rotation; + + if (IsContest()) + { + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + } + else if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + gBattleAnimArgs[3] = -gBattleAnimArgs[3]; + } + + InitSpritePosToAnimAttacker(sprite, TRUE); + targetXPos = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[2]; + targetYPos = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[3]; + rotation = ArcTan2Neg(targetXPos - sprite->pos1.x, targetYPos - sprite->pos1.y); + rotation += 0xF000; + if (IsContest()) + rotation -= 0x6000; + + TrySetSpriteRotScale(sprite, FALSE, 0x100, 0x100, rotation); + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = targetXPos; + sprite->data[4] = targetYPos; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +static void AnimAirWaveProjectile_Step2(struct Sprite *sprite) +{ + if (sprite->data[0]-- <= 0) + { + gTasks[sprite->data[7]].data[1]--; + DestroySprite(sprite); + } +} + +static void AnimAirWaveProjectile_Step1(struct Sprite *sprite) +{ + struct Task* task = &gTasks[sprite->data[7]]; + if (sprite->data[0] > task->data[5]) + { + sprite->data[5] += sprite->data[3]; + sprite->data[6] += sprite->data[4]; + } + else + { + sprite->data[5] -= sprite->data[3]; + sprite->data[6] -= sprite->data[4]; + } + + sprite->data[1] += sprite->data[5]; + sprite->data[2] += sprite->data[6]; + if (1 & task->data[7]) + sprite->pos2.x = ((u16)sprite->data[1] >> 8) * -1; + else + sprite->pos2.x = (u16)sprite->data[1] >> 8; + + if (1 & task->data[8]) + sprite->pos2.y = ((u16)sprite->data[2] / 256u) * -1; + else + sprite->pos2.y = (u16)sprite->data[2] / 256u; + + if (sprite->data[0]-- <= 0) + { + sprite->data[0] = 30; + sprite->callback = AnimAirWaveProjectile_Step2; + } +} + +void AnimAirWaveProjectile(struct Sprite *sprite) +{ + s16 a; + s16 b; + s16 c; + + struct Task* task = &gTasks[sprite->data[7]]; + sprite->data[1] += (-2 & task->data[7]); + sprite->data[2] += (-2 & task->data[8]); + if (1 & task->data[7]) + sprite->pos2.x = ((u16)sprite->data[1] >> 8) * -1; + else + sprite->pos2.x = (u16)sprite->data[1] >> 8; + + if (1 & task->data[8]) + sprite->pos2.y = ((u16)sprite->data[2] / 256u) * -1; + else + sprite->pos2.y = (u16)sprite->data[2] / 256u; + + if (sprite->data[0]-- <= 0) + { + sprite->data[0] = 8; + task->data[5] = 4; + a = sub_80D8B90(0x1000); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + if (task->data[11] >= sprite->pos1.x) + b = (task->data[11] - sprite->pos1.x) << 8; + else + b = (sprite->pos1.x - task->data[11]) << 8; + + if (task->data[12] >= sprite->pos1.y) + c = (task->data[12] - sprite->pos1.y) << 8; + else + c = (sprite->pos1.y - task->data[12]) << 8; + + sprite->data[2] = 0; + sprite->data[1] = 0; + sprite->data[6] = 0; + sprite->data[5] = 0; + sprite->data[3] = sub_80D8AA0(sub_80D8AA0(b, a), sub_80D8B90(0x1C0)); + sprite->data[4] = sub_80D8AA0(sub_80D8AA0(c, a), sub_80D8B90(0x1C0)); + sprite->callback = AnimAirWaveProjectile_Step1; + } +} + +static void AirCutterProjectileStep2(u8 taskId) +{ + if (gTasks[taskId].data[1] == 0) + DestroyAnimVisualTask(taskId); +} + +static void AirCutterProjectileStep1(u8 taskId) +{ + if (gTasks[taskId].data[0]-- <= 0) + { + u8 spriteId; + struct Sprite *sprite; + spriteId = CreateSprite(&gAirWaveProjectileSpriteTemplate, gTasks[taskId].data[9], gTasks[taskId].data[10], gTasks[taskId].data[2] - gTasks[taskId].data[1]); + sprite = &gSprites[spriteId]; + switch (gTasks[taskId].data[4]) + { + case 1: + sprite->oam.matrixNum |= (ST_OAM_HFLIP | ST_OAM_VFLIP); + break; + case 2: + sprite->oam.matrixNum = ST_OAM_HFLIP; + break; + } + + sprite->data[0] = gTasks[taskId].data[5] - gTasks[taskId].data[6]; + sprite->data[7] = taskId; + gTasks[taskId].data[gTasks[taskId].data[1] + 13] = spriteId; + gTasks[taskId].data[0] = gTasks[taskId].data[3]; + gTasks[taskId].data[1]++; + PlaySE12WithPanning(SE_W059B, BattleAnimAdjustPanning(-63)); + if (gTasks[taskId].data[1] > 2) + gTasks[taskId].func = AirCutterProjectileStep2; + } +} + +void AnimTask_AirCutterProjectile(u8 taskId) +{ + s16 attackerY = 0; + s16 attackerX = 0; + s16 targetX = 0; + s16 targetY = 0; + s16 xDiff, yDiff; + + if (IsContest()) + { + gTasks[taskId].data[4] = 2; + gBattleAnimArgs[0] = -gBattleAnimArgs[0]; + if (gBattleAnimArgs[2] & 1) + gBattleAnimArgs[2] &= ~1; + else + gBattleAnimArgs[2] |= 1; + } + else + { + if ((gBattlerPositions[gBattleAnimTarget] & BIT_SIDE) == B_SIDE_PLAYER) + { + gTasks[taskId].data[4] = 1; + gBattleAnimArgs[0] = -gBattleAnimArgs[0]; + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + if (gBattleAnimArgs[2] & 1) + gBattleAnimArgs[2] &= ~1; + else + gBattleAnimArgs[2] |= 1; + } + } + + attackerX = gTasks[taskId].data[9] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + attackerY = gTasks[taskId].data[10] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + && IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget))) + { + SetAverageBattlerPositions(gBattleAnimTarget, 0, &targetX, &targetY); + } + else + { + targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); + } + + targetX = gTasks[taskId].data[11] = targetX + gBattleAnimArgs[0]; + targetY = gTasks[taskId].data[12] = targetY + gBattleAnimArgs[1]; + if (targetX >= attackerX) + xDiff = targetX - attackerX; + else + xDiff = attackerX - targetX; + + gTasks[taskId].data[5] = sub_80D8AA0(xDiff, sub_80D8B90(gBattleAnimArgs[2] & ~1)); + gTasks[taskId].data[6] = sub_80D8AA0(gTasks[taskId].data[5], 0x80); + gTasks[taskId].data[7] = gBattleAnimArgs[2]; + if (targetY >= attackerY) + { + yDiff = targetY - attackerY; + gTasks[taskId].data[8] = sub_80D8AA0(yDiff, sub_80D8B90(gTasks[taskId].data[5])) & ~1; + } + else + { + yDiff = attackerY - targetY; + gTasks[taskId].data[8] = sub_80D8AA0(yDiff, sub_80D8B90(gTasks[taskId].data[5])) | 1; + } + + gTasks[taskId].data[3] = gBattleAnimArgs[3]; + if (gBattleAnimArgs[4] & 0x80) + { + gBattleAnimArgs[4] ^= 0x80; + if (gBattleAnimArgs[4] >= 64) + { + u16 var = GetBattlerSpriteSubpriority(gBattleAnimTarget) + (gBattleAnimArgs[4] - 64); + gTasks[taskId].data[2] = var; + } + else + { + u16 var = GetBattlerSpriteSubpriority(gBattleAnimTarget) - gBattleAnimArgs[4]; + gTasks[taskId].data[2] = var; + } + } + else + { + if (gBattleAnimArgs[4] >= 64) + { + u16 var = GetBattlerSpriteSubpriority(gBattleAnimTarget) + (gBattleAnimArgs[4] - 64); + gTasks[taskId].data[2] = var; + } + else + { + u16 var = GetBattlerSpriteSubpriority(gBattleAnimTarget) - gBattleAnimArgs[4]; + gTasks[taskId].data[2] = var; + } + } + + if (gTasks[taskId].data[2] < 3) + gTasks[taskId].data[2] = 3; + + gTasks[taskId].func = AirCutterProjectileStep1; +} + +void sub_80A79E8(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + sprite->data[0] = 0x100 + (IndexOfSpritePaletteTag(gUnknown_83E3D18.paletteTag) << 4); + sprite->callback = sub_80A7A18; +} + +static void sub_80A7A18(struct Sprite *sprite) +{ + u16 id, val; + int i; + + if (++sprite->data[1] == 2) + { + sprite->data[1] = 0; + id = sprite->data[0]; + val = gPlttBufferFaded[8 + id]; + for (i = 8; i < 16; i++) + gPlttBufferFaded[i + id] = gPlttBufferFaded[i + id + 1]; + + gPlttBufferFaded[id + 15] = val; + + if (++sprite->data[2] == 24) + DestroyAnimSprite(sprite); + } +} + +void AnimCoinThrow(struct Sprite *sprite) +{ + s16 r6; + s16 r7; + u16 var; + + InitSpritePosToAnimAttacker(sprite, TRUE); + r6 = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + r7 = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[3]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + r6 += gBattleAnimArgs[2]; + var = ArcTan2Neg(r6 - sprite->pos1.x, r7 - sprite->pos1.y); + var += 0xC000; + TrySetSpriteRotScale(sprite, FALSE, 0x100, 0x100, var); + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = r6; + sprite->data[4] = r7; + sprite->callback = sub_80756A4; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimFallingCoin(struct Sprite *sprite) +{ + sprite->data[2] = -16; + sprite->pos1.y += 8; + sprite->callback = AnimFallingCoin_Step; +} + +static void AnimFallingCoin_Step(struct Sprite *sprite) +{ + sprite->data[0] += 0x80; + sprite->pos2.x = sprite->data[0] >> 8; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + sprite->pos2.x = -sprite->pos2.x; + + sprite->pos2.y = Sin(sprite->data[1], sprite->data[2]); + sprite->data[1] += 5; + if (sprite->data[1] > 126) + { + sprite->data[1] = 0; + sprite->data[2] /= 2; + if (++sprite->data[3] == 2) + DestroyAnimSprite(sprite); + } +} + +void AnimBulletSeed(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = 20; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + sprite->callback = StartAnimLinearTranslation; + sprite->affineAnimPaused = 1; + StoreSpriteCallbackInData6(sprite, AnimBulletSeed_Step1); +} + +static void AnimBulletSeed_Step1(struct Sprite *sprite) +{ + int i; + u16 rand; + s16* ptr; + PlaySE12WithPanning(SE_W030, BattleAnimAdjustPanning(63)); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + ptr = &sprite->data[7]; + for (i = 0; i < 8; i++) + ptr[i - 7] = 0; + + rand = Random2(); + sprite->data[6] = 0xFFF4 - (rand & 7); + rand = Random2(); + sprite->data[7] = (rand % 0xA0) + 0xA0; + sprite->callback = AnimBulletSeed_Step2; + sprite->affineAnimPaused = 0; +} + +static void AnimBulletSeed_Step2(struct Sprite *sprite) +{ + sprite->data[0] += sprite->data[7]; + sprite->pos2.x = sprite->data[0] >> 8; + if (sprite->data[7] & 1) + sprite->pos2.x = -sprite->pos2.x; + + sprite->pos2.y = Sin(sprite->data[1], sprite->data[6]); + sprite->data[1] += 8; + if (sprite->data[1] > 126) + { + sprite->data[1] = 0; + sprite->data[2] /= 2; + if (++sprite->data[3] == 1) + DestroyAnimSprite(sprite); + } +} + +// Moves a tornado in a circlular motion. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: wave amplitude +// arg 3: unused +// arg 4: initial wave offset +// arg 5: wave period (higher means faster wave) +// arg 6: duration +void AnimRazorWindTornado(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + sprite->pos1.y += 16; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[5]; + sprite->data[3] = gBattleAnimArgs[6]; + sprite->data[4] = gBattleAnimArgs[3]; + sprite->callback = TranslateSpriteInCircleOverDuration; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback(sprite); +} + +// Animates a single pincer line that extends towards the center of the target mon. +// arg 0: invert +void AnimViceGripPincer(struct Sprite *sprite) +{ + s16 startXOffset = 32; + s16 startYOffset = -32; + s16 endXOffset = 16; + s16 endYOffset = -16; + if (gBattleAnimArgs[0]) + { + startXOffset = -32; + startYOffset = 32; + endXOffset = -16; + endYOffset = 16; + StartSpriteAnim(sprite, 1); + } + + sprite->pos1.x += startXOffset; + sprite->pos1.y += startYOffset; + sprite->data[0] = 6; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + endXOffset; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + endYOffset; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, AnimViceGripPincerStep); +} + +static void AnimViceGripPincerStep(struct Sprite *sprite) +{ + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +// Animates a single pincer line that extends towards the center of the target mon, and then back out. +// arg 0: animation id +void AnimGuillotinePincer(struct Sprite *sprite) +{ + s16 startXOffset = 32; + s16 startYOffset = -32; + s16 endXOffset = 16; + s16 endYOffset = -16; + if (gBattleAnimArgs[0]) + { + startXOffset = -32; + startYOffset = 32; + endXOffset = -16; + endYOffset = 16; + StartSpriteAnim(sprite, gBattleAnimArgs[0]); + } + + sprite->pos1.x += startXOffset; + sprite->pos1.y += startYOffset; + sprite->data[0] = 6; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + endXOffset; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + endYOffset; + InitAnimLinearTranslation(sprite); + sprite->data[5] = gBattleAnimArgs[0]; + sprite->data[6] = sprite->data[0]; + sprite->callback = AnimGuillotinePincerStep1; +} + +static void AnimGuillotinePincerStep1(struct Sprite *sprite) +{ + if (AnimTranslateLinear(sprite) && sprite->animEnded) + { + SeekSpriteAnim(sprite, 0); + sprite->animPaused = 1; + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 2; + sprite->pos2.y = -2; + sprite->data[0] = sprite->data[6]; + sprite->data[1] ^= 1; + sprite->data[2] ^= 1; + sprite->data[4] = 0; + sprite->data[3] = 0; + sprite->callback = AnimGuillotinePincerStep2; + } +} + +static void AnimGuillotinePincerStep2(struct Sprite *sprite) +{ + if (sprite->data[3]) + { + sprite->pos2.x = -sprite->pos2.x; + sprite->pos2.y = -sprite->pos2.y; + } + + sprite->data[3] ^= 1; + if (++sprite->data[4] == 51) + { + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[4] = 0; + sprite->data[3] = 0; + sprite->animPaused = 0; + StartSpriteAnim(sprite, sprite->data[5] ^ 1); + sprite->callback = AnimGuillotinePincerStep3; + } +} + +static void AnimGuillotinePincerStep3(struct Sprite *sprite) +{ + if (AnimTranslateLinear(sprite)) + DestroyAnimSprite(sprite); +} + +// Scales up the target mon sprite, and sets the palette to greyscale. +// Used in MOVE_DISABLE. +// No args. +void AnimTask_GrowAndGreyscale(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_BLEND); + SetSpriteRotScale(spriteId, 0xD0, 0xD0, 0); + SetGreyscaleOrOriginalPalette(gSprites[spriteId].oam.paletteNum + 16, FALSE); + gTasks[taskId].data[0] = 80; + gTasks[taskId].func = AnimTask_GrowAndGreyscaleStep; +} + +static void AnimTask_GrowAndGreyscaleStep(u8 taskId) +{ + if (--gTasks[taskId].data[0] == -1) + { + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + ResetSpriteRotScale(spriteId); + SetGreyscaleOrOriginalPalette(gSprites[spriteId].oam.paletteNum + 16, TRUE); + DestroyAnimVisualTask(taskId); + } +} + +// Shrinks and grows the attacking mon several times. Also creates transparent versions of the +// mon's sprite while it is shrinking. +// No args. +void AnimTask_Minimize(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 0x100; + task->data[5] = 0; + task->data[6] = 0; + task->data[7] = GetBattlerSpriteSubpriority(gBattleAnimAttacker); + task->func = AnimTask_MinimizeStep1; +} + +static void AnimTask_MinimizeStep1(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[1]) + { + case 0: + if (task->data[2] == 0 || task->data[2] == 3 || task->data[2] == 6) + CreateMinimizeSprite(task, taskId); + task->data[2]++; + task->data[4] += 0x28; + SetSpriteRotScale(task->data[0], task->data[4], task->data[4], 0); + SetBattlerSpriteYOffsetFromYScale(task->data[0]); + if (task->data[2] == 32) + { + task->data[5]++; + task->data[1]++; + } + break; + case 1: + if (task->data[6] == 0) + { + if (task->data[5] == 3) + { + task->data[2] = 0; + task->data[1] = 3; + } + else + { + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 0x100; + SetSpriteRotScale(task->data[0], task->data[4], task->data[4], 0); + SetBattlerSpriteYOffsetFromYScale(task->data[0]); + task->data[1] = 2; + } + } + break; + case 2: + task->data[1] = 0; + break; + case 3: + if (++task->data[2] > 32) + { + task->data[2] = 0; + task->data[1]++; + } + break; + case 4: + task->data[2] += 2; + task->data[4] -= 0x50; + SetSpriteRotScale(task->data[0], task->data[4], task->data[4], 0); + SetBattlerSpriteYOffsetFromYScale(task->data[0]); + if (task->data[2] == 32) + { + task->data[2] = 0; + task->data[1]++; + } + break; + case 5: + ResetSpriteRotScale(task->data[0]); + gSprites[task->data[15]].pos2.y = 0; + DestroyAnimVisualTask(taskId); + break; + } +} + +static void CreateMinimizeSprite(struct Task* task, u8 taskId) +{ + u16 matrixNum; + s16 spriteId = CloneBattlerSpriteWithBlend(ANIM_ATTACKER); + if (spriteId >= 0) + { + if ((matrixNum = AllocOamMatrix()) == 0xFF) + { + obj_delete_but_dont_free_vram(&gSprites[spriteId]); + } + else + { + gSprites[spriteId].oam.objMode = ST_OAM_OBJ_BLEND; + gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_DOUBLE; + gSprites[spriteId].affineAnimPaused = TRUE; + gSprites[spriteId].oam.matrixNum = matrixNum; + gSprites[spriteId].subpriority = task->data[7] - task->data[3]; + task->data[3]++; + task->data[6]++; + gSprites[spriteId].data[0] = 16; + gSprites[spriteId].data[1] = taskId; + gSprites[spriteId].data[2] = 6; + gSprites[spriteId].callback = ClonedMinizeSprite_Step; + SetSpriteRotScale(spriteId, task->data[4], task->data[4], 0); + gSprites[spriteId].oam.affineMode = 1; + CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode); + } + } +} + +static void ClonedMinizeSprite_Step(struct Sprite *sprite) +{ + if (--sprite->data[0] == 0) + { + gTasks[sprite->data[1]].data[sprite->data[2]]--; + FreeOamMatrix(sprite->oam.matrixNum); + obj_delete_but_dont_free_vram(sprite); + } +} + +// Task to facilitate expanding and hopping effect seen in Splash. +// arg 0: anim battler +// arg 1: num hops +void AnimTask_Splash(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (gBattleAnimArgs[1] == 0) + { + DestroyAnimVisualTask(taskId); + } + else + { + u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->data[0] = spriteId; + task->data[1] = 0; + task->data[2] = gBattleAnimArgs[1]; + task->data[3] = 0; + task->data[4] = 0; + PrepareAffineAnimInTaskData(task, spriteId, gSplashEffectAffineAnimCmds); + task->func = AnimTask_SplashStep; + } +} + +static void AnimTask_SplashStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[1]) + { + case 0: + RunAffineAnimFromTaskData(task); + task->data[4] += 3; + gSprites[task->data[0]].pos2.y += task->data[4]; + if (++task->data[3] > 7) + { + task->data[3] = 0; + task->data[1]++; + } + break; + case 1: + RunAffineAnimFromTaskData(task); + gSprites[task->data[0]].pos2.y += task->data[4]; + if (++task->data[3] > 7) + { + task->data[3] = 0; + task->data[1]++; + } + break; + case 2: + if (task->data[4] != 0) + { + gSprites[task->data[0]].pos2.y -= 2; + task->data[4] -= 2; + } + else + task->data[1]++; + break; + case 3: + if (!RunAffineAnimFromTaskData(task)) + { + if (--task->data[2] == 0) + { + gSprites[task->data[0]].pos2.y = 0; + DestroyAnimVisualTask(taskId); + } + else + { + PrepareAffineAnimInTaskData(task, task->data[0], gSplashEffectAffineAnimCmds); + task->data[1] = 0; + } + } + break; + } +} + +// Grows, pauses, then shrinks the attacking mon. +// Used by MOVE_SWAGGER and MOVE_BULK_UP +// No args. +void AnimTask_GrowAndShrink(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + PrepareAffineAnimInTaskData(task, spriteId, gGrowAndShrinkAffineAnimCmds); + task->func = AnimTask_GrowAndShrinkStep; +} + +static void AnimTask_GrowAndShrinkStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) + DestroyAnimVisualTask(taskId); +} + +// Animates a little puff of the mon's breath. +// Used by MOVE_SWAGGER and MOVE_BULK_UP +// No args. +void AnimBreathPuff(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + StartSpriteAnim(sprite, 0); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + 32; + sprite->data[1] = 64; + } + else + { + StartSpriteAnim(sprite, 1); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) - 32; + sprite->data[1] = -64; + } + + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->data[0] = 52; + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = 0; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = TranslateSpriteLinearFixedPoint; +} + +// Animates an "angry" mark above a mon's head. +// arg 0: target mon (0 = attacker, 1 = target) +// arg 1: x pixel offset +// arg 2: y pixel offset +void AnimAngerMark(struct Sprite *sprite) +{ + u8 battler; + if (!gBattleAnimArgs[0]) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + gBattleAnimArgs[1] *= -1; + + sprite->pos1.x = GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; + if (sprite->pos1.y < 8) + sprite->pos1.y = 8; + + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; +} + +// left/right movements +void AnimTask_ThrashMoveMonHorizontal(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; + task->data[1] = 0; + PrepareAffineAnimInTaskData(task, spriteId, gThrashMoveMonAffineAnimCmds); + task->func = ThrashMoveMonStep; +} + +static void ThrashMoveMonStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) + DestroyAnimVisualTask(taskId); +} + +// up/down movements +void AnimTask_ThrashMoveMonVertical(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + task->data[0] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[1] = 0; + task->data[2] = 4; + task->data[3] = 7; + task->data[4] = 3; + task->data[5] = gSprites[task->data[0]].pos1.x; + task->data[6] = gSprites[task->data[0]].pos1.y; + task->data[7] = 0; + task->data[8] = 0; + task->data[9] = 2; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + task->data[2] *= -1; + + task->func = ThrashMoveMon; +} + +static void ThrashMoveMon(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (++task->data[7] > 2) + { + task->data[7] = 0; + task->data[8]++; + if (task->data[8] & 1) + gSprites[task->data[0]].pos1.y += task->data[9]; + else + gSprites[task->data[0]].pos1.y -= task->data[9]; + } + switch (task->data[1]) + { + case 0: + gSprites[task->data[0]].pos1.x += task->data[2]; + if (--task->data[3] == 0) + { + task->data[3] = 14; + task->data[1] = 1; + } + break; + case 1: + gSprites[task->data[0]].pos1.x -= task->data[2]; + if (--task->data[3] == 0) + { + task->data[3] = 7; + task->data[1] = 2; + } + break; + case 2: + gSprites[task->data[0]].pos1.x += task->data[2]; + if (--task->data[3] == 0) + { + if (--task->data[4] != 0) + { + task->data[3] = 7; + task->data[1] = 0; + } + else + { + if ((task->data[8] & 1) != 0) + gSprites[task->data[0]].pos1.y -= task->data[9]; + + DestroyAnimVisualTask(taskId); + } + } + break; + } +} + +void sub_80A8874(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + struct ScanlineEffectParams params; + + s16 i; + task->data[0] = GetBattlerYCoordWithElevation(gBattleAnimTarget) + 32; + task->data[1] = 4; + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 0; + task->data[5] = 0; + task->data[15] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT); + + if (GetBattlerSpriteBGPriorityRank(gBattleAnimTarget) == 1) + { + task->data[6] = gBattle_BG1_X; + params.dmaDest = (u16 *)REG_ADDR_BG1HOFS; + } + else + { + task->data[6] = gBattle_BG2_X; + params.dmaDest = (u16 *)REG_ADDR_BG2HOFS; + } + + for (i = task->data[0] - 0x40; i <= task->data[0]; i++) + { + if (i >= 0) + { + gScanlineEffectRegBuffers[0][i] = task->data[6] + 0xF0; + gScanlineEffectRegBuffers[1][i] = task->data[6] + 0xF0; + } + } + + params.dmaControl = SCANLINE_EFFECT_DMACNT_16BIT; + params.initState = 1; + params.unused9 = 0; + ScanlineEffect_SetParams(params); + task->func = AnimTask_SketchDrawMon; +} + +static void AnimTask_SketchDrawMon(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + + switch (task->data[4]) + { + case 0: + if (++task->data[5] > 20) + task->data[4]++; + break; + case 1: + if (++task->data[1] > 3) + { + task->data[1] = 0; + task->data[2] = task->data[3] & 3; + task->data[5] = task->data[0] - task->data[3]; + switch (task->data[2]) + { + case 0: + break; + case 1: + task->data[5] -= 2; + break; + case 2: + task->data[5] += 1; + break; + case 3: + task->data[5] += 1; + break; + } + + if (task->data[5] >= 0) + { + gScanlineEffectRegBuffers[0][task->data[5]] = task->data[6]; + gScanlineEffectRegBuffers[1][task->data[5]] = task->data[6]; + } + + if (++task->data[3] >= task->data[15]) + { + gScanlineEffect.state = 3; + DestroyAnimVisualTask(taskId); + } + } + break; + } +} + +void AnimPencil(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) - 16; + sprite->pos1.y = GetBattlerYCoordWithElevation(gBattleAnimTarget) + 16; + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[3] = 16; + sprite->data[4] = 0; + sprite->data[5] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT) + 2; + sprite->data[6] = BattleAnimAdjustPanning(63); + sprite->callback = AnimPencil_Step; +} + +static void AnimPencil_Step(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (++sprite->data[2] > 1) + { + sprite->data[2] = 0; + sprite->invisible = !sprite->invisible; + } + if (++sprite->data[1] > 16) + { + sprite->invisible = 0; + sprite->data[0]++; + } + break; + case 1: + if (++sprite->data[1] > 3 && sprite->data[2] < sprite->data[5]) + { + sprite->data[1] = 0; + sprite->pos1.y -= 1; + sprite->data[2]++; + if (sprite->data[2] % 10 == 0) + PlaySE12WithPanning(SE_W166, sprite->data[6]); + } + sprite->data[4] += sprite->data[3]; + if (sprite->data[4] > 31) + { + sprite->data[4] = 0x40 - sprite->data[4]; + sprite->data[3] *= -1; + } + else if (sprite->data[4] <= -32) + { + sprite->data[4] = -0x40 - sprite->data[4]; + sprite->data[3] *= -1; + } + sprite->pos2.x = sprite->data[4]; + if (sprite->data[5] == sprite->data[2]) + { + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 2: + if (++sprite->data[2] > 1) + { + sprite->data[2] = 0; + sprite->invisible = !sprite->invisible; + } + if (++sprite->data[1] > 16) + { + sprite->invisible = 0; + DestroyAnimSprite(sprite); + } + break; + } +} + +void AnimBlendThinRing(struct Sprite *sprite) +{ + u8 battler = 0; + u16 sp0 = 0; + u16 sp1 = 0; + u8 r4; + + if (gBattleAnimArgs[2] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + r4 = gBattleAnimArgs[3] ^ 1; + if (IsDoubleBattle() && IsBattlerSpriteVisible(BATTLE_PARTNER(battler))) + { + SetAverageBattlerPositions(battler, r4, &sp0, &sp1); + if (r4 == 0) + r4 = GetBattlerSpriteCoord(battler, 0); + else + r4 = GetBattlerSpriteCoord(battler, 2); + + if (GetBattlerSide(battler) != B_SIDE_PLAYER) + gBattleAnimArgs[0] -= (sp0 - r4) - gBattleAnimArgs[0]; // This is weird. + else + gBattleAnimArgs[0] = sp0 - r4; + } + + sprite->callback = AnimSpriteOnMonPos; + sprite->callback(sprite); +} + +void sub_80A8C84(struct Sprite *sprite) +{ + if (AnimTranslateLinear(sprite)) + { + FreeSpriteOamMatrix(sprite); + DestroyAnimSprite(sprite); + } +} + +void AnimHyperVoiceRing(struct Sprite *sprite) +{ + u16 r9 = 0; + u16 r6 = 0; + s16 sp0 = 0; + s16 sp1 = 0; + u8 sp4; + u8 battler1; + u8 battler2; + u8 r10; + + if (gBattleAnimArgs[5] == 0) + { + battler1 = gBattleAnimAttacker; + battler2 = gBattleAnimTarget; + } + else + { + battler1 = gBattleAnimTarget; + battler2 = gBattleAnimAttacker; + } + + if (!gBattleAnimArgs[6]) + { + r10 = 0; + sp4 = 1; + } + else + { + r10 = 2; + sp4 = 3; + } + + if (GetBattlerSide(battler1) != B_SIDE_PLAYER) + { + r9 = GetBattlerSpriteCoord(battler1, r10) + gBattleAnimArgs[0]; + if (IsBattlerSpriteVisible(BATTLE_PARTNER(battler2))) + sprite->subpriority = gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler2)]].subpriority - 1; + else + sprite->subpriority = gSprites[gBattlerSpriteIds[battler2]].subpriority - 1; + } + else + { + r9 = GetBattlerSpriteCoord(battler1, r10) - gBattleAnimArgs[0]; + if (!IsContest() && IsBattlerSpriteVisible(BATTLE_PARTNER(battler1))) + { + if (gSprites[gBattlerSpriteIds[battler1]].pos1.x < gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler1)]].pos1.x) + sprite->subpriority = gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler1)]].subpriority + 1; + else + sprite->subpriority = gSprites[gBattlerSpriteIds[battler1]].subpriority - 1; + } + else + { + sprite->subpriority = gSprites[gBattlerSpriteIds[battler1]].subpriority - 1; + } + + } + + r6 = GetBattlerSpriteCoord(battler1, sp4) + gBattleAnimArgs[1]; + if (!IsContest() && IsBattlerSpriteVisible(BATTLE_PARTNER(battler2))) + { + SetAverageBattlerPositions(battler2, gBattleAnimArgs[6], &sp0, &sp1); + } + else + { + sp0 = GetBattlerSpriteCoord(battler2, r10); + sp1 = GetBattlerSpriteCoord(battler2, sp4); + } + + if (GetBattlerSide(battler2)) + sp0 += gBattleAnimArgs[3]; + else + sp0 -= gBattleAnimArgs[3]; + + sp1 += gBattleAnimArgs[4]; + sprite->pos1.x = sprite->data[1] = r9; + sprite->pos1.y = sprite->data[3] = r6; + sprite->data[2] = sp0; + sprite->data[4] = sp1; + sprite->data[0] = gBattleAnimArgs[0]; + InitAnimLinearTranslation(sprite); + sprite->callback = sub_80A8C84; + sprite->callback(sprite); +} + +void AnimUproarRing(struct Sprite *sprite) +{ + u8 index = IndexOfSpritePaletteTag(ANIM_TAG_THIN_RING); + if (index != 0xFF) + { + BlendPalette(((index << 20) + 0x1010000) >> 16, 15, gBattleAnimArgs[5], gBattleAnimArgs[4]); + } + + StartSpriteAffineAnim(sprite, 1); + sprite->callback = AnimSpriteOnMonPos; + sprite->callback(sprite); +} + +void AnimSoftBoiledEgg(struct Sprite *sprite) +{ + s16 r1; + InitSpritePosToAnimAttacker(sprite, FALSE); + r1 = GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER ? -160 : 160; + sprite->data[0] = 0x380; + sprite->data[1] = r1; + sprite->data[7] = gBattleAnimArgs[2]; + sprite->callback = AnimSoftBoiledEgg_Step1; +} + +static void AnimSoftBoiledEgg_Step1(struct Sprite *sprite) +{ + s16 add; + sprite->pos2.y -= (sprite->data[0] >> 8); + sprite->pos2.x = sprite->data[1] >> 8; + sprite->data[0] -= 32; + add = GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER ? -160 : 160; + sprite->data[1] += add; + if (sprite->pos2.y > 0) + { + sprite->pos1.y += sprite->pos2.y; + sprite->pos1.x += sprite->pos2.x; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[0] = 0; + StartSpriteAffineAnim(sprite, 1); + sprite->callback = AnimSoftBoiledEgg_Step2; + } +} + +static void AnimSoftBoiledEgg_Step2(struct Sprite *sprite) +{ + if (sprite->data[0]++ > 19) + { + StartSpriteAffineAnim(sprite, 2); + sprite->callback = AnimSoftBoiledEgg_Step3; + } +} + +static void AnimSoftBoiledEgg_Step3(struct Sprite *sprite) +{ + if (sprite->affineAnimEnded) + { + StartSpriteAffineAnim(sprite, 1); + sprite->data[0] = 0; + if (sprite->data[7] == 0) + { + sprite->oam.tileNum += 16; + sprite->callback = AnimSoftBoiledEgg_Step3_Callback1; + } + else + { + sprite->oam.tileNum += 32; + sprite->callback = AnimSoftBoiledEgg_Step4; + } + } +} + +static void AnimSoftBoiledEgg_Step3_Callback1(struct Sprite *sprite) +{ + sprite->pos2.y -= 2; + if (++sprite->data[0] == 9) + { + sprite->data[0] = 16; + sprite->data[1] = 0; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND((u16)sprite->data[0], 0)); + sprite->callback = AnimSoftBoiledEgg_Step3_Callback2; + } +} + +static void AnimSoftBoiledEgg_Step3_Callback2(struct Sprite *sprite) +{ + if (sprite->data[1]++ % 3 == 0) + { + sprite->data[0]--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 16 - sprite->data[0])); + if (sprite->data[0] == 0) + sprite->callback = AnimSoftBoiledEgg_Step4; + } +} + +static void AnimSoftBoiledEgg_Step4(struct Sprite *sprite) +{ + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + { + sprite->invisible = 1; + if (sprite->data[7] == 0) + sprite->callback = AnimSoftBoiledEgg_Step4_Callback; + else + sprite->callback = DestroyAnimSprite; + } +} + +static void AnimSoftBoiledEgg_Step4_Callback(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimSprite(sprite); +} + +void AnimTask_StretchAttacker(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; + PrepareAffineAnimInTaskData(task, spriteId, gStretchAttackerAffineAnimCmds); + task->func = StretchAttacker_Step; +} + +static void StretchAttacker_Step(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) + { + gSprites[task->data[0]].pos2.y = 0; + gSprites[task->data[0]].invisible = 1; + DestroyAnimVisualTask(taskId); + } +} + +void AnimTask_ExtremeSpeedImpact(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[12] = 3; + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + task->data[13] = 0xFFFF; + task->data[14] = 8; + } + else + { + task->data[13] = 1; + task->data[14] = -8; + } + + task->data[15] = GetAnimBattlerSpriteId(ANIM_TARGET); + task->func = ExtremeSpeedImpact_Step; +} + +static void ExtremeSpeedImpact_Step(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + gSprites[task->data[15]].pos2.x += task->data[14]; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[0]++; + break; + case 1: + if (++task->data[1] > 1) + { + task->data[1] = 0; + task->data[2]++; + if (task->data[2] & 1) + gSprites[task->data[15]].pos2.x += 6; + else + gSprites[task->data[15]].pos2.x -= 6; + + if (++task->data[3] > 4) + { + if (task->data[2] & 1) + gSprites[task->data[15]].pos2.x -= 6; + + task->data[0]++; + } + } + break; + case 2: + if (--task->data[12] != 0) + task->data[0] = 0; + else + task->data[0]++; + break; + case 3: + gSprites[task->data[15]].pos2.x += task->data[13]; + if (gSprites[task->data[15]].pos2.x == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimTask_ExtremeSpeedMonReappear(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 1; + task->data[13] = 14; + task->data[14] = 2; + task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->func = ExtremeSpeedMonReappear_Step; +} + +static void ExtremeSpeedMonReappear_Step(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (task->data[0] == 0 && ++task->data[1] > task->data[4]) + { + task->data[1] = 0; + if (++task->data[2] & 1) + gSprites[task->data[15]].invisible = 0; + else + gSprites[task->data[15]].invisible = 1; + + if (++task->data[3] >= task->data[13]) + { + if (++task->data[4] < task->data[14]) + { + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + } + else + { + gSprites[task->data[15]].invisible = 0; + DestroyAnimVisualTask(taskId); + } + } + } +} + +void AnimTask_SpeedDust(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + task->data[0] = 0; + task->data[1] = 4; + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 0; + task->data[5] = 0; + task->data[6] = 0; + task->data[7] = 0; + task->data[8] = 0; + task->data[13] = 0; + task->data[14] = GetBattlerSpriteCoord(gBattleAnimAttacker, ANIM_ATTACKER); + task->data[15] = GetBattlerSpriteCoord(gBattleAnimAttacker, ANIM_TARGET); + task->func = SpeedDust_Step1; +} + +static void SpeedDust_Step1(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[8]) + { + case 0: + if (++task->data[4] > 1) + { + task->data[4] = 0; + task->data[5] = (task->data[5] + 1) & 1; + if (++task->data[6] > 20) + { + if (task->data[7] == 0) + { + task->data[6] = 0; + task->data[8] = 1; + } + else + task->data[8] = 2; + } + } + break; + case 1: + task->data[5] = 0; + if (++task->data[4] > 20) + { + task->data[7] = 1; + task->data[8] = 0; + } + break; + case 2: + task->data[5] = 1; + break; + } + + switch (task->data[0]) + { + case 0: + if (++task->data[1] > 4) + { + u8 spriteId; + task->data[1] = 0; + spriteId = CreateSprite(&gSpeedDustSpriteTemplate, task->data[14], task->data[15], 0); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].data[0] = taskId; + gSprites[spriteId].data[1] = 13; + gSprites[spriteId].pos2.x = gSpeedDustPosTable[task->data[2]][0]; + gSprites[spriteId].pos2.y = gSpeedDustPosTable[task->data[2]][1]; + task->data[13]++; + if (++task->data[2] > 3) + { + task->data[2] = 0; + if (++task->data[3] > 5) + task->data[0]++; + } + } + } + break; + case 1: + if (task->data[13] == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimSpeedDust(struct Sprite *sprite) +{ + sprite->invisible = gTasks[sprite->data[0]].data[5]; + if (sprite->animEnded) + { + gTasks[sprite->data[0]].data[sprite->data[1]]--; + DestroySprite(sprite); + } +} + +void sub_80A96B4(u8 taskId) +{ + int i; + u8 paletteNums[3]; + + paletteNums[0] = IndexOfSpritePaletteTag(ANIM_TAG_MUSIC_NOTES_2); + for (i = 1; i < 3; i++) + paletteNums[i] = AllocSpritePalette(ANIM_SPRITES_START - i); + + gMonSpritesGfxPtr->field_17C = AllocZeroed(0x2000); + LZDecompressWram(gBattleAnimSpritePal_MusicNotes2, gMonSpritesGfxPtr->field_17C); + for (i = 0; i < 3; i++) + LoadPalette(&gMonSpritesGfxPtr->field_17C[i * 32], (u16)((paletteNums[i] << 4) + 0x100), 32); + + FREE_AND_SET_NULL(gMonSpritesGfxPtr->field_17C); + DestroyAnimVisualTask(taskId); +} + +void sub_80A9760(u8 taskId) +{ + int i; + for (i = 0; i < 3; i++) + FreeSpritePaletteByTag(gMusicNotePaletteTagsTable[i]); + + DestroyAnimVisualTask(taskId); +} + +static void SetMusicNotePalette(struct Sprite *sprite, u8 a, u8 b) +{ + u8 tile; + tile = (b & 1); + tile = ((-tile | tile) >> 31) & 32; + sprite->oam.tileNum += tile + (a << 2); + sprite->oam.paletteNum = IndexOfSpritePaletteTag(gMusicNotePaletteTagsTable[b >> 1]); +} + +void AnimHealBellMusicNote(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[3]; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + SetMusicNotePalette(sprite, gBattleAnimArgs[5], gBattleAnimArgs[6]); +} + +void AnimMagentaHeart(struct Sprite *sprite) +{ + if (++sprite->data[0] == 1) + InitSpritePosToAnimAttacker(sprite, FALSE); + + sprite->pos2.x = Sin(sprite->data[1], 8); + sprite->pos2.y = sprite->data[2] >> 8; + sprite->data[1] = (sprite->data[1] + 7) & 0xFF; + sprite->data[2] -= 0x80; + if (sprite->data[0] == 60) + DestroyAnimSprite(sprite); +} + +void AnimTask_FakeOut(u8 taskId) +{ + u16 win0h = IsContest() ? 0x98 : 0xF0; + u16 win0v = 0; + + gBattle_WIN0H = win0h; + gBattle_WIN0V = 0xA0; + SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); + SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); + SetGpuReg(REG_OFFSET_WININ, 0x3F1F); + SetGpuReg(REG_OFFSET_WINOUT, 0x3F3F); + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_DARKEN); + SetGpuReg(REG_OFFSET_BLDY, 0x10); + gTasks[taskId].data[0] = win0v; + gTasks[taskId].data[1] = win0h; + gTasks[taskId].func = FakeOutStep1; +} + +static void FakeOutStep1(u8 taskId) +{ + gTasks[taskId].data[0] += 13; + gTasks[taskId].data[1] -= 13; + if (gTasks[taskId].data[0] >= gTasks[taskId].data[1]) + { + gBattle_WIN0H = 0; + gTasks[taskId].func = FakeOutStep2; + } + else + { + gBattle_WIN0H = gTasks[taskId].data[1] | (gTasks[taskId].data[0] << 8); + } +} + +static void FakeOutStep2(u8 taskId) +{ + if (++gTasks[taskId].data[10] == 5) + { + gTasks[taskId].data[11] = 0x88; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_LIGHTEN); + BlendPalettes(sub_80A75AC(1, 0, 0, 0, 0, 0, 0), 16, RGB(31, 31, 31)); + } + else if (gTasks[taskId].data[10] > 4) + { + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDY, 0); + DestroyAnimVisualTask(taskId); + } +} + +void sub_80A9A20(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (++gTasks[taskId].data[0] == 1) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(1), gUnknown_83E4200); + gSprites[spriteId].pos2.x = 4; + } + else + { + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos2.x; + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + { + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + DestroyAnimVisualTask(taskId); + } + } +} + +void sub_80A9AB0(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + if (++gTasks[taskId].data[0] == 1) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(0), gUnknown_83E4200); + gSprites[spriteId].pos2.x = 4; + } + else + { + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos2.x; + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + { + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + DestroyAnimVisualTask(taskId); + } + } +} + +void AnimRedHeartProjectile(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = 95; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + InitAnimLinearTranslation(sprite); + sprite->callback = AnimRedHeartProjectile_Step; +} + +static void AnimRedHeartProjectile_Step(struct Sprite *sprite) +{ + if (!AnimTranslateLinear(sprite)) + { + sprite->pos2.y += Sin(sprite->data[5], 14); + sprite->data[5] = (sprite->data[5] + 4) & 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +void AnimParticuleBurst(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[1] = gBattleAnimArgs[0]; + sprite->data[2] = gBattleAnimArgs[1]; + sprite->data[0]++; + } + else + { + sprite->data[4] += sprite->data[1]; + sprite->pos2.x = sprite->data[4] >> 8; + sprite->pos2.y = Sin(sprite->data[3], sprite->data[2]); + sprite->data[3] = (sprite->data[3] + 3) & 0xFF; + if (sprite->data[3] > 100) + sprite->invisible = sprite->data[3] % 2; + + if (sprite->data[3] > 120) + DestroyAnimSprite(sprite); + } +} + +void AnimRedHeartRising(struct Sprite *sprite) +{ + sprite->pos1.x = gBattleAnimArgs[0]; + sprite->pos1.y = 160; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimRedHeartRising_Step); +} + +static void AnimRedHeartRising_Step(struct Sprite *sprite) +{ + s16 y; + sprite->data[2] += sprite->data[1]; + sprite->pos2.y = -((u16)sprite->data[2] >> 8); + sprite->pos2.x = Sin(sprite->data[3], 4); + sprite->data[3] = (sprite->data[3] + 3) & 0xFF; + y = sprite->pos1.y + sprite->pos2.y; + if (y <= 72) + { + sprite->invisible = sprite->data[3] % 2; + if (y <= 64) + DestroyAnimSprite(sprite); + } +} + +void AnimTask_HeartsBackground(u8 taskId) +{ + struct BattleAnimBgData animBg; + + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 3); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; + SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); + SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); + sub_80752A0(&animBg); + AnimLoadCompressedBgGfx(animBg.bgId, &gUnknown_08C232E0, animBg.tilesOffset); + sub_80A6D60(&animBg, &gUnknown_08C23D78, 0); + LoadCompressedPalette(&gUnknown_08C23D50, animBg.paletteId * 16, 32); + gTasks[taskId].func = HeartsBackground_Step; +} + +static void HeartsBackground_Step(u8 taskId) +{ + struct BattleAnimBgData animBg; + + switch (gTasks[taskId].data[12]) + { + case 0: + if (++gTasks[taskId].data[10] == 4) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[11]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[11], 16 - gTasks[taskId].data[11])); + if (gTasks[taskId].data[11] == 16) + { + gTasks[taskId].data[12]++; + gTasks[taskId].data[11] = 0; + } + } + break; + case 1: + if (++gTasks[taskId].data[11] == 141) + { + gTasks[taskId].data[11] = 16; + gTasks[taskId].data[12]++; + } + break; + case 2: + if (++gTasks[taskId].data[10] == 4) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[11]--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[11], 16 - gTasks[taskId].data[11])); + if (gTasks[taskId].data[11] == 0) + { + gTasks[taskId].data[12]++; + gTasks[taskId].data[11] = 0; + } + } + break; + case 3: + sub_80752A0(&animBg); + sub_8075358(animBg.bgId); + gTasks[taskId].data[12]++; + break; + case 4: + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimTask_ScaryFace(u8 taskId) +{ + struct BattleAnimBgData animBg; + + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; + SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); + SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); + sub_80752A0(&animBg); + if (IsContest()) + sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFaceContest, 0); + else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) + sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFacePlayer, 0); + else + sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFaceOpponent, 0); + + AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C249F8, animBg.tilesOffset); + LoadCompressedPalette(gUnknown_08C249D0, animBg.paletteId * 16, 32); + gTasks[taskId].func = ScaryFace_Step; +} + +static void ScaryFace_Step(u8 taskId) +{ + struct BattleAnimBgData animBg; + + switch (gTasks[taskId].data[12]) + { + case 0: + if (++gTasks[taskId].data[10] == 2) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[11]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[11], 16 - gTasks[taskId].data[11])); + if (gTasks[taskId].data[11] == 14) + { + gTasks[taskId].data[12]++; + gTasks[taskId].data[11] = 0; + } + } + break; + case 1: + if (++gTasks[taskId].data[11] == 21) + { + gTasks[taskId].data[11] = 14; + gTasks[taskId].data[12]++; + } + break; + case 2: + if (++gTasks[taskId].data[10] == 2) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[11]--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[11], 16 - gTasks[taskId].data[11])); + if (gTasks[taskId].data[11] == 0) + { + gTasks[taskId].data[12]++; + gTasks[taskId].data[11] = 0; + } + } + break; + case 3: + sub_80752A0(&animBg); + sub_8075358(1); + sub_8075358(2); + gTasks[taskId].data[12]++; + // fall through + case 4: + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + DestroyAnimVisualTask(taskId); + break; + } +} + +// Orbits a sphere in an ellipse around the mon. +// Used by MOVE_HIDDEN_POWER +// arg 0: duration +// arg 1: initial wave offset +void AnimOrbitFast(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->affineAnimPaused = 1; + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[7] = GetBattlerSpriteSubpriority(gBattleAnimAttacker); + sprite->callback = AnimOrbitFastStep; + sprite->callback(sprite); +} + +static void AnimOrbitFastStep(struct Sprite *sprite) +{ + if (sprite->data[1] >= 64 && sprite->data[1] <= 191) + sprite->subpriority = sprite->data[7] + 1; + else + sprite->subpriority = sprite->data[7] - 1; + + sprite->pos2.x = Sin(sprite->data[1], sprite->data[2] >> 8); + sprite->pos2.y = Cos(sprite->data[1], sprite->data[3] >> 8); + sprite->data[1] = (sprite->data[1] + 9) & 0xFF; + switch (sprite->data[5]) + { + case 1: + sprite->data[2] -= 0x400; + sprite->data[3] -= 0x100; + if (++sprite->data[4] == sprite->data[0]) + { + sprite->data[5] = 2; + return; + } + break; + case 0: + sprite->data[2] += 0x400; + sprite->data[3] += 0x100; + if (++sprite->data[4] == sprite->data[0]) + { + sprite->data[4] = 0; + sprite->data[5] = 1; + } + break; + } + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + DestroyAnimSprite(sprite); +} + +// Moves orbs away from the mon, based on where they are in their orbit. +// Used in MOVE_HIDDEN_POWER. +// arg 0: initial wave offset +void AnimOrbitScatter(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->data[0] = Sin(gBattleAnimArgs[0], 10); + sprite->data[1] = Cos(gBattleAnimArgs[0], 7); + sprite->callback = AnimOrbitScatterStep; +} + +static void AnimOrbitScatterStep(struct Sprite *sprite) +{ + sprite->pos2.x += sprite->data[0]; + sprite->pos2.y += sprite->data[1]; + if (sprite->pos1.x + sprite->pos2.x + 16 > 272u || sprite->pos1.y + sprite->pos2.y > 160 || sprite->pos1.y + sprite->pos2.y < -16) + DestroyAnimSprite(sprite); +} + +static void AnimSpitUpOrb_Step(struct Sprite *sprite) +{ + sprite->pos2.x += sprite->data[0]; + sprite->pos2.y += sprite->data[1]; + if (sprite->data[3]++ >= sprite->data[2]) + DestroyAnimSprite(sprite); +} + +void AnimSpitUpOrb(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->data[0] = Sin(gBattleAnimArgs[0], 10); + sprite->data[1] = Cos(gBattleAnimArgs[0], 7); + sprite->data[2] = gBattleAnimArgs[1]; + sprite->callback = AnimSpitUpOrb_Step; +} + +static void sub_80AA3D4(struct Sprite *sprite) +{ + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimEyeSparkle(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->callback = sub_80AA3D4; +} + +void AnimAngel(struct Sprite *sprite) +{ + s16 var0; + if (!sprite->data[0]) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + + sprite->data[0]++; + var0 = (sprite->data[0] * 10) & 0xFF; + sprite->pos2.x = Sin(var0, 80) >> 8; + if (sprite->data[0] < 80) + sprite->pos2.y = (sprite->data[0] / 2) + (Cos(var0, 80) >> 8); + + if (sprite->data[0] > 90) + { + sprite->data[2]++; + sprite->pos2.x -= sprite->data[2] / 2; + } + + if (sprite->data[0] > 100) + DestroyAnimSprite(sprite); +} + +static void sub_80AA49C(struct Sprite *sprite) +{ + sprite->data[5]++; + sprite->pos2.x = Sin(sprite->data[3], 5); + sprite->pos2.y = sprite->data[5] / 2; + sprite->data[3] = (sprite->data[3] + 3) & 0xFF; + if (sprite->data[5] > 20) + sprite->invisible = sprite->data[5] % 2; + + if (sprite->data[5] > 30) + DestroyAnimSprite(sprite); +} + +void AnimPinkHeart(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[1] = gBattleAnimArgs[0]; + sprite->data[2] = gBattleAnimArgs[1]; + sprite->data[0]++; + } + else + { + sprite->data[4] += sprite->data[1]; + sprite->pos2.x = sprite->data[4] >> 8; + sprite->pos2.y = Sin(sprite->data[3], sprite->data[2]); + sprite->data[3] = (sprite->data[3] + 3) & 0xFF; + if (sprite->data[3] > 70) + { + sprite->callback = sub_80AA49C; + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[3] = Random2() % 180; + } + } +} + +void AnimDevil(struct Sprite *sprite) +{ + if (sprite->data[3] == 0) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + StartSpriteAnim(sprite, 0); + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) - 1; + sprite->data[2] = 1; + } + sprite->data[0] += sprite->data[2]; + sprite->data[1] = (sprite->data[0] * 4) % 256; + if (sprite->data[1] < 0) + sprite->data[1] = 0; + sprite->pos2.x = Cos(sprite->data[1], 30 - sprite->data[0] / 4); + sprite->pos2.y = Sin(sprite->data[1], 10 - sprite->data[0] / 8); + if (sprite->data[1] > 128 && sprite->data[2] > 0) + sprite->data[2] = -1; + if (sprite->data[1] == 0 && sprite->data[2] < 0) + sprite->data[2] = 1; + sprite->data[3]++; + if (sprite->data[3] < 10 || sprite->data[3] > 80) + sprite->invisible = sprite->data[0] % 2; + else + sprite->invisible = FALSE; + if (sprite->data[3] > 90) + DestroyAnimSprite(sprite); +} + +void AnimFurySwipes(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + StartSpriteAnim(sprite, gBattleAnimArgs[2]); + sprite->data[0]++; + } + else if (sprite->animEnded) + { + DestroyAnimSprite(sprite); + } +} + +void AnimMovmentWaves(struct Sprite *sprite) +{ + if (!gBattleAnimArgs[2]) + { + DestroyAnimSprite(sprite); + } + else + { + if (!gBattleAnimArgs[0]) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + } + + if (!gBattleAnimArgs[1]) + sprite->pos1.x += 32; + else + sprite->pos1.x -= 32; + + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[1]; + StartSpriteAnim(sprite, sprite->data[1]); + sprite->callback = AnimMovmentWaves_Step; + } +} + +static void AnimMovmentWaves_Step(struct Sprite *sprite) +{ + if (sprite->animEnded) + { + if (--sprite->data[0]) + StartSpriteAnim(sprite, sprite->data[1]); + else + DestroyAnimSprite(sprite); + } +} + +void AnimTask_UproarDistortion(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + + PrepareAffineAnimInTaskData(&gTasks[taskId], spriteId, gUnknown_08593B98); + gTasks[taskId].func = UproarDistortion_Step; +} + +static void UproarDistortion_Step(u8 taskId) +{ + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); +} + +void AnimJaggedMusicNote(struct Sprite *sprite) +{ + int var1; + u8 battler = !gBattleAnimArgs[0] ? gBattleAnimAttacker : gBattleAnimTarget; + + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + gBattleAnimArgs[1] *= -1; + + sprite->pos1.x = GetBattlerSpriteCoord(battler, 2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[2]; + sprite->data[0] = 0; + sprite->data[1] = (u16)sprite->pos1.x << 3; + sprite->data[2] = (u16)sprite->pos1.y << 3; + + var1 = gBattleAnimArgs[1] << 3; + if (var1 < 0) + var1 += 7; + sprite->data[3] = var1 >> 3; + + var1 = gBattleAnimArgs[2] << 3; + if (var1 < 0) + var1 += 7; + sprite->data[4] = var1 >> 3; + + sprite->oam.tileNum += gBattleAnimArgs[3] * 16; + sprite->callback = AnimJaggedMusicNote_Step; +} + +static void AnimJaggedMusicNote_Step(struct Sprite *sprite) +{ + sprite->data[1] += sprite->data[3]; + sprite->data[2] += sprite->data[4]; + sprite->pos1.x = sprite->data[1] >> 3; + sprite->pos1.y = sprite->data[2] >> 3; + if (++sprite->data[0] > 16) + DestroyAnimSprite(sprite); +} + +void AnimPerishSongMusicNote2(struct Sprite *sprite) +{ + if (!sprite->data[0]) + { + sprite->data[1] = 120 - gBattleAnimArgs[0]; + sprite->invisible = 1; + } + + if (++sprite->data[0] == sprite->data[1]) + SetGreyscaleOrOriginalPalette(sprite->oam.paletteNum + 16, 0); + + if (sprite->data[0] == sprite->data[1] + 80) + DestroyAnimSprite(sprite); +} + +void AnimPerishSongMusicNote(struct Sprite *sprite) +{ + int index; + int var2; + + if (!sprite->data[0]) + { + sprite->pos1.x = 120; + sprite->pos1.y = (gBattleAnimArgs[0] + (((u16)gBattleAnimArgs[0]) >> 31)) / 2 - 15; + + StartSpriteAnim(sprite, gBattleAnimArgs[1]); + + sprite->data[5] = 120; + sprite->data[3] = gBattleAnimArgs[2]; + } + + sprite->data[0]++; + + sprite->data[1] = (sprite->data[0] + ((u16)sprite->data[0] >> 31)) / 2; + index = ((sprite->data[0] * 3) + (u16)sprite->data[3]); + var2 = 0xFF; + sprite->data[6] = (sprite->data[6] + 10) & 0xFF; + + index &= var2; + sprite->pos2.x = Cos(index, 100); + + sprite->pos2.y = sprite->data[1] + Sin(index, 10) + Cos(sprite->data[6], 4); + + if (sprite->data[0] > sprite->data[5]) + { + sprite->callback = AnimPerishSongMusicNote_Step1; + + sprite->data[0] = 0; + SetSpritePrimaryCoordsFromSecondaryCoords(sprite); + sprite->data[2] = 5; + sprite->data[4] = 0; + sprite->data[3] = 0; + + StartSpriteAffineAnim(sprite, 1); + } +} + +static void AnimPerishSongMusicNote_Step1(struct Sprite *sprite) +{ + if (++sprite->data[0] > 10) + { + sprite->data[0] = 0; + sprite->callback = AnimPerishSongMusicNote_Step2; + } +} + +static void AnimPerishSongMusicNote_Step2(struct Sprite *sprite) +{ + sprite->data[3] += sprite->data[2]; + sprite->pos2.y = sprite->data[3]; + + sprite->data[2]++; + + if (sprite->data[3] > 48 && sprite->data[2] > 0) + { + sprite->data[2] = sprite->data[4] - 5; + sprite->data[4]++; + } + + if (sprite->data[4] > 3) + { + int var1 = sprite->data[2]; + sprite->invisible = var1 - (((s32)(var1 + ((u32)var1 >> 31)) >> 1) << 1); + DestroyAnimSprite(sprite); + } + + if (sprite->data[4] == 4) + { + DestroyAnimSprite(sprite); + } +} + +void AnimGuardRing(struct Sprite *sprite) +{ + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) && IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker))) + { + SetAverageBattlerPositions(gBattleAnimAttacker, 0, &sprite->pos1.x, &sprite->pos1.y); + sprite->pos1.y += 40; + + StartSpriteAffineAnim(sprite, 1); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + 40; + } + + sprite->data[0] = 13; + sprite->data[2] = sprite->pos1.x; + sprite->data[4] = sprite->pos1.y - 72; + + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimTask_IsFuryCutterHitRight(u8 taskId) +{ + gBattleAnimArgs[7] = gAnimDisableStructPtr->furyCutterCounter & 1; + DestroyAnimVisualTask(taskId); +} + +void AnimTask_GetFuryCutterHitCount(u8 taskId) +{ + gBattleAnimArgs[7] = gAnimDisableStructPtr->furyCutterCounter; + DestroyAnimVisualTask(taskId); +} diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c new file mode 100644 index 000000000..89f66139f --- /dev/null +++ b/src/battle_anim_effects_3.c @@ -0,0 +1,5495 @@ +#include "global.h" +#include "malloc.h" +#include "battle.h" +#include "battle_anim.h" +#include "bg.h" +#include "contest.h" +#include "data.h" +#include "decompress.h" +#include "dma3.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "palette.h" +#include "pokemon_icon.h" +#include "random.h" +#include "scanline_effect.h" +#include "sound.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" +#include "util.h" +#include "constants/battle_anim.h" +#include "constants/rgb.h" +#include "constants/songs.h" +#include "constants/species.h" +#include "constants/weather.h" + +extern const struct SpriteTemplate gThoughtBubbleSpriteTemplate; + +void AnimBlackSmoke(struct Sprite *); +void AnimWhiteHalo(struct Sprite *); +void AnimTealAlert(struct Sprite *); +void AnimMeanLookEye(struct Sprite *); +void AnimSpikes(struct Sprite *); +void AnimLeer(struct Sprite *); +void AnimLetterZ(struct Sprite *); +void AnimFang(struct Sprite *); +void AnimSpotlight(struct Sprite *); +void AnimClappingHand(struct Sprite *); +void AnimClappingHand2(struct Sprite *); +void AnimRapidSpin(struct Sprite *); +void AnimTriAttackTriangle(struct Sprite *); +void AnimBatonPassPokeball(struct Sprite *); +void AnimWishStar(struct Sprite *); +void AnimMiniTwinklingStar(struct Sprite *); +void AnimSwallowBlueOrb(struct Sprite *); +void AnimGreenStar(struct Sprite *); +void AnimWeakFrustrationAngerMark(struct Sprite *); +void AnimSweetScentPetal(struct Sprite *); +void AnimPainSplitProjectile(struct Sprite *); +void AnimFlatterConfetti(struct Sprite *); +void AnimFlatterSpotlight(struct Sprite *); +void AnimReversalOrb(struct Sprite *); +void AnimYawnCloud(struct Sprite *); +void AnimSmokeBallEscapeCloud(struct Sprite *); +void AnimFacadeSweatDrop(struct Sprite *); +void AnimRoarNoiseLine(struct Sprite *); +void AnimGlareEyeDot(struct Sprite *); +void AnimAssistPawprint(struct Sprite *); +void AnimSmellingSaltsHand(struct Sprite *); +void AnimSmellingSaltExclamation(struct Sprite *); +void AnimHelpingHandClap(struct Sprite *); +void AnimForesightMagnifyingGlass(struct Sprite *); +void AnimMeteorMashStar(struct Sprite *); +void AnimBlockX(struct Sprite *); +void sub_80E3E84(struct Sprite *); +void AnimParticuleBurst(struct Sprite *); +void AnimKnockOffStrike(struct Sprite *); +void AnimRecycle(struct Sprite *); +static void AnimBlackSmokeStep(struct Sprite *); +static void AnimWhiteHalo_Step1(struct Sprite *); +static void AnimWhiteHalo_Step2(struct Sprite *); +static void AnimMeanLookEye_Step1(struct Sprite *); +static void AnimMeanLookEye_Step2(struct Sprite *); +static void AnimMeanLookEye_Step3(struct Sprite *); +static void AnimMeanLookEye_Step4(struct Sprite *); +static void SetPsychicBackground_Step(u8); +static void FadeScreenToWhite_Step(u8); +static void AnimSpikes_Step1(struct Sprite *); +static void AnimSpikes_Step2(struct Sprite *); +static void AnimSpotlight_Step1(struct Sprite *); +static void AnimSpotlight_Step2(struct Sprite *); +static void AnimClappingHand_Step(struct Sprite *); +static void AnimRapidSpin_Step(struct Sprite *); +static void RapinSpinMonElevation_Step(u8); +static void TormentAttacker_Step(u8); +static void TormentAttacker_Callback(struct Sprite *); +static void AnimWishStar_Step(struct Sprite *); +static void AnimMiniTwinklingStar_Step(struct Sprite *); +static void AnimGreenStar_Step1(struct Sprite *); +static void AnimGreenStar_Step2(struct Sprite *); +static void AnimGreenStar_Callback(struct Sprite *); +static void AnimTask_RockMonBackAndForthStep(u8); +static void AnimSweetScentPetalStep(struct Sprite *); +static void AnimTask_FlailMovementStep(u8); +static void AnimFlatterConfettiStep(struct Sprite *); +static void AnimFlatterSpotlightStep(struct Sprite *); +static void AnimReversalOrbStep(struct Sprite *); +static void AnimTask_RolePlaySilhouetteStep1(u8); +static void AnimTask_RolePlaySilhouetteStep2(u8); +static void AnimTask_AcidArmorStep(u8); +static void AnimTask_DeepInhaleStep(u8); +static void AnimYawnCloudStep(struct Sprite *); +static void AnimTask_SquishAndSweatDropletsStep(u8); +static void CreateSweatDroplets(u8, bool8); +static void AnimTask_FacadeColorBlendStep(u8); +static void AnimRoarNoiseLineStep(struct Sprite *); +static void AnimTask_GlareEyeDotsStep(u8); +static void GetGlareEyeDotCoords(s16, s16, s16, s16, u8, u8, s16 *, s16 *); +static void AnimTask_BarrageBallStep(u8); +static void AnimSmellingSaltsHand_Step(struct Sprite *); +static void AnimTask_SmellingSaltsSquishStep(u8); +static void AnimSmellingSaltExclamationStep(struct Sprite *); +static void AnimHelpingHandClapStep(struct Sprite *); +static void AnimTask_HelpingHandAttackerMovementStep(u8); +static void AnimForesightMagnifyingGlassStep(struct Sprite *); +static void AnimTask_MonToSubstituteDoll(u8); +static void AnimBlockXStep(struct Sprite *); +static void AnimTask_OdorSleuthMovementWaitFinish(u8); +static void MoveOdorSleuthClone(struct Sprite *); +static void AnimTask_TeeterDanceMovementStep(u8); +static void AnimRecycleStep(struct Sprite *); +static void AnimTask_SlackOffSquishStep(u8); +const union AnimCmd gScratchAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_FRAME(64, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gScratchAnimTable[] = +{ + gScratchAnimCmds, +}; + +const struct SpriteTemplate gScratchSpriteTemplate = +{ + .tileTag = ANIM_TAG_SCRATCH, + .paletteTag = ANIM_TAG_SCRATCH, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gScratchAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const struct SpriteTemplate gBlackSmokeSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLACK_SMOKE, + .paletteTag = ANIM_TAG_BLACK_SMOKE, + .oam = &gOamData_AffineOff_ObjNormal_32x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBlackSmoke, +}; + +const struct SpriteTemplate gBlackBallSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLACK_BALL, + .paletteTag = ANIM_TAG_BLACK_BALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimThrowProjectile, +}; + +const union AnimCmd gOpeningEyeAnimCmds[] = +{ + ANIMCMD_FRAME(0, 40), + ANIMCMD_FRAME(16, 8), + ANIMCMD_FRAME(32, 40), + ANIMCMD_END, +}; + +const union AnimCmd *const gOpeningEyeAnimTable[] = +{ + gOpeningEyeAnimCmds, +}; + +const struct SpriteTemplate gOpeningEyeSpriteTemplate = +{ + .tileTag = ANIM_TAG_OPENING_EYE, + .paletteTag = ANIM_TAG_OPENING_EYE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gOpeningEyeAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const struct SpriteTemplate gWhiteHaloSpriteTemplate = +{ + .tileTag = ANIM_TAG_ROUND_WHITE_HALO, + .paletteTag = ANIM_TAG_ROUND_WHITE_HALO, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWhiteHalo, +}; + +const struct SpriteTemplate gTealAlertSpriteTemplate = +{ + .tileTag = ANIM_TAG_TEAL_ALERT, + .paletteTag = ANIM_TAG_TEAL_ALERT, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimTealAlert, +}; + +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x180, 0x180, 0, 0), + AFFINEANIMCMD_FRAME(-0x20, 0x18, 0, 5), + AFFINEANIMCMD_FRAME(0x18, -0x20, 0, 5), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x30, 0x30, 0, 0), + AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 6), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = +{ + gMeanLookEyeAffineAnimCmds1, + gMeanLookEyeAffineAnimCmds2, +}; + +const struct SpriteTemplate gMeanLookEyeSpriteTemplate = +{ + .tileTag = ANIM_TAG_EYE, + .paletteTag = ANIM_TAG_EYE, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gMeanLookEyeAffineAnimTable, + .callback = AnimMeanLookEye, +}; + +const struct SpriteTemplate gSpikesSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPIKES, + .paletteTag = ANIM_TAG_SPIKES, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpikes, +}; + +const union AnimCmd gLeerAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(64, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gLeerAnimTable[] = +{ + gLeerAnimCmds, +}; + +const struct SpriteTemplate gLeerSpriteTemplate = +{ + .tileTag = ANIM_TAG_LEER, + .paletteTag = ANIM_TAG_LEER, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gLeerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimLeer, +}; + +const union AnimCmd gLetterZAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gLetterZAnimTable[] = +{ + gLetterZAnimCmds, +}; + +const union AffineAnimCmd gLetterZAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-7, -7, -3, 16), + AFFINEANIMCMD_FRAME(7, 7, 3, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gLetterZAffineAnimTable[] = +{ + gLetterZAffineAnimCmds, +}; + +const struct SpriteTemplate gLetterZSpriteTemplate = +{ + .tileTag = ANIM_TAG_LETTER_Z, + .paletteTag = ANIM_TAG_LETTER_Z, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gLetterZAnimTable, + .images = NULL, + .affineAnims = gLetterZAffineAnimTable, + .callback = AnimLetterZ, +}; + +const union AnimCmd gFangAnimCmds[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(16, 16), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gFangAnimTable[] = +{ + gFangAnimCmds, +}; + +const union AffineAnimCmd gFangAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), + AFFINEANIMCMD_FRAME(-0x20, -0x20, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gFangAffineAnimTable[] = +{ + gFangAffineAnimCmds, +}; + +const struct SpriteTemplate gFangSpriteTemplate = +{ + .tileTag = ANIM_TAG_FANG_ATTACK, + .paletteTag = ANIM_TAG_FANG_ATTACK, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, + .anims = gFangAnimTable, + .images = NULL, + .affineAnims = gFangAffineAnimTable, + .callback = AnimFang, +}; + +const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x180, 0, 0), + AFFINEANIMCMD_FRAME(0x10, 0x0, 0, 20), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x140, 0x180, 0, 0), + AFFINEANIMCMD_FRAME(-0x10, 0x0, 0, 19), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = +{ + gSpotlightAffineAnimCmds1, + gSpotlightAffineAnimCmds2, +}; + +const struct SpriteTemplate gSpotlightSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPOTLIGHT, + .paletteTag = ANIM_TAG_SPOTLIGHT, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSpotlightAffineAnimTable, + .callback = AnimSpotlight, +}; + +const struct SpriteTemplate gClappingHandSpriteTemplate = +{ + .tileTag = ANIM_TAG_TAG_HAND, + .paletteTag = ANIM_TAG_TAG_HAND, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimClappingHand, +}; + +const struct SpriteTemplate gClappingHand2SpriteTemplate = +{ + .tileTag = ANIM_TAG_TAG_HAND, + .paletteTag = ANIM_TAG_TAG_HAND, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimClappingHand2, +}; + +const union AnimCmd gRapidSpinAnimCmds[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(8, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gRapidSpinAnimTable[] = +{ + gRapidSpinAnimCmds, +}; + +const struct SpriteTemplate gRapidSpinSpriteTemplate = +{ + .tileTag = ANIM_TAG_RAPID_SPIN, + .paletteTag = ANIM_TAG_RAPID_SPIN, + .oam = &gOamData_AffineOff_ObjNormal_32x16, + .anims = gRapidSpinAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRapidSpin, +}; + +const union AffineAnimCmd gUnknown_085CE2A0[] = +{ + AFFINEANIMCMD_FRAME(-12, 8, 0, 4), + AFFINEANIMCMD_FRAME(20, -20, 0, 4), + AFFINEANIMCMD_FRAME(-8, 12, 0, 4), + AFFINEANIMCMD_END, +}; + +const union AnimCmd gTriAttackTriangleAnimCmds[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_END, +}; + +const union AnimCmd *const gTriAttackTriangleAnimTable[] = +{ + gTriAttackTriangleAnimCmds, +}; + +const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 0, 5, 40), + AFFINEANIMCMD_FRAME(0, 0, 10, 10), + AFFINEANIMCMD_FRAME(0, 0, 15, 10), + AFFINEANIMCMD_FRAME(0, 0, 20, 40), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = +{ + gTriAttackTriangleAffineAnimCmds, +}; + +const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = +{ + .tileTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, + .paletteTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, + .anims = gTriAttackTriangleAnimTable, + .images = NULL, + .affineAnims = gTriAttackTriangleAffineAnimTable, + .callback = AnimTriAttackTriangle, +}; + +const union AnimCmd gEclipsingOrbAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(32, 3, .hFlip = TRUE), + ANIMCMD_FRAME(16, 3, .hFlip = TRUE), + ANIMCMD_FRAME(0, 3, .hFlip = TRUE), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd *const gEclipsingOrbAnimTable[] = +{ + gEclipsingOrbAnimCmds, +}; + +const struct SpriteTemplate gEclipsingOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_ECLIPSING_ORB, + .paletteTag = ANIM_TAG_ECLIPSING_ORB, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gEclipsingOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-12, 20, 0, 8), + AFFINEANIMCMD_FRAME(12, -20, 0, 8), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = +{ + .tileTag = ANIM_TAG_POKEBALL, + .paletteTag = ANIM_TAG_POKEBALL, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBatonPassPokeball, +}; + +const struct SpriteTemplate gWishStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_GOLD_STARS, + .paletteTag = ANIM_TAG_GOLD_STARS, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWishStar, +}; + +const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_GOLD_STARS, + .paletteTag = ANIM_TAG_GOLD_STARS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMiniTwinklingStar, +}; + +const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(8, -8, 0, 12), + AFFINEANIMCMD_FRAME(-16, 16, 0, 12), + AFFINEANIMCMD_FRAME(8, -8, 0, 12), + AFFINEANIMCMD_LOOP(1), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 6, 0, 20), + AFFINEANIMCMD_FRAME(0, 0, 0, 20), + AFFINEANIMCMD_FRAME(0, -18, 0, 6), + AFFINEANIMCMD_FRAME(-18, -18, 0, 3), + AFFINEANIMCMD_FRAME(0, 0, 0, 15), + AFFINEANIMCMD_FRAME(4, 4, 0, 13), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLUE_ORB, + .paletteTag = ANIM_TAG_BLUE_ORB, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSwallowBlueOrb, +}; + +const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 6, 0, 20), + AFFINEANIMCMD_FRAME(0, 0, 0, 20), + AFFINEANIMCMD_FRAME(7, -30, 0, 6), + AFFINEANIMCMD_FRAME(0, 0, 0, 20), + AFFINEANIMCMD_FRAME(-2, 3, 0, 20), + AFFINEANIMCMD_END, +}; + +const s8 gMorningSunLightBeamCoordsTable[] = +{ + 0xE8, + 0x18, + 0xFC, + 0x00, +}; + +const union AnimCmd gGreenStarAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(4, 6), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gGreenStarAnimCmds2[] = +{ + ANIMCMD_FRAME(8, 6), + ANIMCMD_END, +}; + +const union AnimCmd gGreenStarAnimCmds3[] = +{ + ANIMCMD_FRAME(12, 6), + ANIMCMD_END, +}; + +const union AnimCmd *const gGreenStarAnimTable[] = +{ + gGreenStarAnimCmds1, + gGreenStarAnimCmds2, + gGreenStarAnimCmds3, +}; + +const struct SpriteTemplate gGreenStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_GREEN_STAR, + .paletteTag = ANIM_TAG_GREEN_STAR, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gGreenStarAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimGreenStar, +}; + +const s8 gDoomDesireLightBeamCoordTable[] = +{ + 0x78, + 0x50, + 0x28, + 0x00, +}; + +const u8 gDoomDesireLightBeamDelayTable[] = +{ + 0, + 0, + 0, + 0, + 50, +}; + +const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, -15, 0, 7), + AFFINEANIMCMD_FRAME(0, 15, 0, 7), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = +{ + .tileTag = ANIM_TAG_ANGER, + .paletteTag = ANIM_TAG_ANGER, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWeakFrustrationAngerMark, +}; + +const union AnimCmd gSweetScentPetalAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(3, 8), + ANIMCMD_FRAME(3, 8, .vFlip = TRUE), + ANIMCMD_FRAME(2, 8, .vFlip = TRUE), + ANIMCMD_FRAME(0, 8, .vFlip = TRUE), + ANIMCMD_FRAME(1, 8, .vFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gSweetScentPetalAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 8, .hFlip = TRUE), + ANIMCMD_FRAME(1, 8, .hFlip = TRUE), + ANIMCMD_FRAME(2, 8, .hFlip = TRUE), + ANIMCMD_FRAME(3, 8, .hFlip = TRUE), + ANIMCMD_FRAME(3, 8, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(2, 8, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(0, 8, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(1, 8, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gSweetScentPetalAnimCmds3[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_END, +}; + +const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = +{ + gSweetScentPetalAnimCmds1, + gSweetScentPetalAnimCmds2, + gSweetScentPetalAnimCmds3, +}; + +const struct SpriteTemplate gSweetScentPetalSpriteTemplate = +{ + .tileTag = ANIM_TAG_PINK_PETAL, + .paletteTag = ANIM_TAG_PINK_PETAL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gSweetScentPetalAnimCmdTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSweetScentPetal, +}; + +const u16 gUnknown_085CE55C[] = INCBIN_U16("graphics/unknown/unknown_85CE55C.gbapal"); + +const union AnimCmd gPainSplitAnimCmds[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(4, 9), + ANIMCMD_FRAME(8, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gPainSplitAnimCmdTable[] = +{ + gPainSplitAnimCmds, +}; + +const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = +{ + .tileTag = ANIM_TAG_PAIN_SPLIT, + .paletteTag = ANIM_TAG_PAIN_SPLIT, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gPainSplitAnimCmdTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPainSplitProjectile, +}; + +const struct SpriteTemplate gFlatterConfettiSpriteTemplate = +{ + .tileTag = ANIM_TAG_CONFETTI, + .paletteTag = ANIM_TAG_CONFETTI, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFlatterConfetti, +}; + +const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPOTLIGHT, + .paletteTag = ANIM_TAG_SPOTLIGHT, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSpotlightAffineAnimTable, + .callback = AnimFlatterSpotlight, +}; + +const struct SpriteTemplate gReversalOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLUE_ORB, + .paletteTag = ANIM_TAG_BLUE_ORB, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimReversalOrb, +}; + +const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(16, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, -3, 0, 16), + AFFINEANIMCMD_FRAME(4, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 24), + AFFINEANIMCMD_FRAME(-5, 3, 0, 16), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), + AFFINEANIMCMD_FRAME(-8, -8, 0, 8), + AFFINEANIMCMD_FRAME(8, 8, 0, 8), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), + AFFINEANIMCMD_FRAME(8, 8, 0, 8), + AFFINEANIMCMD_FRAME(-8, -8, 0, 8), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(8, 8, 0, 8), + AFFINEANIMCMD_FRAME(-8, -8, 0, 8), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = +{ + gYawnCloudAffineAnimCmds1, + gYawnCloudAffineAnimCmds2, + gYawnCloudAffineAnimCmds3, +}; + +const struct SpriteTemplate gYawnCloudSpriteTemplate = +{ + .tileTag = ANIM_TAG_PINK_CLOUD, + .paletteTag = ANIM_TAG_PINK_CLOUD, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gYawnCloudAffineAnimTable, + .callback = AnimYawnCloud, +}; + +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), + AFFINEANIMCMD_FRAME(-4, -6, 0, 16), + AFFINEANIMCMD_FRAME(4, 6, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), + AFFINEANIMCMD_FRAME(4, 6, 0, 16), + AFFINEANIMCMD_FRAME(-4, -6, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(4, 6, 0, 16), + AFFINEANIMCMD_FRAME(-4, -6, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(8, 10, 0, 30), + AFFINEANIMCMD_FRAME(-8, -10, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = +{ + gSmokeBallEscapeCloudAffineAnimCmds1, + gSmokeBallEscapeCloudAffineAnimCmds2, + gSmokeBallEscapeCloudAffineAnimCmds3, + gSmokeBallEscapeCloudAffineAnimCmds4, +}; + +const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = +{ + .tileTag = ANIM_TAG_PINK_CLOUD, + .paletteTag = ANIM_TAG_PINK_CLOUD, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSmokeBallEscapeCloudAffineAnimTable, + .callback = AnimSmokeBallEscapeCloud, +}; + +const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-16, 16, 0, 6), + AFFINEANIMCMD_FRAME(16, -16, 0, 12), + AFFINEANIMCMD_FRAME(-16, 16, 0, 6), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = +{ + .tileTag = ANIM_TAG_SWEAT_DROP, + .paletteTag = ANIM_TAG_SWEAT_DROP, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFacadeSweatDrop, +}; + +const u16 gFacadeBlendColors[] = { + RGB(28, 25, 1), + RGB(28, 21, 5), + RGB(27, 18, 8), + RGB(27, 14, 11), + RGB(26, 10, 15), + RGB(26, 7, 18), + RGB(25, 3, 21), + RGB(25, 0, 25), + RGB(25, 0, 23), + RGB(25, 0, 20), + RGB(25, 0, 16), + RGB(25, 0, 13), + RGB(26, 0, 10), + RGB(26, 0, 6), + RGB(26, 0, 3), + RGB(27, 0, 0), + RGB(27, 1, 0), + RGB(27, 5, 0), + RGB(27, 9, 0), + RGB(27, 12, 0), + RGB(28, 16, 0), + RGB(28, 19, 0), + RGB(28, 23, 0), + RGB(29, 27, 0), +}; + +const union AnimCmd gRoarNoiseLineAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gRoarNoiseLineAnimCmds2[] = +{ + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gRoarNoiseLineAnimTable[] = +{ + gRoarNoiseLineAnimCmds1, + gRoarNoiseLineAnimCmds2, +}; + +const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = +{ + .tileTag = ANIM_TAG_NOISE_LINE, + .paletteTag = ANIM_TAG_NOISE_LINE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gRoarNoiseLineAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRoarNoiseLine, +}; + +const struct SpriteTemplate gGlareEyeDotSpriteTemplate = +{ + .tileTag = ANIM_TAG_SMALL_RED_EYE, + .paletteTag = ANIM_TAG_SMALL_RED_EYE, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimGlareEyeDot, +}; + +const struct SpriteTemplate gAssistPawprintSpriteTemplate = +{ + .tileTag = ANIM_TAG_PAW_PRINT, + .paletteTag = ANIM_TAG_PAW_PRINT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimAssistPawprint, +}; + +const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0, 0, -4, 24), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), + AFFINEANIMCMD_FRAME(0, 0, 4, 24), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = +{ + gBarrageBallAffineAnimCmds1, + gBarrageBallAffineAnimCmds2, +}; + +const struct SpriteTemplate gBarrageBallSpriteTemplate = +{ + .tileTag = ANIM_TAG_RED_BALL, + .paletteTag = ANIM_TAG_RED_BALL, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gBarrageBallAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = +{ + .tileTag = ANIM_TAG_TAG_HAND, + .paletteTag = ANIM_TAG_TAG_HAND, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSmellingSaltsHand, +}; + +const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, -16, 0, 6), + AFFINEANIMCMD_FRAME(0, 16, 0, 6), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = +{ + .tileTag = ANIM_TAG_SMELLINGSALT_EFFECT, + .paletteTag = ANIM_TAG_SMELLINGSALT_EFFECT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSmellingSaltExclamation, +}; + +const struct SpriteTemplate gHelpingHandClapSpriteTemplate = +{ + .tileTag = ANIM_TAG_TAG_HAND, + .paletteTag = ANIM_TAG_TAG_HAND, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimHelpingHandClap, +}; + +const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = +{ + .tileTag = ANIM_TAG_MAGNIFYING_GLASS, + .paletteTag = ANIM_TAG_MAGNIFYING_GLASS, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimForesightMagnifyingGlass, +}; + +const struct SpriteTemplate gMeteorMashStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_GOLD_STARS, + .paletteTag = ANIM_TAG_GOLD_STARS, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMeteorMashStar, +}; + +const struct SpriteTemplate gUnknown_085CE8F4 = +{ + .tileTag = ANIM_TAG_GOLD_STARS, + .paletteTag = ANIM_TAG_GOLD_STARS, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimParticuleBurst, +}; + +const struct SpriteTemplate gBlockXSpriteTemplate = +{ + .tileTag = ANIM_TAG_X_SIGN, + .paletteTag = ANIM_TAG_X_SIGN, + .oam = &gOamData_AffineOff_ObjNormal_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBlockX, +}; + +const struct SpriteTemplate gUnknown_085CE924 = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_815FE80, +}; + +const union AnimCmd gKnockOffStrikeAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(64, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gKnockOffStrikeAnimTable[] = +{ + gKnockOffStrikeAnimCmds, +}; + +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, -4, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = +{ + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, 4, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = +{ + gKnockOffStrikeAffineanimCmds1, + gKnockOffStrikeAffineanimCmds2, +}; + +const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLAM_HIT_2, + .paletteTag = ANIM_TAG_SLAM_HIT_2, + .oam = &gOamData_AffineNormal_ObjNormal_64x64, + .anims = gKnockOffStrikeAnimTable, + .images = NULL, + .affineAnims = gKnockOffStrikeAffineAnimTable, + .callback = AnimKnockOffStrike, +}; + +const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 0, -4, 64), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = +{ + gRecycleSpriteAffineAnimCmds, +}; + +const struct SpriteTemplate gRecycleSpriteTemplate = +{ + .tileTag = ANIM_TAG_RECYCLE, + .paletteTag = ANIM_TAG_RECYCLE, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gRecycleSpriteAffineAnimTable, + .callback = AnimRecycle, +}; + +const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 16, 0, 4), + AFFINEANIMCMD_FRAME(-2, 0, 0, 8), + AFFINEANIMCMD_FRAME(0, 4, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 24), + AFFINEANIMCMD_FRAME(1, -5, 0, 16), + AFFINEANIMCMD_END, +}; + +// Functions +void AnimBlackSmoke(struct Sprite *sprite) +{ + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + + if (!gBattleAnimArgs[3]) + sprite->data[0] = gBattleAnimArgs[2]; + else + sprite->data[0] = -gBattleAnimArgs[2]; + + sprite->data[1] = gBattleAnimArgs[4]; + sprite->callback = AnimBlackSmokeStep; +} + +static void AnimBlackSmokeStep(struct Sprite *sprite) +{ + if (sprite->data[1] > 0) + { + sprite->pos2.x = sprite->data[2] >> 8; + sprite->data[2] += sprite->data[0]; + sprite->invisible ^= 1; + sprite->data[1]--; + } + else + { + DestroyAnimSprite(sprite); + } +} + +void AnimTask_SmokescreenImpact(u8 taskId) +{ + SmokescreenImpact( + GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 8, + GetBattlerSpriteCoord(gBattleAnimTarget, 3) + 8, + 0); + DestroyAnimVisualTask(taskId); +} + +void AnimWhiteHalo(struct Sprite *sprite) +{ + sprite->data[0] = 90; + sprite->callback = WaitAnimForDuration; + sprite->data[1] = 7; + StoreSpriteCallbackInData6(sprite, AnimWhiteHalo_Step1); + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[1], 16 - sprite->data[1])); +} + +static void AnimWhiteHalo_Step1(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[1], 16 - sprite->data[1])); + if (--sprite->data[1] < 0) + { + sprite->invisible = 1; + sprite->callback = AnimWhiteHalo_Step2; + } +} + +static void AnimWhiteHalo_Step2(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimSprite(sprite); +} + +void AnimTealAlert(struct Sprite *sprite) +{ + u16 rotation; + u8 x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + u8 y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + + InitSpritePosToAnimTarget(sprite, TRUE); + + rotation = ArcTan2Neg(sprite->pos1.x - x, sprite->pos1.y - y); + rotation += 0x6000; + if (IsContest()) + rotation += 0x4000; + + TrySetSpriteRotScale(sprite, FALSE, 0x100, 0x100, rotation); + + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = x; + sprite->data[4] = y; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimMeanLookEye(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + sprite->data[0] = 4; + sprite->callback = AnimMeanLookEye_Step1; +} + +static void AnimMeanLookEye_Step1(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 16 - sprite->data[0])); + + if (sprite->data[1]) + sprite->data[0]--; + else + sprite->data[0]++; + + if (sprite->data[0] == 15 || sprite->data[0] == 4) + sprite->data[1] ^= 1; + + if (sprite->data[2]++ > 70) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + StartSpriteAffineAnim(sprite, 1); + sprite->data[2] = 0; + sprite->invisible = 1; + sprite->affineAnimPaused = 1; + sprite->callback = AnimMeanLookEye_Step2; + } +} + +static void AnimMeanLookEye_Step2(struct Sprite *sprite) +{ + if (sprite->data[2]++ > 9) + { + sprite->invisible = 0; + sprite->affineAnimPaused = 0; + if (sprite->affineAnimEnded) + sprite->callback = AnimMeanLookEye_Step3; + } +} + +static void AnimMeanLookEye_Step3(struct Sprite *sprite) +{ + switch (sprite->data[3]) + { + case 0: + case 1: + sprite->pos2.x = 1; + sprite->pos2.y = 0; + break; + case 2: + case 3: + sprite->pos2.x = -1; + sprite->pos2.y = 0; + break; + case 4: + case 5: + sprite->pos2.x = 0; + sprite->pos2.y = 1; + break; + case 6: + default: + sprite->pos2.x = 0; + sprite->pos2.y = -1; + break; + } + + if (++sprite->data[3] > 7) + sprite->data[3] = 0; + + if (sprite->data[4]++ > 15) + { + sprite->data[0] = 16; + sprite->data[1] = 0; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 0)); + sprite->callback = AnimMeanLookEye_Step4; + } +} + +static void AnimMeanLookEye_Step4(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 16 - sprite->data[0])); + + if (sprite->data[1]++ > 1) + { + sprite->data[0]--; + sprite->data[1] = 0; + } + + if (sprite->data[0] == 0) + sprite->invisible = 1; + + if (sprite->data[0] < 0) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimSprite(sprite); + } +} + +void AnimTask_SetPsychicBackground(u8 taskId) +{ + gTasks[taskId].func = SetPsychicBackground_Step; + gAnimVisualTaskCount--; +} + +static void SetPsychicBackground_Step(u8 taskId) +{ + int i; + u16 lastColor; + u8 paletteIndex = GetBattleBgPaletteNum(); + + if (++gTasks[taskId].data[5] == 4) + { + lastColor = gPlttBufferFaded[paletteIndex * 16 + 11]; + for (i = 10; i > 0; i--) + gPlttBufferFaded[paletteIndex * 16 + i + 1] = gPlttBufferFaded[paletteIndex * 16 + i]; + + gPlttBufferFaded[paletteIndex * 16 + 1] = lastColor; + gTasks[taskId].data[5] = 0; + } + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + DestroyTask(taskId); +} + +void AnimTask_FadeScreenToWhite(u8 taskId) +{ + gTasks[taskId].func = FadeScreenToWhite_Step; + gAnimVisualTaskCount--; +} + +static void FadeScreenToWhite_Step(u8 taskId) +{ + int i; + u16 lastColor; + u8 paletteIndex = GetBattleBgPaletteNum(); + + if (++gTasks[taskId].data[5] == 4) + { + lastColor = gPlttBufferFaded[paletteIndex * 16 + 11]; + for (i = 10; i > 0; i--) + gPlttBufferFaded[paletteIndex * 16 + i + 1] = gPlttBufferFaded[paletteIndex * 16 + i]; + gPlttBufferFaded[paletteIndex * 16 + 1] = lastColor; + + lastColor = gPlttBufferUnfaded[paletteIndex * 16 + 11]; + for (i = 10; i > 0; i--) + gPlttBufferUnfaded[paletteIndex * 16 + i + 1] = gPlttBufferUnfaded[paletteIndex * 16 + i]; + gPlttBufferUnfaded[paletteIndex * 16 + 1] = lastColor; + + gTasks[taskId].data[5] = 0; + } + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + DestroyTask(taskId); +} + +void AnimSpikes(struct Sprite *sprite) +{ + u16 x; + u16 y; + + InitSpritePosToAnimAttacker(sprite, TRUE); + SetAverageBattlerPositions(gBattleAnimTarget, FALSE, &x, &y); + + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = x + gBattleAnimArgs[2]; + sprite->data[4] = y + gBattleAnimArgs[3]; + sprite->data[5] = -50; + + InitAnimArcTranslation(sprite); + sprite->callback = AnimSpikes_Step1; +} + +static void AnimSpikes_Step1(struct Sprite *sprite) +{ + if (TranslateAnimHorizontalArc(sprite)) + { + sprite->data[0] = 30; + sprite->data[1] = 0; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimSpikes_Step2); + } +} + +static void AnimSpikes_Step2(struct Sprite *sprite) +{ + if (sprite->data[1] & 1) + sprite->invisible ^= 1; + + if (++sprite->data[1] == 16) + DestroyAnimSprite(sprite); +} + +void AnimLeer(struct Sprite *sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->callback = RunStoredCallbackWhenAnimEnds; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimLetterZ(struct Sprite *sprite) +{ + int var0; + if (sprite->data[0] == 0) + { + SetSpriteCoordsToAnimAttackerCoords(sprite); + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + if (!IsContest()) + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->data[1] = gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[3]; + } + else + { + sprite->data[1] = -1 * gBattleAnimArgs[2]; + sprite->data[2] = -1 * gBattleAnimArgs[3]; + } + } + else + { + sprite->data[1] = -1 * gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[3]; + } + } + + sprite->data[0]++; + var0 = (sprite->data[0] * 20) & 0xFF; + sprite->data[3] += sprite->data[1]; + sprite->data[4] += sprite->data[2]; + sprite->pos2.x = sprite->data[3] / 2; + sprite->pos2.y = Sin(var0 & 0xFF, 5) + (sprite->data[4] / 2); + + if ((u16)(sprite->pos1.x + sprite->pos2.x) > 240) + DestroyAnimSprite(sprite); +} + +void AnimFang(struct Sprite *sprite) +{ + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimTask_IsTargetPlayerSide(u8 taskId) +{ + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) + gBattleAnimArgs[7] = 0; + else + gBattleAnimArgs[7] = 1; + + DestroyAnimVisualTask(taskId); +} + +void AnimTask_IsHealingMove(u8 taskId) +{ + if (gAnimMoveDmg > 0) + gBattleAnimArgs[7] = 0; + else + gBattleAnimArgs[7] = 1; + + DestroyAnimVisualTask(taskId); +} + +void AnimSpotlight(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJWIN_ON); + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); + SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); + + InitSpritePosToAnimTarget(sprite, FALSE); + + sprite->oam.objMode = ST_OAM_OBJ_WINDOW; + sprite->invisible = 1; + sprite->callback = AnimSpotlight_Step1; +} + +static void AnimSpotlight_Step1(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->invisible = 0; + if (sprite->affineAnimEnded) + sprite->data[0]++; + break; + case 1: + case 3: + sprite->data[1] += 117; + sprite->pos2.x = sprite->data[1] >> 8; + if (++sprite->data[2] == 21) + { + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 2: + sprite->data[1] -= 117; + sprite->pos2.x = sprite->data[1] >> 8; + if (++sprite->data[2] == 41) + { + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 4: + ChangeSpriteAffineAnim(sprite, 1); + sprite->data[0]++; + break; + case 5: + if (sprite->affineAnimEnded) + { + sprite->invisible = 1; + sprite->callback = AnimSpotlight_Step2; + } + break; + } +} + +static void AnimSpotlight_Step2(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + SetGpuReg(REG_OFFSET_DISPCNT, GetGpuReg(REG_OFFSET_DISPCNT) ^ DISPCNT_OBJWIN_ON); + DestroyAnimSprite(sprite); +} + +void AnimClappingHand(struct Sprite *sprite) +{ + if (gBattleAnimArgs[3] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + } + + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->oam.tileNum += 16; + + if (gBattleAnimArgs[2] == 0) + { + sprite->oam.matrixNum = ST_OAM_HFLIP; + sprite->pos2.x = -12; + sprite->data[1] = 2; + } + else + { + sprite->pos2.x = 12; + sprite->data[1] = -2; + } + + sprite->data[0] = gBattleAnimArgs[4]; + + if (sprite->data[3] != 255) + sprite->data[3] = gBattleAnimArgs[2]; + + sprite->callback = AnimClappingHand_Step; +} + +static void AnimClappingHand_Step(struct Sprite *sprite) +{ + if (sprite->data[2] == 0) + { + sprite->pos2.x += sprite->data[1]; + if (sprite->pos2.x == 0) + { + sprite->data[2]++; + if (sprite->data[3] == 0) + { + PlaySE1WithPanning(SE_W227, BattleAnimAdjustPanning(-64)); + } + } + } + else + { + sprite->pos2.x -= sprite->data[1]; + if (abs(sprite->pos2.x) == 12) + { + sprite->data[0]--; + sprite->data[2]--; + } + + } + + if (sprite->data[0] == 0) + DestroyAnimSprite(sprite); +} + +void AnimClappingHand2(struct Sprite *sprite) +{ + sprite->oam.objMode = ST_OAM_OBJ_WINDOW; + sprite->data[3] = 255; + AnimClappingHand(sprite); +} + +void AnimTask_CreateSpotlight(u8 taskId) +{ + if (IsContest()) + { + SetGpuReg(REG_OFFSET_WININ, 0x1F3F); + gBattle_WIN1H = 0x98F0; + gBattle_WIN1V = 0x00A0; + SetGpuReg(REG_OFFSET_WIN1H, gBattle_WIN0H); + SetGpuReg(REG_OFFSET_WIN1V, gBattle_WIN0V); + } + else + { + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ); + gBattle_WIN1H = 0x00F0; + gBattle_WIN1V = 0x78A0; + SetGpuReg(REG_OFFSET_WIN1H, 0x00F0); + SetGpuReg(REG_OFFSET_WIN1V, gBattle_WIN1V); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON); + } + + DestroyAnimVisualTask(taskId); +} + +void AnimTask_RemoveSpotlight(u8 taskId) +{ + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); + gBattle_WIN1H = 0; + gBattle_WIN1V = 0; + if (!IsContest()) + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON); + + DestroyAnimVisualTask(taskId); +} + +void AnimRapidSpin(struct Sprite *sprite) +{ + if (gBattleAnimArgs[0] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + } + + sprite->pos2.y = gBattleAnimArgs[2]; + + sprite->data[0] = (sprite->pos2.y > gBattleAnimArgs[3]); + sprite->data[1] = 0; + sprite->data[2] = gBattleAnimArgs[4]; + sprite->data[3] = gBattleAnimArgs[5]; + sprite->data[4] = gBattleAnimArgs[3]; + sprite->callback = AnimRapidSpin_Step; +} + +static void AnimRapidSpin_Step(struct Sprite *sprite) +{ + sprite->data[1] = (sprite->data[1] + sprite->data[2]) & 0xFF; + sprite->pos2.x = gSineTable[sprite->data[1]] >> 4; + sprite->pos2.y += sprite->data[3]; + + if (sprite->data[0]) + { + if (sprite->pos2.y < sprite->data[4]) + DestroyAnimSprite(sprite); + } + else + { + if (sprite->pos2.y > sprite->data[4]) + DestroyAnimSprite(sprite); + } +} + +void AnimTask_RapinSpinMonElevation(u8 taskId) +{ + s16 var0; + u8 toBG2; + s16 var2; + int var3; + int var4; + s16 i; + struct ScanlineEffectParams scanlineParams; + struct Task *task = &gTasks[taskId]; + + if (!gBattleAnimArgs[0]) + { + var0 = GetBattlerYCoordWithElevation(gBattleAnimAttacker); + toBG2 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); + } + else + { + var0 = GetBattlerYCoordWithElevation(gBattleAnimTarget); + toBG2 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); + } + + task->data[0] = var0 + 36; + task->data[1] = task->data[0]; + task->data[2] = var0 - 33; + if (task->data[2] < 0) + task->data[2] = 0; + + task->data[3] = task->data[0]; + task->data[4] = 8; + task->data[5] = gBattleAnimArgs[1]; + task->data[6] = 0; + task->data[7] = 0; + + if (toBG2 == 1) + { + var3 = gBattle_BG1_X; + task->data[8] = var3; + var4 = var3 + 240; + } + else + { + var3 = gBattle_BG2_X; + task->data[8] = var3; + var4 = var3 + 240; + } + + task->data[9] = var4; + task->data[10] = gBattleAnimArgs[2]; + + if (!gBattleAnimArgs[2]) + { + task->data[11] = var4; + var2 = task->data[8]; + } + else + { + task->data[11] = var3; + var2 = task->data[9]; + } + + task->data[15] = 0; + + i = task->data[2]; + while (i <= task->data[3]) + { + gScanlineEffectRegBuffers[0][i] = var2; + gScanlineEffectRegBuffers[1][i] = var2; + i++; + } + + if (toBG2 == 1) + scanlineParams.dmaDest = ®_BG1HOFS; + else + scanlineParams.dmaDest = ®_BG2HOFS; + + scanlineParams.dmaControl = SCANLINE_EFFECT_DMACNT_16BIT; + scanlineParams.initState = 1; + scanlineParams.unused9 = 0; + ScanlineEffect_SetParams(scanlineParams); + + task->func = RapinSpinMonElevation_Step; +} + +static void RapinSpinMonElevation_Step(u8 taskId) +{ + s16 i; + struct Task *task = &gTasks[taskId]; + + task->data[0] -= task->data[5]; + if (task->data[0] < task->data[2]) + task->data[0] = task->data[2]; + + if (task->data[4] == 0) + { + task->data[1] -= task->data[5]; + if (task->data[1] < task->data[2]) + { + task->data[1] = task->data[2]; + task->data[15] = 1; + } + } + else + { + task->data[4]--; + } + + if (++task->data[6] > 1) + { + task->data[6] = 0; + task->data[7] = task->data[7] == 0 ? 1 : 0; + + if (task->data[7]) + task->data[12] = task->data[8]; + else + task->data[12] = task->data[9]; + } + + i = task->data[0]; + while (i < task->data[1]) + { + gScanlineEffectRegBuffers[0][i] = task->data[12]; + gScanlineEffectRegBuffers[1][i] = task->data[12]; + i++; + } + + i = task->data[1]; + while (i <= task->data[3]) + { + gScanlineEffectRegBuffers[0][i] = task->data[11]; + gScanlineEffectRegBuffers[1][i] = task->data[11]; + i++; + } + + if (task->data[15]) + { + if (task->data[10]) + gScanlineEffect.state = 3; + + DestroyAnimVisualTask(taskId); + } +} + +void AnimTask_TormentAttacker(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + task->data[3] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + task->data[4] = 32; + task->data[5] = -20; + task->data[6] = 0; + task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->func = TormentAttacker_Step; +} + +static void TormentAttacker_Step(u8 taskId) +{ + int var0, var1; + s16 x, y; + u16 i, j; + u8 spriteId; + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + var0 = task->data[2]; + if (task->data[1] & 1) + { + var1 = task->data[4]; + x = var0 - var1; + } + else + { + var1 = task->data[4]; + x = var0 + var1; + } + + y = task->data[3] + task->data[5]; + spriteId = CreateSprite(&gThoughtBubbleSpriteTemplate, x, y, 6 - task->data[1]); + PlaySE12WithPanning(SE_W118, BattleAnimAdjustPanning(-64)); + + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].hFlip = task->data[1] & 1; + gSprites[spriteId].callback = SpriteCallbackDummy; + } + + if (task->data[1] & 1) + { + task->data[4] -= 6; + task->data[5] -= 6; + } + + PrepareAffineAnimInTaskData(task, task->data[15], gUnknown_085CE2A0); + task->data[1]++; + task->data[0] = 1; + break; + case 1: + if (!RunAffineAnimFromTaskData(task)) + { + if (task->data[1] == 6) + { + task->data[6] = 8; + task->data[0] = 3; + } + else + { + if (task->data[1] <= 2) + task->data[6] = 10; + else + task->data[6] = 0; + + task->data[0] = 2; + } + } + break; + case 2: + if (task->data[6] != 0) + task->data[6]--; + else + task->data[0] = 0; + break; + case 3: + if (task->data[6] != 0) + task->data[6]--; + else + task->data[0] = 4; + break; + case 4: + for (i = 0, j = 0; i < MAX_SPRITES; i++) + { + if (gSprites[i].template == &gThoughtBubbleSpriteTemplate) + { + gSprites[i].data[0] = taskId; + gSprites[i].data[1] = 6; + StartSpriteAnim(&gSprites[i], 2); + gSprites[i].callback = TormentAttacker_Callback; + + if (++j == 6) + break; + } + } + + task->data[6] = j; + task->data[0] = 5; + break; + case 5: + if (task->data[6] == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +static void TormentAttacker_Callback(struct Sprite *sprite) +{ + if (sprite->animEnded) + { + gTasks[sprite->data[0]].data[sprite->data[1]]--; + DestroySprite(sprite); + } +} + +void AnimTriAttackTriangle(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + InitSpritePosToAnimAttacker(sprite, FALSE); + + if (++sprite->data[0] < 40) + { + u16 var = sprite->data[0]; + if ((var & 1) == 0) + sprite->invisible = 1; + else + sprite->invisible = 0; + } + + if (sprite->data[0] > 30) + sprite->invisible = 0; + + if (sprite->data[0] == 61) + { + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 20; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->callback = StartAnimLinearTranslation; + } +} + +void AnimTask_DefenseCurlDeformMon(u8 taskId) +{ + switch (gTasks[taskId].data[0]) + { + case 0: + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE350); + gTasks[taskId].data[0]++; + break; + case 1: + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimBatonPassPokeball(struct Sprite *sprite) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + + switch (sprite->data[0]) + { + case 0: + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + sprite->data[1] = 256; + sprite->data[2] = 256; + sprite->data[0]++; + break; + case 1: + sprite->data[1] += 96; + sprite->data[2] -= 26; + SetSpriteRotScale(spriteId, sprite->data[1], sprite->data[2], 0); + + if (++sprite->data[3] == 5) + sprite->data[0]++; + // fall through + case 2: + sprite->data[1] += 96; + sprite->data[2] += 48; + SetSpriteRotScale(spriteId, sprite->data[1], sprite->data[2], 0); + + if (++sprite->data[3] == 9) + { + sprite->data[3] = 0; + gSprites[spriteId].invisible = 1; + ResetSpriteRotScale(spriteId); + sprite->data[0]++; + } + break; + case 3: + sprite->pos2.y -= 6; + if (sprite->pos1.y + sprite->pos2.y < -32) + DestroyAnimSprite(sprite); + break; + } +} + +void AnimWishStar(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x = -16; + else + sprite->pos1.x = 256; + + sprite->pos1.y = 0; + sprite->callback = AnimWishStar_Step; +} + +static void AnimWishStar_Step(struct Sprite *sprite) +{ + u32 newX; + + sprite->data[0] += 72; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos2.x = sprite->data[0] >> 4; + else + sprite->pos2.x = -(sprite->data[0] >> 4); + + sprite->data[1] += 16; + sprite->pos2.y += sprite->data[1] >> 8; + + if (++sprite->data[2] % 3 == 0) + { + CreateSpriteAndAnimate( + &gMiniTwinklingStarSpriteTemplate, + sprite->pos1.x + sprite->pos2.x, + sprite->pos1.y + sprite->pos2.y, + sprite->subpriority + 1); + } + + newX = sprite->pos1.x + sprite->pos2.x + 32; + if (newX > 304) + DestroyAnimSprite(sprite); +} + +void AnimMiniTwinklingStar(struct Sprite *sprite) +{ + u8 rand; + s8 y; + + rand = Random2() & 3; + if (rand == 0) + sprite->oam.tileNum += 4; + else + sprite->oam.tileNum += 5; + + y = Random2() & 7; + if (y > 3) + y = -y; + + sprite->pos2.y = y; + sprite->callback = AnimMiniTwinklingStar_Step; +} + +static void AnimMiniTwinklingStar_Step(struct Sprite *sprite) +{ + if (++sprite->data[0] < 30) + { + if (++sprite->data[1] == 2) + { + sprite->invisible ^= 1; + sprite->data[1] = 0; + } + } + else + { + if (sprite->data[1] == 2) + sprite->invisible = 0; + + if (sprite->data[1] == 3) + { + sprite->invisible = 1; + sprite->data[1] = -1; + } + + sprite->data[1]++; + } + + if (sprite->data[0] > 60) + DestroySprite(sprite); +} + +void AnimTask_StockpileDeformMon(u8 taskId) +{ + if (!gTasks[taskId].data[0]) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE3B8); + gTasks[taskId].data[0]++; + } + else + { + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + } +} + +void AnimTask_SpitUpDeformMon(u8 taskId) +{ + if (!gTasks[taskId].data[0]) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE3E0); + gTasks[taskId].data[0]++; + } + else + { + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + } +} + +void AnimSwallowBlueOrb(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + InitSpritePosToAnimAttacker(sprite, FALSE); + sprite->data[1] = 0x900; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->data[0]++; + break; + case 1: + sprite->pos2.y -= sprite->data[1] >> 8; + sprite->data[1] -= 96; + if (sprite->pos1.y + sprite->pos2.y > sprite->data[2]) + DestroyAnimSprite(sprite); + break; + } +} + +void AnimTask_SwallowDeformMon(u8 taskId) +{ + if (!gTasks[taskId].data[0]) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE430); + gTasks[taskId].data[0]++; + } + else + { + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + } +} + +void AnimTask_TransformMon(u8 taskId) +{ + int i, j; + u8 position; + struct BattleAnimBgData animBg; + u8 *dest; + u8 *src; + u16 *bgTilemap; + u16 stretch; + + switch (gTasks[taskId].data[0]) + { + case 0: + SetGpuReg(REG_OFFSET_MOSAIC, 0); + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) + SetAnimBgAttribute(1, BG_ANIM_MOSAIC, 1); + else + SetAnimBgAttribute(2, BG_ANIM_MOSAIC, 1); + + gTasks[taskId].data[10] = gBattleAnimArgs[0]; + gTasks[taskId].data[0]++; + break; + case 1: + if (gTasks[taskId].data[2]++ > 1) + { + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[1]++; + stretch = gTasks[taskId].data[1]; + SetGpuReg(REG_OFFSET_MOSAIC, (stretch << 4) | stretch); + if (stretch == 15) + gTasks[taskId].data[0]++; + } + break; + case 2: + HandleSpeciesGfxDataChange(gBattleAnimAttacker, gBattleAnimTarget, gTasks[taskId].data[10]); + sub_80A6BFC(&animBg, gBattleAnimAttacker); + + if (IsContest()) + position = 0; + else + position = GetBattlerPosition(gBattleAnimAttacker); + + src = gMonSpritesGfxPtr->sprites[position] + (gBattleMonForms[gBattleAnimAttacker] << 11); + dest = animBg.bgTiles; + CpuCopy32(src, dest, 0x800); + LoadBgTiles(1, animBg.bgTiles, 0x800, animBg.tilesOffset); + if (IsContest()) + { + if (IsSpeciesNotUnown(gContestResources->field_18->species) != IsSpeciesNotUnown(gContestResources->field_18->unk2)) + { + bgTilemap = (u16 *)animBg.bgTilemap; + for (i = 0; i < 8; i++) + { + for (j = 0; j < 4; j++) + { + u16 temp = bgTilemap[j + i * 0x20]; + bgTilemap[j + i * 0x20] = bgTilemap[(7 - j) + i * 0x20]; + bgTilemap[(7 - j) + i * 0x20] = temp; + } + } + + for (i = 0; i < 8; i++) + { + for (j = 0; j < 8; j++) + { + bgTilemap[j + i * 0x20] ^= 0x400; + } + } + } + + if (IsSpeciesNotUnown(gContestResources->field_18->unk2)) + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].affineAnims = gUnknown_082FF6C0; + else + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].affineAnims = gUnknown_082FF694; + + StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimAttacker]], 0); + } + + gTasks[taskId].data[0]++; + break; + case 3: + if (gTasks[taskId].data[2]++ > 1) + { + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[1]--; + stretch = gTasks[taskId].data[1]; + SetGpuReg(REG_OFFSET_MOSAIC, (stretch << 4) | stretch); + + if (stretch == 0) + gTasks[taskId].data[0]++; + } + break; + case 4: + SetGpuReg(REG_OFFSET_MOSAIC, 0); + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) + SetAnimBgAttribute(1, BG_ANIM_MOSAIC, 0); + else + SetAnimBgAttribute(2, BG_ANIM_MOSAIC, 0); + + if (!IsContest()) + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + { + if (gTasks[taskId].data[10] == 0) + SetBattlerShadowSpriteCallback(gBattleAnimAttacker, gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies); + } + } + + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimTask_IsMonInvisible(u8 taskId) +{ + gBattleAnimArgs[7] = gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].invisible; + DestroyAnimVisualTask(taskId); +} + +void AnimTask_CastformGfxChange(u8 taskId) +{ + HandleSpeciesGfxDataChange(gBattleAnimAttacker, gBattleAnimTarget, TRUE); + DestroyAnimVisualTask(taskId); +} + +void AnimTask_MorningSunLightBeam(u8 taskId) +{ + struct BattleAnimBgData animBg; + + switch (gTasks[taskId].data[0]) + { + case 0: + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND | BLDCNT_TGT1_BG1); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + sub_80752A0 + sub_807543C + sub_80753B4 //AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); + LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); + if (IsContest()) + { + sub_80730C0(animBg.paletteId, [sp+4 ???], 0, 0); + gBattle_BG1_X = -56; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattle_BG1_X = -135; + else + gBattle_BG1_X = -10; + } + + gBattle_BG1_Y = 0; + + /* + sub_80752A0(&animBg); + sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); + + if (IsContest()) + { + gBattle_BG1_X = -56; + gBattle_BG1_Y = 0; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattle_BG1_X = -135; + else + gBattle_BG1_X = -10; + + gBattle_BG1_Y = 0; + } + */ + + + + + gTasks[taskId].data[10] = gBattle_BG1_X; + gTasks[taskId].data[11] = gBattle_BG1_Y; + + gTasks[taskId].data[0]++; + PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(-64)); + break; + case 1: + if (gTasks[taskId].data[4]++ > 0) + { + gTasks[taskId].data[4] = 0; + if (++gTasks[taskId].data[1] > 12) + gTasks[taskId].data[1] = 12; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + + if (gTasks[taskId].data[1] == 12) + gTasks[taskId].data[0]++; + } + break; + case 2: + if (--gTasks[taskId].data[1] < 0) + gTasks[taskId].data[1] = 0; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + + if (!gTasks[taskId].data[1]) + { + gBattle_BG1_X = gUnknown_085CE460[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; + if (++gTasks[taskId].data[2] == 4) + gTasks[taskId].data[0] = 4; + else + gTasks[taskId].data[0] = 3; + } + break; + case 3: + if (++gTasks[taskId].data[3] == 4) + { + gTasks[taskId].data[3] = 0; + gTasks[taskId].data[0] = 1; + PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(-64)); + } + break; + case 4: + sub_80752A0(&animBg); + sub_8075358(animBg.bgId); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimGreenStar(struct Sprite *sprite) +{ + s16 xOffset; + u8 spriteId1; + u8 spriteId2; + + xOffset = Random2(); + xOffset &= 0x3F; + if (xOffset > 31) + xOffset = 32 - xOffset; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + xOffset; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + 32; + sprite->data[1] = gBattleAnimArgs[0]; + sprite->data[2] = gBattleAnimArgs[1]; + + spriteId1 = CreateSprite(&gUnknown_085CE48C, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); + spriteId2 = CreateSprite(&gUnknown_085CE48C, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); + StartSpriteAnim(&gSprites[spriteId1], 1); + StartSpriteAnim(&gSprites[spriteId2], 2); + + gSprites[spriteId1].data[1] = gBattleAnimArgs[0]; + gSprites[spriteId1].data[2] = gBattleAnimArgs[1]; + gSprites[spriteId2].data[1] = gBattleAnimArgs[0]; + gSprites[spriteId2].data[2] = gBattleAnimArgs[1]; + gSprites[spriteId1].data[7] = -1; + gSprites[spriteId2].data[7] = -1; + gSprites[spriteId1].invisible = 1; + gSprites[spriteId2].invisible = 1; + gSprites[spriteId1].callback = AnimGreenStar_Callback; + gSprites[spriteId2].callback = AnimGreenStar_Callback; + + sprite->data[6] = spriteId1; + sprite->data[7] = spriteId2; + sprite->callback = AnimGreenStar_Step1; +} + +static void AnimGreenStar_Step1(struct Sprite *sprite) +{ + s16 delta = sprite->data[3] + sprite->data[2]; + sprite->pos2.y -= delta >> 8; + sprite->data[3] += sprite->data[2]; + sprite->data[3] &= 0xFF; + if (sprite->data[4] == 0 && sprite->pos2.y < -8) + { + gSprites[sprite->data[6]].invisible = 0; + sprite->data[4]++; + } + + if (sprite->data[4] == 1 && sprite->pos2.y < -16) + { + gSprites[sprite->data[7]].invisible = 0; + sprite->data[4]++; + } + + if (--sprite->data[1] == -1) + { + sprite->invisible = 1; + sprite->callback = AnimGreenStar_Step2; + } +} + +static void AnimGreenStar_Step2(struct Sprite *sprite) +{ + if (gSprites[sprite->data[6]].callback == SpriteCallbackDummy + && gSprites[sprite->data[7]].callback == SpriteCallbackDummy) + { + DestroySprite(&gSprites[sprite->data[6]]); + DestroySprite(&gSprites[sprite->data[7]]); + DestroyAnimSprite(sprite); + } +} + +static void AnimGreenStar_Callback(struct Sprite *sprite) +{ + if (!sprite->invisible) + { + s16 delta = sprite->data[3] + sprite->data[2]; + sprite->pos2.y -= delta >> 8; + sprite->data[3] += sprite->data[2]; + sprite->data[3] &= 0xFF; + if (--sprite->data[1] == -1) + { + sprite->invisible = 1; + sprite->callback = SpriteCallbackDummy; + } + } +} + +void AnimTask_DoomDesireLightBeam(u8 taskId) +{ + struct BattleAnimBgData animBg; + + switch (gTasks[taskId].data[0]) + { + case 0: + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND | BLDCNT_TGT1_BG1); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(3, 13)); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + /* + sub_80752A0(&animBg); + sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); + */ + + sub_80752A0 + sub_807543C + sub_80753B4 + LoadCompressedPalette + //... + + if (IsContest()) + { + gBattle_BG1_X = -56; + gBattle_BG1_Y = 0; + } + else + { + u8 position = GetBattlerPosition(gBattleAnimTarget); + if (IsDoubleBattle() == TRUE) + { + if (position == B_POSITION_OPPONENT_LEFT) + gBattle_BG1_X = -155; + if (position == B_POSITION_OPPONENT_RIGHT) + gBattle_BG1_X = -115; + if (position == B_POSITION_PLAYER_LEFT) + gBattle_BG1_X = 14; + if (position == B_POSITION_PLAYER_RIGHT) + gBattle_BG1_X = -20; + } + else + { + if (position == B_POSITION_OPPONENT_LEFT) + gBattle_BG1_X = -135; + if (position == B_POSITION_PLAYER_LEFT) + gBattle_BG1_X = -10; + } + + gBattle_BG1_Y = 0; + } + + AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); + LoadCompressedPalette(gUnknown_08C2A6D4, animBg.paletteId * 16, 32); + gTasks[taskId].data[10] = gBattle_BG1_X; + gTasks[taskId].data[11] = gBattle_BG1_Y; + gTasks[taskId].data[0]++; + break; + case 1: + gTasks[taskId].data[3] = 0; + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) + gBattle_BG1_X = gTasks[taskId].data[10] + gUnknown_085CE4A4[gTasks[taskId].data[2]]; + else + gBattle_BG1_X = gTasks[taskId].data[10] - gUnknown_085CE4A4[gTasks[taskId].data[2]]; + + if (++gTasks[taskId].data[2] == 5) + gTasks[taskId].data[0] = 5; + else + gTasks[taskId].data[0]++; + break; + case 2: + if (--gTasks[taskId].data[1] <= 4) + gTasks[taskId].data[1] = 5; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(3, gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 5) + gTasks[taskId].data[0]++; + break; + case 3: + if (++gTasks[taskId].data[3] > gUnknown_085CE4A8[gTasks[taskId].data[2]]) + gTasks[taskId].data[0]++; + break; + case 4: + if (++gTasks[taskId].data[1] > 13) + gTasks[taskId].data[1] = 13; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(3, gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 13) + gTasks[taskId].data[0] = 1; + break; + case 5: + sub_80752A0(&animBg); + sub_8075358(animBg.bgId); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimVisualTask(taskId); + break; + } +} + +// Briefly vertically grows and shrinks the attacking mon's sprite. +// No args. +void AnimTask_StrongFrustrationGrowAndShrink(u8 taskId) +{ + if (gTasks[taskId].data[0] == 0) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gStrongFrustrationAffineAnimCmds); + gTasks[taskId].data[0]++; + } + else + { + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + } +} + +// Animates an anger mark near the mon's head. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +void AnimWeakFrustrationAngerMark(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + InitSpritePosToAnimAttacker(sprite, 0); + sprite->data[0]++; + } + else if (sprite->data[0]++ > 20) + { + sprite->data[1] += 160; + sprite->data[2] += 128; + + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos2.x = -(sprite->data[1] >> 8); + else + sprite->pos2.x = sprite->data[1] >> 8; + + sprite->pos2.y += sprite->data[2] >> 8; + if (sprite->pos2.y > 64) + DestroyAnimSprite(sprite); + } +} + +// Rocks the mon back and forth. This is done on a pivot so it is done via rotation. +// arg 0: which battler +// arg 1: number of rocks +// arg 2: rotation speed increase +void AnimTask_RockMonBackAndForth(u8 taskId) +{ + u8 side; + struct Task *task = &gTasks[taskId]; + + if (!gBattleAnimArgs[1]) + { + DestroyAnimVisualTask(taskId); + return; + } + + if (gBattleAnimArgs[2] < 0) + gBattleAnimArgs[2] = 0; + if (gBattleAnimArgs[2] > 2) + gBattleAnimArgs[2] = 2; + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 8 - (2 * gBattleAnimArgs[2]); + task->data[4] = 0x100 + (gBattleAnimArgs[2] * 128); + task->data[5] = gBattleAnimArgs[2] + 2; + task->data[6] = gBattleAnimArgs[1] - 1; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + side = GetBattlerSide(gBattleAnimAttacker); + else + side = GetBattlerSide(gBattleAnimTarget); + + if (side == B_SIDE_OPPONENT) + { + task->data[4] *= -1; + task->data[5] *= -1; + } + + PrepareBattlerSpriteForRotScale(task->data[15], ST_OAM_OBJ_NORMAL); + task->func = AnimTask_RockMonBackAndForthStep; +} + +static void AnimTask_RockMonBackAndForthStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + gSprites[task->data[15]].pos2.x += task->data[5]; + task->data[2] -= task->data[4]; + SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); + SetBattlerSpriteYOffsetFromRotation(task->data[15]); + if (++task->data[1] >= task->data[3]) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 1: + gSprites[task->data[15]].pos2.x -= task->data[5]; + task->data[2] += task->data[4]; + SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); + SetBattlerSpriteYOffsetFromRotation(task->data[15]); + if (++task->data[1] >= task->data[3] * 2) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 2: + gSprites[task->data[15]].pos2.x += task->data[5]; + task->data[2] -= task->data[4]; + SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); + SetBattlerSpriteYOffsetFromRotation(task->data[15]); + if (++task->data[1] >= task->data[3]) + { + if (task->data[6]) + { + task->data[6]--; + task->data[1] = 0; + task->data[0] = 0; + } + else + { + task->data[0]++; + } + } + break; + case 3: + ResetSpriteRotScale(task->data[15]); + DestroyAnimVisualTask(taskId); + break; + } +} + +// Floats a petal across the screen towards the target mon's side. +// arg 0: initial y pixel offset +// arg 1: sprite anim num +// arg 2: unused +void AnimSweetScentPetal(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x = 0; + sprite->pos1.y = gBattleAnimArgs[0]; + } + else + { + sprite->pos1.x = 240; + sprite->pos1.y = gBattleAnimArgs[0] - 30; + } + + sprite->data[2] = gBattleAnimArgs[2]; + StartSpriteAnim(sprite, gBattleAnimArgs[1]); + sprite->callback = AnimSweetScentPetalStep; +} + +static void AnimSweetScentPetalStep(struct Sprite *sprite) +{ + sprite->data[0] += 3; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x += 5; + sprite->pos1.y -= 1; + + if (sprite->pos1.x > 240) + DestroyAnimSprite(sprite); + + sprite->pos2.y = Sin(sprite->data[0] & 0xFF, 16); + } + else + { + sprite->pos1.x -= 5; + sprite->pos1.y += 1; + + if (sprite->pos1.x < 0) + DestroyAnimSprite(sprite); + + sprite->pos2.y = Cos(sprite->data[0] & 0xFF, 16); + } +} + +// Moves the mon sprite in a flailing back-and-forth motion. +// arg 0: which battler +void AnimTask_FlailMovement(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[12] = 0x20; + task->data[13] = 0x40; + task->data[14] = 0x800; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + + PrepareBattlerSpriteForRotScale(task->data[15], ST_OAM_OBJ_NORMAL); + task->func = AnimTask_FlailMovementStep; +} + +static void AnimTask_FlailMovementStep(u8 taskId) +{ + int temp; + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + task->data[2] += 0x200; + if (task->data[2] >= task->data[14]) + { + s16 diff = task->data[14] - task->data[2]; + s16 div = diff / (task->data[14] * 2); + s16 mod = diff % (task->data[14] * 2); + + if ((div & 1) == 0) + { + task->data[2] = task->data[14] - mod; + task->data[0] = 1; + } + else + { + task->data[2] = mod - task->data[14]; + } + } + break; + case 1: + task->data[2] -= 0x200; + if (task->data[2] <= -task->data[14]) + { + s16 diff = task->data[14] - task->data[2]; + s16 div = diff / (task->data[14] * 2); + s16 mod = diff % (task->data[14] * 2); + + if ((1 & div) == 0) + { + task->data[2] = mod - task->data[14]; + task->data[0] = 0; + } + else + { + task->data[2] = task->data[14] - mod; + } + } + break; + case 2: + ResetSpriteRotScale(task->data[15]); + DestroyAnimVisualTask(taskId); + return; + } + + SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); + SetBattlerSpriteYOffsetFromRotation(task->data[15]); + gSprites[task->data[15]].pos2.x = -(((temp = task->data[2]) >= 0 ? task->data[2] : temp + 63) >> 6); + + if (++task->data[1] > 8) + { + if (task->data[12]) + { + task->data[12]--; + task->data[14] -= task->data[13]; + if (task->data[14] < 16) + task->data[14] = 16; + } + else + { + task->data[0] = 2; + } + } +} + +// Makes a spark-like projectile fall on top of the mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: which battler +void AnimPainSplitProjectile(struct Sprite *sprite) +{ + if (!sprite->data[0]) + { + if (gBattleAnimArgs[2] == ANIM_ATTACKER) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + } + + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[1] = 0x80; + sprite->data[2] = 0x300; + sprite->data[3] = gBattleAnimArgs[1]; + sprite->data[0]++; + } + else + { + sprite->pos2.x = sprite->data[1] >> 8; + sprite->pos2.y += sprite->data[2] >> 8; + if (sprite->data[4] == 0 && sprite->pos2.y > -sprite->data[3]) + { + sprite->data[4] = 1; + sprite->data[2] = (-sprite->data[2] / 3) * 2; + } + + sprite->data[1] += 192; + sprite->data[2] += 128; + if (sprite->animEnded) + DestroyAnimSprite(sprite); + } +} + +// Performs one of several affine transformations on the mon sprite. +// arg 0: which battler +// arg 1: which transformation +void AnimTask_PainSplitMovement(u8 taskId) +{ + u8 spriteId; + + if (gTasks[taskId].data[0] == 0) + { + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + gTasks[taskId].data[11] = gBattleAnimAttacker; + else + gTasks[taskId].data[11] = gBattleAnimTarget; + + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gTasks[taskId].data[10] = spriteId; + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + + switch (gBattleAnimArgs[1]) + { + case 0: + SetSpriteRotScale(spriteId, 0xE0, 0x140, 0); + SetBattlerSpriteYOffsetFromYScale(spriteId); + break; + case 1: + SetSpriteRotScale(spriteId, 0xD0, 0x130, 0xF00); + SetBattlerSpriteYOffsetFromYScale(spriteId); + if (IsContest() || GetBattlerSide(gTasks[taskId].data[11]) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.y += 16; + break; + case 2: + SetSpriteRotScale(spriteId, 0xD0, 0x130, 0xF100); + SetBattlerSpriteYOffsetFromYScale(spriteId); + if (IsContest() || GetBattlerSide(gTasks[taskId].data[11]) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.y += 16; + break; + } + + gSprites[spriteId].pos2.x = 2; + gTasks[taskId].data[0]++; + } + else + { + spriteId = gTasks[taskId].data[10]; + if (++gTasks[taskId].data[2] == 3) + { + gTasks[taskId].data[2] = 0; + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos2.x; + } + + if (++gTasks[taskId].data[1] == 13) + { + ResetSpriteRotScale(spriteId); + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + DestroyAnimVisualTask(taskId); + } + } +} + +// Move a piece of confetti in a slightly-random speed across the screen. +// arg 0: which battler the confetti starts from +void AnimFlatterConfetti(struct Sprite *sprite) +{ + u8 tileOffset; + int rand1; + int rand2; + + tileOffset = Random2() % 12; + sprite->oam.tileNum += tileOffset; + rand1 = Random2() & 0x1FF; + rand2 = Random2() & 0xFF; + + if (rand1 & 1) + sprite->data[0] = 0x5E0 + rand1; + else + sprite->data[0] = 0x5E0 - rand1; + + if (rand2 & 1) + sprite->data[1] = 0x480 + rand2; + else + sprite->data[1] = 0x480 - rand2; + + sprite->data[2] = gBattleAnimArgs[0]; + if (sprite->data[2] == ANIM_ATTACKER) + sprite->pos1.x = -8; + else + sprite->pos1.x = 248; + + sprite->pos1.y = 104; + sprite->callback = AnimFlatterConfettiStep; +} + +static void AnimFlatterConfettiStep(struct Sprite *sprite) +{ + if (sprite->data[2] == 0) + { + sprite->pos2.x += sprite->data[0] >> 8; + sprite->pos2.y -= sprite->data[1] >> 8; + } + else + { + sprite->pos2.x -= sprite->data[0] >> 8; + sprite->pos2.y -= sprite->data[1] >> 8; + } + + sprite->data[0] -= 22; + sprite->data[1] -= 48; + if (sprite->data[0] < 0) + sprite->data[0] = 0; + + if (++sprite->data[3] == 31) + DestroyAnimSprite(sprite); +} + +// Uses a spotlight sprite as a light mask to illuminate the target mon. The spotlight grows and shrinks. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: duration of fully-opened spotlight +void AnimFlatterSpotlight(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJWIN_ON); + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); + SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); + + sprite->data[0] = gBattleAnimArgs[2]; + InitSpritePosToAnimTarget(sprite, FALSE); + sprite->oam.objMode = ST_OAM_OBJ_WINDOW; + sprite->invisible = 1; + sprite->callback = AnimFlatterSpotlightStep; +} + +static void AnimFlatterSpotlightStep(struct Sprite *sprite) +{ + switch (sprite->data[1]) + { + case 0: + sprite->invisible = 0; + if (sprite->affineAnimEnded) + sprite->data[1]++; + break; + case 1: + if (--sprite->data[0] == 0) + { + ChangeSpriteAffineAnim(sprite, 1); + sprite->data[1]++; + } + break; + case 2: + if (sprite->affineAnimEnded) + { + sprite->invisible = 1; + sprite->data[1]++; + } + break; + case 3: + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + SetGpuReg(REG_OFFSET_DISPCNT, GetGpuReg(REG_OFFSET_DISPCNT) ^ DISPCNT_OBJWIN_ON); + DestroyAnimSprite(sprite); + break; + } +} + +// Spins an orb around the attacking mon, while its path radius grows and shrinks. +// arg 0: duration +// arg 1: initial wave offset +void AnimReversalOrb(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->callback = AnimReversalOrbStep; + sprite->callback(sprite); +} + +static void AnimReversalOrbStep(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[1], sprite->data[2] >> 8); + sprite->pos2.y = Cos(sprite->data[1], sprite->data[3] >> 8); + sprite->data[1] = (sprite->data[1] + 9) & 0xFF; + + if ((u16)sprite->data[1] < 64 || sprite->data[1] > 195) + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) - 1; + else + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) + 1; + + if (!sprite->data[5]) + { + sprite->data[2] += 0x400; + sprite->data[3] += 0x100; + sprite->data[4]++; + if (sprite->data[4] == sprite->data[0]) + { + sprite->data[4] = 0; + sprite->data[5] = 1; + } + } + else if (sprite->data[5] == 1) + { + sprite->data[2] -= 0x400; + sprite->data[3] -= 0x100; + sprite->data[4]++; + if (sprite->data[4] == sprite->data[0]) + DestroyAnimSprite(sprite); + } +} + +// Copies the target mon's sprite, and makes a white silhouette that shrinks away. +void AnimTask_RolePlaySilhouette(u8 taskId) +{ + u8 isBackPic; + u32 personality; + u32 otId; + u16 species; + s16 xOffset; + u32 priority; + u8 spriteId; + s16 coord1, coord2; + + GetAnimBattlerSpriteId(ANIM_ATTACKER); + if (IsContest()) + { + isBackPic = 1; + personality = gContestResources->field_18->unk10; + otId = gContestResources->field_18->unkC; + species = gContestResources->field_18->unk2; + xOffset = 20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + isBackPic = 0; + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } + + xOffset = 20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + else + { + isBackPic = 1; + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } + + xOffset = -20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + } + + coord1 = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + coord2 = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + spriteId = sub_80A8394(species, isBackPic, 0, coord1 + xOffset, coord2, 5, personality, otId, gBattleAnimTarget, 1); + + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].oam.objMode = ST_OAM_OBJ_BLEND; + FillPalette(RGB_WHITE, (gSprites[spriteId].oam.paletteNum << 4) + 0x100, 32); + gSprites[spriteId].oam.priority = priority; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].func = AnimTask_RolePlaySilhouetteStep1; +} + +static void AnimTask_RolePlaySilhouetteStep1(u8 taskId) +{ + if (gTasks[taskId].data[10]++ > 1) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 10) + { + gTasks[taskId].data[10] = 256; + gTasks[taskId].data[11] = 256; + gTasks[taskId].func = AnimTask_RolePlaySilhouetteStep2; + } + } +} + +static void AnimTask_RolePlaySilhouetteStep2(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[0]; + gTasks[taskId].data[10] -= 16; + gTasks[taskId].data[11] += 128; + gSprites[spriteId].oam.affineMode |= ST_OAM_AFFINE_DOUBLE_MASK; + TrySetSpriteRotScale(&gSprites[spriteId], TRUE, gTasks[taskId].data[10], gTasks[taskId].data[11], 0); + if (++gTasks[taskId].data[12] == 9) + { + sub_80A749C(&gSprites[spriteId]); + DestroySpriteAndFreeResources_(&gSprites[spriteId]); + gTasks[taskId].func = DestroyAnimVisualTaskAndDisableBlend; + } +} + +// Performs a wavy transformation on the mon's sprite, and fades out. +// arg 0: which battler +void AnimTask_AcidArmor(u8 taskId) +{ + u8 battler; + u16 bgX, bgY; + s16 y, i; + struct ScanlineEffectParams scanlineParams; + struct Task *task = &gTasks[taskId]; + + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 16; + task->data[4] = 0; + task->data[5] = battler; + task->data[6] = 32; + task->data[7] = 0; + task->data[8] = 24; + + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + task->data[8] *= -1; + + task->data[13] = GetBattlerYCoordWithElevation(battler) - 34; + if (task->data[13] < 0) + task->data[13] = 0; + + task->data[14] = task->data[13] + 66; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + if (GetBattlerSpriteBGPriorityRank(battler) == 1) + { + scanlineParams.dmaDest = ®_BG1HOFS; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND | BLDCNT_TGT1_BG1); + bgX = gBattle_BG1_X; + bgY = gBattle_BG1_Y; + } + else + { + scanlineParams.dmaDest = ®_BG2HOFS; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND | BLDCNT_TGT1_BG2); + bgX = gBattle_BG2_X; + bgY = gBattle_BG2_Y; + } + + for (y = 0, i = 0; y < 160; y++, i += 2) + { + gScanlineEffectRegBuffers[0][i] = bgX; + gScanlineEffectRegBuffers[1][i] = bgX; + gScanlineEffectRegBuffers[0][i + 1] = bgY; + gScanlineEffectRegBuffers[1][i + 1] = bgY; + } + + scanlineParams.dmaControl = SCANLINE_EFFECT_DMACNT_32BIT; + scanlineParams.initState = 1; + scanlineParams.unused9 = 0; + ScanlineEffect_SetParams(scanlineParams); + task->func = AnimTask_AcidArmorStep; +} + +static void AnimTask_AcidArmorStep(u8 taskId) +{ + struct Task *task; + s16 var1; + s16 var2; + s16 bgX, bgY; + s16 offset; + s16 var0; + s16 i; + s16 sineIndex; + s16 var3; + + task = &gTasks[taskId]; + if (GetBattlerSpriteBGPriorityRank(task->data[5]) == 1) + { + bgX = gBattle_BG1_X; + bgY = gBattle_BG1_Y; + } + else + { + bgX = gBattle_BG2_X; + bgY = gBattle_BG2_Y; + } + + switch (task->data[0]) + { + case 0: + offset = task->data[14] * 2; + var1 = 0; + var2 = 0; + i = 0; + task->data[1] = (task->data[1] + 2) & 0xFF; + sineIndex = task->data[1]; + task->data[9] = 0x7E0 / task->data[6]; + task->data[10] = -((task->data[7] * 2) / task->data[9]); + task->data[11] = task->data[7]; + var3 = task->data[11] >> 5; + task->data[12] = var3; + var0 = task->data[14]; + while (var0 > task->data[13]) + { + gScanlineEffectRegBuffers[gScanlineEffect.srcBuffer][offset + 1] = (i - var2) + bgY; + gScanlineEffectRegBuffers[gScanlineEffect.srcBuffer][offset] = bgX + var3 + (gSineTable[sineIndex] >> 5); + sineIndex = (sineIndex + 10) & 0xFF; + task->data[11] += task->data[10]; + var3 = task->data[11] >> 5; + task->data[12] = var3; + + i++; + offset -= 2; + var1 += task->data[6]; + var2 = var1 >> 5; + var0--; + } + + var0 *= 2; + while (var0 >= 0) + { + gScanlineEffectRegBuffers[0][var0] = bgX + 240; + gScanlineEffectRegBuffers[1][var0] = bgX + 240; + var0 -= 2; + } + + if (++task->data[6] > 63) + { + task->data[6] = 64; + task->data[2]++; + if (task->data[2] & 1) + task->data[3]--; + else + task->data[4]++; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(task->data[3], task->data[4])); + if (task->data[3] == 0 && task->data[4] == 16) + { + task->data[2] = 0; + task->data[3] = 0; + task->data[0]++; + } + } + else + { + task->data[7] += task->data[8]; + } + break; + case 1: + if (++task->data[2] > 12) + { + gScanlineEffect.state = 3; + task->data[2] = 0; + task->data[0]++; + } + break; + case 2: + task->data[2]++; + if (task->data[2] & 1) + task->data[3]++; + else + task->data[4]--; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(task->data[3], task->data[4])); + if (task->data[3] == 16 && task->data[4] == 0) + { + task->data[2] = 0; + task->data[3] = 0; + task->data[0]++; + } + break; + case 3: + DestroyAnimVisualTask(taskId); + break; + } +} + +// Runs an affine animation that makes it look like the mon is inhaling deeply. +// arg 0: which battler +void AnimTask_DeepInhale(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + task->data[0] = 0; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + PrepareAffineAnimInTaskData(&gTasks[taskId], task->data[15], gDeepInhaleAffineAnimCmds); + task->func = AnimTask_DeepInhaleStep; +} + +static void AnimTask_DeepInhaleStep(u8 taskId) +{ + u16 var0; + + struct Task *task = &gTasks[taskId]; + var0 = task->data[0]; + task->data[0]++; + var0 -= 20; + if (var0 < 23) + { + if (++task->data[1] > 1) + { + task->data[1] = 0; + task->data[2]++; + if (task->data[2] & 1) + gSprites[task->data[15]].pos2.x = 1; + else + gSprites[task->data[15]].pos2.x = -1; + } + } + else + { + gSprites[task->data[15]].pos2.x = 0; + } + + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); +} + +static void InitYawnCloudPosition(struct Sprite *sprite, s16 startX, s16 startY, s16 destX, s16 destY, u16 duration) +{ + sprite->pos1.x = startX; + sprite->pos1.y = startY; + sprite->data[4] = startX << 4; + sprite->data[5] = startY << 4; + sprite->data[6] = ((destX - startX) << 4) / duration; + sprite->data[7] = ((destY - startY) << 4) / duration; +} + +static void UpdateYawnCloudPosition(struct Sprite *sprite) +{ + sprite->data[4] += sprite->data[6]; + sprite->data[5] += sprite->data[7]; + sprite->pos1.x = sprite->data[4] >> 4; + sprite->pos1.y = sprite->data[5] >> 4; +} + +// Drifts a cloud in a wavy path towards the target mon. +// arg 0: which affine anim +void AnimYawnCloud(struct Sprite *sprite) +{ + s16 destX = sprite->pos1.x; + s16 destY = sprite->pos1.y; + + SetSpriteCoordsToAnimAttackerCoords(sprite); + StartSpriteAffineAnim(sprite, gBattleAnimArgs[0]); + InitYawnCloudPosition(sprite, sprite->pos1.x, sprite->pos1.y, destX, destY, 64); + sprite->data[0] = 0; + sprite->callback = AnimYawnCloudStep; +} + +static void AnimYawnCloudStep(struct Sprite *sprite) +{ + int index; + + sprite->data[0]++; + index = (sprite->data[0] * 8) & 0xFF; + UpdateYawnCloudPosition(sprite); + sprite->pos2.y = Sin(index, 8); + if (sprite->data[0] > 58) + { + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + sprite->data[2]++; + sprite->invisible = sprite->data[2] & 1; + if (sprite->data[2] > 3) + DestroySpriteAndMatrix(sprite); + } + } +} + +// Animates a cloud coming from the smoke ball. +// arg 0: ? +// arg 1: initial x pixel offset +// arg 2: initial y pixel offset +// arg 3: ? +void AnimSmokeBallEscapeCloud(struct Sprite *sprite) +{ + sprite->data[0] = gBattleAnimArgs[3]; + StartSpriteAffineAnim(sprite, gBattleAnimArgs[0]); + if (GetBattlerSide(gBattleAnimTarget) != B_SIDE_PLAYER) + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; + sprite->callback = sub_80B1D3C; +} + +static void sub_80E1990(u8 taskId) +{ + u16 var0 = 0; + u16 var1 = 0; + + gTasks[taskId].data[0]--; + if ((gTasks[taskId].data[6] & 0x8000) && (--gTasks[taskId].data[1] == -1)) + { + if (gTasks[taskId].data[9] == 0) + { + gTasks[taskId].data[9] = gTasks[taskId].data[4]; + gTasks[taskId].data[4] = -gTasks[taskId].data[4]; + } + else + { + gTasks[taskId].data[9] = 0; + } + + if (gTasks[taskId].data[10] == 0) + { + gTasks[taskId].data[10] = gTasks[taskId].data[5]; + gTasks[taskId].data[5] = -gTasks[taskId].data[5]; + } + else + { + gTasks[taskId].data[10] = 0; + } + + gTasks[taskId].data[1] = gTasks[taskId].data[13]; + } + + var0 = gTasks[taskId].data[7]; + var1 = gTasks[taskId].data[8]; + if (gTasks[taskId].data[2] & 0x8000) + gSprites[gTasks[taskId].data[15]].pos2.x = gTasks[taskId].data[9] - (var0 >> 8); + else + gSprites[gTasks[taskId].data[15]].pos2.x = gTasks[taskId].data[9] + (var0 >> 8); + + if (gTasks[taskId].data[3] & 0x8000) + gSprites[gTasks[taskId].data[15]].pos2.y = gTasks[taskId].data[10] - (var1 >> 8); + else + gSprites[gTasks[taskId].data[15]].pos2.y = gTasks[taskId].data[10] + (var1 >> 8); + + if (gTasks[taskId].data[0] < 1) + { + DestroyTask(taskId); + gAnimVisualTaskCount--; + } +} + +static void sub_80E1AD8(u8 taskId) +{ + u16 var0 = 0; + u16 var1 = 0; + + gTasks[taskId].data[0]--; + if ((gTasks[taskId].data[6] & 0x8000) && (--gTasks[taskId].data[1] == -1)) + { + if (gTasks[taskId].data[9] == 0) + { + gTasks[taskId].data[9] = gTasks[taskId].data[4]; + gTasks[taskId].data[4] = -gTasks[taskId].data[4]; + } + else + { + gTasks[taskId].data[9] = var0; + } + + if (gTasks[taskId].data[10] == 0) + { + gTasks[taskId].data[10] = gTasks[taskId].data[5]; + gTasks[taskId].data[5] = -gTasks[taskId].data[5]; + } + else + { + gTasks[taskId].data[10] = 0; + } + + gTasks[taskId].data[1] = gTasks[taskId].data[13]; + } + + var0 = (gTasks[taskId].data[2] & 0x7FFF) + gTasks[taskId].data[7]; + var1 = (gTasks[taskId].data[3] & 0x7FFF) + gTasks[taskId].data[8]; + if (gTasks[taskId].data[2] & 0x8000) + gSprites[gTasks[taskId].data[15]].pos2.x = gTasks[taskId].data[9] - (var0 >> 8); + else + gSprites[gTasks[taskId].data[15]].pos2.x = gTasks[taskId].data[9] + (var0 >> 8); + + if (gTasks[taskId].data[3] & 0x8000) + gSprites[gTasks[taskId].data[15]].pos2.y = gTasks[taskId].data[10] - (var1 >> 8); + else + gSprites[gTasks[taskId].data[15]].pos2.y = gTasks[taskId].data[10] + (var1 >> 8); + + gTasks[taskId].data[7] = var0; + gTasks[taskId].data[8] = var1; + if (gTasks[taskId].data[0] < 1) + { + gTasks[taskId].data[0] = 30; + gTasks[taskId].data[13] = 0; + gTasks[taskId].func = sub_80E1990; + } +} + +void sub_80E1C48(u8 taskId) +{ + gTasks[taskId].data[15] = gBattlerSpriteIds[gBattleAnimAttacker]; + gTasks[taskId].data[14] = gBattleAnimArgs[0]; + gTasks[taskId].data[0] = gBattleAnimArgs[0]; + gTasks[taskId].data[13] = gBattleAnimArgs[6]; + if (gBattleAnimArgs[3]) + gTasks[taskId].data[6] = gTasks[taskId].data[6] | -0x8000; + + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + gTasks[taskId].data[2] = gBattleAnimArgs[1]; + gTasks[taskId].data[3] = gBattleAnimArgs[2]; + } + else + { + if (gBattleAnimArgs[1] & 0x8000) + gTasks[taskId].data[2] = gBattleAnimArgs[1] & 0x7FFF; + else + gTasks[taskId].data[2] = gBattleAnimArgs[1] | -0x8000; + + if (gBattleAnimArgs[2] & 0x8000) + gTasks[taskId].data[3] = gBattleAnimArgs[2] & 0x7FFF; + else + gTasks[taskId].data[3] = gBattleAnimArgs[2] | -0x8000; + } + + gTasks[taskId].data[8] = 0; + gTasks[taskId].data[7] = 0; + gTasks[taskId].data[4] = gBattleAnimArgs[4]; + gTasks[taskId].data[5] = gBattleAnimArgs[5]; + gTasks[taskId].func = sub_80E1AD8; +} + +// Squishes the mon vertically and emits sweat droplets a few times. +// arg 0: battler +// arg 1: num squishes +void AnimTask_SquishAndSweatDroplets(u8 taskId) +{ + u8 battler; + struct Task *task = &gTasks[taskId]; + + if (!gBattleAnimArgs[1]) + DestroyAnimVisualTask(taskId); + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = gBattleAnimArgs[1]; + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + task->data[4] = GetBattlerSpriteCoord(battler, BATTLER_COORD_X); + task->data[5] = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y); + task->data[6] = GetBattlerSpriteSubpriority(battler); + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + PrepareAffineAnimInTaskData(task, task->data[15], gFacadeSquishAffineAnimCmds); + task->func = AnimTask_SquishAndSweatDropletsStep; +} + +static void AnimTask_SquishAndSweatDropletsStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + task->data[1]++; + if (task->data[1] == 6) + CreateSweatDroplets(taskId, TRUE); + + if (task->data[1] == 18) + CreateSweatDroplets(taskId, FALSE); + + if (!RunAffineAnimFromTaskData(task)) + { + if (--task->data[3] == 0) + { + task->data[0]++; + } + else + { + task->data[1] = 0; + PrepareAffineAnimInTaskData(task, task->data[15], gFacadeSquishAffineAnimCmds); + } + } + break; + case 1: + if (task->data[2] == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +static void CreateSweatDroplets(u8 taskId, bool8 arg1) +{ + u8 i; + s8 xOffset, yOffset; + struct Task *task; + s16 xCoords[4]; + s16 yCoords[2]; + + task = &gTasks[taskId]; + if (!arg1) + { + xOffset = 18; + yOffset = -20; + } + else + { + xOffset = 30; + yOffset = 20; + } + + xCoords[0] = task->data[4] - xOffset; + xCoords[1] = task->data[4] - xOffset - 4; + xCoords[2] = task->data[4] + xOffset; + xCoords[3] = task->data[4] + xOffset + 4; + yCoords[0] = task->data[5] + yOffset; + yCoords[1] = task->data[5] + yOffset + 6; + + for (i = 0; i < 4; i++) + { + u8 spriteId = CreateSprite(&gFacadeSweatDrop, xCoords[i], yCoords[i & 1], task->data[6] - 5); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].data[0] = 0; + gSprites[spriteId].data[1] = i < 2 ? -2 : 2; + gSprites[spriteId].data[2] = -1; + gSprites[spriteId].data[3] = taskId; + gSprites[spriteId].data[4] = 2; + task->data[2]++; + } + } +} + +void AnimFacadeSweatDrop(struct Sprite *sprite) +{ + sprite->pos1.x += sprite->data[1]; + sprite->pos1.y += sprite->data[2]; + if (++sprite->data[0] > 6) + { + gTasks[sprite->data[3]].data[sprite->data[4]]--; + DestroySprite(sprite); + } +} + +// Blends the mon sprite's color with a rotating set of colors. +// arg 0: battler +// arg 1: duration +void AnimTask_FacadeColorBlend(u8 taskId) +{ + u8 spriteId; + + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gTasks[taskId].data[2] = 0x100 + gSprites[spriteId].oam.paletteNum * 16; + gTasks[taskId].func = AnimTask_FacadeColorBlendStep; +} + +static void AnimTask_FacadeColorBlendStep(u8 taskId) +{ + if (gTasks[taskId].data[1]) + { + BlendPalette(gTasks[taskId].data[2], 16, 8, gFacadeBlendColors[gTasks[taskId].data[0]]); + if (++gTasks[taskId].data[0] > 23) + gTasks[taskId].data[0] = 0; + + gTasks[taskId].data[1]--; + } + else + { + BlendPalette(gTasks[taskId].data[2], 16, 0, RGB(0, 0, 0)); + DestroyAnimVisualTask(taskId); + } +} + +void sub_80E2084(u8 taskId) +{ + sub_80BBA20(taskId, + 0, + 0x1A0, + gBattleAnimAttacker, + gBattleAnimArgs[0], + 10, + 2, + 30, + gCureBubblesGfx, + gCureBubblesTilemap, + gCureBubblesPal); +} + +// Moves a noise line from the mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: which direction (0 = upward, 1 = downward, 2 = horizontal) +void AnimRoarNoiseLine(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + gBattleAnimArgs[0] = -gBattleAnimArgs[0]; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y) + gBattleAnimArgs[1]; + if (gBattleAnimArgs[2] == 0) + { + sprite->data[0] = 0x280; + sprite->data[1] = -0x280; + } + else if (gBattleAnimArgs[2] == 1) + { + sprite->vFlip = 1; + sprite->data[0] = 0x280; + sprite->data[1] = 0x280; + } + else + { + StartSpriteAnim(sprite, 1); + sprite->data[0] = 0x280; + } + + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->data[0] = -sprite->data[0]; + sprite->hFlip = 1; + } + + sprite->callback = AnimRoarNoiseLineStep; +} + +static void AnimRoarNoiseLineStep(struct Sprite *sprite) +{ + sprite->data[6] += sprite->data[0]; + sprite->data[7] += sprite->data[1]; + sprite->pos2.x = sprite->data[6] >> 8; + sprite->pos2.y = sprite->data[7] >> 8; + if (++sprite->data[5] == 14) + DestroyAnimSprite(sprite); +} + +// Makes a series of dots in a trail from the attacker to the target. +// arg 0: unused +void AnimTask_GlareEyeDots(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + if (IsContest()) + { + task->data[5] = 8; + task->data[6] = 3; + task->data[7] = 1; + } + else + { + task->data[5] = 12; + task->data[6] = 3; + task->data[7] = 0; + } + + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; + else + task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) - GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; + + task->data[12] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) - GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; + task->data[13] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + task->data[14] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + task->func = AnimTask_GlareEyeDotsStep; +} + +static void AnimTask_GlareEyeDotsStep(u8 taskId) +{ + u8 i; + s16 x, y; + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + if (++task->data[1] > 3) + { + task->data[1] = 0; + GetGlareEyeDotCoords( + task->data[11], + task->data[12], + task->data[13], + task->data[14], + task->data[5], + task->data[2], + &x, + &y); + + for (i = 0; i < 2; i++) + { + u8 spriteId = CreateSprite(&gGlareEyeDotSpriteTemplate, x, y, 35); + if (spriteId != MAX_SPRITES) + { + if (task->data[7] == 0) + { + if (i == 0) + gSprites[spriteId].pos2.x = gSprites[spriteId].pos2.y = -task->data[6]; + else + gSprites[spriteId].pos2.x = gSprites[spriteId].pos2.y = task->data[6]; + } + else + { + if (i == 0) + { + gSprites[spriteId].pos2.x = -task->data[6]; + gSprites[spriteId].pos2.y = task->data[6]; + } + else + { + gSprites[spriteId].pos2.x = task->data[6]; + gSprites[spriteId].pos2.y = -task->data[6]; + } + } + + gSprites[spriteId].data[0] = 0; + gSprites[spriteId].data[1] = taskId; + gSprites[spriteId].data[2] = 10; + task->data[10]++; + } + } + + if (task->data[2] == task->data[5]) + task->data[0]++; + + task->data[2]++; + } + break; + case 1: + if (task->data[10] == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +static void GetGlareEyeDotCoords(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, s16 *x, s16 *y) +{ + int x2; + int y2; + + if (arg5 == 0) + { + *x = arg0; + *y = arg1; + return; + } + + if (arg5 >= arg4) + { + *x = arg2; + *y = arg3; + return; + } + + arg4--; + x2 = (arg0 << 8) + arg5 * (((arg2 - arg0) << 8) / arg4); + y2 = (arg1 << 8) + arg5 * (((arg3 - arg1) << 8) / arg4); + *x = x2 >> 8; + *y = y2 >> 8; +} + +void AnimGlareEyeDot(struct Sprite *sprite) +{ + if (++sprite->data[0] > 36) + { + gTasks[sprite->data[1]].data[sprite->data[2]]--; + DestroySprite(sprite); + } +} + +// Moves a pawprint in a straight line. +// arg 0: initial x position +// arg 1: initial y position +// arg 2: destination x position +// arg 3: destination y position +// arg 4: duration +void AnimAssistPawprint(struct Sprite *sprite) +{ + sprite->pos1.x = gBattleAnimArgs[0]; + sprite->pos1.y = gBattleAnimArgs[1]; + sprite->data[2] = gBattleAnimArgs[2]; + sprite->data[4] = gBattleAnimArgs[3]; + sprite->data[0] = gBattleAnimArgs[4]; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = InitAndRunAnimFastLinearTranslation; +} + +// Moves a ball in an arc twoards the target, and rotates the ball while arcing. +// No args. +void AnimTask_BarrageBall(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + task->data[12] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + task->data[13] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + task->data[14] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT) / 4; + task->data[15] = CreateSprite(&gBarrageBallSpriteTemplate, task->data[11], task->data[12], GetBattlerSpriteSubpriority(gBattleAnimTarget) - 5); + if (task->data[15] != MAX_SPRITES) + { + gSprites[task->data[15]].data[0] = 16; + gSprites[task->data[15]].data[2] = task->data[13]; + gSprites[task->data[15]].data[4] = task->data[14]; + gSprites[task->data[15]].data[5] = -32; + InitAnimArcTranslation(&gSprites[task->data[15]]); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + StartSpriteAffineAnim(&gSprites[task->data[15]], 1); + + task->func = AnimTask_BarrageBallStep; + } + else + { + DestroyAnimVisualTask(taskId); + } +} + +static void AnimTask_BarrageBallStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + if (++task->data[1] > 1) + { + task->data[1] = 0; + TranslateAnimHorizontalArc(&gSprites[task->data[15]]); + if (++task->data[2] > 7) + task->data[0]++; + } + break; + case 1: + if (TranslateAnimHorizontalArc(&gSprites[task->data[15]])) + { + task->data[1] = 0; + task->data[2] = 0; + task->data[0]++; + } + break; + case 2: + if (++task->data[1] > 1) + { + task->data[1] = 0; + task->data[2]++; + gSprites[task->data[15]].invisible = task->data[2] & 1; + if (task->data[2] == 16) + { + FreeOamMatrix(gSprites[task->data[15]].oam.matrixNum); + DestroySprite(&gSprites[task->data[15]]); + task->data[0]++; + } + } + break; + case 3: + DestroyAnimVisualTask(taskId); + break; + } +} + +// Moves a hand back and forth in a squishing motion. +// arg 0: which battler +// arg 1: horizontal flip +// arg 2: num squishes +void AnimSmellingSaltsHand(struct Sprite *sprite) +{ + u8 battler; + + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + sprite->oam.tileNum += 16; + sprite->data[6] = gBattleAnimArgs[2]; + sprite->data[7] = gBattleAnimArgs[1] == 0 ? -1 : 1; + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3); + if (gBattleAnimArgs[1] == 0) + { + sprite->oam.matrixNum |= ST_OAM_HFLIP; + sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_LEFT) - 8; + } + else + { + sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_RIGHT) + 8; + } + + sprite->callback = AnimSmellingSaltsHand_Step; +} + +static void AnimSmellingSaltsHand_Step(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + sprite->pos2.x += sprite->data[7]; + if (++sprite->data[2] == 12) + sprite->data[0]++; + } + break; + case 1: + if (++sprite->data[1] == 8) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 2: + sprite->pos2.x -= sprite->data[7] * 4; + if (++sprite->data[1] == 6) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 3: + sprite->pos2.x += sprite->data[7] * 3; + if (++sprite->data[1] == 8) + { + if (--sprite->data[6]) + { + sprite->data[1] = 0; + sprite->data[0]--; + } + else + { + DestroyAnimSprite(sprite); + } + } + break; + } +} + +// Squishes the mon horizontally a few times. +// arg 0: which mon +// arg 1: number of squishes +void AnimTask_SmellingSaltsSquish(u8 taskId) +{ + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + { + DestroyAnimVisualTask(taskId); + } + else + { + gTasks[taskId].data[0] = gBattleAnimArgs[1]; + gTasks[taskId].data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], gSmellingSaltsSquishAffineAnimCmds); + gTasks[taskId].func = AnimTask_SmellingSaltsSquishStep; + } +} + +static void AnimTask_SmellingSaltsSquishStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + if (++task->data[1] > 1) + { + task->data[1] = 0; + if (!(task->data[2] & 1)) + gSprites[task->data[15]].pos2.x = 2; + else + gSprites[task->data[15]].pos2.x = -2; + } + + if (!RunAffineAnimFromTaskData(task)) + { + gSprites[task->data[15]].pos2.x = 0; + if (--task->data[0]) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], gSmellingSaltsSquishAffineAnimCmds); + task->data[1] = 0; + task->data[2] = 0; + } + else + { + DestroyAnimVisualTask(taskId); + } + } +} + +// Blinks an exclamation image over the mon a few times. +// arg 0: which mon +// arg 1: blink delay +// arg 2: number of blinks +void AnimSmellingSaltExclamation(struct Sprite *sprite) +{ + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_TOP); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->pos1.y = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_TOP); + } + + if (sprite->pos1.y < 8) + sprite->pos1.y = 8; + + sprite->data[0] = 0; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[2] = 0; + sprite->data[3] = gBattleAnimArgs[2]; + sprite->callback = AnimSmellingSaltExclamationStep; +} + +static void AnimSmellingSaltExclamationStep(struct Sprite *sprite) +{ + if (++sprite->data[0] >= sprite->data[1]) + { + sprite->data[0] = 0; + sprite->data[2] = (sprite->data[2] + 1) & 1; + sprite->invisible = sprite->data[2]; + if (sprite->data[2] && --sprite->data[3] == 0) + DestroyAnimSprite(sprite); + } +} + +// Claps a hand several times. +// arg 0: which hand +// arg 1: +void AnimHelpingHandClap(struct Sprite *sprite) +{ + if (gBattleAnimArgs[0] == 0) + { + sprite->oam.matrixNum |= ST_OAM_HFLIP; + sprite->pos1.x = 100; + sprite->data[7] = 1; + } + else + { + sprite->pos1.x = 140; + sprite->data[7] = -1; + } + + sprite->pos1.y = 56; + sprite->callback = AnimHelpingHandClapStep; +} + +static void AnimHelpingHandClapStep(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->pos1.y -= sprite->data[7] * 2; + if (sprite->data[1] & 1) + sprite->pos1.x -= sprite->data[7] * 2; + + if (++sprite->data[1] == 9) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 1: + if (++sprite->data[1] == 4) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 2: + sprite->data[1]++; + sprite->pos1.y += sprite->data[7] * 3; + sprite->pos2.x = sprite->data[7] * (gSineTable[sprite->data[1] * 10] >> 3); + if (sprite->data[1] == 12) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 3: + if (++sprite->data[1] == 2) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 4: + sprite->data[1]++; + sprite->pos1.y -= sprite->data[7] * 3; + sprite->pos2.x = sprite->data[7] * (gSineTable[sprite->data[1] * 10] >> 3); + if (sprite->data[1] == 12) + sprite->data[0]++; + break; + case 5: + sprite->data[1]++; + sprite->pos1.y += sprite->data[7] * 3; + sprite->pos2.x = sprite->data[7] * (gSineTable[sprite->data[1] * 10] >> 3); + if (sprite->data[1] == 15) + sprite->oam.tileNum += 16; + + if (sprite->data[1] == 18) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 6: + sprite->pos1.x += sprite->data[7] * 6; + if (++sprite->data[1] == 9) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 7: + sprite->pos1.x += sprite->data[7] * 2; + if (++sprite->data[1] == 1) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 8: + sprite->pos1.x -= sprite->data[7] * 3; + if (++sprite->data[1] == 5) + DestroyAnimSprite(sprite); + break; + } +} + +// Repeatedly moves the attacking mon in a horizontal lunging motion. +// No args. +void AnimTask_HelpingHandAttackerMovement(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + if (!IsContest()) + { + if (IsDoubleBattle() == TRUE) + { + int x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + int y = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimAttacker), 0); + if (x > y) + task->data[14] = 1; + else + task->data[14] = -1; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + task->data[14] = -1; + else + task->data[14] = 1; + } + } + else + { + task->data[14] = 1; + } + + task->func = AnimTask_HelpingHandAttackerMovementStep; +} + +static void AnimTask_HelpingHandAttackerMovementStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + if (++task->data[1] == 13) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 1: + gSprites[task->data[15]].pos2.x -= task->data[14] * 3; + if (++task->data[1] == 6) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 2: + gSprites[task->data[15]].pos2.x += task->data[14] * 3; + if (++task->data[1] == 6) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 3: + if (++task->data[1] == 2) + { + task->data[1] = 0; + if (task->data[2] == 0) + { + task->data[2]++; + task->data[0] = 1; + } + else + { + task->data[0]++; + } + } + break; + case 4: + gSprites[task->data[15]].pos2.x += task->data[14]; + if (++task->data[1] == 3) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 5: + if (++task->data[1] == 6) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 6: + gSprites[task->data[15]].pos2.x -= task->data[14] * 4; + if (++task->data[1] == 5) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 7: + gSprites[task->data[15]].pos2.x += task->data[14] * 4; + if (++task->data[1] == 5) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 8: + gSprites[task->data[15]].pos2.x = 0; + DestroyAnimVisualTask(taskId); + break; + } +} + +// Moves a magnifying glass around in straight lines. +// arg 0: magnifying glass target mon +void AnimForesightMagnifyingGlass(struct Sprite *sprite) +{ + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + { + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[7] = gBattleAnimAttacker; + } + else + { + sprite->data[7] = gBattleAnimTarget; + } + + if (GetBattlerSide(sprite->data[7]) == B_SIDE_OPPONENT) + sprite->oam.matrixNum = ST_OAM_HFLIP; + + sprite->oam.priority = GetBattlerSpriteBGPriority(sprite->data[7]); + sprite->oam.objMode = ST_OAM_OBJ_BLEND; + sprite->callback = AnimForesightMagnifyingGlassStep; +} + +static void AnimForesightMagnifyingGlassStep(struct Sprite *sprite) +{ + u16 x, y; + + switch (sprite->data[5]) + { + case 0: + switch (sprite->data[6]) + { + default: + sprite->data[6] = 0; + case 0: + case 4: + x = GetBattlerSpriteCoordAttr(sprite->data[7], 5) - 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], 3) - 4; + break; + case 1: + x = GetBattlerSpriteCoordAttr(sprite->data[7], 5) - 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], 2) + 4; + break; + case 2: + x = GetBattlerSpriteCoordAttr(sprite->data[7], 4) + 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], 3) - 4; + break; + case 3: + x = GetBattlerSpriteCoordAttr(sprite->data[7], 4) + 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], 2) - 4; + break; + case 5: + x = GetBattlerSpriteCoord(sprite->data[7], 2); + y = GetBattlerSpriteCoord(sprite->data[7], 3); + break; + } + + if (sprite->data[6] == 4) + sprite->data[0] = 24; + else if (sprite->data[6] == 5) + sprite->data[0] = 6; + else + sprite->data[0] = 12; + + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = x; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = y; + InitAnimLinearTranslation(sprite); + sprite->data[5]++; + break; + case 1: + if (AnimTranslateLinear(sprite)) + { + switch (sprite->data[6]) + { + default: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[0] = 0; + sprite->data[5]++; + sprite->data[6]++; + break; + case 4: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[5] = 0; + sprite->data[6]++; + break; + case 5: + sprite->data[0] = 0; + sprite->data[1] = 16; + sprite->data[2] = 0; + sprite->data[5] = 3; + break; + } + } + break; + case 2: + if (++sprite->data[0] == 4) + sprite->data[5] = 0; + break; + case 3: + if (!(sprite->data[0] & 1)) + sprite->data[1]--; + else + sprite->data[2]++; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[1], sprite->data[2])); + if (++sprite->data[0] == 32) + { + sprite->invisible = 1; + sprite->data[5]++; + } + break; + case 4: + DestroyAnimSprite(sprite); + break; + } +} + +static void AnimMeteorMashStarStep(struct Sprite *sprite) +{ + sprite->pos2.x = ((sprite->data[2] - sprite->data[0]) * sprite->data[5]) / sprite->data[4]; + sprite->pos2.y = ((sprite->data[3] - sprite->data[1]) * sprite->data[5]) / sprite->data[4]; + if (!(sprite->data[5] & 1)) + { + CreateSprite( + &gMiniTwinklingStarSpriteTemplate, + sprite->pos1.x + sprite->pos2.x, + sprite->pos1.y + sprite->pos2.y, 5); + } + + if (sprite->data[5] == sprite->data[4]) + DestroyAnimSprite(sprite); + + sprite->data[5]++; +} + +// Moves a shooting star across the screen that leaves little twinkling stars behind its path. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: destination x pixel offset +// arg 3: destination y pixel offset +// arg 4: duration +void AnimMeteorMashStar(struct Sprite *sprite) +{ + s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); // unused local variable + s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); // unused local variable + + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER || IsContest()) + { + sprite->data[0] = sprite->pos1.x - gBattleAnimArgs[0]; + sprite->data[2] = sprite->pos1.x - gBattleAnimArgs[2]; + } + else + { + sprite->data[0] = sprite->pos1.x + gBattleAnimArgs[0]; + sprite->data[2] = sprite->pos1.x + gBattleAnimArgs[2]; + } + + sprite->data[1] = sprite->pos1.y + gBattleAnimArgs[1]; + sprite->data[3] = sprite->pos1.y + gBattleAnimArgs[3]; + sprite->data[4] = gBattleAnimArgs[4]; + sprite->pos1.x = sprite->data[0]; + sprite->pos1.y = sprite->data[1]; + sprite->callback = AnimMeteorMashStarStep; +} + +void AnimTask_MonToSubstitute(u8 taskId) +{ + int i; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + + if (gTasks[taskId].data[0] == 0) + { + PrepareBattlerSpriteForRotScale(spriteId, FALSE); + gTasks[taskId].data[1] = 0x100; + gTasks[taskId].data[2] = 0x100; + gTasks[taskId].data[0]++; + } + else if (gTasks[taskId].data[0] == 1) + { + gTasks[taskId].data[1] += 0x60; + gTasks[taskId].data[2] -= 0xD; + SetSpriteRotScale(spriteId, gTasks[taskId].data[1], gTasks[taskId].data[2], 0); + if (++gTasks[taskId].data[3] == 9) + { + gTasks[taskId].data[3] = 0; + ResetSpriteRotScale(spriteId); + gSprites[spriteId].invisible = 1; + gTasks[taskId].data[0]++; + } + } + else + { + LoadBattleMonGfxAndAnimate(gBattleAnimAttacker, 0, spriteId); + for (i = 0; i < 16; i++) + gTasks[taskId].data[i] = 0; + + gTasks[taskId].func = AnimTask_MonToSubstituteDoll; + } +} + +static void AnimTask_MonToSubstituteDoll(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + + switch (gTasks[taskId].data[0]) + { + case 0: + gSprites[spriteId].pos2.y = -200; + gSprites[spriteId].pos2.x = 200; + gSprites[spriteId].invisible = 0; + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[0]++; + break; + case 1: + gTasks[taskId].data[10] += 112; + gSprites[spriteId].pos2.y += gTasks[taskId].data[10] >> 8; + if (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y >= -32) + gSprites[spriteId].pos2.x = 0; + + if (gSprites[spriteId].pos2.y > 0) + gSprites[spriteId].pos2.y = 0; + + if (gSprites[spriteId].pos2.y == 0) + { + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + gTasks[taskId].data[10] -= 0x800; + gTasks[taskId].data[0]++; + } + break; + case 2: + gTasks[taskId].data[10] -= 112; + if (gTasks[taskId].data[10] < 0) + gTasks[taskId].data[10] = 0; + + gSprites[spriteId].pos2.y -= gTasks[taskId].data[10] >> 8; + if (gTasks[taskId].data[10] == 0) + gTasks[taskId].data[0]++; + break; + case 3: + gTasks[taskId].data[10] += 112; + gSprites[spriteId].pos2.y += gTasks[taskId].data[10] >> 8; + if (gSprites[spriteId].pos2.y > 0) + gSprites[spriteId].pos2.y = 0; + + if (gSprites[spriteId].pos2.y == 0) + { + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + DestroyAnimVisualTask(taskId); + } + break; + } +} + +// Moves down an X that flickers and disappears. +// No args. +void AnimBlockX(struct Sprite *sprite) +{ + s16 y; + + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) - 2; + y = -144; + } + else + { + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + 2; + y = -96; + } + + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->pos2.y = y; + sprite->callback = AnimBlockXStep; +} + +static void AnimBlockXStep(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->pos2.y += 10; + if (sprite->pos2.y >= 0) + { + PlaySE12WithPanning(SE_W166, BattleAnimAdjustPanning(63)); + sprite->pos2.y = 0; + sprite->data[0]++; + } + break; + case 1: + sprite->data[1] += 4; + sprite->pos2.y = -(gSineTable[sprite->data[1]] >> 3); + if (sprite->data[1] > 0x7F) + { + PlaySE12WithPanning(SE_W166, BattleAnimAdjustPanning(63)); + sprite->data[1] = 0; + sprite->pos2.y = 0; + sprite->data[0]++; + } + break; + case 2: + sprite->data[1] += 6; + sprite->pos2.y = -(gSineTable[sprite->data[1]] >> 4); + if (sprite->data[1] > 0x7F) + { + sprite->data[1] = 0; + sprite->pos2.y = 0; + sprite->data[0]++; + } + break; + case 3: + if (++sprite->data[1] > 8) + { + PlaySE12WithPanning(SE_W043, BattleAnimAdjustPanning(63)); + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 4: + if (++sprite->data[1] > 8) + { + sprite->data[1] = 0; + sprite->data[2]++; + sprite->invisible = sprite->data[2] & 1; + if (sprite->data[2] == 7) + DestroyAnimSprite(sprite); + } + break; + } +} + +// Quickly moves two clones of the target mon back and forth. +// No args. +void AnimTask_OdorSleuthMovement(u8 taskId) +{ + s16 spriteId1, spriteId2; + + if (IsContest()) + { + DestroyAnimVisualTask(taskId); + return; + } + + spriteId1 = CloneBattlerSpriteWithBlend(ANIM_TARGET); + if (spriteId1 < 0) + { + DestroyAnimVisualTask(taskId); + return; + } + + spriteId2 = CloneBattlerSpriteWithBlend(ANIM_TARGET); + if (spriteId2 < 0) + { + obj_delete_but_dont_free_vram(&gSprites[spriteId1]); + DestroyAnimVisualTask(taskId); + return; + } + + gSprites[spriteId2].pos2.x += 24; + gSprites[spriteId1].pos2.x -= 24; + gSprites[spriteId2].data[0] = 0; + gSprites[spriteId1].data[0] = 0; + gSprites[spriteId2].data[1] = 0; + gSprites[spriteId1].data[1] = 0; + gSprites[spriteId2].data[2] = 0; + gSprites[spriteId1].data[2] = 0; + gSprites[spriteId2].data[3] = 16; + gSprites[spriteId1].data[3] = -16; + gSprites[spriteId2].data[4] = 0; + gSprites[spriteId1].data[4] = 128; + gSprites[spriteId2].data[5] = 24; + gSprites[spriteId1].data[5] = 24; + gSprites[spriteId2].data[6] = taskId; + gSprites[spriteId1].data[6] = taskId; + gSprites[spriteId2].data[7] = 0; + gSprites[spriteId1].data[7] = 0; + gTasks[taskId].data[0] = 2; + + if (!gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].invisible) + { + gSprites[spriteId2].invisible = 0; + gSprites[spriteId1].invisible = 1; + } + else + { + gSprites[spriteId2].invisible = 1; + gSprites[spriteId1].invisible = 1; + } + + gSprites[spriteId2].oam.objMode = ST_OAM_OBJ_NORMAL; + gSprites[spriteId1].oam.objMode = ST_OAM_OBJ_NORMAL; + gSprites[spriteId2].callback = MoveOdorSleuthClone; + gSprites[spriteId1].callback = MoveOdorSleuthClone; + gTasks[taskId].func = AnimTask_OdorSleuthMovementWaitFinish; +} + +static void AnimTask_OdorSleuthMovementWaitFinish(u8 taskId) +{ + if (gTasks[taskId].data[0] == 0) + DestroyAnimVisualTask(taskId); +} + +static void MoveOdorSleuthClone(struct Sprite *sprite) +{ + int zero = 0; + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + if (!gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].invisible) + sprite->invisible ^= 1; + } + + sprite->data[4] = sprite->data[4] + sprite->data[3]; + sprite->data[4] &= 0xFF; + sprite->pos2.x = Cos(sprite->data[4], sprite->data[5]); + switch (sprite->data[0]) + { + case 0: + if (++sprite->data[2] == 60) + { + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 1: + if (++sprite->data[2] > 0) + { + sprite->data[2] = 0; + sprite->data[5] -= 2; + if (sprite->data[5] < 0) + { + gTasks[sprite->data[6]].data[sprite->data[7]]--; + obj_delete_but_dont_free_vram(sprite); + } + } + break; + } +} + +void AnimTask_GetReturnPowerLevel(u8 taskId) +{ + gBattleAnimArgs[7] = 0; + if (gAnimFriendship < 60) + gBattleAnimArgs[7] = 0; + if (gAnimFriendship > 60 && gAnimFriendship < 92) + gBattleAnimArgs[7] = 1; + if (gAnimFriendship > 91 && gAnimFriendship < 201) + gBattleAnimArgs[7] = 2; + if (gAnimFriendship > 200) + gBattleAnimArgs[7] = 3; + + DestroyAnimVisualTask(taskId); +} + +// Makes the mon run out of screen, run past the opposing mon, and return to its original position. +// No args. +void AnimTask_SnatchOpposingMonMove(u8 taskId) +{ + u8 spriteId, spriteId2; + int personality; + int otId; + u16 species; + u8 subpriority; + u8 isBackPic; + s16 x; + + switch (gTasks[taskId].data[0]) + { + case 0: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.x += (gTasks[taskId].data[1] >> 8); + else + gSprites[spriteId].pos2.x -= (gTasks[taskId].data[1] >> 8); + + gTasks[taskId].data[1] &= 0xFF; + x = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x; + if ((u16)(x + 32) > 304) + { + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[0]++; + } + break; + case 1: + if (IsContest()) + { + personality = gContestResources->field_18->unk8; + otId = gContestResources->field_18->unkC; + species = gContestResources->field_18->species; + subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker); + isBackPic = 0; + x = -32; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; + isBackPic = 0; + x = 272; + } + else + { + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + isBackPic = 1; + x = -32; + } + } + + spriteId2 = sub_80A8394(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) + BlendPalette((gSprites[spriteId2].oam.paletteNum * 16) | 0x100, 16, 6, RGB_WHITE); + + gTasks[taskId].data[15] = spriteId2; + gTasks[taskId].data[0]++; + break; + case 2: + spriteId2 = gTasks[taskId].data[15]; + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId2].pos2.x -= (gTasks[taskId].data[1] >> 8); + else + gSprites[spriteId2].pos2.x += (gTasks[taskId].data[1] >> 8); + + gTasks[taskId].data[1] &= 0xFF; + x = gSprites[spriteId2].pos1.x + gSprites[spriteId2].pos2.x; + if (gTasks[taskId].data[14] == 0) + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + if (x < GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X)) + { + gTasks[taskId].data[14]++; + gBattleAnimArgs[7] = 0xFFFF; + } + } + else + { + if (x > GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X)) + { + gTasks[taskId].data[14]++; + gBattleAnimArgs[7] = 0xFFFF; + } + } + } + + if ((u16)(x + 32) > 304) + { + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[0]++; + } + break; + case 3: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + spriteId2 = gTasks[taskId].data[15]; + DestroySpriteAndFreeResources_(&gSprites[spriteId2]); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos1.x - 32; + else + gSprites[spriteId].pos2.x = 272 - gSprites[spriteId].pos1.x; + + gTasks[taskId].data[0]++; + break; + case 4: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + gSprites[spriteId].pos2.x += (gTasks[taskId].data[1] >> 8); + if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x >= GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X)) + gSprites[spriteId].pos2.x = 0; + } + else + { + gSprites[spriteId].pos2.x -= (gTasks[taskId].data[1] >> 8); + if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x <= GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X)) + gSprites[spriteId].pos2.x = 0; + } + + gTasks[taskId].data[1] = (u8)gTasks[taskId].data[1]; + if (gSprites[spriteId].pos2.x == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +void sub_80E3E84(struct Sprite *sprite) +{ + switch (sprite->data[7]) + { + case 0: + if (gBattleAnimArgs[7] == -1) + { + PlaySE12WithPanning(SE_W233, BattleAnimAdjustPanning(63)); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + 16; + sprite->data[0] = -32; + sprite->data[7]++; + sprite->invisible = 0; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT && !IsContest()) + sprite->subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + } + else + { + sprite->invisible = 1; + } + break; + case 1: + sprite->pos2.y = Sin(sprite->data[1], sprite->data[0]); + sprite->data[1] += 5; + if (sprite->data[1] > 0x7F) + { + sprite->data[0] = sprite->data[0] / 2; + sprite->data[3]++; + sprite->data[1] -= 0x7F; + } + + sprite->data[2] += 0x100; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + sprite->pos2.x -= (sprite->data[2] >> 8); + else + sprite->pos2.x += (sprite->data[2] >> 8); + + sprite->data[2] &= 0xFF; + if (sprite->data[3] == 2) + DestroyAnimSprite(sprite); + break; + } +} + +// Quickly moves the mon towards its partner and back. +// No args. +void AnimTask_SnatchPartnerMove(u8 taskId) +{ + s16 attackerX, targetX; + u8 spriteId; + + switch (gTasks[taskId].data[15]) + { + case 0: + attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + gTasks[taskId].data[0] = 6; + if (attackerX > targetX) + gTasks[taskId].data[0] *= -1; + + gTasks[taskId].data[1] = attackerX; + gTasks[taskId].data[2] = targetX; + gTasks[taskId].data[15]++; + break; + case 1: + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + gSprites[spriteId].pos2.x += gTasks[taskId].data[0]; + if (gTasks[taskId].data[0] > 0) + { + if (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x >= gTasks[taskId].data[2]) + gTasks[taskId].data[15]++; + } + else + { + if (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x <= gTasks[taskId].data[2]) + gTasks[taskId].data[15]++; + } + break; + case 2: + gTasks[taskId].data[0] *= -1; + gTasks[taskId].data[15]++; + break; + case 3: + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + gSprites[spriteId].pos2.x += gTasks[taskId].data[0]; + if (gTasks[taskId].data[0] < 0) + { + if (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x <= gTasks[taskId].data[1]) + gTasks[taskId].data[15]++; + } + else + { + if (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x >= gTasks[taskId].data[1]) + gTasks[taskId].data[15]++; + } + break; + case 4: + default: + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + gSprites[spriteId].pos2.x = 0; + DestroyAnimVisualTask(taskId); + break; + } +} + +// Moves the mon's sprite back and forth in an unpredictable swaying motion. +// No args. +void AnimTask_TeeterDanceMovement(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + task->data[3] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[4] = GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER ? 1 : -1; + task->data[6] = gSprites[task->data[3]].pos1.y; + task->data[5] = gSprites[task->data[3]].pos1.x; + task->data[9] = 0; + task->data[11] = 0; + task->data[10] = 1; + task->data[12] = 0; + task->func = AnimTask_TeeterDanceMovementStep; +} + +static void AnimTask_TeeterDanceMovementStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + switch (task->data[0]) + { + case 0: + task->data[11] += 8; + task->data[11] &= 0xFF; + gSprites[task->data[3]].pos2.x = gSineTable[task->data[11]] >> 5; + task->data[9] += 2; + task->data[9] &= 0xFF; + gSprites[task->data[3]].pos1.x = (gSineTable[task->data[9]] >> 3) * task->data[4] + task->data[5]; + if (task->data[9] == 0) + { + gSprites[task->data[3]].pos1.x = task->data[5]; + task->data[0]++; + } + break; + case 1: + task->data[11] += 8; + task->data[11] &= 0xFF; + gSprites[task->data[3]].pos2.x = gSineTable[task->data[11]] >> 5; + if (task->data[11] == 0) + { + gSprites[task->data[3]].pos2.x = 0; + task->data[0]++; + } + break; + case 2: + DestroyAnimVisualTask(taskId); + break; + } +} + +static void AnimKnockOffStrikeStep(struct Sprite *sprite) +{ + // These two cases are identical. + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + sprite->data[1] += sprite->data[0]; + sprite->data[1] &= 0xFF; + } + else + { + sprite->data[1] += sprite->data[0]; + sprite->data[1] &= 0xFF; + } + + sprite->pos2.x = Cos(sprite->data[1], 20); + sprite->pos2.y = Sin(sprite->data[1], 20); + if (sprite->animEnded) + DestroyAnimSprite(sprite); + + sprite->data[2]++; +} + +// Animates a strike that swipes downard at the target mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +void AnimKnockOffStrike(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = -11; + sprite->data[1] = 192; + StartSpriteAffineAnim(sprite, 1); + } + else + { + sprite->data[0] = 11; + sprite->data[1] = 192; + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + + sprite->callback = AnimKnockOffStrikeStep; +} + +// Gradually fades a rotating recyle arrow sprite in and back out. +// No args. +void AnimRecycle(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_TOP); + if (sprite->pos1.y < 16) + sprite->pos1.y = 16; + + sprite->data[6] = 0; + sprite->data[7] = 16; + sprite->callback = AnimRecycleStep; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); +} + +static void AnimRecycleStep(struct Sprite *sprite) +{ + switch (sprite->data[2]) + { + case 0: + if (++sprite->data[0] > 1) + { + sprite->data[0] = 0; + if (!(sprite->data[1] & 1)) + { + if (sprite->data[6] < 16) + sprite->data[6]++; + } + else + { + if (sprite->data[7] != 0) + sprite->data[7]--; + } + + sprite->data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + if (sprite->data[7] == 0) + sprite->data[2]++; + } + break; + case 1: + if (++sprite->data[0] == 10) + { + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2]++; + } + break; + case 2: + if (++sprite->data[0] > 1) + { + sprite->data[0] = 0; + if (!(sprite->data[1] & 1)) + { + if (sprite->data[6] != 0) + sprite->data[6]--; + } + else + { + if (sprite->data[7] < 16) + sprite->data[7]++; + } + + sprite->data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + if (sprite->data[7] == 16) + sprite->data[2]++; + } + break; + case 3: + DestroySpriteAndMatrix(sprite); + break; + } +} + +void AnimTask_GetWeather(u8 taskId) +{ + gBattleAnimArgs[7] = ANIM_WEATHER_NONE; + if (gWeatherMoveAnim & WEATHER_SUN_ANY) + gBattleAnimArgs[7] = ANIM_WEATHER_SUN; + else if (gWeatherMoveAnim & WEATHER_RAIN_ANY) + gBattleAnimArgs[7] = ANIM_WEATHER_RAIN; + else if (gWeatherMoveAnim & WEATHER_SANDSTORM_ANY) + gBattleAnimArgs[7] = ANIM_WEATHER_SANDSTORM; + else if (gWeatherMoveAnim & WEATHER_HAIL_ANY) + gBattleAnimArgs[7] = ANIM_WEATHER_HAIL; + + DestroyAnimVisualTask(taskId); +} + +// Squishes the mon sprite vertically, and shakes it back and forth. +// arg 0: which battler +void AnimTask_SlackOffSquish(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + task->data[0] = 0; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + PrepareAffineAnimInTaskData(task, task->data[15], gSlackOffSquishAffineAnimCmds); + task->func = AnimTask_SlackOffSquishStep; +} + +static void AnimTask_SlackOffSquishStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + gTasks[taskId].data[0]++; + if (gTasks[taskId].data[0] > 16 && gTasks[taskId].data[0] < 40) + { + if (++task->data[1] > 2) + { + task->data[1] = 0; + task->data[2]++; + if (!(task->data[2] & 1)) + gSprites[task->data[15]].pos2.x = -1; + else + gSprites[task->data[15]].pos2.x = 1; + } + } + else + { + gSprites[task->data[15]].pos2.x = 0; + } + + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); +} -- cgit v1.2.3 From f475600b4c058236fac6790446b98a4d1d6d6fb2 Mon Sep 17 00:00:00 2001 From: Evan Date: Mon, 2 Dec 2019 15:49:22 -0700 Subject: init battle_anim_special --- src/battle_anim_effects_3.c | 282 +++--- src/battle_anim_special.c | 2296 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2440 insertions(+), 138 deletions(-) create mode 100644 src/battle_anim_special.c (limited to 'src') diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 89f66139f..4fd6ada0b 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -120,7 +120,9 @@ static void MoveOdorSleuthClone(struct Sprite *); static void AnimTask_TeeterDanceMovementStep(u8); static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); -const union AnimCmd gScratchAnimCmds[] = + +// Data +const union AnimCmd gScratchAnimCmds[] = //83FEDE4 { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -130,12 +132,12 @@ const union AnimCmd gScratchAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gScratchAnimTable[] = +const union AnimCmd *const gScratchAnimTable[] = //83FEDFC { gScratchAnimCmds, }; -const struct SpriteTemplate gScratchSpriteTemplate = +const struct SpriteTemplate gScratchSpriteTemplate = //83FEE00 { .tileTag = ANIM_TAG_SCRATCH, .paletteTag = ANIM_TAG_SCRATCH, @@ -146,7 +148,7 @@ const struct SpriteTemplate gScratchSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gBlackSmokeSpriteTemplate = +const struct SpriteTemplate gBlackSmokeSpriteTemplate = //83FEE18 { .tileTag = ANIM_TAG_BLACK_SMOKE, .paletteTag = ANIM_TAG_BLACK_SMOKE, @@ -157,7 +159,7 @@ const struct SpriteTemplate gBlackSmokeSpriteTemplate = .callback = AnimBlackSmoke, }; -const struct SpriteTemplate gBlackBallSpriteTemplate = +const struct SpriteTemplate gBlackBallSpriteTemplate = //83FEE30 { .tileTag = ANIM_TAG_BLACK_BALL, .paletteTag = ANIM_TAG_BLACK_BALL, @@ -168,7 +170,7 @@ const struct SpriteTemplate gBlackBallSpriteTemplate = .callback = AnimThrowProjectile, }; -const union AnimCmd gOpeningEyeAnimCmds[] = +const union AnimCmd gOpeningEyeAnimCmds[] = //83FEE48 { ANIMCMD_FRAME(0, 40), ANIMCMD_FRAME(16, 8), @@ -176,12 +178,12 @@ const union AnimCmd gOpeningEyeAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gOpeningEyeAnimTable[] = +const union AnimCmd *const gOpeningEyeAnimTable[] = //83FEE58 { gOpeningEyeAnimCmds, }; -const struct SpriteTemplate gOpeningEyeSpriteTemplate = +const struct SpriteTemplate gOpeningEyeSpriteTemplate = //83FEE5C { .tileTag = ANIM_TAG_OPENING_EYE, .paletteTag = ANIM_TAG_OPENING_EYE, @@ -192,7 +194,7 @@ const struct SpriteTemplate gOpeningEyeSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gWhiteHaloSpriteTemplate = +const struct SpriteTemplate gWhiteHaloSpriteTemplate = //83FEE74 { .tileTag = ANIM_TAG_ROUND_WHITE_HALO, .paletteTag = ANIM_TAG_ROUND_WHITE_HALO, @@ -203,7 +205,7 @@ const struct SpriteTemplate gWhiteHaloSpriteTemplate = .callback = AnimWhiteHalo, }; -const struct SpriteTemplate gTealAlertSpriteTemplate = +const struct SpriteTemplate gTealAlertSpriteTemplate = //83FEE8C { .tileTag = ANIM_TAG_TEAL_ALERT, .paletteTag = ANIM_TAG_TEAL_ALERT, @@ -214,7 +216,7 @@ const struct SpriteTemplate gTealAlertSpriteTemplate = .callback = AnimTealAlert, }; -const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = //83FEEA4 { AFFINEANIMCMD_FRAME(0x180, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x20, 0x18, 0, 5), @@ -222,20 +224,20 @@ const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = //83FEEC4 { AFFINEANIMCMD_FRAME(0x30, 0x30, 0, 0), AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 6), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = +const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = //83FEEDC { gMeanLookEyeAffineAnimCmds1, gMeanLookEyeAffineAnimCmds2, }; -const struct SpriteTemplate gMeanLookEyeSpriteTemplate = +const struct SpriteTemplate gMeanLookEyeSpriteTemplate = //83FEEE4 { .tileTag = ANIM_TAG_EYE, .paletteTag = ANIM_TAG_EYE, @@ -246,7 +248,7 @@ const struct SpriteTemplate gMeanLookEyeSpriteTemplate = .callback = AnimMeanLookEye, }; -const struct SpriteTemplate gSpikesSpriteTemplate = +const struct SpriteTemplate gSpikesSpriteTemplate = //83FEEFC { .tileTag = ANIM_TAG_SPIKES, .paletteTag = ANIM_TAG_SPIKES, @@ -257,7 +259,7 @@ const struct SpriteTemplate gSpikesSpriteTemplate = .callback = AnimSpikes, }; -const union AnimCmd gLeerAnimCmds[] = +const union AnimCmd gLeerAnimCmds[] = //83FEF14 { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -267,12 +269,12 @@ const union AnimCmd gLeerAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gLeerAnimTable[] = +const union AnimCmd *const gLeerAnimTable[] = //83FEF2C { gLeerAnimCmds, }; -const struct SpriteTemplate gLeerSpriteTemplate = +const struct SpriteTemplate gLeerSpriteTemplate = //83FEF30 { .tileTag = ANIM_TAG_LEER, .paletteTag = ANIM_TAG_LEER, @@ -283,30 +285,30 @@ const struct SpriteTemplate gLeerSpriteTemplate = .callback = AnimLeer, }; -const union AnimCmd gLetterZAnimCmds[] = +const union AnimCmd gLetterZAnimCmds[] = //83FEF48 { ANIMCMD_FRAME(0, 3), ANIMCMD_END, }; -const union AnimCmd *const gLetterZAnimTable[] = +const union AnimCmd *const gLetterZAnimTable[] = //83FEF50 { gLetterZAnimCmds, }; -const union AffineAnimCmd gLetterZAffineAnimCmds[] = +const union AffineAnimCmd gLetterZAffineAnimCmds[] = //83FEF54 { AFFINEANIMCMD_FRAME(-7, -7, -3, 16), AFFINEANIMCMD_FRAME(7, 7, 3, 16), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gLetterZAffineAnimTable[] = +const union AffineAnimCmd *const gLetterZAffineAnimTable[] = //83FEF6C { gLetterZAffineAnimCmds, }; -const struct SpriteTemplate gLetterZSpriteTemplate = +const struct SpriteTemplate gLetterZSpriteTemplate = //83FEF70 { .tileTag = ANIM_TAG_LETTER_Z, .paletteTag = ANIM_TAG_LETTER_Z, @@ -317,7 +319,7 @@ const struct SpriteTemplate gLetterZSpriteTemplate = .callback = AnimLetterZ, }; -const union AnimCmd gFangAnimCmds[] = +const union AnimCmd gFangAnimCmds[] = //83FEF88 { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(16, 16), @@ -326,24 +328,24 @@ const union AnimCmd gFangAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gFangAnimTable[] = +const union AnimCmd *const gFangAnimTable[] = //83FEF9C { gFangAnimCmds, }; -const union AffineAnimCmd gFangAffineAnimCmds[] = +const union AffineAnimCmd gFangAffineAnimCmds[] = //83FEFA0 { AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), AFFINEANIMCMD_FRAME(-0x20, -0x20, 0, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gFangAffineAnimTable[] = +const union AffineAnimCmd *const gFangAffineAnimTable[] = //83FEFB8 { gFangAffineAnimCmds, }; -const struct SpriteTemplate gFangSpriteTemplate = +const struct SpriteTemplate gFangSpriteTemplate = //83FEFBC { .tileTag = ANIM_TAG_FANG_ATTACK, .paletteTag = ANIM_TAG_FANG_ATTACK, @@ -354,27 +356,27 @@ const struct SpriteTemplate gFangSpriteTemplate = .callback = AnimFang, }; -const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = +const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = //83FEFD4 { AFFINEANIMCMD_FRAME(0x0, 0x180, 0, 0), AFFINEANIMCMD_FRAME(0x10, 0x0, 0, 20), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = +const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = //83FEFEC { AFFINEANIMCMD_FRAME(0x140, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x10, 0x0, 0, 19), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = +const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = //83FF004 { gSpotlightAffineAnimCmds1, gSpotlightAffineAnimCmds2, }; -const struct SpriteTemplate gSpotlightSpriteTemplate = +const struct SpriteTemplate gSpotlightSpriteTemplate = //83FF00C { .tileTag = ANIM_TAG_SPOTLIGHT, .paletteTag = ANIM_TAG_SPOTLIGHT, @@ -385,7 +387,7 @@ const struct SpriteTemplate gSpotlightSpriteTemplate = .callback = AnimSpotlight, }; -const struct SpriteTemplate gClappingHandSpriteTemplate = +const struct SpriteTemplate gClappingHandSpriteTemplate = //83FF024 { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -396,7 +398,7 @@ const struct SpriteTemplate gClappingHandSpriteTemplate = .callback = AnimClappingHand, }; -const struct SpriteTemplate gClappingHand2SpriteTemplate = +const struct SpriteTemplate gClappingHand2SpriteTemplate = //83FF03C { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -407,7 +409,7 @@ const struct SpriteTemplate gClappingHand2SpriteTemplate = .callback = AnimClappingHand2, }; -const union AnimCmd gRapidSpinAnimCmds[] = +const union AnimCmd gRapidSpinAnimCmds[] = //83FF054 { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(8, 2), @@ -415,12 +417,12 @@ const union AnimCmd gRapidSpinAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRapidSpinAnimTable[] = +const union AnimCmd *const gRapidSpinAnimTable[] = //83FF064 { gRapidSpinAnimCmds, }; -const struct SpriteTemplate gRapidSpinSpriteTemplate = +const struct SpriteTemplate gRapidSpinSpriteTemplate = //83FF068 { .tileTag = ANIM_TAG_RAPID_SPIN, .paletteTag = ANIM_TAG_RAPID_SPIN, @@ -431,7 +433,7 @@ const struct SpriteTemplate gRapidSpinSpriteTemplate = .callback = AnimRapidSpin, }; -const union AffineAnimCmd gUnknown_085CE2A0[] = +const union AffineAnimCmd gUnknown_83FF080[] = //83FF080 { AFFINEANIMCMD_FRAME(-12, 8, 0, 4), AFFINEANIMCMD_FRAME(20, -20, 0, 4), @@ -439,18 +441,18 @@ const union AffineAnimCmd gUnknown_085CE2A0[] = AFFINEANIMCMD_END, }; -const union AnimCmd gTriAttackTriangleAnimCmds[] = +const union AnimCmd gTriAttackTriangleAnimCmds[] = //83FF0A0 { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -const union AnimCmd *const gTriAttackTriangleAnimTable[] = +const union AnimCmd *const gTriAttackTriangleAnimTable[] = //83FF0A8 { gTriAttackTriangleAnimCmds, }; -const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = +const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = //83FF0AC { AFFINEANIMCMD_FRAME(0, 0, 5, 40), AFFINEANIMCMD_FRAME(0, 0, 10, 10), @@ -459,12 +461,12 @@ const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = +const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = //83FF0D4 { gTriAttackTriangleAffineAnimCmds, }; -const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = +const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = //83FF0D8 { .tileTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, .paletteTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, @@ -475,7 +477,7 @@ const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = .callback = AnimTriAttackTriangle, }; -const union AnimCmd gEclipsingOrbAnimCmds[] = +const union AnimCmd gEclipsingOrbAnimCmds[] = //83FF0F0 { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -488,12 +490,12 @@ const union AnimCmd gEclipsingOrbAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gEclipsingOrbAnimTable[] = +const union AnimCmd *const gEclipsingOrbAnimTable[] = //83FF114 { gEclipsingOrbAnimCmds, }; -const struct SpriteTemplate gEclipsingOrbSpriteTemplate = +const struct SpriteTemplate gEclipsingOrbSpriteTemplate = //83FF118 { .tileTag = ANIM_TAG_ECLIPSING_ORB, .paletteTag = ANIM_TAG_ECLIPSING_ORB, @@ -504,7 +506,7 @@ const struct SpriteTemplate gEclipsingOrbSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = +const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = //83FF130 { AFFINEANIMCMD_FRAME(-12, 20, 0, 8), AFFINEANIMCMD_FRAME(12, -20, 0, 8), @@ -512,7 +514,7 @@ const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = +const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = //83FF150 { .tileTag = ANIM_TAG_POKEBALL, .paletteTag = ANIM_TAG_POKEBALL, @@ -523,7 +525,7 @@ const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = .callback = AnimBatonPassPokeball, }; -const struct SpriteTemplate gWishStarSpriteTemplate = +const struct SpriteTemplate gWishStarSpriteTemplate = //83FF168 { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -534,7 +536,7 @@ const struct SpriteTemplate gWishStarSpriteTemplate = .callback = AnimWishStar, }; -const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = +const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = //83FF180 { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -545,7 +547,7 @@ const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = .callback = AnimMiniTwinklingStar, }; -const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = +const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = //83FF198 { AFFINEANIMCMD_FRAME(8, -8, 0, 12), AFFINEANIMCMD_FRAME(-16, 16, 0, 12), @@ -554,7 +556,7 @@ const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = +const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = //83FF1C0 { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -565,7 +567,7 @@ const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = +const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = //83FF1F8 { .tileTag = ANIM_TAG_BLUE_ORB, .paletteTag = ANIM_TAG_BLUE_ORB, @@ -576,7 +578,7 @@ const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = .callback = AnimSwallowBlueOrb, }; -const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = +const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = //83FF210 { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -586,7 +588,7 @@ const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const s8 gMorningSunLightBeamCoordsTable[] = +const s8 gMorningSunLightBeamCoordsTable[] = //83FF240 { 0xE8, 0x18, @@ -594,33 +596,33 @@ const s8 gMorningSunLightBeamCoordsTable[] = 0x00, }; -const union AnimCmd gGreenStarAnimCmds1[] = +const union AnimCmd gGreenStarAnimCmds1[] = //83FF244 { ANIMCMD_FRAME(0, 6), ANIMCMD_FRAME(4, 6), ANIMCMD_JUMP(0), }; -const union AnimCmd gGreenStarAnimCmds2[] = +const union AnimCmd gGreenStarAnimCmds2[] = //83FF250 { ANIMCMD_FRAME(8, 6), ANIMCMD_END, }; -const union AnimCmd gGreenStarAnimCmds3[] = +const union AnimCmd gGreenStarAnimCmds3[] = //83FF258 { ANIMCMD_FRAME(12, 6), ANIMCMD_END, }; -const union AnimCmd *const gGreenStarAnimTable[] = +const union AnimCmd *const gGreenStarAnimTable[] = //83FF260 { gGreenStarAnimCmds1, gGreenStarAnimCmds2, gGreenStarAnimCmds3, }; -const struct SpriteTemplate gGreenStarSpriteTemplate = +const struct SpriteTemplate gGreenStarSpriteTemplate = //83FF26C { .tileTag = ANIM_TAG_GREEN_STAR, .paletteTag = ANIM_TAG_GREEN_STAR, @@ -631,7 +633,7 @@ const struct SpriteTemplate gGreenStarSpriteTemplate = .callback = AnimGreenStar, }; -const s8 gDoomDesireLightBeamCoordTable[] = +const s8 gDoomDesireLightBeamCoordTable[] = //83FF284 { 0x78, 0x50, @@ -639,7 +641,7 @@ const s8 gDoomDesireLightBeamCoordTable[] = 0x00, }; -const u8 gDoomDesireLightBeamDelayTable[] = +const u8 gDoomDesireLightBeamDelayTable[] = //83FF288 { 0, 0, @@ -648,7 +650,7 @@ const u8 gDoomDesireLightBeamDelayTable[] = 50, }; -const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = +const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = //83FF290 { AFFINEANIMCMD_FRAME(0, -15, 0, 7), AFFINEANIMCMD_FRAME(0, 15, 0, 7), @@ -656,7 +658,7 @@ const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = +const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = //83FF2B0 { .tileTag = ANIM_TAG_ANGER, .paletteTag = ANIM_TAG_ANGER, @@ -667,7 +669,7 @@ const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = .callback = AnimWeakFrustrationAngerMark, }; -const union AnimCmd gSweetScentPetalAnimCmds1[] = +const union AnimCmd gSweetScentPetalAnimCmds1[] = //83FF2C8 { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(1, 8), @@ -680,7 +682,7 @@ const union AnimCmd gSweetScentPetalAnimCmds1[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gSweetScentPetalAnimCmds2[] = +const union AnimCmd gSweetScentPetalAnimCmds2[] = //83FF2EC { ANIMCMD_FRAME(0, 8, .hFlip = TRUE), ANIMCMD_FRAME(1, 8, .hFlip = TRUE), @@ -693,20 +695,20 @@ const union AnimCmd gSweetScentPetalAnimCmds2[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gSweetScentPetalAnimCmds3[] = +const union AnimCmd gSweetScentPetalAnimCmds3[] = //83FF310 { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = +const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = //83FF318 { gSweetScentPetalAnimCmds1, gSweetScentPetalAnimCmds2, gSweetScentPetalAnimCmds3, }; -const struct SpriteTemplate gSweetScentPetalSpriteTemplate = +const struct SpriteTemplate gSweetScentPetalSpriteTemplate = //83FF324 { .tileTag = ANIM_TAG_PINK_PETAL, .paletteTag = ANIM_TAG_PINK_PETAL, @@ -717,9 +719,9 @@ const struct SpriteTemplate gSweetScentPetalSpriteTemplate = .callback = AnimSweetScentPetal, }; -const u16 gUnknown_085CE55C[] = INCBIN_U16("graphics/unknown/unknown_85CE55C.gbapal"); +const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/unknown/unk_83FF33C.gbapal"); //Unused -const union AnimCmd gPainSplitAnimCmds[] = +const union AnimCmd gPainSplitAnimCmds[] = //83FF35C { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 9), @@ -727,12 +729,12 @@ const union AnimCmd gPainSplitAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gPainSplitAnimCmdTable[] = +const union AnimCmd *const gPainSplitAnimCmdTable[] = //83FF36C { gPainSplitAnimCmds, }; -const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = +const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = //83FF370 { .tileTag = ANIM_TAG_PAIN_SPLIT, .paletteTag = ANIM_TAG_PAIN_SPLIT, @@ -743,7 +745,7 @@ const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = .callback = AnimPainSplitProjectile, }; -const struct SpriteTemplate gFlatterConfettiSpriteTemplate = +const struct SpriteTemplate gFlatterConfettiSpriteTemplate = //83FF388 { .tileTag = ANIM_TAG_CONFETTI, .paletteTag = ANIM_TAG_CONFETTI, @@ -754,7 +756,7 @@ const struct SpriteTemplate gFlatterConfettiSpriteTemplate = .callback = AnimFlatterConfetti, }; -const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = +const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = //83FF3A0 { .tileTag = ANIM_TAG_SPOTLIGHT, .paletteTag = ANIM_TAG_SPOTLIGHT, @@ -765,7 +767,7 @@ const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = .callback = AnimFlatterSpotlight, }; -const struct SpriteTemplate gReversalOrbSpriteTemplate = +const struct SpriteTemplate gReversalOrbSpriteTemplate = //83FF3B8 { .tileTag = ANIM_TAG_BLUE_ORB, .paletteTag = ANIM_TAG_BLUE_ORB, @@ -776,7 +778,7 @@ const struct SpriteTemplate gReversalOrbSpriteTemplate = .callback = AnimReversalOrb, }; -const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = +const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = //83FF3D0 { AFFINEANIMCMD_FRAME(16, 0, 0, 4), AFFINEANIMCMD_FRAME(0, -3, 0, 16), @@ -786,7 +788,7 @@ const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = +const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = //83FF400 { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-8, -8, 0, 8), @@ -794,7 +796,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = +const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = //83FF420 { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -802,7 +804,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = +const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = //83FF440 { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -810,14 +812,14 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = +const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = //83FF460 { gYawnCloudAffineAnimCmds1, gYawnCloudAffineAnimCmds2, gYawnCloudAffineAnimCmds3, }; -const struct SpriteTemplate gYawnCloudSpriteTemplate = +const struct SpriteTemplate gYawnCloudSpriteTemplate = //83FF46C { .tileTag = ANIM_TAG_PINK_CLOUD, .paletteTag = ANIM_TAG_PINK_CLOUD, @@ -828,7 +830,7 @@ const struct SpriteTemplate gYawnCloudSpriteTemplate = .callback = AnimYawnCloud, }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = //83FF484 { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-4, -6, 0, 16), @@ -836,7 +838,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = //83FF4A4 { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -844,7 +846,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = //83FF4C4 { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -852,7 +854,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = //83FF4E4 { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 10, 0, 30), @@ -860,7 +862,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = +const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = //83FF504 { gSmokeBallEscapeCloudAffineAnimCmds1, gSmokeBallEscapeCloudAffineAnimCmds2, @@ -868,7 +870,7 @@ const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = gSmokeBallEscapeCloudAffineAnimCmds4, }; -const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = +const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = //83FF514 { .tileTag = ANIM_TAG_PINK_CLOUD, .paletteTag = ANIM_TAG_PINK_CLOUD, @@ -879,7 +881,7 @@ const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = .callback = AnimSmokeBallEscapeCloud, }; -const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = +const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = //83FF52C { AFFINEANIMCMD_FRAME(-16, 16, 0, 6), AFFINEANIMCMD_FRAME(16, -16, 0, 12), @@ -887,7 +889,7 @@ const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = +const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = //83FF54C { .tileTag = ANIM_TAG_SWEAT_DROP, .paletteTag = ANIM_TAG_SWEAT_DROP, @@ -898,7 +900,8 @@ const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = .callback = AnimFacadeSweatDrop, }; -const u16 gFacadeBlendColors[] = { +const u16 gFacadeBlendColors[] = //83FF564 +{ RGB(28, 25, 1), RGB(28, 21, 5), RGB(27, 18, 8), @@ -925,27 +928,27 @@ const u16 gFacadeBlendColors[] = { RGB(29, 27, 0), }; -const union AnimCmd gRoarNoiseLineAnimCmds1[] = +const union AnimCmd gRoarNoiseLineAnimCmds1[] = //83FF594 { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd gRoarNoiseLineAnimCmds2[] = +const union AnimCmd gRoarNoiseLineAnimCmds2[] = //83FF5A0 { ANIMCMD_FRAME(32, 3), ANIMCMD_FRAME(48, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRoarNoiseLineAnimTable[] = +const union AnimCmd *const gRoarNoiseLineAnimTable[] = //83FF5AC { gRoarNoiseLineAnimCmds1, gRoarNoiseLineAnimCmds2, }; -const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = +const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = //83FF5B4 { .tileTag = ANIM_TAG_NOISE_LINE, .paletteTag = ANIM_TAG_NOISE_LINE, @@ -956,7 +959,7 @@ const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = .callback = AnimRoarNoiseLine, }; -const struct SpriteTemplate gGlareEyeDotSpriteTemplate = +const struct SpriteTemplate gGlareEyeDotSpriteTemplate = //83FF5CC { .tileTag = ANIM_TAG_SMALL_RED_EYE, .paletteTag = ANIM_TAG_SMALL_RED_EYE, @@ -967,7 +970,7 @@ const struct SpriteTemplate gGlareEyeDotSpriteTemplate = .callback = AnimGlareEyeDot, }; -const struct SpriteTemplate gAssistPawprintSpriteTemplate = +const struct SpriteTemplate gAssistPawprintSpriteTemplate = //83FF5E4 { .tileTag = ANIM_TAG_PAW_PRINT, .paletteTag = ANIM_TAG_PAW_PRINT, @@ -978,26 +981,26 @@ const struct SpriteTemplate gAssistPawprintSpriteTemplate = .callback = AnimAssistPawprint, }; -const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = +const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = //83FF5FC { AFFINEANIMCMD_FRAME(0, 0, -4, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = +const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = //83FF60C { AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = +const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = //83FF624 { gBarrageBallAffineAnimCmds1, gBarrageBallAffineAnimCmds2, }; -const struct SpriteTemplate gBarrageBallSpriteTemplate = +const struct SpriteTemplate gBarrageBallSpriteTemplate = //83FF62C { .tileTag = ANIM_TAG_RED_BALL, .paletteTag = ANIM_TAG_RED_BALL, @@ -1008,7 +1011,7 @@ const struct SpriteTemplate gBarrageBallSpriteTemplate = .callback = SpriteCallbackDummy, }; -const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = +const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = //83FF644 { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -1019,14 +1022,14 @@ const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = .callback = AnimSmellingSaltsHand, }; -const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = +const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = //83FF65C { AFFINEANIMCMD_FRAME(0, -16, 0, 6), AFFINEANIMCMD_FRAME(0, 16, 0, 6), AFFINEANIMCMD_END, }; -const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = +const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = //83FF674 { .tileTag = ANIM_TAG_SMELLINGSALT_EFFECT, .paletteTag = ANIM_TAG_SMELLINGSALT_EFFECT, @@ -1037,7 +1040,7 @@ const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = .callback = AnimSmellingSaltExclamation, }; -const struct SpriteTemplate gHelpingHandClapSpriteTemplate = +const struct SpriteTemplate gHelpingHandClapSpriteTemplate = //83FF68C { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -1048,7 +1051,7 @@ const struct SpriteTemplate gHelpingHandClapSpriteTemplate = .callback = AnimHelpingHandClap, }; -const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = +const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = //83FF6A4 { .tileTag = ANIM_TAG_MAGNIFYING_GLASS, .paletteTag = ANIM_TAG_MAGNIFYING_GLASS, @@ -1059,7 +1062,7 @@ const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = .callback = AnimForesightMagnifyingGlass, }; -const struct SpriteTemplate gMeteorMashStarSpriteTemplate = +const struct SpriteTemplate gMeteorMashStarSpriteTemplate = //83FF6BC { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -1070,7 +1073,7 @@ const struct SpriteTemplate gMeteorMashStarSpriteTemplate = .callback = AnimMeteorMashStar, }; -const struct SpriteTemplate gUnknown_085CE8F4 = +const struct SpriteTemplate gUnknown_83FF6D4 = //83FF6D4 { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -1081,7 +1084,7 @@ const struct SpriteTemplate gUnknown_085CE8F4 = .callback = AnimParticuleBurst, }; -const struct SpriteTemplate gBlockXSpriteTemplate = +const struct SpriteTemplate gBlockXSpriteTemplate = //83FF6EC { .tileTag = ANIM_TAG_X_SIGN, .paletteTag = ANIM_TAG_X_SIGN, @@ -1092,7 +1095,7 @@ const struct SpriteTemplate gBlockXSpriteTemplate = .callback = AnimBlockX, }; -const struct SpriteTemplate gUnknown_085CE924 = +const struct SpriteTemplate gUnknown_83FF704 = //83FF704 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -1100,42 +1103,42 @@ const struct SpriteTemplate gUnknown_085CE924 = .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_815FE80, + .callback = sub_80E3E84, }; -const union AnimCmd gKnockOffStrikeAnimCmds[] = +const union AnimCmd gKnockOffStrikeAnimCmds[] = //83FF71C { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(64, 4), ANIMCMD_END, }; -const union AnimCmd *const gKnockOffStrikeAnimTable[] = +const union AnimCmd *const gKnockOffStrikeAnimTable[] = //83FF728 { gKnockOffStrikeAnimCmds, }; -const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = //83FF72C { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -4, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = //83FF744 { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = +const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = //83FF75C { gKnockOffStrikeAffineanimCmds1, gKnockOffStrikeAffineanimCmds2, }; -const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = +const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = //83FF764 { .tileTag = ANIM_TAG_SLAM_HIT_2, .paletteTag = ANIM_TAG_SLAM_HIT_2, @@ -1146,18 +1149,18 @@ const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = .callback = AnimKnockOffStrike, }; -const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = +const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = //83FF77C { AFFINEANIMCMD_FRAME(0, 0, -4, 64), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = +const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = //83FF78C { gRecycleSpriteAffineAnimCmds, }; -const struct SpriteTemplate gRecycleSpriteTemplate = +const struct SpriteTemplate gRecycleSpriteTemplate = //83FF790 { .tileTag = ANIM_TAG_RECYCLE, .paletteTag = ANIM_TAG_RECYCLE, @@ -1168,7 +1171,7 @@ const struct SpriteTemplate gRecycleSpriteTemplate = .callback = AnimRecycle, }; -const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = +const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = //83FF7A8 { AFFINEANIMCMD_FRAME(0, 16, 0, 4), AFFINEANIMCMD_FRAME(-2, 0, 0, 8), @@ -1179,6 +1182,8 @@ const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = }; // Functions + +// 80DE2C0 void AnimBlackSmoke(struct Sprite *sprite) { sprite->pos1.x += gBattleAnimArgs[0]; @@ -1944,7 +1949,7 @@ static void TormentAttacker_Step(u8 taskId) task->data[5] -= 6; } - PrepareAffineAnimInTaskData(task, task->data[15], gUnknown_085CE2A0); + PrepareAffineAnimInTaskData(task, task->data[15], gUnknown_83FF080); task->data[1]++; task->data[0] = 1; break; @@ -2049,7 +2054,7 @@ void AnimTask_DefenseCurlDeformMon(u8 taskId) switch (gTasks[taskId].data[0]) { case 0: - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE350); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), DefenseCurlDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; break; case 1: @@ -2191,7 +2196,7 @@ void AnimTask_StockpileDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE3B8); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gStockpileDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2205,7 +2210,7 @@ void AnimTask_SpitUpDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE3E0); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gSpitUpDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2238,7 +2243,7 @@ void AnimTask_SwallowDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE430); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gSwallowDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2248,6 +2253,7 @@ void AnimTask_SwallowDeformMon(u8 taskId) } } +// case 2 quite different :/ void AnimTask_TransformMon(u8 taskId) { int i, j; @@ -2456,7 +2462,7 @@ void AnimTask_MorningSunLightBeam(u8 taskId) if (!gTasks[taskId].data[1]) { - gBattle_BG1_X = gUnknown_085CE460[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; + gBattle_BG1_X = gMorningSunLightBeamCoordsTable[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; if (++gTasks[taskId].data[2] == 4) gTasks[taskId].data[0] = 4; else @@ -2503,8 +2509,8 @@ void AnimGreenStar(struct Sprite *sprite) sprite->data[1] = gBattleAnimArgs[0]; sprite->data[2] = gBattleAnimArgs[1]; - spriteId1 = CreateSprite(&gUnknown_085CE48C, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); - spriteId2 = CreateSprite(&gUnknown_085CE48C, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); + spriteId1 = CreateSprite(&gGreenStarSpriteTemplate, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); + spriteId2 = CreateSprite(&gGreenStarSpriteTemplate, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); StartSpriteAnim(&gSprites[spriteId1], 1); StartSpriteAnim(&gSprites[spriteId2], 2); @@ -2595,10 +2601,10 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); */ - sub_80752A0 - sub_807543C - sub_80753B4 - LoadCompressedPalette + sub_80752A0( , + sub_807543C( , gUnknown_8D2A8C0 + sub_80753B4( , gUnknown_8D2A808 + LoadCompressedPalette(gUnknown_8D2A808 //... if (IsContest()) @@ -2631,8 +2637,8 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) gBattle_BG1_Y = 0; } - AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); - LoadCompressedPalette(gUnknown_08C2A6D4, animBg.paletteId * 16, 32); + //AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); + //LoadCompressedPalette(gUnknown_08C2A6D4, animBg.paletteId * 16, 32); gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; gTasks[taskId].data[0]++; @@ -2640,9 +2646,9 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) case 1: gTasks[taskId].data[3] = 0; if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) - gBattle_BG1_X = gTasks[taskId].data[10] + gUnknown_085CE4A4[gTasks[taskId].data[2]]; + gBattle_BG1_X = gTasks[taskId].data[10] + gDoomDesireLightBeamCoordTable[gTasks[taskId].data[2]]; else - gBattle_BG1_X = gTasks[taskId].data[10] - gUnknown_085CE4A4[gTasks[taskId].data[2]]; + gBattle_BG1_X = gTasks[taskId].data[10] - gDoomDesireLightBeamCoordTable[gTasks[taskId].data[2]]; if (++gTasks[taskId].data[2] == 5) gTasks[taskId].data[0] = 5; @@ -2658,7 +2664,7 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) gTasks[taskId].data[0]++; break; case 3: - if (++gTasks[taskId].data[3] > gUnknown_085CE4A8[gTasks[taskId].data[2]]) + if (++gTasks[taskId].data[3] > gDoomDesireLightBeamDelayTable[gTasks[taskId].data[2]]) gTasks[taskId].data[0]++; break; case 4: diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c new file mode 100644 index 000000000..d0d40a6d8 --- /dev/null +++ b/src/battle_anim_special.c @@ -0,0 +1,2296 @@ +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "battle_controllers.h" +#include "battle_interface.h" +#include "decompress.h" +#include "dma3.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "m4a.h" +#include "main.h" +#include "palette.h" +#include "pokeball.h" +#include "sound.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" +#include "util.h" +#include "constants/items.h" +#include "constants/moves.h" +#include "constants/songs.h" +#include "constants/rgb.h" + +// Defines +#define TAG_PARTICLES_POKEBALL 55020 +#define TAG_PARTICLES_GREATBALL 55021 +#define TAG_PARTICLES_SAFARIBALL 55022 +#define TAG_PARTICLES_ULTRABALL 55023 +#define TAG_PARTICLES_MASTERBALL 55024 +#define TAG_PARTICLES_NETBALL 55025 +#define TAG_PARTICLES_DIVEBALL 55026 +#define TAG_PARTICLES_NESTBALL 55027 +#define TAG_PARTICLES_REPEATBALL 55028 +#define TAG_PARTICLES_TIMERBALL 55029 +#define TAG_PARTICLES_LUXURYBALL 55030 +#define TAG_PARTICLES_PREMIERBALL 55031 + +// IWRAM +EWRAM_DATA int gUnknown_3005424 = 0; +EWRAM_DATA u16 gUnknown_3005428 = 0; +EWRAM_DATA u16 gUnknown_300542C = 0; + +// Function Declarations +static void sub_80EEDF4(u8); +static void sub_80EF1CC(u8); +static void sub_80EF698(u8); +static void sub_80EF8C0(struct Sprite *); +static void sub_80EF7EC(u8); +static void sub_80EF864(u8); +static void sub_80EF8F0(struct Sprite *); +static void sub_80F0478(struct Sprite *); +static void sub_80EF9B4(struct Sprite *); +static void sub_80EFA0C(struct Sprite *); +static void sub_80EFB58(struct Sprite *); +static void sub_80EFB9C(struct Sprite *); +static void sub_80EFF80(struct Sprite *); +static void sub_80EFCA0(struct Sprite *); +static void sub_80EFCEC(struct Sprite *); +static void sub_80EFFA4(struct Sprite *); +static void sub_80F02B0(struct Sprite *); +static void sub_80EFFC4(struct Sprite *); +static void sub_80F01B8(struct Sprite *); +static void sub_80F00A4(struct Sprite *); +static void sub_80F018C(struct Sprite *); +static void sub_80F05B4(u8); +static void sub_80F0278(struct Sprite *); +static void sub_80F0378(struct Sprite *); +static void sub_80F04B4(struct Sprite *); +static void PokeBallOpenParticleAnimation_Step1(struct Sprite *); +static void PokeBallOpenParticleAnimation_Step2(struct Sprite *); +static void DestroyBallOpenAnimationParticle(struct Sprite *); +static void FanOutBallOpenParticles_Step1(struct Sprite *); +static void RepeatBallOpenParticleAnimation_Step1(struct Sprite *); +static void PremierBallOpenParticleAnimation_Step1(struct Sprite *); +static void sub_80F12E0(u8); +static void sub_80F1370(u8); +static void sub_80F13C0(u8); +static void sub_80F181C(u8); +static void sub_80F1A2C(struct Sprite *); +static void sub_80F1A80(struct Sprite *); +static void sub_80F19E0(u8); +static void sub_80F1BCC(struct Sprite *); +static void sub_80F1C04(struct Sprite *); +static void sub_80F1C30(struct Sprite *); +static void PokeBallOpenParticleAnimation(u8); +static void GreatBallOpenParticleAnimation(u8); +static void SafariBallOpenParticleAnimation(u8); +static void UltraBallOpenParticleAnimation(u8); +static void MasterBallOpenParticleAnimation(u8); +static void DiveBallOpenParticleAnimation(u8); +static void RepeatBallOpenParticleAnimation(u8); +static void TimerBallOpenParticleAnimation(u8); +static void PremierBallOpenParticleAnimation(u8); +static void sub_80F1B3C(struct Sprite *); + +// Data +struct BallCaptureSuccessStarData +{ + s8 xOffset; + s8 yOffset; + s8 unk2; +}; + +static const struct BallCaptureSuccessStarData sBallCaptureSuccessStarData[] = //gUnknown_840BF3C +{ + { + .xOffset = 10, + .yOffset = 2, + .unk2 = -3, + }, + { + .xOffset = 15, + .yOffset = 0, + .unk2 = -4, + }, + { + .xOffset = -10, + .yOffset = 2, + .unk2 = -4, + }, +}; + +const struct CompressedSpriteSheet gBallParticleSpritesheets[] = //gUnknown_840BF48 +{ + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_POKEBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_GREATBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_SAFARIBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_ULTRABALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_MASTERBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_NETBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_DIVEBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_NESTBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_REPEATBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_TIMERBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_LUXURYBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_PREMIERBALL}, +}; + +const struct CompressedSpritePalette gBallParticlePalettes[] = //gUnknown_840BFA8 +{ + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_POKEBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_GREATBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_SAFARIBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_ULTRABALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_MASTERBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_NETBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_DIVEBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_NESTBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_REPEATBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_TIMERBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_LUXURYBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_PREMIERBALL}, +}; + +const union AnimCmd gAnim_RegularBall[] = //gAnimCmd_840C008 +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_FRAME(2, 1), + ANIMCMD_FRAME(0, 1, .hFlip = TRUE), + ANIMCMD_FRAME(2, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnim_MasterBall[] = //gAnimCmd_840C024 +{ + ANIMCMD_FRAME(3, 1), + ANIMCMD_END, +}; + +const union AnimCmd gAnim_NetDiveBall[] = //gAnimCmd_840C02C +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd gAnim_NestBall[] = //gAnimCmd_840C034 +{ + ANIMCMD_FRAME(5, 1), + ANIMCMD_END, +}; + +const union AnimCmd gAnim_LuxuryPremierBall[] = //gAnimCmd_840C03C +{ + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(7, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnim_UltraRepeatTimerBall[] = //gAnimCmd_840C048 +{ + ANIMCMD_FRAME(7, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gAnims_BallParticles[] = //gSpriteAnimTable_840C050 +{ + gAnim_RegularBall, + gAnim_MasterBall, + gAnim_NetDiveBall, + gAnim_NestBall, + gAnim_LuxuryPremierBall, + gAnim_UltraRepeatTimerBall, +}; + +const u8 gBallParticleAnimNums[] = //gUnknown_840C068 +{ + [BALL_POKE] = 0, + [BALL_GREAT] = 0, + [BALL_SAFARI] = 0, + [BALL_ULTRA] = 5, + [BALL_MASTER] = 1, + [BALL_NET] = 2, + [BALL_DIVE] = 2, + [BALL_NEST] = 3, + [BALL_REPEAT] = 5, + [BALL_TIMER] = 5, + [BALL_LUXURY] = 4, + [BALL_PREMIER] = 4, +}; + +const TaskFunc gBallParticleAnimationFuncs[] = //gUnknown_840C074 +{ + PokeBallOpenParticleAnimation, + GreatBallOpenParticleAnimation, + SafariBallOpenParticleAnimation, + UltraBallOpenParticleAnimation, + MasterBallOpenParticleAnimation, + SafariBallOpenParticleAnimation, + DiveBallOpenParticleAnimation, + UltraBallOpenParticleAnimation, + RepeatBallOpenParticleAnimation, + TimerBallOpenParticleAnimation, + GreatBallOpenParticleAnimation, + PremierBallOpenParticleAnimation, +}; + +const struct SpriteTemplate gBallParticlesSpriteTemplates[] = //gUnknown_840C0A4 +{ + { + .tileTag = TAG_PARTICLES_POKEBALL, + .paletteTag = TAG_PARTICLES_POKEBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_GREATBALL, + .paletteTag = TAG_PARTICLES_GREATBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_SAFARIBALL, + .paletteTag = TAG_PARTICLES_SAFARIBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_ULTRABALL, + .paletteTag = TAG_PARTICLES_ULTRABALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_MASTERBALL, + .paletteTag = TAG_PARTICLES_MASTERBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_NETBALL, + .paletteTag = TAG_PARTICLES_NETBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_DIVEBALL, + .paletteTag = TAG_PARTICLES_DIVEBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_NESTBALL, + .paletteTag = TAG_PARTICLES_NESTBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_REPEATBALL, + .paletteTag = TAG_PARTICLES_REPEATBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_TIMERBALL, + .paletteTag = TAG_PARTICLES_TIMERBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_LUXURYBALL, + .paletteTag = TAG_PARTICLES_LUXURYBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_PREMIERBALL, + .paletteTag = TAG_PARTICLES_PREMIERBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, +}; + +const u16 gBallOpenFadeColors[] = //gUnknown_840C1C4 +{ + [BALL_POKE] = RGB(31, 22, 30), + [BALL_GREAT] = RGB(16, 23, 30), + [BALL_SAFARI] = RGB(23, 30, 20), + [BALL_ULTRA] = RGB(31, 31, 15), + [BALL_MASTER] = RGB(23, 20, 28), + [BALL_NET] = RGB(21, 31, 25), + [BALL_DIVE] = RGB(12, 25, 30), + [BALL_NEST] = RGB(30, 27, 10), + [BALL_REPEAT] = RGB(31, 24, 16), + [BALL_TIMER] = RGB(29, 30, 30), + [BALL_LUXURY] = RGB(31, 17, 10), + [BALL_PREMIER] = RGB(31, 9, 10), + + // Garbage data + RGB(0, 0, 0), + RGB(1, 16, 0), + RGB(3, 0, 1), + RGB(1, 8, 0), + RGB(0, 8, 0), + RGB(3, 8, 1), + RGB(6, 8, 1), + RGB(4, 0, 0), +}; + +const struct SpriteTemplate gPokeblockSpriteTemplate = //gUnknown_840C1EC +{ + .tileTag = ANIM_TAG_POKEBLOCK, + .paletteTag = ANIM_TAG_POKEBLOCK, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80F1B3C, +}; + +const union AnimCmd gUnknown_840C204[] = +{ + ANIMCMD_FRAME(64, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gSpriteAnimTable_840C20C[] = { + gUnknown_840C204, +}; + +const struct SpriteTemplate gUnknown_840C210 = +{ + .tileTag = ANIM_TAG_ROCKS, + .paletteTag = ANIM_TAG_ROCKS, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAnimTable_840C20C, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80F1B3C, +}; + +extern const struct SpriteTemplate gWishStarSpriteTemplate; +extern const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate; + +// Functions +void sub_80EEC0C(u8 taskId) +{ + struct BattleAnimBgData unknownStruct; + u8 healthBoxSpriteId; + u8 battler; + u8 spriteId1, spriteId2, spriteId3, spriteId4; + + battler = gBattleAnimAttacker; + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG2 | WINOUT_WIN01_BG3 | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJWIN_ON); + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 0); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 1); + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + healthBoxSpriteId = gHealthboxSpriteIds[battler]; + spriteId1 = gSprites[healthBoxSpriteId].oam.affineParam; + spriteId2 = gSprites[healthBoxSpriteId].data[5]; + spriteId3 = CreateInvisibleSpriteWithCallback(SpriteCallbackDummy); + spriteId4 = CreateInvisibleSpriteWithCallback(SpriteCallbackDummy); + gSprites[healthBoxSpriteId].oam.priority = 1; + gSprites[spriteId1].oam.priority = 1; + gSprites[spriteId2].oam.priority = 1; + gSprites[spriteId3] = gSprites[healthBoxSpriteId]; + gSprites[spriteId4] = gSprites[spriteId1]; + gSprites[spriteId3].oam.objMode = ST_OAM_OBJ_WINDOW; + gSprites[spriteId4].oam.objMode = ST_OAM_OBJ_WINDOW; + gSprites[spriteId3].callback = SpriteCallbackDummy; + gSprites[spriteId4].callback = SpriteCallbackDummy; + + sub_80A6B30(&unknownStruct); + AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_08C2EA9C); + AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_08C2EA50, unknownStruct.tilesOffset); + LoadCompressedPalette(gCureBubblesPal, unknownStruct.paletteId << 4, 32); + + gBattle_BG1_X = -gSprites[spriteId3].pos1.x + 32; + gBattle_BG1_Y = -gSprites[spriteId3].pos1.y - 32; + gTasks[taskId].data[1] = 640; + gTasks[taskId].data[0] = spriteId3; + gTasks[taskId].data[2] = spriteId4; + gTasks[taskId].func = sub_80EEDF4; +} + +static void sub_80EEDF4(u8 taskId) +{ + u8 spriteId1, spriteId2; + u8 battler; + + battler = gBattleAnimAttacker; + gTasks[taskId].data[13] += gTasks[taskId].data[1]; + gBattle_BG1_Y += (u16)gTasks[taskId].data[13] >> 8; + gTasks[taskId].data[13] &= 0xFF; + + switch (gTasks[taskId].data[15]) + { + case 0: + if (gTasks[taskId].data[11]++ > 1) + { + gTasks[taskId].data[11] = 0; + gTasks[taskId].data[12]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[12], 16 - gTasks[taskId].data[12])); + if (gTasks[taskId].data[12] == 8) + gTasks[taskId].data[15]++; + } + break; + case 1: + if (++gTasks[taskId].data[10] == 30) + gTasks[taskId].data[15]++; + break; + case 2: + if (gTasks[taskId].data[11]++ > 1) + { + gTasks[taskId].data[11] = 0; + gTasks[taskId].data[12]--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[12], 16 - gTasks[taskId].data[12])); + if (gTasks[taskId].data[12] == 0) + { + sub_80A477C(0); + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetGpuReg(REG_OFFSET_DISPCNT, GetGpuReg(REG_OFFSET_DISPCNT) ^ DISPCNT_OBJWIN_ON); + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 0)); + DestroySprite(&gSprites[gTasks[taskId].data[0]]); + DestroySprite(&gSprites[gTasks[taskId].data[2]]); + SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0); + spriteId1 = gSprites[gHealthboxSpriteIds[battler]].oam.affineParam; + spriteId2 = gSprites[gHealthboxSpriteIds[battler]].data[5]; + gSprites[gHealthboxSpriteIds[battler]].oam.priority = 1; + gSprites[spriteId1].oam.priority = 1; + gSprites[spriteId2].oam.priority = 1; + DestroyAnimVisualTask(taskId); + } + } + break; + } +} + +static void sub_80EEFC8(u8 *paletteId1, u8 *paletteId2, u8 battler) +{ + u8 healthBoxSpriteId; + u8 spriteId1, spriteId2; + u16 offset1, offset2; + + healthBoxSpriteId = gHealthboxSpriteIds[battler]; + spriteId1 = gSprites[healthBoxSpriteId].oam.affineParam; + spriteId2 = gSprites[healthBoxSpriteId].data[5]; + *paletteId1 = AllocSpritePalette(0xD709); + *paletteId2 = AllocSpritePalette(0xD70A); + + offset1 = (gSprites[healthBoxSpriteId].oam.paletteNum * 16) + 0x100; + offset2 = (gSprites[spriteId2].oam.paletteNum * 16) + 0x100; + LoadPalette(&gPlttBufferUnfaded[offset1], *paletteId1 * 16 + 0x100, 0x20); + LoadPalette(&gPlttBufferUnfaded[offset2], *paletteId2 * 16 + 0x100, 0x20); + + gSprites[healthBoxSpriteId].oam.paletteNum = *paletteId1; + gSprites[spriteId1].oam.paletteNum = *paletteId1; + gSprites[spriteId2].oam.paletteNum = *paletteId2; +} + +void sub_80EF0B4(u8 taskId) +{ + u8 paletteId1, paletteId2; + sub_80EEFC8(&paletteId1, &paletteId2, gBattleAnimAttacker); + DestroyAnimVisualTask(taskId); +} + +static void sub_80EF0E0(u8 battler) +{ + u8 healthBoxSpriteId; + u8 spriteId1, spriteId2; + u8 paletteId1, paletteId2; + + healthBoxSpriteId = gHealthboxSpriteIds[battler]; + spriteId1 = gSprites[healthBoxSpriteId].oam.affineParam; + spriteId2 = gSprites[healthBoxSpriteId].data[5]; + + FreeSpritePaletteByTag(0xD709); + FreeSpritePaletteByTag(0xD70A); + paletteId1 = IndexOfSpritePaletteTag(0xD6FF); + paletteId2 = IndexOfSpritePaletteTag(0xD704); + gSprites[healthBoxSpriteId].oam.paletteNum = paletteId1; + gSprites[spriteId1].oam.paletteNum = paletteId1; + gSprites[spriteId2].oam.paletteNum = paletteId2; +} + +void sub_80EF180(u8 taskId) +{ + sub_80EF0E0(gBattleAnimAttacker); + DestroyAnimVisualTask(taskId); +} + +void sub_80EF1A0(u8 taskId) +{ + gTasks[taskId].data[10] = gBattleAnimArgs[0]; + gTasks[taskId].data[11] = gBattleAnimArgs[1]; + gTasks[taskId].func = sub_80EF1CC; +} + +static void sub_80EF1CC(u8 taskId) +{ + u8 paletteNum; + int paletteOffset, colorOffset; + + gTasks[taskId].data[0]++; + if (gTasks[taskId].data[0]++ >= gTasks[taskId].data[11]) + { + gTasks[taskId].data[0] = 0; + paletteNum = IndexOfSpritePaletteTag(0xD709); + colorOffset = gTasks[taskId].data[10] == 0 ? 6 : 2; + switch (gTasks[taskId].data[1]) + { + case 0: + gTasks[taskId].data[2] += 2; + if (gTasks[taskId].data[2] > 16) + gTasks[taskId].data[2] = 16; + + paletteOffset = paletteNum * 16 + 0x100; + BlendPalette(paletteOffset + colorOffset, 1, gTasks[taskId].data[2], RGB(20, 27, 31)); + if (gTasks[taskId].data[2] == 16) + gTasks[taskId].data[1]++; + break; + case 1: + gTasks[taskId].data[2] -= 2; + if (gTasks[taskId].data[2] < 0) + gTasks[taskId].data[2] = 0; + + paletteOffset = paletteNum * 16 + 0x100; + BlendPalette(paletteOffset + colorOffset, 1, gTasks[taskId].data[2], RGB(20, 27, 31)); + if (gTasks[taskId].data[2] == 0) + DestroyAnimVisualTask(taskId); + break; + } + } +} + +void sub_80EF298(u8 taskId) +{ + u8 spriteId; + + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + switch (gTasks[taskId].data[0]) + { + case 0: + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + gTasks[taskId].data[10] = 0x100; + gTasks[taskId].data[0]++; + break; + case 1: + gTasks[taskId].data[10] += 0x30; + SetSpriteRotScale(spriteId, gTasks[taskId].data[10], gTasks[taskId].data[10], 0); + SetBattlerSpriteYOffsetFromYScale(spriteId); + if (gTasks[taskId].data[10] >= 0x2D0) + gTasks[taskId].data[0]++; + break; + case 2: + ResetSpriteRotScale(spriteId); + gSprites[spriteId].invisible = 1; + DestroyAnimVisualTask(taskId); + break; + } +} + +void sub_80EF344(u8 taskId) +{ + u8 spriteId; + u16 ball; + u8 ballId; + u8 x, y; + u8 priority, subpriority; + u32 selectedPalettes; + + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + ball = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_POKEBALL); + else + ball = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_POKEBALL); + + ballId = ItemIdToBallId(ball); + switch (gTasks[taskId].data[0]) + { + case 0: + x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + priority = gSprites[spriteId].oam.priority; + subpriority = gSprites[spriteId].subpriority; + gTasks[taskId].data[10] = AnimateBallOpenParticles(x, y + 32, priority, subpriority, ballId); + selectedPalettes = sub_80A75AC(1, 0, 0, 0, 0, 0, 0); + gTasks[taskId].data[11] = LaunchBallFadeMonTask(0, gBattleAnimAttacker, selectedPalettes, ballId); + gTasks[taskId].data[0]++; + break; + case 1: + if (!gTasks[gTasks[taskId].data[10]].isActive && !gTasks[gTasks[taskId].data[11]].isActive) + DestroyAnimVisualTask(taskId); + break; + } +} + +void sub_80EF490(u8 taskId) +{ + u8 ballId = ItemIdToBallId(gLastUsedItem); + LoadBallGfx(ballId); + DestroyAnimVisualTask(taskId); +} + +void sub_80EF4B8(u8 taskId) +{ + u8 ballId = ItemIdToBallId(gLastUsedItem); + FreeBallGfx(ballId); + DestroyAnimVisualTask(taskId); +} + +void AnimTask_IsBallBlockedByTrainer(u8 taskId) +{ + if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_TRAINER_BLOCK) + gBattleAnimArgs[ARG_RET_ID] = -1; + else + gBattleAnimArgs[ARG_RET_ID] = 0; + + DestroyAnimVisualTask(taskId); +} + +u8 ItemIdToBallId(u16 ballItem) +{ + switch (ballItem) + { + case ITEM_MASTER_BALL: + return BALL_MASTER; + case ITEM_ULTRA_BALL: + return BALL_ULTRA; + case ITEM_GREAT_BALL: + return BALL_GREAT; + case ITEM_SAFARI_BALL: + return BALL_SAFARI; + case ITEM_NET_BALL: + return BALL_NET; + case ITEM_DIVE_BALL: + return BALL_DIVE; + case ITEM_NEST_BALL: + return BALL_NEST; + case ITEM_REPEAT_BALL: + return BALL_REPEAT; + case ITEM_TIMER_BALL: + return BALL_TIMER; + case ITEM_LUXURY_BALL: + return BALL_LUXURY; + case ITEM_PREMIER_BALL: + return BALL_PREMIER; + case ITEM_POKE_BALL: + default: + return BALL_POKE; + } +} + +void sub_80EF5AC(u8 taskId) +{ + u8 ballId; + u8 spriteId; + + ballId = ItemIdToBallId(gLastUsedItem); + spriteId = CreateSprite(&gBallSpriteTemplates[ballId], 32, 80, 29); + gSprites[spriteId].data[0] = 34; + gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) - 16; + gSprites[spriteId].callback = sub_80EF8C0; + gBattleSpritesDataPtr->animationData->field_9_x2 = gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible; + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].func = sub_80EF698; +} + +static void sub_80EF698(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[0]; + if ((u16)gSprites[spriteId].data[0] == 0xFFFF) + DestroyAnimVisualTask(taskId); +} + +void sub_80EF6D4(u8 taskId) +{ + int x, y; + u8 ballId; + u8 subpriority; + u8 spriteId; + + if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) + { + x = 32; + y = 11; + } + else + { + x = 23; + y = 5; + } + + ballId = ItemIdToBallId(gLastUsedItem); + subpriority = GetBattlerSpriteSubpriority(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)) + 1; + spriteId = CreateSprite(&gBallSpriteTemplates[ballId], x + 32, y | 80, subpriority); + gSprites[spriteId].data[0] = 34; + gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) - 16; + gSprites[spriteId].callback = SpriteCallbackDummy; + gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].callback = sub_8039E84; + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].func = sub_80EF7EC; +} + +static void sub_80EF7EC(u8 taskId) +{ + if (gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].animCmdIndex == 1) + { + PlaySE12WithPanning(SE_NAGERU, 0); + gSprites[gTasks[taskId].data[0]].callback = sub_80EF8C0; + CreateTask(sub_80EF864, 10); + gTasks[taskId].func = sub_80EF698; + } +} + +static void sub_80EF864(u8 taskId) +{ + if (gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].animEnded) + { + StartSpriteAnim(&gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]], 0); + DestroyTask(taskId); + } +} + +static void sub_80EF8C0(struct Sprite *sprite) +{ + u16 temp = sprite->data[1]; + u16 temp2 = sprite->data[2]; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = temp; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = temp2; + sprite->data[5] = -40; + InitAnimArcTranslation(sprite); + sprite->callback = sub_80EF8F0; +} + +static void sub_80EF8F0(struct Sprite *sprite) +{ + int i; + u8 ballId; + + if (TranslateAnimHorizontalArc(sprite)) + { + if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_TRAINER_BLOCK) + { + sprite->callback = sub_80F0478; + } + else if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_GHOST_DODGE) + { + sprite->callback = sub_80F052C; + } + else + { + StartSpriteAnim(sprite, 1); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + + for (i = 0; i < 8; i++) + sprite->data[i] = 0; + + sprite->data[5] = 0; + sprite->callback = sub_80EF9B4; + + ballId = ItemIdToBallId(gLastUsedItem); + switch (ballId) + { + case 0 ... POKEBALL_COUNT - 1: + AnimateBallOpenParticles(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); + LaunchBallFadeMonTask(0, gBattleAnimTarget, 14, ballId); + break; + } + } + } +} + +static void sub_80EF9B4(struct Sprite *sprite) +{ + if (++sprite->data[5] == 10) + { + sprite->data[5] = CreateTask(TaskDummy, 50); + sprite->callback = sub_80EFA0C; + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] = 0; + } +} + +static void sub_80EFA0C(struct Sprite *sprite) +{ + u8 spriteId; + u8 taskId; + + spriteId = gBattlerSpriteIds[gBattleAnimTarget]; + taskId = sprite->data[5]; + + if (++gTasks[taskId].data[1] == 11) + PlaySE(SE_SUIKOMU); + + switch (gTasks[taskId].data[0]) + { + case 0: + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + gTasks[taskId].data[10] = 256; + gUnknown_3005424 = 28; + gUnknown_300542C = (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y) - (sprite->pos1.y + sprite->pos2.y); + gUnknown_3005428 = (u32)(gUnknown_300542C * 256) / 28; + gTasks[taskId].data[2] = gUnknown_3005428; + gTasks[taskId].data[0]++; + break; + case 1: + gTasks[taskId].data[10] += 0x20; + SetSpriteRotScale(spriteId, gTasks[taskId].data[10], gTasks[taskId].data[10], 0); + gTasks[taskId].data[3] += gTasks[taskId].data[2]; + gSprites[spriteId].pos2.y = -gTasks[taskId].data[3] >> 8; + if (gTasks[taskId].data[10] >= 0x480) + gTasks[taskId].data[0]++; + break; + case 2: + ResetSpriteRotScale(spriteId); + gSprites[spriteId].invisible = 1; + gTasks[taskId].data[0]++; + break; + default: + if (gTasks[taskId].data[1] > 10) + { + DestroyTask(taskId); + StartSpriteAnim(sprite, 2); + sprite->data[5] = 0; + sprite->callback = sub_80EFB58; + } + break; + } +} + +static void sub_80EFB58(struct Sprite *sprite) +{ + int angle; + + if (sprite->animEnded) + { + sprite->data[3] = 0; + sprite->data[4] = 40; + sprite->data[5] = 0; + angle = 0; + sprite->pos1.y += Cos(angle, 40); + sprite->pos2.y = -Cos(angle, sprite->data[4]); + sprite->callback = sub_80EFB9C; + } +} + +static void sub_80EFB9C(struct Sprite *sprite) +{ + bool8 lastBounce; + int bounceCount; + + lastBounce = 0; + + switch (sprite->data[3] & 0xFF) + { + case 0: + sprite->pos2.y = -Cos(sprite->data[5], sprite->data[4]); + sprite->data[5] += (sprite->data[3] >> 8) + 4; + if (sprite->data[5] >= 64) + { + sprite->data[4] -= 10; + sprite->data[3] += 257; + + bounceCount = sprite->data[3] >> 8; + if (bounceCount == 4) + lastBounce = 1; + + // Play a different sound effect for each pokeball bounce. + switch (bounceCount) + { + case 1: + PlaySE(SE_KON); + break; + case 2: + PlaySE(SE_KON2); + break; + case 3: + PlaySE(SE_KON3); + break; + default: + PlaySE(SE_KON4); + break; + } + } + break; + case 1: + sprite->pos2.y = -Cos(sprite->data[5], sprite->data[4]); + sprite->data[5] -= (sprite->data[3] >> 8) + 4; + if (sprite->data[5] <= 0) + { + sprite->data[5] = 0; + sprite->data[3] &= -0x100; + } + break; + } + + if (lastBounce) + { + sprite->data[3] = 0; + sprite->pos1.y += Cos(64, 40); + sprite->pos2.y = 0; + if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_NO_SHAKES) + { + sprite->data[5] = 0; + sprite->callback = sub_80EFF80; + } + else + { + sprite->callback = sub_80EFCA0; + sprite->data[4] = 1; + sprite->data[5] = 0; + } + } +} + +static void sub_80EFCA0(struct Sprite *sprite) +{ + if (++sprite->data[3] == 31) + { + sprite->data[3] = 0; + sprite->affineAnimPaused = 1; + StartSpriteAffineAnim(sprite, 1); + gBattleSpritesDataPtr->animationData->field_C = 0; + sprite->callback = sub_80EFCEC; + PlaySE(SE_BOWA); + } +} + +static void sub_80EFCEC(struct Sprite *sprite) +{ + s8 state; + u16 var0; + + switch (sprite->data[3] & 0xFF) + { + case 0: + if (gBattleSpritesDataPtr->animationData->field_C > 0xFF) + { + sprite->pos2.x += sprite->data[4]; + gBattleSpritesDataPtr->animationData->field_C &= 0xFF; + } + else + { + gBattleSpritesDataPtr->animationData->field_C += 0xB0; + } + + sprite->data[5]++; + sprite->affineAnimPaused = 0; + var0 = sprite->data[5] + 7; + if (var0 > 14) + { + gBattleSpritesDataPtr->animationData->field_C = 0; + sprite->data[3]++; + sprite->data[5] = 0; + } + break; + case 1: + if (++sprite->data[5] == 1) + { + sprite->data[5] = 0; + sprite->data[4] = -sprite->data[4]; + sprite->data[3]++; + sprite->affineAnimPaused = 0; + if (sprite->data[4] < 0) + ChangeSpriteAffineAnim(sprite, 2); + else + ChangeSpriteAffineAnim(sprite, 1); + } + else + { + sprite->affineAnimPaused = 1; + } + break; + case 2: + if (gBattleSpritesDataPtr->animationData->field_C > 0xFF) + { + sprite->pos2.x += sprite->data[4]; + gBattleSpritesDataPtr->animationData->field_C &= 0xFF; + } + else + { + gBattleSpritesDataPtr->animationData->field_C += 0xB0; + } + + sprite->data[5]++; + sprite->affineAnimPaused = 0; + var0 = sprite->data[5] + 12; + if (var0 > 24) + { + gBattleSpritesDataPtr->animationData->field_C = 0; + sprite->data[3]++; + sprite->data[5] = 0; + } + break; + case 3: + if (sprite->data[5]++ < 0) + { + sprite->affineAnimPaused = 1; + break; + } + + sprite->data[5] = 0; + sprite->data[4] = -sprite->data[4]; + sprite->data[3]++; + sprite->affineAnimPaused = 0; + if (sprite->data[4] < 0) + ChangeSpriteAffineAnim(sprite, 2); + else + ChangeSpriteAffineAnim(sprite, 1); + // fall through + case 4: + if (gBattleSpritesDataPtr->animationData->field_C > 0xFF) + { + sprite->pos2.x += sprite->data[4]; + gBattleSpritesDataPtr->animationData->field_C &= 0xFF; + } + else + { + gBattleSpritesDataPtr->animationData->field_C += 0xB0; + } + + sprite->data[5]++; + sprite->affineAnimPaused = 0; + var0 = sprite->data[5] + 4; + if (var0 > 8) + { + gBattleSpritesDataPtr->animationData->field_C = 0; + sprite->data[3]++; + sprite->data[5] = 0; + sprite->data[4] = -sprite->data[4]; + } + break; + case 5: + sprite->data[3] += 0x100; + state = sprite->data[3] >> 8; + if (state == gBattleSpritesDataPtr->animationData->ballThrowCaseId) + { + sprite->affineAnimPaused = 1; + sprite->callback = sub_80EFF80; + } + else + { + if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_3_SHAKES_SUCCESS && state == 3) + { + sprite->callback = sub_80EFFA4; + sprite->affineAnimPaused = 1; + } + else + { + sprite->data[3]++; + sprite->affineAnimPaused = 1; + } + } + break; + case 6: + default: + if (++sprite->data[5] == 31) + { + sprite->data[5] = 0; + sprite->data[3] &= -0x100; + StartSpriteAffineAnim(sprite, 3); + if (sprite->data[4] < 0) + StartSpriteAffineAnim(sprite, 2); + else + StartSpriteAffineAnim(sprite, 1); + + PlaySE(SE_BOWA); + } + break; + } +} + +static void sub_80EFF80(struct Sprite *sprite) +{ + if (++sprite->data[5] == 31) + { + sprite->data[5] = 0; + sprite->callback = sub_80F02B0; + } +} + +static void sub_80EFFA4(struct Sprite *sprite) +{ + sprite->animPaused = 1; + sprite->callback = sub_80EFFC4; + sprite->data[3] = 0; + sprite->data[4] = 0; + sprite->data[5] = 0; +} + +static void sub_80EFFC4(struct Sprite *sprite) +{ + u8 *battler = &gBattleAnimTarget; + + sprite->data[4]++; + if (sprite->data[4] == 40) + { + PlaySE(SE_RG_GETTING); + BlendPalettes(0x10000 << sprite->oam.paletteNum, 6, RGB(0, 0, 0)); + sub_80F01B8(sprite); + } + else if (sprite->data[4] == 60) + { + BeginNormalPaletteFade(0x10000 << sprite->oam.paletteNum, 2, 6, 0, RGB(0, 0, 0)); + } + else if (sprite->data[4] == 95) + { + gDoingBattleAnim = 0; + UpdateOamPriorityInAllHealthboxes(1); + m4aMPlayAllStop(); + PlaySE(MUS_RG_FAN6); + } + else if (sprite->data[4] == 315) + { + FreeOamMatrix(gSprites[gBattlerSpriteIds[*battler]].oam.matrixNum); + DestroySprite(&gSprites[gBattlerSpriteIds[*battler]]); + sprite->data[0] = 0; + sprite->callback = sub_80F00A4; + } +} + +static void sub_80F00A4(struct Sprite *sprite) +{ + u8 paletteIndex; + + switch (sprite->data[0]) + { + case 0: + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->oam.objMode = ST_OAM_OBJ_BLEND; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16, 0)); + paletteIndex = IndexOfSpritePaletteTag(sprite->template->paletteTag); + BeginNormalPaletteFade(1 << (paletteIndex + 0x10), 0, 0, 16, RGB(31, 31, 31)); + sprite->data[0]++; + break; + case 1: + if (sprite->data[1]++ > 0) + { + sprite->data[1] = 0; + sprite->data[2]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[2], sprite->data[2])); + if (sprite->data[2] == 16) + sprite->data[0]++; + } + break; + case 2: + sprite->invisible = 1; + sprite->data[0]++; + break; + default: + if (!gPaletteFade.active) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + } + break; + } +} + +static void sub_80F018C(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[0] = -1; + } + else + { + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); + } +} + +static void sub_80F01B8(struct Sprite *sprite) +{ + u32 i; + u8 subpriority; + + if (sprite->subpriority) + { + subpriority = sprite->subpriority - 1; + } + else + { + subpriority = 0; + sprite->subpriority = 1; + } + + sub_80F05B4(4); + for (i = 0; i < 3; i++) + { + u8 spriteId = CreateSprite(&gBallParticlesSpriteTemplates[4], sprite->pos1.x, sprite->pos1.y, subpriority); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].data[0] = 24; + gSprites[spriteId].data[2] = sprite->pos1.x + sBallCaptureSuccessStarData[i].xOffset; + gSprites[spriteId].data[4] = sprite->pos1.y + sBallCaptureSuccessStarData[i].yOffset; + gSprites[spriteId].data[5] = sBallCaptureSuccessStarData[i].unk2; + InitAnimArcTranslation(&gSprites[spriteId]); + gSprites[spriteId].callback = sub_80F0278; + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[4]); + } + } +} + +static void sub_80F0278(struct Sprite *sprite) +{ + sprite->invisible = !sprite->invisible; + if (TranslateAnimHorizontalArc(sprite)) + DestroySprite(sprite); +} + +static void sub_80F02B0(struct Sprite *sprite) +{ + u8 ballId; + + StartSpriteAnim(sprite, 1); + StartSpriteAffineAnim(sprite, 0); + sprite->callback = sub_80F0378; + + ballId = ItemIdToBallId(gLastUsedItem); + switch (ballId) + { + case 0 ... POKEBALL_COUNT - 1: + AnimateBallOpenParticles(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); + LaunchBallFadeMonTask(1, gBattleAnimTarget, 14, ballId); + break; + } + + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible = 0; + StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimTarget]], 1); + AnimateSprite(&gSprites[gBattlerSpriteIds[gBattleAnimTarget]]); + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] = 0x1000; +} + +static void sub_80F0378(struct Sprite *sprite) +{ + int next = FALSE; + + if (sprite->animEnded) + sprite->invisible = 1; + + if (gSprites[gBattlerSpriteIds[gBattleAnimTarget]].affineAnimEnded) + { + StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimTarget]], 0); + next = TRUE; + } + else + { + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] -= 288; + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].pos2.y = gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] >> 8; + } + + if (sprite->animEnded && next) + { + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].pos2.y = 0; + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible = gBattleSpritesDataPtr->animationData->field_9_x2; + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + gDoingBattleAnim = 0; + UpdateOamPriorityInAllHealthboxes(1); + } +} + +static void sub_80F0478(struct Sprite *sprite) +{ + int i; + + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + for (i = 0; i < 6; i++) + sprite->data[i] = 0; + + sprite->callback = sub_80F04B4; +} + +static void sub_80F04B4(struct Sprite *sprite) +{ + s16 var0 = sprite->data[0] + 0x800; + s16 var1 = sprite->data[1] + 0x680; + sprite->pos2.x -= var1 >> 8; + sprite->pos2.y += var0 >> 8; + sprite->data[0] = (sprite->data[0] + 0x800) & 0xFF; + sprite->data[1] = (sprite->data[1] + 0x680) & 0xFF; + + if (sprite->pos1.y + sprite->pos2.y > 160 + || sprite->pos1.x + sprite->pos2.x < -8) + { + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + gDoingBattleAnim = 0; + UpdateOamPriorityInAllHealthboxes(1); + } +} + +// GhostBallDodge +static void sub_80F052C(struct Sprite *sprite) +{ + // to do +} + +static void sub_80F0574(struct Sprite *sprite) +{ + //to do +} + +static void sub_80F05B4(u8 ballId) +{ + u8 taskId; + + if (GetSpriteTileStartByTag(gBallParticleSpritesheets[ballId].tag) == 0xFFFF) + { + LoadCompressedSpriteSheetUsingHeap(&gBallParticleSpritesheets[ballId]); + LoadCompressedSpritePaletteUsingHeap(&gBallParticlePalettes[ballId]); + } +} + +u8 AnimateBallOpenParticles(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId) +{ + u8 taskId; + + sub_80F05B4(ballId); + taskId = CreateTask(gBallParticleAnimationFuncs[ballId], 5); + gTasks[taskId].data[1] = x; + gTasks[taskId].data[2] = y; + gTasks[taskId].data[3] = priority; + gTasks[taskId].data[4] = subpriority; + gTasks[taskId].data[15] = ballId; + PlaySE(SE_BOWA2); + + return taskId; +} + +void sub_80F0674(void) +{ + if (gMain.inBattle) + gBattleSpritesDataPtr->animationData->field_A++; +} + +static void PokeBallOpenParticleAnimation(u8 taskId) +{ + u8 spriteId; + u8 x, y; + u8 priority, subpriority; + u8 ballId; + u8 var0; + + ballId = gTasks[taskId].data[15]; + if (gTasks[taskId].data[0] < 16) + { + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = PokeBallOpenParticleAnimation_Step1; + gSprites[spriteId].oam.priority = priority; + + var0 = (u8)gTasks[taskId].data[0]; + if (var0 >= 8) + var0 -= 8; + + gSprites[spriteId].data[0] = var0 * 32; + } + + if (gTasks[taskId].data[0] == 15) + { + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); + return; + } + } + + gTasks[taskId].data[0]++; +} + +static void PokeBallOpenParticleAnimation_Step1(struct Sprite *sprite) +{ + if (sprite->data[1] == 0) + sprite->callback = PokeBallOpenParticleAnimation_Step2; + else + sprite->data[1]--; +} + +static void PokeBallOpenParticleAnimation_Step2(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], sprite->data[1]); + sprite->data[1] += 2; + if (sprite->data[1] == 50) + DestroyBallOpenAnimationParticle(sprite); +} + +static void TimerBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 10; + gSprites[spriteId].data[5] = 2; + gSprites[spriteId].data[6] = 1; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +static void DiveBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 10; + gSprites[spriteId].data[5] = 1; + gSprites[spriteId].data[6] = 2; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +// Also used for Net Ball +static void SafariBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 4; + gSprites[spriteId].data[5] = 1; + gSprites[spriteId].data[6] = 1; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +// Also used for Nest Ball +static void UltraBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 10; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 25; + gSprites[spriteId].data[4] = 5; + gSprites[spriteId].data[5] = 1; + gSprites[spriteId].data[6] = 1; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +// Also used for Luxury Ball +static void GreatBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + if (gTasks[taskId].data[7]) + { + gTasks[taskId].data[7]--; + } + else + { + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 8; + gSprites[spriteId].data[5] = 2; + gSprites[spriteId].data[6] = 2; + } + } + + gTasks[taskId].data[7] = 8; + if (++gTasks[taskId].data[0] == 2) + { + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); + } + } +} + +static void FanOutBallOpenParticles_Step1(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], sprite->data[2]); + sprite->data[0] = (sprite->data[0] + sprite->data[4]) & 0xFF; + sprite->data[1] += sprite->data[5]; + sprite->data[2] += sprite->data[6]; + if (++sprite->data[3] == 51) + DestroyBallOpenAnimationParticle(sprite); +} + +static void RepeatBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < POKEBALL_COUNT; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = RepeatBallOpenParticleAnimation_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 21; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +static void RepeatBallOpenParticleAnimation_Step1(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], Sin(sprite->data[0], sprite->data[2])); + sprite->data[0] = (sprite->data[0] + 6) & 0xFF; + sprite->data[1]++; + sprite->data[2]++; + if (++sprite->data[3] == 51) + DestroyBallOpenAnimationParticle(sprite); +} + +static void MasterBallOpenParticleAnimation(u8 taskId) +{ + u8 i, j; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (j = 0; j < 2; j++) + { + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 8; + + if (j == 0) + { + gSprites[spriteId].data[5] = 2; + gSprites[spriteId].data[6] = 1; + } + else + { + gSprites[spriteId].data[5] = 1; + gSprites[spriteId].data[6] = 2; + } + } + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +static void PremierBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = PremierBallOpenParticleAnimation_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +static void PremierBallOpenParticleAnimation_Step1(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], Sin(sprite->data[0] & 0x3F, sprite->data[2])); + sprite->data[0] = (sprite->data[0] + 10) & 0xFF; + sprite->data[1]++; + sprite->data[2]++; + if (++sprite->data[3] == 51) + DestroyBallOpenAnimationParticle(sprite); +} + +static void DestroyBallOpenAnimationParticle(struct Sprite *sprite) +{ + int i, j; + + if (!gMain.inBattle) + { + if (sprite->data[7] == 1) + DestroySpriteAndFreeResources(sprite); + else + DestroySprite(sprite); + } + else + { + gBattleSpritesDataPtr->animationData->field_A--; + if (gBattleSpritesDataPtr->animationData->field_A == 0) + { + for (i = 0; i < POKEBALL_COUNT; i++) + { + if (FuncIsActiveTask(gBallParticleAnimationFuncs[i]) == TRUE) + break; + } + + if (i == POKEBALL_COUNT) + { + for (j = 0; j < POKEBALL_COUNT; j++) + { + FreeSpriteTilesByTag(gBallParticleSpritesheets[j].tag); + FreeSpritePaletteByTag(gBallParticlePalettes[j].tag); + } + } + + DestroySprite(sprite); + } + else + { + DestroySprite(sprite); + } + } +} + +u8 LaunchBallFadeMonTask(u8 unfadeLater, u8 battler, u32 selectedPalettes, u8 ballId) +{ + u8 taskId; + + taskId = CreateTask(sub_80F12E0, 5); + gTasks[taskId].data[15] = ballId; + gTasks[taskId].data[3] = battler; + gTasks[taskId].data[10] = selectedPalettes; + gTasks[taskId].data[11] = selectedPalettes >> 16; + + if (!unfadeLater) + { + BlendPalette(battler * 16 + 0x100, 16, 0, gBallOpenFadeColors[ballId]); + gTasks[taskId].data[1] = 1; + } + else + { + BlendPalette(battler * 16 + 0x100, 16, 16, gBallOpenFadeColors[ballId]); + gTasks[taskId].data[0] = 16; + gTasks[taskId].data[1] = -1; + gTasks[taskId].func = sub_80F1370; + } + + BeginNormalPaletteFade(selectedPalettes, 0, 0, 16, RGB(31, 31, 31)); + return taskId; +} + +static void sub_80F12E0(u8 taskId) +{ + u8 ballId = gTasks[taskId].data[15]; + + if (gTasks[taskId].data[2] <= 16) + { + BlendPalette(gTasks[taskId].data[3] * 16 + 0x100, 16, gTasks[taskId].data[0], gBallOpenFadeColors[ballId]); + gTasks[taskId].data[0] += gTasks[taskId].data[1]; + gTasks[taskId].data[2]++; + } + else if (!gPaletteFade.active) + { + u32 selectedPalettes = (u16)gTasks[taskId].data[10] | ((u16)gTasks[taskId].data[11] << 16); + BeginNormalPaletteFade(selectedPalettes, 0, 16, 0, RGB(31, 31, 31)); + DestroyTask(taskId); + } +} + +static void sub_80F1370(u8 taskId) +{ + if (!gPaletteFade.active) + { + u32 selectedPalettes = (u16)gTasks[taskId].data[10] | ((u16)gTasks[taskId].data[11] << 16); + BeginNormalPaletteFade(selectedPalettes, 0, 16, 0, RGB(31, 31, 31)); + gTasks[taskId].func = sub_80F13C0; + } +} + +static void sub_80F13C0(u8 taskId) +{ + u8 ballId = gTasks[taskId].data[15]; + + if (gTasks[taskId].data[2] <= 16) + { + BlendPalette(gTasks[taskId].data[3] * 16 + 0x100, 16, gTasks[taskId].data[0], gBallOpenFadeColors[ballId]); + gTasks[taskId].data[0] += gTasks[taskId].data[1]; + gTasks[taskId].data[2]++; + } + else + { + DestroyTask(taskId); + } +} + +void sub_80F1420(u8 taskId) +{ + u8 spriteId; + u32 x; + u32 done = FALSE; + + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + switch (gTasks[taskId].data[10]) + { + case 0: + gTasks[taskId].data[11] = gBattleAnimArgs[0]; + gTasks[taskId].data[0] += 0x500; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gSprites[spriteId].pos2.x += gTasks[taskId].data[0] >> 8; + else + gSprites[spriteId].pos2.x -= gTasks[taskId].data[0] >> 8; + + gTasks[taskId].data[0] &= 0xFF; + x = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x + 32; + if (x > 304) + gTasks[taskId].data[10]++; + break; + case 1: + LoadBattleMonGfxAndAnimate(gBattleAnimAttacker, gTasks[taskId].data[11], spriteId); + gTasks[taskId].data[10]++; + break; + case 2: + gTasks[taskId].data[0] += 0x500; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gSprites[spriteId].pos2.x -= gTasks[taskId].data[0] >> 8; + else + gSprites[spriteId].pos2.x += gTasks[taskId].data[0] >> 8; + + gTasks[taskId].data[0] &= 0xFF; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + if (gSprites[spriteId].pos2.x <= 0) + { + gSprites[spriteId].pos2.x = 0; + done = TRUE; + } + } + else + { + if (gSprites[spriteId].pos2.x >= 0) + { + gSprites[spriteId].pos2.x = 0; + done = TRUE; + } + } + + if (done) + DestroyAnimVisualTask(taskId); + + break; + } +} + +void sub_80F15C8(u8 taskId) +{ + u8 spriteId; + + switch (gTasks[taskId].data[15]) + { + case 0: + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == B_POSITION_OPPONENT_LEFT) + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + else + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16, 0)); + gTasks[taskId].data[15]++; + break; + case 1: + if (gTasks[taskId].data[1]++ > 1) + { + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[0]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - gTasks[taskId].data[0], gTasks[taskId].data[0])); + if (gTasks[taskId].data[0] == 16) + gTasks[taskId].data[15]++; + } + break; + case 2: + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + RequestDma3Fill(0, (void *)OBJ_VRAM0 + gSprites[spriteId].oam.tileNum * TILE_SIZE_4BPP, 0x800, 1); + ClearBehindSubstituteBit(gBattleAnimAttacker); + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimTask_IsAttackerBehindSubstitute(u8 taskId) +{ + gBattleAnimArgs[ARG_RET_ID] = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].behindSubstitute; + DestroyAnimVisualTask(taskId); +} + +void AnimTask_TargetToEffectBattler(u8 taskId) +{ + gBattleAnimTarget = gEffectBattler; + DestroyAnimVisualTask(taskId); +} + +void sub_80F1720(u8 battler, struct Pokemon *mon) +{ + int isShiny; + u32 otId, personality; + u32 shinyValue; + u8 taskId1, taskId2; + + isShiny = 0; + gBattleSpritesDataPtr->healthBoxesData[battler].flag_x80 = 1; + otId = GetMonData(mon, MON_DATA_OT_ID); + personality = GetMonData(mon, MON_DATA_PERSONALITY); + + if (IsBattlerSpriteVisible(battler)) + { + shinyValue = HIHALF(otId) ^ LOHALF(otId) ^ HIHALF(personality) ^ LOHALF(personality); + if (shinyValue < SHINY_ODDS) + isShiny = TRUE; + + if (isShiny) + { + if (GetSpriteTileStartByTag(ANIM_TAG_GOLD_STARS) == 0xFFFF) + { + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[ANIM_TAG_GOLD_STARS - ANIM_SPRITES_START]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[ANIM_TAG_GOLD_STARS - ANIM_SPRITES_START]); + } + + taskId1 = CreateTask(sub_80F181C, 10); + taskId2 = CreateTask(sub_80F181C, 10); + gTasks[taskId1].data[0] = battler; + gTasks[taskId2].data[0] = battler; + gTasks[taskId1].data[1] = 0; + gTasks[taskId2].data[1] = 1; + return; + } + } + + gBattleSpritesDataPtr->healthBoxesData[battler].field_1_x1 = 1; +} + +static void sub_80F181C(u8 taskId) +{ + u8 battler; + u8 x, y; + u8 spriteId; + u16 counter; + s16 state; + u8 pan; + + if (gTasks[taskId].data[13] < 60) + { + gTasks[taskId].data[13]++; + return; + } + + if (gBattleSpritesDataPtr->animationData->field_A) + return; + + counter = gTasks[taskId].data[10]++; + if (counter & 3) + return; + + battler = gTasks[taskId].data[0]; + x = GetBattlerSpriteCoord(battler, 0); + y = GetBattlerSpriteCoord(battler, 1); + state = gTasks[taskId].data[11]; + if (state == 0) + { + spriteId = CreateSprite(&gWishStarSpriteTemplate, x, y, 5); + } + else if (state >= 0 && gTasks[taskId].data[11] < 4) + { + spriteId = CreateSprite(&gMiniTwinklingStarSpriteTemplate, x, y, 5); + gSprites[spriteId].oam.tileNum += 4; + } + else + { + spriteId = CreateSprite(&gMiniTwinklingStarSpriteTemplate, x, y, 5); + gSprites[spriteId].oam.tileNum += 5; + } + + if (gTasks[taskId].data[1] == 0) + { + gSprites[spriteId].callback = sub_80F1A2C; + } + else + { + gSprites[spriteId].callback = sub_80F1A80; + gSprites[spriteId].pos2.x = -32; + gSprites[spriteId].pos2.y = 32; + gSprites[spriteId].invisible = 1; + if (gTasks[taskId].data[11] == 0) + { + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + pan = -64; + else + pan = 63; + + PlaySE12WithPanning(SE_REAPOKE, pan); + } + } + + gSprites[spriteId].data[0] = taskId; + gTasks[taskId].data[11]++; + if (spriteId != MAX_SPRITES) + gTasks[taskId].data[12]++; + + if (gTasks[taskId].data[11] == 5) + gTasks[taskId].func = sub_80F19E0; +} + +static void sub_80F19E0(u8 taskId) +{ + u8 battler; + + if (gTasks[taskId].data[12] == 0) + { + if (gTasks[taskId].data[1] == 1) + { + battler = gTasks[taskId].data[0]; + gBattleSpritesDataPtr->healthBoxesData[battler].field_1_x1 = 1; + } + + DestroyTask(taskId); + } +} + +static void sub_80F1A2C(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[1], 24); + sprite->pos2.y = Cos(sprite->data[1], 24); + sprite->data[1] += 12; + if (sprite->data[1] > 0xFF) + { + gTasks[sprite->data[0]].data[12]--; + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); + } +} + +static void sub_80F1A80(struct Sprite *sprite) +{ + if (sprite->data[1] < 4) + { + sprite->data[1]++; + } + else + { + sprite->invisible = 0; + sprite->pos2.x += 5; + sprite->pos2.y -= 5; + if (sprite->pos2.x > 32) + { + gTasks[sprite->data[0]].data[12]--; + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); + } + } +} + +void AnimTask_LoadPokeblockGfx(u8 taskId) +{ + u8 paletteIndex; + + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[ANIM_TAG_POKEBLOCK - ANIM_SPRITES_START]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[ANIM_TAG_POKEBLOCK - ANIM_SPRITES_START]); + paletteIndex = IndexOfSpritePaletteTag(ANIM_TAG_POKEBLOCK); // unused + DestroyAnimVisualTask(taskId); +} + +void AnimTask_FreePokeblockGfx(u8 taskId) +{ + FreeSpriteTilesByTag(ANIM_TAG_POKEBLOCK); + FreeSpritePaletteByTag(ANIM_TAG_POKEBLOCK); + DestroyAnimVisualTask(taskId); +} + +static void sub_80F1B3C(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, 0); + sprite->data[0] = 30; + sprite->data[2] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), 0) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), 1) + gBattleAnimArgs[3]; + sprite->data[5] = -32; + InitAnimArcTranslation(sprite); + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].callback = sub_8039E84; + sprite->callback = sub_80F1BCC; +} + +static void sub_80F1BCC(struct Sprite *sprite) +{ + if (gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].animCmdIndex == 1) + sprite->callback = sub_80F1C04; +} + +static void sub_80F1C04(struct Sprite *sprite) +{ + if (TranslateAnimHorizontalArc(sprite)) //TranslateAnimArc? + { + sprite->data[0] = 0; + sprite->invisible = 1; + sprite->callback = sub_80F1C30; + } +} + +static void sub_80F1C30(struct Sprite *sprite) +{ + if (gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].animEnded) + { + if (++sprite->data[0] > 0) + { + StartSpriteAnim(&gSprites[gBattlerSpriteIds[gBattleAnimAttacker]], 0); + DestroyAnimSprite(sprite); + } + } +} + +void sub_80F1C8C(u8 taskId) +{ + switch (gBattleAnimArgs[0]) + { + case 0: + gBattleAnimAttacker = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + gBattleAnimTarget = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + break; + case 1: + gBattleAnimAttacker = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + gBattleAnimTarget = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + break; + } + + DestroyAnimVisualTask(taskId); +} + +void sub_80F1C8C(u8 taskId) +{ + // to do +} + +// 080F1D14 +void AnimTask_GetTrappedMoveAnimId(u8 taskId) +{ + if (gBattleSpritesDataPtr->animationData->animArg == MOVE_FIRE_SPIN) + gBattleAnimArgs[0] = TRAP_ANIM_FIRE_SPIN; + else if (gBattleSpritesDataPtr->animationData->animArg == MOVE_WHIRLPOOL) + gBattleAnimArgs[0] = TRAP_ANIM_WHIRLPOOL; + else if (gBattleSpritesDataPtr->animationData->animArg == MOVE_CLAMP) + gBattleAnimArgs[0] = TRAP_ANIM_CLAMP; + else if (gBattleSpritesDataPtr->animationData->animArg == MOVE_SAND_TOMB) + gBattleAnimArgs[0] = TRAP_ANIM_SAND_TOMB; + else + gBattleAnimArgs[0] = TRAP_ANIM_BIND; + + DestroyAnimVisualTask(taskId); +} + +void AnimTask_GetBattlersFromArg(u8 taskId) +{ + gBattleAnimAttacker = gBattleSpritesDataPtr->animationData->animArg; + gBattleAnimTarget = gBattleSpritesDataPtr->animationData->animArg >> 8; + DestroyAnimVisualTask(taskId); +} -- cgit v1.2.3 From 1f51c4ce846e54b8d4f491084954a010a217182c Mon Sep 17 00:00:00 2001 From: Evan Date: Mon, 2 Dec 2019 17:58:49 -0700 Subject: battle_anim_status_effects --- src/battle_anim_effects_3.c | 1 - src/battle_anim_status_effects.c | 538 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 538 insertions(+), 1 deletion(-) create mode 100644 src/battle_anim_status_effects.c (limited to 'src') diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 4fd6ada0b..426d39056 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -1182,7 +1182,6 @@ const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = //83FF7A8 }; // Functions - // 80DE2C0 void AnimBlackSmoke(struct Sprite *sprite) { diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c new file mode 100644 index 000000000..582dd20a5 --- /dev/null +++ b/src/battle_anim_status_effects.c @@ -0,0 +1,538 @@ +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "decompress.h" +#include "gpu_regs.h" +#include "palette.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" +#include "util.h" +#include "constants/battle_anim.h" +#include "constants/rgb.h" + +// Function Declarations +static u8 sub_8078178(u8 battlerId, bool8 b); +static void sub_80782BC(u8 taskId); +static void sub_80784D8(u8 taskId); +static void sub_8078528(u8 taskId); +static void sub_80785D8(u8 taskId); +static void sub_807862C(u8 taskId); +static void Task_DoStatusAnimation(u8 taskId); +static void sub_807834C(struct Sprite *sprite); +static void sub_8078380(struct Sprite *sprite); + +// Data +extern const struct CompressedSpriteSheet gBattleAnimPicTable[]; +extern const struct CompressedSpritePalette gBattleAnimPaletteTable[]; +extern const u8 *const gBattleAnims_StatusConditions[]; +extern const struct OamData gOamData_AffineOff_ObjNormal_8x8; +extern const struct OamData gOamData_AffineOff_ObjBlend_64x64; + +static const union AnimCmd gUnknown_83BF3E0[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(4, 3), + ANIMCMD_FRAME(8, 3), + ANIMCMD_FRAME(12, 3), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const gSpriteAnimTable_83BF3F4[] = +{ + gUnknown_83BF3E0 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF3F8 = +{ + .tileTag = ANIM_TAG_ORB, + .paletteTag = ANIM_TAG_ORB, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gSpriteAnimTable_83BF3F4, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8AEC, +}; + +const struct SpriteTemplate gSpriteTemplate_83BF410 = +{ + .tileTag = ANIM_TAG_ORB, + .paletteTag = ANIM_TAG_ORB, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gSpriteAnimTable_83BF3F4, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8A6C, +}; + +static const union AnimCmd gUnknown_83BF428[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const gSpriteAnimTable_83BF430[] = +{ + gUnknown_83BF428 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF434 = +{ + .tileTag = ANIM_TAG_WEATHER_BALL, + .paletteTag = ANIM_TAG_WEATHER_BALL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAnimTable_83BF430, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8E30, +}; + +const struct SpriteTemplate gSpriteTemplate_83BF44C = +{ + .tileTag = ANIM_TAG_WEATHER_BALL, + .paletteTag = ANIM_TAG_WEATHER_BALL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAnimTable_83BF430, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8EE4, +}; + +static const union AnimCmd gUnknown_83BF464[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(64, 3), + ANIMCMD_END +}; + +static const union AnimCmd *const gSpriteAnimTable_83BF47C[] = +{ + gUnknown_83BF464 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF480 = +{ + .tileTag = ANIM_TAG_SPARKLE_4, + .paletteTag = ANIM_TAG_SPARKLE_4, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAnimTable_83BF47C, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8B64, +}; + +const struct SpriteTemplate gSpriteTemplate_83BF498 = +{ + .tileTag = ANIM_TAG_MONSTER_FOOT, + .paletteTag = ANIM_TAG_MONSTER_FOOT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8AEC, +}; + +static const union AnimCmd gUnknown_83BF4B0[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd gUnknown_83BF4B8[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd gUnknown_83BF4C0[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const gSpriteAniimTable_83BF4C8[] = +{ + gUnknown_83BF4B0, + gUnknown_83BF4B8, + gUnknown_83BF4C0 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF4D4 = +{ + .tileTag = ANIM_TAG_IMPACT, + .paletteTag = ANIM_TAG_IMPACT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAniimTable_83BF4C8, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8AEC, +}; + +static const union AnimCmd gUnknown_83BF4EC[] = +{ + ANIMCMD_FRAME(0, 15), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const gSpriteAnimTable_83BF4F4[] = +{ + gUnknown_83BF4EC +}; + +static const union AffineAnimCmd gUnknown_83BF4F8[] = +{ + AFFINEANIMCMD_FRAME(96, 96, 0, 0), + AFFINEANIMCMD_FRAME(2, 2, 0, 1), + AFFINEANIMCMD_JUMP(1) +}; + +static const union AffineAnimCmd *const gSpriteAffineAnimTable_83BF510[] = +{ + gUnknown_83BF4F8 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF514 = +{ + .tileTag = ANIM_TAG_ORB, + .paletteTag = ANIM_TAG_ORB, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gSpriteAnimTable_83BF4F4, + .images = NULL, + .affineAnims = gSpriteAffineAnimTable_83BF510, + .callback = sub_80A8A6C, +}; + +static const u32 gUnknown_83BF52C = _("TASK OVER\nタスクがオーバーしました$"); + +static const struct Subsprite gSubsprites_83BF544[] = +{ + {.x = -16, .y = -16, .shape = ST_OAM_SQUARE, .size = 3, .tileOffset = 0, .priority = 2}, + {.x = -16, .y = 48, .shape = ST_OAM_H_RECTANGLE, .size = 3, .tileOffset = 64, .priority = 2}, + {.x = 48, .y = -16, .shape = ST_OAM_V_RECTANGLE, .size = 3, .tileOffset = 96, .priority = 2}, + {.x = 48, .y = 48, .shape = ST_OAM_SQUARE, .size = 2, .tileOffset = 128, .priority = 2}, +}; + +static const struct SubspriteTable gUnknown_83BF554[] = +{ + {ARRAY_COUNT(gSubsprites_83BF544), gSubsprites_83BF544}, +}; + +static const struct SpriteTemplate gUnknown_83BF55C = +{ + .tileTag = ANIM_TAG_ICE_CUBE, + .paletteTag = ANIM_TAG_ICE_CUBE, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +static const struct SpriteTemplate gUnknown_83BF574 = +{ + .tileTag = ANIM_TAG_CIRCLE_IMPACT, + .paletteTag = ANIM_TAG_CIRCLE_IMPACT, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_807834C, +}; + +// Functions +static u8 sub_8078178(u8 battlerId, bool8 b) +{ + u8 battlerSpriteId = gBattlerSpriteIds[battlerId]; + u8 taskId = CreateTask(sub_80782BC, 10); + u8 spriteId2; + u8 i; + + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(ANIM_TAG_CIRCLE_IMPACT)]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(ANIM_TAG_CIRCLE_IMPACT)]); + gTasks[taskId].data[0] = battlerId; + if (b) + { + gTasks[taskId].data[1] = RGB_RED; + for (i = 0; i < 10; i++) + { + spriteId2 = CreateSprite(&gUnknown_83BF574, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y + 32, 0); + gSprites[spriteId2].data[0] = i * 51; + gSprites[spriteId2].data[1] = -256; + gSprites[spriteId2].invisible = TRUE; + if (i > 4) + gSprites[spriteId2].data[6] = 21; + } + } + else + { + gTasks[taskId].data[1] = RGB_BLUE; + for (i = 0; i < 10; i++) + { + spriteId2 = CreateSprite(&gUnknown_83BF574, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y - 32, 0); + gSprites[spriteId2].data[0] = i * 51; + gSprites[spriteId2].data[1] = 256; + gSprites[spriteId2].invisible = TRUE; + if (i > 4) + gSprites[spriteId2].data[6] = 21; + } + } + gSprites[spriteId2].data[7] = 1; + return taskId; +} + +// Functions +static void sub_80782BC(u8 taskId) +{ + if (gTasks[taskId].data[2] == 2) + { + gTasks[taskId].data[2] = 0; + BlendPalette(0x100 + gTasks[taskId].data[0] * 16, 16, gTasks[taskId].data[4], gTasks[taskId].data[1]); + if (gTasks[taskId].data[5] == 0) + { + gTasks[taskId].data[4]++; + if (gTasks[taskId].data[4] > 8) + gTasks[taskId].data[5] ^= 1; + } + else + { + u16 var = gTasks[taskId].data[4]; + + gTasks[taskId].data[4]--; + if (gTasks[taskId].data[4] < 0) + { + gTasks[taskId].data[4] = var; + gTasks[taskId].data[5] ^= 1; + gTasks[taskId].data[3]++; + if (gTasks[taskId].data[3] == 2) + DestroyTask(taskId); + } + } + } + else + { + gTasks[taskId].data[2]++; + } +} + +static void sub_807834C(struct Sprite *sprite) +{ + if (sprite->data[6] == 0) + { + sprite->invisible = FALSE; + sprite->callback = sub_8078380; + sub_8078380(sprite); + } + else + { + sprite->data[6]--; + } +} + +static void sub_8078380(struct Sprite *sprite) +{ + sprite->pos2.x = Cos(sprite->data[0], 32); + sprite->pos2.y = Sin(sprite->data[0], 8); + if (sprite->data[0] < 128) + sprite->subpriority = 29; + else + sprite->subpriority = 31; + sprite->data[0] = (sprite->data[0] + 8) & 0xFF; + sprite->data[5] += sprite->data[1]; + sprite->pos2.y += sprite->data[5] >> 8; + sprite->data[2]++; + if (sprite->data[2] == 52) + { + if (sprite->data[7]) + DestroySpriteAndFreeResources(sprite); + else + DestroySprite(sprite); + } +} + +void sub_80783FC(u8 taskId) +{ + s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) - 32; + s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) - 36; + u8 spriteId; + + if (IsContest()) + x -= 6; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + spriteId = CreateSprite(&gUnknown_83BF55C, x, y, 4); + if (GetSpriteTileStartByTag(ANIM_TAG_ICE_CUBE) == 0xFFFF) + gSprites[spriteId].invisible = TRUE; + SetSubspriteTables(&gSprites[spriteId], gUnknown_83BF554); + gTasks[taskId].data[15] = spriteId; + gTasks[taskId].func = sub_80784D8; +} + +static void sub_80784D8(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] == 10) + { + gTasks[taskId].func = sub_8078528; + gTasks[taskId].data[1] = 0; + } + else + { + u8 var = gTasks[taskId].data[1]; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(var, 16 - var)); + } +} + +static void sub_8078528(u8 taskId) +{ + u8 palIndex = IndexOfSpritePaletteTag(ANIM_TAG_ICE_CUBE); + + if (gTasks[taskId].data[1]++ > 13) + { + gTasks[taskId].data[2]++; + if (gTasks[taskId].data[2] == 3) + { + u16 temp; + + temp = gPlttBufferFaded[0x100 + palIndex * 16 + 13]; + gPlttBufferFaded[0x100 + palIndex * 16 + 13] = gPlttBufferFaded[0x100 + palIndex * 16 + 14]; + gPlttBufferFaded[0x100 + palIndex * 16 + 14] = gPlttBufferFaded[0x100 + palIndex * 16 + 15]; + gPlttBufferFaded[0x100 + palIndex * 16 + 15] = temp; + + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[3]++; + if (gTasks[taskId].data[3] == 3) + { + gTasks[taskId].data[3] = 0; + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[4]++; + if (gTasks[taskId].data[4] == 2) + { + gTasks[taskId].data[1] = 9; + gTasks[taskId].func = sub_80785D8; + } + } + } + } +} + +static void sub_80785D8(u8 taskId) +{ + gTasks[taskId].data[1]--; + if (gTasks[taskId].data[1] == -1) + { + gTasks[taskId].func = sub_807862C; + gTasks[taskId].data[1] = 0; + } + else + { + u8 var = gTasks[taskId].data[1]; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(var, 16 - var)); + } +} + +static void sub_807862C(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] == 37) + { + u8 spriteId = gTasks[taskId].data[15]; + + FreeSpriteOamMatrix(&gSprites[spriteId]); + DestroySprite(&gSprites[spriteId]); + } + else if (gTasks[taskId].data[1] == 39) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimVisualTask(taskId); + } +} + +#define CASE(by, stat) case (STAT_ANIM_##by + stat - 1) + +void AnimTask_StatsChange(u8 taskId) +{ + bool16 goesDown = FALSE; + s16 animStatId = 0; + bool16 sharply = FALSE; + + switch (gBattleSpritesDataPtr->animationData->animArg) + { + CASE(PLUS1, STAT_ATK): goesDown = FALSE; animStatId = 0; break; + CASE(PLUS1, STAT_DEF): goesDown = FALSE; animStatId = 1; break; + CASE(PLUS1, STAT_SPEED): goesDown = FALSE; animStatId = 3; break; + CASE(PLUS1, STAT_SPATK): goesDown = FALSE; animStatId = 5; break; + CASE(PLUS1, STAT_SPDEF): goesDown = FALSE; animStatId = 6; break; + CASE(PLUS1, STAT_ACC): goesDown = FALSE; animStatId = 2; break; + CASE(PLUS1, STAT_EVASION): goesDown = FALSE; animStatId = 4; break; + + CASE(MINUS1, STAT_ATK): goesDown = TRUE; animStatId = 0; break; + CASE(MINUS1, STAT_DEF): goesDown = TRUE; animStatId = 1; break; + CASE(MINUS1, STAT_SPEED): goesDown = TRUE; animStatId = 3; break; + CASE(MINUS1, STAT_SPATK): goesDown = TRUE; animStatId = 5; break; + CASE(MINUS1, STAT_SPDEF): goesDown = TRUE; animStatId = 6; break; + CASE(MINUS1, STAT_ACC): goesDown = TRUE; animStatId = 2; break; + CASE(MINUS1, STAT_EVASION): goesDown = TRUE; animStatId = 4; break; + + CASE(PLUS2, STAT_ATK): goesDown = FALSE; animStatId = 0; sharply = TRUE; break; + CASE(PLUS2, STAT_DEF): goesDown = FALSE; animStatId = 1; sharply = TRUE; break; + CASE(PLUS2, STAT_SPEED): goesDown = FALSE; animStatId = 3; sharply = TRUE; break; + CASE(PLUS2, STAT_SPATK): goesDown = FALSE; animStatId = 5; sharply = TRUE; break; + CASE(PLUS2, STAT_SPDEF): goesDown = FALSE; animStatId = 6; sharply = TRUE; break; + CASE(PLUS2, STAT_ACC): goesDown = FALSE; animStatId = 2; sharply = TRUE; break; + CASE(PLUS2, STAT_EVASION): goesDown = FALSE; animStatId = 4; sharply = TRUE; break; + + CASE(MINUS2, STAT_ATK): goesDown = TRUE; animStatId = 0; sharply = TRUE; break; + CASE(MINUS2, STAT_DEF): goesDown = TRUE; animStatId = 1; sharply = TRUE; break; + CASE(MINUS2, STAT_SPEED): goesDown = TRUE; animStatId = 3; sharply = TRUE; break; + CASE(MINUS2, STAT_SPATK): goesDown = TRUE; animStatId = 5; sharply = TRUE; break; + CASE(MINUS2, STAT_SPDEF): goesDown = TRUE; animStatId = 6; sharply = TRUE; break; + CASE(MINUS2, STAT_ACC): goesDown = TRUE; animStatId = 2; sharply = TRUE; break; + CASE(MINUS2, STAT_EVASION): goesDown = TRUE; animStatId = 4; sharply = TRUE; break; + + case STAT_ANIM_MULTIPLE_PLUS1: goesDown = FALSE; animStatId = 0xFF; sharply = FALSE; break; + case STAT_ANIM_MULTIPLE_PLUS2: goesDown = FALSE; animStatId = 0xFF; sharply = TRUE; break; + case STAT_ANIM_MULTIPLE_MINUS1: goesDown = TRUE; animStatId = 0xFF; sharply = FALSE; break; + case STAT_ANIM_MULTIPLE_MINUS2: goesDown = TRUE; animStatId = 0xFF; sharply = TRUE; break; + + default: + DestroyAnimVisualTask(taskId); + return; + } + + gBattleAnimArgs[0] = goesDown; + gBattleAnimArgs[1] = animStatId; + gBattleAnimArgs[2] = 0; + gBattleAnimArgs[3] = 0; + gBattleAnimArgs[4] = sharply; + gTasks[taskId].func = sub_8116EB4; + sub_8116EB4(taskId); +} + +#undef CASE + +void LaunchStatusAnimation(u8 battlerId, u8 statusAnimId) +{ + u8 taskId; + + gBattleAnimAttacker = battlerId; + gBattleAnimTarget = battlerId; + LaunchBattleAnimation(gBattleAnims_StatusConditions, statusAnimId, 0); + taskId = CreateTask(Task_DoStatusAnimation, 10); + gTasks[taskId].data[0] = battlerId; +} + +static void Task_DoStatusAnimation(u8 taskId) +{ + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + gBattleSpritesDataPtr->healthBoxesData[gTasks[taskId].data[0]].statusAnimActive = FALSE; + DestroyTask(taskId); + } +} -- cgit v1.2.3 From f2eb137154f1afe98ed86f883662a01ba318efa6 Mon Sep 17 00:00:00 2001 From: Evan Date: Mon, 2 Dec 2019 20:58:12 -0700 Subject: resolve compiler errors --- src/battle_anim_effects_1.c | 7 +- src/battle_anim_effects_2.c | 5 +- src/battle_anim_effects_3.c | 261 +++++++++++++-------------------------- src/battle_anim_special.c | 69 +++++++---- src/battle_anim_status_effects.c | 25 ++-- 5 files changed, 154 insertions(+), 213 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 9d820b628..ff0927f88 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -13,7 +13,6 @@ #include "sound.h" #include "trig.h" #include "util.h" -#include "constants/rgb.h" #include "constants/songs.h" // RAM @@ -4373,7 +4372,7 @@ static void AnimLockOnTargetStep4(struct Sprite* sprite) sprite->data[1] = 0; } - BlendPalettes(sub_80A75AC(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB(31, 31, 31)); + BlendPalettes(sub_8075BE8(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB(31, 31, 31)); if (sprite->data[1] == 16) { int pal; @@ -5029,7 +5028,7 @@ void AnimTask_FadeScreenBlueStep(u8); void AnimTask_FadeScreenBlue(u8 taskId) { - int a = sub_80A75AC(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; + int a = sub_8075BE8(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; int b; int c; int d; @@ -5044,7 +5043,7 @@ void AnimTask_FadeScreenBlue(u8 taskId) gTasks[taskId].data[7] = 13; gTasks[taskId].data[8] = 14; gTasks[taskId].data[9] = 15; - b = sub_80A76C4(1, 1, 1, 1); + b = sub_8075CB8(1, 1, 1, 1); c = a | b; StorePointerInVars(&gTasks[taskId].data[14], &gTasks[taskId].data[15], (void*)c); b = b | (0x10000 << IndexOfSpritePaletteTag(ANIM_TAG_MOON)); diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 32ed2fba9..cea915921 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -13,7 +13,6 @@ #include "sound.h" #include "trig.h" #include "util.h" -#include "constants/rgb.h" #include "constants/songs.h" void sub_80A6E48(struct Sprite *); @@ -344,7 +343,7 @@ const struct SpriteTemplate gWaterPulseRingSpriteTemplate = //gUnknown_83E3CE8 .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gWaterPulseRingAffineAnimTable, - .callback = AnimWaterPulseRing, + .callback = sub_80AC6D8, }; const struct SpriteTemplate gEggThrowSpriteTemplate = //gUnknown_83E3D00 @@ -3096,7 +3095,7 @@ static void FakeOutStep2(u8 taskId) { gTasks[taskId].data[11] = 0x88; SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_LIGHTEN); - BlendPalettes(sub_80A75AC(1, 0, 0, 0, 0, 0, 0), 16, RGB(31, 31, 31)); + BlendPalettes(sub_8075BE8(1, 0, 0, 0, 0, 0, 0), 16, RGB(31, 31, 31)); } else if (gTasks[taskId].data[10] > 4) { diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 426d39056..ab8b3f20a 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -3,7 +3,6 @@ #include "battle.h" #include "battle_anim.h" #include "bg.h" -#include "contest.h" #include "data.h" #include "decompress.h" #include "dma3.h" @@ -19,7 +18,6 @@ #include "trig.h" #include "util.h" #include "constants/battle_anim.h" -#include "constants/rgb.h" #include "constants/songs.h" #include "constants/species.h" #include "constants/weather.h" @@ -122,6 +120,10 @@ static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); // Data +extern const u32 gUnknown_8D2A8C0[]; +extern const u32 gUnknown_8D2A808[]; +extern const u32 gUnknown_8D2A8A8[]; + const union AnimCmd gScratchAnimCmds[] = //83FEDE4 { ANIMCMD_FRAME(0, 4), @@ -468,8 +470,8 @@ const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = //83FF0D4 const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = //83FF0D8 { - .tileTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, - .paletteTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, + .tileTag = ANIM_TAG_TRI_FORCE_TRIANGLE, + .paletteTag = ANIM_TAG_TRI_FORCE_TRIANGLE, .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gTriAttackTriangleAnimTable, .images = NULL, @@ -719,7 +721,7 @@ const struct SpriteTemplate gSweetScentPetalSpriteTemplate = //83FF324 .callback = AnimSweetScentPetal, }; -const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/unknown/unk_83FF33C.gbapal"); //Unused +const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/battle_anims/unk_83FF33C.gbapal"); //Unused const union AnimCmd gPainSplitAnimCmds[] = //83FF35C { @@ -1214,7 +1216,7 @@ static void AnimBlackSmokeStep(struct Sprite *sprite) void AnimTask_SmokescreenImpact(u8 taskId) { - SmokescreenImpact( + SmokescreenImpact( //sub_804A76C GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 8, GetBattlerSpriteCoord(gBattleAnimTarget, 3) + 8, 0); @@ -2288,8 +2290,7 @@ void AnimTask_TransformMon(u8 taskId) break; case 2: HandleSpeciesGfxDataChange(gBattleAnimAttacker, gBattleAnimTarget, gTasks[taskId].data[10]); - sub_80A6BFC(&animBg, gBattleAnimAttacker); - + sub_8075300(&animBg, gBattleAnimAttacker); if (IsContest()) position = 0; else @@ -2297,40 +2298,8 @@ void AnimTask_TransformMon(u8 taskId) src = gMonSpritesGfxPtr->sprites[position] + (gBattleMonForms[gBattleAnimAttacker] << 11); dest = animBg.bgTiles; - CpuCopy32(src, dest, 0x800); + CpuSet(src, dest, 0x4000200); LoadBgTiles(1, animBg.bgTiles, 0x800, animBg.tilesOffset); - if (IsContest()) - { - if (IsSpeciesNotUnown(gContestResources->field_18->species) != IsSpeciesNotUnown(gContestResources->field_18->unk2)) - { - bgTilemap = (u16 *)animBg.bgTilemap; - for (i = 0; i < 8; i++) - { - for (j = 0; j < 4; j++) - { - u16 temp = bgTilemap[j + i * 0x20]; - bgTilemap[j + i * 0x20] = bgTilemap[(7 - j) + i * 0x20]; - bgTilemap[(7 - j) + i * 0x20] = temp; - } - } - - for (i = 0; i < 8; i++) - { - for (j = 0; j < 8; j++) - { - bgTilemap[j + i * 0x20] ^= 0x400; - } - } - } - - if (IsSpeciesNotUnown(gContestResources->field_18->unk2)) - gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].affineAnims = gUnknown_082FF6C0; - else - gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].affineAnims = gUnknown_082FF694; - - StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimAttacker]], 0); - } - gTasks[taskId].data[0]++; break; case 3: @@ -2392,13 +2361,13 @@ void AnimTask_MorningSunLightBeam(u8 taskId) if (!IsContest()) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); - sub_80752A0 - sub_807543C - sub_80753B4 //AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); + sub_80752A0(&animBg); + AnimLoadCompressedBgTilemap(animBg.bgId, gUnknown_8D2A8C0); + AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_8D2A808, animBg.tilesOffset); LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); if (IsContest()) { - sub_80730C0(animBg.paletteId, [sp+4 ???], 0, 0); + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); gBattle_BG1_X = -56; } else @@ -2410,30 +2379,6 @@ void AnimTask_MorningSunLightBeam(u8 taskId) } gBattle_BG1_Y = 0; - - /* - sub_80752A0(&animBg); - sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); - - if (IsContest()) - { - gBattle_BG1_X = -56; - gBattle_BG1_Y = 0; - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) - gBattle_BG1_X = -135; - else - gBattle_BG1_X = -10; - - gBattle_BG1_Y = 0; - } - */ - - - - gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; @@ -2594,21 +2539,16 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); if (!IsContest()) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); - - /* - sub_80752A0(&animBg); - sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); - */ - - sub_80752A0( , - sub_807543C( , gUnknown_8D2A8C0 - sub_80753B4( , gUnknown_8D2A808 - LoadCompressedPalette(gUnknown_8D2A808 - //... + sub_80752A0(&animBg); + AnimLoadCompressedBgTilemap(animBg.bgId, gUnknown_8D2A8C0); + AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_8D2A808, animBg.tilesOffset); + LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); + if (IsContest()) { - gBattle_BG1_X = -56; + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + gBattle_BG1_X = -56; gBattle_BG1_Y = 0; } else @@ -2636,8 +2576,6 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) gBattle_BG1_Y = 0; } - //AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); - //LoadCompressedPalette(gUnknown_08C2A6D4, animBg.paletteId * 16, 32); gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; gTasks[taskId].data[0]++; @@ -3229,62 +3167,51 @@ void AnimTask_RolePlaySilhouette(u8 taskId) s16 coord1, coord2; GetAnimBattlerSpriteId(ANIM_ATTACKER); - if (IsContest()) - { - isBackPic = 1; - personality = gContestResources->field_18->unk10; - otId = gContestResources->field_18->unkC; - species = gContestResources->field_18->unk2; - xOffset = 20; - priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) - { - isBackPic = 0; - personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) - { - if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - else - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - } - else - { - species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; - } - xOffset = 20; - priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); - } - else - { - isBackPic = 1; - personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) - { - if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - else - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - } - else - { - species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; - } + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + isBackPic = 0; + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } - xOffset = -20; - priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); - } - } + xOffset = 20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + else + { + isBackPic = 1; + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } + + xOffset = -20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } coord1 = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); coord2 = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); - spriteId = sub_80A8394(species, isBackPic, 0, coord1 + xOffset, coord2, 5, personality, otId, gBattleAnimTarget, 1); + spriteId = sub_80768D0(species, isBackPic, 0, coord1 + xOffset, coord2, 5, personality, otId, gBattleAnimTarget, 1); gSprites[spriteId].oam.priority = priority; gSprites[spriteId].oam.objMode = ST_OAM_OBJ_BLEND; @@ -5056,46 +4983,34 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) } break; case 1: - if (IsContest()) - { - personality = gContestResources->field_18->unk8; - otId = gContestResources->field_18->unkC; - species = gContestResources->field_18->species; - subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker); - isBackPic = 0; - x = -32; - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - { - personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; - isBackPic = 0; - x = 272; - } - else - { - personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; - isBackPic = 1; - x = -32; - } - } + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; + isBackPic = 0; + x = 272; + } + else + { + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + isBackPic = 1; + x = -32; + } - spriteId2 = sub_80A8394(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); + spriteId2 = sub_80768D0(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) BlendPalette((gSprites[spriteId2].oam.paletteNum * 16) | 0x100, 16, 6, RGB_WHITE); diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index d0d40a6d8..a93913b82 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -1,6 +1,7 @@ #include "global.h" #include "battle.h" #include "battle_anim.h" +#include "battle_main.h" #include "battle_controllers.h" #include "battle_interface.h" #include "decompress.h" @@ -19,7 +20,6 @@ #include "constants/items.h" #include "constants/moves.h" #include "constants/songs.h" -#include "constants/rgb.h" // Defines #define TAG_PARTICLES_POKEBALL 55020 @@ -35,6 +35,9 @@ #define TAG_PARTICLES_LUXURYBALL 55030 #define TAG_PARTICLES_PREMIERBALL 55031 +#define HIHALF(n) (((n) & 0xFFFF0000) >> 16) +#define LOHALF(n) ((n) & 0xFFFF) + // IWRAM EWRAM_DATA int gUnknown_3005424 = 0; EWRAM_DATA u16 gUnknown_3005428 = 0; @@ -66,6 +69,8 @@ static void sub_80F05B4(u8); static void sub_80F0278(struct Sprite *); static void sub_80F0378(struct Sprite *); static void sub_80F04B4(struct Sprite *); +static void sub_80F052C(struct Sprite *sprite); +static void sub_80F0574(struct Sprite *sprite); static void PokeBallOpenParticleAnimation_Step1(struct Sprite *); static void PokeBallOpenParticleAnimation_Step2(struct Sprite *); static void DestroyBallOpenAnimationParticle(struct Sprite *); @@ -94,6 +99,10 @@ static void PremierBallOpenParticleAnimation(u8); static void sub_80F1B3C(struct Sprite *); // Data +extern const u32 gUnknown_8D2EC24[]; +extern const u32 gUnknown_8D2EC70[]; +extern const struct SpriteTemplate gBallSpriteTemplates[]; //for now + struct BallCaptureSuccessStarData { s8 xOffset; @@ -445,9 +454,9 @@ void sub_80EEC0C(u8 taskId) gSprites[spriteId3].callback = SpriteCallbackDummy; gSprites[spriteId4].callback = SpriteCallbackDummy; - sub_80A6B30(&unknownStruct); - AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_08C2EA9C); - AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_08C2EA50, unknownStruct.tilesOffset); + sub_80752A0(&unknownStruct); + AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_8D2EC70); + AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_8D2EC24, unknownStruct.tilesOffset); LoadCompressedPalette(gCureBubblesPal, unknownStruct.paletteId << 4, 32); gBattle_BG1_X = -gSprites[spriteId3].pos1.x + 32; @@ -492,7 +501,7 @@ static void sub_80EEDF4(u8 taskId) SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[12], 16 - gTasks[taskId].data[12])); if (gTasks[taskId].data[12] == 0) { - sub_80A477C(0); + sub_8073128(0); gBattle_WIN0H = 0; gBattle_WIN0V = 0; SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); @@ -518,7 +527,7 @@ static void sub_80EEDF4(u8 taskId) } } -static void sub_80EEFC8(u8 *paletteId1, u8 *paletteId2, u8 battler) +void sub_80EEFC8(u8 *paletteId1, u8 *paletteId2, u8 battler) { u8 healthBoxSpriteId; u8 spriteId1, spriteId2; @@ -547,7 +556,7 @@ void sub_80EF0B4(u8 taskId) DestroyAnimVisualTask(taskId); } -static void sub_80EF0E0(u8 battler) +void sub_80EF0E0(u8 battler) { u8 healthBoxSpriteId; u8 spriteId1, spriteId2; @@ -666,8 +675,8 @@ void sub_80EF344(u8 taskId) y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); priority = gSprites[spriteId].oam.priority; subpriority = gSprites[spriteId].subpriority; - gTasks[taskId].data[10] = AnimateBallOpenParticles(x, y + 32, priority, subpriority, ballId); - selectedPalettes = sub_80A75AC(1, 0, 0, 0, 0, 0, 0); + gTasks[taskId].data[10] = LaunchBallStarsTask(x, y + 32, priority, subpriority, ballId); + selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0); gTasks[taskId].data[11] = LaunchBallFadeMonTask(0, gBattleAnimAttacker, selectedPalettes, ballId); gTasks[taskId].data[0]++; break; @@ -764,25 +773,27 @@ void sub_80EF6D4(u8 taskId) u8 subpriority; u8 spriteId; - if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) + if (gBattleTypeFlags & BATTLE_TYPE_OLD_MAN_TUTORIAL) { - x = 32; + x = 28; y = 11; } else { x = 23; - y = 5; + y = 11; + if (gSaveBlock2Ptr->playerGender == FEMALE) + y = 13; } ballId = ItemIdToBallId(gLastUsedItem); subpriority = GetBattlerSpriteSubpriority(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)) + 1; - spriteId = CreateSprite(&gBallSpriteTemplates[ballId], x + 32, y | 80, subpriority); + spriteId = CreateSprite(&gBallSpriteTemplates[ballId], x | 32, y | 80, subpriority); gSprites[spriteId].data[0] = 34; gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, 0); gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) - 16; gSprites[spriteId].callback = SpriteCallbackDummy; - gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].callback = sub_8039E84; + gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].callback = sub_8012354; gTasks[taskId].data[0] = spriteId; gTasks[taskId].func = sub_80EF7EC; } @@ -853,7 +864,7 @@ static void sub_80EF8F0(struct Sprite *sprite) switch (ballId) { case 0 ... POKEBALL_COUNT - 1: - AnimateBallOpenParticles(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); + LaunchBallStarsTask(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); LaunchBallFadeMonTask(0, gBattleAnimTarget, 14, ballId); break; } @@ -1185,7 +1196,7 @@ static void sub_80EFFC4(struct Sprite *sprite) sprite->data[4]++; if (sprite->data[4] == 40) { - PlaySE(SE_RG_GETTING); + PlaySE(SE_GETTING); BlendPalettes(0x10000 << sprite->oam.paletteNum, 6, RGB(0, 0, 0)); sub_80F01B8(sprite); } @@ -1198,7 +1209,7 @@ static void sub_80EFFC4(struct Sprite *sprite) gDoingBattleAnim = 0; UpdateOamPriorityInAllHealthboxes(1); m4aMPlayAllStop(); - PlaySE(MUS_RG_FAN6); + PlaySE(MUS_FAN6); } else if (sprite->data[4] == 315) { @@ -1315,7 +1326,7 @@ static void sub_80F02B0(struct Sprite *sprite) switch (ballId) { case 0 ... POKEBALL_COUNT - 1: - AnimateBallOpenParticles(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); + LaunchBallStarsTask(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); LaunchBallFadeMonTask(1, gBattleAnimTarget, 14, ballId); break; } @@ -1391,7 +1402,23 @@ static void sub_80F04B4(struct Sprite *sprite) // GhostBallDodge static void sub_80F052C(struct Sprite *sprite) { - // to do + s16 x; + s16 y; + + x = sprite->pos1.x + sprite->pos2.x; + sprite->pos1.x = x; + y = sprite->pos1.y + sprite->pos2.y; + sprite->pos1.y = y; + sprite->pos2.x = sprite->pos2.y = 0; + sprite->data[0] = 0x22; + sprite->data[1] = x; + sprite->data[2] = x - 8; + sprite->data[3] = y; + sprite->data[4] = 0x90; + sprite->data[5] = 0x20; + InitAnimArcTranslation(sprite); + TranslateAnimVerticalArc(sprite); + sprite->callback = sub_80F0574; } static void sub_80F0574(struct Sprite *sprite) @@ -1410,7 +1437,7 @@ static void sub_80F05B4(u8 ballId) } } -u8 AnimateBallOpenParticles(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId) +u8 LaunchBallStarsTask(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId) { u8 taskId; @@ -2217,7 +2244,7 @@ static void sub_80F1B3C(struct Sprite *sprite) sprite->data[4] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), 1) + gBattleAnimArgs[3]; sprite->data[5] = -32; InitAnimArcTranslation(sprite); - gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].callback = sub_8039E84; + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].callback = sub_8012354; sprite->callback = sub_80F1BCC; } diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c index 582dd20a5..91c1fabec 100644 --- a/src/battle_anim_status_effects.c +++ b/src/battle_anim_status_effects.c @@ -9,7 +9,7 @@ #include "trig.h" #include "util.h" #include "constants/battle_anim.h" -#include "constants/rgb.h" +#include "constants/pokemon.h" // Function Declarations static u8 sub_8078178(u8 battlerId, bool8 b); @@ -51,7 +51,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF3F8 = .anims = gSpriteAnimTable_83BF3F4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8AEC, + .callback = sub_8076F58, }; const struct SpriteTemplate gSpriteTemplate_83BF410 = @@ -62,7 +62,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF410 = .anims = gSpriteAnimTable_83BF3F4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8A6C, + .callback = sub_8076ED8, }; static const union AnimCmd gUnknown_83BF428[] = @@ -84,7 +84,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF434 = .anims = gSpriteAnimTable_83BF430, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8E30, + .callback = sub_807729C, }; const struct SpriteTemplate gSpriteTemplate_83BF44C = @@ -95,7 +95,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF44C = .anims = gSpriteAnimTable_83BF430, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8EE4, + .callback = sub_8077350, }; static const union AnimCmd gUnknown_83BF464[] = @@ -121,7 +121,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF480 = .anims = gSpriteAnimTable_83BF47C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8B64, + .callback = sub_8076FD0, }; const struct SpriteTemplate gSpriteTemplate_83BF498 = @@ -132,7 +132,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF498 = .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8AEC, + .callback = sub_8076F58, }; static const union AnimCmd gUnknown_83BF4B0[] = @@ -168,7 +168,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF4D4 = .anims = gSpriteAniimTable_83BF4C8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8AEC, + .callback = sub_8076F58, }; static const union AnimCmd gUnknown_83BF4EC[] = @@ -202,10 +202,11 @@ const struct SpriteTemplate gSpriteTemplate_83BF514 = .anims = gSpriteAnimTable_83BF4F4, .images = NULL, .affineAnims = gSpriteAffineAnimTable_83BF510, - .callback = sub_80A8A6C, + .callback = sub_8076ED8, }; -static const u32 gUnknown_83BF52C = _("TASK OVER\nタスクがオーバーしました$"); +const u8 gUnknown_83BF52C[] = _("TASK OVER\n"); +const u8 gUnknown_83BF536[] = {0x60, 0x5D, 0x58, 0x37, 0x55, 0xAE, 0x96, 0xAE, 0x0C, 0x1F, 0x0C, 0x10, 0xFF}; // static const struct Subsprite gSubsprites_83BF544[] = { @@ -510,8 +511,8 @@ void AnimTask_StatsChange(u8 taskId) gBattleAnimArgs[2] = 0; gBattleAnimArgs[3] = 0; gBattleAnimArgs[4] = sharply; - gTasks[taskId].func = sub_8116EB4; - sub_8116EB4(taskId); + gTasks[taskId].func = sub_80BB088; + sub_80BB088(taskId); } #undef CASE -- cgit v1.2.3 From aacb202f812d0b7a54ba40eaafe48e7e21451f8c Mon Sep 17 00:00:00 2001 From: Evan Date: Tue, 3 Dec 2019 10:54:47 -0700 Subject: resolve compiler errors --- src/battle_anim_effects_1.c | 6 +++--- src/battle_anim_effects_2.c | 25 +++++++++++++------------ src/battle_anim_effects_3.c | 32 ++++++++++++++------------------ src/battle_anim_mons.c | 2 +- src/battle_anim_special.c | 29 +++++++++++++++++++---------- src/ghost.c | 6 +++--- 6 files changed, 53 insertions(+), 47 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index ff0927f88..093d2b345 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -2375,7 +2375,7 @@ static void AnimAbsorptionOrbStep(struct Sprite* sprite) void AnimHyperBeamOrb(struct Sprite* sprite) { u16 speed; - u16 animNum = Random2(); + u16 animNum = Random(); StartSpriteAnim(sprite, animNum % 8); sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); @@ -2385,14 +2385,14 @@ void AnimHyperBeamOrb(struct Sprite* sprite) else sprite->pos1.x += 20; - speed = Random2(); + speed = Random(); sprite->data[0] = (speed & 31) + 64; sprite->data[1] = sprite->pos1.x; sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); sprite->data[3] = sprite->pos1.y; sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); InitAnimFastLinearTranslationWithSpeed(sprite); - sprite->data[5] = Random2() & 0xFF; + sprite->data[5] = Random() & 0xFF; sprite->data[6] = sprite->subpriority; sprite->callback = AnimHyperBeamOrbStep; sprite->callback(sprite); diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index cea915921..9cd6f4839 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -343,7 +343,7 @@ const struct SpriteTemplate gWaterPulseRingSpriteTemplate = //gUnknown_83E3CE8 .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gWaterPulseRingAffineAnimTable, - .callback = sub_80AC6D8, + .callback = AnimWaterPulseRing, //water.c }; const struct SpriteTemplate gEggThrowSpriteTemplate = //gUnknown_83E3D00 @@ -1828,9 +1828,9 @@ static void AnimBulletSeed_Step1(struct Sprite *sprite) for (i = 0; i < 8; i++) ptr[i - 7] = 0; - rand = Random2(); + rand = Random(); sprite->data[6] = 0xFFF4 - (rand & 7); - rand = Random2(); + rand = Random(); sprite->data[7] = (rand % 0xA0) + 0xA0; sprite->callback = AnimBulletSeed_Step2; sprite->affineAnimPaused = 0; @@ -3238,9 +3238,9 @@ void AnimTask_HeartsBackground(u8 taskId) SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); sub_80752A0(&animBg); - AnimLoadCompressedBgGfx(animBg.bgId, &gUnknown_08C232E0, animBg.tilesOffset); - sub_80A6D60(&animBg, &gUnknown_08C23D78, 0); - LoadCompressedPalette(&gUnknown_08C23D50, animBg.paletteId * 16, 32); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBg_AttractTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnimBg_AttractGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnimBg_AttractPal, animBg.paletteId * 16, 32); gTasks[taskId].func = HeartsBackground_Step; } @@ -3316,15 +3316,16 @@ void AnimTask_ScaryFace(u8 taskId) SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); sub_80752A0(&animBg); + if (IsContest()) - sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFaceContest, 0); + LZDecompressVram(gBattleAnimBgTilemap_ScaryFaceContest, animBg.bgTilemap); else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) - sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFacePlayer, 0); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBgTilemap_ScaryFacePlayer); else - sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFaceOpponent, 0); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBgTilemap_ScaryFaceOpponent); - AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C249F8, animBg.tilesOffset); - LoadCompressedPalette(gUnknown_08C249D0, animBg.paletteId * 16, 32); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_ScaryFaceGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnim_ScaryFacePal, animBg.paletteId * 16, 32); gTasks[taskId].func = ScaryFace_Step; } @@ -3546,7 +3547,7 @@ void AnimPinkHeart(struct Sprite *sprite) sprite->pos1.y += sprite->pos2.y; sprite->pos2.x = 0; sprite->pos2.y = 0; - sprite->data[3] = Random2() % 180; + sprite->data[3] = Random() % 180; } } } diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index ab8b3f20a..4b2a3f310 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -120,10 +120,6 @@ static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); // Data -extern const u32 gUnknown_8D2A8C0[]; -extern const u32 gUnknown_8D2A808[]; -extern const u32 gUnknown_8D2A8A8[]; - const union AnimCmd gScratchAnimCmds[] = //83FEDE4 { ANIMCMD_FRAME(0, 4), @@ -2151,13 +2147,13 @@ void AnimMiniTwinklingStar(struct Sprite *sprite) u8 rand; s8 y; - rand = Random2() & 3; + rand = Random() & 3; if (rand == 0) sprite->oam.tileNum += 4; else sprite->oam.tileNum += 5; - y = Random2() & 7; + y = Random() & 7; if (y > 3) y = -y; @@ -2362,9 +2358,9 @@ void AnimTask_MorningSunLightBeam(u8 taskId) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); sub_80752A0(&animBg); - AnimLoadCompressedBgTilemap(animBg.bgId, gUnknown_8D2A8C0); - AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_8D2A808, animBg.tilesOffset); - LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnim_MorningSunTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_MorningSunGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnim_MorningSunPal, animBg.paletteId * 16, 32); if (IsContest()) { sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); @@ -2443,7 +2439,7 @@ void AnimGreenStar(struct Sprite *sprite) u8 spriteId1; u8 spriteId2; - xOffset = Random2(); + xOffset = Random(); xOffset &= 0x3F; if (xOffset > 31) xOffset = 32 - xOffset; @@ -2541,9 +2537,9 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); sub_80752A0(&animBg); - AnimLoadCompressedBgTilemap(animBg.bgId, gUnknown_8D2A8C0); - AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_8D2A808, animBg.tilesOffset); - LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnim_MorningSunTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_MorningSunGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnim_MorningSunPal, animBg.paletteId * 16, 32); if (IsContest()) { @@ -3011,10 +3007,10 @@ void AnimFlatterConfetti(struct Sprite *sprite) int rand1; int rand2; - tileOffset = Random2() % 12; + tileOffset = Random() % 12; sprite->oam.tileNum += tileOffset; - rand1 = Random2() & 0x1FF; - rand2 = Random2() & 0xFF; + rand1 = Random() & 0x1FF; + rand2 = Random() & 0xFF; if (rand1 & 1) sprite->data[0] = 0x5E0 + rand1; @@ -3249,7 +3245,7 @@ static void AnimTask_RolePlaySilhouetteStep2(u8 taskId) TrySetSpriteRotScale(&gSprites[spriteId], TRUE, gTasks[taskId].data[10], gTasks[taskId].data[11], 0); if (++gTasks[taskId].data[12] == 9) { - sub_80A749C(&gSprites[spriteId]); + sub_8075AD8(&gSprites[spriteId]); DestroySpriteAndFreeResources_(&gSprites[spriteId]); gTasks[taskId].func = DestroyAnimVisualTaskAndDisableBlend; } @@ -3771,7 +3767,7 @@ static void CreateSweatDroplets(u8 taskId, bool8 arg1) for (i = 0; i < 4; i++) { - u8 spriteId = CreateSprite(&gFacadeSweatDrop, xCoords[i], yCoords[i & 1], task->data[6] - 5); + u8 spriteId = CreateSprite(&gFacadeSweatDropSpriteTemplate, xCoords[i], yCoords[i & 1], task->data[6] - 5); if (spriteId != MAX_SPRITES) { gSprites[spriteId].data[0] = 0; diff --git a/src/battle_anim_mons.c b/src/battle_anim_mons.c index bdba7ae3b..7f3516670 100644 --- a/src/battle_anim_mons.c +++ b/src/battle_anim_mons.c @@ -884,7 +884,7 @@ void AnimLoadCompressedBgTilemap(u32 bgId, const u32 *src) CopyBgTilemapBufferToVram(bgId); } -u8 sub_8075454(void) +u8 GetBattleBgPaletteNum(void) { return 2; } diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index a93913b82..c228048cc 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -20,6 +20,7 @@ #include "constants/items.h" #include "constants/moves.h" #include "constants/songs.h" +#include "constants/pokemon.h" // Defines #define TAG_PARTICLES_POKEBALL 55020 @@ -39,9 +40,13 @@ #define LOHALF(n) ((n) & 0xFFFF) // IWRAM -EWRAM_DATA int gUnknown_3005424 = 0; -EWRAM_DATA u16 gUnknown_3005428 = 0; -EWRAM_DATA u16 gUnknown_300542C = 0; +//EWRAM_DATA int gUnknown_3005424 = 0; +//EWRAM_DATA u16 gUnknown_3005428 = 0; +//EWRAM_DATA u16 gUnknown_300542C = 0; + +extern u32 gUnknown_3005424; +extern u32 gUnknown_3005428; +extern u32 gUnknown_300542C; // Function Declarations static void sub_80EEDF4(u8); @@ -99,9 +104,8 @@ static void PremierBallOpenParticleAnimation(u8); static void sub_80F1B3C(struct Sprite *); // Data -extern const u32 gUnknown_8D2EC24[]; -extern const u32 gUnknown_8D2EC70[]; -extern const struct SpriteTemplate gBallSpriteTemplates[]; //for now +extern const struct SpriteTemplate gBallSpriteTemplates[POKEBALL_COUNT]; //for now +extern const u32 gBattleAnimSpriteGfx_Particles[]; struct BallCaptureSuccessStarData { @@ -455,8 +459,8 @@ void sub_80EEC0C(u8 taskId) gSprites[spriteId4].callback = SpriteCallbackDummy; sub_80752A0(&unknownStruct); - AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_8D2EC70); - AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_8D2EC24, unknownStruct.tilesOffset); + AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_D2EC24_Tilemap); + AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_D2EC24_Gfx, unknownStruct.tilesOffset); LoadCompressedPalette(gCureBubblesPal, unknownStruct.paletteId << 4, 32); gBattle_BG1_X = -gSprites[spriteId3].pos1.x + 32; @@ -2293,9 +2297,14 @@ void sub_80F1C8C(u8 taskId) DestroyAnimVisualTask(taskId); } -void sub_80F1C8C(u8 taskId) +void sub_80F1CE4(u8 taskId) { - // to do + if (gBattleCommunication[MULTISTRING_CHOOSER] > 2) + gBattleAnimArgs[7] = 0; + else + gBattleAnimArgs[7] = gBattleCommunication[MULTISTRING_CHOOSER]; + + DestroyAnimVisualTask(taskId); } // 080F1D14 diff --git a/src/ghost.c b/src/ghost.c index 643cc3b0d..793c9838c 100644 --- a/src/ghost.c +++ b/src/ghost.c @@ -1319,13 +1319,13 @@ static void sub_80B6BE4(u8 taskId) SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X); SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y); sub_80752C8(&animBgData, 2); - AnimLoadCompressedBgGfx(animBgData.bgId, gFile_graphics_battle_anims_backgrounds_scary_face_sheet, animBgData.tilesOffset); - LoadCompressedPalette(gFile_graphics_battle_anims_backgrounds_scary_face_palette, 16 * animBgData.paletteId, 0x20); + AnimLoadCompressedBgGfx(animBgData.bgId, gBattleAnim_ScaryFaceGfx, animBgData.tilesOffset); + LoadCompressedPalette(gBattleAnim_ScaryFacePal, 16 * animBgData.paletteId, 0x20); break; case 3: sub_80752C8(&animBgData, 2); gMonSpritesGfxPtr->field_17C = AllocZeroed(0x2000); - LZDecompressWram(gFile_graphics_battle_anims_backgrounds_scary_face_player_tilemap, gMonSpritesGfxPtr->field_17C); + LZDecompressWram(gBattleAnimBgTilemap_ScaryFacePlayer, gMonSpritesGfxPtr->field_17C); sub_80730C0(animBgData.paletteId, gMonSpritesGfxPtr->field_17C, 256, 0); CopyToBgTilemapBufferRect_ChangePalette(animBgData.bgId, gMonSpritesGfxPtr->field_17C, 0, 0, 0x20, 0x20, 0x11); CopyBgTilemapBufferToVram(2); -- cgit v1.2.3 From 11b4456aa549c148a822cadf13231cbd8112c896 Mon Sep 17 00:00:00 2001 From: Evan Date: Tue, 3 Dec 2019 19:50:42 -0700 Subject: resolve references --- src/battle_anim_effects_2.c | 4 ++-- src/battle_anim_special.c | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 9cd6f4839..215b7d869 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -292,12 +292,12 @@ const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = +const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = //gUnknown_83E3C98 { gGrowingRingAffineAnimCmds, }; -const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = +const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = //83E3C9C { gWaterPulseRingAffineAnimCmds, }; diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index c228048cc..108e6c196 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -104,8 +104,7 @@ static void PremierBallOpenParticleAnimation(u8); static void sub_80F1B3C(struct Sprite *); // Data -extern const struct SpriteTemplate gBallSpriteTemplates[POKEBALL_COUNT]; //for now -extern const u32 gBattleAnimSpriteGfx_Particles[]; +extern const struct SpriteTemplate gBallSpriteTemplates[]; //for now struct BallCaptureSuccessStarData { -- cgit v1.2.3 From 00577da2e14b64f2289dbac92ca8dd3943259dcb Mon Sep 17 00:00:00 2001 From: Evan Date: Wed, 4 Dec 2019 07:46:49 -0700 Subject: match battle_anim funcs --- src/battle_anim.c | 104 ++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 70 insertions(+), 34 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index de5f08f38..6510003e0 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -2165,52 +2165,83 @@ static void ScriptCmd_monbg(void) u8 taskId; u8 battlerId; u8 animBattler; + u8 position; + u8 spriteId; sBattleAnimScriptPtr++; - animBattler = sBattleAnimScriptPtr[0]; - if (animBattler & ANIM_TARGET) - battlerId = gBattleAnimTarget; - else - battlerId = gBattleAnimAttacker; + if (animBattler == 0) + animBattler = 2; + else if (animBattler == 1) + animBattler = 3; + if (animBattler == 0 || animBattler == 2) + battlerId = gBattleAnimAttacker; + else + battlerId = gBattleAnimTarget; + if (IsBattlerSpriteVisible(battlerId)) { - u8 position = GetBattlerPosition(battlerId); - toBG_2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) // || position == B_POSITION_PLAYER_RIGHT) + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; + else + toBG_2 = TRUE; MoveBattlerSpriteToBG(battlerId, toBG_2); + spriteId = gBattlerSpriteIds[battlerId]; taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); - gAnimVisualTaskCount++; - gTasks[taskId].data[t1_MONBG_BATTLER] = battlerId; - gTasks[taskId].data[t1_MON_IN_BG2] = toBG_2; - gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE; - gTasks[taskId].data[t1_IS_SECONDMON_BG] = 0; + gTasks[taskId].data[t1_MONBG_BATTLER] = spriteId; + gTasks[taskId].data[1] = gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x; + gTasks[taskId].data[2] = gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y; + if (!toBG_2) + { + gTasks[taskId].data[3] = gBattle_BG1_X; + gTasks[taskId].data[4] = gBattle_BG1_Y; + } + else + { + gTasks[taskId].data[3] = gBattle_BG2_X; + gTasks[taskId].data[4] = gBattle_BG2_Y; + } + gTasks[taskId].data[5] = toBG_2; + gTasks[taskId].data[6] = battlerId; + sMonAnimTaskIdArray[0] = taskId; } battlerId ^= BIT_FLANK; - if (IsBattlerSpriteVisible(battlerId)) + if (animBattler > 1 && IsBattlerSpriteVisible(battlerId)) { - u8 position = GetBattlerPosition(battlerId); - toBG_2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) // || position == B_POSITION_PLAYER_RIGHT) + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; + else + toBG_2 = TRUE; MoveBattlerSpriteToBG(battlerId, toBG_2); + spriteId = gBattlerSpriteIds[battlerId]; taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); - gAnimVisualTaskCount++; - gTasks[taskId].data[0] = battlerId; - gTasks[taskId].data[1] = toBG_2; - gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE; - gTasks[taskId].data[t1_IS_SECONDMON_BG] = 1; + gTasks[taskId].data[t1_MONBG_BATTLER] = spriteId; + gTasks[taskId].data[1] = gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x; + gTasks[taskId].data[2] = gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y; + if (!toBG_2) + { + gTasks[taskId].data[3] = gBattle_BG1_X; + gTasks[taskId].data[4] = gBattle_BG1_Y; + } + else + { + gTasks[taskId].data[3] = gBattle_BG2_X; + gTasks[taskId].data[4] = gBattle_BG2_Y; + } + + gTasks[taskId].data[5] = toBG_2; + gTasks[taskId].data[6] = battlerId; + sMonAnimTaskIdArray[1] = taskId; } sBattleAnimScriptPtr++; - gAnimFramesToWait = 1; - gAnimScriptCallback = WaitAnimFrameCount; } bool8 IsBattlerSpriteVisible(u8 battlerId) @@ -2224,26 +2255,30 @@ bool8 IsBattlerSpriteVisible(u8 battlerId) return FALSE; } +// re-check needed? void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) { struct BattleAnimBgData animBg; u8 battlerSpriteId; + struct Sprite *sprite; if (!toBG_2) { - u8 battlerPosition; - RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(16)), 0x2000, 1); - RequestDma3Fill(0xFF, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 0); + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(8)), 0x2000, 1); + RequestDma3Fill(0xFF, (void*)(BG_SCREEN_ADDR(28)), 0x1000, 0); sub_80752A0(&animBg); - CpuFill16(0, animBg.bgTiles, 0x1000); - CpuFill16(0xFF, animBg.bgTilemap, 0x800); + CpuFill16(toBG_2, animBg.bgTiles, 0x1000); + CpuFill16(toBG_2, animBg.bgTilemap, 0x800); SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 2); SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 1); SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0); battlerSpriteId = gBattlerSpriteIds[battlerId]; + gBattle_BG1_X = -(gSprites[battlerSpriteId].pos1.x + gSprites[battlerSpriteId].pos2.x) + 0x20; + gBattle_BG1_Y = -(gSprites[battlerSpriteId].pos1.y + gSprites[battlerSpriteId].pos2.y) + 0x20; + gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE; SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); @@ -2251,9 +2286,7 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], animBg.paletteId * 16, 0x20); CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + animBg.paletteId * 32), 0x20); - battlerPosition = GetBattlerPosition(battlerId); - - sub_80BCEF4(1, 0, 0, battlerPosition, animBg.paletteId, animBg.bgTiles, animBg.bgTilemap, animBg.tilesOffset); + sub_80BCEF4(1, 0, 0, GetBattlerPosition(battlerId), animBg.paletteId, animBg.bgTiles, animBg.bgTilemap, animBg.tilesOffset); } else { @@ -2261,15 +2294,15 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 1); sub_80752C8(&animBg, 2); CpuFill16(0, animBg.bgTiles + 0x1000, 0x1000); - CpuFill16(0, animBg.bgTilemap + 0x400, 0x800); + CpuFill16(0, animBg.bgTilemap + 0x400, 0x400); SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1); SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0); battlerSpriteId = gBattlerSpriteIds[battlerId]; - gBattle_BG2_X = -(gSprites[battlerSpriteId].pos1.x + gSprites[battlerSpriteId].pos2.x) + 0x20; gBattle_BG2_Y = -(gSprites[battlerSpriteId].pos1.y + gSprites[battlerSpriteId].pos2.y) + 0x20; + gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE; SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X); SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y); @@ -2285,6 +2318,7 @@ void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) { s32 i, j; s32 var; + s32 x; if (d == 0) var = 32; @@ -2295,7 +2329,9 @@ void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) for (i = 0; i < var; i++) { for (j = 0; j < 32; j++) + { b[j + i * 32] = ((b[j + i * 32] & 0xFFF) | a) + c; + } } } -- cgit v1.2.3 From aa272d1e512c38bb271d8d6f1f7491920f28c5eb Mon Sep 17 00:00:00 2001 From: Evan Date: Wed, 4 Dec 2019 14:49:35 -0700 Subject: matching up battle_anim_special --- src/battle_anim.c | 97 +++++++++++++++++++++++++-------------------- src/battle_anim_effects_1.c | 16 ++------ src/battle_anim_effects_2.c | 18 ++++++--- src/battle_anim_effects_3.c | 72 ++++++++++++--------------------- src/battle_anim_special.c | 68 ++++++++++++++++++------------- 5 files changed, 137 insertions(+), 134 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index 6510003e0..16cf56920 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -65,6 +65,7 @@ static void LoadDefaultBg(void); static void Task_LoopAndPlaySE(u8 taskId); static void Task_WaitAndPlaySE(u8 taskId); static void sub_807331C(u8 taskId); +static bool8 sub_807378C(u16 a); static void ScriptCmd_loadspritegfx(void); static void ScriptCmd_unloadspritegfx(void); @@ -2316,9 +2317,8 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) { - s32 i, j; - s32 var; - s32 x; + u8 i, j; + u32 var; if (d == 0) var = 32; @@ -2330,7 +2330,7 @@ void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) { for (j = 0; j < 32; j++) { - b[j + i * 32] = ((b[j + i * 32] & 0xFFF) | a) + c; + b[32 * i + j] = ((b[32 * i + j] & 0xFFF) | a) + c; } } } @@ -2398,13 +2398,12 @@ static void ScriptCmd_clearmonbg(void) sBattleAnimScriptPtr++; animBattlerId = sBattleAnimScriptPtr[0]; + if (animBattlerId == 0) + animBattlerId = 2; + else if (animBattlerId == 1) + animBattlerId = 3; - if (animBattlerId == ANIM_ATTACKER) - animBattlerId = ANIM_ATK_PARTNER; - else if (animBattlerId == ANIM_TARGET) - animBattlerId = ANIM_DEF_PARTNER; - - if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + if (animBattlerId == 0 || animBattlerId == 2) battlerId = gBattleAnimAttacker; else battlerId = gBattleAnimTarget; @@ -2425,24 +2424,27 @@ static void ScriptCmd_clearmonbg(void) static void sub_807331C(u8 taskId) { - gTasks[taskId].data[1]++; + u8 toBG_2; + u8 position; + + gTasks[taskId].data[1]++; if (gTasks[taskId].data[1] != 1) { - u8 to_BG2; - u8 position = GetBattlerPosition(gTasks[taskId].data[2]); - to_BG2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) - to_BG2 = FALSE; + position = ((GetBattlerPosition((u8)gTasks[taskId].data[2]) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) + toBG_2 = FALSE; + else + toBG_2 = TRUE; if (sMonAnimTaskIdArray[0] != 0xFF) { - sub_8073128(to_BG2); + sub_8073128(toBG_2); DestroyTask(sMonAnimTaskIdArray[0]); sMonAnimTaskIdArray[0] = 0xFF; } if (gTasks[taskId].data[0] > 1) { - sub_8073128(to_BG2 ^ 1); + sub_8073128(toBG_2 ^ 1); DestroyTask(sMonAnimTaskIdArray[1]); sMonAnimTaskIdArray[1] = 0xFF; } @@ -2455,40 +2457,43 @@ static void ScriptCmd_monbg_22(void) bool8 toBG_2; u8 battlerId; u8 animBattlerId; + u8 position; sBattleAnimScriptPtr++; - animBattlerId = sBattleAnimScriptPtr[0]; + if (animBattlerId == 0) + animBattlerId = 2; + else if (animBattlerId == 1) + animBattlerId = 3; - if (animBattlerId == ANIM_ATTACKER) - animBattlerId = ANIM_ATK_PARTNER; - else if (animBattlerId == ANIM_TARGET) - animBattlerId = ANIM_DEF_PARTNER; - - if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + if (animBattlerId == 0 || animBattlerId == 2) battlerId = gBattleAnimAttacker; else battlerId = gBattleAnimTarget; if (IsBattlerSpriteVisible(battlerId)) { - u8 position = GetBattlerPosition(battlerId); - toBG_2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; - + else + toBG_2 = TRUE; + MoveBattlerSpriteToBG(battlerId, toBG_2); + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; } battlerId ^= BIT_FLANK; if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId)) { - u8 position = GetBattlerPosition(battlerId); - toBG_2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; + else + toBG_2 = TRUE; MoveBattlerSpriteToBG(battlerId, toBG_2); + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; } sBattleAnimScriptPtr++; @@ -2530,16 +2535,19 @@ static void ScriptCmd_clearmonbg_23(void) static void sub_8073558(u8 taskId) { bool8 to_BG2; + u8 position; + u8 battlerId; gTasks[taskId].data[1]++; if (gTasks[taskId].data[1] != 1) { bool8 toBG_2; - u8 battlerId = gTasks[taskId].data[2]; - u8 position = GetBattlerPosition(battlerId); - to_BG2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) - to_BG2 = FALSE; + battlerId = gTasks[taskId].data[2]; + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) + toBG_2 = FALSE; + else + toBG_2 = TRUE; if (IsBattlerSpriteVisible(battlerId)) sub_8073128(toBG_2); @@ -2625,6 +2633,7 @@ static void ScriptCmd_choosetwoturnanim(void) static void ScriptCmd_jumpifmoveturn(void) { u8 toCheck; + sBattleAnimScriptPtr++; toCheck = sBattleAnimScriptPtr[0]; sBattleAnimScriptPtr++; @@ -2641,13 +2650,18 @@ static void ScriptCmd_goto(void) sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); } -//unused bool8 IsContest(void) { - if (!gMain.inBattle) - return TRUE; - else + return FALSE; +} + +// Unused +static bool8 sub_807378C(u16 a) +{ + if (a == 0xC9) return FALSE; + else + return TRUE; } #define tBackgroundId data[0] @@ -3192,7 +3206,6 @@ static void ScriptCmd_jumpargeq(void) static void ScriptCmd_jumpifcontest(void) { - sBattleAnimScriptPtr++; sBattleAnimScriptPtr += 5; } diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 093d2b345..2f92515c1 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -2215,6 +2215,7 @@ const struct SpriteTemplate gTauntFingerSpriteTemplate = //gUnknown_83E3AC4 .callback = AnimTauntFinger, }; +// Functions // Animates the falling particles that horizontally wave back and forth. // Used by Sleep Powder, Stun Spore, and Poison Powder. // arg 0: initial x pixel offset @@ -2734,7 +2735,7 @@ static void AnimTranslateLinearSingleSineWaveStep(struct Sprite* sprite) // arg 4: speedup frame (particles move faster at the end of the animation) void AnimMoveTwisterParticle(struct Sprite* sprite) { - if (IsDoubleBattle() == TRUE) + if (!IsContest() && IsDoubleBattle() == TRUE) SetAverageBattlerPositions(gBattleAnimTarget, 1, &sprite->pos1.x, &sprite->pos1.y); sprite->pos1.y += 32; @@ -2836,11 +2837,6 @@ void sub_80A2F0C(u8 taskId) else { PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_BLEND); - gTasks[taskId].data[14] = gSprites[spriteId].oam.priority; - gSprites[spriteId].oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget); - spriteId = GetAnimBattlerSpriteId(ANIM_DEF_PARTNER); - gTasks[taskId].data[15] = gSprites[spriteId].oam.priority; - gSprites[spriteId].oam.priority = GetBattlerSpriteBGPriority(BATTLE_PARTNER(gBattleAnimTarget)); gTasks[taskId].data[0] = gBattleAnimArgs[0]; gTasks[taskId].data[1] = gBattleAnimArgs[1]; gTasks[taskId].data[11] = 0x100; @@ -2874,12 +2870,8 @@ static void AnimTask_DuplicateAndShrinkToPosStep2(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); ResetSpriteRotScale(spriteId); - gSprites[spriteId].pos2.x = 0; - gSprites[spriteId].pos2.y = 0; - gSprites[spriteId].oam.priority = gTasks[taskId].data[14]; - spriteId = GetAnimBattlerSpriteId(ANIM_DEF_PARTNER); - gSprites[spriteId].oam.priority = gTasks[taskId].data[15]; - gTasks[taskId].data[0]++; + gSprites[spriteId].pos2.y = gSprites[spriteId].pos2.x = 0; + gTasks[taskId].data[0]++; return; } } diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 215b7d869..1fe43b78c 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -51,7 +51,7 @@ void AnimAngel(struct Sprite *); void AnimPinkHeart(struct Sprite *); void AnimDevil(struct Sprite *); void AnimFurySwipes(struct Sprite *); -void AnimMovmentWaves(struct Sprite *); +void AnimMovementWaves(struct Sprite *); void AnimJaggedMusicNote(struct Sprite *); void AnimPerishSongMusicNote2(struct Sprite *); void AnimPerishSongMusicNote(struct Sprite *); @@ -98,7 +98,7 @@ static void HeartsBackground_Step(u8); static void ScaryFace_Step(u8); static void AnimOrbitFastStep(struct Sprite *); static void AnimOrbitScatterStep(struct Sprite *); -static void AnimMovmentWaves_Step(struct Sprite *); +static void AnimMovementWaves_Step(struct Sprite *); static void UproarDistortion_Step(u8); static void AnimJaggedMusicNote_Step(struct Sprite *); static void AnimPerishSongMusicNote_Step1(struct Sprite *); @@ -1152,7 +1152,7 @@ const struct SpriteTemplate gMovementWavesSpriteTemplate = //gUnknown_83E43F8 .anims = gMovementWavesAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = AnimMovmentWaves, + .callback = AnimMovementWaves, }; const union AffineAnimCmd gUnknown_08593B98[] = @@ -3241,6 +3241,9 @@ void AnimTask_HeartsBackground(u8 taskId) AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBg_AttractTilemap); AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnimBg_AttractGfx, animBg.tilesOffset); LoadCompressedPalette(gBattleAnimBg_AttractPal, animBg.paletteId * 16, 32); + if (IsContest()) + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + gTasks[taskId].func = HeartsBackground_Step; } @@ -3326,6 +3329,9 @@ void AnimTask_ScaryFace(u8 taskId) AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_ScaryFaceGfx, animBg.tilesOffset); LoadCompressedPalette(gBattleAnim_ScaryFacePal, animBg.paletteId * 16, 32); + if (IsContest()) + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + gTasks[taskId].func = ScaryFace_Step; } @@ -3596,7 +3602,7 @@ void AnimFurySwipes(struct Sprite *sprite) } } -void AnimMovmentWaves(struct Sprite *sprite) +void AnimMovementWaves(struct Sprite *sprite) { if (!gBattleAnimArgs[2]) { @@ -3623,11 +3629,11 @@ void AnimMovmentWaves(struct Sprite *sprite) sprite->data[0] = gBattleAnimArgs[2]; sprite->data[1] = gBattleAnimArgs[1]; StartSpriteAnim(sprite, sprite->data[1]); - sprite->callback = AnimMovmentWaves_Step; + sprite->callback = AnimMovementWaves_Step; } } -static void AnimMovmentWaves_Step(struct Sprite *sprite) +static void AnimMovementWaves_Step(struct Sprite *sprite) { if (sprite->animEnded) { diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 4b2a3f310..ec99a9f95 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -2365,6 +2365,7 @@ void AnimTask_MorningSunLightBeam(u8 taskId) { sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); gBattle_BG1_X = -56; + gBattle_BG1_Y = 0; } else { @@ -2372,15 +2373,17 @@ void AnimTask_MorningSunLightBeam(u8 taskId) gBattle_BG1_X = -135; else gBattle_BG1_X = -10; + + gBattle_BG1_Y = 0; } - - gBattle_BG1_Y = 0; + gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; gTasks[taskId].data[0]++; PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(-64)); break; + break; case 1: if (gTasks[taskId].data[4]++ > 0) { @@ -3890,18 +3893,9 @@ void AnimTask_GlareEyeDots(u8 taskId) { struct Task *task = &gTasks[taskId]; - if (IsContest()) - { - task->data[5] = 8; - task->data[6] = 3; - task->data[7] = 1; - } - else - { - task->data[5] = 12; - task->data[6] = 3; - task->data[7] = 0; - } + task->data[5] = 12; + task->data[6] = 3; + task->data[7] = 0; if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; @@ -4379,29 +4373,22 @@ void AnimTask_HelpingHandAttackerMovement(u8 taskId) struct Task *task = &gTasks[taskId]; task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); - if (!IsContest()) - { - if (IsDoubleBattle() == TRUE) - { - int x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); - int y = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimAttacker), 0); - if (x > y) - task->data[14] = 1; - else - task->data[14] = -1; - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - task->data[14] = -1; - else - task->data[14] = 1; - } - } - else - { - task->data[14] = 1; - } + if (IsDoubleBattle() == TRUE) + { + int x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + int y = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimAttacker), 0); + if (x > y) + task->data[14] = 1; + else + task->data[14] = -1; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + task->data[14] = -1; + else + task->data[14] = 1; + } task->func = AnimTask_HelpingHandAttackerMovementStep; } @@ -4641,7 +4628,7 @@ void AnimMeteorMashStar(struct Sprite *sprite) s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); // unused local variable s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); // unused local variable - if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER || IsContest()) + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) { sprite->data[0] = sprite->pos1.x - gBattleAnimArgs[0]; sprite->data[2] = sprite->pos1.x - gBattleAnimArgs[2]; @@ -4831,12 +4818,6 @@ void AnimTask_OdorSleuthMovement(u8 taskId) { s16 spriteId1, spriteId2; - if (IsContest()) - { - DestroyAnimVisualTask(taskId); - return; - } - spriteId1 = CloneBattlerSpriteWithBlend(ANIM_TARGET); if (spriteId1 < 0) { @@ -5095,7 +5076,7 @@ void sub_80E3E84(struct Sprite *sprite) sprite->data[0] = -32; sprite->data[7]++; sprite->invisible = 0; - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT && !IsContest()) + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) sprite->subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; } else @@ -5239,7 +5220,6 @@ static void AnimTask_TeeterDanceMovementStep(u8 taskId) static void AnimKnockOffStrikeStep(struct Sprite *sprite) { - // These two cases are identical. if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) { sprite->data[1] += sprite->data[0]; diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 108e6c196..0ee1eee2e 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -40,13 +40,13 @@ #define LOHALF(n) ((n) & 0xFFFF) // IWRAM -//EWRAM_DATA int gUnknown_3005424 = 0; -//EWRAM_DATA u16 gUnknown_3005428 = 0; -//EWRAM_DATA u16 gUnknown_300542C = 0; +EWRAM_DATA u16 gUnknown_3005424 = 0; +EWRAM_DATA u16 gUnknown_3005428 = 0; +EWRAM_DATA u16 gUnknown_300542C = 0; -extern u32 gUnknown_3005424; -extern u32 gUnknown_3005428; -extern u32 gUnknown_300542C; +//extern u32 gUnknown_3005424; +//extern u32 gUnknown_3005428; +//extern u32 gUnknown_300542C; // Function Declarations static void sub_80EEDF4(u8); @@ -704,12 +704,20 @@ void sub_80EF4B8(u8 taskId) DestroyAnimVisualTask(taskId); } -void AnimTask_IsBallBlockedByTrainer(u8 taskId) +void AnimTask_IsBallBlockedByTrainerOrDodged(u8 taskId) { - if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_TRAINER_BLOCK) - gBattleAnimArgs[ARG_RET_ID] = -1; - else - gBattleAnimArgs[ARG_RET_ID] = 0; + switch (gBattleSpritesDataPtr->animationData->ballThrowCaseId) + { + case BALL_TRAINER_BLOCK: + gBattleAnimArgs[ARG_RET_ID] = -1; + break; + case BALL_GHOST_DODGE: + gBattleAnimArgs[ARG_RET_ID] = -2; + break; + default: + gBattleAnimArgs[ARG_RET_ID] = 0; + break; + } DestroyAnimVisualTask(taskId); } @@ -902,8 +910,8 @@ static void sub_80EFA0C(struct Sprite *sprite) PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); gTasks[taskId].data[10] = 256; gUnknown_3005424 = 28; - gUnknown_300542C = (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y) - (sprite->pos1.y + sprite->pos2.y); - gUnknown_3005428 = (u32)(gUnknown_300542C * 256) / 28; + gUnknown_300542C = (gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y) - (sprite->pos2.y + sprite->pos1.y); + gUnknown_3005428 = (gUnknown_300542C * 256) / 28; gTasks[taskId].data[2] = gUnknown_3005428; gTasks[taskId].data[0]++; break; @@ -1209,7 +1217,7 @@ static void sub_80EFFC4(struct Sprite *sprite) } else if (sprite->data[4] == 95) { - gDoingBattleAnim = 0; + gDoingBattleAnim = FALSE; UpdateOamPriorityInAllHealthboxes(1); m4aMPlayAllStop(); PlaySE(MUS_FAN6); @@ -1364,7 +1372,7 @@ static void sub_80F0378(struct Sprite *sprite) gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible = gBattleSpritesDataPtr->animationData->field_9_x2; sprite->data[0] = 0; sprite->callback = sub_80F018C; - gDoingBattleAnim = 0; + gDoingBattleAnim = FALSE; UpdateOamPriorityInAllHealthboxes(1); } } @@ -1397,7 +1405,7 @@ static void sub_80F04B4(struct Sprite *sprite) { sprite->data[0] = 0; sprite->callback = sub_80F018C; - gDoingBattleAnim = 0; + gDoingBattleAnim = FALSE; UpdateOamPriorityInAllHealthboxes(1); } } @@ -1405,18 +1413,13 @@ static void sub_80F04B4(struct Sprite *sprite) // GhostBallDodge static void sub_80F052C(struct Sprite *sprite) { - s16 x; - s16 y; - - x = sprite->pos1.x + sprite->pos2.x; - sprite->pos1.x = x; - y = sprite->pos1.y + sprite->pos2.y; - sprite->pos1.y = y; - sprite->pos2.x = sprite->pos2.y = 0; + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = sprite->pos2.y = 0; sprite->data[0] = 0x22; - sprite->data[1] = x; - sprite->data[2] = x - 8; - sprite->data[3] = y; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = sprite->pos1.x - 8; + sprite->data[3] = sprite->pos1.y; sprite->data[4] = 0x90; sprite->data[5] = 0x20; InitAnimArcTranslation(sprite); @@ -1426,7 +1429,16 @@ static void sub_80F052C(struct Sprite *sprite) static void sub_80F0574(struct Sprite *sprite) { - //to do + if (!TranslateAnimVerticalArc(sprite)) + { + if ((sprite->pos1.y + sprite->pos2.y) < 65) + return; + } + + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + gDoingBattleAnim = FALSE; + UpdateOamPriorityInAllHealthboxes(1); } static void sub_80F05B4(u8 ballId) -- cgit v1.2.3 From 2582f7e44b46f6f83007928fb2992ff3d1f235b4 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 21 Nov 2019 09:29:07 -0500 Subject: Dump tileset anims data --- src/tileset_anims.c | 120 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 112 insertions(+), 8 deletions(-) (limited to 'src') diff --git a/src/tileset_anims.c b/src/tileset_anims.c index 30f390512..9403bc1df 100644 --- a/src/tileset_anims.c +++ b/src/tileset_anims.c @@ -23,14 +23,118 @@ static void (*sSecondaryTilesetAnimCallback)(u16); static void _InitPrimaryTilesetAnimation(void); static void _InitSecondaryTilesetAnimation(void); -extern const u16 *const gUnknown_83A7660[]; -extern const u16 *const gUnknown_83AA654[]; -extern const u16 *const gUnknown_83AB874[]; -extern const u16 *const gUnknown_83ABDB4[]; -extern const u16 *const gUnknown_83AC1E8[]; -extern const u16 *const gUnknown_83AC5F8[]; -extern const u16 *const gUnknown_83AC7C8[]; -extern const u16 *const gUnknown_83AC950[]; +static const u16 gUnknown_83A73E0[] = INCBIN_U16("graphics/tileset_anims/aim_0_0.bin"); +static const u16 gUnknown_83A7460[] = INCBIN_U16("graphics/tileset_anims/aim_0_1.bin"); +static const u16 gUnknown_83A74E0[] = INCBIN_U16("graphics/tileset_anims/aim_0_2.bin"); +static const u16 gUnknown_83A7560[] = INCBIN_U16("graphics/tileset_anims/aim_0_3.bin"); +static const u16 gUnknown_83A75E0[] = INCBIN_U16("graphics/tileset_anims/aim_0_4.bin"); + +static const u16 *const gUnknown_83A7660[] = { + gUnknown_83A73E0, + gUnknown_83A7460, + gUnknown_83A74E0, + gUnknown_83A7560, + gUnknown_83A75E0 +}; + +static const u16 gUnknown_83A7674[] = INCBIN_U16("graphics/tileset_anims/aim_1_0.bin"); +static const u16 gUnknown_83A7C74[] = INCBIN_U16("graphics/tileset_anims/aim_1_1.bin"); +static const u16 gUnknown_83A8274[] = INCBIN_U16("graphics/tileset_anims/aim_1_2.bin"); +static const u16 gUnknown_83A8874[] = INCBIN_U16("graphics/tileset_anims/aim_1_3.bin"); +static const u16 gUnknown_83A8E74[] = INCBIN_U16("graphics/tileset_anims/aim_1_4.bin"); +static const u16 gUnknown_83A9474[] = INCBIN_U16("graphics/tileset_anims/aim_1_5.bin"); +static const u16 gUnknown_83A9A74[] = INCBIN_U16("graphics/tileset_anims/aim_1_6.bin"); +static const u16 gUnknown_83AA074[] = INCBIN_U16("graphics/tileset_anims/aim_1_7.bin"); + +static const u16 *const gUnknown_83AA654[] = { + gUnknown_83A7674, + gUnknown_83A7C74, + gUnknown_83A8274, + gUnknown_83A8874, + gUnknown_83A8E74, + gUnknown_83A9474, + gUnknown_83A9A74, + gUnknown_83AA074 +}; + +static const u16 gUnknown_83AA674[] = INCBIN_U16("graphics/tileset_anims/aim_2_0.bin"); +static const u16 gUnknown_83AA8B4[] = INCBIN_U16("graphics/tileset_anims/aim_2_1.bin"); +static const u16 gUnknown_83AAAF4[] = INCBIN_U16("graphics/tileset_anims/aim_2_2.bin"); +static const u16 gUnknown_83AAD34[] = INCBIN_U16("graphics/tileset_anims/aim_2_3.bin"); +static const u16 gUnknown_83AAF74[] = INCBIN_U16("graphics/tileset_anims/aim_2_4.bin"); +static const u16 gUnknown_83AB1B4[] = INCBIN_U16("graphics/tileset_anims/aim_2_5.bin"); +static const u16 gUnknown_83AB3F4[] = INCBIN_U16("graphics/tileset_anims/aim_2_6.bin"); +static const u16 gUnknown_83AB634[] = INCBIN_U16("graphics/tileset_anims/aim_2_7.bin"); + +static const u16 *const gUnknown_83AB874[] = { + gUnknown_83AA674, + gUnknown_83AA8B4, + gUnknown_83AAAF4, + gUnknown_83AAD34, + gUnknown_83AAF74, + gUnknown_83AB1B4, + gUnknown_83AB3F4, + gUnknown_83AB634 +}; + +static const u16 gUnknown_83AB894[] = INCBIN_U16("graphics/tileset_anims/aim_3_0.bin"); +static const u16 gUnknown_83AB994[] = INCBIN_U16("graphics/tileset_anims/aim_3_1.bin"); +static const u16 gUnknown_83ABA94[] = INCBIN_U16("graphics/tileset_anims/aim_3_2.bin"); +static const u16 gUnknown_83ABB94[] = INCBIN_U16("graphics/tileset_anims/aim_3_3.bin"); +static const u16 gUnknown_83ABC94[] = INCBIN_U16("graphics/tileset_anims/aim_3_4.bin"); +static const u16 gUnknown_83ABD94[16] = {}; + +static const u16 *const gUnknown_83ABDB4[] = { + gUnknown_83AB894, + gUnknown_83AB994, + gUnknown_83ABA94, + gUnknown_83ABB94, + gUnknown_83ABC94 +}; + +static const u16 gUnknown_83ABDC8[] = INCBIN_U16("graphics/tileset_anims/aim_4_0.bin"); +static const u16 gUnknown_83ABEC8[] = INCBIN_U16("graphics/tileset_anims/aim_4_1.bin"); +static const u16 gUnknown_83ABFC8[] = INCBIN_U16("graphics/tileset_anims/aim_4_2.bin"); +static const u16 gUnknown_83AC0C8[] = INCBIN_U16("graphics/tileset_anims/aim_4_3.bin"); +static const u16 gUnknown_83AC1C8[0x10] = {}; + +static const u16 *const gUnknown_83AC1E8[] = { + gUnknown_83ABDC8, + gUnknown_83ABEC8, + gUnknown_83ABFC8, + gUnknown_83AC0C8 +}; + +static const u16 gUnknown_83AC1F8[] = INCBIN_U16("graphics/tileset_anims/aim_5_0.bin"); +static const u16 gUnknown_83AC2F8[] = INCBIN_U16("graphics/tileset_anims/aim_5_1.bin"); +static const u16 gUnknown_83AC3F8[] = INCBIN_U16("graphics/tileset_anims/aim_5_2.bin"); +static const u16 gUnknown_83AC4F8[] = INCBIN_U16("graphics/tileset_anims/aim_5_3.bin"); + +static const u16 *const gUnknown_83AC5F8[] = { + gUnknown_83AC1F8, + gUnknown_83AC2F8, + gUnknown_83AC3F8, + gUnknown_83AC4F8 +}; + +static const u16 gUnknown_83AC608[] = INCBIN_U16("graphics/tileset_anims/aim_6_0.bin"); +static const u16 gUnknown_83AC6E8[] = INCBIN_U16("graphics/tileset_anims/aim_6_1.bin"); + +static const u16 *const gUnknown_83AC7C8[] = { + gUnknown_83AC608, + gUnknown_83AC6E8 +}; + +static const u16 gUnknown_83AC7D0[] = INCBIN_U16("graphics/tileset_anims/aim_7_0.bin"); +static const u16 gUnknown_83AC850[] = INCBIN_U16("graphics/tileset_anims/aim_7_1.bin"); +static const u16 gUnknown_83AC8D0[] = INCBIN_U16("graphics/tileset_anims/aim_7_2.bin"); + +static const u16 *const gUnknown_83AC950[] = { + gUnknown_83AC7D0, + gUnknown_83AC850, + gUnknown_83AC8D0, + gUnknown_83AC850 +}; static void ResetTilesetAnimBuffer(void) { -- cgit v1.2.3 From 96f793f696ee96632df69a86943ecc884c1d70ad Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 21 Nov 2019 09:48:20 -0500 Subject: Minor refactor of tileset_anims --- src/tileset_anims.c | 36 +++++++++--------------------------- 1 file changed, 9 insertions(+), 27 deletions(-) (limited to 'src') diff --git a/src/tileset_anims.c b/src/tileset_anims.c index 9403bc1df..4fdb1e6bf 100644 --- a/src/tileset_anims.c +++ b/src/tileset_anims.c @@ -209,26 +209,17 @@ static void _InitSecondaryTilesetAnimation(void) static void sub_80700A4(u16 timer) { - const u16 *const *ptr = gUnknown_83A7660; - u16 i = timer % 5; - - AppendTilesetAnimToBuffer(ptr[i], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(508)), 0x80); + AppendTilesetAnimToBuffer(gUnknown_83A7660[timer % NELEMS(gUnknown_83A7660)], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(508)), 0x80); } static void sub_80700D0(u16 timer) { - const u16 *const *ptr = gUnknown_83AA654; - u16 i = timer % 8; - - AppendTilesetAnimToBuffer(ptr[i], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(416)), 0x600); + AppendTilesetAnimToBuffer(gUnknown_83AA654[timer % NELEMS(gUnknown_83AA654)], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(416)), 0x600); } static void sub_80700F8(u16 timer) { - const u16 *const *ptr = gUnknown_83AB874; - u16 i = timer % 8; - - AppendTilesetAnimToBuffer(ptr[i], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(464)), 0x240); + AppendTilesetAnimToBuffer(gUnknown_83AB874[timer % NELEMS(gUnknown_83AB874)], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(464)), 0x240); } static void sub_8070120(u16 timer) @@ -250,10 +241,7 @@ void sub_8070154(void) static void sub_807017C(u16 timer) { - const u16 *const *ptr = gUnknown_83ABDB4; - u16 i = timer % 5; - - AppendTilesetAnimToBuffer(ptr[i], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(744)), 0x100); + AppendTilesetAnimToBuffer(gUnknown_83ABDB4[timer % NELEMS(gUnknown_83ABDB4)], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(744)), 0x100); } static void sub_80701AC(u16 timer) @@ -271,10 +259,7 @@ void sub_80701D8(void) static void sub_80701FC(u16 timer) { - const u16 *const *ptr = gUnknown_83AC1E8; - u16 i = timer % 4; - - AppendTilesetAnimToBuffer(ptr[i], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(976)), 0x100); + AppendTilesetAnimToBuffer(gUnknown_83AC1E8[timer % NELEMS(gUnknown_83AC1E8)], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(976)), 0x100); } static void sub_8070224(u16 timer) @@ -292,10 +277,7 @@ void sub_8070250(void) static void sub_8070274(u16 timer) { - const u16 *const *ptr = gUnknown_83AC5F8; - u16 i = timer % 4; - - AppendTilesetAnimToBuffer(ptr[i], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(896)), 0x100); + AppendTilesetAnimToBuffer(gUnknown_83AC5F8[timer % NELEMS(gUnknown_83AC5F8)], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(896)), 0x100); } static void sub_807029C(u16 timer) @@ -313,8 +295,8 @@ void sub_80702B4(void) static void sub_80702DC(u16 timer) { - u16 i = timer % 2; - + u16 i = timer % NELEMS(gUnknown_83AC7C8); + AppendTilesetAnimToBuffer(gUnknown_83AC7C8[i], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(880)), 0xE0); } @@ -333,7 +315,7 @@ void sub_807031C(void) static void sub_8070340(u16 timer) { - u16 i = timer % 4; + u16 i = timer % NELEMS(gUnknown_83AC950); AppendTilesetAnimToBuffer(gUnknown_83AC950[i], (u16 *)(BG_VRAM + TILE_OFFSET_4BPP(739)), 0x80); } -- cgit v1.2.3 From 4596a9c7bba34a879a5af8f116a9d562d03bac5c Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 21 Nov 2019 10:59:22 -0500 Subject: Fix review comments --- src/tileset_anims.c | 78 ++++++++++++++++++++++++++--------------------------- 1 file changed, 39 insertions(+), 39 deletions(-) (limited to 'src') diff --git a/src/tileset_anims.c b/src/tileset_anims.c index 4fdb1e6bf..a8539a5d8 100644 --- a/src/tileset_anims.c +++ b/src/tileset_anims.c @@ -23,11 +23,11 @@ static void (*sSecondaryTilesetAnimCallback)(u16); static void _InitPrimaryTilesetAnimation(void); static void _InitSecondaryTilesetAnimation(void); -static const u16 gUnknown_83A73E0[] = INCBIN_U16("graphics/tileset_anims/aim_0_0.bin"); -static const u16 gUnknown_83A7460[] = INCBIN_U16("graphics/tileset_anims/aim_0_1.bin"); -static const u16 gUnknown_83A74E0[] = INCBIN_U16("graphics/tileset_anims/aim_0_2.bin"); -static const u16 gUnknown_83A7560[] = INCBIN_U16("graphics/tileset_anims/aim_0_3.bin"); -static const u16 gUnknown_83A75E0[] = INCBIN_U16("graphics/tileset_anims/aim_0_4.bin"); +static const u16 gUnknown_83A73E0[] = INCBIN_U16("graphics/tileset_anims/anim_0_0.bin"); +static const u16 gUnknown_83A7460[] = INCBIN_U16("graphics/tileset_anims/anim_0_1.bin"); +static const u16 gUnknown_83A74E0[] = INCBIN_U16("graphics/tileset_anims/anim_0_2.bin"); +static const u16 gUnknown_83A7560[] = INCBIN_U16("graphics/tileset_anims/anim_0_3.bin"); +static const u16 gUnknown_83A75E0[] = INCBIN_U16("graphics/tileset_anims/anim_0_4.bin"); static const u16 *const gUnknown_83A7660[] = { gUnknown_83A73E0, @@ -37,14 +37,14 @@ static const u16 *const gUnknown_83A7660[] = { gUnknown_83A75E0 }; -static const u16 gUnknown_83A7674[] = INCBIN_U16("graphics/tileset_anims/aim_1_0.bin"); -static const u16 gUnknown_83A7C74[] = INCBIN_U16("graphics/tileset_anims/aim_1_1.bin"); -static const u16 gUnknown_83A8274[] = INCBIN_U16("graphics/tileset_anims/aim_1_2.bin"); -static const u16 gUnknown_83A8874[] = INCBIN_U16("graphics/tileset_anims/aim_1_3.bin"); -static const u16 gUnknown_83A8E74[] = INCBIN_U16("graphics/tileset_anims/aim_1_4.bin"); -static const u16 gUnknown_83A9474[] = INCBIN_U16("graphics/tileset_anims/aim_1_5.bin"); -static const u16 gUnknown_83A9A74[] = INCBIN_U16("graphics/tileset_anims/aim_1_6.bin"); -static const u16 gUnknown_83AA074[] = INCBIN_U16("graphics/tileset_anims/aim_1_7.bin"); +static const u16 gUnknown_83A7674[] = INCBIN_U16("graphics/tileset_anims/anim_1_0.bin"); +static const u16 gUnknown_83A7C74[] = INCBIN_U16("graphics/tileset_anims/anim_1_1.bin"); +static const u16 gUnknown_83A8274[] = INCBIN_U16("graphics/tileset_anims/anim_1_2.bin"); +static const u16 gUnknown_83A8874[] = INCBIN_U16("graphics/tileset_anims/anim_1_3.bin"); +static const u16 gUnknown_83A8E74[] = INCBIN_U16("graphics/tileset_anims/anim_1_4.bin"); +static const u16 gUnknown_83A9474[] = INCBIN_U16("graphics/tileset_anims/anim_1_5.bin"); +static const u16 gUnknown_83A9A74[] = INCBIN_U16("graphics/tileset_anims/anim_1_6.bin"); +static const u16 gUnknown_83AA074[] = INCBIN_U16("graphics/tileset_anims/anim_1_7.bin"); static const u16 *const gUnknown_83AA654[] = { gUnknown_83A7674, @@ -57,14 +57,14 @@ static const u16 *const gUnknown_83AA654[] = { gUnknown_83AA074 }; -static const u16 gUnknown_83AA674[] = INCBIN_U16("graphics/tileset_anims/aim_2_0.bin"); -static const u16 gUnknown_83AA8B4[] = INCBIN_U16("graphics/tileset_anims/aim_2_1.bin"); -static const u16 gUnknown_83AAAF4[] = INCBIN_U16("graphics/tileset_anims/aim_2_2.bin"); -static const u16 gUnknown_83AAD34[] = INCBIN_U16("graphics/tileset_anims/aim_2_3.bin"); -static const u16 gUnknown_83AAF74[] = INCBIN_U16("graphics/tileset_anims/aim_2_4.bin"); -static const u16 gUnknown_83AB1B4[] = INCBIN_U16("graphics/tileset_anims/aim_2_5.bin"); -static const u16 gUnknown_83AB3F4[] = INCBIN_U16("graphics/tileset_anims/aim_2_6.bin"); -static const u16 gUnknown_83AB634[] = INCBIN_U16("graphics/tileset_anims/aim_2_7.bin"); +static const u16 gUnknown_83AA674[] = INCBIN_U16("graphics/tileset_anims/anim_2_0.bin"); +static const u16 gUnknown_83AA8B4[] = INCBIN_U16("graphics/tileset_anims/anim_2_1.bin"); +static const u16 gUnknown_83AAAF4[] = INCBIN_U16("graphics/tileset_anims/anim_2_2.bin"); +static const u16 gUnknown_83AAD34[] = INCBIN_U16("graphics/tileset_anims/anim_2_3.bin"); +static const u16 gUnknown_83AAF74[] = INCBIN_U16("graphics/tileset_anims/anim_2_4.bin"); +static const u16 gUnknown_83AB1B4[] = INCBIN_U16("graphics/tileset_anims/anim_2_5.bin"); +static const u16 gUnknown_83AB3F4[] = INCBIN_U16("graphics/tileset_anims/anim_2_6.bin"); +static const u16 gUnknown_83AB634[] = INCBIN_U16("graphics/tileset_anims/anim_2_7.bin"); static const u16 *const gUnknown_83AB874[] = { gUnknown_83AA674, @@ -77,11 +77,11 @@ static const u16 *const gUnknown_83AB874[] = { gUnknown_83AB634 }; -static const u16 gUnknown_83AB894[] = INCBIN_U16("graphics/tileset_anims/aim_3_0.bin"); -static const u16 gUnknown_83AB994[] = INCBIN_U16("graphics/tileset_anims/aim_3_1.bin"); -static const u16 gUnknown_83ABA94[] = INCBIN_U16("graphics/tileset_anims/aim_3_2.bin"); -static const u16 gUnknown_83ABB94[] = INCBIN_U16("graphics/tileset_anims/aim_3_3.bin"); -static const u16 gUnknown_83ABC94[] = INCBIN_U16("graphics/tileset_anims/aim_3_4.bin"); +static const u16 gUnknown_83AB894[] = INCBIN_U16("graphics/tileset_anims/anim_3_0.bin"); +static const u16 gUnknown_83AB994[] = INCBIN_U16("graphics/tileset_anims/anim_3_1.bin"); +static const u16 gUnknown_83ABA94[] = INCBIN_U16("graphics/tileset_anims/anim_3_2.bin"); +static const u16 gUnknown_83ABB94[] = INCBIN_U16("graphics/tileset_anims/anim_3_3.bin"); +static const u16 gUnknown_83ABC94[] = INCBIN_U16("graphics/tileset_anims/anim_3_4.bin"); static const u16 gUnknown_83ABD94[16] = {}; static const u16 *const gUnknown_83ABDB4[] = { @@ -92,10 +92,10 @@ static const u16 *const gUnknown_83ABDB4[] = { gUnknown_83ABC94 }; -static const u16 gUnknown_83ABDC8[] = INCBIN_U16("graphics/tileset_anims/aim_4_0.bin"); -static const u16 gUnknown_83ABEC8[] = INCBIN_U16("graphics/tileset_anims/aim_4_1.bin"); -static const u16 gUnknown_83ABFC8[] = INCBIN_U16("graphics/tileset_anims/aim_4_2.bin"); -static const u16 gUnknown_83AC0C8[] = INCBIN_U16("graphics/tileset_anims/aim_4_3.bin"); +static const u16 gUnknown_83ABDC8[] = INCBIN_U16("graphics/tileset_anims/anim_4_0.bin"); +static const u16 gUnknown_83ABEC8[] = INCBIN_U16("graphics/tileset_anims/anim_4_1.bin"); +static const u16 gUnknown_83ABFC8[] = INCBIN_U16("graphics/tileset_anims/anim_4_2.bin"); +static const u16 gUnknown_83AC0C8[] = INCBIN_U16("graphics/tileset_anims/anim_4_3.bin"); static const u16 gUnknown_83AC1C8[0x10] = {}; static const u16 *const gUnknown_83AC1E8[] = { @@ -105,10 +105,10 @@ static const u16 *const gUnknown_83AC1E8[] = { gUnknown_83AC0C8 }; -static const u16 gUnknown_83AC1F8[] = INCBIN_U16("graphics/tileset_anims/aim_5_0.bin"); -static const u16 gUnknown_83AC2F8[] = INCBIN_U16("graphics/tileset_anims/aim_5_1.bin"); -static const u16 gUnknown_83AC3F8[] = INCBIN_U16("graphics/tileset_anims/aim_5_2.bin"); -static const u16 gUnknown_83AC4F8[] = INCBIN_U16("graphics/tileset_anims/aim_5_3.bin"); +static const u16 gUnknown_83AC1F8[] = INCBIN_U16("graphics/tileset_anims/anim_5_0.bin"); +static const u16 gUnknown_83AC2F8[] = INCBIN_U16("graphics/tileset_anims/anim_5_1.bin"); +static const u16 gUnknown_83AC3F8[] = INCBIN_U16("graphics/tileset_anims/anim_5_2.bin"); +static const u16 gUnknown_83AC4F8[] = INCBIN_U16("graphics/tileset_anims/anim_5_3.bin"); static const u16 *const gUnknown_83AC5F8[] = { gUnknown_83AC1F8, @@ -117,17 +117,17 @@ static const u16 *const gUnknown_83AC5F8[] = { gUnknown_83AC4F8 }; -static const u16 gUnknown_83AC608[] = INCBIN_U16("graphics/tileset_anims/aim_6_0.bin"); -static const u16 gUnknown_83AC6E8[] = INCBIN_U16("graphics/tileset_anims/aim_6_1.bin"); +static const u16 gUnknown_83AC608[] = INCBIN_U16("graphics/tileset_anims/anim_6_0.bin"); +static const u16 gUnknown_83AC6E8[] = INCBIN_U16("graphics/tileset_anims/anim_6_1.bin"); static const u16 *const gUnknown_83AC7C8[] = { gUnknown_83AC608, gUnknown_83AC6E8 }; -static const u16 gUnknown_83AC7D0[] = INCBIN_U16("graphics/tileset_anims/aim_7_0.bin"); -static const u16 gUnknown_83AC850[] = INCBIN_U16("graphics/tileset_anims/aim_7_1.bin"); -static const u16 gUnknown_83AC8D0[] = INCBIN_U16("graphics/tileset_anims/aim_7_2.bin"); +static const u16 gUnknown_83AC7D0[] = INCBIN_U16("graphics/tileset_anims/anim_7_0.bin"); +static const u16 gUnknown_83AC850[] = INCBIN_U16("graphics/tileset_anims/anim_7_1.bin"); +static const u16 gUnknown_83AC8D0[] = INCBIN_U16("graphics/tileset_anims/anim_7_2.bin"); static const u16 *const gUnknown_83AC950[] = { gUnknown_83AC7D0, -- cgit v1.2.3 From 622fcd2cb95401d99c27820bebbc5141a12e0b49 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Wed, 20 Nov 2019 11:23:34 +0800 Subject: document some symbols --- src/battle_controller_oak_old_man.c | 10 +++---- src/battle_controller_player.c | 10 +++---- src/battle_controller_pokedude.c | 10 +++---- src/battle_controllers.c | 6 ++-- src/battle_gfx_sfx_util.c | 2 +- src/battle_main.c | 38 ++++++++++++------------- src/battle_script_commands.c | 4 +-- src/berry_pouch.c | 4 +-- src/daycare.c | 2 +- src/field_fadetransition.c | 2 +- src/field_poison.c | 4 +-- src/field_specials.c | 4 +-- src/fieldmap.c | 2 +- src/fldeff_softboiled.c | 56 ++++++++++++++++++------------------- src/fldeff_sweetscent.c | 2 +- src/item_pc.c | 4 +-- src/item_use.c | 26 ++++++++--------- src/map_preview_screen.c | 2 +- src/player_pc.c | 8 +++--- src/quest_log.c | 24 ++++++++-------- src/roamer.c | 2 +- src/save_menu_util.c | 2 +- src/tm_case.c | 10 +++---- src/trade.c | 18 ++++++------ src/wild_pokemon_area.c | 2 +- 25 files changed, 127 insertions(+), 127 deletions(-) (limited to 'src') diff --git a/src/battle_controller_oak_old_man.c b/src/battle_controller_oak_old_man.c index a6730cbbb..da8530c72 100644 --- a/src/battle_controller_oak_old_man.c +++ b/src/battle_controller_oak_old_man.c @@ -355,7 +355,7 @@ static void OpenPartyMenuToChooseMon(void) caseId = gTasks[gUnknown_3004FFC[gActiveBattler]].data[0]; DestroyTask(gUnknown_3004FFC[gActiveBattler]); FreeAllWindowBuffers(); - OpenPartyMenuInBattle(caseId); + OpenPartyMenuInTutorialBattle(caseId); } } @@ -363,8 +363,8 @@ static void WaitForMonSelection(void) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { - if (gUnknown_203B0C0 == 1) - BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gUnknown_203B0DC); + if (gPartyMenuUseExitCallback == 1) + BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gBattlePartyCurrentOrder); else BtlController_EmitChosenMonReturnValue(1, 6, NULL); OakOldManBufferExecCompleted(); @@ -1879,7 +1879,7 @@ static void OakOldManHandleChooseItem(void) gBattlerControllerFuncs[gActiveBattler] = OpenBagAndChooseItem; gBattlerInMenuId = gActiveBattler; for (i = 0; i < 3; ++i) - gUnknown_203B0DC[i] = gBattleBufferA[gActiveBattler][i + 1]; + gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][i + 1]; } static void OakOldManHandleChoosePokemon(void) @@ -1892,7 +1892,7 @@ static void OakOldManHandleChoosePokemon(void) *(&gBattleStruct->field_8B) = gBattleBufferA[gActiveBattler][2]; *(&gBattleStruct->abilityPreventingSwitchout) = gBattleBufferA[gActiveBattler][3]; for (i = 0; i < 3; ++i) - gUnknown_203B0DC[i] = gBattleBufferA[gActiveBattler][4 + i]; + gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][4 + i]; BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK); gBattlerControllerFuncs[gActiveBattler] = OpenPartyMenuToChooseMon; gBattlerInMenuId = gActiveBattler; diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index 16bf1ec87..41d81052e 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -1305,7 +1305,7 @@ static void OpenPartyMenuToChooseMon(void) caseId = gTasks[gUnknown_3004FFC[gActiveBattler]].data[0]; DestroyTask(gUnknown_3004FFC[gActiveBattler]); FreeAllWindowBuffers(); - OpenPartyMenuInBattle(caseId); + OpenPartyMenuInTutorialBattle(caseId); } } @@ -1313,8 +1313,8 @@ static void WaitForMonSelection(void) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { - if (gUnknown_203B0C0 == 1) - BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gUnknown_203B0DC); + if (gPartyMenuUseExitCallback == 1) + BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gBattlePartyCurrentOrder); else BtlController_EmitChosenMonReturnValue(1, 6, NULL); if ((gBattleBufferA[gActiveBattler][1] & 0xF) == 1) @@ -2462,7 +2462,7 @@ static void PlayerHandleChooseItem(void) gBattlerControllerFuncs[gActiveBattler] = OpenBagAndChooseItem; gBattlerInMenuId = gActiveBattler; for (i = 0; i < 3; ++i) - gUnknown_203B0DC[i] = gBattleBufferA[gActiveBattler][1 + i]; + gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][1 + i]; } static void PlayerHandleChoosePokemon(void) @@ -2475,7 +2475,7 @@ static void PlayerHandleChoosePokemon(void) *(&gBattleStruct->field_8B) = gBattleBufferA[gActiveBattler][2]; *(&gBattleStruct->abilityPreventingSwitchout) = gBattleBufferA[gActiveBattler][3]; for (i = 0; i < 3; ++i) - gUnknown_203B0DC[i] = gBattleBufferA[gActiveBattler][4 + i]; + gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][4 + i]; BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK); gBattlerControllerFuncs[gActiveBattler] = OpenPartyMenuToChooseMon; gBattlerInMenuId = gActiveBattler; diff --git a/src/battle_controller_pokedude.c b/src/battle_controller_pokedude.c index 57a405f3c..59fda163b 100644 --- a/src/battle_controller_pokedude.c +++ b/src/battle_controller_pokedude.c @@ -706,7 +706,7 @@ static void OpenPartyMenuToChooseMon(void) gBattlerControllerFuncs[gActiveBattler] = WaitForMonSelection; DestroyTask(gUnknown_3004FFC[gActiveBattler]); FreeAllWindowBuffers(); - sub_8127968(); + OpenPartyMenuInBattle(); } } @@ -714,8 +714,8 @@ static void WaitForMonSelection(void) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { - if (gUnknown_203B0C0 == 1) - BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gUnknown_203B0DC); + if (gPartyMenuUseExitCallback == 1) + BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gBattlePartyCurrentOrder); else BtlController_EmitChosenMonReturnValue(1, 6, NULL); PokedudeBufferExecCompleted(); @@ -1985,7 +1985,7 @@ static void PokedudeHandleChooseItem(void) gBattlerControllerFuncs[gActiveBattler] = OpenBagAndChooseItem; gBattlerInMenuId = gActiveBattler; for (i = 0; i < 3; ++i) - gUnknown_203B0DC[i] = gBattleBufferA[gActiveBattler][i + 1]; + gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][i + 1]; } static void PokedudeHandleChoosePokemon(void) @@ -1998,7 +1998,7 @@ static void PokedudeHandleChoosePokemon(void) *(&gBattleStruct->field_8B) = gBattleBufferA[gActiveBattler][2]; *(&gBattleStruct->abilityPreventingSwitchout) = gBattleBufferA[gActiveBattler][3]; for (i = 0; i < 3; ++i) - gUnknown_203B0DC[i] = gBattleBufferA[gActiveBattler][4 + i]; + gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][4 + i]; BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK); gBattlerControllerFuncs[gActiveBattler] = OpenPartyMenuToChooseMon; gBattlerInMenuId = gActiveBattler; diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 6fb090307..ca2ef0b22 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -75,7 +75,7 @@ void sub_800D30C(void) SetBattlePartyIds(); if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI)) for (i = 0; i < gBattlersCount; ++i) - sub_8127DA8(i, 0); + BufferBattlePartyCurrentOrderBySide(i, 0); } static void InitSinglePlayerBtlControllers(void) @@ -199,11 +199,11 @@ static void InitLinkBtlControllers(void) { case 0: case 3: - sub_8127DA8(gLinkPlayers[i].id, 0); + BufferBattlePartyCurrentOrderBySide(gLinkPlayers[i].id, 0); break; case 1: case 2: - sub_8127DA8(gLinkPlayers[i].id, 1); + BufferBattlePartyCurrentOrderBySide(gLinkPlayers[i].id, 1); break; } if (i == multiplayerId) diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c index d2e728d0c..55d413b3b 100644 --- a/src/battle_gfx_sfx_util.c +++ b/src/battle_gfx_sfx_util.c @@ -620,7 +620,7 @@ bool8 BattleInitAllSprites(u8 *state, u8 *battlerId) break; case 6: LoadAndCreateEnemyShadowSprites(); - sub_8127CAC(); + BufferBattlePartyCurrentOrder(); retVal = TRUE; break; } diff --git a/src/battle_main.c b/src/battle_main.c index 1125a8d2d..da9bc1a49 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -144,7 +144,7 @@ static EWRAM_DATA u32 gUnknown_2022AE8[25] = {0}; EWRAM_DATA u32 gBattleTypeFlags = 0; EWRAM_DATA u8 gBattleTerrain = 0; EWRAM_DATA u32 gUnknown_2022B54 = 0; -EWRAM_DATA struct UnknownPokemonStruct4 gUnknown_2022B58[3] = {0}; +EWRAM_DATA struct UnknownPokemonStruct4 gMultiPartnerParty[3] = {0}; EWRAM_DATA u8 *gUnknown_2022BB8 = NULL; EWRAM_DATA u8 *gUnknown_2022BBC = NULL; EWRAM_DATA u16 *gUnknown_2022BC0 = NULL; @@ -1078,16 +1078,16 @@ static void sub_80108C4(void) for (i = 0; i < 3; ++i) { - gUnknown_2022B58[i].species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES); - gUnknown_2022B58[i].heldItem = GetMonData(&gPlayerParty[i], MON_DATA_HELD_ITEM); - nick = gUnknown_2022B58[i].nickname; + gMultiPartnerParty[i].species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES); + gMultiPartnerParty[i].heldItem = GetMonData(&gPlayerParty[i], MON_DATA_HELD_ITEM); + nick = gMultiPartnerParty[i].nickname; GetMonData(&gPlayerParty[i], MON_DATA_NICKNAME, nick); - gUnknown_2022B58[i].level = GetMonData(&gPlayerParty[i], MON_DATA_LEVEL); - gUnknown_2022B58[i].hp = GetMonData(&gPlayerParty[i], MON_DATA_HP); - gUnknown_2022B58[i].maxhp = GetMonData(&gPlayerParty[i], MON_DATA_MAX_HP); - gUnknown_2022B58[i].status = GetMonData(&gPlayerParty[i], MON_DATA_STATUS); - gUnknown_2022B58[i].personality = GetMonData(&gPlayerParty[i], MON_DATA_PERSONALITY); - gUnknown_2022B58[i].gender = GetMonGender(&gPlayerParty[i]); + gMultiPartnerParty[i].level = GetMonData(&gPlayerParty[i], MON_DATA_LEVEL); + gMultiPartnerParty[i].hp = GetMonData(&gPlayerParty[i], MON_DATA_HP); + gMultiPartnerParty[i].maxhp = GetMonData(&gPlayerParty[i], MON_DATA_MAX_HP); + gMultiPartnerParty[i].status = GetMonData(&gPlayerParty[i], MON_DATA_STATUS); + gMultiPartnerParty[i].personality = GetMonData(&gPlayerParty[i], MON_DATA_PERSONALITY); + gMultiPartnerParty[i].gender = GetMonGender(&gPlayerParty[i]); StripExtCtrlCodes(nick); if (GetMonData(&gPlayerParty[i], MON_DATA_LANGUAGE) != LANGUAGE_JAPANESE) { @@ -1098,7 +1098,7 @@ static void sub_80108C4(void) cur[j] = EOS; } } - memcpy(&gBattleStruct->field_184, gUnknown_2022B58, sizeof(gUnknown_2022B58)); + memcpy(&gBattleStruct->field_184, gMultiPartnerParty, sizeof(gMultiPartnerParty)); } static void CB2_PreInitMultiBattle(void) @@ -1123,7 +1123,7 @@ static void CB2_PreInitMultiBattle(void) if (gReceivedRemoteLinkPlayers != 0 && IsLinkTaskFinished()) { sub_80108C4(); - SendBlock(bitmask_all_link_players_but_self(), &gBattleStruct->field_184, sizeof(gUnknown_2022B58)); + SendBlock(bitmask_all_link_players_but_self(), &gBattleStruct->field_184, sizeof(gMultiPartnerParty)); ++gBattleCommunication[MULTIUSE_STATE]; } break; @@ -1137,13 +1137,13 @@ static void CB2_PreInitMultiBattle(void) continue; if ((!(gLinkPlayers[i].id & 1) && !(gLinkPlayers[playerMultiplierId].id & 1)) || (gLinkPlayers[i].id & 1 && gLinkPlayers[playerMultiplierId].id & 1)) - memcpy(gUnknown_2022B58, gBlockRecvBuffer[i], sizeof(gUnknown_2022B58)); + memcpy(gMultiPartnerParty, gBlockRecvBuffer[i], sizeof(gMultiPartnerParty)); } ++gBattleCommunication[MULTIUSE_STATE]; *savedCallback = gMain.savedCallback; *savedBattleTypeFlags = gBattleTypeFlags; gMain.savedCallback = CB2_PreInitMultiBattle; - sub_8128198(); + ShowPartyMenuToShowcaseMultiBattleParty(); } break; case 2: @@ -3004,22 +3004,22 @@ void sub_8013F6C(u8 battler) u8 r4, r1; for (i = 0; i < 3; ++i) - gUnknown_203B0DC[i] = *(battler * 3 + i + (u8 *)(gBattleStruct->field_60)); + gBattlePartyCurrentOrder[i] = *(battler * 3 + i + (u8 *)(gBattleStruct->field_60)); r4 = pokemon_order_func(gBattlerPartyIndexes[battler]); r1 = pokemon_order_func(*(gBattleStruct->monToSwitchIntoId + battler)); - sub_8127FF4(r4, r1); + SwitchPartyMonSlots(r4, r1); if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { for (i = 0; i < 3; ++i) { - *(battler * 3 + i + (u8 *)(gBattleStruct->field_60)) = gUnknown_203B0DC[i]; - *(BATTLE_PARTNER(battler) * 3 + i + (u8 *)(gBattleStruct->field_60)) = gUnknown_203B0DC[i]; + *(battler * 3 + i + (u8 *)(gBattleStruct->field_60)) = gBattlePartyCurrentOrder[i]; + *(BATTLE_PARTNER(battler) * 3 + i + (u8 *)(gBattleStruct->field_60)) = gBattlePartyCurrentOrder[i]; } } else { for (i = 0; i < 3; ++i) - *(battler * 3 + i + (u8 *)(gBattleStruct->field_60)) = gUnknown_203B0DC[i]; + *(battler * 3 + i + (u8 *)(gBattleStruct->field_60)) = gBattlePartyCurrentOrder[i]; } } diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index 8a0e32ba8..c568d96f9 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -7140,8 +7140,8 @@ static void atk8F_forcerandomswitch(void) *(gBattleStruct->monToSwitchIntoId + gBattlerTarget) = i; if (!IsMultiBattle()) sub_8013F6C(gBattlerTarget); - sub_8127EC4(gBattlerTarget, i, 0); - sub_8127EC4(gBattlerTarget ^ 2, i, 1); + SwitchPartyOrderLinkMulti(gBattlerTarget, i, 0); + SwitchPartyOrderLinkMulti(gBattlerTarget ^ 2, i, 1); } } else diff --git a/src/berry_pouch.c b/src/berry_pouch.c index b8b66c0bc..466fe7927 100644 --- a/src/berry_pouch.c +++ b/src/berry_pouch.c @@ -1194,7 +1194,7 @@ static void Task_BerryPouch_Give(u8 taskId) Task_Give_PrintThereIsNoPokemon(taskId); else { - sResources->exitCallback = sub_8126EDC; + sResources->exitCallback = CB2_ChooseMonToGiveItem; gTasks[taskId].func = BerryPouch_StartFadeToExitCallback; } } @@ -1251,7 +1251,7 @@ static void Task_ContextMenu_FromPartyGiveMenu(u8 taskId) } else { - sResources->exitCallback = c2_8123744; + sResources->exitCallback = CB2_GiveHoldItem; gTasks[taskId].func = BerryPouch_StartFadeToExitCallback; } } diff --git a/src/daycare.c b/src/daycare.c index f034bc220..8862dfda9 100644 --- a/src/daycare.c +++ b/src/daycare.c @@ -1582,7 +1582,7 @@ void ShowDaycareLevelMenu(void) void ChooseSendDaycareMon(void) { - sub_8128370(); + ChooseMonForDaycare(); gMain.savedCallback = CB2_ReturnToField; } diff --git a/src/field_fadetransition.c b/src/field_fadetransition.c index 58caad509..d6bf4ea07 100644 --- a/src/field_fadetransition.c +++ b/src/field_fadetransition.c @@ -522,7 +522,7 @@ static bool32 sub_807E40C(void) bool32 sub_807E418(void) { - if (field_weather_is_fade_finished() == TRUE && sub_80F83B0()) + if (IsWeatherNotFadingIn() == TRUE && sub_80F83B0()) return TRUE; else return FALSE; diff --git a/src/field_poison.c b/src/field_poison.c index 474fbcd69..07c2b763f 100644 --- a/src/field_poison.c +++ b/src/field_poison.c @@ -43,7 +43,7 @@ static void FaintFromFieldPoison(u8 partyIdx) static bool32 MonFaintedFromPoison(u8 partyIdx) { struct Pokemon *pokemon = gPlayerParty + partyIdx; - if (IsMonValidSpecies(pokemon) && !GetMonData(pokemon, MON_DATA_HP) && pokemon_ailments_get_primary(GetMonData(pokemon, MON_DATA_STATUS)) == AILMENT_PSN) + if (IsMonValidSpecies(pokemon) && !GetMonData(pokemon, MON_DATA_HP) && GetAilmentFromStatus(GetMonData(pokemon, MON_DATA_STATUS)) == AILMENT_PSN) return TRUE; return FALSE; } @@ -97,7 +97,7 @@ s32 DoPoisonFieldEffect(void) u32 numFainted = 0; for (i = 0; i < PARTY_SIZE; i++) { - if (GetMonData(pokemon, MON_DATA_SANITY_HAS_SPECIES) && pokemon_ailments_get_primary(GetMonData(pokemon, MON_DATA_STATUS)) == AILMENT_PSN) + if (GetMonData(pokemon, MON_DATA_SANITY_HAS_SPECIES) && GetAilmentFromStatus(GetMonData(pokemon, MON_DATA_STATUS)) == AILMENT_PSN) { hp = GetMonData(pokemon, MON_DATA_HP); if (hp == 0 || --hp == 0) diff --git a/src/field_specials.c b/src/field_specials.c index 617faa017..374c74f3c 100644 --- a/src/field_specials.c +++ b/src/field_specials.c @@ -1863,7 +1863,7 @@ void sub_80CC59C(void) { if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(ROUTE22) && (gSaveBlock1Ptr->location.mapNum == MAP_NUM(ROUTE22) || gSaveBlock1Ptr->location.mapNum == MAP_NUM(ROUTE23))) { - sp0.unk0 = get_mapheader_by_bank_and_number(sInsideOutsidePairs[r5].grp, sInsideOutsidePairs[r5].num)->regionMapSectionId; + sp0.unk0 = Overworld_GetMapHeaderByGroupAndId(sInsideOutsidePairs[r5].grp, sInsideOutsidePairs[r5].num)->regionMapSectionId; if (gSaveBlock1Ptr->location.mapNum == MAP_NUM(ROUTE22)) sp0.unk1 = r5; else @@ -1875,7 +1875,7 @@ void sub_80CC59C(void) } if (gSaveBlock1Ptr->location.mapGroup == sInsideOutsidePairs[r5].grp2 && gSaveBlock1Ptr->location.mapNum == sInsideOutsidePairs[r5].num2) { - sp0.unk0 = get_mapheader_by_bank_and_number(sInsideOutsidePairs[r5].grp, sInsideOutsidePairs[r5].num)->regionMapSectionId; + sp0.unk0 = Overworld_GetMapHeaderByGroupAndId(sInsideOutsidePairs[r5].grp, sInsideOutsidePairs[r5].num)->regionMapSectionId; sp0.unk1 = r5; if (r5 == 22) { diff --git a/src/fieldmap.c b/src/fieldmap.c index 000b8105b..4244762c0 100644 --- a/src/fieldmap.c +++ b/src/fieldmap.c @@ -60,7 +60,7 @@ const u8 gUnknown_8352F10[] = { const struct MapHeader * mapconnection_get_mapheader(struct MapConnection * connection) { - return get_mapheader_by_bank_and_number(connection->mapGroup, connection->mapNum); + return Overworld_GetMapHeaderByGroupAndId(connection->mapGroup, connection->mapNum); } void not_trainer_hill_battle_pyramid(void) diff --git a/src/fldeff_softboiled.c b/src/fldeff_softboiled.c index 400a1d382..6840df686 100644 --- a/src/fldeff_softboiled.c +++ b/src/fldeff_softboiled.c @@ -13,7 +13,7 @@ static void sub_80E58A0(u8 taskId); static void sub_80E5934(u8 taskId); extern const u8 gUnknown_84169F8[]; -extern const u8 gUnknown_8416F27[]; +extern const u8 gText_PkmnHPRestoredByVar2[]; bool8 hm_prepare_dive_probably(void) { @@ -26,27 +26,27 @@ bool8 hm_prepare_dive_probably(void) return FALSE; } -void sub_80E56DC(u8 taskId) +void ChooseMonForSoftboiled(u8 taskId) { - gUnknown_203B0A0.unkB = 10; - gUnknown_203B0A0.unkA = gUnknown_203B0A0.unk9; - sub_811F818(GetCursorSelectionMonId(), 1); - sub_8121D0C(5); - gTasks[taskId].func = sub_811FB28; + gPartyMenu.unkB = 10; + gPartyMenu.unkA = gPartyMenu.unk9; + AnimatePartySlot(GetCursorSelectionMonId(), 1); + DisplayPartyMenuStdMessage(5); + gTasks[taskId].func = Task_HandleChooseMonInput; } void sub_80E5724(u8 taskId) { - u8 r8 = gUnknown_203B0A0.unk9; - u8 r5 = gUnknown_203B0A0.unkA; + u8 r8 = gPartyMenu.unk9; + u8 r5 = gPartyMenu.unkA; u16 curHp; s16 delta; if (r5 > 6) { - gUnknown_203B0A0.unkB = 0; - sub_8121D0C(0); - gTasks[taskId].func = sub_811FB28; + gPartyMenu.unkB = 0; + DisplayPartyMenuStdMessage(0); + gTasks[taskId].func = Task_HandleChooseMonInput; } else { @@ -58,7 +58,7 @@ void sub_80E5724(u8 taskId) else { PlaySE(SE_KAIFUKU); - sub_8120760(taskId, r8, -1, GetMonData(&gPlayerParty[r8], MON_DATA_MAX_HP) / 5, sub_80E57E8); + PartyMenuModifyHP(taskId, r8, -1, GetMonData(&gPlayerParty[r8], MON_DATA_MAX_HP) / 5, sub_80E57E8); } } } @@ -66,46 +66,46 @@ void sub_80E5724(u8 taskId) static void sub_80E57E8(u8 taskId) { PlaySE(SE_KAIFUKU); - sub_8120760(taskId, gUnknown_203B0A0.unkA, 1, GetMonData(&gPlayerParty[gUnknown_203B0A0.unk9], MON_DATA_MAX_HP) / 5, sub_80E583C); + PartyMenuModifyHP(taskId, gPartyMenu.unkA, 1, GetMonData(&gPlayerParty[gPartyMenu.unk9], MON_DATA_MAX_HP) / 5, sub_80E583C); } static void sub_80E583C(u8 taskId) { - GetMonNickname(&gPlayerParty[gUnknown_203B0A0.unkA], gStringVar1); - StringExpandPlaceholders(gStringVar4, gUnknown_8416F27); - sub_81202F8(gStringVar4, 0); + GetMonNickname(&gPlayerParty[gPartyMenu.unkA], gStringVar1); + StringExpandPlaceholders(gStringVar4, gText_PkmnHPRestoredByVar2); + DisplayPartyMenuMessage(gStringVar4, 0); ScheduleBgCopyTilemapToVram(2); gTasks[taskId].func = sub_80E58A0; } static void sub_80E58A0(u8 taskId) { - if (sub_8120370() != TRUE) + if (IsPartyMenuTextPrinterActive() != TRUE) { - gUnknown_203B0A0.unkB = 0; - sub_811F818(gUnknown_203B0A0.unk9, 0); - gUnknown_203B0A0.unk9 = gUnknown_203B0A0.unkA; - sub_811F818(gUnknown_203B0A0.unkA, 1); + gPartyMenu.unkB = 0; + AnimatePartySlot(gPartyMenu.unk9, 0); + gPartyMenu.unk9 = gPartyMenu.unkA; + AnimatePartySlot(gPartyMenu.unkA, 1); ClearStdWindowAndFrameToTransparent(6, 0); ClearWindowTilemap(6); - sub_8121D0C(0); - gTasks[taskId].func = sub_811FB28; + DisplayPartyMenuStdMessage(0); + gTasks[taskId].func = Task_HandleChooseMonInput; } } static void sub_80E5900(u8 taskId) { - if (sub_8120370() != TRUE) + if (IsPartyMenuTextPrinterActive() != TRUE) { - sub_8121D0C(5); - gTasks[taskId].func = sub_811FB28; + DisplayPartyMenuStdMessage(5); + gTasks[taskId].func = Task_HandleChooseMonInput; } } static void sub_80E5934(u8 taskId) { PlaySE(SE_SELECT); - sub_81202F8(gUnknown_84169F8, 0); + DisplayPartyMenuMessage(gUnknown_84169F8, 0); ScheduleBgCopyTilemapToVram(2); gTasks[taskId].func = sub_80E5900; } diff --git a/src/fldeff_sweetscent.c b/src/fldeff_sweetscent.c index 114bf0b57..c413f29c1 100644 --- a/src/fldeff_sweetscent.c +++ b/src/fldeff_sweetscent.c @@ -20,7 +20,7 @@ static void FailSweetScentEncounter(u8 taskId); static void Unused_StartSweetscentFldeff(void) { - gUnknown_203B0A0.unk9 = 0; + gPartyMenu.unk9 = 0; FieldCallback_SweetScent(); } diff --git a/src/item_pc.c b/src/item_pc.c index 60a74ac59..450e0d142 100644 --- a/src/item_pc.c +++ b/src/item_pc.c @@ -1029,8 +1029,8 @@ static void Task_ItemPcGive(u8 taskId) static void ItemPc_CB2_SwitchToPartyMenu(void) { - PartyMenuInit(0, 0, 6, 0, 6, sub_811FB28, ItemPc_CB2_ReturnFromPartyMenu); - gUnknown_203B0A0.unkC = ItemPc_GetItemIdBySlotId(ItemPc_GetCursorPosition()); + InitPartyMenu(0, 0, 6, 0, 6, Task_HandleChooseMonInput, ItemPc_CB2_ReturnFromPartyMenu); + gPartyMenu.unkC = ItemPc_GetItemIdBySlotId(ItemPc_GetCursorPosition()); } static void ItemPc_CB2_ReturnFromPartyMenu(void) diff --git a/src/item_use.c b/src/item_use.c index db0475370..73ad9a284 100644 --- a/src/item_use.c +++ b/src/item_use.c @@ -133,7 +133,7 @@ static const u8 sUnref_83E27B4[] = { }; void (*const gUnknown_83E2954[])(void) = { - sub_8124C8C, + CB2_ShowPartyMenuForItemUse, CB2_ReturnToField, NULL, NULL @@ -179,7 +179,7 @@ void sub_80A1084(void) void sub_80A109C(u8 taskId) { - if (field_weather_is_fade_finished() == TRUE) + if (IsWeatherNotFadingIn() == TRUE) { sItemUseOnFieldCB(taskId); } @@ -234,7 +234,7 @@ bool8 sub_80A1194(void) void sub_80A11C0(u8 taskId) { - if (field_weather_is_fade_finished() == TRUE) + if (IsWeatherNotFadingIn() == TRUE) { UnfreezeMapObjects(); ScriptContext2_Disable(); @@ -415,37 +415,37 @@ void sub_80A16D0(u8 taskId) void FieldUseFunc_Medicine(u8 taskId) { - gUnknown_3005E98 = sub_81252D0; + gItemUseCB = sub_81252D0; sub_80A16D0(taskId); } void FieldUseFunc_Ether(u8 taskId) { - gUnknown_3005E98 = ItemUseCB_PpRestore; + gItemUseCB = ItemUseCB_PPRecovery; sub_80A16D0(taskId); } void FieldUseFunc_PpUp(u8 taskId) { - gUnknown_3005E98 = dp05_pp_up; + gItemUseCB = ItemUseCB_PPUp; sub_80A16D0(taskId); } void FieldUseFunc_RareCandy(u8 taskId) { - gUnknown_3005E98 = dp05_rare_candy; + gItemUseCB = dp05_rare_candy; sub_80A16D0(taskId); } void FieldUseFunc_EvoItem(u8 taskId) { - gUnknown_3005E98 = sub_8126B60; + gItemUseCB = sub_8126B60; sub_80A16D0(taskId); } void FieldUseFunc_SacredAsh(u8 taskId) { - gUnknown_3005E98 = sub_8126894; + gItemUseCB = ItemUseCB_SacredAsh; sub_80A0FBC(taskId); } @@ -765,7 +765,7 @@ void BattleUseFunc_GuardSpec(u8 taskId) { if (ExecuteTableBasedItemEffect(&gPlayerParty[gBattlerPartyIndexes[gBattlerInMenuId]], gSpecialVar_ItemId, gBattlerPartyIndexes[gBattlerInMenuId], 0)) { - DisplayItemMessageInBag(taskId, 2, gUnknown_84169DC, sub_810A1F8); + DisplayItemMessageInBag(taskId, 2, gText_WontHaveEffect, sub_810A1F8); } else { @@ -812,19 +812,19 @@ void ItemUse_SwitchToPartyMenuInBattle(u8 taskId) void BattleUseFunc_Medicine(u8 taskId) { - gUnknown_3005E98 = ItemUseCB_Medicine; + gItemUseCB = ItemUseCB_Medicine; ItemUse_SwitchToPartyMenuInBattle(taskId); } void sub_80A1FD8(u8 taskId) { - gUnknown_3005E98 = sub_8126894; + gItemUseCB = ItemUseCB_SacredAsh; ItemUse_SwitchToPartyMenuInBattle(taskId); } void BattleUseFunc_Ether(u8 taskId) { - gUnknown_3005E98 = ItemUseCB_PpRestore; + gItemUseCB = ItemUseCB_PPRecovery; ItemUse_SwitchToPartyMenuInBattle(taskId); } diff --git a/src/map_preview_screen.c b/src/map_preview_screen.c index c465a5683..0747e8ade 100644 --- a/src/map_preview_screen.c +++ b/src/map_preview_screen.c @@ -495,7 +495,7 @@ static void sub_80F83D0(u8 taskId) } break; case 2: - if (field_weather_is_fade_finished()) + if (IsWeatherNotFadingIn()) { Overworld_PlaySpecialMapMusic(); data[0]++; diff --git a/src/player_pc.c b/src/player_pc.c index f454cd07f..c3dc81dd2 100644 --- a/src/player_pc.c +++ b/src/player_pc.c @@ -322,7 +322,7 @@ static void Task_DepositItem_WaitFadeAndGoToBag(u8 taskId) if (!gPaletteFade.active) { CleanupOverworldWindowsAndTilemaps(); - sub_8107DB4(3, POCKET_ITEMS - 1, CB2_ReturnToField); + GoToBagMenu(3, POCKET_ITEMS - 1, CB2_ReturnToField); gFieldCallback = CB2_ReturnFromDepositMenu; DestroyTask(taskId); } @@ -336,7 +336,7 @@ static void Task_PlayerPcDepositItem(u8 taskId) static void Task_ReturnToItemStorageSubmenu(u8 taskId) { - if (field_weather_is_fade_finished() == TRUE) + if (IsWeatherNotFadingIn() == TRUE) gTasks[taskId].func = Task_TopMenu_ItemStorageSubmenu_HandleInput; } @@ -573,7 +573,7 @@ static void Task_WaitFadeAndReadSelectedMail(u8 taskId) static void Task_WaitFadeAndReturnToMailboxPcInputHandler(u8 taskId) { - if (field_weather_is_fade_finished() == TRUE) + if (IsWeatherNotFadingIn() == TRUE) gTasks[taskId].func = Task_MailboxPcHandleInput; } @@ -674,7 +674,7 @@ static void Task_WaitFadeAndGoToPartyMenu(u8 taskId) { MailboxPC_DestroyListMenuBuffer(); CleanupOverworldWindowsAndTilemaps(); - PartyMenuInit_FromPlayerPc(); + ChooseMonToGiveMailFromMailbox(); DestroyTask(taskId); } } diff --git a/src/quest_log.c b/src/quest_log.c index d7b544882..9683d7799 100644 --- a/src/quest_log.c +++ b/src/quest_log.c @@ -987,7 +987,7 @@ void sub_8111708(void) gSaveBlock1Ptr->mapDataId = VarGet(VAR_0x40AE); if (gSaveBlock1Ptr->mapDataId == 0) { - sp0 = *get_mapheader_by_bank_and_number(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); + sp0 = *Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); gSaveBlock1Ptr->mapDataId = sp0.mapDataId; } } @@ -1363,7 +1363,7 @@ static void sub_8111FCC(u8 taskId) { if (gUnknown_203AE94.unk_0_6 != 1) { - sub_80C4DF8(gStringVar1, gMapHeader.regionMapSectionId); + GetMapNameGeneric(gStringVar1, gMapHeader.regionMapSectionId); StringExpandPlaceholders(gStringVar4, gUnknown_841B073); sub_8111D10(); } @@ -3166,7 +3166,7 @@ static const u16 *sub_8113FBC(const u16 *a0) StringCopy(gStringVar1, ItemId_GetName(r5[0])); if (r5[0] == ITEM_ESCAPE_ROPE) { - sub_80C4DF8(gStringVar2, r5[2]); + GetMapNameGeneric(gStringVar2, r5[2]); StringExpandPlaceholders(gStringVar4, gUnknown_841AFA6); } else if (r5[1] != 0xFFFF) @@ -3814,7 +3814,7 @@ static const u16 *sub_8114D68(const u16 *a0) a0 = sub_8113E88(30, a0); r6 = (const u8 *)a0 + 6; DynamicPlaceholderTextUtil_Reset(); - sub_80C4DF8(gStringVar1, r6[0]); + GetMapNameGeneric(gStringVar1, r6[0]); DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1); DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, gTrainers[a0[2]].trainerName); QuestLog_AutoGetSpeciesName(a0[0], 0, 2); @@ -3855,7 +3855,7 @@ static const u16 *sub_8114E68(const u16 *a0) r6 = (const u8 *)a0 + 8; DynamicPlaceholderTextUtil_Reset(); - sub_80C4DF8(gStringVar1, r6[2]); + GetMapNameGeneric(gStringVar1, r6[2]); DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1); QuestLog_AutoGetSpeciesName(a0[2], NULL, 1); ConvertIntToDecimalStringN(gStringVar2, r6[0], STR_CONV_MODE_LEFT_ALIGN, 3); @@ -3983,7 +3983,7 @@ static const u16 *sub_81151DC(const u16 *a0) const u16 *r5 = sub_8113E88(34, a0); const u8 *r6 = (const u8 *)r5 + 6; DynamicPlaceholderTextUtil_Reset(); - sub_80C4DF8(gStringVar1, r6[0]); + GetMapNameGeneric(gStringVar1, r6[0]); DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1); if ( gTrainers[r5[2]].trainerClass == 0x51 @@ -4164,7 +4164,7 @@ static const u16 *sub_81152BC(const u16 *a0) const u16 *r5 = sub_8113E88(35, a0); const u8 *r5_2 = (const u8 *)r5 + 0; r6 = r5_2[1]; - sub_80C4DF8(gStringVar1, r5_2[0]); + GetMapNameGeneric(gStringVar1, r5_2[0]); StringCopy(gStringVar2, gUnknown_8456AF0[r6]); if (gUnknown_8456BE4[r6] == 5) { @@ -4238,7 +4238,7 @@ static const u16 *sub_8115460(const u16 *a0) const u8 *r5 = (const u8 *)r4 + 2; QuestLog_AutoGetSpeciesName(r4[0], gStringVar1, 0); if (r5[1] != 0xFF) - sub_80C4DF8(gStringVar2, r5[1]); + GetMapNameGeneric(gStringVar2, r5[1]); if (r5[0] == 7) { if (r5[1] == 0x58) @@ -4270,7 +4270,7 @@ static const u16 *sub_8115518(const u16 *a0) const u8 *r7 = (const u8 *)r4 + 8; u32 r6 = (r4[2] << 16) + r4[3]; DynamicPlaceholderTextUtil_Reset(); - sub_80C4DF8(gStringVar1, r7[0]); + GetMapNameGeneric(gStringVar1, r7[0]); DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1); DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, ItemId_GetName(r4[0])); if (r4[1] < 2) @@ -4303,7 +4303,7 @@ static const u16 *sub_81155E0(const u16 *a0) { const u8 *r7 = (const u8 *) r5 + 8; u32 r6 = (r5[2] << 16) + r5[3]; DynamicPlaceholderTextUtil_Reset(); - sub_80C4DF8(gStringVar1, r7[0]); + GetMapNameGeneric(gStringVar1, r7[0]); if (r7[1] == 0) { DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gSaveBlock2Ptr->playerName); DynamicPlaceholderTextUtil_SetPlaceholderPtr(1, gStringVar1); @@ -4344,7 +4344,7 @@ static const u16 *sub_8115700(const u16 *a0) { const u16 *r4 = sub_8113E88(40, a0); const u8 *r5 = (const u8 *)r4 + 2; - sub_80C4DF8(gStringVar1, r5[0]); + GetMapNameGeneric(gStringVar1, r5[0]); StringCopy(gStringVar2, ItemId_GetName(r4[0])); StringExpandPlaceholders(gStringVar4, gUnknown_841B03F); return (const u16 *)(r5 + 2); @@ -4420,7 +4420,7 @@ static u16 *sub_81157DC(u16 *a0, const u16 *a1) static const u16 *sub_8115800(const u16 *a0) { const u16 *r4 = sub_8113E88(42, a0); - sub_80C4DF8(gStringVar1, r4[0]); + GetMapNameGeneric(gStringVar1, r4[0]); StringExpandPlaceholders(gStringVar4, gUnknown_841B064); return r4 + 1; } diff --git a/src/roamer.c b/src/roamer.c index b42855644..b3cc67f85 100644 --- a/src/roamer.c +++ b/src/roamer.c @@ -236,5 +236,5 @@ u16 GetRoamerLocationMapSectionId(void) struct Roamer *roamer = &saveRoamer; if (!saveRoamer.active) return MAPSEC_NONE; - return get_mapheader_by_bank_and_number(sRoamerLocation[MAP_GRP], sRoamerLocation[MAP_NUM])->regionMapSectionId; + return Overworld_GetMapHeaderByGroupAndId(sRoamerLocation[MAP_GRP], sRoamerLocation[MAP_NUM])->regionMapSectionId; } diff --git a/src/save_menu_util.c b/src/save_menu_util.c index 195b29b0c..54073785e 100644 --- a/src/save_menu_util.c +++ b/src/save_menu_util.c @@ -41,7 +41,7 @@ void SaveStatToString(u8 gameStatId, u8 *dest0, u8 color) dest = ConvertIntToDecimalStringN(dest, gSaveBlock2Ptr->playTimeMinutes, STR_CONV_MODE_LEADING_ZEROS, 2); break; case SAVE_STAT_LOCATION: - sub_80C4DF8(dest, gMapHeader.regionMapSectionId); + GetMapNameGeneric(dest, gMapHeader.regionMapSectionId); break; case SAVE_STAT_BADGES: for (flagId = FLAG_BADGE01_GET, nBadges = 0; flagId < FLAG_BADGE01_GET + 8; flagId++) diff --git a/src/tm_case.c b/src/tm_case.c index 25fe9a72c..0734c6d24 100644 --- a/src/tm_case.c +++ b/src/tm_case.c @@ -848,8 +848,8 @@ static void TMHMContextMenuAction_Use(u8 taskId) } else { - gUnknown_3005E98 = sub_8125B40; - sTMCaseDynamicResources->savedCallback = sub_8124C8C; + gItemUseCB = ItemUseCB_TMHM; + sTMCaseDynamicResources->savedCallback = CB2_ShowPartyMenuForItemUse; Task_BeginFadeOutFromTMCase(taskId); } } @@ -874,7 +874,7 @@ static void TMHMContextMenuAction_Give(u8 taskId) } else { - sTMCaseDynamicResources->savedCallback = sub_8126EDC; + sTMCaseDynamicResources->savedCallback = CB2_ChooseMonToGiveItem; Task_BeginFadeOutFromTMCase(taskId); } } @@ -945,7 +945,7 @@ static void Task_SelectTMAction_Type1(u8 taskId) if (!itemid_is_unique(BagGetItemIdByPocketPosition(POCKET_TM_CASE, data[1]))) { - sTMCaseDynamicResources->savedCallback = c2_8123744; + sTMCaseDynamicResources->savedCallback = CB2_GiveHoldItem; Task_BeginFadeOutFromTMCase(taskId); } else @@ -1274,7 +1274,7 @@ static void Task_TMCaseDude_Playback(u8 taskId) sTMCaseStaticResources.scrollOffset = sPokeDudePackBackup->unk_162; Free(sPokeDudePackBackup); CpuFastCopy(gPlttBufferFaded, gPlttBufferUnfaded, 0x400); - sub_8108CF0(); + CB2_SetUpReshowBattleScreenAfterMenu(); BeginNormalPaletteFade(0xFFFFFFFF, -2, 0, 16, 0); data[8]++; } diff --git a/src/trade.c b/src/trade.c index 5151ecedd..792f1524b 100644 --- a/src/trade.c +++ b/src/trade.c @@ -879,11 +879,11 @@ static void sub_804C728(void) break; case 8: LoadHeldItemIcons(); - sub_812256C(sTradeMenuResourcesPtr->partyCounts, sTradeMenuResourcesPtr->partyIcons, 0); + DrawHeldItemIconsForTrade(sTradeMenuResourcesPtr->partyCounts, sTradeMenuResourcesPtr->partyIcons, 0); gMain.state++; break; case 9: - sub_812256C(sTradeMenuResourcesPtr->partyCounts, sTradeMenuResourcesPtr->partyIcons, 1); + DrawHeldItemIconsForTrade(sTradeMenuResourcesPtr->partyCounts, sTradeMenuResourcesPtr->partyIcons, 1); gMain.state++; break; case 10: @@ -1483,7 +1483,7 @@ static void sub_804C728(void) "\tadds r0, 0x36\n" "\tadds r1, 0x28\n" "\tmovs r2, 0\n" - "\tbl sub_812256C\n" + "\tbl DrawHeldItemIconsForTrade\n" "\tldr r1, _0804CB74 @ =gMain\n" "\tmovs r5, 0x87\n" "\tlsls r5, 3\n" @@ -1499,7 +1499,7 @@ static void sub_804C728(void) "\tadds r0, 0x36\n" "\tadds r1, 0x28\n" "\tmovs r2, 0x1\n" - "\tbl sub_812256C\n" + "\tbl DrawHeldItemIconsForTrade\n" "\tldr r1, _0804CB98 @ =gMain\n" "\tmovs r7, 0x87\n" "\tlsls r7, 3\n" @@ -1989,11 +1989,11 @@ void sub_804CF14(void) break; case 8: LoadHeldItemIcons(); - sub_812256C(sTradeMenuResourcesPtr->partyCounts, sTradeMenuResourcesPtr->partyIcons, 0); + DrawHeldItemIconsForTrade(sTradeMenuResourcesPtr->partyCounts, sTradeMenuResourcesPtr->partyIcons, 0); gMain.state++; break; case 9: - sub_812256C(sTradeMenuResourcesPtr->partyCounts, sTradeMenuResourcesPtr->partyIcons, 1); + DrawHeldItemIconsForTrade(sTradeMenuResourcesPtr->partyCounts, sTradeMenuResourcesPtr->partyIcons, 1); gMain.state++; break; case 10: @@ -2365,7 +2365,7 @@ void sub_804CF14(void) "\tadds r0, 0x36\n" "\tadds r1, 0x28\n" "\tmovs r2, 0\n" - "\tbl sub_812256C\n" + "\tbl DrawHeldItemIconsForTrade\n" "\tldr r1, _0804D174 @ =gMain\n" "\tmovs r5, 0x87\n" "\tlsls r5, 3\n" @@ -2381,7 +2381,7 @@ void sub_804CF14(void) "\tadds r0, 0x36\n" "\tadds r1, 0x28\n" "\tmovs r2, 0x1\n" - "\tbl sub_812256C\n" + "\tbl DrawHeldItemIconsForTrade\n" "\tldr r1, _0804D198 @ =gMain\n" "\tmovs r7, 0x87\n" "\tlsls r7, 3\n" @@ -4394,7 +4394,7 @@ static bool32 IsDeoxysOrMewUntradable(u16 species, bool8 isObedientBitSet) return FALSE; } -int sub_804FBEC(struct UnkLinkRfuStruct_02022B14Substruct a0, struct UnkLinkRfuStruct_02022B14Substruct a1, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet) +int GetUnionRoomTradeMessageId(struct UnkLinkRfuStruct_02022B14Substruct a0, struct UnkLinkRfuStruct_02022B14Substruct a1, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet) { u8 r9 = a0.unk_01_0; u8 r4 = a0.unk_00_7; diff --git a/src/wild_pokemon_area.c b/src/wild_pokemon_area.c index fc4df06ed..3c5afaf25 100644 --- a/src/wild_pokemon_area.c +++ b/src/wild_pokemon_area.c @@ -289,7 +289,7 @@ static bool32 PokemonInEncounterTable(const struct WildPokemonInfo * info, s32 s static u16 GetMapSecIdFromWildMonHeader(const struct WildPokemonHeader * header) { - return get_mapheader_by_bank_and_number(header->mapGroup, header->mapNum)->regionMapSectionId; + return Overworld_GetMapHeaderByGroupAndId(header->mapGroup, header->mapNum)->regionMapSectionId; } static bool32 TryGetMapSecPokedexAreaEntry(u16 mapSecId, const u16 (*lut)[2], s32 count, s32 * lutIdx_p, u16 * tableIdx_p) -- cgit v1.2.3 From d89a2d791edaf9bc892bd00dbf2ffcd35f84435a Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Thu, 21 Nov 2019 10:48:08 +0800 Subject: party_menu data --- src/battle_controller_oak_old_man.c | 2 +- src/battle_controller_player.c | 2 +- src/battle_controller_pokedude.c | 2 +- src/battle_main.c | 10 +- src/battle_script_commands.c | 6 +- src/data/party_menu.h | 1334 +++++++++++++++++ src/data/pokemon/tutor_learnsets.h | 2813 +++++++++++++++++++++++++++++++++++ src/fldeff_softboiled.c | 24 +- src/fldeff_sweetscent.c | 2 +- src/item_pc.c | 2 +- src/party_menu.c | 172 +++ src/trade.c | 6 +- 12 files changed, 4347 insertions(+), 28 deletions(-) create mode 100644 src/data/party_menu.h create mode 100644 src/data/pokemon/tutor_learnsets.h create mode 100644 src/party_menu.c (limited to 'src') diff --git a/src/battle_controller_oak_old_man.c b/src/battle_controller_oak_old_man.c index da8530c72..08c89ec1e 100644 --- a/src/battle_controller_oak_old_man.c +++ b/src/battle_controller_oak_old_man.c @@ -364,7 +364,7 @@ static void WaitForMonSelection(void) if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { if (gPartyMenuUseExitCallback == 1) - BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gBattlePartyCurrentOrder); + BtlController_EmitChosenMonReturnValue(1, gSelectedMonPartyId, gBattlePartyCurrentOrder); else BtlController_EmitChosenMonReturnValue(1, 6, NULL); OakOldManBufferExecCompleted(); diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index 41d81052e..baa794f70 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -1314,7 +1314,7 @@ static void WaitForMonSelection(void) if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { if (gPartyMenuUseExitCallback == 1) - BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gBattlePartyCurrentOrder); + BtlController_EmitChosenMonReturnValue(1, gSelectedMonPartyId, gBattlePartyCurrentOrder); else BtlController_EmitChosenMonReturnValue(1, 6, NULL); if ((gBattleBufferA[gActiveBattler][1] & 0xF) == 1) diff --git a/src/battle_controller_pokedude.c b/src/battle_controller_pokedude.c index 59fda163b..0b71a92e8 100644 --- a/src/battle_controller_pokedude.c +++ b/src/battle_controller_pokedude.c @@ -715,7 +715,7 @@ static void WaitForMonSelection(void) if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { if (gPartyMenuUseExitCallback == 1) - BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gBattlePartyCurrentOrder); + BtlController_EmitChosenMonReturnValue(1, gSelectedMonPartyId, gBattlePartyCurrentOrder); else BtlController_EmitChosenMonReturnValue(1, 6, NULL); PokedudeBufferExecCompleted(); diff --git a/src/battle_main.c b/src/battle_main.c index da9bc1a49..a6d7e69c8 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -3137,7 +3137,7 @@ static void HandleTurnActionSelectionState(void) *(gBattleStruct->field_58 + gActiveBattler) = gBattlerPartyIndexes[gActiveBattler]; if (gBattleMons[gActiveBattler].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION) || gStatuses3[gActiveBattler] & STATUS3_ROOTED) { - BtlController_EmitChoosePokemon(0, PARTY_CANT_SWITCH, 6, ABILITY_NONE, gBattleStruct->field_60[gActiveBattler]); + BtlController_EmitChoosePokemon(0, PARTY_ACTION_CANT_SWITCH, 6, ABILITY_NONE, gBattleStruct->field_60[gActiveBattler]); } else if ((i = ABILITY_ON_OPPOSING_FIELD(gActiveBattler, ABILITY_SHADOW_TAG)) || ((i = ABILITY_ON_OPPOSING_FIELD(gActiveBattler, ABILITY_ARENA_TRAP)) @@ -3146,16 +3146,16 @@ static void HandleTurnActionSelectionState(void) || ((i = AbilityBattleEffects(ABILITYEFFECT_CHECK_FIELD_EXCEPT_BATTLER, gActiveBattler, ABILITY_MAGNET_PULL, 0, 0)) && IS_BATTLER_OF_TYPE(gActiveBattler, TYPE_STEEL))) { - BtlController_EmitChoosePokemon(0, ((i - 1) << 4) | PARTY_ABILITY_PREVENTS, 6, gLastUsedAbility, gBattleStruct->field_60[gActiveBattler]); + BtlController_EmitChoosePokemon(0, ((i - 1) << 4) | PARTY_ACTION_ABILITY_PREVENTS, 6, gLastUsedAbility, gBattleStruct->field_60[gActiveBattler]); } else { if (gActiveBattler == 2 && gChosenActionByBattler[0] == B_ACTION_SWITCH) - BtlController_EmitChoosePokemon(0, PARTY_CHOOSE_MON, *(gBattleStruct->monToSwitchIntoId + 0), ABILITY_NONE, gBattleStruct->field_60[gActiveBattler]); + BtlController_EmitChoosePokemon(0, PARTY_ACTION_CHOOSE_MON, *(gBattleStruct->monToSwitchIntoId + 0), ABILITY_NONE, gBattleStruct->field_60[gActiveBattler]); else if (gActiveBattler == 3 && gChosenActionByBattler[1] == B_ACTION_SWITCH) - BtlController_EmitChoosePokemon(0, PARTY_CHOOSE_MON, *(gBattleStruct->monToSwitchIntoId + 1), ABILITY_NONE, gBattleStruct->field_60[gActiveBattler]); + BtlController_EmitChoosePokemon(0, PARTY_ACTION_CHOOSE_MON, *(gBattleStruct->monToSwitchIntoId + 1), ABILITY_NONE, gBattleStruct->field_60[gActiveBattler]); else - BtlController_EmitChoosePokemon(0, PARTY_CHOOSE_MON, 6, ABILITY_NONE, gBattleStruct->field_60[gActiveBattler]); + BtlController_EmitChoosePokemon(0, PARTY_ACTION_CHOOSE_MON, 6, ABILITY_NONE, gBattleStruct->field_60[gActiveBattler]); } MarkBattlerForControllerExec(gActiveBattler); break; diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index c568d96f9..fe7359eb9 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -4504,7 +4504,7 @@ static void atk4F_jumpifcantswitch(void) static void sub_8024398(u8 arg0) { *(gBattleStruct->field_58 + gActiveBattler) = gBattlerPartyIndexes[gActiveBattler]; - BtlController_EmitChoosePokemon(0, PARTY_MUST_CHOOSE_MON, arg0, 0, gBattleStruct->field_60[gActiveBattler]); + BtlController_EmitChoosePokemon(0, PARTY_ACTION_SEND_OUT, arg0, 0, gBattleStruct->field_60[gActiveBattler]); MarkBattlerForControllerExec(gActiveBattler); } @@ -4739,9 +4739,9 @@ static void atk50_openpartyscreen(void) else { if (gBattlescriptCurrInstr[1] & OPEN_PARTY_ALLOW_CANCEL) - hitmarkerFaintBits = PARTY_CHOOSE_MON; // Used here as the caseId for the EmitChoose function. + hitmarkerFaintBits = PARTY_ACTION_CHOOSE_MON; // Used here as the caseId for the EmitChoose function. else - hitmarkerFaintBits = PARTY_MUST_CHOOSE_MON; + hitmarkerFaintBits = PARTY_ACTION_SEND_OUT; battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1] & ~(OPEN_PARTY_ALLOW_CANCEL)); if (gSpecialStatuses[battlerId].flag40) { diff --git a/src/data/party_menu.h b/src/data/party_menu.h new file mode 100644 index 000000000..fde1a80f8 --- /dev/null +++ b/src/data/party_menu.h @@ -0,0 +1,1334 @@ +const struct BgTemplate sPartyMenuBgTemplates[] = +{ + { + .bg = 0, + .charBaseIndex = 0, + .mapBaseIndex = 31, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0 + }, + { + .bg = 1, + .charBaseIndex = 0, + .mapBaseIndex = 30, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0 + }, + { + .bg = 2, + .charBaseIndex = 0, + .mapBaseIndex = 28, + .screenSize = 1, + .paletteMode = 0, + .priority = 0, + .baseTile = 0 + }, +}; + +enum +{ + PARTY_BOX_LEFT_COLUMN, + PARTY_BOX_RIGHT_COLUMN, +}; + +const struct PartyMenuBoxInfoRects sPartyBoxInfoRects[] = +{ + [PARTY_BOX_LEFT_COLUMN] = + { + BlitBitmapToPartyWindow_LeftColumn, + { + // The below are the x, y, width, and height for each of the following info + 24, 11, 40, 13, // Nickname + 32, 20, 32, 8, // Level + 64, 20, 8, 8, // Gender + 38, 36, 24, 8, // HP + 53, 36, 24, 8, // Max HP + 24, 35, 48, 3 // HP bar + }, + 12, 34, 64, 16 // Description text (e.g. NO USE) + }, + [PARTY_BOX_RIGHT_COLUMN] = + { + BlitBitmapToPartyWindow_RightColumn, + { + // The below are the x, y, width, and height for each of the following info + 22, 3, 40, 13, // Nickname + 32, 12, 32, 8, // Level + 64, 12, 8, 8, // Gender + 102, 12, 24, 8, // HP + 117, 12, 24, 8, // Max HP + 88, 10, 48, 3 // HP bar + }, + 77, 4, 64, 16 // Description text + }, +}; + +const u8 sPartyMenuSpriteCoords[PARTY_LAYOUT_COUNT][PARTY_SIZE][4 * 2] = +{ + [PARTY_LAYOUT_SINGLE] = + { + { 16, 40, 20, 50, 56, 52, 16, 34}, + {104, 18, 108, 28, 144, 27, 102, 25}, + {104, 42, 108, 52, 144, 51, 102, 49}, + {104, 66, 108, 76, 144, 75, 102, 73}, + {104, 90, 108, 100, 144, 99, 102, 97}, + {104, 114, 108, 124, 144, 123, 102, 121}, + }, + [PARTY_LAYOUT_DOUBLE] = + { + { 16, 24, 20, 34, 56, 36, 16, 18}, + { 16, 80, 20, 90, 56, 92, 16, 74}, + {104, 18, 108, 28, 144, 27, 102, 25}, + {104, 50, 108, 60, 144, 59, 102, 57}, + {104, 82, 108, 92, 144, 91, 102, 89}, + {104, 114, 108, 124, 144, 123, 102, 121}, + }, + [PARTY_LAYOUT_MULTI] = + { + { 16, 24, 20, 34, 56, 36, 16, 18}, + { 16, 80, 20, 90, 56, 92, 16, 74}, + {104, 26, 106, 36, 144, 35, 102, 33}, + {104, 50, 106, 60, 144, 59, 102, 57}, + {104, 82, 106, 92, 144, 91, 102, 89}, + {104, 106, 106, 116, 144, 115, 102, 113}, + }, + [PARTY_LAYOUT_MULTI_SHOWCASE] = + { + { 16, 32, 20, 42, 56, 44, 16, 26}, + {104, 34, 106, 44, 144, 43, 102, 41}, + {104, 58, 106, 68, 144, 67, 102, 65}, + { 16, 104, 20, 114, 56, 116, 16, 98}, + {104, 106, 106, 116, 144, 115, 102, 113}, + {104, 130, 106, 140, 144, 139, 102, 137}, + }, +}; + +const u32 sConfirmButton_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_confirm_button.bin"); +const u32 sCancelButton_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_cancel_button.bin"); + +// NOTE TO MYSELF: remove these after #159 gets merged +#define TEXT_COLOR_TRANSPARENT 0x0 +#define TEXT_COLOR_WHITE 0x1 +#define TEXT_COLOR_DARK_GREY 0x2 +#define TEXT_COLOR_LIGHT_GREY 0x3 +#define TEXT_COLOR_RED 0x4 +#define TEXT_COLOR_LIGHT_RED 0x5 +#define TEXT_COLOR_GREEN 0x6 +#define TEXT_COLOR_LIGHT_GREEN 0x7 +#define TEXT_COLOR_BLUE 0x8 +#define TEXT_COLOR_LIGHT_BLUE 0x9 +#define TEXT_DYNAMIC_COLOR_1 0xA // Usually white +#define TEXT_DYNAMIC_COLOR_2 0xB // Usually white w/ tinge of green +#define TEXT_DYNAMIC_COLOR_3 0xC // Usually white +#define TEXT_DYNAMIC_COLOR_4 0xD // Usually aquamarine +#define TEXT_DYNAMIC_COLOR_5 0xE // Usually blue-green +#define TEXT_DYNAMIC_COLOR_6 0xF // Usually cerulean + +const u8 sFontColorTable[][3] = +{ + {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_LIGHT_GREY, TEXT_COLOR_DARK_GREY}, // Default + {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_WHITE, TEXT_COLOR_GREEN}, // Unused + {TEXT_COLOR_TRANSPARENT, TEXT_DYNAMIC_COLOR_2, TEXT_DYNAMIC_COLOR_3}, // Gender symbol + {TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY}, // Selection actions + {TEXT_COLOR_WHITE, TEXT_COLOR_BLUE, TEXT_COLOR_LIGHT_BLUE}, // Field moves + {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GREY}, // Unused +}; + +const struct WindowTemplate sSinglePartyMenuWindowTemplate[] = +{ + { + .bg = 0, + .tilemapLeft = 1, + .tilemapTop = 3, + .width = 10, + .height = 7, + .paletteNum = 3, + .baseBlock = 0x63, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 1, + .width = 18, + .height = 3, + .paletteNum = 4, + .baseBlock = 0xA9, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 4, + .width = 18, + .height = 3, + .paletteNum = 5, + .baseBlock = 0xDF, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 7, + .width = 18, + .height = 3, + .paletteNum = 6, + .baseBlock = 0x115, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 10, + .width = 18, + .height = 3, + .paletteNum = 7, + .baseBlock = 0x14B, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 13, + .width = 18, + .height = 3, + .paletteNum = 8, + .baseBlock = 0x181, + }, + { + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 15, + .width = 28, + .height = 4, + .paletteNum = 14, + .baseBlock = 0x1DF, + }, + DUMMY_WIN_TEMPLATE +}; + +const struct WindowTemplate sDoublePartyMenuWindowTemplate[] = +{ + { + .bg = 0, + .tilemapLeft = 1, + .tilemapTop = 1, + .width = 10, + .height = 7, + .paletteNum = 3, + .baseBlock = 0x63, + }, + { + .bg = 0, + .tilemapLeft = 1, + .tilemapTop = 8, + .width = 10, + .height = 7, + .paletteNum = 4, + .baseBlock = 0xA9, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 1, + .width = 18, + .height = 3, + .paletteNum = 5, + .baseBlock = 0xEF, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 5, + .width = 18, + .height = 3, + .paletteNum = 6, + .baseBlock = 0x125, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 9, + .width = 18, + .height = 3, + .paletteNum = 7, + .baseBlock = 0x15B, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 13, + .width = 18, + .height = 3, + .paletteNum = 8, + .baseBlock = 0x191, + }, + { + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 15, + .width = 28, + .height = 4, + .paletteNum = 14, + .baseBlock = 0x1DF, + }, + DUMMY_WIN_TEMPLATE +}; + +const struct WindowTemplate sMultiPartyMenuWindowTemplate[] = +{ + { + .bg = 0, + .tilemapLeft = 1, + .tilemapTop = 1, + .width = 10, + .height = 7, + .paletteNum = 3, + .baseBlock = 0x63, + }, + { + .bg = 0, + .tilemapLeft = 1, + .tilemapTop = 8, + .width = 10, + .height = 7, + .paletteNum = 4, + .baseBlock = 0xA9, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 2, + .width = 18, + .height = 3, + .paletteNum = 5, + .baseBlock = 0xEF, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 5, + .width = 18, + .height = 3, + .paletteNum = 6, + .baseBlock = 0x125, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 9, + .width = 18, + .height = 3, + .paletteNum = 7, + .baseBlock = 0x15B, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 12, + .width = 18, + .height = 3, + .paletteNum = 8, + .baseBlock = 0x191, + }, + { + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 15, + .width = 28, + .height = 4, + .paletteNum = 14, + .baseBlock = 0x1DF, + }, + DUMMY_WIN_TEMPLATE +}; + +const struct WindowTemplate sShowcaseMultiPartyMenuWindowTemplate[] = +{ + { + .bg = 0, + .tilemapLeft = 1, + .tilemapTop = 2, + .width = 10, + .height = 7, + .paletteNum = 3, + .baseBlock = 0x63, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 3, + .width = 18, + .height = 3, + .paletteNum = 5, + .baseBlock = 0xA9, + }, + { + .bg = 0, + .tilemapLeft = 12, + .tilemapTop = 6, + .width = 18, + .height = 3, + .paletteNum = 6, + .baseBlock = 0xDF, + }, + { + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 11, + .width = 10, + .height = 7, + .paletteNum = 4, + .baseBlock = 0x115, + }, + { + .bg = 2, + .tilemapLeft = 12, + .tilemapTop = 12, + .width = 18, + .height = 3, + .paletteNum = 7, + .baseBlock = 0x16B, + }, + { + .bg = 2, + .tilemapLeft = 12, + .tilemapTop = 15, + .width = 18, + .height = 3, + .paletteNum = 8, + .baseBlock = 0x1A1, + }, + DUMMY_WIN_TEMPLATE +}; + +const struct WindowTemplate sCancelButtonWindowTemplate = +{ + .bg = 0, + .tilemapLeft = 24, + .tilemapTop = 17, + .width = 6, + .height = 2, + .paletteNum = 3, + .baseBlock = 0x1C7, +}; + +const struct WindowTemplate sMultiCancelButtonWindowTemplate = +{ + .bg = 0, + .tilemapLeft = 24, + .tilemapTop = 18, + .width = 6, + .height = 2, + .paletteNum = 3, + .baseBlock = 0x1C7, +}; + +const struct WindowTemplate sConfirmButtonWindowTemplate = +{ + .bg = 0, + .tilemapLeft = 24, + .tilemapTop = 16, + .width = 6, + .height = 2, + .paletteNum = 3, + .baseBlock = 0x1D3, +}; + +const struct WindowTemplate sDefaultPartyMsgWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 17, + .width = 21, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x24F, +}; + +const struct WindowTemplate sDoWhatWithMonMsgWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 17, + .width = 16, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x279, +}; + +const struct WindowTemplate sDoWhatWithItemMsgWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 17, + .width = 19, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x299, +}; + +const struct WindowTemplate sDoWhatWithMailMsgWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 17, + .width = 16, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x299, +}; + +const struct WindowTemplate sWhichMoveMsgWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 17, + .width = 15, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x299, +}; + +const struct WindowTemplate sItemGiveTakeWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 22, + .tilemapTop = 13, + .width = 7, + .height = 6, + .paletteNum = 14, + .baseBlock = 0x373, +}; + +const struct WindowTemplate sMailReadTakeWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 19, + .tilemapTop = 13, + .width = 10, + .height = 6, + .paletteNum = 14, + .baseBlock = 0x373, +}; + +const struct WindowTemplate sMoveSelectWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 18, + .tilemapTop = 11, + .width = 11, + .height = 8, + .paletteNum = 14, + .baseBlock = 0x2BF, +}; + +const struct WindowTemplate sPartyMenuYesNoWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 21, + .tilemapTop = 9, + .width = 6, + .height = 4, + .paletteNum = 14, + .baseBlock = 0x2BF, +}; + +const struct WindowTemplate sLevelUpStatsWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 19, + .tilemapTop = 1, + .width = 10, + .height = 11, + .paletteNum = 14, + .baseBlock = 0x2BF, +}; + +const struct WindowTemplate gUnknown_845A170 = +{ + .bg = 2, + .tilemapLeft = 2, + .tilemapTop = 15, + .width = 26, + .height = 4, + .paletteNum = 14, + .baseBlock = 0x1DF, +}; + +const struct WindowTemplate gUnknown_845A178 = +{ + .bg = 2, + .tilemapLeft = 0, + .tilemapTop = 13, + .width = 18, + .height = 3, + .paletteNum = 12, + .baseBlock = 0x373, +}; + +const u8 sMainSlotTileNums[] = +{ + 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, + 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, + 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, + 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, + 40, 59, 60, 58, 58, 58, 58, 58, 58, 61, + 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, + 46, 47, 47, 47, 47, 47, 47, 47, 47, 48, +}; + +const u8 sMainSlotTileNums_Egg[] = +{ + 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, + 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, + 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, + 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, + 40, 41, 41, 41, 41, 41, 41, 41, 41, 42, + 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, + 46, 47, 47, 47, 47, 47, 47, 47, 47, 48, +}; + +const u8 sOtherSlotsTileNums[] = +{ + 43, 44, 44, 44, 44, 44, 44, 44, 44, 44, + 44, 44, 44, 44, 44, 44, 44, 45, 49, 33, + 33, 33, 33, 33, 33, 33, 33, 52, 53, 51, + 51, 51, 51, 51, 51, 54, 55, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 57, +}; + +const u8 sOtherSlotsTileNums_Egg[] = +{ + 43, 44, 44, 44, 44, 44, 44, 44, 44, 44, + 44, 44, 44, 44, 44, 44, 44, 45, 49, 33, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 33, 33, 33, 33, 33, 50, 55, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 57, +}; + +const u8 sEmptySlotTileNums[] = +{ + 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 23, 30, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 37, 38, 38, 38, + 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, + 38, 38, 38, 39, +}; + +const u8 sGenderPalOffsets[] = {11, 12}; + +const u8 sHPBarPalOffsets[] = {9, 10}; + +const u8 sPartyBoxPalOffsets1[] = {4, 5, 6}; + +const u8 sPartyBoxPalOffsets2[] = {1, 7, 8}; + +const u8 sGenderMalePalIds[] = {59, 60}; + +const u8 sGenderFemalePalIds[] = {75, 76}; + +const u8 sHPBarGreenPalIds[] = {57, 58}; + +const u8 sHPBarYellowPalIds[] = {73, 74}; + +const u8 sHPBarRedPalIds[] = {89, 90}; + +const u8 sPartyBoxEmptySlotPalIds1[] = {52, 53, 54}; + +const u8 sPartyBoxMultiPalIds1[] = {68, 69, 70}; + +const u8 sPartyBoxFaintedPalIds1[] = {84, 85, 86}; + +const u8 sPartyBoxCurrSelectionPalIds1[] = {116, 117, 118}; + +const u8 sPartyBoxCurrSelectionMultiPalIds[] = {132, 133, 134}; + +const u8 sPartyBoxCurrSelectionFaintedPalIds[] = {148, 149, 150}; + +const u8 sPartyBoxSelectedForActionPalIds1[] = {100, 101, 102}; + +const u8 sPartyBoxEmptySlotPalIds2[] = {49, 55, 56}; + +const u8 sPartyBoxMultiPalIds2[] = {65, 71, 72}; + +const u8 sPartyBoxFaintedPalIds2[] = {81, 87, 88}; + +const u8 sPartyBoxCurrSelectionPalIds2[] = {97, 103, 104}; + +const u8 sPartyBoxSelectedForActionPalIds2[] = {161, 167, 168}; + +const u8 *const sActionStringTable[] = +{ + [PARTY_MSG_CHOOSE_MON] = gText_ChoosePokemon, + [PARTY_MSG_CHOOSE_MON_OR_CANCEL] = gText_ChoosePokemonCancel, + [PARTY_MSG_CHOOSE_MON_AND_CONFIRM] = gText_ChoosePokemonConfirm, + [PARTY_MSG_MOVE_TO_WHERE] = gText_MoveToWhere, + [PARTY_MSG_TEACH_WHICH_MON] = gText_TeachWhichPokemon, + [PARTY_MSG_USE_ON_WHICH_MON] = gText_UseOnWhichPokemon, + [PARTY_MSG_GIVE_TO_WHICH_MON] = gText_GiveToWhichPokemon, + [PARTY_MSG_NOTHING_TO_CUT] = gText_NothingToCut, + [PARTY_MSG_CANT_SURF_HERE] = gText_CantSurfHere, + [PARTY_MSG_ALREADY_SURFING] = gText_AlreadySurfing, + [PARTY_MSG_CURRENT_TOO_FAST] = gText_CurrentIsTooFast, + [PARTY_MSG_ENJOY_CYCLING] = gText_EnjoyCycling, + [PARTY_MSG_ALREADY_IN_USE] = gText_InUseAlready_PM, + [PARTY_MSG_CANT_USE_HERE] = gText_CantUseHere, + [PARTY_MSG_NO_MON_FOR_BATTLE] = gText_NoPokemonForBattle, + [PARTY_MSG_CHOOSE_MON_2] = gText_ChoosePokemon2, + [PARTY_MSG_NOT_ENOUGH_HP] = gText_NotEnoughHp, + [PARTY_MSG_THREE_MONS_ARE_NEEDED] = gText_ThreePkmnAreNeeded, + [PARTY_MSG_TWO_MONS_ARE_NEEDED] = gText_TwoPokemonAreNeeded, + [PARTY_MSG_MONS_CANT_BE_SAME] = gText_PokemonCantBeSame, + [PARTY_MSG_NO_SAME_HOLD_ITEMS] = gText_NoIdenticalHoldItems, + [PARTY_MSG_UNUSED] = gString_Dummy, + [PARTY_MSG_DO_WHAT_WITH_MON] = gText_DoWhatWithPokemon, + [PARTY_MSG_RESTORE_WHICH_MOVE] = gText_RestoreWhichMove, + [PARTY_MSG_BOOST_PP_WHICH_MOVE] = gText_BoostPp, + [PARTY_MSG_DO_WHAT_WITH_ITEM] = gText_DoWhatWithItem, + [PARTY_MSG_DO_WHAT_WITH_MAIL] = gText_DoWhatWithMail, +}; + +const u8 *const sDescriptionStringTable[] = +{ + [PARTYBOX_DESC_NO_USE] = gText_NoUse, + [PARTYBOX_DESC_ABLE_3] = gText_Able, + [PARTYBOX_DESC_FIRST] = gText_First_PM, + [PARTYBOX_DESC_SECOND] = gText_Second_PM, + [PARTYBOX_DESC_THIRD] = gText_Third_PM, + [PARTYBOX_DESC_ABLE] = gText_Able2, + [PARTYBOX_DESC_NOT_ABLE] = gText_NotAble, + [PARTYBOX_DESC_ABLE_2] = gText_Able3, + [PARTYBOX_DESC_NOT_ABLE_2] = gText_NotAble2, + [PARTYBOX_DESC_LEARNED] = gText_Learned, +}; + +const u8 *const sHMDescriptionTable[] = +{ + gText_LightUpDarkness, + gText_CutATreeOrGrass, + gText_FlyToAKnownTown, + gText_MoveHeavyBoulders, + gText_TravelOnWater, + gText_ShatterACrackedRock, + gText_ClimbAWaterfall, + gText_ReturnToAHealingSpot, + gText_EscapeFromHere, + gText_ShareHp, + gText_ShareHp, + gText_LureWildPokemon, +}; + +const u32 sHeldItemGfx[] = INCBIN_U32("graphics/interface/hold_icons.4bpp"); +const u16 sHeldItemPalette[] = INCBIN_U16("graphics/interface/hold_icons.gbapal"); + +const struct OamData sOamData_HeldItem = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +const union AnimCmd sSpriteAnim_HeldItem[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END +}; + +const union AnimCmd sSpriteAnim_HeldMail[] = +{ + ANIMCMD_FRAME(1, 1), + ANIMCMD_END +}; + +const union AnimCmd *const sSpriteAnimTable_HeldItem[] = +{ + sSpriteAnim_HeldItem, + sSpriteAnim_HeldMail, +}; + +const struct SpriteSheet sSpriteSheet_HeldItem = +{ + sHeldItemGfx, sizeof(sHeldItemGfx), 0xd750 +}; + +const struct SpritePalette sSpritePalette_HeldItem = +{ + sHeldItemPalette, 0xd750 +}; + +const struct SpriteTemplate sSpriteTemplate_HeldItem = +{ + 0xd750, + 0xd750, + &sOamData_HeldItem, + sSpriteAnimTable_HeldItem, + NULL, + gDummySpriteAffineAnimTable, + SpriteCallbackDummy, +}; + +const struct OamData sOamData_MenuPokeball = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +const union AnimCmd sPokeballAnim_Closed[] = +{ + ANIMCMD_FRAME(0, 0), + ANIMCMD_END +}; + +const union AnimCmd sPokeballAnim_Open[] = +{ + ANIMCMD_FRAME(16, 0), + ANIMCMD_END +}; + +const union AnimCmd *const sSpriteAnimTable_MenuPokeball[] = +{ + sPokeballAnim_Closed, + sPokeballAnim_Open, +}; + +const struct CompressedSpriteSheet sSpriteSheet_MenuPokeball = +{ + gPartyMenuPokeball_Gfx, 0x400, 0x04b0 +}; + +const struct CompressedSpritePalette sSpritePalette_MenuPokeball = +{ + gPartyMenuPokeball_Pal, 0x04b0 +}; + +// Used for the pokeball sprite on each party slot / Cancel button +const struct SpriteTemplate sSpriteTemplate_MenuPokeball = +{ + .tileTag = 0x04b0, + .paletteTag = 0x04b0, + .oam = &sOamData_MenuPokeball, + .anims = sSpriteAnimTable_MenuPokeball, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const struct OamData sOamData_MenuPokeballSmall = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, + .affineParam = 0, +}; + +const union AnimCmd sSmallPokeballAnim_Closed[] = +{ + ANIMCMD_FRAME(0, 0), + ANIMCMD_END +}; + +const union AnimCmd sSmallPokeballAnim_Open[] = +{ + ANIMCMD_FRAME(4, 0), + ANIMCMD_END +}; + +const union AnimCmd sSmallPokeballAnim_Blank1[] = +{ + ANIMCMD_FRAME(8, 0), + ANIMCMD_END +}; + +const union AnimCmd sSmallPokeballAnim_Blank2[] = +{ + ANIMCMD_FRAME(12, 0), + ANIMCMD_END +}; + +const union AnimCmd sSmallPokeballAnim_Blank3[] = +{ + ANIMCMD_FRAME(16, 0), + ANIMCMD_END +}; + +const union AnimCmd sSmallPokeballAnim_Blank4[] = +{ + ANIMCMD_FRAME(20, 0), + ANIMCMD_END +}; + +// The blanks below are never used. See SpriteCB_BounceConfirmCancelButton, where they were intended to be used +const union AnimCmd *const sSpriteAnimTable_MenuPokeballSmall[] = +{ + sSmallPokeballAnim_Closed, + sSmallPokeballAnim_Open, + sSmallPokeballAnim_Blank1, + sSmallPokeballAnim_Blank2, + sSmallPokeballAnim_Blank3, + sSmallPokeballAnim_Blank4, +}; + +const struct CompressedSpriteSheet sSpriteSheet_MenuPokeballSmall = +{ + gPartyMenuPokeballSmall_Gfx, 0x0300, 0x04b1 +}; + +// Used for the pokeball sprite next to Cancel and Confirm when both are present, otherwise sSpriteTemplate_MenuPokeball is used +const struct SpriteTemplate sSpriteTemplate_MenuPokeballSmall = +{ + .tileTag = 1201, + .paletteTag = 1200, + .oam = &sOamData_MenuPokeballSmall, + .anims = sSpriteAnimTable_MenuPokeballSmall, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const struct OamData sOamData_StatusCondition = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +const union AnimCmd sSpriteAnim_StatusPoison[] = +{ + ANIMCMD_FRAME(0, 0), + ANIMCMD_END +}; + +const union AnimCmd sSpriteAnim_StatusParalyzed[] = +{ + ANIMCMD_FRAME(4, 0), + ANIMCMD_END +}; + +const union AnimCmd sSpriteAnim_StatusSleep[] = +{ + ANIMCMD_FRAME(8, 0), + ANIMCMD_END +}; + +const union AnimCmd sSpriteAnim_StatusFrozen[] = +{ + ANIMCMD_FRAME(12, 0), + ANIMCMD_END +}; + +const union AnimCmd sSpriteAnim_StatusBurn[] = +{ + ANIMCMD_FRAME(16, 0), + ANIMCMD_END +}; + +const union AnimCmd sSpriteAnim_StatusPokerus[] = +{ + ANIMCMD_FRAME(20, 0), + ANIMCMD_END +}; + +const union AnimCmd sSpriteAnim_StatusFaint[] = +{ + ANIMCMD_FRAME(24, 0), + ANIMCMD_END +}; + +const union AnimCmd sSpriteAnim_Blank[] = +{ + ANIMCMD_FRAME(28, 0), + ANIMCMD_END +}; + +const union AnimCmd *const sSpriteTemplate_StatusCondition[] = +{ + sSpriteAnim_StatusPoison, + sSpriteAnim_StatusParalyzed, + sSpriteAnim_StatusSleep, + sSpriteAnim_StatusFrozen, + sSpriteAnim_StatusBurn, + sSpriteAnim_StatusPokerus, + sSpriteAnim_StatusFaint, + sSpriteAnim_Blank, +}; + +const struct CompressedSpriteSheet sSpriteSheet_StatusIcons = +{ + gStatusGfx_Icons, 0x400, 1202 +}; + +const struct CompressedSpritePalette sSpritePalette_StatusIcons = +{ + gStatusPal_Icons, 1202 +}; + +const struct SpriteTemplate sSpriteTemplate_StatusIcons = +{ + .tileTag = 1202, + .paletteTag = 1202, + .oam = &sOamData_StatusCondition, + .anims = sSpriteTemplate_StatusCondition, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const bool8 sMultiBattlePartnersPartyMask[PARTY_SIZE + 2] = +{ + FALSE, + TRUE, + FALSE, + FALSE, + TRUE, + TRUE, + FALSE, +}; + +const u16 sTMHMMoves_Duplicate[] = +{ + MOVE_FOCUS_PUNCH, + MOVE_DRAGON_CLAW, + MOVE_WATER_PULSE, + MOVE_CALM_MIND, + MOVE_ROAR, + MOVE_TOXIC, + MOVE_HAIL, + MOVE_BULK_UP, + MOVE_BULLET_SEED, + MOVE_HIDDEN_POWER, + MOVE_SUNNY_DAY, + MOVE_TAUNT, + MOVE_ICE_BEAM, + MOVE_BLIZZARD, + MOVE_HYPER_BEAM, + MOVE_LIGHT_SCREEN, + MOVE_PROTECT, + MOVE_RAIN_DANCE, + MOVE_GIGA_DRAIN, + MOVE_SAFEGUARD, + MOVE_FRUSTRATION, + MOVE_SOLAR_BEAM, + MOVE_IRON_TAIL, + MOVE_THUNDERBOLT, + MOVE_THUNDER, + MOVE_EARTHQUAKE, + MOVE_RETURN, + MOVE_DIG, + MOVE_PSYCHIC, + MOVE_SHADOW_BALL, + MOVE_BRICK_BREAK, + MOVE_DOUBLE_TEAM, + MOVE_REFLECT, + MOVE_SHOCK_WAVE, + MOVE_FLAMETHROWER, + MOVE_SLUDGE_BOMB, + MOVE_SANDSTORM, + MOVE_FIRE_BLAST, + MOVE_ROCK_TOMB, + MOVE_AERIAL_ACE, + MOVE_TORMENT, + MOVE_FACADE, + MOVE_SECRET_POWER, + MOVE_REST, + MOVE_ATTRACT, + MOVE_THIEF, + MOVE_STEEL_WING, + MOVE_SKILL_SWAP, + MOVE_SNATCH, + MOVE_OVERHEAT, + MOVE_CUT, + MOVE_FLY, + MOVE_SURF, + MOVE_STRENGTH, + MOVE_FLASH, + MOVE_ROCK_SMASH, + MOVE_WATERFALL, + MOVE_DIVE, +}; + +enum +{ + MENU_SUMMARY, + MENU_SWITCH, + MENU_CANCEL1, + MENU_ITEM, + MENU_GIVE, + MENU_TAKE_ITEM, + MENU_MAIL, + MENU_TAKE_MAIL, + MENU_READ, + MENU_CANCEL2, + MENU_SHIFT, + MENU_SEND_OUT, + MENU_ENTER, + MENU_NO_ENTRY, + MENU_STORE, + MENU_REGISTER, + MENU_TRADE1, + MENU_TRADE2, + MENU_FIELD_MOVES, +}; + +enum +{ + FIELD_MOVE_FLASH, + FIELD_MOVE_CUT, + FIELD_MOVE_FLY, + FIELD_MOVE_STRENGTH, + FIELD_MOVE_SURF, + FIELD_MOVE_ROCK_SMASH, + FIELD_MOVE_WATERFALL, + FIELD_MOVE_TELEPORT, + FIELD_MOVE_DIG, + FIELD_MOVE_MILK_DRINK, + FIELD_MOVE_SOFT_BOILED, + FIELD_MOVE_SWEET_SCENT, + FIELD_MOVE_END, +}; + +struct +{ + const u8 *text; + TaskFunc func; +} const sCursorOptions[] = +{ + [MENU_SUMMARY] = {gText_Summary5, CursorCB_Summary}, + [MENU_SWITCH] = {gText_Switch2, CursorCB_Switch}, + [MENU_CANCEL1] = {gFameCheckerText_Cancel, CursorCB_Cancel1}, + [MENU_ITEM] = {gText_Item, CursorCB_Item}, + [MENU_GIVE] = {gOtherText_Give, CursorCB_Give}, + [MENU_TAKE_ITEM] = {gText_Take, CursorCB_TakeItem}, + [MENU_MAIL] = {gText_Mail, CursorCB_Mail}, + [MENU_TAKE_MAIL] = {gText_Take2, CursorCB_TakeMail}, + [MENU_READ] = {gText_Read2, CursorCB_Read}, + [MENU_CANCEL2] = {gFameCheckerText_Cancel, CursorCB_Cancel2}, + [MENU_SHIFT] = {gText_Shift, CursorCB_SendMon}, + [MENU_SEND_OUT] = {gText_SendOut, CursorCB_SendMon}, + [MENU_ENTER] = {gText_Enter, CursorCB_Enter}, + [MENU_NO_ENTRY] = {gText_NoEntry, CursorCB_NoEntry}, + [MENU_STORE] = {gText_Store, CursorCB_Store}, + [MENU_REGISTER] = {gText_Register, CursorCB_Register}, + [MENU_TRADE1] = {gText_Trade4, CursorCB_Trade1}, + [MENU_TRADE2] = {gText_Trade4, CursorCB_Trade2}, + [MENU_FIELD_MOVES + FIELD_MOVE_FLASH] = {gMoveNames[MOVE_FLASH], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_CUT] = {gMoveNames[MOVE_CUT], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_FLY] = {gMoveNames[MOVE_FLY], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_STRENGTH] = {gMoveNames[MOVE_STRENGTH], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_SURF] = {gMoveNames[MOVE_SURF], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_ROCK_SMASH] = {gMoveNames[MOVE_ROCK_SMASH], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_WATERFALL] = {gMoveNames[MOVE_WATERFALL], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_TELEPORT] = {gMoveNames[MOVE_TELEPORT], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_DIG] = {gMoveNames[MOVE_DIG], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_MILK_DRINK] = {gMoveNames[MOVE_MILK_DRINK], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_SOFT_BOILED] = {gMoveNames[MOVE_SOFT_BOILED], CursorCB_FieldMove}, + [MENU_FIELD_MOVES + FIELD_MOVE_SWEET_SCENT] = {gMoveNames[MOVE_SWEET_SCENT], CursorCB_FieldMove}, +}; + +const u8 sPartyMenuAction_SummarySwitchCancel[] = {MENU_SUMMARY, MENU_SWITCH, MENU_CANCEL1}; +const u8 sPartyMenuAction_ShiftSummaryCancel[] = {MENU_SHIFT, MENU_SUMMARY, MENU_CANCEL1}; +const u8 sPartyMenuAction_SendOutSummaryCancel[] = {MENU_SEND_OUT, MENU_SUMMARY, MENU_CANCEL1}; +const u8 sPartyMenuAction_SummaryCancel[] = {MENU_SUMMARY, MENU_CANCEL1}; +const u8 sPartyMenuAction_EnterSummaryCancel[] = {MENU_ENTER, MENU_SUMMARY, MENU_CANCEL1}; +const u8 sPartyMenuAction_NoEntrySummaryCancel[] = {MENU_NO_ENTRY, MENU_SUMMARY, MENU_CANCEL1}; +const u8 sPartyMenuAction_StoreSummaryCancel[] = {MENU_STORE, MENU_SUMMARY, MENU_CANCEL1}; +const u8 sPartyMenuAction_GiveTakeItemCancel[] = {MENU_GIVE, MENU_TAKE_ITEM, MENU_CANCEL2}; +const u8 sPartyMenuAction_ReadTakeMailCancel[] = {MENU_READ, MENU_TAKE_MAIL, MENU_CANCEL2}; +const u8 sPartyMenuAction_RegisterSummaryCancel[] = {MENU_REGISTER, MENU_SUMMARY, MENU_CANCEL1}; +const u8 sPartyMenuAction_TradeSummaryCancel1[] = {MENU_TRADE1, MENU_SUMMARY, MENU_CANCEL1}; +const u8 sPartyMenuAction_TradeSummaryCancel2[] = {MENU_TRADE2, MENU_SUMMARY, MENU_CANCEL1}; + +// IDs for the action lists that appear when a party mon is selected +enum +{ + ACTIONS_NONE, + ACTIONS_SWITCH, + ACTIONS_SHIFT, + ACTIONS_SEND_OUT, + ACTIONS_ENTER, + ACTIONS_NO_ENTRY, + ACTIONS_STORE, + ACTIONS_SUMMARY_ONLY, + ACTIONS_ITEM, + ACTIONS_MAIL, + ACTIONS_REGISTER, + ACTIONS_TRADE, + ACTIONS_SPIN_TRADE, +}; + +const u8 *const sPartyMenuActions[] = +{ + [ACTIONS_NONE] = NULL, + [ACTIONS_SWITCH] = sPartyMenuAction_SummarySwitchCancel, + [ACTIONS_SHIFT] = sPartyMenuAction_ShiftSummaryCancel, + [ACTIONS_SEND_OUT] = sPartyMenuAction_SendOutSummaryCancel, + [ACTIONS_ENTER] = sPartyMenuAction_EnterSummaryCancel, + [ACTIONS_NO_ENTRY] = sPartyMenuAction_NoEntrySummaryCancel, + [ACTIONS_STORE] = sPartyMenuAction_StoreSummaryCancel, + [ACTIONS_SUMMARY_ONLY] = sPartyMenuAction_SummaryCancel, + [ACTIONS_ITEM] = sPartyMenuAction_GiveTakeItemCancel, + [ACTIONS_MAIL] = sPartyMenuAction_ReadTakeMailCancel, + [ACTIONS_REGISTER] = sPartyMenuAction_RegisterSummaryCancel, + [ACTIONS_TRADE] = sPartyMenuAction_TradeSummaryCancel1, + [ACTIONS_SPIN_TRADE] = sPartyMenuAction_TradeSummaryCancel2, +}; + +const u8 sPartyMenuActionCounts[] = +{ + [ACTIONS_NONE] = 0, + [ACTIONS_SWITCH] = NELEMS(sPartyMenuAction_SummarySwitchCancel), + [ACTIONS_SHIFT] = NELEMS(sPartyMenuAction_ShiftSummaryCancel), + [ACTIONS_SEND_OUT] = NELEMS(sPartyMenuAction_SendOutSummaryCancel), + [ACTIONS_ENTER] = NELEMS(sPartyMenuAction_EnterSummaryCancel), + [ACTIONS_NO_ENTRY] = NELEMS(sPartyMenuAction_NoEntrySummaryCancel), + [ACTIONS_STORE] = NELEMS(sPartyMenuAction_StoreSummaryCancel), + [ACTIONS_SUMMARY_ONLY] = NELEMS(sPartyMenuAction_SummaryCancel), + [ACTIONS_ITEM] = NELEMS(sPartyMenuAction_GiveTakeItemCancel), + [ACTIONS_MAIL] = NELEMS(sPartyMenuAction_ReadTakeMailCancel), + [ACTIONS_REGISTER] = NELEMS(sPartyMenuAction_RegisterSummaryCancel), + [ACTIONS_TRADE] = NELEMS(sPartyMenuAction_TradeSummaryCancel1), + [ACTIONS_SPIN_TRADE] = NELEMS(sPartyMenuAction_TradeSummaryCancel2), +}; + +const u16 sFieldMoves[] = +{ + MOVE_FLASH, MOVE_CUT, MOVE_FLY, MOVE_STRENGTH, MOVE_SURF, MOVE_ROCK_SMASH, MOVE_WATERFALL, MOVE_TELEPORT, + MOVE_DIG, MOVE_MILK_DRINK, MOVE_SOFT_BOILED, MOVE_SWEET_SCENT, FIELD_MOVE_END // this may be misuse of enum. same in emerald +}; + +struct +{ + bool8 (*fieldMoveFunc)(void); + u8 msgId; +} const sFieldMoveCursorCallbacks[] = +{ + [FIELD_MOVE_FLASH] = {SetUpFieldMove_Flash, PARTY_MSG_CANT_USE_HERE}, + [FIELD_MOVE_CUT] = {SetUpFieldMove_Cut, PARTY_MSG_NOTHING_TO_CUT}, + [FIELD_MOVE_FLY] = {SetUpFieldMove_Fly, PARTY_MSG_CANT_USE_HERE}, + [FIELD_MOVE_STRENGTH] = {SetUpFieldMove_Strength, PARTY_MSG_CANT_USE_HERE}, + [FIELD_MOVE_SURF] = {SetUpFieldMove_Surf, PARTY_MSG_CANT_SURF_HERE}, + [FIELD_MOVE_ROCK_SMASH] = {SetUpFieldMove_RockSmash, PARTY_MSG_CANT_USE_HERE}, + [FIELD_MOVE_WATERFALL] = {SetUpFieldMove_Waterfall, PARTY_MSG_CANT_USE_HERE}, + [FIELD_MOVE_TELEPORT] = {SetUpFieldMove_Teleport, PARTY_MSG_CANT_USE_HERE}, + [FIELD_MOVE_DIG] = {SetUpFieldMove_Dig, PARTY_MSG_CANT_USE_HERE}, + [FIELD_MOVE_MILK_DRINK] = {SetUpFieldMove_SoftBoiled, PARTY_MSG_NOT_ENOUGH_HP}, + [FIELD_MOVE_SOFT_BOILED] = {SetUpFieldMove_SoftBoiled, PARTY_MSG_NOT_ENOUGH_HP}, + [FIELD_MOVE_SWEET_SCENT] = {SetUpFieldMove_SweetScent, PARTY_MSG_CANT_USE_HERE}, +}; + +const u8 *const sUnionRoomTradeMessages[] = +{ + [UR_TRADE_MSG_NOT_MON_PARTNER_WANTS - 1] = gText_NotPkmnOtherTrainerWants, + [UR_TRADE_MSG_NOT_EGG - 1] = gText_ThatIsntAnEgg, + [UR_TRADE_MSG_MON_CANT_BE_TRADED_1 - 1] = gText_PkmnCantBeTradedNow, + [UR_TRADE_MSG_MON_CANT_BE_TRADED_2 - 1] = gText_PkmnCantBeTradedNow, + [UR_TRADE_MSG_PARTNERS_MON_CANT_BE_TRADED - 1] = gText_OtherTrainersPkmnCantBeTraded, + [UR_TRADE_MSG_EGG_CANT_BE_TRADED -1] = gText_EggCantBeTradedNow, + [UR_TRADE_MSG_PARTNER_CANT_ACCEPT_MON - 1] = gText_OtherTrainerCantAcceptPkmn, + [UR_TRADE_MSG_CANT_TRADE_WITH_PARTNER_1 - 1] = gText_CantTradeWithTrainer, + [UR_TRADE_MSG_CANT_TRADE_WITH_PARTNER_2 - 1] = gText_CantTradeWithTrainer, +}; + +const u16 sTMHMMoves[] = +{ + MOVE_FOCUS_PUNCH, + MOVE_DRAGON_CLAW, + MOVE_WATER_PULSE, + MOVE_CALM_MIND, + MOVE_ROAR, + MOVE_TOXIC, + MOVE_HAIL, + MOVE_BULK_UP, + MOVE_BULLET_SEED, + MOVE_HIDDEN_POWER, + MOVE_SUNNY_DAY, + MOVE_TAUNT, + MOVE_ICE_BEAM, + MOVE_BLIZZARD, + MOVE_HYPER_BEAM, + MOVE_LIGHT_SCREEN, + MOVE_PROTECT, + MOVE_RAIN_DANCE, + MOVE_GIGA_DRAIN, + MOVE_SAFEGUARD, + MOVE_FRUSTRATION, + MOVE_SOLAR_BEAM, + MOVE_IRON_TAIL, + MOVE_THUNDERBOLT, + MOVE_THUNDER, + MOVE_EARTHQUAKE, + MOVE_RETURN, + MOVE_DIG, + MOVE_PSYCHIC, + MOVE_SHADOW_BALL, + MOVE_BRICK_BREAK, + MOVE_DOUBLE_TEAM, + MOVE_REFLECT, + MOVE_SHOCK_WAVE, + MOVE_FLAMETHROWER, + MOVE_SLUDGE_BOMB, + MOVE_SANDSTORM, + MOVE_FIRE_BLAST, + MOVE_ROCK_TOMB, + MOVE_AERIAL_ACE, + MOVE_TORMENT, + MOVE_FACADE, + MOVE_SECRET_POWER, + MOVE_REST, + MOVE_ATTRACT, + MOVE_THIEF, + MOVE_STEEL_WING, + MOVE_SKILL_SWAP, + MOVE_SNATCH, + MOVE_OVERHEAT, + MOVE_CUT, + MOVE_FLY, + MOVE_SURF, + MOVE_STRENGTH, + MOVE_FLASH, + MOVE_ROCK_SMASH, + MOVE_WATERFALL, + MOVE_DIVE, +}; diff --git a/src/data/pokemon/tutor_learnsets.h b/src/data/pokemon/tutor_learnsets.h new file mode 100644 index 000000000..3f2fbf6a0 --- /dev/null +++ b/src/data/pokemon/tutor_learnsets.h @@ -0,0 +1,2813 @@ +const u16 sTutorMoves[TUTOR_MOVE_COUNT] = +{ + [TUTOR_MOVE_MEGA_PUNCH] = MOVE_MEGA_PUNCH, + [TUTOR_MOVE_SWORDS_DANCE] = MOVE_SWORDS_DANCE, + [TUTOR_MOVE_MEGA_KICK] = MOVE_MEGA_KICK, + [TUTOR_MOVE_BODY_SLAM] = MOVE_BODY_SLAM, + [TUTOR_MOVE_DOUBLE_EDGE] = MOVE_DOUBLE_EDGE, + [TUTOR_MOVE_COUNTER] = MOVE_COUNTER, + [TUTOR_MOVE_SEISMIC_TOSS] = MOVE_SEISMIC_TOSS, + [TUTOR_MOVE_MIMIC] = MOVE_MIMIC, + [TUTOR_MOVE_METRONOME] = MOVE_METRONOME, + [TUTOR_MOVE_SOFT_BOILED] = MOVE_SOFT_BOILED, + [TUTOR_MOVE_DREAM_EATER] = MOVE_DREAM_EATER, + [TUTOR_MOVE_THUNDER_WAVE] = MOVE_THUNDER_WAVE, + [TUTOR_MOVE_EXPLOSION] = MOVE_EXPLOSION, + [TUTOR_MOVE_ROCK_SLIDE] = MOVE_ROCK_SLIDE, + [TUTOR_MOVE_SUBSTITUTE] = MOVE_SUBSTITUTE, +}; + +#define TUTOR(move) (1u << (TUTOR_##move)) + +const u16 sTutorLearnsets[] = +{ + [SPECIES_NONE] = 0, + + [SPECIES_BULBASAUR] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_IVYSAUR] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VENUSAUR] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CHARMANDER] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CHARMELEON] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CHARIZARD] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SQUIRTLE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WARTORTLE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BLASTOISE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CATERPIE] = 0, + + [SPECIES_METAPOD] = 0, + + [SPECIES_BUTTERFREE] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WEEDLE] = 0, + + [SPECIES_KAKUNA] = 0, + + [SPECIES_BEEDRILL] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PIDGEY] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PIDGEOTTO] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PIDGEOT] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RATTATA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RATICATE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SPEAROW] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FEAROW] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_EKANS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ARBOK] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PIKACHU] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RAICHU] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SANDSHREW] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SANDSLASH] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NIDORAN_F] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NIDORINA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NIDOQUEEN] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NIDORAN_M] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NIDORINO] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NIDOKING] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CLEFAIRY] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CLEFABLE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VULPIX] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NINETALES] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_JIGGLYPUFF] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WIGGLYTUFF] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ZUBAT] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GOLBAT] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ODDISH] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GLOOM] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VILEPLUME] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PARAS] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PARASECT] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VENONAT] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VENOMOTH] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DIGLETT] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DUGTRIO] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MEOWTH] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PERSIAN] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PSYDUCK] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GOLDUCK] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MANKEY] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PRIMEAPE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GROWLITHE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ARCANINE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_POLIWAG] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_POLIWHIRL] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_POLIWRATH] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ABRA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KADABRA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ALAKAZAM] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MACHOP] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MACHOKE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MACHAMP] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BELLSPROUT] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WEEPINBELL] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VICTREEBEL] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TENTACOOL] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TENTACRUEL] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GEODUDE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GRAVELER] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GOLEM] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PONYTA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RAPIDASH] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SLOWPOKE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SLOWBRO] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAGNEMITE] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAGNETON] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FARFETCHD] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DODUO] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DODRIO] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SEEL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DEWGONG] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GRIMER] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MUK] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SHELLDER] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CLOYSTER] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GASTLY] = TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HAUNTER] = TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GENGAR] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ONIX] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DROWZEE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HYPNO] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KRABBY] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KINGLER] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VOLTORB] = TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ELECTRODE] = TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_EXEGGCUTE] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_EXEGGUTOR] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CUBONE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAROWAK] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HITMONLEE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HITMONCHAN] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LICKITUNG] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KOFFING] = TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WEEZING] = TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RHYHORN] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RHYDON] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CHANSEY] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TANGELA] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KANGASKHAN] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HORSEA] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SEADRA] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GOLDEEN] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SEAKING] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_STARYU] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_STARMIE] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MR_MIME] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SCYTHER] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_JYNX] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ELECTABUZZ] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAGMAR] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PINSIR] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TAUROS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAGIKARP] = 0, + + [SPECIES_GYARADOS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LAPRAS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DITTO] = 0, + + [SPECIES_EEVEE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VAPOREON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_JOLTEON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FLAREON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PORYGON] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_OMANYTE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_OMASTAR] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KABUTO] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KABUTOPS] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_AERODACTYL] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SNORLAX] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ARTICUNO] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ZAPDOS] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MOLTRES] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DRATINI] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DRAGONAIR] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DRAGONITE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MEWTWO] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MEW] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CHIKORITA] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BAYLEEF] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MEGANIUM] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CYNDAQUIL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_QUILAVA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TYPHLOSION] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TOTODILE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CROCONAW] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FERALIGATR] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SENTRET] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FURRET] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HOOTHOOT] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NOCTOWL] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LEDYBA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LEDIAN] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SPINARAK] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ARIADOS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CROBAT] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CHINCHOU] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LANTURN] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PICHU] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CLEFFA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_IGGLYBUFF] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TOGEPI] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TOGETIC] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NATU] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_XATU] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAREEP] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FLAAFFY] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_AMPHAROS] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BELLOSSOM] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MARILL] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_AZUMARILL] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SUDOWOODO] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_POLITOED] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HOPPIP] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SKIPLOOM] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_JUMPLUFF] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_AIPOM] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SUNKERN] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SUNFLORA] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_YANMA] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WOOPER] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_QUAGSIRE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ESPEON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_UMBREON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MURKROW] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SLOWKING] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MISDREAVUS] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_UNOWN] = 0, + + [SPECIES_WOBBUFFET] = 0, + + [SPECIES_GIRAFARIG] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PINECO] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FORRETRESS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DUNSPARCE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GLIGAR] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_STEELIX] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SNUBBULL] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GRANBULL] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_QWILFISH] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SCIZOR] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SHUCKLE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HERACROSS] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SNEASEL] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TEDDIURSA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_URSARING] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SLUGMA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAGCARGO] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SWINUB] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PILOSWINE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CORSOLA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_REMORAID] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_OCTILLERY] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DELIBIRD] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MANTINE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SKARMORY] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HOUNDOUR] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HOUNDOOM] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KINGDRA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PHANPY] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DONPHAN] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PORYGON2] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_STANTLER] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SMEARGLE] = 0, + + [SPECIES_TYROGUE] = TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HITMONTOP] = TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SMOOCHUM] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ELEKID] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAGBY] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MILTANK] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BLISSEY] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RAIKOU] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ENTEI] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SUICUNE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LARVITAR] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PUPITAR] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TYRANITAR] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LUGIA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HO_OH] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CELEBI] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TREECKO] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GROVYLE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SCEPTILE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TORCHIC] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_COMBUSKEN] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BLAZIKEN] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MUDKIP] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MARSHTOMP] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SWAMPERT] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_POOCHYENA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MIGHTYENA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ZIGZAGOON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LINOONE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WURMPLE] = 0, + + [SPECIES_SILCOON] = 0, + + [SPECIES_BEAUTIFLY] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CASCOON] = 0, + + [SPECIES_DUSTOX] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LOTAD] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LOMBRE] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LUDICOLO] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SEEDOT] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NUZLEAF] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SHIFTRY] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NINCADA] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NINJASK] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SHEDINJA] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TAILLOW] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SWELLOW] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SHROOMISH] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BRELOOM] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SPINDA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WINGULL] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PELIPPER] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SURSKIT] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MASQUERAIN] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WAILMER] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WAILORD] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SKITTY] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DELCATTY] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KECLEON] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BALTOY] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CLAYDOL] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NOSEPASS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TORKOAL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SABLEYE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BARBOACH] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WHISCASH] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LUVDISC] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CORPHISH] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CRAWDAUNT] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FEEBAS] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MILOTIC] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CARVANHA] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SHARPEDO] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TRAPINCH] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VIBRAVA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_FLYGON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAKUHITA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HARIYAMA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ELECTRIKE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MANECTRIC] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_NUMEL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CAMERUPT] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SPHEAL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SEALEO] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WALREIN] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CACNEA] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CACTURNE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SNORUNT] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GLALIE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LUNATONE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SOLROCK] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_AZURILL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SPOINK] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GRUMPIG] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_PLUSLE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MINUN] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MAWILE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MEDITITE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_MEDICHAM] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SWABLU] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ALTARIA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WYNAUT] = 0, + + [SPECIES_DUSKULL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DUSCLOPS] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ROSELIA] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SLAKOTH] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VIGOROTH] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SLAKING] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GULPIN] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SWALOT] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_TROPIUS] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_WHISMUR] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LOUDRED] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_EXPLOUD] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CLAMPERL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_HUNTAIL] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GOREBYSS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ABSOL] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SHUPPET] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BANETTE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SEVIPER] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ZANGOOSE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RELICANTH] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ARON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LAIRON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_AGGRON] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CASTFORM] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_VOLBEAT] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ILLUMISE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LILEEP] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CRADILY] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ANORITH] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_ARMALDO] = TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RALTS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KIRLIA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GARDEVOIR] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BAGON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SHELGON] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_SALAMENCE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_BELDUM] = 0, + + [SPECIES_METANG] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_METAGROSS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_REGIROCK] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_REGICE] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_REGISTEEL] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_KYOGRE] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_GROUDON] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_RAYQUAZA] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LATIAS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_LATIOS] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_JIRACHI] = TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_DEOXYS] = TUTOR(MOVE_MEGA_PUNCH) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), + + [SPECIES_CHIMECHO] = TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), +}; diff --git a/src/fldeff_softboiled.c b/src/fldeff_softboiled.c index 6840df686..d68d66d08 100644 --- a/src/fldeff_softboiled.c +++ b/src/fldeff_softboiled.c @@ -15,7 +15,7 @@ static void sub_80E5934(u8 taskId); extern const u8 gUnknown_84169F8[]; extern const u8 gText_PkmnHPRestoredByVar2[]; -bool8 hm_prepare_dive_probably(void) +bool8 SetUpFieldMove_SoftBoiled(void) { u16 maxHp = GetMonData(&gPlayerParty[GetCursorSelectionMonId()], MON_DATA_MAX_HP); u16 curHp = GetMonData(&gPlayerParty[GetCursorSelectionMonId()], MON_DATA_HP); @@ -28,8 +28,8 @@ bool8 hm_prepare_dive_probably(void) void ChooseMonForSoftboiled(u8 taskId) { - gPartyMenu.unkB = 10; - gPartyMenu.unkA = gPartyMenu.unk9; + gPartyMenu.action = 10; + gPartyMenu.slotId2 = gPartyMenu.slotId; AnimatePartySlot(GetCursorSelectionMonId(), 1); DisplayPartyMenuStdMessage(5); gTasks[taskId].func = Task_HandleChooseMonInput; @@ -37,14 +37,14 @@ void ChooseMonForSoftboiled(u8 taskId) void sub_80E5724(u8 taskId) { - u8 r8 = gPartyMenu.unk9; - u8 r5 = gPartyMenu.unkA; + u8 r8 = gPartyMenu.slotId; + u8 r5 = gPartyMenu.slotId2; u16 curHp; s16 delta; if (r5 > 6) { - gPartyMenu.unkB = 0; + gPartyMenu.action = 0; DisplayPartyMenuStdMessage(0); gTasks[taskId].func = Task_HandleChooseMonInput; } @@ -66,12 +66,12 @@ void sub_80E5724(u8 taskId) static void sub_80E57E8(u8 taskId) { PlaySE(SE_KAIFUKU); - PartyMenuModifyHP(taskId, gPartyMenu.unkA, 1, GetMonData(&gPlayerParty[gPartyMenu.unk9], MON_DATA_MAX_HP) / 5, sub_80E583C); + PartyMenuModifyHP(taskId, gPartyMenu.slotId2, 1, GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_MAX_HP) / 5, sub_80E583C); } static void sub_80E583C(u8 taskId) { - GetMonNickname(&gPlayerParty[gPartyMenu.unkA], gStringVar1); + GetMonNickname(&gPlayerParty[gPartyMenu.slotId2], gStringVar1); StringExpandPlaceholders(gStringVar4, gText_PkmnHPRestoredByVar2); DisplayPartyMenuMessage(gStringVar4, 0); ScheduleBgCopyTilemapToVram(2); @@ -82,10 +82,10 @@ static void sub_80E58A0(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { - gPartyMenu.unkB = 0; - AnimatePartySlot(gPartyMenu.unk9, 0); - gPartyMenu.unk9 = gPartyMenu.unkA; - AnimatePartySlot(gPartyMenu.unkA, 1); + gPartyMenu.action = 0; + AnimatePartySlot(gPartyMenu.slotId, 0); + gPartyMenu.slotId = gPartyMenu.slotId2; + AnimatePartySlot(gPartyMenu.slotId2, 1); ClearStdWindowAndFrameToTransparent(6, 0); ClearWindowTilemap(6); DisplayPartyMenuStdMessage(0); diff --git a/src/fldeff_sweetscent.c b/src/fldeff_sweetscent.c index c413f29c1..66529cd55 100644 --- a/src/fldeff_sweetscent.c +++ b/src/fldeff_sweetscent.c @@ -20,7 +20,7 @@ static void FailSweetScentEncounter(u8 taskId); static void Unused_StartSweetscentFldeff(void) { - gPartyMenu.unk9 = 0; + gPartyMenu.slotId = 0; FieldCallback_SweetScent(); } diff --git a/src/item_pc.c b/src/item_pc.c index 450e0d142..f4320cd41 100644 --- a/src/item_pc.c +++ b/src/item_pc.c @@ -1030,7 +1030,7 @@ static void Task_ItemPcGive(u8 taskId) static void ItemPc_CB2_SwitchToPartyMenu(void) { InitPartyMenu(0, 0, 6, 0, 6, Task_HandleChooseMonInput, ItemPc_CB2_ReturnFromPartyMenu); - gPartyMenu.unkC = ItemPc_GetItemIdBySlotId(ItemPc_GetCursorPosition()); + gPartyMenu.bagItem = ItemPc_GetItemIdBySlotId(ItemPc_GetCursorPosition()); } static void ItemPc_CB2_ReturnFromPartyMenu(void) diff --git a/src/party_menu.c b/src/party_menu.c new file mode 100644 index 000000000..674b329c2 --- /dev/null +++ b/src/party_menu.c @@ -0,0 +1,172 @@ +#include "global.h" +#include "malloc.h" +#include "battle.h" +#include "battle_anim.h" +#include "battle_controllers.h" +#include "battle_gfx_sfx_util.h" +#include "battle_interface.h" +#include "bg.h" +#include "data.h" +#include "decompress.h" +#include "easy_chat.h" +#include "event_data.h" +#include "evolution_scene.h" +#include "field_control_avatar.h" +#include "field_effect.h" +#include "field_player_avatar.h" +#include "field_screen_effect.h" +#include "field_specials.h" +#include "field_weather.h" +#include "fieldmap.h" +#include "fldeff.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "item.h" +#include "item_menu.h" +#include "item_use.h" +#include "link.h" +#include "link_rfu.h" +#include "mail.h" +#include "main.h" +#include "menu.h" +#include "menu_helpers.h" +#include "new_menu_helpers.h" +#include "metatile_behavior.h" +#include "overworld.h" +#include "palette.h" +#include "party_menu.h" +#include "player_pc.h" +#include "pokemon.h" +#include "pokemon_icon.h" +#include "pokemon_jump.h" +#include "pokemon_storage_system.h" +#include "pokemon_summary_screen.h" +#include "region_map.h" +#include "reshow_battle_screen.h" +#include "scanline_effect.h" +#include "script.h" +#include "sound.h" +#include "sprite.h" +#include "start_menu.h" +#include "string_util.h" +#include "strings.h" +#include "task.h" +#include "text.h" +#include "text_window.h" +#include "trade.h" +#include "union_room.h" +#include "window.h" +#include "constants/battle.h" +#include "constants/easy_chat.h" +#include "constants/field_effects.h" +#include "constants/flags.h" +#include "constants/item_effects.h" +#include "constants/items.h" +#include "constants/maps.h" +#include "constants/moves.h" +#include "constants/songs.h" +#include "constants/species.h" +#include "constants/vars.h" + +#define PARTY_PAL_SELECTED (1 << 0) +#define PARTY_PAL_FAINTED (1 << 1) +#define PARTY_PAL_TO_SWITCH (1 << 2) +#define PARTY_PAL_MULTI_ALT (1 << 3) +#define PARTY_PAL_SWITCHING (1 << 4) +#define PARTY_PAL_TO_SOFTBOIL (1 << 5) +#define PARTY_PAL_NO_MON (1 << 6) +#define PARTY_PAL_UNUSED (1 << 7) + +#define MENU_DIR_DOWN 1 +#define MENU_DIR_UP -1 +#define MENU_DIR_RIGHT 2 +#define MENU_DIR_LEFT -2 + +enum +{ + CAN_LEARN_MOVE, + CANNOT_LEARN_MOVE, + ALREADY_KNOWS_MOVE, + CANNOT_LEARN_MOVE_IS_EGG +}; + +struct PartyMenuBoxInfoRects +{ + void (*blitFunc)(u8 windowId, u8 x, u8 y, u8 width, u8 height, bool8 isEgg); + u8 dimensions[24]; + u8 descTextLeft; + u8 descTextTop; + u8 descTextWidth; + u8 descTextHeight; +}; + +struct PartyMenuInternal +{ + TaskFunc task; + MainCallback exitCallback; + u32 chooseHalf:1; + u32 lastSelectedSlot:3; // Used to return to same slot when going left/right bewtween columns + u32 spriteIdConfirmPokeball:7; + u32 spriteIdCancelPokeball:7; + u32 messageId:14; + u8 windowId[3]; + u8 actions[8]; + u8 numActions; + u16 palBuffer[BG_PLTT_SIZE / sizeof(u16)]; + s16 data[16]; +}; + +struct PartyMenuBox +{ + const struct PartyMenuBoxInfoRects *infoRects; + const u8 *spriteCoords; + u8 windowId; + u8 monSpriteId; + u8 itemSpriteId; + u8 pokeballSpriteId; + u8 statusSpriteId; +}; + +void BlitBitmapToPartyWindow_LeftColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, bool8 isEgg); +void BlitBitmapToPartyWindow_RightColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, bool8 isEgg); +void CursorCB_Summary(u8 taskId); +void CursorCB_Switch(u8 taskId); +void CursorCB_Cancel1(u8 taskId); +void CursorCB_Item(u8 taskId); +void CursorCB_Give(u8 taskId); +void CursorCB_TakeItem(u8 taskId); +void CursorCB_Mail(u8 taskId); +void CursorCB_Read(u8 taskId); +void CursorCB_TakeMail(u8 taskId); +void CursorCB_Cancel2(u8 taskId); +void CursorCB_SendMon(u8 taskId); +void CursorCB_Enter(u8 taskId); +void CursorCB_NoEntry(u8 taskId); +void CursorCB_Store(u8 taskId); +void CursorCB_Register(u8 taskId); +void CursorCB_Trade1(u8 taskId); +void CursorCB_Trade2(u8 taskId); +void CursorCB_FieldMove(u8 taskId); +bool8 SetUpFieldMove_Fly(void); +bool8 SetUpFieldMove_Waterfall(void); +bool8 SetUpFieldMove_Surf(void); + +EWRAM_DATA struct PartyMenuInternal *sPartyMenuInternal = NULL; +EWRAM_DATA struct PartyMenu gPartyMenu = {0}; +EWRAM_DATA struct PartyMenuBox *sPartyMenuBoxes = NULL; +EWRAM_DATA u8 *sPartyBgGfxTilemap = NULL; +EWRAM_DATA u8 *sPartyBgTilemapBuffer = NULL; +EWRAM_DATA bool8 gPartyMenuUseExitCallback = FALSE; +EWRAM_DATA u8 gSelectedMonPartyId = 0; +EWRAM_DATA MainCallback gPostMenuFieldCallback = NULL; +EWRAM_DATA u16 *sSlot1TilemapBuffer = NULL; // for switching party slots +EWRAM_DATA u16 *sSlot2TilemapBuffer = NULL; +EWRAM_DATA struct Pokemon *gUnknown_203B0D0 = NULL; +EWRAM_DATA u8 gSelectedOrderFromParty[4] = {0}; +EWRAM_DATA u16 sPartyMenuItemId = ITEM_NONE; +ALIGNED(4) EWRAM_DATA u8 gBattlePartyCurrentOrder[PARTY_SIZE / 2] = {0}; // bits 0-3 are the current pos of Slot 1, 4-7 are Slot 2, and so on + +void (*gItemUseCB)(u8, TaskFunc); + +#include "data/pokemon/tutor_learnsets.h" +#include "data/party_menu.h" diff --git a/src/trade.c b/src/trade.c index 792f1524b..85bd7b2ca 100644 --- a/src/trade.c +++ b/src/trade.c @@ -459,9 +459,9 @@ static const u8 *const sTradeErrorOrStatusMessagePtrs[] = { gUnknown_8417094, // That's your only POKéMON for battle gUnknown_841E199, // Waiting for your friend to finish gUnknown_841E1C5, // Your friend wants to trade POKéMON - gUnknown_84170BC, // That POKéMON can't be traded now - gUnknown_84170E0, // An EGG can't be traded now - gUnknown_84170FC // The other TRAINER's POKéMON can't be traded now + gText_PkmnCantBeTradedNow, // That POKéMON can't be traded now + gText_EggCantBeTradedNow, // An EGG can't be traded now + gText_OtherTrainersPkmnCantBeTraded // The other TRAINER's POKéMON can't be traded now }; static const u8 gUnknown_8261F18[] = { 0, 1, 2 }; -- cgit v1.2.3 From 069eb2baed314133a9d72658c07126e73b3b3db1 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Fri, 22 Nov 2019 06:46:04 +0800 Subject: party_menu first quarter --- src/berry_pouch.c | 2 +- src/data/party_menu.h | 18 - src/fldeff_softboiled.c | 2 +- src/item_pc.c | 2 +- src/item_use.c | 137 ++-- src/menu.c | 8 +- src/menu_helpers.c | 4 +- src/new_menu_helpers.c | 2 +- src/party_menu.c | 1787 +++++++++++++++++++++++++++++++++++++++++++++++ src/tm_case.c | 2 +- 10 files changed, 1866 insertions(+), 98 deletions(-) (limited to 'src') diff --git a/src/berry_pouch.c b/src/berry_pouch.c index 466fe7927..bb1b106af 100644 --- a/src/berry_pouch.c +++ b/src/berry_pouch.c @@ -765,7 +765,7 @@ static void PrintSelectedBerryDescription(s32 itemIdx) static void SetDescriptionWindowBorderPalette(s32 pal) { - SetBgRectPal(1, 0, 16, 30, 4, pal + 1); + SetBgTilemapPalette(1, 0, 16, 30, 4, pal + 1); ScheduleBgCopyTilemapToVram(1); } diff --git a/src/data/party_menu.h b/src/data/party_menu.h index fde1a80f8..c00fe3613 100644 --- a/src/data/party_menu.h +++ b/src/data/party_menu.h @@ -110,24 +110,6 @@ const u8 sPartyMenuSpriteCoords[PARTY_LAYOUT_COUNT][PARTY_SIZE][4 * 2] = const u32 sConfirmButton_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_confirm_button.bin"); const u32 sCancelButton_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_cancel_button.bin"); -// NOTE TO MYSELF: remove these after #159 gets merged -#define TEXT_COLOR_TRANSPARENT 0x0 -#define TEXT_COLOR_WHITE 0x1 -#define TEXT_COLOR_DARK_GREY 0x2 -#define TEXT_COLOR_LIGHT_GREY 0x3 -#define TEXT_COLOR_RED 0x4 -#define TEXT_COLOR_LIGHT_RED 0x5 -#define TEXT_COLOR_GREEN 0x6 -#define TEXT_COLOR_LIGHT_GREEN 0x7 -#define TEXT_COLOR_BLUE 0x8 -#define TEXT_COLOR_LIGHT_BLUE 0x9 -#define TEXT_DYNAMIC_COLOR_1 0xA // Usually white -#define TEXT_DYNAMIC_COLOR_2 0xB // Usually white w/ tinge of green -#define TEXT_DYNAMIC_COLOR_3 0xC // Usually white -#define TEXT_DYNAMIC_COLOR_4 0xD // Usually aquamarine -#define TEXT_DYNAMIC_COLOR_5 0xE // Usually blue-green -#define TEXT_DYNAMIC_COLOR_6 0xF // Usually cerulean - const u8 sFontColorTable[][3] = { {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_LIGHT_GREY, TEXT_COLOR_DARK_GREY}, // Default diff --git a/src/fldeff_softboiled.c b/src/fldeff_softboiled.c index d68d66d08..60437c125 100644 --- a/src/fldeff_softboiled.c +++ b/src/fldeff_softboiled.c @@ -35,7 +35,7 @@ void ChooseMonForSoftboiled(u8 taskId) gTasks[taskId].func = Task_HandleChooseMonInput; } -void sub_80E5724(u8 taskId) +void Task_TryUseSoftboiledOnPartyMon(u8 taskId) { u8 r8 = gPartyMenu.slotId; u8 r5 = gPartyMenu.slotId2; diff --git a/src/item_pc.c b/src/item_pc.c index f4320cd41..f30cf1381 100644 --- a/src/item_pc.c +++ b/src/item_pc.c @@ -709,7 +709,7 @@ static void ItemPc_SetScrollPosition(void) static void ItemPc_SetMessageWindowPalette(int a0) { - SetBgRectPal(1, 0, 14, 30, 6, a0 + 1); + SetBgTilemapPalette(1, 0, 14, 30, 6, a0 + 1); ScheduleBgCopyTilemapToVram(1); } diff --git a/src/item_use.c b/src/item_use.c index 73ad9a284..70673d681 100644 --- a/src/item_use.c +++ b/src/item_use.c @@ -44,37 +44,36 @@ #include "constants/songs.h" #include "constants/map_types.h" -EWRAM_DATA void (*sItemUseOnFieldCB)(u8 taskId) = NULL; - -void sub_80A1084(void); -void sub_80A109C(u8 taskId); -void sub_80A112C(u8 taskId); -void sub_80A11C0(u8 taskId); -bool8 sub_80A1194(void); -void sub_80A1208(void); -void ItemUseOnFieldCB_Bicycle(u8 taskId); -bool8 ItemUseCheckFunc_Rod(void); -void ItemUseOnFieldCB_Rod(u8 taskId); -void FieldUseFunc_EvoItem(u8 taskId); -void sub_80A1648(u8 taskId); -void sub_80A1674(u8 taskId); -void InitTMCaseFromBag(void); -void Task_InitTMCaseFromField(u8 taskId); -void InitBerryPouchFromBag(void); -void Task_InitBerryPouchFromField(u8 taskId); -void InitBerryPouchFromBattle(void); -void InitTeachyTvFromBag(void); -void Task_InitTeachyTvFromField(u8 taskId); -void sub_80A19E8(u8 taskId); -void sub_80A1A44(void); -void sub_80A1B48(u8 taskId); -void sub_80A1C08(u8 taskId); -void sub_80A1CAC(void); -void sub_80A1CC0(u8 taskId); -void sub_80A1D58(void); -void sub_80A1D68(u8 taskId); -void Task_BattleUse_StatBooster_DelayAndPrint(u8 taskId); -void Task_BattleUse_StatBooster_WaitButton_ReturnToBattle(u8 taskId); +static EWRAM_DATA void (*sItemUseOnFieldCB)(u8 taskId) = NULL; + +static void sub_80A1084(void); +static void sub_80A109C(u8 taskId); +static void sub_80A112C(u8 taskId); +static void sub_80A11C0(u8 taskId); +static bool8 sub_80A1194(void); +static void sub_80A1208(void); +static void ItemUseOnFieldCB_Bicycle(u8 taskId); +static bool8 ItemUseCheckFunc_Rod(void); +static void ItemUseOnFieldCB_Rod(u8 taskId); +static void sub_80A1648(u8 taskId); +static void sub_80A1674(u8 taskId); +static void InitTMCaseFromBag(void); +static void Task_InitTMCaseFromField(u8 taskId); +static void InitBerryPouchFromBag(void); +static void Task_InitBerryPouchFromField(u8 taskId); +static void InitBerryPouchFromBattle(void); +static void InitTeachyTvFromBag(void); +static void Task_InitTeachyTvFromField(u8 taskId); +static void sub_80A19E8(u8 taskId); +static void sub_80A1A44(void); +static void sub_80A1B48(u8 taskId); +static void sub_80A1C08(u8 taskId); +static void sub_80A1CAC(void); +static void sub_80A1CC0(u8 taskId); +static void sub_80A1D58(void); +static void sub_80A1D68(u8 taskId); +static void Task_BattleUse_StatBooster_DelayAndPrint(u8 taskId); +static void Task_BattleUse_StatBooster_WaitButton_ReturnToBattle(u8 taskId); // No clue what this is static const u8 sUnref_83E27B4[] = { @@ -132,14 +131,14 @@ static const u8 sUnref_83E27B4[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; -void (*const gUnknown_83E2954[])(void) = { +static void (*const gUnknown_83E2954[])(void) = { CB2_ShowPartyMenuForItemUse, CB2_ReturnToField, NULL, NULL }; -void sub_80A0FBC(u8 taskId) +static void sub_80A0FBC(u8 taskId) { u8 itemType; if (gSpecialVar_ItemId == ITEM_ENIGMA_BERRY) @@ -160,7 +159,7 @@ void sub_80A0FBC(u8 taskId) } } -void sub_80A103C(u8 taskId) +static void sub_80A103C(u8 taskId) { if (gTasks[taskId].data[3] != 1) { @@ -171,13 +170,13 @@ void sub_80A103C(u8 taskId) sItemUseOnFieldCB(taskId); } -void sub_80A1084(void) +static void sub_80A1084(void) { sub_807DC00(); CreateTask(sub_80A109C, 8); } -void sub_80A109C(u8 taskId) +static void sub_80A109C(u8 taskId) { if (IsWeatherNotFadingIn() == TRUE) { @@ -185,7 +184,7 @@ void sub_80A109C(u8 taskId) } } -void sub_80A10C4(u8 taskId, bool8 a1, u8 a2, const u8 * str) +static void sub_80A10C4(u8 taskId, bool8 a1, u8 a2, const u8 * str) { StringExpandPlaceholders(gStringVar4, str); if (a1 == FALSE) @@ -194,12 +193,12 @@ void sub_80A10C4(u8 taskId, bool8 a1, u8 a2, const u8 * str) DisplayItemMessageOnField(taskId, a2, gStringVar4, sub_80A112C); } -void sub_80A1110(u8 taskId, bool8 a1) +static void sub_80A1110(u8 taskId, bool8 a1) { sub_80A10C4(taskId, a1, 4, gUnknown_8416425); } -void sub_80A112C(u8 taskId) +static void sub_80A112C(u8 taskId) { ClearDialogWindowAndFrame(0, 1); DestroyTask(taskId); @@ -207,7 +206,7 @@ void sub_80A112C(u8 taskId) ScriptContext2_Disable(); } -u8 GetItemCompatibilityRule(u16 itemId) +u8 CheckIfItemIsTMHMOrEvolutionStone(u16 itemId) { if (ItemId_GetPocket(itemId) == POCKET_TM_CASE) return 1; @@ -217,12 +216,12 @@ u8 GetItemCompatibilityRule(u16 itemId) return 0; } -void sub_80A1184(void) +static void sub_80A1184(void) { gFieldCallback2 = sub_80A1194; } -bool8 sub_80A1194(void) +static bool8 sub_80A1194(void) { FreezeEventObjects(); ScriptContext2_Enable(); @@ -232,7 +231,7 @@ bool8 sub_80A1194(void) return TRUE; } -void sub_80A11C0(u8 taskId) +static void sub_80A11C0(u8 taskId) { if (IsWeatherNotFadingIn() == TRUE) { @@ -248,7 +247,7 @@ void FieldUseFunc_OrangeMail(u8 taskId) ItemMenu_StartFadeToExitCallback(taskId); } -void sub_80A1208(void) +static void sub_80A1208(void) { struct MailStruct mail; @@ -279,7 +278,7 @@ void FieldUseFunc_MachBike(u8 taskId) sub_80A1110(taskId, gTasks[taskId].data[3]); } -void ItemUseOnFieldCB_Bicycle(u8 taskId) +static void ItemUseOnFieldCB_Bicycle(u8 taskId) { if (!TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE)) PlaySE(SE_JITENSYA); @@ -300,7 +299,7 @@ void FieldUseFunc_OldRod(u8 taskId) sub_80A1110(taskId, gTasks[taskId].data[3]); } -bool8 ItemUseCheckFunc_Rod(void) +static bool8 ItemUseCheckFunc_Rod(void) { s16 x, y; u16 behavior; @@ -327,7 +326,7 @@ bool8 ItemUseCheckFunc_Rod(void) return FALSE; } -void ItemUseOnFieldCB_Rod(u8 taskId) +static void ItemUseOnFieldCB_Rod(u8 taskId) { sub_805D2C0(ItemId_GetSecondaryId(gSpecialVar_ItemId)); DestroyTask(taskId); @@ -391,13 +390,13 @@ void FieldUseFunc_PokeFlute(u8 taskId) } } -void sub_80A1648(u8 taskId) +static void sub_80A1648(u8 taskId) { PlayFanfareByFanfareNum(FANFARE_POKEFLUTE); gTasks[taskId].func = sub_80A1674; } -void sub_80A1674(u8 taskId) +static void sub_80A1674(u8 taskId) { if (WaitFanfare(FALSE)) { @@ -408,7 +407,7 @@ void sub_80A1674(u8 taskId) } } -void sub_80A16D0(u8 taskId) +static void sub_80A16D0(u8 taskId) { sub_80A0FBC(taskId); } @@ -464,12 +463,12 @@ void FieldUseFunc_TmCase(u8 taskId) } } -void InitTMCaseFromBag(void) +static void InitTMCaseFromBag(void) { InitTMCase(0, CB2_BagMenuFromStartMenu, 0); } -void Task_InitTMCaseFromField(u8 taskId) +static void Task_InitTMCaseFromField(u8 taskId) { if (!gPaletteFade.active) { @@ -495,12 +494,12 @@ void FieldUseFunc_BerryPouch(u8 taskId) } } -void InitBerryPouchFromBag(void) +static void InitBerryPouchFromBag(void) { InitBerryPouch(BERRYPOUCH_FROMFIELD, CB2_BagMenuFromStartMenu, 0); } -void Task_InitBerryPouchFromField(u8 taskId) +static void Task_InitBerryPouchFromField(u8 taskId) { if (!gPaletteFade.active) { @@ -517,7 +516,7 @@ void BattleUseFunc_BerryPouch(u8 taskId) ItemMenu_StartFadeToExitCallback(taskId); } -void InitBerryPouchFromBattle(void) +static void InitBerryPouchFromBattle(void) { InitBerryPouch(BERRYPOUCH_FROMBATTLE, sub_8107ECC, 0); } @@ -538,12 +537,12 @@ void FieldUseFunc_TeachyTv(u8 taskId) } } -void InitTeachyTvFromBag(void) +static void InitTeachyTvFromBag(void) { InitTeachyTvController(0, CB2_BagMenuFromStartMenu); } -void Task_InitTeachyTvFromField(u8 taskId) +static void Task_InitTeachyTvFromField(u8 taskId) { if (!gPaletteFade.active) { @@ -566,7 +565,7 @@ void FieldUseFunc_SuperRepel(u8 taskId) DisplayItemMessageInBag(taskId, 2, gUnknown_841659E, sub_810A1F8); } -void sub_80A19E8(u8 taskId) +static void sub_80A19E8(u8 taskId) { if (!IsSEPlaying()) { @@ -577,7 +576,7 @@ void sub_80A19E8(u8 taskId) } } -void sub_80A1A44(void) +static void sub_80A1A44(void) { RemoveBagItem(gSpecialVar_ItemId, 1); sub_8108DC8(ItemId_GetPocket(gSpecialVar_ItemId)); @@ -609,7 +608,7 @@ void FieldUseFunc_BlackFlute(u8 taskId) } } -void sub_80A1B48(u8 taskId) +static void sub_80A1B48(u8 taskId) { if (++gTasks[taskId].data[8] > 7) { @@ -638,7 +637,7 @@ void ItemUseOutOfBattle_EscapeRope(u8 taskId) sub_80A1110(taskId, gTasks[taskId].data[3]); } -void sub_80A1C08(u8 taskId) +static void sub_80A1C08(u8 taskId) { Overworld_ResetStateAfterDigEscRope(); sub_80A1A44(); @@ -668,12 +667,12 @@ void FieldUseFunc_TownMap(u8 taskId) } } -void sub_80A1CAC(void) +static void sub_80A1CAC(void) { sub_80BFF50(0, CB2_BagMenuFromStartMenu); } -void sub_80A1CC0(u8 taskId) +static void sub_80A1CC0(u8 taskId) { if (!gPaletteFade.active) { @@ -700,12 +699,12 @@ void FieldUseFunc_FameChecker(u8 taskId) } } -void sub_80A1D58(void) +static void sub_80A1D58(void) { UseFameChecker(CB2_BagMenuFromStartMenu); } -void sub_80A1D68(u8 taskId) +static void sub_80A1D68(u8 taskId) { if (!gPaletteFade.active) { @@ -774,7 +773,7 @@ void BattleUseFunc_GuardSpec(u8 taskId) } } -void Task_BattleUse_StatBooster_DelayAndPrint(u8 taskId) +static void Task_BattleUse_StatBooster_DelayAndPrint(u8 taskId) { s16 * data = gTasks[taskId].data; @@ -787,7 +786,7 @@ void Task_BattleUse_StatBooster_DelayAndPrint(u8 taskId) } } -void Task_BattleUse_StatBooster_WaitButton_ReturnToBattle(u8 taskId) +static void Task_BattleUse_StatBooster_WaitButton_ReturnToBattle(u8 taskId) { if (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON)) { @@ -796,7 +795,7 @@ void Task_BattleUse_StatBooster_WaitButton_ReturnToBattle(u8 taskId) } } -void ItemUse_SwitchToPartyMenuInBattle(u8 taskId) +static void ItemUse_SwitchToPartyMenuInBattle(u8 taskId) { if (GetPocketByItemId(gSpecialVar_ItemId) == POCKET_BERRY_POUCH) { @@ -816,7 +815,7 @@ void BattleUseFunc_Medicine(u8 taskId) ItemUse_SwitchToPartyMenuInBattle(taskId); } -void sub_80A1FD8(u8 taskId) +static void sub_80A1FD8(u8 taskId) { gItemUseCB = ItemUseCB_SacredAsh; ItemUse_SwitchToPartyMenuInBattle(taskId); diff --git a/src/menu.c b/src/menu.c index b8a68145c..5a0da28b9 100644 --- a/src/menu.c +++ b/src/menu.c @@ -815,13 +815,13 @@ static s8 sub_81106F4(void) MultichoiceGrid_MoveCursor(0, 1); return MENU_NOTHING_CHOSEN; } - else if (JOY_REPT(DPAD_ANY) == DPAD_LEFT || sub_80BF66C() == 1) + else if (JOY_REPT(DPAD_ANY) == DPAD_LEFT || GetLRKeysPressedAndHeld() == 1) { PlaySE(SE_SELECT); MultichoiceGrid_MoveCursor(-1, 0); return MENU_NOTHING_CHOSEN; } - else if (JOY_REPT(DPAD_ANY) == DPAD_RIGHT || sub_80BF66C() == 2) + else if (JOY_REPT(DPAD_ANY) == DPAD_RIGHT || GetLRKeysPressedAndHeld() == 2) { PlaySE(SE_SELECT); MultichoiceGrid_MoveCursor(1, 0); @@ -857,13 +857,13 @@ static s8 sub_81107A0(void) PlaySE(SE_SELECT); return MENU_NOTHING_CHOSEN; } - else if (JOY_REPT(DPAD_ANY) == DPAD_LEFT || sub_80BF66C() == 1) + else if (JOY_REPT(DPAD_ANY) == DPAD_LEFT || GetLRKeysPressedAndHeld() == 1) { if (oldPos != MultichoiceGrid_MoveCursorIfValid(-1, 0)) PlaySE(SE_SELECT); return MENU_NOTHING_CHOSEN; } - else if (JOY_REPT(DPAD_ANY) == DPAD_RIGHT || sub_80BF66C() == 2) + else if (JOY_REPT(DPAD_ANY) == DPAD_RIGHT || GetLRKeysPressedAndHeld() == 2) { if (oldPos != MultichoiceGrid_MoveCursorIfValid(1, 0)) PlaySE(SE_SELECT); diff --git a/src/menu_helpers.c b/src/menu_helpers.c index f17bff0d0..905e3c1ea 100644 --- a/src/menu_helpers.c +++ b/src/menu_helpers.c @@ -83,7 +83,7 @@ u8 GetLRKeysState(void) return 0; } -u8 sub_80BF66C(void) +u8 GetLRKeysPressedAndHeld(void) { if (gSaveBlock2Ptr->optionsButtonMode == OPTIONS_BUTTON_MODE_LR) { @@ -149,7 +149,7 @@ void SetVBlankHBlankCallbacksToNull(void) SetHBlankCallback(NULL); } -void ClearVramOamPltt(void) +void ResetVramOamAndBgCntRegs(void) { ResetAllBgsCoordinatesAndBgCntRegs(); CpuFill16(0, (void*) VRAM, VRAM_SIZE); diff --git a/src/new_menu_helpers.c b/src/new_menu_helpers.c index f879e6810..decd000d6 100644 --- a/src/new_menu_helpers.c +++ b/src/new_menu_helpers.c @@ -343,7 +343,7 @@ static u16 CopyDecompressedTileDataToVram(u8 bgId, const void *src, u16 size, u1 return LoadBgTilemap(bgId, src, size, offset); } -void SetBgRectPal(u8 bgId, u8 left, u8 top, u8 width, u8 height, u8 palette) +void SetBgTilemapPalette(u8 bgId, u8 left, u8 top, u8 width, u8 height, u8 palette) { u8 i, j; u16 *ptr = GetBgTilemapBuffer(bgId); diff --git a/src/party_menu.c b/src/party_menu.c index 674b329c2..73965c4ae 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -21,12 +21,14 @@ #include "fldeff.h" #include "gpu_regs.h" #include "graphics.h" +#include "help_system.h" #include "item.h" #include "item_menu.h" #include "item_use.h" #include "link.h" #include "link_rfu.h" #include "mail.h" +#include "mail_data.h" #include "main.h" #include "menu.h" #include "menu_helpers.h" @@ -150,6 +152,117 @@ void CursorCB_FieldMove(u8 taskId); bool8 SetUpFieldMove_Fly(void); bool8 SetUpFieldMove_Waterfall(void); bool8 SetUpFieldMove_Surf(void); +void CB2_InitPartyMenu(void); +void ResetPartyMenu(void); +bool8 ShowPartyMenu(void); +void SetPartyMonsAllowedInMinigame(void); +void ExitPartyMenu(void); +bool8 CreatePartyMonSpritesLoop(void); +bool8 AllocPartyMenuBg(void); +bool8 AllocPartyMenuBgGfx(void); +void InitPartyMenuWindows(u8 layout); +void InitPartyMenuBoxes(u8 layout); +void LoadPartyMenuPokeballGfx(void); +void LoadPartyMenuAilmentGfx(void); +bool8 RenderPartyMenuBoxes(void); +void CreateCancelConfirmPokeballSprites(void); +void CreateCancelConfirmWindows(bool8 chooseHalf); +void Task_ExitPartyMenu(u8 taskId); +void FreePartyPointers(void); +void PartyPaletteBufferCopy(u8 offset); +void DisplayPartyPokemonDataForMultiBattle(u8 slot); +void DisplayPartyPokemonDataForChooseHalf(u8 slot); +bool8 DisplayPartyPokemonDataForMoveTutorOrEvolutionItem(u8 slot); +void DisplayPartyPokemonData(u8 slot); +void DisplayPartyPokemonDataForWirelessMinigame(u8 slot); +void LoadPartyBoxPalette(struct PartyMenuBox *menuBox, u8 palFlags); +void DrawEmptySlot(u8 windowId); +void DisplayPartyPokemonNickname(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +void DisplayPartyPokemonLevelCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +void DisplayPartyPokemonGenderNidoranCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +void DisplayPartyPokemonHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +void DisplayPartyPokemonMaxHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +void DisplayPartyPokemonHPBarCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox); +void DisplayPartyPokemonDescriptionText(u8 stringId, struct PartyMenuBox *menuBox, u8 c); +bool8 GetBattleEntryEligibility(struct Pokemon *mon); +bool8 IsMonAllowedInMinigame(u8 slot); +void DisplayPartyPokemonDataToTeachMove(u8 slot, u16 item, u8 tutor); +u8 CanMonLearnTMTutor(struct Pokemon *mon, u16 item, u8 tutor); +void DisplayPartyPokemonBarDetail(u8 windowId, const u8 *str, u8 color, const u8 *align); +void DisplayPartyPokemonLevel(u8 level, struct PartyMenuBox *menuBox); +void DisplayPartyPokemonGender(u8 gender, u16 species, u8 *nickname, struct PartyMenuBox *menuBox); +void DisplayPartyPokemonHP(u16 hp, struct PartyMenuBox *menuBox); +void DisplayPartyPokemonMaxHP(u16 maxhp, struct PartyMenuBox *menuBox); +void DisplayPartyPokemonHPBar(u16 hp, u16 maxhp, struct PartyMenuBox *menuBox); +void CreatePartyMonIconSpriteParameterized(u16 species, u32 pid, struct PartyMenuBox *menuBox, u8 priority, bool32 handleDeoxys); +void CreatePartyMonHeldItemSpriteParameterized(u16 species, u16 item, struct PartyMenuBox *menuBox); +void CreatePartyMonPokeballSpriteParameterized(u16 species, struct PartyMenuBox *menuBox); +void CreatePartyMonStatusSpriteParameterized(u16 species, u8 status, struct PartyMenuBox *menuBox); +void CreatePartyMonIconSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox, u32 slot); +void CreatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); +void CreatePartyMonPokeballSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); +void CreatePartyMonStatusSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); +void CreateCancelConfirmPokeballSprites(void); +void DrawCancelConfirmButtons(void); +u8 CreatePokeballButtonSprite(u8 x, u8 y); +u8 CreateSmallPokeballButtonSprite(u8 x, u8 y); +u8 GetPartyBoxPaletteFlags(u8 slot, u8 animNum); +void AnimateSelectedPartyIcon(u8 spriteId, u8 animNum); +void PartyMenuStartSpriteAnim(u8 spriteId, u8 animNum); +void Task_ClosePartyMenuAndSetCB2(u8 taskId); +void UpdatePartyToFieldOrder(void); +s8 *GetCurrentPartySlotPtr(void); +u16 PartyMenuButtonHandler(s8 *slotPtr); +void HandleChooseMonSelection(u8 taskId, s8 *slotPtr); +void HandleChooseMonCancel(u8 taskId, s8 *slotPtr); +void MoveCursorToConfirm(void); +bool8 IsSelectedMonNotEgg(u8 *slotPtr); +void TryTutorSelectedMon(u8 taskId); +void TryGiveMailToSelectedMon(u8 taskId); +void SwitchSelectedMons(u8 taskId); +void TryEnterMonForMinigame(u8 taskId, u8 slot); +void Task_TryCreateSelectionWindow(u8 taskId); +void TryGiveItemOrMailToSelectedMon(u8 taskId); +void PartyMenuRemoveWindow(u8 *ptr); +void CB2_SetUpExitToBattleScreen(void); +void Task_ClosePartyMenuAfterText(u8 taskId); +void FinishTwoMonAction(u8 taskId); +void CancelParticipationPrompt(u8 taskId); +void DisplayCancelChooseMonYesNo(u8 taskId); +void Task_CancelChooseMonYesNo(u8 taskId); +void Task_HandleCancelChooseMonYesNoInput(u8 taskId); +void PartyMenuDisplayYesNoMenu(void); +void Task_ReturnToChooseMonAfterText(u8 taskId); +void UpdateCurrentPartySelection(s8 *slotPtr, s8 movementDir); +void UpdatePartySelectionSingleLayout(s8 *slotPtr, s8 movementDir); +void UpdatePartySelectionDoubleLayout(s8 *slotPtr, s8 movementDir); +s8 GetNewSlotDoubleLayout(s8 slotId, s8 movementDir); +void Task_PrintAndWaitForText(u8 taskId); +void PartyMenuPrintText(const u8 *text); +void sub_8124B60(struct Pokemon *mon, u16 item, u16 item2); +bool16 IsMonAllowedInPokemonJump(struct Pokemon *mon); +bool16 IsMonAllowedInDodrioBerryPicking(struct Pokemon *mon); +void Task_CancelParticipationYesNo(u8 taskId); +void Task_HandleCancelParticipationYesNoInput(u8 taskId); +void Task_TryCreateSelectionWindow(u8 taskId); +u16 GetTutorMove(u8 tutor); +bool8 CanLearnTutorMove(u16 species, u8 tutor); +void sub_8120C6C(u8 taskId); +void sub_8120CA8(u8 taskId); +void sub_8120CD8(u8 taskId); +void sub_8120D08(u8 taskId); +void sub_8120D40(u8 taskId); +void sub_8120D7C(u8 taskId); +void sub_8120DAC(u8 taskId); +void sub_8120DE0(u8 taskId); +void sub_8120E1C(u8 taskId); +void sub_8120E58(u8 taskId); +void sub_8120EE0(u8 taskId); +bool8 sub_8120F78(u8 taskId); +bool8 sub_81220D4(void); +void sub_8122084(u8 windowId, const u8 *str); +void sub_8122110(u8 windowId); +void CreateSelectionWindow(void); EWRAM_DATA struct PartyMenuInternal *sPartyMenuInternal = NULL; EWRAM_DATA struct PartyMenu gPartyMenu = {0}; @@ -170,3 +283,1677 @@ void (*gItemUseCB)(u8, TaskFunc); #include "data/pokemon/tutor_learnsets.h" #include "data/party_menu.h" + +void InitPartyMenu(u8 menuType, u8 layout, u8 partyAction, bool8 keepCursorPos, u8 messageId, TaskFunc task, MainCallback callback) +{ + u16 i; + + ResetPartyMenu(); + sPartyMenuInternal = Alloc(sizeof(struct PartyMenuInternal)); + if (sPartyMenuInternal == NULL) + { + SetMainCallback2(callback); + } + else + { + gPartyMenu.menuType = menuType; + gPartyMenu.exitCallback = callback; + gPartyMenu.action = partyAction; + sPartyMenuInternal->messageId = messageId; + sPartyMenuInternal->task = task; + sPartyMenuInternal->exitCallback = NULL; + sPartyMenuInternal->lastSelectedSlot = 0; + if (menuType == PARTY_MENU_TYPE_CHOOSE_HALF) + sPartyMenuInternal->chooseHalf = TRUE; + else + sPartyMenuInternal->chooseHalf = FALSE; + if (layout != KEEP_PARTY_LAYOUT) + gPartyMenu.layout = layout; + for (i = 0; i < NELEMS(sPartyMenuInternal->data); ++i) + sPartyMenuInternal->data[i] = 0; + for (i = 0; i < NELEMS(sPartyMenuInternal->windowId); ++i) + sPartyMenuInternal->windowId[i] = 0xFF; + if (!keepCursorPos) + gPartyMenu.slotId = 0; + else if (gPartyMenu.slotId > PARTY_SIZE - 1 || GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES) == SPECIES_NONE) + gPartyMenu.slotId = 0; + gTextFlags.autoScroll = FALSE; + CalculatePlayerPartyCount(); + SetMainCallback2(CB2_InitPartyMenu); + } +} + +void CB2_UpdatePartyMenu(void) +{ + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + DoScheduledBgTilemapCopiesToVram(); + UpdatePaletteFade(); +} + +void VBlankCB_PartyMenu(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +void CB2_InitPartyMenu(void) +{ + while (TRUE) + { + if (sub_80BF748() == TRUE || ShowPartyMenu() == TRUE || MenuHelpers_LinkSomething() == TRUE) + break; + } +} + +bool8 ShowPartyMenu(void) +{ + switch (gMain.state) + { + case 0: + SetVBlankHBlankCallbacksToNull(); + ResetVramOamAndBgCntRegs(); + ClearScheduledBgCopiesToVram(); + ++gMain.state; + break; + case 1: + ScanlineEffect_Stop(); + ++gMain.state; + break; + case 2: + ResetPaletteFade(); + gPaletteFade.bufferTransferDisabled = TRUE; + ++gMain.state; + break; + case 3: + ResetSpriteData(); + ++gMain.state; + break; + case 4: + FreeAllSpritePalettes(); + ++gMain.state; + break; + case 5: + if (!MenuHelpers_LinkSomething()) + ResetTasks(); + ++gMain.state; + break; + case 6: + SetPartyMonsAllowedInMinigame(); + ++gMain.state; + break; + case 7: + if (!AllocPartyMenuBg()) + { + ExitPartyMenu(); + return TRUE; + } + else + { + sPartyMenuInternal->data[0] = 0; + ++gMain.state; + } + break; + case 8: + if (AllocPartyMenuBgGfx()) + ++gMain.state; + break; + case 9: + InitPartyMenuWindows(gPartyMenu.layout); + ++gMain.state; + break; + case 10: + InitPartyMenuBoxes(gPartyMenu.layout); + sPartyMenuInternal->data[0] = 0; + ++gMain.state; + break; + case 11: + LoadHeldItemIcons(); + ++gMain.state; + break; + case 12: + LoadPartyMenuPokeballGfx(); + ++gMain.state; + break; + case 13: + LoadPartyMenuAilmentGfx(); + ++gMain.state; + break; + case 14: + LoadMonIconPalettes(); + ++gMain.state; + break; + case 15: + if (CreatePartyMonSpritesLoop()) + { + sPartyMenuInternal->data[0] = 0; + ++gMain.state; + } + break; + case 16: + if (RenderPartyMenuBoxes()) + { + sPartyMenuInternal->data[0] = 0; + ++gMain.state; + } + break; + case 17: + CreateCancelConfirmPokeballSprites(); + ++gMain.state; + break; + case 18: + CreateCancelConfirmWindows(sPartyMenuInternal->chooseHalf); + ++gMain.state; + break; + case 19: + HelpSystem_SetSomeVariable2(5); + ++gMain.state; + break; + case 20: + CreateTask(sPartyMenuInternal->task, 0); + DisplayPartyMenuStdMessage(sPartyMenuInternal->messageId); + ++gMain.state; + break; + case 21: + BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK); + ++gMain.state; + break; + case 22: + BeginNormalPaletteFade(0xFFFFFFFF, -2, 16, 0, RGB_BLACK); + gPaletteFade.bufferTransferDisabled = FALSE; + ++gMain.state; + break; + default: + SetVBlankCallback(VBlankCB_PartyMenu); + SetMainCallback2(CB2_UpdatePartyMenu); + return TRUE; + } + return FALSE; +} + +void ExitPartyMenu(void) +{ + BeginNormalPaletteFade(0xFFFFFFFF, -2, 0, 16, RGB_BLACK); + CreateTask(Task_ExitPartyMenu, 0); + SetVBlankCallback(VBlankCB_PartyMenu); + SetMainCallback2(CB2_UpdatePartyMenu); +} + +void Task_ExitPartyMenu(u8 taskId) +{ + if (!gPaletteFade.active) + { + SetMainCallback2(gPartyMenu.exitCallback); + FreePartyPointers(); + DestroyTask(taskId); + } +} + +void ResetPartyMenu(void) +{ + sPartyMenuInternal = NULL; + sPartyBgTilemapBuffer = NULL; + sPartyMenuBoxes = NULL; + sPartyBgGfxTilemap = NULL; +} + +bool8 AllocPartyMenuBg(void) +{ + ResetAllBgsCoordinatesAndBgCntRegs(); + sPartyBgTilemapBuffer = Alloc(0x800); + if (sPartyBgTilemapBuffer == NULL) + return FALSE; + memset(sPartyBgTilemapBuffer, 0, 0x800); + ResetBgsAndClearDma3BusyFlags(0); + InitBgsFromTemplates(0, sPartyMenuBgTemplates, NELEMS(sPartyMenuBgTemplates)); + SetBgTilemapBuffer(1, sPartyBgTilemapBuffer); + ScheduleBgCopyTilemapToVram(1); + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP); + SetGpuReg(REG_OFFSET_BLDCNT, 0); + ShowBg(0); + ShowBg(1); + ShowBg(2); + return TRUE; +} + +bool8 AllocPartyMenuBgGfx(void) +{ + u32 sizeout; + + switch (sPartyMenuInternal->data[0]) + { + case 0: + sPartyBgGfxTilemap = MallocAndDecompress(gPartyMenuBg_Gfx, &sizeout); + LoadBgTiles(1, sPartyBgGfxTilemap, sizeout, 0); + ++sPartyMenuInternal->data[0]; + break; + case 1: + if (!IsDma3ManagerBusyWithBgCopy()) + { + LZDecompressWram(gPartyMenuBg_Tilemap, sPartyBgTilemapBuffer); + ++sPartyMenuInternal->data[0]; + } + break; + case 2: + LoadCompressedPalette(gPartyMenuBg_Pal, 0, 0x160); + CpuCopy16(gPlttBufferUnfaded, sPartyMenuInternal->palBuffer, 0x160); + ++sPartyMenuInternal->data[0]; + break; + case 3: + PartyPaletteBufferCopy(4); + ++sPartyMenuInternal->data[0]; + break; + case 4: + PartyPaletteBufferCopy(5); + ++sPartyMenuInternal->data[0]; + break; + case 5: + PartyPaletteBufferCopy(6); + ++sPartyMenuInternal->data[0]; + break; + case 6: + PartyPaletteBufferCopy(7); + ++sPartyMenuInternal->data[0]; + break; + case 7: + PartyPaletteBufferCopy(8); + ++sPartyMenuInternal->data[0]; + break; + default: + return TRUE; + } + return FALSE; +} + +void PartyPaletteBufferCopy(u8 offset) +{ + offset *= 16; + CpuCopy16(&gPlttBufferUnfaded[0x30], &gPlttBufferUnfaded[offset], 32); + CpuCopy16(&gPlttBufferUnfaded[0x30], &gPlttBufferFaded[offset], 32); +} + +void FreePartyPointers(void) +{ + if (sPartyMenuInternal) + Free(sPartyMenuInternal); + if (sPartyBgTilemapBuffer) + Free(sPartyBgTilemapBuffer); + if (sPartyBgGfxTilemap) + Free(sPartyBgGfxTilemap); + if (sPartyMenuBoxes) + Free(sPartyMenuBoxes); + FreeAllWindowBuffers(); +} + +void InitPartyMenuBoxes(u8 layout) +{ + u8 i; + + sPartyMenuBoxes = Alloc(sizeof(struct PartyMenuBox[PARTY_SIZE])); + for (i = 0; i < PARTY_SIZE; ++i) + { + sPartyMenuBoxes[i].infoRects = &sPartyBoxInfoRects[PARTY_BOX_RIGHT_COLUMN]; + sPartyMenuBoxes[i].spriteCoords = sPartyMenuSpriteCoords[layout][i]; + sPartyMenuBoxes[i].windowId = i; + } + // The first party mon goes in the left column + sPartyMenuBoxes[0].infoRects = &sPartyBoxInfoRects[PARTY_BOX_LEFT_COLUMN]; + if (layout == PARTY_LAYOUT_MULTI_SHOWCASE) + sPartyMenuBoxes[3].infoRects = &sPartyBoxInfoRects[PARTY_BOX_LEFT_COLUMN]; + else if (layout != PARTY_LAYOUT_SINGLE) + sPartyMenuBoxes[1].infoRects = &sPartyBoxInfoRects[PARTY_BOX_LEFT_COLUMN]; +} + +void RenderPartyMenuBox(u8 slot) +{ + if (gPartyMenu.menuType == PARTY_MENU_TYPE_MULTI_SHOWCASE && slot >= MULTI_PARTY_SIZE) + { + DisplayPartyPokemonDataForMultiBattle(slot); + LoadPartyBoxPalette(&sPartyMenuBoxes[slot], PARTY_PAL_MULTI_ALT); + CopyWindowToVram(sPartyMenuBoxes[slot].windowId, 2); + PutWindowTilemap(sPartyMenuBoxes[slot].windowId); + ScheduleBgCopyTilemapToVram(2); + } + else + { + if (GetMonData(&gPlayerParty[slot], MON_DATA_SPECIES) == SPECIES_NONE) + { + DrawEmptySlot(sPartyMenuBoxes[slot].windowId); + CopyWindowToVram(sPartyMenuBoxes[slot].windowId, 2); + } + else + { + if (gPartyMenu.menuType == PARTY_MENU_TYPE_CHOOSE_HALF) + DisplayPartyPokemonDataForChooseHalf(slot); + else if (gPartyMenu.menuType == PARTY_MENU_TYPE_MINIGAME) + DisplayPartyPokemonDataForWirelessMinigame(slot); + else if (!DisplayPartyPokemonDataForMoveTutorOrEvolutionItem(slot)) + DisplayPartyPokemonData(slot); + if (gPartyMenu.menuType == PARTY_MENU_TYPE_MULTI_SHOWCASE) + AnimatePartySlot(slot, 0); + else if (gPartyMenu.slotId == slot) + AnimatePartySlot(slot, 1); + else + AnimatePartySlot(slot, 0); + } + PutWindowTilemap(sPartyMenuBoxes[slot].windowId); + ScheduleBgCopyTilemapToVram(0); + } +} + +void DisplayPartyPokemonData(u8 slot) +{ + if (GetMonData(&gPlayerParty[slot], MON_DATA_IS_EGG)) + { + sPartyMenuBoxes[slot].infoRects->blitFunc(sPartyMenuBoxes[slot].windowId, 0, 0, 0, 0, TRUE); + DisplayPartyPokemonNickname(&gPlayerParty[slot], &sPartyMenuBoxes[slot], 0); + } + else + { + sPartyMenuBoxes[slot].infoRects->blitFunc(sPartyMenuBoxes[slot].windowId, 0, 0, 0, 0, FALSE); + DisplayPartyPokemonNickname(&gPlayerParty[slot], &sPartyMenuBoxes[slot], 0); + DisplayPartyPokemonLevelCheck(&gPlayerParty[slot], &sPartyMenuBoxes[slot], 0); + DisplayPartyPokemonGenderNidoranCheck(&gPlayerParty[slot], &sPartyMenuBoxes[slot], 0); + DisplayPartyPokemonHPCheck(&gPlayerParty[slot], &sPartyMenuBoxes[slot], 0); + DisplayPartyPokemonMaxHPCheck(&gPlayerParty[slot], &sPartyMenuBoxes[slot], 0); + DisplayPartyPokemonHPBarCheck(&gPlayerParty[slot], &sPartyMenuBoxes[slot]); + } +} + +void DisplayPartyPokemonDescriptionData(u8 slot, u8 stringId) +{ + struct Pokemon *mon = &gPlayerParty[slot]; + + sPartyMenuBoxes[slot].infoRects->blitFunc(sPartyMenuBoxes[slot].windowId, 0, 0, 0, 0, TRUE); + DisplayPartyPokemonNickname(mon, &sPartyMenuBoxes[slot], 0); + if (!GetMonData(mon, MON_DATA_IS_EGG)) + { + DisplayPartyPokemonLevelCheck(mon, &sPartyMenuBoxes[slot], 0); + DisplayPartyPokemonGenderNidoranCheck(mon, &sPartyMenuBoxes[slot], 0); + } + DisplayPartyPokemonDescriptionText(stringId, &sPartyMenuBoxes[slot], 0); +} + +void DisplayPartyPokemonDataForChooseHalf(u8 slot) +{ + u8 i; + struct Pokemon *mon = &gPlayerParty[slot]; + u8 *order = gSelectedOrderFromParty; + u8 r3; + + if (!GetBattleEntryEligibility(mon)) + { + DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_NOT_ABLE); + } + else + { + if (gPartyMenu.unk_8_6 == 2) + r3 = 2; + else + r3 = 3; + for (i = 0; i < r3; ++i) + { + if (order[i] != 0 && (order[i] - 1) == slot) + { + DisplayPartyPokemonDescriptionData(slot, i + PARTYBOX_DESC_FIRST); + return; + } + } + DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_ABLE_3); + } +} + +void DisplayPartyPokemonDataForWirelessMinigame(u8 slot) +{ + if (IsMonAllowedInMinigame(slot) == TRUE) + DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_ABLE); + else + DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_NOT_ABLE); +} + +// Returns TRUE if teaching move or cant evolve with item (i.e. description data is shown), FALSE otherwise +bool8 DisplayPartyPokemonDataForMoveTutorOrEvolutionItem(u8 slot) +{ + struct Pokemon *currentPokemon = &gPlayerParty[slot]; + u16 item = gSpecialVar_ItemId; + + if (gPartyMenu.action == PARTY_ACTION_MOVE_TUTOR) + { + gSpecialVar_Result = FALSE; + if (gSpecialVar_0x8005 > 14) + return FALSE; + DisplayPartyPokemonDataToTeachMove(slot, 0, gSpecialVar_0x8005); + } + else + { + if (gPartyMenu.action != PARTY_ACTION_USE_ITEM) + return FALSE; + switch (CheckIfItemIsTMHMOrEvolutionStone(item)) + { + default: + return FALSE; + case 1: // TM/HM + DisplayPartyPokemonDataToTeachMove(slot, item, 0); + break; + case 2: // Evolution stone + if (!GetMonData(currentPokemon, MON_DATA_IS_EGG) && GetEvolutionTargetSpecies(currentPokemon, 3, item) != SPECIES_NONE) + return FALSE; + DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_NO_USE); + break; + } + } + return TRUE; +} + +void DisplayPartyPokemonDataToTeachMove(u8 slot, u16 item, u8 tutor) +{ + switch (CanMonLearnTMTutor(&gPlayerParty[slot], item, tutor)) + { + case CANNOT_LEARN_MOVE: + case CANNOT_LEARN_MOVE_IS_EGG: + DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_NOT_ABLE_2); + break; + case ALREADY_KNOWS_MOVE: + DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_LEARNED); + break; + default: + DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_ABLE_2); + break; + } +} + +void DisplayPartyPokemonDataForMultiBattle(u8 slot) +{ + struct PartyMenuBox *menuBox = &sPartyMenuBoxes[slot]; + u8 actualSlot = slot - (3); + + if (gMultiPartnerParty[actualSlot].species == SPECIES_NONE) + { + DrawEmptySlot(menuBox->windowId); + } + else + { + menuBox->infoRects->blitFunc(menuBox->windowId, 0, 0, 0, 0, FALSE); + StringCopy(gStringVar1, gMultiPartnerParty[actualSlot].nickname); + StringGetEnd10(gStringVar1); + if (StringLength(gStringVar1) <= 5) + ConvertInternationalString(gStringVar1, 1); + DisplayPartyPokemonBarDetail(menuBox->windowId, gStringVar1, 0, menuBox->infoRects->dimensions); + DisplayPartyPokemonLevel(gMultiPartnerParty[actualSlot].level, menuBox); + DisplayPartyPokemonGender(gMultiPartnerParty[actualSlot].gender, gMultiPartnerParty[actualSlot].species, gMultiPartnerParty[actualSlot].nickname, menuBox); + DisplayPartyPokemonHP(gMultiPartnerParty[actualSlot].hp, menuBox); + DisplayPartyPokemonMaxHP(gMultiPartnerParty[actualSlot].maxhp, menuBox); + DisplayPartyPokemonHPBar(gMultiPartnerParty[actualSlot].hp, gMultiPartnerParty[actualSlot].maxhp, menuBox); + } +} + +bool8 RenderPartyMenuBoxes(void) +{ + RenderPartyMenuBox(sPartyMenuInternal->data[0]); + if (++sPartyMenuInternal->data[0] == PARTY_SIZE) + return TRUE; + else + return FALSE; +} + +u8 *GetPartyMenuBgTile(u16 tileId) +{ + return &sPartyBgGfxTilemap[tileId << 5]; +} + +void CreatePartyMonSprites(u8 slot) +{ + u8 actualSlot; + + if (gPartyMenu.menuType == PARTY_MENU_TYPE_MULTI_SHOWCASE && slot >= MULTI_PARTY_SIZE) + { + u8 status; + + actualSlot = slot - MULTI_PARTY_SIZE; + if (gMultiPartnerParty[actualSlot].species != SPECIES_NONE) + { + CreatePartyMonIconSpriteParameterized(gMultiPartnerParty[actualSlot].species, gMultiPartnerParty[actualSlot].personality, &sPartyMenuBoxes[slot], 0, FALSE); + CreatePartyMonHeldItemSpriteParameterized(gMultiPartnerParty[actualSlot].species, gMultiPartnerParty[actualSlot].heldItem, &sPartyMenuBoxes[slot]); + CreatePartyMonPokeballSpriteParameterized(gMultiPartnerParty[actualSlot].species, &sPartyMenuBoxes[slot]); + if (gMultiPartnerParty[actualSlot].hp == 0) + status = AILMENT_FNT; + else + status = GetAilmentFromStatus(gMultiPartnerParty[actualSlot].status); + CreatePartyMonStatusSpriteParameterized(gMultiPartnerParty[actualSlot].species, status, &sPartyMenuBoxes[slot]); + } + } + else if (GetMonData(&gPlayerParty[slot], MON_DATA_SPECIES) != SPECIES_NONE) + { + CreatePartyMonIconSprite(&gPlayerParty[slot], &sPartyMenuBoxes[slot], slot); + CreatePartyMonHeldItemSprite(&gPlayerParty[slot], &sPartyMenuBoxes[slot]); + CreatePartyMonPokeballSprite(&gPlayerParty[slot], &sPartyMenuBoxes[slot]); + CreatePartyMonStatusSprite(&gPlayerParty[slot], &sPartyMenuBoxes[slot]); + } +} + +bool8 CreatePartyMonSpritesLoop(void) +{ + CreatePartyMonSprites(sPartyMenuInternal->data[0]); + if (++sPartyMenuInternal->data[0] == PARTY_SIZE) + return TRUE; + else + return FALSE; +} + +void CreateCancelConfirmPokeballSprites(void) +{ + if (gPartyMenu.menuType == PARTY_MENU_TYPE_MULTI_SHOWCASE) + { + // The showcase has no Cancel/Confirm buttons + FillBgTilemapBufferRect(1, 14, 23, 17, 7, 2, 1); + } + else + { + if (sPartyMenuInternal->chooseHalf) + { + sPartyMenuInternal->spriteIdConfirmPokeball = CreateSmallPokeballButtonSprite(0xBF, 0x88); + DrawCancelConfirmButtons(); + sPartyMenuInternal->spriteIdCancelPokeball = CreateSmallPokeballButtonSprite(0xBF, 0x98); + } + else + { + sPartyMenuInternal->spriteIdCancelPokeball = CreatePokeballButtonSprite(198, 148); + } + AnimatePartySlot(gPartyMenu.slotId, 1); + } +} + +void AnimatePartySlot(u8 slot, u8 animNum) +{ + u8 spriteId; + + switch (slot) + { + default: + if (GetMonData(&gPlayerParty[slot], MON_DATA_SPECIES) != SPECIES_NONE) + { + LoadPartyBoxPalette(&sPartyMenuBoxes[slot], GetPartyBoxPaletteFlags(slot, animNum)); + AnimateSelectedPartyIcon(sPartyMenuBoxes[slot].monSpriteId, animNum); + PartyMenuStartSpriteAnim(sPartyMenuBoxes[slot].pokeballSpriteId, animNum); + } + return; + case PARTY_SIZE: // Confirm + if (animNum == 0) + SetBgTilemapPalette(1, 23, 16, 7, 2, 1); + else + SetBgTilemapPalette(1, 23, 16, 7, 2, 2); + spriteId = sPartyMenuInternal->spriteIdConfirmPokeball; + break; + case PARTY_SIZE + 1: // Cancel + // The position of the Cancel button changes if Confirm is present + if (!sPartyMenuInternal->chooseHalf) + { + if (animNum == 0) + SetBgTilemapPalette(1, 23, 17, 7, 2, 1); + else + SetBgTilemapPalette(1, 23, 17, 7, 2, 2); + } + else if (animNum == 0) + { + SetBgTilemapPalette(1, 23, 18, 7, 2, 1); + } + else + { + SetBgTilemapPalette(1, 23, 18, 7, 2, 2); + } + spriteId = sPartyMenuInternal->spriteIdCancelPokeball; + break; + } + PartyMenuStartSpriteAnim(spriteId, animNum); + ScheduleBgCopyTilemapToVram(1); +} + +u8 GetPartyBoxPaletteFlags(u8 slot, u8 animNum) +{ + u8 palFlags = 0; + + if (animNum == 1) + palFlags |= PARTY_PAL_SELECTED; + if (GetMonData(&gPlayerParty[slot], MON_DATA_HP) == 0) + palFlags |= PARTY_PAL_FAINTED; + if (gPartyMenu.layout == PARTY_LAYOUT_MULTI + && (slot == 1 || slot == 4 || slot == 5)) + palFlags |= PARTY_PAL_MULTI_ALT; + if (gPartyMenu.action == PARTY_ACTION_SWITCHING) + palFlags |= PARTY_PAL_SWITCHING; + if (gPartyMenu.action == PARTY_ACTION_SWITCH) + { + if (slot == gPartyMenu.slotId || slot == gPartyMenu.slotId2) + palFlags |= PARTY_PAL_TO_SWITCH; + } + if (gPartyMenu.action == PARTY_ACTION_SOFTBOILED && slot == gPartyMenu.slotId ) + palFlags |= PARTY_PAL_TO_SOFTBOIL; + return palFlags; +} + +void DrawCancelConfirmButtons(void) +{ + CopyToBgTilemapBufferRect_ChangePalette(1, sConfirmButton_Tilemap, 23, 16, 7, 2, 17); + CopyToBgTilemapBufferRect_ChangePalette(1, sCancelButton_Tilemap, 23, 18, 7, 2, 17); + ScheduleBgCopyTilemapToVram(1); +} + +bool8 IsMultiBattle(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_DOUBLE && gBattleTypeFlags & BATTLE_TYPE_TRAINER && gBattleTypeFlags & BATTLE_TYPE_LINK) + return TRUE; + else + return FALSE; +} + +void SwapPartyPokemon(struct Pokemon *mon1, struct Pokemon *mon2) +{ + struct Pokemon *buffer = Alloc(sizeof(struct Pokemon)); + + *buffer = *mon1; + *mon1 = *mon2; + *mon2 = *buffer; + Free(buffer); +} + +void Task_ClosePartyMenu(u8 taskId) +{ + BeginNormalPaletteFade(0xFFFFFFFF, -2, 0, 16, RGB_BLACK); + gTasks[taskId].func = Task_ClosePartyMenuAndSetCB2; +} + +void Task_ClosePartyMenuAndSetCB2(u8 taskId) +{ + if (!gPaletteFade.active) + { + if (gPartyMenu.menuType == PARTY_MENU_TYPE_IN_BATTLE) + UpdatePartyToFieldOrder(); + if (sPartyMenuInternal->exitCallback != NULL) + SetMainCallback2(sPartyMenuInternal->exitCallback); + else + SetMainCallback2(gPartyMenu.exitCallback); + FreePartyPointers(); + DestroyTask(taskId); + } +} + +u8 GetCursorSelectionMonId(void) +{ + return gPartyMenu.slotId; +} + +u8 GetPartyMenuType(void) +{ + return gPartyMenu.menuType; +} + +void Task_HandleChooseMonInput(u8 taskId) +{ + if (!gPaletteFade.active && sub_80BF748() != TRUE) + { + s8 *slotPtr = GetCurrentPartySlotPtr(); + + switch (PartyMenuButtonHandler(slotPtr)) + { + case 1: // Selected mon + HandleChooseMonSelection(taskId, slotPtr); + break; + case 2: // Selected Cancel + HandleChooseMonCancel(taskId, slotPtr); + break; + case 8: // Start button + if (sPartyMenuInternal->chooseHalf) + { + PlaySE(SE_SELECT); + MoveCursorToConfirm(); + } + break; + } + } +} + +s8 *GetCurrentPartySlotPtr(void) +{ + if (gPartyMenu.action == PARTY_ACTION_SWITCH || gPartyMenu.action == PARTY_ACTION_SOFTBOILED) + return &gPartyMenu.slotId2; + else + return &gPartyMenu.slotId; +} + +void HandleChooseMonSelection(u8 taskId, s8 *slotPtr) +{ + if (*slotPtr == PARTY_SIZE) + { + gPartyMenu.task(taskId); + } + else + { + switch (gPartyMenu.action - 3) + { + case PARTY_ACTION_SOFTBOILED - 3: + if (IsSelectedMonNotEgg((u8 *)slotPtr)) + Task_TryUseSoftboiledOnPartyMon(taskId); + break; + case PARTY_ACTION_USE_ITEM - 3: + if (IsSelectedMonNotEgg((u8 *)slotPtr)) + { + if (gPartyMenu.menuType == PARTY_MENU_TYPE_IN_BATTLE) + sPartyMenuInternal->exitCallback = CB2_SetUpExitToBattleScreen; + gItemUseCB(taskId, Task_ClosePartyMenuAfterText); + } + break; + case PARTY_ACTION_MOVE_TUTOR - 3: + if (IsSelectedMonNotEgg((u8 *)slotPtr)) + { + PlaySE(SE_SELECT); + TryTutorSelectedMon(taskId); + } + break; + case PARTY_ACTION_GIVE_MAILBOX_MAIL - 3: + if (IsSelectedMonNotEgg((u8 *)slotPtr)) + { + PlaySE(SE_SELECT); + TryGiveMailToSelectedMon(taskId); + } + break; + case PARTY_ACTION_GIVE_ITEM - 3: + case PARTY_ACTION_GIVE_PC_ITEM - 3: + if (IsSelectedMonNotEgg((u8 *)slotPtr)) + { + PlaySE(SE_SELECT); + TryGiveItemOrMailToSelectedMon(taskId); + } + break; + case PARTY_ACTION_SWITCH - 3: + PlaySE(SE_SELECT); + SwitchSelectedMons(taskId); + break; + case PARTY_ACTION_CHOOSE_AND_CLOSE - 3: + PlaySE(SE_SELECT); + gSpecialVar_0x8004 = *slotPtr; + if (gPartyMenu.menuType == PARTY_MENU_TYPE_MOVE_RELEARNER) + gSpecialVar_0x8005 = GetNumberOfRelearnableMoves(&gPlayerParty[*slotPtr]); + Task_ClosePartyMenu(taskId); + break; + case PARTY_ACTION_MINIGAME - 3: + if (IsSelectedMonNotEgg((u8 *)slotPtr)) + TryEnterMonForMinigame(taskId, (u8)*slotPtr); + break; + default: + case PARTY_ACTION_ABILITY_PREVENTS - 3: + case PARTY_ACTION_SWITCHING - 3: + PlaySE(SE_SELECT); + Task_TryCreateSelectionWindow(taskId); + break; + } + } +} + +bool8 IsSelectedMonNotEgg(u8 *slotPtr) +{ + if (GetMonData(&gPlayerParty[*slotPtr], MON_DATA_IS_EGG) == TRUE) + { + PlaySE(SE_HAZURE); + return FALSE; + } + return TRUE; +} + +void HandleChooseMonCancel(u8 taskId, s8 *slotPtr) +{ + switch (gPartyMenu.action) + { + case PARTY_ACTION_SEND_OUT: + PlaySE(SE_HAZURE); + break; + case PARTY_ACTION_SWITCH: + case PARTY_ACTION_SOFTBOILED: + PlaySE(SE_SELECT); + FinishTwoMonAction(taskId); + break; + case PARTY_ACTION_MINIGAME: + PlaySE(SE_SELECT); + CancelParticipationPrompt(taskId); + break; + default: + PlaySE(SE_SELECT); + if (gPartyMenu.menuType == PARTY_MENU_TYPE_CHOOSE_HALF) + { + DisplayCancelChooseMonYesNo(taskId); + } + else + { + if (!MenuHelpers_LinkSomething()) + gSpecialVar_0x8004 = PARTY_SIZE + 1; + gPartyMenuUseExitCallback = FALSE; + *slotPtr = PARTY_SIZE + 1; + Task_ClosePartyMenu(taskId); + } + break; + } +} + +void DisplayCancelChooseMonYesNo(u8 taskId) +{ + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + StringExpandPlaceholders(gStringVar4, gUnknown_84176CF); + DisplayPartyMenuMessage(gStringVar4, TRUE); + gTasks[taskId].func = Task_CancelChooseMonYesNo; +} + +void Task_CancelChooseMonYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleCancelChooseMonYesNoInput; + } +} + +void Task_HandleCancelChooseMonYesNoInput(u8 taskId) +{ + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: + gPartyMenuUseExitCallback = FALSE; + gPartyMenu.slotId = PARTY_SIZE + 1; + ClearSelectedPartyOrder(); + Task_ClosePartyMenu(taskId); + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: + Task_ReturnToChooseMonAfterText(taskId); + break; + } +} + +u16 PartyMenuButtonHandler(s8 *slotPtr) +{ + s8 movementDir; + + switch (gMain.newAndRepeatedKeys) + { + case DPAD_UP: + movementDir = MENU_DIR_UP; + break; + case DPAD_DOWN: + movementDir = MENU_DIR_DOWN; + break; + case DPAD_LEFT: + movementDir = MENU_DIR_LEFT; + break; + case DPAD_RIGHT: + movementDir = MENU_DIR_RIGHT; + break; + default: + switch (GetLRKeysPressedAndHeld()) + { + case MENU_L_PRESSED: + movementDir = MENU_DIR_UP; + break; + case MENU_R_PRESSED: + movementDir = MENU_DIR_DOWN; + break; + default: + movementDir = 0; + break; + } + break; + } + if (JOY_NEW(START_BUTTON)) + return 8; + if (movementDir) + { + UpdateCurrentPartySelection(slotPtr, movementDir); + return 0; + } + // Pressed Cancel + if (JOY_NEW(A_BUTTON) && *slotPtr == PARTY_SIZE + 1) + return 2; + return JOY_NEW(A_BUTTON | B_BUTTON); +} + +void UpdateCurrentPartySelection(s8 *slotPtr, s8 movementDir) +{ + s8 newSlotId = *slotPtr; + u8 layout = gPartyMenu.layout; + + if (layout == PARTY_LAYOUT_SINGLE) + UpdatePartySelectionSingleLayout(slotPtr, movementDir); + else + UpdatePartySelectionDoubleLayout(slotPtr, movementDir); + if (*slotPtr != newSlotId) + { + PlaySE(SE_SELECT); + AnimatePartySlot(newSlotId, 0); + AnimatePartySlot(*slotPtr, 1); + } +} + +void UpdatePartySelectionSingleLayout(s8 *slotPtr, s8 movementDir) +{ + // PARTY_SIZE + 1 is Cancel, PARTY_SIZE is Confirm + switch (movementDir) + { + case MENU_DIR_UP: + if (*slotPtr == 0) + { + *slotPtr = PARTY_SIZE + 1; + } + else if (*slotPtr == PARTY_SIZE) + { + *slotPtr = gPlayerPartyCount - 1; + } + else if (*slotPtr == PARTY_SIZE + 1) + { + if (sPartyMenuInternal->chooseHalf) + *slotPtr = PARTY_SIZE; + else + *slotPtr = gPlayerPartyCount - 1; + } + else + { + --*slotPtr; + } + break; + case MENU_DIR_DOWN: + if (*slotPtr == PARTY_SIZE + 1) + { + *slotPtr = 0; + } + else + { + if (*slotPtr == gPlayerPartyCount - 1) + { + if (sPartyMenuInternal->chooseHalf) + *slotPtr = PARTY_SIZE; + else + *slotPtr = PARTY_SIZE + 1; + } + else + { + ++*slotPtr; + } + } + break; + case MENU_DIR_RIGHT: + if (gPlayerPartyCount != 1 && *slotPtr == 0) + { + if (sPartyMenuInternal->lastSelectedSlot == 0) + *slotPtr = 1; + else + *slotPtr = sPartyMenuInternal->lastSelectedSlot; + } + break; + case MENU_DIR_LEFT: + if (*slotPtr != 0 && *slotPtr != PARTY_SIZE && *slotPtr != PARTY_SIZE + 1) + { + sPartyMenuInternal->lastSelectedSlot = *slotPtr; + *slotPtr = 0; + } + break; + } +} + +void UpdatePartySelectionDoubleLayout(s8 *slotPtr, s8 movementDir) +{ + // PARTY_SIZE + 1 is Cancel, PARTY_SIZE is Confirm + // newSlot is used temporarily as a movement direction during its later assignment + s8 newSlot = movementDir; + + switch (movementDir) + { + case MENU_DIR_UP: + if (*slotPtr == 0) + { + *slotPtr = PARTY_SIZE + 1; + break; + } + else if (*slotPtr == PARTY_SIZE) + { + *slotPtr = gPlayerPartyCount - 1; + break; + } + else if (*slotPtr == PARTY_SIZE + 1) + { + if (sPartyMenuInternal->chooseHalf) + { + *slotPtr = PARTY_SIZE; + break; + } + --*slotPtr; + } + newSlot = GetNewSlotDoubleLayout(*slotPtr, newSlot); + if (newSlot != -1) + *slotPtr = newSlot; + break; + case MENU_DIR_DOWN: + if (*slotPtr == PARTY_SIZE) + { + *slotPtr = PARTY_SIZE + 1; + } + else if (*slotPtr == PARTY_SIZE + 1) + { + *slotPtr = 0; + } + else + { + newSlot = GetNewSlotDoubleLayout(*slotPtr, MENU_DIR_DOWN); + if (newSlot == -1) + { + if (sPartyMenuInternal->chooseHalf) + *slotPtr = PARTY_SIZE; + else + *slotPtr = PARTY_SIZE + 1; + } + else + { + *slotPtr = newSlot; + } + } + break; + case MENU_DIR_RIGHT: + if (*slotPtr == 0) + { + if (sPartyMenuInternal->lastSelectedSlot == 3) + { + if (GetMonData(&gPlayerParty[3], MON_DATA_SPECIES) != SPECIES_NONE) + *slotPtr = 3; + } + else if (GetMonData(&gPlayerParty[2], MON_DATA_SPECIES) != SPECIES_NONE) + { + *slotPtr = 2; + } + } + else if (*slotPtr == 1) + { + if (sPartyMenuInternal->lastSelectedSlot == 5) + { + if (GetMonData(&gPlayerParty[5], MON_DATA_SPECIES) != SPECIES_NONE) + *slotPtr = 5; + } + else if (GetMonData(&gPlayerParty[4], MON_DATA_SPECIES) != SPECIES_NONE) + { + *slotPtr = 4; + } + } + break; + case MENU_DIR_LEFT: + if (*slotPtr == 2 || *slotPtr == 3) + { + sPartyMenuInternal->lastSelectedSlot = *slotPtr; + *slotPtr = 0; + } + else if (*slotPtr == 4 || *slotPtr == 5) + { + sPartyMenuInternal->lastSelectedSlot = *slotPtr; + *slotPtr = 1; + } + break; + } +} + +s8 GetNewSlotDoubleLayout(s8 slotId, s8 movementDir) +{ + while (TRUE) + { + slotId += movementDir; + if ((u8)slotId >= PARTY_SIZE) + return -1; + if (GetMonData(&gPlayerParty[slotId], MON_DATA_SPECIES) != SPECIES_NONE) + return slotId; + } +} + +u8 *GetMonNickname(struct Pokemon *mon, u8 *dest) +{ + GetMonData(mon, MON_DATA_NICKNAME, dest); + return StringGetEnd10(dest); +} + +#define tKeepOpen data[0] + +u8 DisplayPartyMenuMessage(const u8 *str, bool8 keepOpen) +{ + u8 taskId; + + PartyMenuPrintText(str); + taskId = CreateTask(Task_PrintAndWaitForText, 1); + gTasks[taskId].tKeepOpen = keepOpen; + return taskId; +} + +void Task_PrintAndWaitForText(u8 taskId) +{ + if (RunTextPrinters_CheckActive(6) != TRUE) + { + if (gTasks[taskId].tKeepOpen == FALSE) + { + ClearStdWindowAndFrameToTransparent(6, 0); + ClearWindowTilemap(6); + } + DestroyTask(taskId); + } +} + +#undef tKeepOpen + +bool8 IsPartyMenuTextPrinterActive(void) +{ + return FuncIsActiveTask(Task_PrintAndWaitForText); +} + +void Task_WaitForLinkAndReturnToChooseMon(u8 taskId) +{ + if (sub_80BF748() != TRUE) + { + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON); + gTasks[taskId].func = Task_HandleChooseMonInput; + } +} + +void Task_ReturnToChooseMonAfterText(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + ClearStdWindowAndFrameToTransparent(6, 0); + ClearWindowTilemap(6); + if (MenuHelpers_LinkSomething() == TRUE) + { + gTasks[taskId].func = Task_WaitForLinkAndReturnToChooseMon; + } + else + { + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON); + gTasks[taskId].func = Task_HandleChooseMonInput; + } + } +} + +void DisplayGaveHeldItemMessage(struct Pokemon *mon, u16 item, bool8 keepOpen, u8 a4) +{ + if (!a4) + ItemUse_SetQuestLogEvent(5, mon, item, 0xFFFF); + else if (gPartyMenu.action == PARTY_ACTION_GIVE_PC_ITEM) + ItemUse_SetQuestLogEvent(7, mon, item, 0xFFFF); + else + ItemUse_SetQuestLogEvent(6, mon, item, 0xFFFF); + GetMonNickname(mon, gStringVar1); + CopyItemName(item, gStringVar2); + StringExpandPlaceholders(gStringVar4, gText_PkmnWasGivenItem); + DisplayPartyMenuMessage(gStringVar4, keepOpen); + ScheduleBgCopyTilemapToVram(2); +} + +void DisplayTookHeldItemMessage(struct Pokemon *mon, u16 item, bool8 keepOpen) +{ + ItemUse_SetQuestLogEvent(8, mon, item, 0xFFFF); + GetMonNickname(mon, gStringVar1); + CopyItemName(item, gStringVar2); + StringExpandPlaceholders(gStringVar4, gText_ReceivedItemFromPkmn); + DisplayPartyMenuMessage(gStringVar4, keepOpen); + ScheduleBgCopyTilemapToVram(2); +} + +void DisplayAlreadyHoldingItemSwitchMessage(struct Pokemon *mon, u16 item, bool8 keepOpen) +{ + GetMonNickname(mon, gStringVar1); + CopyItemName(item, gStringVar2); + StringExpandPlaceholders(gStringVar4, gText_PkmnAlreadyHoldingItemSwitch); + DisplayPartyMenuMessage(gStringVar4, keepOpen); + ScheduleBgCopyTilemapToVram(2); +} + +void DisplaySwitchedHeldItemMessage(u16 item, u16 item2, bool8 keepOpen) +{ + sub_8124B60(&gPlayerParty[gPartyMenu.slotId], item2, item); + CopyItemName(item, gStringVar1); + CopyItemName(item2, gStringVar2); + StringExpandPlaceholders(gStringVar4, gText_SwitchedPkmnItem); + DisplayPartyMenuMessage(gStringVar4, keepOpen); + ScheduleBgCopyTilemapToVram(2); +} + +void GiveItemToMon(struct Pokemon *mon, u16 item) +{ + u8 itemBytes[2]; + + if (ItemIsMail(item) == TRUE) + { + if (GiveMailToMon(mon, item) == 0xFF) + return; + } + itemBytes[0] = item; + itemBytes[1] = item >> 8; + SetMonData(mon, MON_DATA_HELD_ITEM, itemBytes); +} + +u8 TryTakeMonItem(struct Pokemon *mon) +{ + u16 item = GetMonData(mon, MON_DATA_HELD_ITEM); + + if (item == ITEM_NONE) + return 0; + if (AddBagItem(item, 1) == FALSE) + return 1; + item = ITEM_NONE; + SetMonData(mon, MON_DATA_HELD_ITEM, &item); + return 2; +} + +void BufferBagFullCantTakeItemMessage(u16 itemId) +{ + const u8 *string; + + switch (ItemId_GetPocket(itemId)) + { + default: + string = gStartMenuText_Bag; + break; + case POCKET_TM_CASE: + string = ItemId_GetName(ITEM_TM_CASE); + break; + case POCKET_BERRY_POUCH: + string = ItemId_GetName(ITEM_BERRY_POUCH); + break; + } + StringCopy(gStringVar1, string); + StringExpandPlaceholders(gStringVar4, gText_BagFullCouldNotRemoveItem); +} + +#define tHP data[0] +#define tMaxHP data[1] +#define tHPIncrement data[2] +#define tHPToAdd data[3] +#define tPartyId data[4] +#define tStartHP data[5] + +void Task_PartyMenuModifyHP(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + tHP += tHPIncrement; + --tHPToAdd; + SetMonData(&gPlayerParty[tPartyId], MON_DATA_HP, &tHP); + DisplayPartyPokemonHPCheck(&gPlayerParty[tPartyId], &sPartyMenuBoxes[tPartyId], 1); + DisplayPartyPokemonHPBarCheck(&gPlayerParty[tPartyId], &sPartyMenuBoxes[tPartyId]); + if (tHPToAdd == 0 || tHP == 0 || tHP == tMaxHP) + { + // If HP was recovered, buffer the amount recovered + if (tHP > tStartHP) + ConvertIntToDecimalStringN(gStringVar2, tHP - tStartHP, STR_CONV_MODE_LEFT_ALIGN, 3); + SwitchTaskToFollowupFunc(taskId); + } +} + +void PartyMenuModifyHP(u8 taskId, u8 slot, s8 hpIncrement, s16 hpDifference, TaskFunc task) +{ + struct Pokemon *mon = &gPlayerParty[slot]; + s16 *data = gTasks[taskId].data; + + tHP = GetMonData(mon, MON_DATA_HP); + tMaxHP = GetMonData(mon, MON_DATA_MAX_HP); + tHPIncrement = hpIncrement; + tHPToAdd = hpDifference; + tPartyId = slot; + tStartHP = tHP; + SetTaskFuncWithFollowupFunc(taskId, Task_PartyMenuModifyHP, task); +} + +void ResetHPTaskData(u8 taskId, u8 caseId, u32 hp) +{ + s16 *data = gTasks[taskId].data; + + switch (caseId) // always zero + { + case 0: + tHP = hp; + tStartHP = hp; + break; + case 1: + tMaxHP = hp; + break; + case 2: + tHPIncrement = hp; + break; + case 3: + tHPToAdd = hp; + break; + case 4: + tPartyId = hp; + break; + case 5: + SetTaskFuncWithFollowupFunc(taskId, Task_PartyMenuModifyHP, (TaskFunc)hp); // >casting hp as a taskfunc + break; + } +} + +#undef tHP +#undef tMaxHP +#undef tHPIncrement +#undef tHPToAdd +#undef tPartyId +#undef tStartHP + +u8 GetAilmentFromStatus(u32 status) +{ + if (status & STATUS1_PSN_ANY) + return AILMENT_PSN; + if (status & STATUS1_PARALYSIS) + return AILMENT_PRZ; + if (status & STATUS1_SLEEP) + return AILMENT_SLP; + if (status & STATUS1_FREEZE) + return AILMENT_FRZ; + if (status & STATUS1_BURN) + return AILMENT_BRN; + return AILMENT_NONE; +} + +u8 GetMonAilment(struct Pokemon *mon) +{ + u8 ailment; + + if (GetMonData(mon, MON_DATA_HP) == 0) + return AILMENT_FNT; + ailment = GetAilmentFromStatus(GetMonData(mon, MON_DATA_STATUS)); + if (ailment != AILMENT_NONE) + return ailment; + if (CheckPartyPokerus(mon, 0)) + return AILMENT_PKRS; + return AILMENT_NONE; +} + +void SetPartyMonsAllowedInMinigame(void) +{ + u16 *ptr; + + if (gPartyMenu.menuType == PARTY_MENU_TYPE_MINIGAME) + { + u8 i; + + ptr = &gPartyMenu.data1; + gPartyMenu.data1 = 0; + if (gSpecialVar_0x8005 == 0) + { + for (i = 0; i < gPlayerPartyCount; ++i) + *ptr += IsMonAllowedInPokemonJump(&gPlayerParty[i]) << i; + } + else + { + for (i = 0; i < gPlayerPartyCount; ++i) + *ptr += IsMonAllowedInDodrioBerryPicking(&gPlayerParty[i]) << i; + } + } +} + +bool16 IsMonAllowedInPokemonJump(struct Pokemon *mon) +{ + if (GetMonData(mon, MON_DATA_IS_EGG) != TRUE && IsSpeciesAllowedInPokemonJump(GetMonData(mon, MON_DATA_SPECIES))) + return TRUE; + return FALSE; +} + + +bool16 IsMonAllowedInDodrioBerryPicking(struct Pokemon *mon) +{ + if (GetMonData(mon, MON_DATA_IS_EGG) != TRUE && GetMonData(mon, MON_DATA_SPECIES) == SPECIES_DODRIO) + return TRUE; + return FALSE; +} + +bool8 IsMonAllowedInMinigame(u8 slot) +{ + if (!((gPartyMenu.data1 >> slot) & 1)) + return FALSE; + return TRUE; +} + +void TryEnterMonForMinigame(u8 taskId, u8 slot) +{ + if (IsMonAllowedInMinigame(slot) == TRUE) + { + PlaySE(SE_SELECT); + gSpecialVar_0x8004 = slot; + Task_ClosePartyMenu(taskId); + } + else + { + PlaySE(SE_HAZURE); + DisplayPartyMenuMessage(gText_PkmnCantParticipate, FALSE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + } +} + +void CancelParticipationPrompt(u8 taskId) +{ + DisplayPartyMenuMessage(gText_CancelParticipation, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_CancelParticipationYesNo; +} + +void Task_CancelParticipationYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleCancelParticipationYesNoInput; + } +} + +void Task_HandleCancelParticipationYesNoInput(u8 taskId) +{ + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: + gSpecialVar_0x8004 = PARTY_SIZE + 1; + Task_ClosePartyMenu(taskId); + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + break; + } +} + +u8 CanMonLearnTMTutor(struct Pokemon *mon, u16 item, u8 tutor) +{ + u16 move; + + if (GetMonData(mon, MON_DATA_IS_EGG)) + return CANNOT_LEARN_MOVE_IS_EGG; + + if (item >= ITEM_TM01_FOCUS_PUNCH) + { + if (CanMonLearnTMHM(mon, item - ITEM_TM01_FOCUS_PUNCH)) + move = ItemIdToBattleMoveId(item); + else + return CANNOT_LEARN_MOVE; + do + { + } while (0); + } + else if (CanLearnTutorMove(GetMonData(mon, MON_DATA_SPECIES), tutor) == FALSE) + { + return CANNOT_LEARN_MOVE; + } + else + { + move = GetTutorMove(tutor); + } + if (MonKnowsMove(mon, move) == TRUE) + return ALREADY_KNOWS_MOVE; + else + return CAN_LEARN_MOVE; +} + +u16 GetTutorMove(u8 tutor) +{ + switch (tutor) + { + case TUTOR_MOVE_FRENZY_PLANT: + return MOVE_FRENZY_PLANT; + case TUTOR_MOVE_BLAST_BURN: + return MOVE_BLAST_BURN; + case TUTOR_MOVE_HYDRO_CANNON: + return MOVE_HYDRO_CANNON; + default: + return sTutorMoves[tutor]; + } +} + +bool8 CanLearnTutorMove(u16 species, u8 tutor) +{ + switch (tutor) + { + case TUTOR_MOVE_FRENZY_PLANT: + if (species == SPECIES_VENUSAUR) + return TRUE; + else + return FALSE; + case TUTOR_MOVE_BLAST_BURN: + if (species == SPECIES_CHARIZARD) + return TRUE; + else + return FALSE; + case TUTOR_MOVE_HYDRO_CANNON: + if (species == SPECIES_BLASTOISE) + return TRUE; + else + return FALSE; + default: + if (sTutorLearnsets[species] & (1 << tutor)) + return TRUE; + else + return FALSE; + } +} + +void sub_8120C3C(u8 taskId) +{ + if (!gPaletteFade.active) + gTasks[taskId].func = sub_8120C6C; +} + +void sub_8120C6C(u8 taskId) +{ + BeginNormalPaletteFade(0xFFFF1FFF, 4, 0, 6, RGB_BLACK); + gTasks[taskId].func = sub_8120CA8; +} + +void sub_8120CA8(u8 taskId) +{ + if (!gPaletteFade.active) + gTasks[taskId].func = sub_8120CD8; +} + +void sub_8120CD8(u8 taskId) +{ + gTasks[taskId].data[0] = sub_81220D4(); + gTasks[taskId].func = sub_8120D08; +} + +void sub_8120D08(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (RunTextPrinters_CheckActive((u8)data[0]) != TRUE) + gTasks[taskId].func = sub_8120D40; +} + +void sub_8120D40(u8 taskId) +{ + BeginNormalPaletteFade(0xFFFF0008, 4, 6, 0, RGB_BLACK); + gTasks[taskId].func = sub_8120D7C; +} + +void sub_8120D7C(u8 taskId) +{ + if (!gPaletteFade.active) + gTasks[taskId].func = sub_8120DAC; +} + +void sub_8120DAC(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + sub_8122084(data[0], gUnknown_8417494); + gTasks[taskId].func = sub_8120DE0; +} + +void sub_8120DE0(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (RunTextPrinters_CheckActive((u8)data[0]) != TRUE) + { + sub_8122110((u8)data[0]); + gTasks[taskId].func = sub_8120E1C; + } +} + +void sub_8120E1C(u8 taskId) +{ + BeginNormalPaletteFade(0x0000FFF7, 4, 6, 0, RGB_BLACK); + gTasks[taskId].func = sub_8120E58; +} + +void sub_8120E58(u8 taskId) +{ + if (!gPaletteFade.active) + { + TextWindow_SetUserSelectedFrame(0, 0x4F, 0xD0); + TextWindow_SetStdFrame0_WithPal(0, 0x58, 0xF0); + if (gPartyMenu.action == PARTY_ACTION_USE_ITEM) + DisplayPartyMenuStdMessage(PARTY_MSG_USE_ON_WHICH_MON); + else + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON); + gTasks[taskId].func = Task_HandleChooseMonInput; + } +} + +void sub_8120EBC(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + data[0] = 0; + gTasks[taskId].func = sub_8120EE0; +} + +void sub_8120EE0(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (!gPaletteFade.active && sub_8120F78(taskId) != TRUE) + { + switch (data[0]) + { + case 80: + #ifndef NONMATCHING + asm("":::"r5"); + #endif + UpdateCurrentPartySelection(&gPartyMenu.slotId, 2); + ++data[0]; + break; + case 160: + PlaySE(SE_SELECT); + CreateSelectionWindow(); + ++data[0]; + break; + case 240: + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[2]); + sCursorOptions[sPartyMenuInternal->actions[0]].func(taskId); + // fall through + default: + ++data[0]; + break; + } + } +} diff --git a/src/tm_case.c b/src/tm_case.c index 0734c6d24..a9af2332e 100644 --- a/src/tm_case.c +++ b/src/tm_case.c @@ -595,7 +595,7 @@ static void TMCase_MoveCursor_UpdatePrintedDescription(s32 itemIndex) static void FillBG2RowWithPalette_2timesNplus1(s32 a0) { - SetBgRectPal(2, 0, 12, 30, 8, 2 * a0 + 1); + SetBgTilemapPalette(2, 0, 12, 30, 8, 2 * a0 + 1); ScheduleBgCopyTilemapToVram(2); } -- cgit v1.2.3 From 27ff20d31dc53eba10837064b6c91b99ccf87d8d Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Fri, 22 Nov 2019 13:31:48 +0800 Subject: party_menu second quarter --- src/new_menu_helpers.c | 2 +- src/party_menu.c | 1455 +++++++++++++++++++++++++++++++++++++++++++++++- src/pokemon_icon.c | 2 +- src/quest_log.c | 12 +- src/trade.c | 10 +- 5 files changed, 1460 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/new_menu_helpers.c b/src/new_menu_helpers.c index decd000d6..d2421ed9f 100644 --- a/src/new_menu_helpers.c +++ b/src/new_menu_helpers.c @@ -357,7 +357,7 @@ void SetBgTilemapPalette(u8 bgId, u8 left, u8 top, u8 width, u8 height, u8 palet } } -void CopyRectIntoAltRect(u8 bgId, u16 *dest, u8 left, u8 top, u8 width, u8 height) +void CopyToBufferFromBgTilemap(u8 bgId, u16 *dest, u8 left, u8 top, u8 width, u8 height) { u8 i,j; const u16 *src = GetBgTilemapBuffer(bgId); diff --git a/src/party_menu.c b/src/party_menu.c index 73965c4ae..08600229a 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -27,6 +27,7 @@ #include "item_use.h" #include "link.h" #include "link_rfu.h" +#include "load_save.h" #include "mail.h" #include "mail_data.h" #include "main.h" @@ -43,6 +44,7 @@ #include "pokemon_jump.h" #include "pokemon_storage_system.h" #include "pokemon_summary_screen.h" +#include "quest_log.h" #include "region_map.h" #include "reshow_battle_screen.h" #include "scanline_effect.h" @@ -53,6 +55,7 @@ #include "string_util.h" #include "strings.h" #include "task.h" +#include "teachy_tv.h" #include "text.h" #include "text_window.h" #include "trade.h" @@ -258,11 +261,39 @@ void sub_8120DE0(u8 taskId); void sub_8120E1C(u8 taskId); void sub_8120E58(u8 taskId); void sub_8120EE0(u8 taskId); +void sub_8120FF0(u8 taskId); +void sub_8120FB0(void); bool8 sub_8120F78(u8 taskId); -bool8 sub_81220D4(void); +u8 sub_81220D4(void); void sub_8122084(u8 windowId, const u8 *str); void sub_8122110(u8 windowId); +void sub_812358C(void); void CreateSelectionWindow(void); +bool8 ShouldUseChooseMonText(void); +void UpdatePartyMonHPBar(u8 spriteId, struct Pokemon *mon); +void SpriteCB_UpdatePartyMonIcon(struct Sprite *sprite); +void SpriteCB_BouncePartyMonIcon(struct Sprite *sprite); +void SpriteCB_HeldItem(struct Sprite *sprite); +void UpdatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); +void ShowOrHideHeldItemSprite(u16 item, struct PartyMenuBox *menuBox); +void CreateHeldItemSpriteForTrade(u8 spriteId, bool8 isMail); +void SetPartyMonAilmentGfx(struct Pokemon *mon, struct PartyMenuBox *menuBox); +void UpdatePartyMonAilmentGfx(u8 status, struct PartyMenuBox *menuBox); +void SetPartyMonFieldSelectionActions(struct Pokemon *mons, u8 slotId); +u8 GetPartyMenuActionsTypeInBattle(struct Pokemon *mon); +u8 GetPartySlotEntryStatus(s8 slot); +void Task_HandleSelectionMenuInput(u8 taskId); +void CB2_ShowPokemonSummaryScreen(void); +void CB2_ReturnToPartyMenuFromSummaryScreen(void); +void UpdatePartyToBattleOrder(void); +void SlidePartyMenuBoxOneStep(u8 taskId); +void Task_SlideSelectedSlotsOffscreen(u8 taskId); +void SwitchPartyMon(void); +void Task_SlideSelectedSlotsOnscreen(u8 taskId); +void CB2_WriteMailToGiveMon(void); +void Task_SwitchHoldItemsPrompt(u8 taskId); +void Task_GiveHoldItem(u8 taskId); +void Task_UpdateHeldItemSprite(u8 taskId); EWRAM_DATA struct PartyMenuInternal *sPartyMenuInternal = NULL; EWRAM_DATA struct PartyMenu gPartyMenu = {0}; @@ -1936,24 +1967,1432 @@ void sub_8120EE0(u8 taskId) switch (data[0]) { case 80: - #ifndef NONMATCHING - asm("":::"r5"); - #endif UpdateCurrentPartySelection(&gPartyMenu.slotId, 2); - ++data[0]; break; case 160: PlaySE(SE_SELECT); CreateSelectionWindow(); - ++data[0]; break; case 240: PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[2]); sCursorOptions[sPartyMenuInternal->actions[0]].func(taskId); - // fall through - default: + break; + } + ++data[0]; + } +} + +bool8 sub_8120F78(u8 taskId) +{ + if (JOY_NEW(B_BUTTON)) + { + sPartyMenuInternal->exitCallback = sub_8120FB0; + Task_ClosePartyMenu(taskId); + return TRUE; + } + return FALSE; +} + +void sub_8120FB0(void) +{ + FreeRestoreBattleData(); + LoadPlayerParty(); + SetTeachyTvControllerModeToResume(); + SetMainCallback2(CB2_ReturnToTeachyTV); +} + +void sub_8120FCC(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + data[0] = 0; + gTasks[taskId].func = sub_8120FF0; +} + +void sub_8120FF0(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (!gPaletteFade.active && sub_8120F78(taskId) != TRUE) + { + if (data[0] != 80) + { ++data[0]; + } + else + { + sPartyMenuInternal->exitCallback = CB2_SetUpExitToBattleScreen; + gItemUseCB(taskId, Task_ClosePartyMenuAfterText); + } + } +} + +void InitPartyMenuWindows(u8 layout) +{ + u8 i; + + switch (layout) + { + case PARTY_LAYOUT_SINGLE: + InitWindows(sSinglePartyMenuWindowTemplate); + break; + case PARTY_LAYOUT_DOUBLE: + InitWindows(sDoublePartyMenuWindowTemplate); + break; + case PARTY_LAYOUT_MULTI: + InitWindows(sMultiPartyMenuWindowTemplate); + break; + default: // PARTY_LAYOUT_MULTI_SHOWCASE + InitWindows(sShowcaseMultiPartyMenuWindowTemplate); + break; + } + DeactivateAllTextPrinters(); + for (i = 0; i < PARTY_SIZE; ++i) + FillWindowPixelBuffer(i, PIXEL_FILL(0)); + TextWindow_SetUserSelectedFrame(0, 0x4F, 0xD0); + TextWindow_SetStdFrame0_WithPal(0, 0x58, 0xF0); + LoadPalette(stdpal_get(2), 0xC0, 0x20); + LoadPalette(stdpal_get(0), 0xE0, 0x20); +} + +void CreateCancelConfirmWindows(bool8 chooseHalf) +{ + u8 confirmWindowId; + u8 cancelWindowId; + u8 offset; + + if (gPartyMenu.menuType != PARTY_MENU_TYPE_MULTI_SHOWCASE) + { + if (chooseHalf == TRUE) + { + confirmWindowId = AddWindow(&sConfirmButtonWindowTemplate); + FillWindowPixelBuffer(confirmWindowId, PIXEL_FILL(0)); + AddTextPrinterParameterized4(confirmWindowId, 0, (48 - GetStringWidth(0, gMenuText_Confirm, 0)) / 2u, 1, 0, 0, sFontColorTable[0], -1, gMenuText_Confirm); + PutWindowTilemap(confirmWindowId); + CopyWindowToVram(confirmWindowId, 2); + cancelWindowId = AddWindow(&sMultiCancelButtonWindowTemplate); + offset = 0; + } + else + { + cancelWindowId = AddWindow(&sCancelButtonWindowTemplate); + offset = 3; + } + FillWindowPixelBuffer(cancelWindowId, PIXEL_FILL(0)); + // Branches are functionally identical. Second branch is never reached, Spin Trade wasnt fully implemented + if (gPartyMenu.menuType != PARTY_MENU_TYPE_SPIN_TRADE) + { + offset += (48 - GetStringWidth(0, gFameCheckerText_Cancel, 0)) / 2; + AddTextPrinterParameterized3(cancelWindowId, 0, offset, 1, sFontColorTable[0], -1, gFameCheckerText_Cancel); + } + else + { + offset += (48 - GetStringWidth(0, gOtherText_Exit, 0)) / 2; + AddTextPrinterParameterized3(cancelWindowId, 0, offset, 1, sFontColorTable[0], -1, gOtherText_Exit); + } + PutWindowTilemap(cancelWindowId); + CopyWindowToVram(cancelWindowId, 2); + ScheduleBgCopyTilemapToVram(0); + } +} + +u16 *GetPartyMenuPalBufferPtr(u8 paletteId) +{ + return &sPartyMenuInternal->palBuffer[paletteId]; +} + +void BlitBitmapToPartyWindow(u8 windowId, const u8 *b, u8 c, u8 x, u8 y, u8 width, u8 height) +{ + u8 *pixels = AllocZeroed(height * width * 32); + u8 i, j; + + if (pixels != NULL) + { + for (i = 0; i < height; ++i) + for (j = 0; j < width; ++j) + CpuCopy16(GetPartyMenuBgTile(b[x + j + ((y + i) * c)]), &pixels[(i * width + j) * 32], 32); + BlitBitmapToWindow(windowId, pixels, x * 8, y * 8, width * 8, height * 8); + Free(pixels); + } +} + +void BlitBitmapToPartyWindow_LeftColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, u8 isEgg) +{ + if (width == 0 && height == 0) + { + width = 10; + height = 7; + } + if (!isEgg) + BlitBitmapToPartyWindow(windowId, sMainSlotTileNums, 10, x, y, width, height); + else + BlitBitmapToPartyWindow(windowId, sMainSlotTileNums_Egg, 10, x, y, width, height); +} + +void BlitBitmapToPartyWindow_RightColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, u8 isEgg) +{ + if (width == 0 && height == 0) + { + width = 18; + height = 3; + } + if (!isEgg) + BlitBitmapToPartyWindow(windowId, sOtherSlotsTileNums, 18, x, y, width, height); + else + BlitBitmapToPartyWindow(windowId, sOtherSlotsTileNums_Egg, 18, x, y, width, height); +} + +void DrawEmptySlot(u8 windowId) +{ + BlitBitmapToPartyWindow(windowId, sEmptySlotTileNums, 18, 0, 0, 18, 3); +} + +#define LOAD_PARTY_BOX_PAL(paletteIds, paletteOffsets) \ +{ \ + LoadPalette(GetPartyMenuPalBufferPtr(paletteIds[0]), paletteOffsets[0] + palNum, 2); \ + LoadPalette(GetPartyMenuPalBufferPtr(paletteIds[1]), paletteOffsets[1] + palNum, 2); \ + LoadPalette(GetPartyMenuPalBufferPtr(paletteIds[2]), paletteOffsets[2] + palNum, 2); \ +} + +void LoadPartyBoxPalette(struct PartyMenuBox *menuBox, u8 palFlags) +{ + u8 palNum = GetWindowAttribute(menuBox->windowId, WINDOW_PALETTE_NUM) * 16; + + if (palFlags & PARTY_PAL_TO_SOFTBOIL) + { + if (palFlags & PARTY_PAL_SELECTED) + { + LOAD_PARTY_BOX_PAL(sPartyBoxSelectedForActionPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxCurrSelectionPalIds2, sPartyBoxPalOffsets2); + } + else + { + LOAD_PARTY_BOX_PAL(sPartyBoxSelectedForActionPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxSelectedForActionPalIds2, sPartyBoxPalOffsets2); + } + } + else if (palFlags & PARTY_PAL_SWITCHING) + { + LOAD_PARTY_BOX_PAL(sPartyBoxSelectedForActionPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxSelectedForActionPalIds2, sPartyBoxPalOffsets2); + } + else if (palFlags & PARTY_PAL_TO_SWITCH) + { + if (palFlags & PARTY_PAL_SELECTED) + { + LOAD_PARTY_BOX_PAL(sPartyBoxSelectedForActionPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxCurrSelectionPalIds2, sPartyBoxPalOffsets2); + } + else + { + LOAD_PARTY_BOX_PAL(sPartyBoxSelectedForActionPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxSelectedForActionPalIds2, sPartyBoxPalOffsets2); + } + } + else if (palFlags & PARTY_PAL_FAINTED) + { + if (palFlags & PARTY_PAL_SELECTED) + { + LOAD_PARTY_BOX_PAL(sPartyBoxCurrSelectionFaintedPalIds, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxCurrSelectionPalIds2, sPartyBoxPalOffsets2); + } + else + { + LOAD_PARTY_BOX_PAL(sPartyBoxFaintedPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxFaintedPalIds2, sPartyBoxPalOffsets2); + } + } + else if (palFlags & PARTY_PAL_MULTI_ALT) + { + if (palFlags & PARTY_PAL_SELECTED) + { + LOAD_PARTY_BOX_PAL(sPartyBoxCurrSelectionMultiPalIds, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxCurrSelectionPalIds2, sPartyBoxPalOffsets2); + } + else + { + LOAD_PARTY_BOX_PAL(sPartyBoxMultiPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxMultiPalIds2, sPartyBoxPalOffsets2); + } + } + else if (palFlags & PARTY_PAL_SELECTED) + { + LOAD_PARTY_BOX_PAL(sPartyBoxCurrSelectionPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxCurrSelectionPalIds2, sPartyBoxPalOffsets2); + } + else + { + LOAD_PARTY_BOX_PAL(sPartyBoxEmptySlotPalIds1, sPartyBoxPalOffsets1); + LOAD_PARTY_BOX_PAL(sPartyBoxEmptySlotPalIds2, sPartyBoxPalOffsets2); + } +} + +void DisplayPartyPokemonBarDetail(u8 windowId, const u8 *str, u8 color, const u8 *align) +{ + AddTextPrinterParameterized3(windowId, 0, align[0], align[1], sFontColorTable[color], 0, str); +} + +void DisplayPartyPokemonNickname(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +{ + u8 nickname[POKEMON_NAME_LENGTH + 1]; + + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) + { + if (c == 1) + menuBox->infoRects->blitFunc(menuBox->windowId, menuBox->infoRects->dimensions[0] >> 3, menuBox->infoRects->dimensions[1] >> 3, menuBox->infoRects->dimensions[2] >> 3, menuBox->infoRects->dimensions[3] >> 3, FALSE); + GetMonNickname(mon, nickname); + DisplayPartyPokemonBarDetail(menuBox->windowId, nickname, 0, menuBox->infoRects->dimensions); + } +} + +void DisplayPartyPokemonLevelCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +{ + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) + { + u8 ailment = GetMonAilment(mon); + + if (ailment == AILMENT_NONE || ailment == AILMENT_PKRS) + { + if (c != 0) + menuBox->infoRects->blitFunc(menuBox->windowId, menuBox->infoRects->dimensions[4] >> 3, (menuBox->infoRects->dimensions[5] >> 3) + 1, menuBox->infoRects->dimensions[6] >> 3, menuBox->infoRects->dimensions[7] >> 3, FALSE); + if (c != 2) + DisplayPartyPokemonLevel(GetMonData(mon, MON_DATA_LEVEL), menuBox); + } + } +} + +void DisplayPartyPokemonLevel(u8 level, struct PartyMenuBox *menuBox) +{ + ConvertIntToDecimalStringN(gStringVar2, level, STR_CONV_MODE_LEFT_ALIGN, 3); + StringCopy(gStringVar1, gText_Lv); + StringAppend(gStringVar1, gStringVar2); + DisplayPartyPokemonBarDetail(menuBox->windowId, gStringVar1, 0, &menuBox->infoRects->dimensions[4]); +} + +void DisplayPartyPokemonGenderNidoranCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +{ + u8 nickname[POKEMON_NAME_LENGTH + 1]; + + if (c == 1) + menuBox->infoRects->blitFunc(menuBox->windowId, menuBox->infoRects->dimensions[8] >> 3, (menuBox->infoRects->dimensions[9] >> 3) + 1, menuBox->infoRects->dimensions[10] >> 3, menuBox->infoRects->dimensions[11] >> 3, FALSE); + GetMonNickname(mon, nickname); + DisplayPartyPokemonGender(GetMonGender(mon), GetMonData(mon, MON_DATA_SPECIES), nickname, menuBox); +} + +void DisplayPartyPokemonGender(u8 gender, u16 species, u8 *nickname, struct PartyMenuBox *menuBox) +{ + u8 palNum = GetWindowAttribute(menuBox->windowId, WINDOW_PALETTE_NUM) * 16; + + if (species == SPECIES_NONE) + return; + if ((species == SPECIES_NIDORAN_M || species == SPECIES_NIDORAN_F) && StringCompare(nickname, gSpeciesNames[species]) == 0) + return; + switch (gender) + { + case MON_MALE: + LoadPalette(GetPartyMenuPalBufferPtr(sGenderMalePalIds[0]), sGenderPalOffsets[0] + palNum, 2); + LoadPalette(GetPartyMenuPalBufferPtr(sGenderMalePalIds[1]), sGenderPalOffsets[1] + palNum, 2); + DisplayPartyPokemonBarDetail(menuBox->windowId, gText_MaleSymbol, 2, &menuBox->infoRects->dimensions[8]); + break; + case MON_FEMALE: + LoadPalette(GetPartyMenuPalBufferPtr(sGenderFemalePalIds[0]), sGenderPalOffsets[0] + palNum, 2); + LoadPalette(GetPartyMenuPalBufferPtr(sGenderFemalePalIds[1]), sGenderPalOffsets[1] + palNum, 2); + DisplayPartyPokemonBarDetail(menuBox->windowId, gText_FemaleSymbol, 2, &menuBox->infoRects->dimensions[8]); + break; + } +} + +void DisplayPartyPokemonHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +{ + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) + { + if (c != 0) + menuBox->infoRects->blitFunc(menuBox->windowId, menuBox->infoRects->dimensions[12] >> 3, (menuBox->infoRects->dimensions[13] >> 3) + 1, menuBox->infoRects->dimensions[14] >> 3, menuBox->infoRects->dimensions[15] >> 3, FALSE); + if (c != 2) + DisplayPartyPokemonHP(GetMonData(mon, MON_DATA_HP), menuBox); + } +} + +void DisplayPartyPokemonHP(u16 hp, struct PartyMenuBox *menuBox) +{ + u8 *strOut = ConvertIntToDecimalStringN(gStringVar1, hp, STR_CONV_MODE_RIGHT_ALIGN, 3); + + strOut[0] = CHAR_SLASH; + strOut[1] = EOS; + DisplayPartyPokemonBarDetail(menuBox->windowId, gStringVar1, 0, &menuBox->infoRects->dimensions[12]); +} + +void DisplayPartyPokemonMaxHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +{ + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) + { + if (c != 0) + menuBox->infoRects->blitFunc(menuBox->windowId, (menuBox->infoRects->dimensions[16] >> 3) + 1, (menuBox->infoRects->dimensions[17] >> 3) + 1, menuBox->infoRects->dimensions[18] >> 3, menuBox->infoRects->dimensions[19] >> 3, FALSE); + if (c != 2) + DisplayPartyPokemonMaxHP(GetMonData(mon, MON_DATA_MAX_HP), menuBox); + } +} + +void DisplayPartyPokemonMaxHP(u16 maxhp, struct PartyMenuBox *menuBox) +{ + ConvertIntToDecimalStringN(gStringVar2, maxhp, STR_CONV_MODE_RIGHT_ALIGN, 3); + StringCopy(gStringVar1, gText_Slash); + StringAppend(gStringVar1, gStringVar2); + DisplayPartyPokemonBarDetail(menuBox->windowId, gStringVar1, 0, &menuBox->infoRects->dimensions[16]); +} + +void DisplayPartyPokemonHPBarCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox) +{ + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) + DisplayPartyPokemonHPBar(GetMonData(mon, MON_DATA_HP), GetMonData(mon, MON_DATA_MAX_HP), menuBox); +} + +void DisplayPartyPokemonHPBar(u16 hp, u16 maxhp, struct PartyMenuBox *menuBox) +{ + u8 palNum = GetWindowAttribute(menuBox->windowId, WINDOW_PALETTE_NUM) * 16; + u8 hpFraction; + + switch (GetHPBarLevel(hp, maxhp)) + { + case HP_BAR_GREEN: + case HP_BAR_FULL: + LoadPalette(GetPartyMenuPalBufferPtr(sHPBarGreenPalIds[0]), sHPBarPalOffsets[0] + palNum, 2); + LoadPalette(GetPartyMenuPalBufferPtr(sHPBarGreenPalIds[1]), sHPBarPalOffsets[1] + palNum, 2); + break; + case HP_BAR_YELLOW: + LoadPalette(GetPartyMenuPalBufferPtr(sHPBarYellowPalIds[0]), sHPBarPalOffsets[0] + palNum, 2); + LoadPalette(GetPartyMenuPalBufferPtr(sHPBarYellowPalIds[1]), sHPBarPalOffsets[1] + palNum, 2); + break; + default: + LoadPalette(GetPartyMenuPalBufferPtr(sHPBarRedPalIds[0]), sHPBarPalOffsets[0] + palNum, 2); + LoadPalette(GetPartyMenuPalBufferPtr(sHPBarRedPalIds[1]), sHPBarPalOffsets[1] + palNum, 2); + break; + } + hpFraction = GetScaledHPFraction(hp, maxhp, menuBox->infoRects->dimensions[22]); + FillWindowPixelRect(menuBox->windowId, sHPBarPalOffsets[1], menuBox->infoRects->dimensions[20], menuBox->infoRects->dimensions[21], hpFraction, 1); + FillWindowPixelRect(menuBox->windowId, sHPBarPalOffsets[0], menuBox->infoRects->dimensions[20], menuBox->infoRects->dimensions[21] + 1, hpFraction, 2); + if (hpFraction != menuBox->infoRects->dimensions[22]) + { + // This appears to be an alternating fill + FillWindowPixelRect(menuBox->windowId, 0x0D, menuBox->infoRects->dimensions[20] + hpFraction, menuBox->infoRects->dimensions[21], menuBox->infoRects->dimensions[22] - hpFraction, 1); + FillWindowPixelRect(menuBox->windowId, 0x02, menuBox->infoRects->dimensions[20] + hpFraction, menuBox->infoRects->dimensions[21] + 1, menuBox->infoRects->dimensions[22] - hpFraction, 2); + } + CopyWindowToVram(menuBox->windowId, 2); +} + +void DisplayPartyPokemonDescriptionText(u8 stringId, struct PartyMenuBox *menuBox, u8 c) +{ + if (c != 0) + menuBox->infoRects->blitFunc(menuBox->windowId, menuBox->infoRects->descTextLeft >> 3, menuBox->infoRects->descTextTop >> 3, menuBox->infoRects->descTextWidth >> 3, menuBox->infoRects->descTextHeight >> 3, TRUE); + if (c != 2) + AddTextPrinterParameterized3(menuBox->windowId, 1, menuBox->infoRects->descTextLeft, menuBox->infoRects->descTextTop, sFontColorTable[0], 0, sDescriptionStringTable[stringId]); +} + +void PartyMenuRemoveWindow(u8 *ptr) +{ + if (*ptr != 0xFF) + { + ClearStdWindowAndFrameToTransparent(*ptr, 0); + RemoveWindow(*ptr); + *ptr = 0xFF; + ScheduleBgCopyTilemapToVram(2); + } +} + +void DisplayPartyMenuStdMessage(u32 stringId) +{ + u8 *windowPtr = &sPartyMenuInternal->windowId[1]; + + if (*windowPtr != 0xFF) + PartyMenuRemoveWindow(windowPtr); + + if (stringId != PARTY_MSG_NONE) + { + switch (stringId) + { + case PARTY_MSG_DO_WHAT_WITH_MON: + *windowPtr = AddWindow(&sDoWhatWithMonMsgWindowTemplate); + break; + case PARTY_MSG_DO_WHAT_WITH_ITEM: + *windowPtr = AddWindow(&sDoWhatWithItemMsgWindowTemplate); + break; + case PARTY_MSG_DO_WHAT_WITH_MAIL: + *windowPtr = AddWindow(&sDoWhatWithMailMsgWindowTemplate); + break; + case PARTY_MSG_RESTORE_WHICH_MOVE: + case PARTY_MSG_BOOST_PP_WHICH_MOVE: + *windowPtr = AddWindow(&sWhichMoveMsgWindowTemplate); + break; + default: + *windowPtr = AddWindow(&sDefaultPartyMsgWindowTemplate); break; } + + if (stringId == PARTY_MSG_CHOOSE_MON) + { + if (sPartyMenuInternal->chooseHalf) + stringId = PARTY_MSG_CHOOSE_MON_AND_CONFIRM; + else if (!ShouldUseChooseMonText()) + stringId = PARTY_MSG_CHOOSE_MON_OR_CANCEL; + } + DrawStdFrameWithCustomTileAndPalette(*windowPtr, FALSE, 0x58, 0xF); + StringExpandPlaceholders(gStringVar4, sActionStringTable[stringId]); + AddTextPrinterParameterized(*windowPtr, 2, gStringVar4, 0, 2, 0, 0); + ScheduleBgCopyTilemapToVram(2); + } +} + +bool8 ShouldUseChooseMonText(void) +{ + struct Pokemon *party = gPlayerParty; + u8 i; + u8 numAliveMons = 0; + + if (gPartyMenu.action == PARTY_ACTION_SEND_OUT) + return TRUE; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (GetMonData(&party[i], MON_DATA_SPECIES) != SPECIES_NONE && (GetMonData(&party[i], MON_DATA_HP) != 0 || GetMonData(&party[i], MON_DATA_IS_EGG))) + ++numAliveMons; + if (numAliveMons > 1) + return TRUE; + } + return FALSE; +} + +u8 DisplaySelectionWindow(u8 windowType) +{ + struct WindowTemplate window; + u8 cursorDimension; + u8 fontAttribute; + u8 i; + + switch (windowType) + { + case SELECTWINDOW_ACTIONS: + window = SetWindowTemplateFields(2, 19, 19 - (sPartyMenuInternal->numActions * 2), 10, sPartyMenuInternal->numActions * 2, 14, 0x2BF); + break; + case SELECTWINDOW_ITEM: + window = sItemGiveTakeWindowTemplate; + break; + case SELECTWINDOW_MAIL: + window = sMailReadTakeWindowTemplate; + break; + default: // SELECTWINDOW_MOVES + window = sMoveSelectWindowTemplate; + break; + } + sPartyMenuInternal->windowId[0] = AddWindow(&window); + DrawStdFrameWithCustomTileAndPalette(sPartyMenuInternal->windowId[0], FALSE, 0x4F, 13); + if (windowType == SELECTWINDOW_MOVES) + return sPartyMenuInternal->windowId[0]; + cursorDimension = GetMenuCursorDimensionByFont(2, 0); + fontAttribute = GetFontAttribute(2, FONTATTR_LETTER_SPACING); + for (i = 0; i < sPartyMenuInternal->numActions; ++i) + { + u8 fontColorsId = (sPartyMenuInternal->actions[i] >= MENU_FIELD_MOVES) ? 4 : 3; + + AddTextPrinterParameterized4(sPartyMenuInternal->windowId[0], 2, cursorDimension, (i * 16) + 2, fontAttribute, 0, sFontColorTable[fontColorsId], 0, sCursorOptions[sPartyMenuInternal->actions[i]].text); + } + Menu_InitCursorInternal(sPartyMenuInternal->windowId[0], 2, 0, 2, 16, sPartyMenuInternal->numActions, 0, 1); + ScheduleBgCopyTilemapToVram(2); + return sPartyMenuInternal->windowId[0]; +} + +void PartyMenuPrintText(const u8 *text) +{ + DrawStdFrameWithCustomTileAndPalette(6, FALSE, 0x4F, 13); + gTextFlags.canABSpeedUpPrint = TRUE; + AddTextPrinterParameterized2(6, 2, text, GetTextSpeedSetting(), 0, 2, 1, 3); +} + +void PartyMenuDisplayYesNoMenu(void) +{ + CreateYesNoMenu(&sPartyMenuYesNoWindowTemplate, 2, 0, 2, 0x4F, 13, 0); +} + +u8 CreateLevelUpStatsWindow(void) +{ + sPartyMenuInternal->windowId[0] = AddWindow(&sLevelUpStatsWindowTemplate); + DrawStdFrameWithCustomTileAndPalette(sPartyMenuInternal->windowId[0], FALSE, 0x4F, 13); + return sPartyMenuInternal->windowId[0]; +} + +void RemoveLevelUpStatsWindow(void) +{ + ClearWindowTilemap(sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); +} + +void sub_8122084(u8 windowId, const u8 *str) +{ + StringExpandPlaceholders(gStringVar4, str); + gTextFlags.canABSpeedUpPrint = TRUE; + AddTextPrinterParameterized2(windowId, 4, gStringVar4, GetTextSpeedSetting(), 0, 2, 1, 3); +} + +bool8 sub_81220D4(void) +{ + u8 windowId = AddWindow(&gUnknown_845A170); + + TextWindow_LoadResourcesStdFrame0(windowId, 0x4F, 0xE0); + DrawDialogFrameWithCustomTileAndPalette(windowId, 1, 0x4F, 0xE); + sub_8122084(windowId, gUnknown_8417457); + return windowId; +} + +void sub_8122110(u8 windowId) +{ + ClearWindowTilemap(windowId); + ClearDialogWindowAndFrameToTransparent(windowId, FALSE); + RemoveWindow(windowId); + ScheduleBgCopyTilemapToVram(2); +} + +void sub_8122138(u8 action) +{ + u8 attr; + struct PartyMenuInternal *ptr = sPartyMenuInternal; + + if (action <= 17) + { + if (ptr->windowId[2] != 0xFF) + { + ClearWindowTilemap(ptr->windowId[2]); + RemoveWindow(ptr->windowId[2]); + ptr->windowId[2] = 0xFF; + ScheduleBgCopyTilemapToVram(2); + } + } + else + { + if (ptr->windowId[2] == 0xFF) + ptr->windowId[2] = AddWindow(&gUnknown_845A178); + sub_8112F18(ptr->windowId[2]); + attr = GetFontAttribute(2, FONTATTR_LETTER_SPACING); + AddTextPrinterParameterized4(ptr->windowId[2], 2, 3, 6, attr, 0, sFontColorTable[5], 0, sHMDescriptionTable[action - 18]); + PutWindowTilemap(ptr->windowId[2]); + ScheduleBgCopyTilemapToVram(2); + } +} + +void CreatePartyMonIconSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox, u32 slot) +{ + bool32 handleDeoxys = TRUE; + u16 species2; + + // If in a multi battle, show partners Deoxys icon as Normal forme + if (IsMultiBattle() == TRUE && gMain.inBattle) + handleDeoxys = (sMultiBattlePartnersPartyMask[slot] ^ handleDeoxys) ? TRUE : FALSE; + species2 = GetMonData(mon, MON_DATA_SPECIES2); + CreatePartyMonIconSpriteParameterized(species2, GetMonData(mon, MON_DATA_PERSONALITY), menuBox, 1, handleDeoxys); + UpdatePartyMonHPBar(menuBox->monSpriteId, mon); +} + +void CreatePartyMonIconSpriteParameterized(u16 species, u32 pid, struct PartyMenuBox *menuBox, u8 priority, bool32 handleDeoxys) +{ + if (species != SPECIES_NONE) + { + menuBox->monSpriteId = CreateMonIcon(species, SpriteCB_MonIcon, menuBox->spriteCoords[0], menuBox->spriteCoords[1], 4, pid, handleDeoxys); + gSprites[menuBox->monSpriteId].oam.priority = priority; + } +} + +void UpdateHPBar(u8 spriteId, u16 hp, u16 maxhp) +{ + switch (GetHPBarLevel(hp, maxhp)) + { + case HP_BAR_FULL: + SetPartyHPBarSprite(&gSprites[spriteId], 0); + break; + case HP_BAR_GREEN: + SetPartyHPBarSprite(&gSprites[spriteId], 1); + break; + case HP_BAR_YELLOW: + SetPartyHPBarSprite(&gSprites[spriteId], 2); + break; + case HP_BAR_RED: + SetPartyHPBarSprite(&gSprites[spriteId], 3); + break; + default: + SetPartyHPBarSprite(&gSprites[spriteId], 4); + break; + } +} + +void UpdatePartyMonHPBar(u8 spriteId, struct Pokemon *mon) +{ + UpdateHPBar(spriteId, GetMonData(mon, MON_DATA_HP), GetMonData(mon, MON_DATA_MAX_HP)); +} + +void AnimateSelectedPartyIcon(u8 spriteId, u8 animNum) +{ + gSprites[spriteId].data[0] = 0; + if (animNum == 0) + { + if (gSprites[spriteId].pos1.x == 16) + { + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = -4; + } + else + { + gSprites[spriteId].pos2.x = -4; + gSprites[spriteId].pos2.y = 0; + } + gSprites[spriteId].callback = SpriteCB_UpdatePartyMonIcon; + } + else + { + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + gSprites[spriteId].callback = SpriteCB_BouncePartyMonIcon; + } +} + +void SpriteCB_BouncePartyMonIcon(struct Sprite *sprite) +{ + u8 animCmd = UpdateMonIconFrame(sprite); + + if (animCmd != 0) + { + if (animCmd & 1) // % 2 also matches + sprite->pos2.y = -3; + else + sprite->pos2.y = 1; + } +} + +void SpriteCB_UpdatePartyMonIcon(struct Sprite *sprite) +{ + UpdateMonIconFrame(sprite); +} + +void CreatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) +{ + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) + { + menuBox->itemSpriteId = CreateSprite(&sSpriteTemplate_HeldItem, menuBox->spriteCoords[2], menuBox->spriteCoords[3], 0); + UpdatePartyMonHeldItemSprite(mon, menuBox); + } +} + +void CreatePartyMonHeldItemSpriteParameterized(u16 species, u16 item, struct PartyMenuBox *menuBox) +{ + if (species != SPECIES_NONE) + { + menuBox->itemSpriteId = CreateSprite(&sSpriteTemplate_HeldItem, menuBox->spriteCoords[2], menuBox->spriteCoords[3], 0); + gSprites[menuBox->itemSpriteId].oam.priority = 0; + ShowOrHideHeldItemSprite(item, menuBox); + } +} + +void UpdatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) +{ + ShowOrHideHeldItemSprite(GetMonData(mon, MON_DATA_HELD_ITEM), menuBox); +} + +void ShowOrHideHeldItemSprite(u16 item, struct PartyMenuBox *menuBox) +{ + if (item == ITEM_NONE) + { + gSprites[menuBox->itemSpriteId].invisible = TRUE; + } + else + { + if (ItemIsMail(item)) + StartSpriteAnim(&gSprites[menuBox->itemSpriteId], 1); + else + StartSpriteAnim(&gSprites[menuBox->itemSpriteId], 0); + gSprites[menuBox->itemSpriteId].invisible = FALSE; + } +} + +void LoadHeldItemIcons(void) +{ + LoadSpriteSheet(&sSpriteSheet_HeldItem); + LoadSpritePalette(&sSpritePalette_HeldItem); +} + +void DrawHeldItemIconsForTrade(u8 *partyCounts, u8 *partySpriteIds, u8 whichParty) +{ + u16 i; + u16 item; + + switch (whichParty) + { + case TRADE_PLAYER: + for (i = 0; i < partyCounts[TRADE_PLAYER]; ++i) + { + item = GetMonData(&gPlayerParty[i], MON_DATA_HELD_ITEM); + if (item != ITEM_NONE) + CreateHeldItemSpriteForTrade(partySpriteIds[i], ItemIsMail(item)); + } + break; + case TRADE_PARTNER: + for (i = 0; i < partyCounts[TRADE_PARTNER]; ++i) + { + item = GetMonData(&gEnemyParty[i], MON_DATA_HELD_ITEM); + if (item != ITEM_NONE) + CreateHeldItemSpriteForTrade(partySpriteIds[i + PARTY_SIZE], ItemIsMail(item)); + } + break; + } +} + +void CreateHeldItemSpriteForTrade(u8 spriteId, bool8 isMail) +{ + u8 subpriority = gSprites[spriteId].subpriority; + u8 newSpriteId = CreateSprite(&sSpriteTemplate_HeldItem, 250, 170, subpriority - 1); + + gSprites[newSpriteId].pos2.x = 4; + gSprites[newSpriteId].pos2.y = 10; + gSprites[newSpriteId].callback = SpriteCB_HeldItem; + gSprites[newSpriteId].data[7] = spriteId; + StartSpriteAnim(&gSprites[newSpriteId], isMail); + gSprites[newSpriteId].callback(&gSprites[newSpriteId]); +} + +void SpriteCB_HeldItem(struct Sprite *sprite) +{ + u8 otherSpriteId = sprite->data[7]; + + if (gSprites[otherSpriteId].invisible) + { + sprite->invisible = TRUE; + } + else + { + sprite->invisible = FALSE; + sprite->pos1.x = gSprites[otherSpriteId].pos1.x + gSprites[otherSpriteId].pos2.x; + sprite->pos1.y = gSprites[otherSpriteId].pos1.y + gSprites[otherSpriteId].pos2.y; + } +} + +void CreatePartyMonPokeballSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) +{ + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) + menuBox->pokeballSpriteId = CreateSprite(&sSpriteTemplate_MenuPokeball, menuBox->spriteCoords[6], menuBox->spriteCoords[7], 8); +} + +void CreatePartyMonPokeballSpriteParameterized(u16 species, struct PartyMenuBox *menuBox) +{ + if (species != SPECIES_NONE) + { + menuBox->pokeballSpriteId = CreateSprite(&sSpriteTemplate_MenuPokeball, menuBox->spriteCoords[6], menuBox->spriteCoords[7], 8); + gSprites[menuBox->pokeballSpriteId].oam.priority = 0; + } +} + +// For Cancel when Confirm isnt present +u8 CreatePokeballButtonSprite(u8 x, u8 y) +{ + u8 spriteId = CreateSprite(&sSpriteTemplate_MenuPokeball, x, y, 8); + + gSprites[spriteId].oam.priority = 2; + return spriteId; +} + +// For Confirm and Cancel when both are present +u8 CreateSmallPokeballButtonSprite(u8 x, u8 y) +{ + return CreateSprite(&sSpriteTemplate_MenuPokeballSmall, x, y, 8); +} + +void PartyMenuStartSpriteAnim(u8 spriteId, u8 animNum) +{ + StartSpriteAnim(&gSprites[spriteId], animNum); +} + +// Unused. Might explain the large blank section in gPartyMenuPokeballSmall_Gfx +// At the very least this is how the unused anim cmds for sSpriteAnimTable_MenuPokeballSmall were meant to be accessed +void SpriteCB_BounceConfirmCancelButton(u8 spriteId, u8 spriteId2, u8 animNum) +{ + if (animNum == 0) + { + StartSpriteAnim(&gSprites[spriteId], 2); + StartSpriteAnim(&gSprites[spriteId2], 4); + gSprites[spriteId].pos2.y = 0; + gSprites[spriteId2].pos2.y = 0; + } + else + { + StartSpriteAnim(&gSprites[spriteId], 3); + StartSpriteAnim(&gSprites[spriteId2], 5); + gSprites[spriteId].pos2.y = -4; + gSprites[spriteId2].pos2.y = 4; + } +} + +void LoadPartyMenuPokeballGfx(void) +{ + LoadCompressedSpriteSheet(&sSpriteSheet_MenuPokeball); + LoadCompressedSpriteSheet(&sSpriteSheet_MenuPokeballSmall); + LoadCompressedSpritePalette(&sSpritePalette_MenuPokeball); +} + +void CreatePartyMonStatusSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) +{ + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) + { + menuBox->statusSpriteId = CreateSprite(&sSpriteTemplate_StatusIcons, menuBox->spriteCoords[4], menuBox->spriteCoords[5], 0); + SetPartyMonAilmentGfx(mon, menuBox); + } +} + +void CreatePartyMonStatusSpriteParameterized(u16 species, u8 status, struct PartyMenuBox *menuBox) +{ + if (species != SPECIES_NONE) + { + menuBox->statusSpriteId = CreateSprite(&sSpriteTemplate_StatusIcons, menuBox->spriteCoords[4], menuBox->spriteCoords[5], 0); + UpdatePartyMonAilmentGfx(status, menuBox); + gSprites[menuBox->statusSpriteId].oam.priority = 0; + } +} + +void SetPartyMonAilmentGfx(struct Pokemon *mon, struct PartyMenuBox *menuBox) +{ + UpdatePartyMonAilmentGfx(GetMonAilment(mon), menuBox); +} + +void UpdatePartyMonAilmentGfx(u8 status, struct PartyMenuBox *menuBox) +{ + switch (status) + { + case AILMENT_NONE: + case AILMENT_PKRS: + gSprites[menuBox->statusSpriteId].invisible = TRUE; + break; + default: + StartSpriteAnim(&gSprites[menuBox->statusSpriteId], status - 1); + gSprites[menuBox->statusSpriteId].invisible = FALSE; + break; + } +} + +void LoadPartyMenuAilmentGfx(void) +{ + LoadCompressedSpriteSheet(&sSpriteSheet_StatusIcons); + LoadCompressedSpritePalette(&sSpritePalette_StatusIcons); +} + +void SetPartyMonSelectionActions(struct Pokemon *mons, u8 slotId, u8 action) +{ + u8 i; + + if (action == ACTIONS_NONE) + { + SetPartyMonFieldSelectionActions(mons, slotId); + } + else + { + sPartyMenuInternal->numActions = sPartyMenuActionCounts[action]; + for (i = 0; i < sPartyMenuInternal->numActions; ++i) + sPartyMenuInternal->actions[i] = sPartyMenuActions[action][i]; + } +} + +void SetPartyMonFieldSelectionActions(struct Pokemon *mons, u8 slotId) +{ + u8 i, j; + + sPartyMenuInternal->numActions = 0; + AppendToList(sPartyMenuInternal->actions, &sPartyMenuInternal->numActions, MENU_SUMMARY); + // Add field moves to action list + for (i = 0; i < MAX_MON_MOVES; ++i) + { + for (j = 0; sFieldMoves[j] != FIELD_MOVE_END; ++j) + { + if (GetMonData(&mons[slotId], i + MON_DATA_MOVE1) == sFieldMoves[j]) + { + AppendToList(sPartyMenuInternal->actions, &sPartyMenuInternal->numActions, j + MENU_FIELD_MOVES); + break; + } + } + } + if (GetMonData(&mons[1], MON_DATA_SPECIES) != SPECIES_NONE) + AppendToList(sPartyMenuInternal->actions, &sPartyMenuInternal->numActions, MENU_SWITCH); + if (ItemIsMail(GetMonData(&mons[slotId], MON_DATA_HELD_ITEM))) + AppendToList(sPartyMenuInternal->actions, &sPartyMenuInternal->numActions, MENU_MAIL); + else + AppendToList(sPartyMenuInternal->actions, &sPartyMenuInternal->numActions, MENU_ITEM); + AppendToList(sPartyMenuInternal->actions, &sPartyMenuInternal->numActions, MENU_CANCEL1); +} + +u8 GetPartyMenuActionsType(struct Pokemon *mon) +{ + u32 actionType; + + switch (gPartyMenu.menuType) + { + case PARTY_MENU_TYPE_FIELD: + if (GetMonData(mon, MON_DATA_IS_EGG)) + actionType = ACTIONS_SWITCH; + else + actionType = ACTIONS_NONE; // actions populated by SetPartyMonFieldSelectionActions + break; + case PARTY_MENU_TYPE_IN_BATTLE: + actionType = GetPartyMenuActionsTypeInBattle(mon); + break; + case PARTY_MENU_TYPE_CHOOSE_HALF: + switch (GetPartySlotEntryStatus(gPartyMenu.slotId)) + { + default: // Not eligible + actionType = ACTIONS_SUMMARY_ONLY; + break; + case 0: // Eligible + actionType = ACTIONS_ENTER; + break; + case 1: // Already selected + actionType = ACTIONS_NO_ENTRY; + break; + } + break; + case PARTY_MENU_TYPE_DAYCARE: + actionType = (GetMonData(mon, MON_DATA_IS_EGG)) ? ACTIONS_SUMMARY_ONLY : ACTIONS_STORE; + break; + case PARTY_MENU_TYPE_UNION_ROOM_REGISTER: + actionType = ACTIONS_REGISTER; + break; + case PARTY_MENU_TYPE_UNION_ROOM_TRADE: + actionType = ACTIONS_TRADE; + break; + case PARTY_MENU_TYPE_SPIN_TRADE: + actionType = ACTIONS_SPIN_TRADE; + break; + // The following have no selection actions (i.e. they exit immediately upon selection) + // PARTY_MENU_TYPE_CONTEST + // PARTY_MENU_TYPE_CHOOSE_MON + // PARTY_MENU_TYPE_MULTI_SHOWCASE + // PARTY_MENU_TYPE_MOVE_RELEARNER + // PARTY_MENU_TYPE_MINIGAME + default: + actionType = ACTIONS_NONE; + break; + } + return actionType; +} + +void CreateSelectionWindow(void) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + + GetMonNickname(mon, gStringVar1); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + SetPartyMonSelectionActions(gPlayerParty, gPartyMenu.slotId, GetPartyMenuActionsType(mon)); + DisplaySelectionWindow(SELECTWINDOW_ACTIONS); + DisplayPartyMenuStdMessage(PARTY_MSG_DO_WHAT_WITH_MON); +} + +void Task_TryCreateSelectionWindow(u8 taskId) +{ + CreateSelectionWindow(); + gTasks[taskId].data[0] = 0xFF; + gTasks[taskId].func = Task_HandleSelectionMenuInput; +} + +void Task_HandleSelectionMenuInput(u8 taskId) +{ + if (!gPaletteFade.active && sub_80BF748() != TRUE) + { + s8 input; + s16 *data = gTasks[taskId].data; + + if (sPartyMenuInternal->numActions <= 3) + input = Menu_ProcessInputNoWrapAround_other(); + else + input = Menu_ProcessInput_other(); + if (data[0] != Menu_GetCursorPos()) + sub_8122138(sPartyMenuInternal->actions[Menu_GetCursorPos()]); + data[0] = Menu_GetCursorPos(); + switch (input) + { + case MENU_NOTHING_CHOSEN: + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[2]); + sCursorOptions[sPartyMenuInternal->actions[sPartyMenuInternal->numActions - 1]].func(taskId); + break; + default: + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[2]); + sCursorOptions[sPartyMenuInternal->actions[input]].func(taskId); + break; + } + } +} + +void CursorCB_Summary(u8 taskId) +{ + PlaySE(SE_SELECT); + sPartyMenuInternal->exitCallback = CB2_ShowPokemonSummaryScreen; + Task_ClosePartyMenu(taskId); +} + +void CB2_ShowPokemonSummaryScreen(void) +{ + if (gPartyMenu.menuType == PARTY_MENU_TYPE_IN_BATTLE) + UpdatePartyToBattleOrder(); + ShowPokemonSummaryScreen(gPlayerParty, gPartyMenu.slotId, gPlayerPartyCount - 1, CB2_ReturnToPartyMenuFromSummaryScreen, 0); +} + +void CB2_ReturnToPartyMenuFromSummaryScreen(void) +{ + gPaletteFade.bufferTransferDisabled = TRUE; + gPartyMenu.slotId = GetLastViewedMonIndex(); + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_DO_WHAT_WITH_MON, Task_TryCreateSelectionWindow, gPartyMenu.exitCallback); +} + +void CursorCB_Switch(u8 taskId) +{ + PlaySE(SE_SELECT); + gPartyMenu.action = PARTY_ACTION_SWITCH; + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + DisplayPartyMenuStdMessage(PARTY_MSG_MOVE_TO_WHERE); + AnimatePartySlot(gPartyMenu.slotId, 1); + gPartyMenu.slotId2 = gPartyMenu.slotId; + gTasks[taskId].func = Task_HandleChooseMonInput; +} + +#define tSlot1Left data[0] +#define tSlot1Top data[1] +#define tSlot1Width data[2] +#define tSlot1Height data[3] +#define tSlot2Left data[4] +#define tSlot2Top data[5] +#define tSlot2Width data[6] +#define tSlot2Height data[7] +#define tSlot1Offset data[8] +#define tSlot2Offset data[9] +#define tSlot1SlideDir data[10] +#define tSlot2SlideDir data[11] + +void SwitchSelectedMons(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + u8 windowIds[2]; + + if (gPartyMenu.slotId2 == gPartyMenu.slotId) + { + FinishTwoMonAction(taskId); + } + else + { + // Initialize switching party mons slide animation + sub_812358C(); + windowIds[0] = sPartyMenuBoxes[gPartyMenu.slotId].windowId; + tSlot1Left = GetWindowAttribute(windowIds[0], WINDOW_TILEMAP_LEFT); + tSlot1Top = GetWindowAttribute(windowIds[0], WINDOW_TILEMAP_TOP); + tSlot1Width = GetWindowAttribute(windowIds[0], WINDOW_WIDTH); + tSlot1Height = GetWindowAttribute(windowIds[0], WINDOW_HEIGHT); + tSlot1Offset = 0; + if (tSlot1Width == 10) + tSlot1SlideDir = -1; + else + tSlot1SlideDir = 1; + windowIds[1] = sPartyMenuBoxes[gPartyMenu.slotId2].windowId; + tSlot2Left = GetWindowAttribute(windowIds[1], WINDOW_TILEMAP_LEFT); + tSlot2Top = GetWindowAttribute(windowIds[1], WINDOW_TILEMAP_TOP); + tSlot2Width = GetWindowAttribute(windowIds[1], WINDOW_WIDTH); + tSlot2Height = GetWindowAttribute(windowIds[1], WINDOW_HEIGHT); + tSlot2Offset = 0; + if (tSlot2Width == 10) + tSlot2SlideDir = -1; + else + tSlot2SlideDir = 1; + sSlot1TilemapBuffer = Alloc(tSlot1Width * (tSlot1Height << 1)); + sSlot2TilemapBuffer = Alloc(tSlot2Width * (tSlot2Height << 1)); + CopyToBufferFromBgTilemap(0, sSlot1TilemapBuffer, tSlot1Left, tSlot1Top, tSlot1Width, tSlot1Height); + CopyToBufferFromBgTilemap(0, sSlot2TilemapBuffer, tSlot2Left, tSlot2Top, tSlot2Width, tSlot2Height); + ClearWindowTilemap(windowIds[0]); + ClearWindowTilemap(windowIds[1]); + gPartyMenu.action = PARTY_ACTION_SWITCHING; + AnimatePartySlot(gPartyMenu.slotId, 1); + AnimatePartySlot(gPartyMenu.slotId2, 1); + SlidePartyMenuBoxOneStep(taskId); + gTasks[taskId].func = Task_SlideSelectedSlotsOffscreen; + } +} + +// returns FALSE if the slot has slid fully offscreen / back onscreen +bool8 TryMovePartySlot(s16 x, s16 width, u8 *leftMove, u8 *newX, u8 *newWidth) +{ + if ((x + width) < 0) + return FALSE; + if (x > 31) + return FALSE; + if (x < 0) + { + *leftMove = x * -1; + *newX = 0; + *newWidth = width + x; + } + else + { + *leftMove = 0; + *newX = x; + if ((x + width) > 31) + *newWidth = 32 - x; + else + *newWidth = width; + } + return TRUE; +} + +void MoveAndBufferPartySlot(const void *rectSrc, s16 x, s16 y, s16 width, s16 height, s16 dir) +{ + // The use of the dimension parameters here is a mess + u8 leftMove, newX, newWidth; // leftMove is used as a srcX, newX is used as both x and srcHeight, newWidth is used as both width and destY + + if (TryMovePartySlot(x, width, &leftMove, &newX, &newWidth)) + { + FillBgTilemapBufferRect_Palette0(0, 0, newX, y, newWidth, height); + if (TryMovePartySlot(x + dir, width, &leftMove, &newX, &newWidth)) + CopyRectToBgTilemapBufferRect(0, rectSrc, leftMove, 0, width, height, newX, y, newWidth, height, 17, 0, 0); + } +} + +void MovePartyMenuBoxSprites(struct PartyMenuBox *menuBox, s16 offset) +{ + gSprites[menuBox->pokeballSpriteId].pos2.x += offset * 8; + gSprites[menuBox->itemSpriteId].pos2.x += offset * 8; + gSprites[menuBox->monSpriteId].pos2.x += offset * 8; + gSprites[menuBox->statusSpriteId].pos2.x += offset * 8; +} + +void SlidePartyMenuBoxSpritesOneStep(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (tSlot1SlideDir != 0) + MovePartyMenuBoxSprites(&sPartyMenuBoxes[gPartyMenu.slotId], tSlot1SlideDir); + if (tSlot2SlideDir != 0) + MovePartyMenuBoxSprites(&sPartyMenuBoxes[gPartyMenu.slotId2], tSlot2SlideDir); +} + +void SlidePartyMenuBoxOneStep(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (tSlot1SlideDir != 0) + MoveAndBufferPartySlot(sSlot1TilemapBuffer, tSlot1Left + tSlot1Offset, tSlot1Top, tSlot1Width, tSlot1Height, tSlot1SlideDir); + if (tSlot2SlideDir != 0) + MoveAndBufferPartySlot(sSlot2TilemapBuffer, tSlot2Left + tSlot2Offset, tSlot2Top, tSlot2Width, tSlot2Height, tSlot2SlideDir); + ScheduleBgCopyTilemapToVram(0); +} + +void Task_SlideSelectedSlotsOffscreen(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + u16 slidingSlotPositions[2]; + + SlidePartyMenuBoxOneStep(taskId); + SlidePartyMenuBoxSpritesOneStep(taskId); + tSlot1Offset += tSlot1SlideDir; + tSlot2Offset += tSlot2SlideDir; + slidingSlotPositions[0] = tSlot1Left + tSlot1Offset; + slidingSlotPositions[1] = tSlot2Left + tSlot2Offset; + // Both slots have slid offscreen + if (slidingSlotPositions[0] > 33 && slidingSlotPositions[1] > 33) + { + tSlot1SlideDir *= -1; + tSlot2SlideDir *= -1; + SwitchPartyMon(); + DisplayPartyPokemonData(gPartyMenu.slotId); + DisplayPartyPokemonData(gPartyMenu.slotId2); + PutWindowTilemap(sPartyMenuBoxes[gPartyMenu.slotId].windowId); + PutWindowTilemap(sPartyMenuBoxes[gPartyMenu.slotId2].windowId); + CopyToBufferFromBgTilemap(0, sSlot1TilemapBuffer, tSlot1Left, tSlot1Top, tSlot1Width, tSlot1Height); + CopyToBufferFromBgTilemap(0, sSlot2TilemapBuffer, tSlot2Left, tSlot2Top, tSlot2Width, tSlot2Height); + ClearWindowTilemap(sPartyMenuBoxes[gPartyMenu.slotId].windowId); + ClearWindowTilemap(sPartyMenuBoxes[gPartyMenu.slotId2].windowId); + gTasks[taskId].func = Task_SlideSelectedSlotsOnscreen; + } +} + +void Task_SlideSelectedSlotsOnscreen(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + SlidePartyMenuBoxOneStep(taskId); + SlidePartyMenuBoxSpritesOneStep(taskId); + + // Both slots have slide back onscreen + if (tSlot1SlideDir == 0 && tSlot2SlideDir == 0) + { + PutWindowTilemap(sPartyMenuBoxes[gPartyMenu.slotId].windowId); + PutWindowTilemap(sPartyMenuBoxes[gPartyMenu.slotId2].windowId); + ScheduleBgCopyTilemapToVram(0); + // memory leak + // Free(sSlot1TilemapBuffer); + // Free(sSlot2TilemapBuffer); + FinishTwoMonAction(taskId); + } + // Continue sliding + else + { + tSlot1Offset += tSlot1SlideDir; + tSlot2Offset += tSlot2SlideDir; + if (tSlot1Offset == 0) + tSlot1SlideDir = 0; + if (tSlot2Offset == 0) + tSlot2SlideDir = 0; + } +} + +void SwitchMenuBoxSprites(u8 *spriteIdPtr1, u8 *spriteIdPtr2) +{ + u8 spriteIdBuffer = *spriteIdPtr1; + u16 xBuffer1, yBuffer1, xBuffer2, yBuffer2; + + *spriteIdPtr1 = *spriteIdPtr2; + *spriteIdPtr2 = spriteIdBuffer; + xBuffer1 = gSprites[*spriteIdPtr1].pos1.x; + yBuffer1 = gSprites[*spriteIdPtr1].pos1.y; + xBuffer2 = gSprites[*spriteIdPtr1].pos2.x; + yBuffer2 = gSprites[*spriteIdPtr1].pos2.y; + gSprites[*spriteIdPtr1].pos1.x = gSprites[*spriteIdPtr2].pos1.x; + gSprites[*spriteIdPtr1].pos1.y = gSprites[*spriteIdPtr2].pos1.y; + gSprites[*spriteIdPtr1].pos2.x = gSprites[*spriteIdPtr2].pos2.x; + gSprites[*spriteIdPtr1].pos2.y = gSprites[*spriteIdPtr2].pos2.y; + gSprites[*spriteIdPtr2].pos1.x = xBuffer1; + gSprites[*spriteIdPtr2].pos1.y = yBuffer1; + gSprites[*spriteIdPtr2].pos2.x = xBuffer2; + gSprites[*spriteIdPtr2].pos2.y = yBuffer2; +} + +void SwitchPartyMon(void) +{ + struct PartyMenuBox *menuBoxes[2]; + struct Pokemon *mon1, *mon2; + struct Pokemon *monBuffer; + + menuBoxes[0] = &sPartyMenuBoxes[gPartyMenu.slotId]; + menuBoxes[1] = &sPartyMenuBoxes[gPartyMenu.slotId2]; + mon1 = &gPlayerParty[gPartyMenu.slotId]; + mon2 = &gPlayerParty[gPartyMenu.slotId2]; + monBuffer = Alloc(sizeof(struct Pokemon)); + *monBuffer = *mon1; + *mon1 = *mon2; + *mon2 = *monBuffer; + Free(monBuffer); + SwitchMenuBoxSprites(&menuBoxes[0]->pokeballSpriteId, &menuBoxes[1]->pokeballSpriteId); + SwitchMenuBoxSprites(&menuBoxes[0]->itemSpriteId, &menuBoxes[1]->itemSpriteId); + SwitchMenuBoxSprites(&menuBoxes[0]->monSpriteId, &menuBoxes[1]->monSpriteId); + SwitchMenuBoxSprites(&menuBoxes[0]->statusSpriteId, &menuBoxes[1]->statusSpriteId); +} + +void sub_812358C(void) +{ + u16 *buffer = Alloc(2 * sizeof(u16)); + + buffer[0] = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES2); + buffer[1] = GetMonData(&gPlayerParty[gPartyMenu.slotId2], MON_DATA_SPECIES2); + sub_8113550(3, buffer); + Free(buffer); +} + +// Finish switching mons or using Softboiled +void FinishTwoMonAction(u8 taskId) +{ + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + gPartyMenu.action = PARTY_ACTION_CHOOSE_MON; + AnimatePartySlot(gPartyMenu.slotId, 0); + gPartyMenu.slotId = gPartyMenu.slotId2; + AnimatePartySlot(gPartyMenu.slotId2, 1); + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON); + gTasks[taskId].func = Task_HandleChooseMonInput; +} + +#undef tSlot1Left +#undef tSlot1Top +#undef tSlot1Width +#undef tSlot1Height +#undef tSlot2Left +#undef tSlot2Top +#undef tSlot2Width +#undef tSlot2Height +#undef tSlot1Offset +#undef tSlot2Offset +#undef tSlot1SlideDir +#undef tSlot2SlideDir + +void CursorCB_Cancel1(u8 taskId) +{ + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + if (gPartyMenu.menuType == PARTY_MENU_TYPE_DAYCARE) + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON_2); + else + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON); + gTasks[taskId].func = Task_HandleChooseMonInput; +} + +void CursorCB_Item(u8 taskId) +{ + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + SetPartyMonSelectionActions(gPlayerParty, gPartyMenu.slotId, ACTIONS_ITEM); + DisplaySelectionWindow(SELECTWINDOW_ITEM); + DisplayPartyMenuStdMessage(PARTY_MSG_DO_WHAT_WITH_ITEM); + gTasks[taskId].data[0] = 0xFF; + gTasks[taskId].func = Task_HandleSelectionMenuInput; +} + +void CursorCB_Give(u8 taskId) +{ + PlaySE(SE_SELECT); + sPartyMenuInternal->exitCallback = CB2_SelectBagItemToGive; + Task_ClosePartyMenu(taskId); +} + +void CB2_SelectBagItemToGive(void) +{ + GoToBagMenu(1, 3, CB2_GiveHoldItem); +} + +void CB2_GiveHoldItem(void) +{ + if (gSpecialVar_ItemId == ITEM_NONE) + { + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_NONE, Task_TryCreateSelectionWindow, gPartyMenu.exitCallback); + } + else + { + sPartyMenuItemId = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_HELD_ITEM); + // Already holding item + if (sPartyMenuItemId != ITEM_NONE) + { + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_NONE, Task_SwitchHoldItemsPrompt, gPartyMenu.exitCallback); + } + // Give mail + else if (ItemIsMail(gSpecialVar_ItemId)) + { + RemoveBagItem(gSpecialVar_ItemId, 1); + GiveItemToMon(&gPlayerParty[gPartyMenu.slotId], gSpecialVar_ItemId); + CB2_WriteMailToGiveMon(); + } + // Give item + else + { + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_NONE, Task_GiveHoldItem, gPartyMenu.exitCallback); + } + } +} + +void Task_GiveHoldItem(u8 taskId) +{ + u16 item; + + if (!gPaletteFade.active) + { + item = gSpecialVar_ItemId; + DisplayGaveHeldItemMessage(&gPlayerParty[gPartyMenu.slotId], item, FALSE, 0); + GiveItemToMon(&gPlayerParty[gPartyMenu.slotId], item); + RemoveBagItem(item, 1); + gTasks[taskId].func = Task_UpdateHeldItemSprite; } } diff --git a/src/pokemon_icon.c b/src/pokemon_icon.c index f3492593c..4c7681231 100644 --- a/src/pokemon_icon.c +++ b/src/pokemon_icon.c @@ -1276,7 +1276,7 @@ static void DestroyMonIconInternal(struct Sprite * sprite) DestroySprite(sprite); } -void MonIcon_SetAnim(struct Sprite * sprite, u8 animNum) +void SetPartyHPBarSprite(struct Sprite * sprite, u8 animNum) { sprite->animNum = animNum; sprite->animDelayCounter = 0; diff --git a/src/quest_log.c b/src/quest_log.c index 9683d7799..04369f1c2 100644 --- a/src/quest_log.c +++ b/src/quest_log.c @@ -1972,15 +1972,15 @@ void DestroyHelpMessageWindow(u8 a0) } #ifdef NONMATCHING -void sub_8112F18(u8 a0) +void sub_8112F18(u8 windowId) { - u8 width = GetWindowAttribute(a0, WINDOW_WIDTH); - u8 height = GetWindowAttribute(a0, WINDOW_HEIGHT); + u8 width = GetWindowAttribute(windowId, WINDOW_WIDTH); + u8 height = GetWindowAttribute(windowId, WINDOW_HEIGHT); u8 *buffer = Alloc(32 * width * height); u8 i, j; u8 k; - if (buffer) + if (buffer != NULL) { for (i = 0; i < height; i++) { @@ -1999,13 +1999,13 @@ void sub_8112F18(u8 a0) ); } } - CopyToWindowPixelBuffer(a0, buffer, width * height * 32, 0); + CopyToWindowPixelBuffer(windowId, buffer, width * height * 32, 0); Free(buffer); } } #else NAKED -void sub_8112F18(u8 a0) +void sub_8112F18(u8 windowId) { asm_unified("\tpush {r4-r7,lr}\n" "\tmov r7, r10\n" diff --git a/src/trade.c b/src/trade.c index 85bd7b2ca..537a5503b 100644 --- a/src/trade.c +++ b/src/trade.c @@ -2053,9 +2053,9 @@ void sub_804CF14(void) } if (sTradeMenuResourcesPtr->tradeMenuCursorPosition < 6) - sTradeMenuResourcesPtr->tradeMenuCursorPosition = sub_8138B20(); + sTradeMenuResourcesPtr->tradeMenuCursorPosition = GetLastViewedMonIndex(); else - sTradeMenuResourcesPtr->tradeMenuCursorPosition = sub_8138B20() + 6; + sTradeMenuResourcesPtr->tradeMenuCursorPosition = GetLastViewedMonIndex() + 6; sTradeMenuResourcesPtr->tradeMenuCursorSpriteIdx = CreateSprite(&sSpriteTemplate_TradeButtons, sTradeMonSpriteCoords[sTradeMenuResourcesPtr->tradeMenuCursorPosition][0] * 8 + 32, sTradeMonSpriteCoords[sTradeMenuResourcesPtr->tradeMenuCursorPosition][1] * 8, 2); gMain.state = 16; @@ -2633,14 +2633,14 @@ void sub_804CF14(void) "\tldrb r0, [r0]\n" "\tcmp r0, 0x5\n" "\tbhi _0804D3B8\n" - "\tbl sub_8138B20\n" + "\tbl GetLastViewedMonIndex\n" "\tldr r1, [r4]\n" "\tb _0804D3C0\n" "\t.align 2, 0\n" "_0804D3B0: .4byte sSpriteTemplate_Text\n" "_0804D3B4: .4byte sTradeMenuResourcesPtr\n" "_0804D3B8:\n" - "\tbl sub_8138B20\n" + "\tbl GetLastViewedMonIndex\n" "\tldr r1, [r4]\n" "\tadds r0, 0x6\n" "_0804D3C0:\n" @@ -4243,7 +4243,7 @@ static void sub_804F964(void) { for (j = 0; j < sTradeMenuResourcesPtr->partyCounts[i]; j++) { - MonIcon_SetAnim(&gSprites[sTradeMenuResourcesPtr->partyIcons[i][j]], 4 - sTradeMenuResourcesPtr->unk_5D[i][j]); + SetPartyHPBarSprite(&gSprites[sTradeMenuResourcesPtr->partyIcons[i][j]], 4 - sTradeMenuResourcesPtr->unk_5D[i][j]); } } } -- cgit v1.2.3 From 17743fe0e675be80b3df7bc3b480c684fe110fde Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Sat, 23 Nov 2019 08:09:06 +0800 Subject: party_menu third quarter --- src/option_menu.c | 2 +- src/party_menu.c | 1660 ++++++++++++++++++++++++++++++++++++++++++++++++++++- src/start_menu.c | 6 +- src/trade.c | 2 +- 4 files changed, 1641 insertions(+), 29 deletions(-) (limited to 'src') diff --git a/src/option_menu.c b/src/option_menu.c index 35fe957be..5453dfa9e 100644 --- a/src/option_menu.c +++ b/src/option_menu.c @@ -206,7 +206,7 @@ void CB2_OptionsMenuFromStartMenu(void) u8 i; if (gMain.savedCallback == NULL) - gMain.savedCallback = CB2_ReturnToStartMenu; + gMain.savedCallback = CB2_ReturnToFieldWithOpenMenu; sOptionMenuPtr = AllocZeroed(sizeof(struct OptionMenu)); sOptionMenuPtr->state3 = 0; sOptionMenuPtr->state2 = 0; diff --git a/src/party_menu.c b/src/party_menu.c index 08600229a..f88f2f6fc 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -5,6 +5,7 @@ #include "battle_controllers.h" #include "battle_gfx_sfx_util.h" #include "battle_interface.h" +#include "berry_pouch.h" #include "bg.h" #include "data.h" #include "decompress.h" @@ -42,6 +43,7 @@ #include "pokemon.h" #include "pokemon_icon.h" #include "pokemon_jump.h" +#include "pokemon_special_anim.h" #include "pokemon_storage_system.h" #include "pokemon_summary_screen.h" #include "quest_log.h" @@ -58,6 +60,7 @@ #include "teachy_tv.h" #include "text.h" #include "text_window.h" +#include "tm_case.h" #include "trade.h" #include "union_room.h" #include "window.h" @@ -69,6 +72,7 @@ #include "constants/items.h" #include "constants/maps.h" #include "constants/moves.h" +#include "constants/pokemon.h" #include "constants/songs.h" #include "constants/species.h" #include "constants/vars.h" @@ -250,24 +254,6 @@ void Task_HandleCancelParticipationYesNoInput(u8 taskId); void Task_TryCreateSelectionWindow(u8 taskId); u16 GetTutorMove(u8 tutor); bool8 CanLearnTutorMove(u16 species, u8 tutor); -void sub_8120C6C(u8 taskId); -void sub_8120CA8(u8 taskId); -void sub_8120CD8(u8 taskId); -void sub_8120D08(u8 taskId); -void sub_8120D40(u8 taskId); -void sub_8120D7C(u8 taskId); -void sub_8120DAC(u8 taskId); -void sub_8120DE0(u8 taskId); -void sub_8120E1C(u8 taskId); -void sub_8120E58(u8 taskId); -void sub_8120EE0(u8 taskId); -void sub_8120FF0(u8 taskId); -void sub_8120FB0(void); -bool8 sub_8120F78(u8 taskId); -u8 sub_81220D4(void); -void sub_8122084(u8 windowId, const u8 *str); -void sub_8122110(u8 windowId); -void sub_812358C(void); void CreateSelectionWindow(void); bool8 ShouldUseChooseMonText(void); void UpdatePartyMonHPBar(u8 spriteId, struct Pokemon *mon); @@ -294,6 +280,81 @@ void CB2_WriteMailToGiveMon(void); void Task_SwitchHoldItemsPrompt(u8 taskId); void Task_GiveHoldItem(u8 taskId); void Task_UpdateHeldItemSprite(u8 taskId); +void Task_HandleSwitchItemsYesNoInput(u8 taskId); +void Task_SwitchItemsYesNo(u8 taskId); +void Task_WriteMailToGiveMonAfterText(u8 taskId); +void CB2_ReturnToPartyMenuFromWritingMail(void); +void CB2_ReturnToPartyMenuFromWritingMail(void); +void Task_DisplayGaveMailFromPartyMessage(u8 taskId); +void CB2_ReadHeldMail(void); +void CB2_ReturnToPartyMenuFromReadingMail(void); +void Task_SendMailToPCYesNo(u8 taskId); +void Task_HandleSendMailToPCYesNoInput(u8 taskId); +void Task_LoseMailMessageYesNo(u8 taskId); +void Task_HandleLoseMailMessageYesNoInput(u8 taskId); +bool8 TrySwitchInPokemon(void); +void DisplayCantUseFlashMessage(void); +void DisplayCantUseSurfMessage(void); +void Task_CancelAfterAorBPress(u8 taskId); +void DisplayFieldMoveExitAreaMessage(u8 taskId); +void Task_FieldMoveExitAreaYesNo(u8 taskId); +void Task_HandleFieldMoveExitAreaYesNoInput(u8 taskId); +void Task_FieldMoveWaitForFade(u8 taskId); +u16 GetFieldMoveMonSpecies(void); +u8 GetPartyLayoutFromBattleType(void); +void Task_SetSacredAshCB(u8 taskId); +void CB2_ReturnToBagMenu(void); +u8 GetPartyIdFromBattleSlot(u8 slot); +void Task_DisplayHPRestoredMessage(u8 taskId); +void SetSelectedMoveForPPItem(u8 taskId); +void ReturnToUseOnWhichMon(u8 taskId); +void TryUsePPItem(u8 taskId); +void ItemUseCB_LearnedMove(u8 taskId, UNUSED TaskFunc func); +void Task_LearnedMove(u8 taskId); +void Task_ReplaceMoveYesNo(u8 taskId); +void Task_DoLearnedMoveFanfareAfterText(u8 taskId); +void Task_TryLearningNextMove(u8 taskId); +void Task_LearnNextMoveOrClosePartyMenu(u8 taskId); +void Task_HandleReplaceMoveYesNoInput(u8 taskId); +void StopLearningMovePrompt(u8 taskId); +void Task_ShowSummaryScreenToForgetMove(u8 taskId); +void CB2_ShowSummaryScreenToForgetMove(void); +void CB2_ReturnToPartyMenuWhileLearningMove(void); +void Task_ReturnToPartyMenuWhileLearningMove(u8 taskId); +void DisplayPartyMenuForgotMoveMessage(u8 taskId); +void Task_PartyMenuReplaceMove(u8 taskId); +void Task_StopLearningMoveYesNo(u8 taskId); +void Task_HandleStopLearningMoveYesNoInput(u8 taskId); +void Task_TryLearningNextMoveAfterText(u8 taskId); +void sub_8120C6C(u8 taskId); +void sub_8120CA8(u8 taskId); +void sub_8120CD8(u8 taskId); +void sub_8120D08(u8 taskId); +void sub_8120D40(u8 taskId); +void sub_8120D7C(u8 taskId); +void sub_8120DAC(u8 taskId); +void sub_8120DE0(u8 taskId); +void sub_8120E1C(u8 taskId); +void sub_8120E58(u8 taskId); +void sub_8120EE0(u8 taskId); +void sub_8120FF0(u8 taskId); +bool8 sub_8120F78(u8 taskId); +void sub_8120FB0(void); +void sub_8122084(u8 windowId, const u8 *str); +u8 sub_81220D4(void); +void sub_8122110(u8 windowId); +void sub_812358C(void); +void sub_8124BB0(struct Pokemon *mon, u8 fieldMove); +void sub_8124DB0(void); +void sub_8124DA0(void); +void sub_8124DE0(void); +void sub_8124E48(void); +void sub_812580C(u8 taskId); +void sub_8125898(u8 taskId, UNUSED TaskFunc func); +void sub_8125F4C(u8 taskId, UNUSED TaskFunc func); +void sub_8125F5C(u8 taskId); +void sub_8126BD4(void); +bool8 sub_8126C24(void); EWRAM_DATA struct PartyMenuInternal *sPartyMenuInternal = NULL; EWRAM_DATA struct PartyMenu gPartyMenu = {0}; @@ -712,7 +773,7 @@ void DisplayPartyPokemonDataForChooseHalf(u8 slot) u8 i; struct Pokemon *mon = &gPlayerParty[slot]; u8 *order = gSelectedOrderFromParty; - u8 r3; + u8 maxBattlers; if (!GetBattleEntryEligibility(mon)) { @@ -721,10 +782,10 @@ void DisplayPartyPokemonDataForChooseHalf(u8 slot) else { if (gPartyMenu.unk_8_6 == 2) - r3 = 2; + maxBattlers = 2; else - r3 = 3; - for (i = 0; i < r3; ++i) + maxBattlers = 3; + for (i = 0; i < maxBattlers; ++i) { if (order[i] != 0 && (order[i] - 1) == slot) { @@ -2570,7 +2631,7 @@ void sub_8122138(u8 action) ptr->windowId[2] = AddWindow(&gUnknown_845A178); sub_8112F18(ptr->windowId[2]); attr = GetFontAttribute(2, FONTATTR_LETTER_SPACING); - AddTextPrinterParameterized4(ptr->windowId[2], 2, 3, 6, attr, 0, sFontColorTable[5], 0, sHMDescriptionTable[action - 18]); + AddTextPrinterParameterized4(ptr->windowId[2], 2, 3, 6, attr, 0, sFontColorTable[5], 0, sHMDescriptionTable[action - MENU_FIELD_MOVES]); PutWindowTilemap(ptr->windowId[2]); ScheduleBgCopyTilemapToVram(2); } @@ -3224,7 +3285,7 @@ void Task_SlideSelectedSlotsOnscreen(u8 taskId) PutWindowTilemap(sPartyMenuBoxes[gPartyMenu.slotId].windowId); PutWindowTilemap(sPartyMenuBoxes[gPartyMenu.slotId2].windowId); ScheduleBgCopyTilemapToVram(0); - // memory leak + // BUG: memory leak // Free(sSlot1TilemapBuffer); // Free(sSlot2TilemapBuffer); FinishTwoMonAction(taskId); @@ -3396,3 +3457,1554 @@ void Task_GiveHoldItem(u8 taskId) gTasks[taskId].func = Task_UpdateHeldItemSprite; } } + +void Task_SwitchHoldItemsPrompt(u8 taskId) +{ + if (!gPaletteFade.active) + { + DisplayAlreadyHoldingItemSwitchMessage(&gPlayerParty[gPartyMenu.slotId], sPartyMenuItemId, TRUE); + gTasks[taskId].func = Task_SwitchItemsYesNo; + } +} + +void Task_SwitchItemsYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleSwitchItemsYesNoInput; + } +} + +void Task_HandleSwitchItemsYesNoInput(u8 taskId) +{ + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: // Yes, switch items + RemoveBagItem(gSpecialVar_ItemId, 1); + + // No room to return held item to bag + if (AddBagItem(sPartyMenuItemId, 1) == FALSE) + { + AddBagItem(gSpecialVar_ItemId, 1); + BufferBagFullCantTakeItemMessage(sPartyMenuItemId); + DisplayPartyMenuMessage(gStringVar4, FALSE); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + } + // Giving mail + else if (ItemIsMail(gSpecialVar_ItemId)) + { + GiveItemToMon(&gPlayerParty[gPartyMenu.slotId], gSpecialVar_ItemId); + gTasks[taskId].func = Task_WriteMailToGiveMonAfterText; + } + // Giving item + else + { + GiveItemToMon(&gPlayerParty[gPartyMenu.slotId], gSpecialVar_ItemId); + DisplaySwitchedHeldItemMessage(gSpecialVar_ItemId, sPartyMenuItemId, TRUE); + gTasks[taskId].func = Task_UpdateHeldItemSprite; + } + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: // No + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + break; + } +} + +void Task_WriteMailToGiveMonAfterText(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + sPartyMenuInternal->exitCallback = CB2_WriteMailToGiveMon; + Task_ClosePartyMenu(taskId); + } +} + +void CB2_WriteMailToGiveMon(void) +{ + u8 mail = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_MAIL); + + DoEasyChatScreen(EASY_CHAT_TYPE_MAIL, + gSaveBlock1Ptr->mail[mail].words, + CB2_ReturnToPartyMenuFromWritingMail); +} + +void CB2_ReturnToPartyMenuFromWritingMail(void) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 item = GetMonData(mon, MON_DATA_HELD_ITEM); + + // Canceled writing mail + if (gSpecialVar_Result == FALSE) + { + TakeMailFromMon(mon); + SetMonData(mon, MON_DATA_HELD_ITEM, &sPartyMenuItemId); + RemoveBagItem(sPartyMenuItemId, 1); + AddBagItem(item, 1); + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_CHOOSE_MON, Task_TryCreateSelectionWindow, gPartyMenu.exitCallback); + } + // Wrote mail + else + { + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_CHOOSE_MON, Task_DisplayGaveMailFromPartyMessage, gPartyMenu.exitCallback); + } +} + +// Nearly redundant with Task_DisplayGaveMailFromBagMessgae +void Task_DisplayGaveMailFromPartyMessage(u8 taskId) +{ + if (!gPaletteFade.active) + { + if (sPartyMenuItemId == ITEM_NONE) + DisplayGaveHeldItemMessage(&gPlayerParty[gPartyMenu.slotId], gSpecialVar_ItemId, FALSE, 0); + else + DisplaySwitchedHeldItemMessage(gSpecialVar_ItemId, sPartyMenuItemId, FALSE); + gTasks[taskId].func = Task_UpdateHeldItemSprite; + } +} + +void Task_UpdateHeldItemSprite(u8 taskId) +{ + s8 slotId = gPartyMenu.slotId; + + if (IsPartyMenuTextPrinterActive() != TRUE) + { + UpdatePartyMonHeldItemSprite(&gPlayerParty[slotId], &sPartyMenuBoxes[slotId]); + Task_ReturnToChooseMonAfterText(taskId); + } +} + +void CursorCB_TakeItem(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 item = GetMonData(mon, MON_DATA_HELD_ITEM); + + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + switch (TryTakeMonItem(mon)) + { + case 0: // Not holding item + GetMonNickname(mon, gStringVar1); + StringExpandPlaceholders(gStringVar4, gText_PkmnNotHolding); + DisplayPartyMenuMessage(gStringVar4, TRUE); + break; + case 1: // No room to take item + BufferBagFullCantTakeItemMessage(item); + DisplayPartyMenuMessage(gStringVar4, TRUE); + break; + default: // Took item + DisplayTookHeldItemMessage(mon, item, TRUE); + break; + } + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_UpdateHeldItemSprite; +} + +void CursorCB_Mail(u8 taskId) +{ + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + SetPartyMonSelectionActions(gPlayerParty, gPartyMenu.slotId, ACTIONS_MAIL); + DisplaySelectionWindow(SELECTWINDOW_MAIL); + DisplayPartyMenuStdMessage(PARTY_MSG_DO_WHAT_WITH_MAIL); + gTasks[taskId].data[0] = 0xFF; + gTasks[taskId].func = Task_HandleSelectionMenuInput; +} + +void CursorCB_Read(u8 taskId) +{ + PlaySE(SE_SELECT); + sPartyMenuInternal->exitCallback = CB2_ReadHeldMail; + Task_ClosePartyMenu(taskId); +} + +void CB2_ReadHeldMail(void) +{ + ReadMail(&gSaveBlock1Ptr->mail[GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_MAIL)], CB2_ReturnToPartyMenuFromReadingMail, 1); +} + +void CB2_ReturnToPartyMenuFromReadingMail(void) +{ + gPaletteFade.bufferTransferDisabled = TRUE; + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_DO_WHAT_WITH_MON, Task_TryCreateSelectionWindow, gPartyMenu.exitCallback); +} + +void CursorCB_TakeMail(u8 taskId) +{ + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + DisplayPartyMenuMessage(gText_SendMailToPC, TRUE); + gTasks[taskId].func = Task_SendMailToPCYesNo; +} + +void Task_SendMailToPCYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleSendMailToPCYesNoInput; + } +} + +void Task_HandleSendMailToPCYesNoInput(u8 taskId) +{ + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: // Yes, send to PC + if (TakeMailFromMon2(&gPlayerParty[gPartyMenu.slotId]) != 0xFF) + { + DisplayPartyMenuMessage(gText_MailSentToPC, FALSE); + gTasks[taskId].func = Task_UpdateHeldItemSprite; + } + else + { + DisplayPartyMenuMessage(gText_PCMailboxFull, FALSE); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + } + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: + DisplayPartyMenuMessage(gText_MailMessageWillBeLost, TRUE); + gTasks[taskId].func = Task_LoseMailMessageYesNo; + break; + } +} + +void Task_LoseMailMessageYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleLoseMailMessageYesNoInput; + } +} + +void Task_HandleLoseMailMessageYesNoInput(u8 taskId) +{ + u16 item; + + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: // Yes, lose mail message + item = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_HELD_ITEM); + if (AddBagItem(item, 1) == TRUE) + { + TakeMailFromMon(&gPlayerParty[gPartyMenu.slotId]); + DisplayPartyMenuMessage(gText_MailTakenFromPkmn, FALSE); + gTasks[taskId].func = Task_UpdateHeldItemSprite; + } + else + { + BufferBagFullCantTakeItemMessage(item); + DisplayPartyMenuMessage(gStringVar4, FALSE); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + } + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + break; + } +} + +void CursorCB_Cancel2(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + SetPartyMonSelectionActions(gPlayerParty, gPartyMenu.slotId, GetPartyMenuActionsType(mon)); + DisplaySelectionWindow(SELECTWINDOW_ACTIONS); + DisplayPartyMenuStdMessage(PARTY_MSG_DO_WHAT_WITH_MON); + gTasks[taskId].data[0] = 0xFF; + gTasks[taskId].func = Task_HandleSelectionMenuInput; +} + +void CursorCB_SendMon(u8 taskId) +{ + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + if (TrySwitchInPokemon() == TRUE) + { + Task_ClosePartyMenu(taskId); + } + else + { + // gStringVar4 below is the error message buffered by TrySwitchInPokemon + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + DisplayPartyMenuMessage(gStringVar4, TRUE); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + } +} + +void CursorCB_Enter(u8 taskId) +{ + u8 maxBattlers; + u8 i; + const u8 *str; + + if (gPartyMenu.unk_8_6 == 2) + { + maxBattlers = 2; + str = gUnknown_8416B3E; + } + else + { + maxBattlers = 3; + str = gUnknown_8416B16; + } + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + for (i = 0; i < maxBattlers; ++i) + { + if (gSelectedOrderFromParty[i] == 0) + { + PlaySE(SE_SELECT); + gSelectedOrderFromParty[i] = gPartyMenu.slotId + 1; + DisplayPartyPokemonDescriptionText(i + PARTYBOX_DESC_FIRST, &sPartyMenuBoxes[gPartyMenu.slotId], 1); + if (i == (maxBattlers - 1)) + MoveCursorToConfirm(); + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON); + gTasks[taskId].func = Task_HandleChooseMonInput; + return; + } + } + PlaySE(SE_HAZURE); + DisplayPartyMenuMessage(str, TRUE); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; +} + +void MoveCursorToConfirm(void) +{ + AnimatePartySlot(gPartyMenu.slotId, 0); + gPartyMenu.slotId = PARTY_SIZE; + AnimatePartySlot(gPartyMenu.slotId, 1); +} + +void CursorCB_NoEntry(u8 taskId) +{ + u8 i; + + PlaySE(SE_SELECT); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + for (i = 0; i < 3; ++i) + { + if (gSelectedOrderFromParty[i] == gPartyMenu.slotId + 1) + { + gSelectedOrderFromParty[i] = 0; + switch (i) + { + case 0: + gSelectedOrderFromParty[0] = gSelectedOrderFromParty[1]; + gSelectedOrderFromParty[1] = gSelectedOrderFromParty[2]; + gSelectedOrderFromParty[2] = 0; + break; + case 1: + gSelectedOrderFromParty[1] = gSelectedOrderFromParty[2]; + gSelectedOrderFromParty[2] = 0; + break; + } + break; + } + } + DisplayPartyPokemonDescriptionText(PARTYBOX_DESC_ABLE_3, &sPartyMenuBoxes[gPartyMenu.slotId], 1); + if (gSelectedOrderFromParty[0] != 0) + DisplayPartyPokemonDescriptionText(PARTYBOX_DESC_FIRST, &sPartyMenuBoxes[gSelectedOrderFromParty[0] - 1], 1); + if (gSelectedOrderFromParty[1] != 0) + DisplayPartyPokemonDescriptionText(1 + PARTYBOX_DESC_FIRST, &sPartyMenuBoxes[gSelectedOrderFromParty[1] - 1], 1); + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON); + gTasks[taskId].func = Task_HandleChooseMonInput; +} + +void CursorCB_Store(u8 taskId) +{ + PlaySE(SE_SELECT); + gSpecialVar_0x8004 = gPartyMenu.slotId; + Task_ClosePartyMenu(taskId); +} + +// Register mon for the Trading Board in Union Room +void CursorCB_Register(u8 taskId) +{ + u16 species2 = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES2); + u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); + u8 obedience = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_OBEDIENCE); + + switch (CanRegisterMonForTradingBoard(*(struct UnkLinkRfuStruct_02022B14Substruct *)sub_80F9800(), species2, species, obedience)) + { + case CANT_REGISTER_MON: + StringExpandPlaceholders(gStringVar4, gText_PkmnCantBeTradedNow); + break; + case CANT_REGISTER_EGG: + StringExpandPlaceholders(gStringVar4, gText_EggCantBeTradedNow); + break; + default: + PlaySE(SE_SELECT); + Task_ClosePartyMenu(taskId); + return; + } + PlaySE(SE_HAZURE); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + StringAppend(gStringVar4, gText_PauseUntilPress); + DisplayPartyMenuMessage(gStringVar4, TRUE); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; +} + +void CursorCB_Trade1(u8 taskId) +{ + u16 species2 = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES2); + u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); + u8 obedience = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_OBEDIENCE); + u32 stringId = GetUnionRoomTradeMessageId(*(struct UnkLinkRfuStruct_02022B14Substruct *)sub_80F9800(), gUnknown_203B064, species2, gUnionRoomOfferedSpecies, gUnionRoomRequestedMonType, species, obedience); + + if (stringId != UR_TRADE_MSG_NONE) + { + StringExpandPlaceholders(gStringVar4, sUnionRoomTradeMessages[stringId - 1]); + PlaySE(SE_HAZURE); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + StringAppend(gStringVar4, gText_PauseUntilPress); + DisplayPartyMenuMessage(gStringVar4, TRUE); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + } + else + { + PlaySE(SE_SELECT); + Task_ClosePartyMenu(taskId); + } +} + +// Spin Trade (based on the translation of the Japanese trade prompt) +// Not implemented, and normally unreachable because PARTY_MENU_TYPE_SPIN_TRADE is never used +void CursorCB_Trade2(u8 taskId) +{ +} + +void CursorCB_FieldMove(u8 taskId) +{ + u8 fieldMove = sPartyMenuInternal->actions[Menu_GetCursorPos()] - MENU_FIELD_MOVES; + const struct MapHeader *mapHeader; + + PlaySE(SE_SELECT); + if (sFieldMoveCursorCallbacks[fieldMove].fieldMoveFunc == NULL) + return; + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); + if (MenuHelpers_LinkSomething() == TRUE || InUnionRoom() == TRUE) + { + if (fieldMove == FIELD_MOVE_MILK_DRINK || fieldMove == FIELD_MOVE_SOFT_BOILED) + DisplayPartyMenuStdMessage(PARTY_MSG_CANT_USE_HERE); + else + DisplayPartyMenuStdMessage(sFieldMoveCursorCallbacks[fieldMove].msgId); + gTasks[taskId].func = Task_CancelAfterAorBPress; + } + else + { + // All field moves before WATERFALL are HMs. + if (fieldMove <= FIELD_MOVE_WATERFALL && FlagGet(FLAG_BADGE01_GET + fieldMove) != TRUE) + { + DisplayPartyMenuMessage(gText_CantUseUntilNewBadge, TRUE); + gTasks[taskId].func = Task_ReturnToChooseMonAfterText; + } + else if (sFieldMoveCursorCallbacks[fieldMove].fieldMoveFunc() == TRUE) + { + switch (fieldMove) + { + case FIELD_MOVE_MILK_DRINK: + case FIELD_MOVE_SOFT_BOILED: + ChooseMonForSoftboiled(taskId); + break; + case FIELD_MOVE_TELEPORT: + mapHeader = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->lastHealLocation.mapGroup, gSaveBlock1Ptr->lastHealLocation.mapNum); + GetMapNameGeneric(gStringVar1, mapHeader->regionMapSectionId); + StringExpandPlaceholders(gStringVar4, gText_ReturnToHealingSpot); + DisplayFieldMoveExitAreaMessage(taskId); + sPartyMenuInternal->data[0] = fieldMove; + break; + case FIELD_MOVE_DIG: + mapHeader = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->escapeWarp.mapGroup, gSaveBlock1Ptr->escapeWarp.mapNum); + GetMapNameGeneric(gStringVar1, mapHeader->regionMapSectionId); + StringExpandPlaceholders(gStringVar4, gText_EscapeFromHereAndReturnTo); + DisplayFieldMoveExitAreaMessage(taskId); + sPartyMenuInternal->data[0] = fieldMove; + break; + case FIELD_MOVE_FLY: + gPartyMenu.exitCallback = MCB2_FlyMap; + Task_ClosePartyMenu(taskId); + break; + default: + gPartyMenu.exitCallback = CB2_ReturnToField; + sub_8124BB0(&gPlayerParty[GetCursorSelectionMonId()], fieldMove); + Task_ClosePartyMenu(taskId); + break; + } + } + // Cant use Field Move + else + { + switch (fieldMove) + { + case FIELD_MOVE_SURF: + DisplayCantUseSurfMessage(); + break; + case FIELD_MOVE_FLASH: + DisplayCantUseFlashMessage(); + break; + default: + DisplayPartyMenuStdMessage(sFieldMoveCursorCallbacks[fieldMove].msgId); + break; + } + gTasks[taskId].func = Task_CancelAfterAorBPress; + } + } +} + +void DisplayFieldMoveExitAreaMessage(u8 taskId) +{ + DisplayPartyMenuMessage(gStringVar4, TRUE); + gTasks[taskId].func = Task_FieldMoveExitAreaYesNo; +} + +void Task_FieldMoveExitAreaYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleFieldMoveExitAreaYesNoInput; + } +} + +void Task_HandleFieldMoveExitAreaYesNoInput(u8 taskId) +{ + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: + gPartyMenu.exitCallback = CB2_ReturnToField; + sub_8124BB0(&gPlayerParty[GetCursorSelectionMonId()], sPartyMenuInternal->data[0]); + Task_ClosePartyMenu(taskId); + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: + gFieldCallback2 = NULL; + gPostMenuFieldCallback = NULL; + Task_ReturnToChooseMonAfterText(taskId); + break; + } +} + +bool8 FieldCallback_PrepareFadeInFromMenu(void) +{ + sub_807DC00(); + CreateTask(Task_FieldMoveWaitForFade, 8); + return TRUE; +} + +void Task_FieldMoveWaitForFade(u8 taskId) +{ + if (IsWeatherNotFadingIn() == TRUE) + { + gFieldEffectArguments[0] = GetFieldMoveMonSpecies(); + gPostMenuFieldCallback(); + DestroyTask(taskId); + } +} + +u16 GetFieldMoveMonSpecies(void) +{ + return GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); +} + +void Task_CancelAfterAorBPress(u8 taskId) +{ + if ((gMain.newKeys & A_BUTTON) || (gMain.newKeys & B_BUTTON)) + CursorCB_Cancel1(taskId); +} + +void DisplayCantUseFlashMessage(void) +{ + if (FlagGet(FLAG_SYS_FLASH_ACTIVE) == TRUE) + DisplayPartyMenuStdMessage(PARTY_MSG_ALREADY_IN_USE); + else + DisplayPartyMenuStdMessage(PARTY_MSG_CANT_USE_HERE); +} + +void FieldCallback_Surf(void) +{ + gFieldEffectArguments[0] = GetCursorSelectionMonId(); + FieldEffectStart(FLDEFF_USE_SURF); +} + +bool8 SetUpFieldMove_Surf(void) +{ + s16 x, y; + + GetXYCoordsOneStepInFrontOfPlayer(&x, &y); + if (MetatileBehavior_IsSemiDeepWater(MapGridGetMetatileBehaviorAt(x, y)) != TRUE + && PartyHasMonWithSurf() == TRUE + && IsPlayerFacingSurfableFishableWater() == TRUE) + { + gFieldCallback2 = FieldCallback_PrepareFadeInFromMenu; + gPostMenuFieldCallback = FieldCallback_Surf; + return TRUE; + } + return FALSE; +} + +void DisplayCantUseSurfMessage(void) +{ + s16 x, y; + + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING)) + { + DisplayPartyMenuStdMessage(PARTY_MSG_ALREADY_SURFING); + } + else + { + GetXYCoordsOneStepInFrontOfPlayer(&x, &y); + if (MetatileBehavior_IsSemiDeepWater(MapGridGetMetatileBehaviorAt(x, y)) == TRUE) + DisplayPartyMenuStdMessage(PARTY_MSG_CURRENT_TOO_FAST); + else if ((gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(ROUTE17)) + && ((gSaveBlock1Ptr->location.mapNum == MAP_NUM(ROUTE17)) + || (gSaveBlock1Ptr->location.mapNum == MAP_NUM(ROUTE18)))) + DisplayPartyMenuStdMessage(PARTY_MSG_ENJOY_CYCLING); + else + DisplayPartyMenuStdMessage(PARTY_MSG_CANT_SURF_HERE); + } +} + +bool8 SetUpFieldMove_Fly(void) +{ + if (Overworld_MapTypeAllowsTeleportAndFly(gMapHeader.mapType) == TRUE) + return TRUE; + else + return FALSE; +} + +void CB2_ReturnToPartyMenuFromFlyMap(void) +{ + InitPartyMenu(PARTY_MENU_TYPE_FIELD, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_MON, TRUE, PARTY_MSG_CHOOSE_MON, Task_HandleChooseMonInput, CB2_ReturnToFieldWithOpenMenu); +} + +void FieldCallback_Waterfall(void) +{ + gFieldEffectArguments[0] = GetCursorSelectionMonId(); + FieldEffectStart(FLDEFF_USE_WATERFALL); +} + +bool8 SetUpFieldMove_Waterfall(void) +{ + s16 x, y; + + GetXYCoordsOneStepInFrontOfPlayer(&x, &y); + if (MetatileBehavior_IsWaterfall(MapGridGetMetatileBehaviorAt(x, y)) == TRUE && IsPlayerSurfingNorth() == TRUE) + { + gFieldCallback2 = FieldCallback_PrepareFadeInFromMenu; + gPostMenuFieldCallback = FieldCallback_Waterfall; + return TRUE; + } + return FALSE; +} + +void sub_8124B60(struct Pokemon *mon, u16 item, u16 item2) +{ + u16 *ptr = Alloc(4 * sizeof(u16)); + + ptr[2] = GetMonData(mon, MON_DATA_SPECIES2); + ptr[0] = item; + ptr[1] = item2; + if (gPartyMenu.action == PARTY_ACTION_GIVE_PC_ITEM) + sub_8113550(10, ptr); + else + sub_8113550(9, ptr); + Free(ptr); +} + +struct FieldMoveWarpParams +{ + u16 species; + u8 fieldMove; + u8 regionMapSectionId; +}; + +void sub_8124BB0(struct Pokemon *mon, u8 fieldMove) +{ + struct FieldMoveWarpParams *ptr = Alloc(sizeof(*ptr)); + + ptr->species = GetMonData(mon, MON_DATA_SPECIES2); + ptr->fieldMove = fieldMove; + switch (ptr->fieldMove) + { + case FIELD_MOVE_TELEPORT: + ptr->regionMapSectionId = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->lastHealLocation.mapGroup, gSaveBlock1Ptr->lastHealLocation.mapNum)->regionMapSectionId; + break; + case FIELD_MOVE_DIG: + ptr->regionMapSectionId = gMapHeader.regionMapSectionId; + break; + default: + ptr->regionMapSectionId = 0xFF; + } + sub_8113550(36, (u16 *)ptr); + Free(ptr); +} + +void sub_8124C1C(const u8 *healLocCtrlData) // TODO: confirm the type of data chunk at 0x83F2EE0 +{ + const struct MapHeader *mapHeader; + struct FieldMoveWarpParams *ptr2; + struct + { + s8 mapGroup; + s8 mapNum; + u32 unk_4; + } *ptr = Alloc(sizeof(*ptr)); + + ptr->mapGroup = healLocCtrlData[0]; + ptr->mapNum = healLocCtrlData[1]; + mapHeader = Overworld_GetMapHeaderByGroupAndId(ptr->mapGroup, ptr->mapNum); + Free(ptr); + ptr2 = Alloc(4); + ptr2->species = GetMonData(&gPlayerParty[GetCursorSelectionMonId()], MON_DATA_SPECIES2); + ptr2->fieldMove = FIELD_MOVE_FLY; + ptr2->regionMapSectionId = mapHeader->regionMapSectionId; + sub_8113550(36, (u16 *)ptr2); + Free(ptr2); +} + +void CB2_ShowPartyMenuForItemUse(void) +{ + MainCallback callback = CB2_ReturnToBagMenu; + u8 partyLayout; + u8 menuType; + u8 i; + u8 msgId; + TaskFunc task; + + if (gMain.inBattle) + { + menuType = PARTY_MENU_TYPE_IN_BATTLE; + partyLayout = GetPartyLayoutFromBattleType(); + } + else + { + menuType = PARTY_MENU_TYPE_FIELD; + partyLayout = PARTY_LAYOUT_SINGLE; + } + + if (GetItemEffectType(gSpecialVar_ItemId) == ITEM_EFFECT_SACRED_ASH) + { + gPartyMenu.slotId = 0; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE && GetMonData(&gPlayerParty[i], MON_DATA_HP) == 0) + { + gPartyMenu.slotId = i; + break; + } + } + if (GetPocketByItemId(gSpecialVar_ItemId) == POCKET_BERRY_POUCH) + callback = sub_8124DB0; + task = Task_SetSacredAshCB; + msgId = PARTY_MSG_NONE; + } + else + { + switch (GetPocketByItemId(gSpecialVar_ItemId)) + { + default: + msgId = PARTY_MSG_USE_ON_WHICH_MON; + break; + case POCKET_TM_CASE: + msgId = PARTY_MSG_TEACH_WHICH_MON; + callback = sub_8124DA0; + break; + case POCKET_BERRY_POUCH: + msgId = PARTY_MSG_USE_ON_WHICH_MON; + callback = sub_8124DB0; + break; + } + task = Task_HandleChooseMonInput; + } + InitPartyMenu(menuType, partyLayout, PARTY_ACTION_USE_ITEM, TRUE, msgId, task, callback); +} + +void CB2_ReturnToBagMenu(void) +{ + GoToBagMenu(11, 3, NULL); +} + +void sub_8124DA0(void) +{ + InitTMCase(5, NULL, 0xFF); +} + +void sub_8124DB0(void) +{ + InitBerryPouch(BERRYPOUCH_NA, NULL, 0xFF); +} + +void sub_8124DC0(u8 taskId) +{ + sPartyMenuInternal->exitCallback = sub_8124DE0; + Task_ClosePartyMenu(taskId); +} + +void sub_8124DE0(void) +{ + if (CheckIfItemIsTMHMOrEvolutionStone(gSpecialVar_ItemId) == 2) // Evolution stone + { + if (sub_8126C24() == TRUE) + sub_811C540(gPartyMenu.slotId, gSpecialVar_ItemId, sub_8126BD4); + else + sub_811C5AC(gPartyMenu.slotId, gSpecialVar_ItemId, gPartyMenu.exitCallback); + } + else + { + sub_811C540(gPartyMenu.slotId, gSpecialVar_ItemId, sub_8124E48); + } +} + +void sub_8124E48(void) +{ + if (ItemId_GetPocket(gSpecialVar_ItemId) == POCKET_TM_CASE + && sub_811D178() == 1) + { + GiveMoveToMon(&gPlayerParty[gPartyMenu.slotId], ItemIdToBattleMoveId(gSpecialVar_ItemId)); + AdjustFriendship(&gPlayerParty[gPartyMenu.slotId], 4); + if (gSpecialVar_ItemId <= ITEM_TM50) + RemoveBagItem(gSpecialVar_ItemId, 1); + SetMainCallback2(gPartyMenu.exitCallback); + } + else + { + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, PARTY_ACTION_CHOOSE_MON, gPartyMenu.slotId, PARTY_MSG_NONE, Task_SetSacredAshCB, gPartyMenu.exitCallback); + } +} + +void sub_8124EFC(void) +{ + if (sub_811D178() == 1) + { + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u8 moveIdx = GetMoveSlotToReplace(); + u16 move = GetMonData(mon, moveIdx + MON_DATA_MOVE1); + + RemoveMonPPBonus(mon, moveIdx); + SetMonMoveSlot(mon, ItemIdToBattleMoveId(gSpecialVar_ItemId), moveIdx); + AdjustFriendship(mon, 4); + ItemUse_SetQuestLogEvent(4, mon, gSpecialVar_ItemId, move); + if (gSpecialVar_ItemId <= ITEM_TM50) + RemoveBagItem(gSpecialVar_ItemId, 1); + SetMainCallback2(gPartyMenu.exitCallback); + } + else + { + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, gPartyMenu.slotId, PARTY_MSG_NONE, Task_SetSacredAshCB, gPartyMenu.exitCallback); + } +} + +void Task_SetSacredAshCB(u8 taskId) +{ + if (!gPaletteFade.active) + { + if (gPartyMenu.menuType == PARTY_MENU_TYPE_IN_BATTLE) + sPartyMenuInternal->exitCallback = CB2_SetUpExitToBattleScreen; + gItemUseCB(taskId, Task_ClosePartyMenuAfterText); // ItemUseCB_SacredAsh in this case + } +} + +bool8 IsHPRecoveryItem(u16 item) +{ + const u8 *effect; + + if (item == ITEM_ENIGMA_BERRY) + effect = gSaveBlock1Ptr->enigmaBerry.itemEffect; + else + effect = gItemEffectTable[item - ITEM_POTION]; + if (effect[4] & ITEM4_HEAL_HP) + return TRUE; + else + return FALSE; +} + +void GetMedicineItemEffectMessage(u16 item) +{ + switch (GetItemEffectType(item)) + { + case ITEM_EFFECT_CURE_POISON: + StringExpandPlaceholders(gStringVar4, gText_PkmnCuredOfPoison); + break; + case ITEM_EFFECT_CURE_SLEEP: + StringExpandPlaceholders(gStringVar4, gText_PkmnWokeUp2); + break; + case ITEM_EFFECT_CURE_BURN: + StringExpandPlaceholders(gStringVar4, gText_PkmnBurnHealed); + break; + case ITEM_EFFECT_CURE_FREEZE: + StringExpandPlaceholders(gStringVar4, gText_PkmnThawedOut); + break; + case ITEM_EFFECT_CURE_PARALYSIS: + StringExpandPlaceholders(gStringVar4, gText_PkmnCuredOfParalysis); + break; + case ITEM_EFFECT_CURE_CONFUSION: + StringExpandPlaceholders(gStringVar4, gText_PkmnSnappedOutOfConfusion); + break; + case ITEM_EFFECT_CURE_INFATUATION: + StringExpandPlaceholders(gStringVar4, gText_PkmnGotOverInfatuation); + break; + case ITEM_EFFECT_CURE_ALL_STATUS: + StringExpandPlaceholders(gStringVar4, gText_PkmnBecameHealthy); + break; + case ITEM_EFFECT_HP_EV: + StringCopy(gStringVar2, gText_HP3); + StringExpandPlaceholders(gStringVar4, gText_PkmnBaseVar2StatIncreased); + break; + case ITEM_EFFECT_ATK_EV: + StringCopy(gStringVar2, gText_Attack3); + StringExpandPlaceholders(gStringVar4, gText_PkmnBaseVar2StatIncreased); + break; + case ITEM_EFFECT_DEF_EV: + StringCopy(gStringVar2, gText_Defense3); + StringExpandPlaceholders(gStringVar4, gText_PkmnBaseVar2StatIncreased); + break; + case ITEM_EFFECT_SPEED_EV: + StringCopy(gStringVar2, gText_Speed2); + StringExpandPlaceholders(gStringVar4, gText_PkmnBaseVar2StatIncreased); + break; + case ITEM_EFFECT_SPATK_EV: + StringCopy(gStringVar2, gText_SpAtk3); + StringExpandPlaceholders(gStringVar4, gText_PkmnBaseVar2StatIncreased); + break; + case ITEM_EFFECT_SPDEF_EV: + StringCopy(gStringVar2, gText_SpDef3); + StringExpandPlaceholders(gStringVar4, gText_PkmnBaseVar2StatIncreased); + break; + case ITEM_EFFECT_PP_UP: + case ITEM_EFFECT_PP_MAX: + StringExpandPlaceholders(gStringVar4, gText_MovesPPIncreased); + break; + case ITEM_EFFECT_HEAL_PP: + StringExpandPlaceholders(gStringVar4, gText_PPWasRestored); + break; + default: + StringExpandPlaceholders(gStringVar4, gText_WontHaveEffect); + break; + } +} + +bool8 NotUsingHPEVItemOnShedinja(struct Pokemon *mon, u16 item) +{ + if (GetItemEffectType(item) == ITEM_EFFECT_HP_EV && GetMonData(mon, MON_DATA_SPECIES) == SPECIES_SHEDINJA) + return FALSE; + return TRUE; +} + +bool8 IsItemFlute(u16 item) +{ + if (item == ITEM_BLUE_FLUTE || item == ITEM_RED_FLUTE || item == ITEM_YELLOW_FLUTE) + return TRUE; + return FALSE; +} + +bool8 ExecuteTableBasedItemEffect_(u8 partyMonIndex, u16 item, u8 monMoveIndex) +{ + if (gMain.inBattle) + return ExecuteTableBasedItemEffect(&gPlayerParty[partyMonIndex], item, GetPartyIdFromBattleSlot(partyMonIndex), monMoveIndex); + else + return ExecuteTableBasedItemEffect(&gPlayerParty[partyMonIndex], item, partyMonIndex, monMoveIndex); +} + +void sub_81252D0(u8 taskId, TaskFunc func) +{ + u16 hp; + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 item = gSpecialVar_ItemId; + bool8 canHeal; + + if (!NotUsingHPEVItemOnShedinja(mon, item)) + { + canHeal = TRUE; + } + else + { + if (IsHPRecoveryItem(item) == TRUE) + { + hp = GetMonData(mon, MON_DATA_HP); + if (hp == GetMonData(mon, MON_DATA_MAX_HP)) + canHeal = FALSE; + } + canHeal = PokemonUseItemEffects2(mon, item, gPartyMenu.slotId, 0); + } + PlaySE(SE_SELECT); + if (canHeal) + { + gPartyMenuUseExitCallback = FALSE; + DisplayPartyMenuMessage(gText_WontHaveEffect, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = func; + } + else + { + ItemUse_SetQuestLogEvent(4, mon, item, 0xFFFF); + sub_8124DC0(taskId); + gItemUseCB = ItemUseCB_Medicine; + } +} + +void ItemUseCB_Medicine(u8 taskId, TaskFunc func) +{ + u16 hp = 0; + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 item = gSpecialVar_ItemId; + bool8 canHeal; + + if (NotUsingHPEVItemOnShedinja(mon, item)) + { + canHeal = IsHPRecoveryItem(item); + if (canHeal == TRUE) + { + hp = GetMonData(mon, MON_DATA_HP); + if (hp == GetMonData(mon, MON_DATA_MAX_HP)) + canHeal = FALSE; + } + if (ExecuteTableBasedItemEffect_(gPartyMenu.slotId, item, 0)) + { + WONT_HAVE_EFFECT: + gPartyMenuUseExitCallback = FALSE; + PlaySE(SE_SELECT); + DisplayPartyMenuMessage(gText_WontHaveEffect, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = func; + return; + } + } + else + { + goto WONT_HAVE_EFFECT; // even loop wrap won't work + } + gPartyMenuUseExitCallback = TRUE; + if (!IsItemFlute(item)) + { + PlaySE(SE_KAIFUKU); + if (gPartyMenu.action != PARTY_ACTION_REUSABLE_ITEM) + RemoveBagItem(item, 1); + } + else + { + PlaySE(SE_BIDORO); + } + SetPartyMonAilmentGfx(mon, &sPartyMenuBoxes[gPartyMenu.slotId]); + if (gSprites[sPartyMenuBoxes[gPartyMenu.slotId].statusSpriteId].invisible) + DisplayPartyPokemonLevelCheck(mon, &sPartyMenuBoxes[gPartyMenu.slotId], 1); + if (canHeal == TRUE) + { + if (hp == 0) + AnimatePartySlot(gPartyMenu.slotId, 1); + PartyMenuModifyHP(taskId, gPartyMenu.slotId, 1, GetMonData(mon, MON_DATA_HP) - hp, Task_DisplayHPRestoredMessage); + ResetHPTaskData(taskId, 0, hp); + return; + } + else + { + GetMonNickname(mon, gStringVar1); + GetMedicineItemEffectMessage(item); + DisplayPartyMenuMessage(gStringVar4, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = func; + } +} + +void Task_DisplayHPRestoredMessage(u8 taskId) +{ + GetMonNickname(&gPlayerParty[gPartyMenu.slotId], gStringVar1); + StringExpandPlaceholders(gStringVar4, gText_PkmnHPRestoredByVar2); + DisplayPartyMenuMessage(gStringVar4, FALSE); + ScheduleBgCopyTilemapToVram(2); + HandleBattleLowHpMusicChange(); + gTasks[taskId].func = Task_ClosePartyMenuAfterText; +} + +void Task_ClosePartyMenuAfterText(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + if (gPartyMenuUseExitCallback == FALSE) + sPartyMenuInternal->exitCallback = NULL; + Task_ClosePartyMenu(taskId); + } +} + +void ShowMoveSelectWindow(u8 slot) +{ + u8 i; + u8 moveCount = 0; + u8 fontId = 2; + u8 windowId = DisplaySelectionWindow(SELECTWINDOW_MOVES); + u16 move; + + for (i = 0; i < MAX_MON_MOVES; ++i) + { + move = GetMonData(&gPlayerParty[slot], MON_DATA_MOVE1 + i); + AddTextPrinterParameterized(windowId, + fontId, + gMoveNames[move], + GetFontAttribute(fontId, FONTATTR_MAX_LETTER_WIDTH) + GetFontAttribute(fontId, FONTATTR_LETTER_SPACING), + (i * 16) + 2, + TEXT_SPEED_FF, + NULL); + if (move != MOVE_NONE) + ++moveCount; + } + Menu_InitCursor(windowId, fontId, 0, 2, 16, moveCount, FALSE); + ScheduleBgCopyTilemapToVram(2); +} + +void Task_HandleWhichMoveInput(u8 taskId) +{ + s8 input = Menu_ProcessInput(); + + if (input != MENU_NOTHING_CHOSEN) + { + if (input == MENU_B_PRESSED) + { + PlaySE(SE_SELECT); + ReturnToUseOnWhichMon(taskId); + } + else + { + SetSelectedMoveForPPItem(taskId); + } + } +} + +void ItemUseCB_PPRecovery(u8 taskId, UNUSED TaskFunc func) +{ + const u8 *effect; + u16 item = gSpecialVar_ItemId; + + if (item == ITEM_ENIGMA_BERRY) + effect = gSaveBlock1Ptr->enigmaBerry.itemEffect; + else + effect = gItemEffectTable[item - ITEM_POTION]; + + if (!(effect[4] & ITEM4_HEAL_PP_ONE)) + { + gPartyMenu.data1 = 0; + if (gPartyMenu.menuType == PARTY_MENU_TYPE_IN_BATTLE) + TryUsePPItem(taskId); + else + sub_812580C(taskId); + } + else + { + PlaySE(SE_SELECT); + DisplayPartyMenuStdMessage(PARTY_MSG_RESTORE_WHICH_MOVE); + ShowMoveSelectWindow(gPartyMenu.slotId); + gTasks[taskId].func = Task_HandleWhichMoveInput; + } +} + +void SetSelectedMoveForPPItem(u8 taskId) +{ + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + gPartyMenu.data1 = Menu_GetCursorPos(); + if (gPartyMenu.menuType == PARTY_MENU_TYPE_IN_BATTLE) + TryUsePPItem(taskId); + else + sub_812580C(taskId); +} + +void ReturnToUseOnWhichMon(u8 taskId) +{ + gTasks[taskId].func = Task_HandleChooseMonInput; + sPartyMenuInternal->exitCallback = NULL; + PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); + DisplayPartyMenuStdMessage(PARTY_MSG_USE_ON_WHICH_MON); +} + +void sub_812580C(u8 taskId) +{ + bool8 noEffect = PokemonUseItemEffects2(&gPlayerParty[gPartyMenu.slotId], + gSpecialVar_ItemId, + gPartyMenu.slotId, + gPartyMenu.data1); + PlaySE(SE_SELECT); + if (noEffect) + { + gPartyMenuUseExitCallback = FALSE; + DisplayPartyMenuMessage(gText_WontHaveEffect, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_ClosePartyMenuAfterText; + } + else + { + sub_8124DC0(taskId); + gItemUseCB = sub_8125898; + } +} + +void sub_8125898(u8 taskId, UNUSED TaskFunc func) +{ + u16 move; + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + + ExecuteTableBasedItemEffect_(gPartyMenu.slotId, gSpecialVar_ItemId, (u8)gPartyMenu.data1); + gPartyMenuUseExitCallback = TRUE; + ItemUse_SetQuestLogEvent(4, mon, gSpecialVar_ItemId, 0xFFFF); + PlaySE(SE_KAIFUKU); + RemoveBagItem(gSpecialVar_ItemId, 1); + move = GetMonData(mon, gPartyMenu.data1 + MON_DATA_MOVE1); + StringCopy(gStringVar1, gMoveNames[move]); + GetMedicineItemEffectMessage(gSpecialVar_ItemId); + DisplayPartyMenuMessage(gStringVar4, 1); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_ClosePartyMenuAfterText; +} + +void TryUsePPItem(u8 taskId) +{ + u16 move = MOVE_NONE; + s16 *moveSlot = &gPartyMenu.data1; + u16 item = gSpecialVar_ItemId; + struct PartyMenu *ptr = &gPartyMenu; + struct Pokemon *mon; + + if (ExecuteTableBasedItemEffect_(ptr->slotId, item, *moveSlot)) + { + gPartyMenuUseExitCallback = FALSE; + PlaySE(SE_SELECT); + DisplayPartyMenuMessage(gText_WontHaveEffect, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_ClosePartyMenuAfterText; + } + else + { + gPartyMenuUseExitCallback = TRUE; + mon = &gPlayerParty[ptr->slotId]; + ItemUse_SetQuestLogEvent(4, mon, item, 0xFFFF); + PlaySE(SE_KAIFUKU); + RemoveBagItem(item, 1); + move = GetMonData(mon, MON_DATA_MOVE1 + *moveSlot); + StringCopy(gStringVar1, gMoveNames[move]); + GetMedicineItemEffectMessage(item); + DisplayPartyMenuMessage(gStringVar4, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_ClosePartyMenuAfterText; + } +} + +void ItemUseCB_PPUp(u8 taskId, UNUSED TaskFunc func) +{ + PlaySE(SE_SELECT); + DisplayPartyMenuStdMessage(PARTY_MSG_BOOST_PP_WHICH_MOVE); + ShowMoveSelectWindow(gPartyMenu.slotId); + gTasks[taskId].func = Task_HandleWhichMoveInput; +} + +u16 ItemIdToBattleMoveId(u16 item) +{ + u16 tmNumber = item - ITEM_TM01_FOCUS_PUNCH; + + return sTMHMMoves[tmNumber]; +} + +bool8 IsMoveHm(u16 move) +{ + u8 i; + + for (i = 0; i < NUM_HIDDEN_MACHINES - 1; ++i) // no dive + if (sTMHMMoves[i + NUM_TECHNICAL_MACHINES] == move) + return TRUE; + return FALSE; +} + +bool8 MonKnowsMove(struct Pokemon *mon, u16 move) +{ + u8 i; + + for (i = 0; i < MAX_MON_MOVES; ++i) + { + if (GetMonData(mon, MON_DATA_MOVE1 + i) == move) + return TRUE; + } + return FALSE; +} + +void DisplayLearnMoveMessage(const u8 *str) +{ + StringExpandPlaceholders(gStringVar4, str); + DisplayPartyMenuMessage(gStringVar4, TRUE); + ScheduleBgCopyTilemapToVram(2); +} + +void DisplayLearnMoveMessageAndClose(u8 taskId, const u8 *str) +{ + DisplayLearnMoveMessage(str); + gTasks[taskId].func = Task_ClosePartyMenuAfterText; +} + +void ItemUseCB_TMHM(u8 taskId, UNUSED TaskFunc func) +{ + struct Pokemon *mon; + s16 *move; + u16 item; + + PlaySE(SE_SELECT); + mon = &gPlayerParty[gPartyMenu.slotId]; + move = &gPartyMenu.data1; + item = gSpecialVar_ItemId; + GetMonNickname(mon, gStringVar1); + move[0] = ItemIdToBattleMoveId(item); + StringCopy(gStringVar2, gMoveNames[move[0]]); + move[1] = 0; + switch (CanMonLearnTMTutor(mon, item, 0)) + { + case CANNOT_LEARN_MOVE: + DisplayLearnMoveMessageAndClose(taskId, gText_PkmnCantLearnMove); + return; + case ALREADY_KNOWS_MOVE: + DisplayLearnMoveMessageAndClose(taskId, gText_PkmnAlreadyKnows); + return; + } + if (GiveMoveToMon(mon, move[0]) != MON_HAS_MAX_MOVES) + { + ItemUse_SetQuestLogEvent(4, mon, item, 0xFFFF); + sub_8124DC0(taskId); + gItemUseCB = ItemUseCB_LearnedMove; + } + else + { + DisplayLearnMoveMessage(gText_PkmnNeedsToReplaceMove); + gTasks[taskId].func = Task_ReplaceMoveYesNo; + } +} + +void ItemUseCB_LearnedMove(u8 taskId, UNUSED TaskFunc func) +{ + Task_LearnedMove(taskId); +} + +void Task_LearnedMove(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + s16 *move = &gPartyMenu.data1; + u16 item = gSpecialVar_ItemId; + + if (move[1] == 0) + { + AdjustFriendship(mon, 4); + if (item < ITEM_HM01_CUT) + RemoveBagItem(item, 1); + } + GetMonNickname(mon, gStringVar1); + StringCopy(gStringVar2, gMoveNames[move[0]]); + StringExpandPlaceholders(gStringVar4, gText_PkmnLearnedMove3); + DisplayPartyMenuMessage(gStringVar4, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_DoLearnedMoveFanfareAfterText; +} + +void Task_DoLearnedMoveFanfareAfterText(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PlayFanfare(MUS_FANFA1); + gTasks[taskId].func = Task_LearnNextMoveOrClosePartyMenu; + } +} + +void Task_LearnNextMoveOrClosePartyMenu(u8 taskId) +{ + if (IsFanfareTaskInactive() && ((gMain.newKeys & A_BUTTON) || (gMain.newKeys & B_BUTTON))) + { + if (gPartyMenu.learnMoveState == 1) + Task_TryLearningNextMove(taskId); + else + { + if (gPartyMenu.learnMoveState == 2) // never occurs + gSpecialVar_Result = TRUE; + Task_ClosePartyMenu(taskId); + } + } +} + +void Task_ReplaceMoveYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleReplaceMoveYesNoInput; + } +} + +void Task_HandleReplaceMoveYesNoInput(u8 taskId) +{ + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: + DisplayPartyMenuMessage(gText_WhichMoveToForget, TRUE); + gTasks[taskId].func = Task_ShowSummaryScreenToForgetMove; + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: + StopLearningMovePrompt(taskId); + break; + } +} + +void Task_ShowSummaryScreenToForgetMove(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + sPartyMenuInternal->exitCallback = CB2_ShowSummaryScreenToForgetMove; + Task_ClosePartyMenu(taskId); + } +} + +void CB2_ShowSummaryScreenToForgetMove(void) +{ + ShowSelectMovePokemonSummaryScreen(gPlayerParty, gPartyMenu.slotId, gPlayerPartyCount - 1, CB2_ReturnToPartyMenuWhileLearningMove, gPartyMenu.data1); +} + +void CB2_ReturnToPartyMenuWhileLearningMove(void) +{ + u8 moveIdx = GetMoveSlotToReplace(); + u16 move; + s32 learnMoveState = gPartyMenu.learnMoveState; + + if (learnMoveState == 0 && moveIdx != MAX_MON_MOVES) + { + move = GetMonData(&gPlayerParty[gPartyMenu.slotId], moveIdx + MON_DATA_MOVE1); + sub_811C568(gPartyMenu.slotId, gSpecialVar_ItemId, move, sub_8124EFC); + gItemUseCB = sub_8125F4C; + gPartyMenu.action = learnMoveState; + } + else + { + InitPartyMenu(PARTY_MENU_TYPE_FIELD, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_MON, TRUE, PARTY_MSG_NONE, Task_ReturnToPartyMenuWhileLearningMove, gPartyMenu.exitCallback); + } +} + +void Task_ReturnToPartyMenuWhileLearningMove(u8 taskId) +{ + if (!gPaletteFade.active) + { + if (GetMoveSlotToReplace() != MAX_MON_MOVES) + DisplayPartyMenuForgotMoveMessage(taskId); + else + StopLearningMovePrompt(taskId); + } +} + +void sub_8125F4C(u8 taskId, UNUSED TaskFunc func) +{ + sub_8125F5C(taskId); +} + +void sub_8125F5C(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u8 moveIdx = GetMoveSlotToReplace(); + u16 move = GetMonData(mon, moveIdx + MON_DATA_MOVE1); + + ItemUse_SetQuestLogEvent(4, mon, gSpecialVar_ItemId, move); + GetMonNickname(mon, gStringVar1); + StringCopy(gStringVar2, gMoveNames[move]); + RemoveMonPPBonus(mon, moveIdx); + SetMonMoveSlot(mon, gPartyMenu.data1, moveIdx); + Task_LearnedMove(taskId); +} + +void DisplayPartyMenuForgotMoveMessage(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 move = GetMonData(mon, MON_DATA_MOVE1 + GetMoveSlotToReplace()); + + GetMonNickname(mon, gStringVar1); + StringCopy(gStringVar2, gMoveNames[move]); + DisplayLearnMoveMessage(gText_12PoofForgotMove); + gTasks[taskId].func = Task_PartyMenuReplaceMove; +} + +void Task_PartyMenuReplaceMove(u8 taskId) +{ + struct Pokemon *mon; + u16 move; + + if (IsPartyMenuTextPrinterActive() != TRUE) + { + mon = &gPlayerParty[gPartyMenu.slotId]; + RemoveMonPPBonus(mon, GetMoveSlotToReplace()); + move = gPartyMenu.data1; + SetMonMoveSlot(mon, move, GetMoveSlotToReplace()); + Task_LearnedMove(taskId); + } +} + +void StopLearningMovePrompt(u8 taskId) +{ + StringCopy(gStringVar2, gMoveNames[gPartyMenu.data1]); + StringExpandPlaceholders(gStringVar4, gText_StopLearningMove2); + DisplayPartyMenuMessage(gStringVar4, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_StopLearningMoveYesNo; +} + +void Task_StopLearningMoveYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleStopLearningMoveYesNoInput; + } +} + +void Task_HandleStopLearningMoveYesNoInput(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: + GetMonNickname(mon, gStringVar1); + StringCopy(gStringVar2, gMoveNames[gPartyMenu.data1]); + StringExpandPlaceholders(gStringVar4, gText_MoveNotLearned); + DisplayPartyMenuMessage(gStringVar4, TRUE); + if (gPartyMenu.learnMoveState == 1) + { + gTasks[taskId].func = Task_TryLearningNextMoveAfterText; + } + else + { + if (gPartyMenu.learnMoveState == 2) // never occurs + gSpecialVar_Result = FALSE; + gTasks[taskId].func = Task_ClosePartyMenuAfterText; + } + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: + GetMonNickname(mon, gStringVar1); + StringCopy(gStringVar2, gMoveNames[gPartyMenu.data1]); + DisplayLearnMoveMessage(gText_PkmnNeedsToReplaceMove); + gTasks[taskId].func = Task_ReplaceMoveYesNo; + break; + } +} diff --git a/src/start_menu.c b/src/start_menu.c index 4a4fe52e3..2a1713902 100644 --- a/src/start_menu.c +++ b/src/start_menu.c @@ -504,7 +504,7 @@ static bool8 StartMenuPlayerCallback(void) PlayRainStoppingSoundEffect(); DestroySafariZoneStatsWindow(); CleanupOverworldWindowsAndTilemaps(); - InitTrainerCard(CB2_ReturnToStartMenu); + InitTrainerCard(CB2_ReturnToFieldWithOpenMenu); return TRUE; } return FALSE; @@ -524,7 +524,7 @@ static bool8 StartMenuOptionCallback(void) DestroySafariZoneStatsWindow(); CleanupOverworldWindowsAndTilemaps(); SetMainCallback2(CB2_OptionsMenuFromStartMenu); - gMain.savedCallback = CB2_ReturnToStartMenu; + gMain.savedCallback = CB2_ReturnToFieldWithOpenMenu; return TRUE; } return FALSE; @@ -554,7 +554,7 @@ static bool8 StartMenuLinkPlayerCallback(void) { PlayRainStoppingSoundEffect(); CleanupOverworldWindowsAndTilemaps(); - InitLinkPartnerTrainerCard(gUnknown_300502C, CB2_ReturnToStartMenu); + InitLinkPartnerTrainerCard(gUnknown_300502C, CB2_ReturnToFieldWithOpenMenu); return TRUE; } return FALSE; diff --git a/src/trade.c b/src/trade.c index 537a5503b..4921a1ba3 100644 --- a/src/trade.c +++ b/src/trade.c @@ -4474,7 +4474,7 @@ int GetUnionRoomTradeMessageId(struct UnkLinkRfuStruct_02022B14Substruct a0, str return 0; } -int Trade_CanTradeSelectedMon(struct UnkLinkRfuStruct_02022B14Substruct a0, u16 species, u16 a2, u8 a3) +int CanRegisterMonForTradingBoard(struct UnkLinkRfuStruct_02022B14Substruct a0, u16 species, u16 a2, u8 a3) { u8 canTradeEggAndNational = a0.unk_01_0; -- cgit v1.2.3 From 98be2d1805920105f31baf633453ce39e968e018 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Sat, 23 Nov 2019 10:55:30 -0500 Subject: fldeff_sweetscent ewram --- src/fldeff_sweetscent.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src') diff --git a/src/fldeff_sweetscent.c b/src/fldeff_sweetscent.c index 66529cd55..943d8504c 100644 --- a/src/fldeff_sweetscent.c +++ b/src/fldeff_sweetscent.c @@ -13,6 +13,8 @@ #include "wild_encounter.h" #include "constants/songs.h" +static EWRAM_DATA u8 *gUnknown_203AAB0 = NULL; + static void FieldCallback_SweetScent(void); static void StartSweetScentFieldEffect(void); static void TrySweetScentEncounter(u8 taskId); -- cgit v1.2.3 From 1ffe7f78cb75b5e5f63bd803ad3fd47126a2e7c6 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Sun, 24 Nov 2019 03:03:29 +0800 Subject: party_menu fourth quarter --- src/battle_gfx_sfx_util.c | 4 +- src/battle_main.c | 4 +- src/battle_script_commands.c | 4 +- src/item.c | 2 +- src/item_pc.c | 2 +- src/item_use.c | 8 +- src/mailbox_pc.c | 4 +- src/party_menu.c | 1491 +++++++++++++++++++++++++++++++++++++++++- src/player_pc.c | 24 +- src/pokemon.c | 10 +- 10 files changed, 1508 insertions(+), 45 deletions(-) (limited to 'src') diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c index 55d413b3b..d7bccb298 100644 --- a/src/battle_gfx_sfx_util.c +++ b/src/battle_gfx_sfx_util.c @@ -859,8 +859,8 @@ void HandleBattleLowHpMusicChange(void) { u8 playerBattler1 = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); u8 playerBattler2 = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); - u8 battler1PartyId = pokemon_order_func(gBattlerPartyIndexes[playerBattler1]); - u8 battler2PartyId = pokemon_order_func(gBattlerPartyIndexes[playerBattler2]); + u8 battler1PartyId = GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[playerBattler1]); + u8 battler2PartyId = GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[playerBattler2]); if (GetMonData(&gPlayerParty[battler1PartyId], MON_DATA_HP) != 0) HandleLowHpMusicChange(&gPlayerParty[battler1PartyId], playerBattler1); diff --git a/src/battle_main.c b/src/battle_main.c index a6d7e69c8..d307d4f55 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -3005,8 +3005,8 @@ void sub_8013F6C(u8 battler) for (i = 0; i < 3; ++i) gBattlePartyCurrentOrder[i] = *(battler * 3 + i + (u8 *)(gBattleStruct->field_60)); - r4 = pokemon_order_func(gBattlerPartyIndexes[battler]); - r1 = pokemon_order_func(*(gBattleStruct->monToSwitchIntoId + battler)); + r4 = GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[battler]); + r1 = GetPartyIdFromBattlePartyId(*(gBattleStruct->monToSwitchIntoId + battler)); SwitchPartyMonSlots(r4, r1); if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index fe7359eb9..a20f47ad4 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -5831,7 +5831,7 @@ static void DrawLevelUpWindow1(void) { u16 currStats[NUM_STATS]; - GetMonLevelUpWindowStats(&gPlayerParty[gBattleStruct->expGetterMonId], currStats); + BufferMonStatsToTaskData(&gPlayerParty[gBattleStruct->expGetterMonId], currStats); DrawLevelUpWindowPg1(12, gBattleResources->beforeLvlUp->stats, currStats, 0xE, 0xD, 0xF); } @@ -5839,7 +5839,7 @@ static void DrawLevelUpWindow2(void) { u16 currStats[NUM_STATS]; - GetMonLevelUpWindowStats(&gPlayerParty[gBattleStruct->expGetterMonId], currStats); + BufferMonStatsToTaskData(&gPlayerParty[gBattleStruct->expGetterMonId], currStats); DrawLevelUpWindowPg2(12, currStats, 0xE, 0xD, 0xF); } diff --git a/src/item.c b/src/item.c index 677c13ad7..e16d5055c 100644 --- a/src/item.c +++ b/src/item.c @@ -412,7 +412,7 @@ bool8 AddPCItem(u16 itemId, u16 count) return TRUE; } -void RemoveItemFromPC(u16 itemId, u16 count) +void RemovePCItem(u16 itemId, u16 count) { u32 i; u16 quantity; diff --git a/src/item_pc.c b/src/item_pc.c index f30cf1381..3e0c50b60 100644 --- a/src/item_pc.c +++ b/src/item_pc.c @@ -926,7 +926,7 @@ static void Task_ItemPcWaitButtonAndFinishWithdrawMultiple(u8 taskId) { PlaySE(SE_SELECT); itemId = ItemPc_GetItemIdBySlotId(data[1]); - RemoveItemFromPC(itemId, data[8]); + RemovePCItem(itemId, data[8]); ItemPcCompaction(); Task_ItemPcCleanUpWithdraw(taskId); } diff --git a/src/item_use.c b/src/item_use.c index 70673d681..256711463 100644 --- a/src/item_use.c +++ b/src/item_use.c @@ -414,7 +414,7 @@ static void sub_80A16D0(u8 taskId) void FieldUseFunc_Medicine(u8 taskId) { - gItemUseCB = sub_81252D0; + gItemUseCB = ItemUseCB_Medicine; sub_80A16D0(taskId); } @@ -432,13 +432,13 @@ void FieldUseFunc_PpUp(u8 taskId) void FieldUseFunc_RareCandy(u8 taskId) { - gItemUseCB = dp05_rare_candy; + gItemUseCB = ItemUseCB_RareCandy; sub_80A16D0(taskId); } void FieldUseFunc_EvoItem(u8 taskId) { - gItemUseCB = sub_8126B60; + gItemUseCB = ItemUseCB_EvolutionStone; sub_80A16D0(taskId); } @@ -811,7 +811,7 @@ static void ItemUse_SwitchToPartyMenuInBattle(u8 taskId) void BattleUseFunc_Medicine(u8 taskId) { - gItemUseCB = ItemUseCB_Medicine; + gItemUseCB = ItemUseCB_MedicineStep; ItemUse_SwitchToPartyMenuInBattle(taskId); } diff --git a/src/mailbox_pc.c b/src/mailbox_pc.c index 0a4535271..5489c4c4e 100644 --- a/src/mailbox_pc.c +++ b/src/mailbox_pc.c @@ -123,7 +123,7 @@ u8 MailboxPC_InitListMenu(struct PlayerPCItemPageStruct * playerPcStruct) gMultiuseListMenuTemplate.itemPrintFunc = ItemPrintFunc; gMultiuseListMenuTemplate.cursorKind = 0; gMultiuseListMenuTemplate.scrollMultiple = 0; - return ListMenuInit(&gMultiuseListMenuTemplate, playerPcStruct->scrollOffset, playerPcStruct->selectedRow); + return ListMenuInit(&gMultiuseListMenuTemplate, playerPcStruct->itemsAbove, playerPcStruct->cursorPos); } static void MoveCursorFunc(s32 itemIndex, bool8 onInit, struct ListMenu * list) @@ -134,7 +134,7 @@ static void MoveCursorFunc(s32 itemIndex, bool8 onInit, struct ListMenu * list) void MailboxPC_AddScrollIndicatorArrows(struct PlayerPCItemPageStruct * playerPcStruct) { - playerPcStruct->scrollIndicatorId = AddScrollIndicatorArrowPairParameterized(2, 0xC2, 0xC, 0x94, playerPcStruct->count - playerPcStruct->pageItems + 1, 110, 110, &playerPcStruct->scrollOffset); + playerPcStruct->scrollIndicatorId = AddScrollIndicatorArrowPairParameterized(2, 0xC2, 0xC, 0x94, playerPcStruct->count - playerPcStruct->pageItems + 1, 110, 110, &playerPcStruct->itemsAbove); } void MailboxPC_DestroyListMenuBuffer(void) diff --git a/src/party_menu.c b/src/party_menu.c index f88f2f6fc..5bee1442e 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -5,6 +5,7 @@ #include "battle_controllers.h" #include "battle_gfx_sfx_util.h" #include "battle_interface.h" +#include "battle_tower.h" #include "berry_pouch.h" #include "bg.h" #include "data.h" @@ -40,6 +41,7 @@ #include "palette.h" #include "party_menu.h" #include "player_pc.h" +#include "pokedex.h" #include "pokemon.h" #include "pokemon_icon.h" #include "pokemon_jump.h" @@ -326,6 +328,43 @@ void Task_PartyMenuReplaceMove(u8 taskId); void Task_StopLearningMoveYesNo(u8 taskId); void Task_HandleStopLearningMoveYesNoInput(u8 taskId); void Task_TryLearningNextMoveAfterText(u8 taskId); +void ItemUseCB_RareCandyStep(u8 taskId, UNUSED TaskFunc func); +void Task_DisplayLevelUpStatsPg1(u8 taskId); +void Task_DisplayLevelUpStatsPg2(u8 taskId); +void UpdateMonDisplayInfoAfterRareCandy(u8 slot, struct Pokemon *mon); +void DisplayLevelUpStatsPg1(u8 taskId); +void DisplayLevelUpStatsPg2(u8 taskId); +void Task_TryLearnNewMoves(u8 taskId); +void PartyMenuTryEvolution(u8 taskId); +void DisplayMonNeedsToReplaceMove(u8 taskId); +void DisplayMonLearnedMove(u8 taskId, u16 move); +void Task_SacredAshDisplayHPRestored(u8 taskId); +void Task_SacredAshLoop(u8 taskId); +void UseSacredAsh(u8 taskId); +void CB2_ReturnToBerryPouchMenu(void); +void CB2_ReturnToTMCaseMenu(void); +void GiveItemOrMailToSelectedMon(u8 taskId); +void RemoveItemToGiveFromBag(u16 item); +void DisplayItemMustBeRemovedFirstMessage(u8 taskId); +void CB2_WriteMailToGiveMonFromBag(void); +void GiveItemToSelectedMon(u8 taskId); +void Task_UpdateHeldItemSpriteAndClosePartyMenu(u8 taskId); +void Task_SwitchItemsFromBagYesNo(u8 taskId); +void CB2_ReturnToPartyOrBagMenuFromWritingMail(void); +bool8 ReturnGiveItemToBagOrPC(u16 item); +void Task_DisplayGaveMailFromBagMessage(u8 taskId); +void Task_HandleSwitchItemsFromBagYesNoInput(u8 taskId); +void Task_ValidateChosenHalfParty(u8 taskId); +bool8 HasPartySlotAlreadyBeenSelected(u8 slot); +void Task_ContinueChoosingHalfParty(u8 taskId); +void BufferBattlePartyOrder(u8 *partyBattleOrder, u8 flankId); +void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battlerId); +void Task_InitMultiPartnerPartySlideIn(u8 taskId); +void Task_WaitAfterMultiPartnerPartySlideIn(u8 taskId); +void SlideMultiPartyMenuBoxSpritesOneStep(u8 taskId); +void Task_MultiPartnerPartySlideIn(u8 taskId); +bool8 CB2_FadeFromPartyMenu(void); +void Task_PartyMenuWaitForFade(u8 taskId); void sub_8120C6C(u8 taskId); void sub_8120CA8(u8 taskId); void sub_8120CD8(u8 taskId); @@ -345,8 +384,6 @@ u8 sub_81220D4(void); void sub_8122110(u8 windowId); void sub_812358C(void); void sub_8124BB0(struct Pokemon *mon, u8 fieldMove); -void sub_8124DB0(void); -void sub_8124DA0(void); void sub_8124DE0(void); void sub_8124E48(void); void sub_812580C(u8 taskId); @@ -366,8 +403,8 @@ EWRAM_DATA u8 gSelectedMonPartyId = 0; EWRAM_DATA MainCallback gPostMenuFieldCallback = NULL; EWRAM_DATA u16 *sSlot1TilemapBuffer = NULL; // for switching party slots EWRAM_DATA u16 *sSlot2TilemapBuffer = NULL; -EWRAM_DATA struct Pokemon *gUnknown_203B0D0 = NULL; -EWRAM_DATA u8 gSelectedOrderFromParty[4] = {0}; +EWRAM_DATA struct Pokemon *sSacredAshQuestLogMonBackup = NULL; +EWRAM_DATA u8 gSelectedOrderFromParty[3] = {0}; EWRAM_DATA u16 sPartyMenuItemId = ITEM_NONE; ALIGNED(4) EWRAM_DATA u8 gBattlePartyCurrentOrder[PARTY_SIZE / 2] = {0}; // bits 0-3 are the current pos of Slot 1, 4-7 are Slot 2, and so on @@ -4217,7 +4254,7 @@ void CB2_ShowPartyMenuForItemUse(void) } } if (GetPocketByItemId(gSpecialVar_ItemId) == POCKET_BERRY_POUCH) - callback = sub_8124DB0; + callback = CB2_ReturnToBerryPouchMenu; task = Task_SetSacredAshCB; msgId = PARTY_MSG_NONE; } @@ -4230,11 +4267,11 @@ void CB2_ShowPartyMenuForItemUse(void) break; case POCKET_TM_CASE: msgId = PARTY_MSG_TEACH_WHICH_MON; - callback = sub_8124DA0; + callback = CB2_ReturnToTMCaseMenu; break; case POCKET_BERRY_POUCH: msgId = PARTY_MSG_USE_ON_WHICH_MON; - callback = sub_8124DB0; + callback = CB2_ReturnToBerryPouchMenu; break; } task = Task_HandleChooseMonInput; @@ -4247,12 +4284,12 @@ void CB2_ReturnToBagMenu(void) GoToBagMenu(11, 3, NULL); } -void sub_8124DA0(void) +void CB2_ReturnToTMCaseMenu(void) { InitTMCase(5, NULL, 0xFF); } -void sub_8124DB0(void) +void CB2_ReturnToBerryPouchMenu(void) { InitBerryPouch(BERRYPOUCH_NA, NULL, 0xFF); } @@ -4428,7 +4465,7 @@ bool8 ExecuteTableBasedItemEffect_(u8 partyMonIndex, u16 item, u8 monMoveIndex) return ExecuteTableBasedItemEffect(&gPlayerParty[partyMonIndex], item, partyMonIndex, monMoveIndex); } -void sub_81252D0(u8 taskId, TaskFunc func) +void ItemUseCB_Medicine(u8 taskId, TaskFunc func) { u16 hp; struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; @@ -4447,7 +4484,7 @@ void sub_81252D0(u8 taskId, TaskFunc func) if (hp == GetMonData(mon, MON_DATA_MAX_HP)) canHeal = FALSE; } - canHeal = PokemonUseItemEffects2(mon, item, gPartyMenu.slotId, 0); + canHeal = PokemonItemUseNoEffect(mon, item, gPartyMenu.slotId, 0); } PlaySE(SE_SELECT); if (canHeal) @@ -4461,11 +4498,11 @@ void sub_81252D0(u8 taskId, TaskFunc func) { ItemUse_SetQuestLogEvent(4, mon, item, 0xFFFF); sub_8124DC0(taskId); - gItemUseCB = ItemUseCB_Medicine; + gItemUseCB = ItemUseCB_MedicineStep; } } -void ItemUseCB_Medicine(u8 taskId, TaskFunc func) +void ItemUseCB_MedicineStep(u8 taskId, TaskFunc func) { u16 hp = 0; struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; @@ -4638,7 +4675,7 @@ void ReturnToUseOnWhichMon(u8 taskId) void sub_812580C(u8 taskId) { - bool8 noEffect = PokemonUseItemEffects2(&gPlayerParty[gPartyMenu.slotId], + bool8 noEffect = PokemonItemUseNoEffect(&gPlayerParty[gPartyMenu.slotId], gSpecialVar_ItemId, gPartyMenu.slotId, gPartyMenu.data1); @@ -5008,3 +5045,1429 @@ void Task_HandleStopLearningMoveYesNoInput(u8 taskId) break; } } + +void Task_TryLearningNextMoveAfterText(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + Task_TryLearningNextMove(taskId); +} + +void ItemUseCB_RareCandy(u8 taskId, TaskFunc func) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 item = gSpecialVar_ItemId; + bool8 noEffect; + + if (GetMonData(mon, MON_DATA_LEVEL) != MAX_LEVEL) + noEffect = PokemonItemUseNoEffect(mon, item, gPartyMenu.slotId, 0); + else + noEffect = TRUE; + PlaySE(SE_SELECT); + if (noEffect) + { + gPartyMenuUseExitCallback = FALSE; + DisplayPartyMenuMessage(gText_WontHaveEffect, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = func; + } + else + { + sub_8124DC0(taskId); + gItemUseCB = ItemUseCB_RareCandyStep; + } +} + +void ItemUseCB_RareCandyStep(u8 taskId, UNUSED TaskFunc func) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + struct PartyMenuInternal *ptr = sPartyMenuInternal; + s16 *arrayPtr = ptr->data; + u8 level; + + BufferMonStatsToTaskData(mon, arrayPtr); + ExecuteTableBasedItemEffect_(gPartyMenu.slotId, gSpecialVar_ItemId, 0); + BufferMonStatsToTaskData(mon, &ptr->data[NUM_STATS]); + gPartyMenuUseExitCallback = TRUE; + ItemUse_SetQuestLogEvent(4, mon, gSpecialVar_ItemId, 0xFFFF); + PlayFanfareByFanfareNum(0); + UpdateMonDisplayInfoAfterRareCandy(gPartyMenu.slotId, mon); + RemoveBagItem(gSpecialVar_ItemId, 1); + GetMonNickname(mon, gStringVar1); + level = GetMonData(mon, MON_DATA_LEVEL); + ConvertIntToDecimalStringN(gStringVar2, level, STR_CONV_MODE_LEFT_ALIGN, 3); + StringExpandPlaceholders(gStringVar4, gText_PkmnElevatedToLvVar2); + DisplayPartyMenuMessage(gStringVar4, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_DisplayLevelUpStatsPg1; +} + +void UpdateMonDisplayInfoAfterRareCandy(u8 slot, struct Pokemon *mon) +{ + SetPartyMonAilmentGfx(mon, &sPartyMenuBoxes[slot]); + if (gSprites[sPartyMenuBoxes[slot].statusSpriteId].invisible) + DisplayPartyPokemonLevelCheck(mon, &sPartyMenuBoxes[slot], 1); + DisplayPartyPokemonHPCheck(mon, &sPartyMenuBoxes[slot], 1); + DisplayPartyPokemonMaxHPCheck(mon, &sPartyMenuBoxes[slot], 1); + DisplayPartyPokemonHPBarCheck(mon, &sPartyMenuBoxes[slot]); + UpdatePartyMonHPBar(sPartyMenuBoxes[slot].monSpriteId, mon); + AnimatePartySlot(slot, 1); + ScheduleBgCopyTilemapToVram(0); +} + +void Task_DisplayLevelUpStatsPg1(u8 taskId) +{ + if (WaitFanfare(FALSE) && IsPartyMenuTextPrinterActive() != TRUE && (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON))) + { + PlaySE(SE_SELECT); + DisplayLevelUpStatsPg1(taskId); + gTasks[taskId].func = Task_DisplayLevelUpStatsPg2; + } +} + +void Task_DisplayLevelUpStatsPg2(u8 taskId) +{ + if (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON)) + { + PlaySE(SE_SELECT); + DisplayLevelUpStatsPg2(taskId); + gTasks[taskId].func = Task_TryLearnNewMoves; + } +} + +void DisplayLevelUpStatsPg1(u8 taskId) +{ + s16 *arrayPtr = sPartyMenuInternal->data; + + arrayPtr[12] = CreateLevelUpStatsWindow(); + DrawLevelUpWindowPg1(arrayPtr[12], arrayPtr, &arrayPtr[6], 1, 2, 3); + CopyWindowToVram(arrayPtr[12], 2); + ScheduleBgCopyTilemapToVram(2); +} + +void DisplayLevelUpStatsPg2(u8 taskId) +{ + s16 *arrayPtr = sPartyMenuInternal->data; + + DrawLevelUpWindowPg2(arrayPtr[12], &arrayPtr[6], 1, 2, 3); + CopyWindowToVram(arrayPtr[12], 2); + ScheduleBgCopyTilemapToVram(2); +} + +void Task_TryLearnNewMoves(u8 taskId) +{ + u16 learnMove; + + if (WaitFanfare(0) && (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON))) + { + RemoveLevelUpStatsWindow(); + learnMove = MonTryLearningNewMove(&gPlayerParty[gPartyMenu.slotId], TRUE); + gPartyMenu.learnMoveState = 1; + switch (learnMove) + { + case 0: // No moves to learn + PartyMenuTryEvolution(taskId); + break; + case MON_HAS_MAX_MOVES: + DisplayMonNeedsToReplaceMove(taskId); + break; + case MON_ALREADY_KNOWS_MOVE: + gTasks[taskId].func = Task_TryLearningNextMove; + break; + default: + DisplayMonLearnedMove(taskId, learnMove); + break; + } + } +} + +void Task_TryLearningNextMove(u8 taskId) +{ + u16 result = MonTryLearningNewMove(&gPlayerParty[gPartyMenu.slotId], FALSE); + + switch (result) + { + case 0: // No moves to learn + PartyMenuTryEvolution(taskId); + break; + case MON_HAS_MAX_MOVES: + DisplayMonNeedsToReplaceMove(taskId); + break; + case MON_ALREADY_KNOWS_MOVE: + return; + default: + DisplayMonLearnedMove(taskId, result); + break; + } +} + +void PartyMenuTryEvolution(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 targetSpecies = GetEvolutionTargetSpecies(mon, 0, 0); + + if (targetSpecies != SPECIES_NONE) + { + FreePartyPointers(); + gCB2_AfterEvolution = gPartyMenu.exitCallback; + BeginEvolutionScene(mon, targetSpecies, 1, gPartyMenu.slotId); + DestroyTask(taskId); + } + else + { + gTasks[taskId].func = Task_ClosePartyMenuAfterText; + } +} + +void DisplayMonNeedsToReplaceMove(u8 taskId) +{ + GetMonNickname(&gPlayerParty[gPartyMenu.slotId], gStringVar1); + StringCopy(gStringVar2, gMoveNames[gMoveToLearn]); + StringExpandPlaceholders(gStringVar4, gText_PkmnNeedsToReplaceMove); + DisplayPartyMenuMessage(gStringVar4, TRUE); + ScheduleBgCopyTilemapToVram(2); + gPartyMenu.data1 = gMoveToLearn; + gTasks[taskId].func = Task_ReplaceMoveYesNo; +} + +void DisplayMonLearnedMove(u8 taskId, u16 move) +{ + GetMonNickname(&gPlayerParty[gPartyMenu.slotId], gStringVar1); + StringCopy(gStringVar2, gMoveNames[move]); + StringExpandPlaceholders(gStringVar4, gText_PkmnLearnedMove3); + DisplayPartyMenuMessage(gStringVar4, TRUE); + ScheduleBgCopyTilemapToVram(2); + gPartyMenu.data1 = move; + gTasks[taskId].func = Task_DoLearnedMoveFanfareAfterText; +} + +#define tUsedOnSlot data[0] +#define tHadEffect data[1] +#define tLastSlotUsed data[2] + +void ItemUseCB_SacredAsh(u8 taskId, UNUSED TaskFunc func) +{ + sPartyMenuInternal->tUsedOnSlot = FALSE; + sPartyMenuInternal->tHadEffect = FALSE; + sPartyMenuInternal->tLastSlotUsed = gPartyMenu.slotId; + UseSacredAsh(taskId); +} + +void UseSacredAsh(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 hp; + + if (GetMonData(mon, MON_DATA_SPECIES) == SPECIES_NONE) + { + gTasks[taskId].func = Task_SacredAshLoop; + return; + } + hp = GetMonData(mon, MON_DATA_HP); + if (ExecuteTableBasedItemEffect_(gPartyMenu.slotId, gSpecialVar_ItemId, 0)) + { + gTasks[taskId].func = Task_SacredAshLoop; + return; + } + PlaySE(SE_KAIFUKU); + if (sPartyMenuInternal->tHadEffect == 0) + sSacredAshQuestLogMonBackup = mon; + SetPartyMonAilmentGfx(mon, &sPartyMenuBoxes[gPartyMenu.slotId]); + if (gSprites[sPartyMenuBoxes[gPartyMenu.slotId].statusSpriteId].invisible) + DisplayPartyPokemonLevelCheck(mon, &sPartyMenuBoxes[gPartyMenu.slotId], 1); + AnimatePartySlot(sPartyMenuInternal->tLastSlotUsed, 0); + AnimatePartySlot(gPartyMenu.slotId, 1); + PartyMenuModifyHP(taskId, gPartyMenu.slotId, 1, GetMonData(mon, MON_DATA_HP) - hp, Task_SacredAshDisplayHPRestored); + ResetHPTaskData(taskId, 0, hp); + sPartyMenuInternal->tUsedOnSlot = TRUE; + sPartyMenuInternal->tHadEffect = TRUE; +} + +void Task_SacredAshLoop(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + if (sPartyMenuInternal->tUsedOnSlot == TRUE) + { + sPartyMenuInternal->tUsedOnSlot = FALSE; + sPartyMenuInternal->tLastSlotUsed = gPartyMenu.slotId; + } + if (++(gPartyMenu.slotId) == PARTY_SIZE) + { + if (sPartyMenuInternal->tHadEffect == FALSE) + { + gPartyMenuUseExitCallback = FALSE; + DisplayPartyMenuMessage(gText_WontHaveEffect, TRUE); + ScheduleBgCopyTilemapToVram(2); + } + else + { + gPartyMenuUseExitCallback = TRUE; + if (gPartyMenu.menuType != PARTY_MENU_TYPE_IN_BATTLE) + ItemUse_SetQuestLogEvent(4, sSacredAshQuestLogMonBackup, gSpecialVar_ItemId, 0xFFFF); + RemoveBagItem(gSpecialVar_ItemId, 1); + } + gTasks[taskId].func = Task_ClosePartyMenuAfterText; + gPartyMenu.slotId = 0; + } + else + { + UseSacredAsh(taskId); + } + } +} + +void Task_SacredAshDisplayHPRestored(u8 taskId) +{ + GetMonNickname(&gPlayerParty[gPartyMenu.slotId], gStringVar1); + StringExpandPlaceholders(gStringVar4, gText_PkmnHPRestoredByVar2); + DisplayPartyMenuMessage(gStringVar4, FALSE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_SacredAshLoop; +} + +#undef tUsedOnSlot +#undef tHadEffect +#undef tLastSlotUsed + +void ItemUseCB_EvolutionStone(u8 taskId, TaskFunc func) +{ + bool8 noEffect; + + PlaySE(SE_SELECT); + noEffect = PokemonItemUseNoEffect(&gPlayerParty[gPartyMenu.slotId], gSpecialVar_ItemId, gPartyMenu.slotId, 0); + if (noEffect) + { + gPartyMenuUseExitCallback = FALSE; + DisplayPartyMenuMessage(gText_WontHaveEffect, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = func; + } + else + { + sub_8124DC0(taskId); + } +} + +void sub_8126BD4(void) +{ + gCB2_AfterEvolution = gPartyMenu.exitCallback; + ExecuteTableBasedItemEffect_(gPartyMenu.slotId, gSpecialVar_ItemId, 0); + ItemUse_SetQuestLogEvent(4, &gPlayerParty[gPartyMenu.slotId], gSpecialVar_ItemId, 0xFFFF); + RemoveBagItem(gSpecialVar_ItemId, 1); +} + +bool8 sub_8126C24(void) +{ + if (!IsNationalPokedexEnabled() + && GetEvolutionTargetSpecies(&gPlayerParty[gPartyMenu.slotId], 2, gSpecialVar_ItemId) > KANTO_DEX_COUNT) + return FALSE; + else + return TRUE; +} + +u8 GetItemEffectType(u16 item) +{ + const u8 *itemEffect; + u32 statusCure; + + if (!IS_POKEMON_ITEM(item)) + return ITEM_EFFECT_NONE; + // Read the item's effect properties. + if (item == ITEM_ENIGMA_BERRY) + itemEffect = gSaveBlock1Ptr->enigmaBerry.itemEffect; + else + itemEffect = gItemEffectTable[item - ITEM_POTION]; + if ((itemEffect[0] & (ITEM0_HIGH_CRIT | ITEM0_X_ATTACK)) || itemEffect[1] || itemEffect[2] || (itemEffect[3] & ITEM3_MIST)) + return ITEM_EFFECT_X_ITEM; + else if (itemEffect[0] & ITEM0_SACRED_ASH) + return ITEM_EFFECT_SACRED_ASH; + else if (itemEffect[3] & ITEM3_LEVEL_UP) + return ITEM_EFFECT_RAISE_LEVEL; + statusCure = itemEffect[3] & ITEM3_STATUS_ALL; + if (statusCure || (itemEffect[0] >> 7)) + { + if (statusCure == ITEM3_SLEEP) + return ITEM_EFFECT_CURE_SLEEP; + else if (statusCure == ITEM3_POISON) + return ITEM_EFFECT_CURE_POISON; + else if (statusCure == ITEM3_BURN) + return ITEM_EFFECT_CURE_BURN; + else if (statusCure == ITEM3_FREEZE) + return ITEM_EFFECT_CURE_FREEZE; + else if (statusCure == ITEM3_PARALYSIS) + return ITEM_EFFECT_CURE_PARALYSIS; + else if (statusCure == ITEM3_CONFUSION) + return ITEM_EFFECT_CURE_CONFUSION; + else if (itemEffect[0] >> 7 && !statusCure) + return ITEM_EFFECT_CURE_INFATUATION; + else + return ITEM_EFFECT_CURE_ALL_STATUS; + } + if (itemEffect[4] & (ITEM4_REVIVE | ITEM4_HEAL_HP)) + return ITEM_EFFECT_HEAL_HP; + else if (itemEffect[4] & ITEM4_EV_ATK) + return ITEM_EFFECT_ATK_EV; + else if (itemEffect[4] & ITEM4_EV_HP) + return ITEM_EFFECT_HP_EV; + else if (itemEffect[5] & ITEM5_EV_SPATK) + return ITEM_EFFECT_SPATK_EV; + else if (itemEffect[5] & ITEM5_EV_SPDEF) + return ITEM_EFFECT_SPDEF_EV; + else if (itemEffect[5] & ITEM5_EV_SPEED) + return ITEM_EFFECT_SPEED_EV; + else if (itemEffect[5] & ITEM5_EV_DEF) + return ITEM_EFFECT_DEF_EV; + else if (itemEffect[4] & ITEM4_EVO_STONE) + return ITEM_EFFECT_EVO_STONE; + else if (itemEffect[4] & ITEM4_PP_UP) + return ITEM_EFFECT_PP_UP; + else if (itemEffect[5] & ITEM5_PP_MAX) + return ITEM_EFFECT_PP_MAX; + else if (itemEffect[4] & (ITEM4_HEAL_PP_ALL | ITEM4_HEAL_PP_ONE)) + return ITEM_EFFECT_HEAL_PP; + else + return ITEM_EFFECT_NONE; +} + +void TryTutorSelectedMon(u8 taskId) +{ + struct Pokemon *mon; + s16 *move; + + if (!gPaletteFade.active) + { + mon = &gPlayerParty[gPartyMenu.slotId]; + move = &gPartyMenu.data1; + GetMonNickname(mon, gStringVar1); + gPartyMenu.data1 = GetTutorMove(gSpecialVar_0x8005); + StringCopy(gStringVar2, gMoveNames[gPartyMenu.data1]); + move[1] = 2; + switch (CanMonLearnTMTutor(mon, 0, gSpecialVar_0x8005)) + { + case CANNOT_LEARN_MOVE: + DisplayLearnMoveMessageAndClose(taskId, gText_PkmnCantLearnMove); + return; + case ALREADY_KNOWS_MOVE: + DisplayLearnMoveMessageAndClose(taskId, gText_PkmnAlreadyKnows); + return; + default: + if (GiveMoveToMon(mon, gPartyMenu.data1) != MON_HAS_MAX_MOVES) + { + Task_LearnedMove(taskId); + return; + } + break; + } + DisplayLearnMoveMessage(gText_PkmnNeedsToReplaceMove); + gTasks[taskId].func = Task_ReplaceMoveYesNo; + } +} + +void CB2_PartyMenuFromStartMenu(void) +{ + InitPartyMenu(PARTY_MENU_TYPE_FIELD, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_MON, FALSE, PARTY_MSG_CHOOSE_MON, Task_HandleChooseMonInput, CB2_ReturnToFieldWithOpenMenu); +} + +// Giving an item by selecting Give from the bag menu +// As opposted to by selecting Give in the party menu, which is handled by CursorCB_Give +void CB2_ChooseMonToGiveItem(void) +{ + MainCallback callback; + + switch (GetPocketByItemId(gSpecialVar_ItemId)) + { + default: + callback = CB2_ReturnToBagMenu; + break; + case POCKET_TM_CASE: + callback = CB2_ReturnToTMCaseMenu; + break; + case POCKET_BERRY_POUCH: + callback = CB2_ReturnToBerryPouchMenu; + break; + } + InitPartyMenu(PARTY_MENU_TYPE_FIELD, PARTY_LAYOUT_SINGLE, PARTY_ACTION_GIVE_ITEM, FALSE, PARTY_MSG_GIVE_TO_WHICH_MON, Task_HandleChooseMonInput, callback); + gPartyMenu.bagItem = gSpecialVar_ItemId; +} + +void TryGiveItemOrMailToSelectedMon(u8 taskId) +{ + sPartyMenuItemId = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_HELD_ITEM); + if (sPartyMenuItemId == ITEM_NONE) + { + GiveItemOrMailToSelectedMon(taskId); + } + else if (ItemIsMail(sPartyMenuItemId)) + { + DisplayItemMustBeRemovedFirstMessage(taskId); + } + else + { + DisplayAlreadyHoldingItemSwitchMessage(&gPlayerParty[gPartyMenu.slotId], sPartyMenuItemId, TRUE); + gTasks[taskId].func = Task_SwitchItemsFromBagYesNo; + } +} + +void GiveItemOrMailToSelectedMon(u8 taskId) +{ + if (ItemIsMail(gPartyMenu.bagItem)) + { + RemoveItemToGiveFromBag(gPartyMenu.bagItem); + sPartyMenuInternal->exitCallback = CB2_WriteMailToGiveMonFromBag; + Task_ClosePartyMenu(taskId); + } + else + { + GiveItemToSelectedMon(taskId); + } +} + +void GiveItemToSelectedMon(u8 taskId) +{ + u16 item; + + if (!gPaletteFade.active) + { + item = gPartyMenu.bagItem; + DisplayGaveHeldItemMessage(&gPlayerParty[gPartyMenu.slotId], item, FALSE, 1); + GiveItemToMon(&gPlayerParty[gPartyMenu.slotId], item); + RemoveItemToGiveFromBag(item); + gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; + } +} + +void Task_UpdateHeldItemSpriteAndClosePartyMenu(u8 taskId) +{ + s8 slot = gPartyMenu.slotId; + + if (IsPartyMenuTextPrinterActive() != TRUE) + { + UpdatePartyMonHeldItemSprite(&gPlayerParty[slot], &sPartyMenuBoxes[slot]); + Task_ClosePartyMenu(taskId); + } +} + +void CB2_WriteMailToGiveMonFromBag(void) +{ + u8 mail; + + GiveItemToMon(&gPlayerParty[gPartyMenu.slotId], gPartyMenu.bagItem); + mail = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_MAIL); + DoEasyChatScreen(EASY_CHAT_TYPE_MAIL, gSaveBlock1Ptr->mail[mail].words, CB2_ReturnToPartyOrBagMenuFromWritingMail); +} + +void CB2_ReturnToPartyOrBagMenuFromWritingMail(void) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + u16 item = GetMonData(mon, MON_DATA_HELD_ITEM); + + // Canceled writing mail + if (gSpecialVar_Result == FALSE) + { + TakeMailFromMon(mon); + SetMonData(mon, MON_DATA_HELD_ITEM, &sPartyMenuItemId); + RemoveBagItem(sPartyMenuItemId, 1); + ReturnGiveItemToBagOrPC(item); + SetMainCallback2(gPartyMenu.exitCallback); + } + // Wrote mail + else + { + InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_NONE, Task_DisplayGaveMailFromBagMessage, gPartyMenu.exitCallback); + } +} + +void Task_DisplayGaveMailFromBagMessage(u8 taskId) +{ + if (!gPaletteFade.active) + { + if (sPartyMenuItemId != ITEM_NONE) + DisplaySwitchedHeldItemMessage(gPartyMenu.bagItem, sPartyMenuItemId, FALSE); + else + DisplayGaveHeldItemMessage(&gPlayerParty[gPartyMenu.slotId], gPartyMenu.bagItem, FALSE, 1); + gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; + } +} + +void Task_SwitchItemsFromBagYesNo(u8 taskId) +{ + if (IsPartyMenuTextPrinterActive() != TRUE) + { + PartyMenuDisplayYesNoMenu(); + gTasks[taskId].func = Task_HandleSwitchItemsFromBagYesNoInput; + } +} + +void Task_HandleSwitchItemsFromBagYesNoInput(u8 taskId) +{ + u16 item; + + switch (Menu_ProcessInputNoWrapClearOnChoose()) + { + case 0: // Yes, switch items + item = gPartyMenu.bagItem; + RemoveItemToGiveFromBag(item); + if (AddBagItem(sPartyMenuItemId, 1) == FALSE) + { + ReturnGiveItemToBagOrPC(item); + BufferBagFullCantTakeItemMessage(sPartyMenuItemId); + DisplayPartyMenuMessage(gStringVar4, FALSE); + gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; + } + else if (ItemIsMail(item)) + { + sPartyMenuInternal->exitCallback = CB2_WriteMailToGiveMonFromBag; + Task_ClosePartyMenu(taskId); + } + else + { + GiveItemToMon(&gPlayerParty[gPartyMenu.slotId], item); + DisplaySwitchedHeldItemMessage(item, sPartyMenuItemId, TRUE); + gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; + } + break; + case MENU_B_PRESSED: + PlaySE(SE_SELECT); + // fallthrough + case 1: // No, dont switch items + gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; + break; + } +} + +void DisplayItemMustBeRemovedFirstMessage(u8 taskId) +{ + DisplayPartyMenuMessage(gText_RemoveMailBeforeItem, TRUE); + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; +} + +void RemoveItemToGiveFromBag(u16 item) +{ + if (gPartyMenu.action == PARTY_ACTION_GIVE_PC_ITEM) // Unused, never occurs + RemovePCItem(item, 1); + else + RemoveBagItem(item, 1); +} + +// Returns FALSE if there was no space to return the item +// but there always should be, and the return is ignored in all uses +bool8 ReturnGiveItemToBagOrPC(u16 item) +{ + if (gPartyMenu.action == PARTY_ACTION_GIVE_ITEM) + return AddBagItem(item, 1); + else + return AddPCItem(item, 1); +} + +void ChooseMonToGiveMailFromMailbox(void) +{ + InitPartyMenu(PARTY_MENU_TYPE_FIELD, PARTY_LAYOUT_SINGLE, PARTY_ACTION_GIVE_MAILBOX_MAIL, FALSE, PARTY_MSG_GIVE_TO_WHICH_MON, Task_HandleChooseMonInput, Mailbox_ReturnToMailListAfterDeposit); +} + +void TryGiveMailToSelectedMon(u8 taskId) +{ + struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; + struct MailStruct *mail; + + gPartyMenuUseExitCallback = FALSE; + mail = &gSaveBlock1Ptr->mail[gPlayerPcMenuManager.itemsAbove + 6 + gPlayerPcMenuManager.cursorPos]; + if (GetMonData(mon, MON_DATA_HELD_ITEM) != ITEM_NONE) + { + DisplayPartyMenuMessage(gText_PkmnHoldingItemCantHoldMail, TRUE); + } + else + { + GiveMailToMon2(mon, mail); + ClearMailStruct(mail); + DisplayPartyMenuMessage(gText_MailTransferredFromMailbox, TRUE); + } + ScheduleBgCopyTilemapToVram(2); + gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; +} + +void InitChooseHalfPartyForBattle(u8 maxBattlers) +{ + ClearSelectedPartyOrder(); + InitPartyMenu(PARTY_MENU_TYPE_CHOOSE_HALF, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_MON, FALSE, PARTY_MSG_CHOOSE_MON, Task_HandleChooseMonInput, gMain.savedCallback); + gPartyMenu.unk_8_6 = maxBattlers; + gPartyMenu.task = Task_ValidateChosenHalfParty; +} + +void ClearSelectedPartyOrder(void) +{ + memset(gSelectedOrderFromParty, 0, sizeof(gSelectedOrderFromParty)); +} + +u8 GetPartySlotEntryStatus(s8 slot) +{ + if (GetBattleEntryEligibility(&gPlayerParty[slot]) == FALSE) + return 2; + if (HasPartySlotAlreadyBeenSelected(slot + 1) == TRUE) + return 1; + return 0; +} + +#ifdef NONMATCHING +bool8 GetBattleEntryEligibility(struct Pokemon *mon) +{ + u16 species; + u16 i = 0; + + if (GetMonData(mon, MON_DATA_IS_EGG)) + return FALSE; + switch (gPartyMenu.unk_8_6) + { + default: + if (GetMonData(mon, MON_DATA_LEVEL) <= 30) + return TRUE; + return FALSE; + case 0: + if (GetMonData(mon, MON_DATA_HP) != 0) + return TRUE; + return FALSE; + case 1: + if (gSaveBlock2Ptr->battleTower.battleTowerLevelType != 0 // level 100 + || GetMonData(mon, MON_DATA_LEVEL) <= 50) + { + species = GetMonData(mon, MON_DATA_SPECIES); + // Although i is always 0, the compiler still computes the offset of + // gBattleTowerBannedSpecies[i] by shifting i. + // It's also in emerald, but for whatever reason it's generated. + for (; gBattleTowerBannedSpecies[i] != 0xFFFF; ++i) + if (gBattleTowerBannedSpecies[i] == species) + return FALSE; + return TRUE; + } + return FALSE; + } +} +#else +NAKED +bool8 GetBattleEntryEligibility(struct Pokemon *mon) +{ + asm_unified("push {r4,r5,lr}\n\ + adds r4, r0, 0\n\ + movs r5, 0\n\ + movs r1, 0x2D\n\ + bl GetMonData\n\ + cmp r0, 0\n\ + bne _0812757A\n\ + ldr r0, _08127580 @ =gPartyMenu\n\ + ldrb r0, [r0, 0x8]\n\ + lsrs r1, r0, 6\n\ + cmp r1, 0\n\ + beq _08127584\n\ + cmp r1, 0x1\n\ + beq _08127592\n\ + adds r0, r4, 0\n\ + movs r1, 0x38\n\ + bl GetMonData\n\ + cmp r0, 0x1E\n\ + bls _081275E0\n\ + _0812757A:\n\ + movs r0, 0\n\ + b _081275E2\n\ + .align 2, 0\n\ + _08127580: .4byte gPartyMenu\n\ + _08127584:\n\ + adds r0, r4, 0\n\ + movs r1, 0x39\n\ + bl GetMonData\n\ + cmp r0, 0\n\ + bne _081275E0\n\ + b _0812757A\n\ + _08127592:\n\ + ldr r0, _081275E8 @ =gSaveBlock2Ptr\n\ + ldr r0, [r0]\n\ + ldr r2, _081275EC @ =0x0000055c\n\ + adds r0, r2\n\ + ldrb r0, [r0]\n\ + ands r1, r0\n\ + cmp r1, 0\n\ + bne _081275AE\n\ + adds r0, r4, 0\n\ + movs r1, 0x38\n\ + bl GetMonData\n\ + cmp r0, 0x32\n\ + bhi _0812757A\n\ + _081275AE:\n\ + adds r0, r4, 0\n\ + movs r1, 0xB\n\ + bl GetMonData\n\ + lsls r0, 16\n\ + lsrs r4, r0, 16\n\ + ldr r3, _081275F0 @ =gBattleTowerBannedSpecies\n\ + lsls r1, r5, 1\n\ + adds r0, r1, r3\n\ + ldrh r0, [r0]\n\ + ldr r2, _081275F4 @ =0x0000ffff\n\ + cmp r0, r2\n\ + beq _081275E0\n\ + _081275C8:\n\ + adds r0, r1, r3\n\ + ldrh r0, [r0]\n\ + cmp r0, r4\n\ + beq _0812757A\n\ + adds r0, r5, 0x1\n\ + lsls r0, 16\n\ + lsrs r5, r0, 16\n\ + lsls r1, r5, 1\n\ + adds r0, r1, r3\n\ + ldrh r0, [r0]\n\ + cmp r0, r2\n\ + bne _081275C8\n\ + _081275E0:\n\ + movs r0, 0x1\n\ + _081275E2:\n\ + pop {r4,r5}\n\ + pop {r1}\n\ + bx r1\n\ + .align 2, 0\n\ + _081275E8: .4byte gSaveBlock2Ptr\n\ + _081275EC: .4byte 0x0000055c\n\ + _081275F0: .4byte gBattleTowerBannedSpecies\n\ + _081275F4: .4byte 0x0000ffff\n\ + "); +} +#endif + +u8 CheckBattleEntriesAndGetMessage(void) +{ + u8 i, j; + struct Pokemon *party = gPlayerParty; + u8 *order = gSelectedOrderFromParty; + + switch (gPartyMenu.unk_8_6) + { + case 1: + if (order[2] == 0) + return PARTY_MSG_THREE_MONS_ARE_NEEDED; + for (i = 0; i < 2; ++i) + { + sPartyMenuInternal->data[15] = GetMonData(&party[order[i] - 1], MON_DATA_SPECIES); + sPartyMenuInternal->data[14] = GetMonData(&party[order[i] - 1], MON_DATA_HELD_ITEM); + for (j = i + 1; j < 3; ++j) + { + if (sPartyMenuInternal->data[15] == GetMonData(&party[order[j] - 1], MON_DATA_SPECIES)) + return PARTY_MSG_MONS_CANT_BE_SAME; + if (sPartyMenuInternal->data[14] != ITEM_NONE && sPartyMenuInternal->data[14] == GetMonData(&party[order[j] - 1], MON_DATA_HELD_ITEM)) + return PARTY_MSG_NO_SAME_HOLD_ITEMS; + } + } + break; + case 2: + if (order[1] == 0) + return PARTY_MSG_TWO_MONS_ARE_NEEDED; + break; + } + return 0xFF; +} + +bool8 HasPartySlotAlreadyBeenSelected(u8 slot) +{ + u8 i; + + for (i = 0; i < NELEMS(gSelectedOrderFromParty); ++i) + if (gSelectedOrderFromParty[i] == slot) + return TRUE; + return FALSE; +} + +void Task_ValidateChosenHalfParty(u8 taskId) +{ + u8 msgId = CheckBattleEntriesAndGetMessage(); + + if (msgId != 0xFF) + { + PlaySE(SE_HAZURE); + DisplayPartyMenuStdMessage(msgId); + gTasks[taskId].func = Task_ContinueChoosingHalfParty; + } + else + { + if (gSelectedOrderFromParty[0] != 0) + { + PlaySE(SE_SELECT); + Task_ClosePartyMenu(taskId); + } + else + { + PlaySE(SE_HAZURE); + DisplayPartyMenuStdMessage(PARTY_MSG_NO_MON_FOR_BATTLE); + gTasks[taskId].func = Task_ContinueChoosingHalfParty; + } + } +} + +void Task_ContinueChoosingHalfParty(u8 taskId) +{ + if (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON)) + { + PlaySE(SE_SELECT); + DisplayPartyMenuStdMessage(PARTY_MSG_CHOOSE_MON); + gTasks[taskId].func = Task_HandleChooseMonInput; + } +} + +void sub_81277F4(u8 menuType, MainCallback callback) +{ + InitPartyMenu(menuType, + PARTY_LAYOUT_SINGLE, + PARTY_ACTION_CHOOSE_MON, + FALSE, + PARTY_MSG_CHOOSE_MON, + Task_HandleChooseMonInput, + callback); +} + +void ChooseMonForMoveTutor(void) +{ + if (gSpecialVar_0x8005 < TUTOR_MOVE_COUNT) + { + InitPartyMenu(PARTY_MENU_TYPE_FIELD, + PARTY_LAYOUT_SINGLE, + PARTY_ACTION_MOVE_TUTOR, + FALSE, + PARTY_MSG_TEACH_WHICH_MON, + Task_HandleChooseMonInput, + CB2_ReturnToFieldContinueScriptPlayMapMusic); + } + else + { + InitPartyMenu(PARTY_MENU_TYPE_FIELD, + PARTY_LAYOUT_SINGLE, + PARTY_ACTION_MOVE_TUTOR, + FALSE, + PARTY_MSG_NONE, + TryTutorSelectedMon, + CB2_ReturnToFieldContinueScriptPlayMapMusic); + gPartyMenu.slotId = gSpecialVar_0x8007; + } +} + +void ChooseMonForWirelessMinigame(void) +{ + InitPartyMenu(PARTY_MENU_TYPE_MINIGAME, PARTY_LAYOUT_SINGLE, PARTY_ACTION_MINIGAME, FALSE, PARTY_MSG_CHOOSE_MON_OR_CANCEL, Task_HandleChooseMonInput, CB2_ReturnToFieldContinueScriptPlayMapMusic); +} + +u8 GetPartyLayoutFromBattleType(void) +{ + if (IsDoubleBattle() == FALSE) + return PARTY_LAYOUT_SINGLE; + if (IsMultiBattle() == TRUE) + return PARTY_LAYOUT_MULTI; + return PARTY_LAYOUT_DOUBLE; +} + +void OpenPartyMenuInTutorialBattle(u8 partyAction) +{ + if (!sub_80EB2E0(8) && (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)) + { + InitPartyMenu(PARTY_MENU_TYPE_IN_BATTLE, + GetPartyLayoutFromBattleType(), + partyAction, + FALSE, + PARTY_MSG_NONE, + sub_8120C3C, + SetCB2ToReshowScreenAfterMenu); + sub_80EB2F4(8); + } + else + { + InitPartyMenu(PARTY_MENU_TYPE_IN_BATTLE, + GetPartyLayoutFromBattleType(), + partyAction, + FALSE, + PARTY_MSG_CHOOSE_MON, + Task_HandleChooseMonInput, + SetCB2ToReshowScreenAfterMenu); + } + nullsub_44(); + UpdatePartyToBattleOrder(); +} + +void OpenPartyMenuInBattle(void) +{ + InitPartyMenu(PARTY_MENU_TYPE_IN_BATTLE, GetPartyLayoutFromBattleType(), PARTY_ACTION_CHOOSE_MON, FALSE, PARTY_MSG_CHOOSE_MON, sub_8120EBC, SetCB2ToReshowScreenAfterMenu); + nullsub_44(); + UpdatePartyToBattleOrder(); +} + +void ChooseMonForInBattleItem(void) +{ + InitPartyMenu(PARTY_MENU_TYPE_IN_BATTLE, GetPartyLayoutFromBattleType(), PARTY_ACTION_REUSABLE_ITEM, FALSE, PARTY_MSG_USE_ON_WHICH_MON, sub_8120FCC, sub_8107ECC); + nullsub_44(); + UpdatePartyToBattleOrder(); +} + +void sub_81279E0(void) +{ + if (!sub_80EB2E0(8) && (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)) + { + InitPartyMenu(PARTY_MENU_TYPE_IN_BATTLE, + GetPartyLayoutFromBattleType(), + PARTY_ACTION_USE_ITEM, + FALSE, + PARTY_MSG_NONE, + sub_8120C3C, + sub_8107ECC); + sub_80EB2F4(8); + } + else + { + MainCallback callback; + + if (GetPocketByItemId(gSpecialVar_ItemId) == POCKET_BERRY_POUCH) + callback = CB2_ReturnToBerryPouchMenu; + else + callback = sub_8107ECC; + InitPartyMenu(PARTY_MENU_TYPE_IN_BATTLE, + GetPartyLayoutFromBattleType(), + PARTY_ACTION_USE_ITEM, + FALSE, + PARTY_MSG_USE_ON_WHICH_MON, + Task_HandleChooseMonInput, + callback); + } + nullsub_44(); + UpdatePartyToBattleOrder(); +} + +u8 GetPartyMenuActionsTypeInBattle(struct Pokemon *mon) +{ + if (GetMonData(&gPlayerParty[1], MON_DATA_SPECIES) == SPECIES_NONE || GetMonData(mon, MON_DATA_IS_EGG)) + return ACTIONS_SUMMARY_ONLY; + else if (gPartyMenu.action == PARTY_ACTION_SEND_OUT) + return ACTIONS_SEND_OUT; + else + return ACTIONS_SHIFT; +} + +bool8 TrySwitchInPokemon(void) +{ + u8 slot = GetCursorSelectionMonId(); + u8 newSlot; + u8 i; + + // In a multi battle, slots 1, 4, and 5 are the partner's pokemon + if (IsMultiBattle() == TRUE && (slot == 1 || slot == 4 || slot == 5)) + { + StringCopy(gStringVar1, GetTrainerPartnerName()); + StringExpandPlaceholders(gStringVar4, gText_CantSwitchWithAlly); + return FALSE; + } + if (GetMonData(&gPlayerParty[slot], MON_DATA_HP) == 0) + { + GetMonNickname(&gPlayerParty[slot], gStringVar1); + StringExpandPlaceholders(gStringVar4, gText_PkmnHasNoEnergy); + return FALSE; + } + for (i = 0; i < gBattlersCount; ++i) + { + if (GetBattlerSide(i) == B_SIDE_PLAYER && GetPartyIdFromBattleSlot(slot) == gBattlerPartyIndexes[i]) + { + GetMonNickname(&gPlayerParty[slot], gStringVar1); + StringExpandPlaceholders(gStringVar4, gText_PkmnAlreadyInBattle); + return FALSE; + } + } + if (GetMonData(&gPlayerParty[slot], MON_DATA_IS_EGG)) + { + StringExpandPlaceholders(gStringVar4, gText_EggCantBattle); + return FALSE; + } + if (GetPartyIdFromBattleSlot(slot) == gBattleStruct->field_8B) + { + GetMonNickname(&gPlayerParty[slot], gStringVar1); + StringExpandPlaceholders(gStringVar4, gText_PkmnAlreadySelected); + return FALSE; + } + if (gPartyMenu.action == PARTY_ACTION_ABILITY_PREVENTS) + { + SetMonPreventsSwitchingString(); + return FALSE; + } + if (gPartyMenu.action == PARTY_ACTION_CANT_SWITCH) + { + u8 currBattler = gBattlerInMenuId; + + GetMonNickname(&gPlayerParty[GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[currBattler])], gStringVar1); + StringExpandPlaceholders(gStringVar4, gText_PkmnCantSwitchOut); + return FALSE; + } + gSelectedMonPartyId = GetPartyIdFromBattleSlot(slot); + gPartyMenuUseExitCallback = TRUE; + newSlot = GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[gBattlerInMenuId]); + SwitchPartyMonSlots(newSlot, slot); + SwapPartyPokemon(&gPlayerParty[newSlot], &gPlayerParty[slot]); + return TRUE; +} + +void BufferBattlePartyCurrentOrder(void) +{ + BufferBattlePartyOrder(gBattlePartyCurrentOrder, GetPlayerFlankId()); +} + +void BufferBattlePartyOrder(u8 *partyBattleOrder, u8 flankId) +{ + u8 partyIds[PARTY_SIZE]; + s32 i, j; + + if (IsMultiBattle() == TRUE) + { + // Party ids are packed in 4 bits at a time + // i.e. the party id order below would be 0, 3, 5, 4, 2, 1, and the two parties would be 0,5,4 and 3,2,1 + if (flankId != 0) + { + partyBattleOrder[0] = 0 | (3 << 4); + partyBattleOrder[1] = 5 | (4 << 4); + partyBattleOrder[2] = 2 | (1 << 4); + } + else + { + partyBattleOrder[0] = 3 | (0 << 4); + partyBattleOrder[1] = 2 | (1 << 4); + partyBattleOrder[2] = 5 | (4 << 4); + } + return; + } + else if (IsDoubleBattle() == FALSE) + { + j = 1; + partyIds[0] = gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (i != partyIds[0]) + { + partyIds[j] = i; + ++j; + } + } + } + else + { + j = 2; + partyIds[0] = gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]; + partyIds[1] = gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT)]; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (i != partyIds[0] && i != partyIds[1]) + { + partyIds[j] = i; + ++j; + } + } + } + for (i = 0; i < (s32)NELEMS(gBattlePartyCurrentOrder); ++i) + partyBattleOrder[i] = (partyIds[0 + (i * 2)] << 4) | partyIds[1 + (i * 2)]; +} + +void BufferBattlePartyCurrentOrderBySide(u8 battlerId, u8 flankId) +{ + BufferBattlePartyOrderBySide(gBattleStruct->field_60[battlerId], flankId, battlerId); +} + +// when GetBattlerSide(battlerId) == B_SIDE_PLAYER, this function is identical the one above +void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battlerId) +{ + u8 partyIndexes[PARTY_SIZE]; + s32 i, j; + u8 leftBattler; + u8 rightBattler; + + if (GetBattlerSide(battlerId) == B_SIDE_PLAYER) + { + leftBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + rightBattler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); + } + else + { + leftBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + rightBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); + } + if (IsMultiBattle() == TRUE) + { + if (flankId != 0) + { + partyBattleOrder[0] = 0 | (3 << 4); + partyBattleOrder[1] = 5 | (4 << 4); + partyBattleOrder[2] = 2 | (1 << 4); + } + else + { + partyBattleOrder[0] = 3 | (0 << 4); + partyBattleOrder[1] = 2 | (1 << 4); + partyBattleOrder[2] = 5 | (4 << 4); + } + return; + } + else if (IsDoubleBattle() == FALSE) + { + j = 1; + partyIndexes[0] = gBattlerPartyIndexes[leftBattler]; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (i != partyIndexes[0]) + { + partyIndexes[j] = i; + ++j; + } + } + } + else + { + j = 2; + partyIndexes[0] = gBattlerPartyIndexes[leftBattler]; + partyIndexes[1] = gBattlerPartyIndexes[rightBattler]; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (i != partyIndexes[0] && i != partyIndexes[1]) + { + partyIndexes[j] = i; + ++j; + } + } + } + for (i = 0; i < 3; ++i) + partyBattleOrder[i] = (partyIndexes[0 + (i * 2)] << 4) | partyIndexes[1 + (i * 2)]; +} + +void SwitchPartyOrderLinkMulti(u8 battlerId, u8 slot, u8 slot2) +{ + u8 partyIds[PARTY_SIZE]; + u8 tempSlot = 0; + s32 i, j; + u8 *partyBattleOrder; + u8 partyIdBuffer; + + if (IsMultiBattle()) + { + partyBattleOrder = gBattleStruct->field_60[battlerId]; + for (i = j = 0; i < 3; ++j, ++i) + { + partyIds[j] = partyBattleOrder[i] >> 4; + j++; + partyIds[j] = partyBattleOrder[i] & 0xF; + } + partyIdBuffer = partyIds[slot2]; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (partyIds[i] == slot) + { + tempSlot = partyIds[i]; + partyIds[i] = partyIdBuffer; + break; + } + } + if (i != PARTY_SIZE) + { + partyIds[slot2] = tempSlot; + partyBattleOrder[0] = (partyIds[0] << 4) | partyIds[1]; + partyBattleOrder[1] = (partyIds[2] << 4) | partyIds[3]; + partyBattleOrder[2] = (partyIds[4] << 4) | partyIds[5]; + } + } +} + +u8 GetPartyIdFromBattleSlot(u8 slot) +{ + u8 modResult = slot & 1; + u8 retVal; + + slot /= 2; + if (modResult != 0) + retVal = gBattlePartyCurrentOrder[slot] & 0xF; + else + retVal = gBattlePartyCurrentOrder[slot] >> 4; + return retVal; +} + +void SetPartyIdAtBattleSlot(u8 slot, u8 setVal) +{ + bool32 modResult = slot & 1; + + slot /= 2; + if (modResult != 0) + gBattlePartyCurrentOrder[slot] = (gBattlePartyCurrentOrder[slot] & 0xF0) | setVal; + else + gBattlePartyCurrentOrder[slot] = (gBattlePartyCurrentOrder[slot] & 0xF) | (setVal << 4); +} + +void SwitchPartyMonSlots(u8 slot, u8 slot2) +{ + u8 partyId = GetPartyIdFromBattleSlot(slot); + + SetPartyIdAtBattleSlot(slot, GetPartyIdFromBattleSlot(slot2)); + SetPartyIdAtBattleSlot(slot2, partyId); +} + +u8 GetPartyIdFromBattlePartyId(u8 battlePartyId) +{ + u8 i, j; + + for (j = i = 0; i < (s32)NELEMS(gBattlePartyCurrentOrder); ++j, ++i) + { + if ((gBattlePartyCurrentOrder[i] >> 4) != battlePartyId) + { + ++j; + if ((gBattlePartyCurrentOrder[i] & 0xF) == battlePartyId) + return j; + } + else + { + return j; + } + } + return 0; +} + +void UpdatePartyToBattleOrder(void) +{ + struct Pokemon *partyBuffer = Alloc(sizeof(gPlayerParty)); + u8 i; + + memcpy(partyBuffer, gPlayerParty, sizeof(gPlayerParty)); + for (i = 0; i < PARTY_SIZE; ++i) + memcpy(&gPlayerParty[GetPartyIdFromBattlePartyId(i)], &partyBuffer[i], sizeof(struct Pokemon)); + Free(partyBuffer); +} + +void UpdatePartyToFieldOrder(void) +{ + struct Pokemon *partyBuffer = Alloc(sizeof(gPlayerParty)); + u8 i; + + memcpy(partyBuffer, gPlayerParty, sizeof(gPlayerParty)); + for (i = 0; i < PARTY_SIZE; ++i) + memcpy(&gPlayerParty[GetPartyIdFromBattleSlot(i)], &partyBuffer[i], sizeof(struct Pokemon)); + Free(partyBuffer); +} + +// not used +void SwitchAliveMonIntoLeadSlot(void) +{ + u8 i; + struct Pokemon *mon; + u8 partyId; + + for (i = 1; i < PARTY_SIZE; ++i) + { + mon = &gPlayerParty[GetPartyIdFromBattleSlot(i)]; + if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE && GetMonData(mon, MON_DATA_HP) != 0) + { + partyId = GetPartyIdFromBattleSlot(0); + SwitchPartyMonSlots(0, i); + SwapPartyPokemon(&gPlayerParty[partyId], mon); + break; + } + } +} + +void CB2_SetUpExitToBattleScreen(void) +{ + CB2_SetUpReshowBattleScreenAfterMenu(); + SetMainCallback2(SetCB2ToReshowScreenAfterMenu); +} + +void ShowPartyMenuToShowcaseMultiBattleParty(void) +{ + InitPartyMenu(PARTY_MENU_TYPE_MULTI_SHOWCASE, PARTY_LAYOUT_MULTI_SHOWCASE, PARTY_ACTION_CHOOSE_MON, FALSE, PARTY_MSG_NONE, Task_InitMultiPartnerPartySlideIn, gMain.savedCallback); +} + +#define tXPos data[0] + +void Task_InitMultiPartnerPartySlideIn(u8 taskId) +{ + // The first slide step also sets the sprites offscreen + gTasks[taskId].tXPos = 256; + SlideMultiPartyMenuBoxSpritesOneStep(taskId); + ChangeBgX(2, 0x10000, 0); + gTasks[taskId].func = Task_MultiPartnerPartySlideIn; +} + +void Task_MultiPartnerPartySlideIn(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + u8 i; + + if (!gPaletteFade.active) + { + tXPos -= 8; + SlideMultiPartyMenuBoxSpritesOneStep(taskId); + if (tXPos == 0) + { + for (i = 3; i < PARTY_SIZE; ++i) + { + if (gMultiPartnerParty[i - MULTI_PARTY_SIZE].species != SPECIES_NONE) + AnimateSelectedPartyIcon(sPartyMenuBoxes[i].monSpriteId, 0); + } + PlaySE(SE_W231); // The Harden SE plays once the partners party mons have slid on screen + gTasks[taskId].func = Task_WaitAfterMultiPartnerPartySlideIn; + } + } +} + +void Task_WaitAfterMultiPartnerPartySlideIn(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + // data[0] used as a timer afterwards rather than the x pos + if (++data[0] == 256) + Task_ClosePartyMenu(taskId); +} + +void MoveMultiPartyMenuBoxSprite(u8 spriteId, s16 x) +{ + if (x >= 0) + gSprites[spriteId].pos2.x = x; +} + +void SlideMultiPartyMenuBoxSpritesOneStep(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + u8 i; + + for (i = 3; i < PARTY_SIZE; ++i) + { + if (gMultiPartnerParty[i - MULTI_PARTY_SIZE].species != SPECIES_NONE) + { + MoveMultiPartyMenuBoxSprite(sPartyMenuBoxes[i].monSpriteId, tXPos - 8); + MoveMultiPartyMenuBoxSprite(sPartyMenuBoxes[i].itemSpriteId, tXPos - 8); + MoveMultiPartyMenuBoxSprite(sPartyMenuBoxes[i].pokeballSpriteId, tXPos - 8); + MoveMultiPartyMenuBoxSprite(sPartyMenuBoxes[i].statusSpriteId, tXPos - 8); + } + } + ChangeBgX(2, 0x800, 1); +} + +#undef tXpos + +void ChooseMonForDaycare(void) +{ + gFieldCallback2 = CB2_FadeFromPartyMenu; + InitPartyMenu(PARTY_MENU_TYPE_DAYCARE, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_MON, FALSE, PARTY_MSG_CHOOSE_MON_2, Task_HandleChooseMonInput, CB2_ReturnToField); +} + +void ChoosePartyMonByMenuType(u8 menuType) +{ + gFieldCallback2 = CB2_FadeFromPartyMenu; + InitPartyMenu(menuType, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_AND_CLOSE, FALSE, PARTY_MSG_CHOOSE_MON, Task_HandleChooseMonInput, CB2_ReturnToField); +} + +bool8 CB2_FadeFromPartyMenu(void) +{ + sub_807DC00(); + CreateTask(Task_PartyMenuWaitForFade, 10); + return TRUE; +} + +void Task_PartyMenuWaitForFade(u8 taskId) +{ + if (IsWeatherNotFadingIn()) + { + DestroyTask(taskId); + ScriptContext2_Disable(); + EnableBothScriptContexts(); + } +} diff --git a/src/player_pc.c b/src/player_pc.c index c3dc81dd2..00d41abe6 100644 --- a/src/player_pc.c +++ b/src/player_pc.c @@ -38,7 +38,7 @@ static EWRAM_DATA const u8 *sItemOrder = NULL; static EWRAM_DATA u8 sTopMenuItemCount = 0; EWRAM_DATA struct PlayerPCItemPageStruct gPlayerPcMenuManager = {}; -#define SELECTED_MAIL (gSaveBlock1Ptr->mail[PC_MAIL_NUM(gPlayerPcMenuManager.scrollOffset) + gPlayerPcMenuManager.selectedRow]) +#define SELECTED_MAIL (gSaveBlock1Ptr->mail[PC_MAIL_NUM(gPlayerPcMenuManager.itemsAbove) + gPlayerPcMenuManager.cursorPos]) static void Task_DrawPlayerPcTopMenu(u8 taskId); static void Task_TopMenuHandleInput(u8 taskId); @@ -234,8 +234,8 @@ static void Task_PlayerPcMailbox(u8 taskId) } else { - gPlayerPcMenuManager.selectedRow = 0; - gPlayerPcMenuManager.scrollOffset = 0; + gPlayerPcMenuManager.cursorPos = 0; + gPlayerPcMenuManager.itemsAbove = 0; PCMailCompaction(); Task_SetPageItemVars(taskId); if (gPlayerPcMenuManager.unk_9 == 0) @@ -469,7 +469,7 @@ static void Task_MailboxPcHandleInput(u8 taskId) if (!gPaletteFade.active) { input = ListMenu_ProcessInput(tListMenuTaskId); - ListMenuGetScrollAndRow(tListMenuTaskId, &gPlayerPcMenuManager.scrollOffset, &gPlayerPcMenuManager.selectedRow); + ListMenuGetScrollAndRow(tListMenuTaskId, &gPlayerPcMenuManager.itemsAbove, &gPlayerPcMenuManager.cursorPos); switch (input) { case -1: @@ -483,7 +483,7 @@ static void Task_MailboxPcHandleInput(u8 taskId) PlaySE(SE_SELECT); MailboxPC_RemoveWindow(0); MailboxPC_RemoveWindow(1); - DestroyListMenuTask(tListMenuTaskId, &gPlayerPcMenuManager.scrollOffset, &gPlayerPcMenuManager.selectedRow); + DestroyListMenuTask(tListMenuTaskId, &gPlayerPcMenuManager.itemsAbove, &gPlayerPcMenuManager.cursorPos); ScheduleBgCopyTilemapToVram(0); RemoveScrollIndicatorArrowPair(gPlayerPcMenuManager.scrollIndicatorId); gTasks[taskId].func = Task_PrintWhatToDoWithSelectedMail; @@ -641,10 +641,10 @@ static void Task_TryPutMailInBag_DestroyMsgIfSuccessful(u8 taskId) ClearMailStruct(mail); PCMailCompaction(); gPlayerPcMenuManager.count--; - if (gPlayerPcMenuManager.count < gPlayerPcMenuManager.pageItems + gPlayerPcMenuManager.scrollOffset) + if (gPlayerPcMenuManager.count < gPlayerPcMenuManager.pageItems + gPlayerPcMenuManager.itemsAbove) { - if (gPlayerPcMenuManager.scrollOffset != 0) - gPlayerPcMenuManager.scrollOffset--; + if (gPlayerPcMenuManager.itemsAbove != 0) + gPlayerPcMenuManager.itemsAbove--; } Task_SetPageItemVars(taskId); } @@ -693,10 +693,10 @@ static void CB2_ReturnToMailboxPc_UpdateScrollVariables(void) PCMailCompaction(); if (count != gPlayerPcMenuManager.count) { - if (gPlayerPcMenuManager.count < gPlayerPcMenuManager.pageItems + gPlayerPcMenuManager.scrollOffset) + if (gPlayerPcMenuManager.count < gPlayerPcMenuManager.pageItems + gPlayerPcMenuManager.itemsAbove) { - if (gPlayerPcMenuManager.scrollOffset != 0) - gPlayerPcMenuManager.scrollOffset--; + if (gPlayerPcMenuManager.itemsAbove != 0) + gPlayerPcMenuManager.itemsAbove--; } } Task_SetPageItemVars(taskId); @@ -708,7 +708,7 @@ static void CB2_ReturnToMailboxPc_UpdateScrollVariables(void) sub_807DC00(); } -void CB2_PlayerPC_ReturnFromPartyMenu(void) +void Mailbox_ReturnToMailListAfterDeposit(void) { gFieldCallback = CB2_ReturnToMailboxPc_UpdateScrollVariables; SetMainCallback2(CB2_ReturnToField); diff --git a/src/pokemon.c b/src/pokemon.c index 9aaddc142..33a3f387e 100644 --- a/src/pokemon.c +++ b/src/pokemon.c @@ -4117,7 +4117,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov if (sp34 != 4) { gAbsentBattlerFlags &= ~gBitTable[sp34]; - CopyPlayerPartyMonToBattleData(sp34, pokemon_order_func(gBattlerPartyIndexes[sp34])); + CopyPlayerPartyMonToBattleData(sp34, GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[sp34])); if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER && gBattleResults.numRevivesUsed < 255) gBattleResults.numRevivesUsed++; } @@ -4405,7 +4405,7 @@ static bool8 HealStatusConditions(struct Pokemon *mon, u32 unused, u32 healMask, } } -bool8 PokemonUseItemEffects2(struct Pokemon *mon, u16 item, u8 partyIndex, u8 moveIndex) +bool8 PokemonItemUseNoEffect(struct Pokemon *mon, u16 item, u8 partyIndex, u8 moveIndex) { u32 data; s32 tmp; @@ -5179,7 +5179,7 @@ void EvolutionRenameMon(struct Pokemon *mon, u16 oldSpecies, u16 newSpecies) SetMonData(mon, MON_DATA_NICKNAME, gSpeciesNames[newSpecies]); } -bool8 sub_80435E0(void) +bool8 GetPlayerFlankId(void) { bool8 retVal = FALSE; switch (gLinkPlayers[GetMultiplayerId()].id) @@ -5813,11 +5813,11 @@ void SetMonPreventsSwitchingString(void) gBattleTextBuff1[4] = B_BUFF_EOS; if (GetBattlerSide(gBattleStruct->battlerPreventingSwitchout) == B_SIDE_PLAYER) - gBattleTextBuff1[3] = pokemon_order_func(gBattlerPartyIndexes[gBattleStruct->battlerPreventingSwitchout]); + gBattleTextBuff1[3] = GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[gBattleStruct->battlerPreventingSwitchout]); else gBattleTextBuff1[3] = gBattlerPartyIndexes[gBattleStruct->battlerPreventingSwitchout]; - PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff2, gBattlerInMenuId, pokemon_order_func(gBattlerPartyIndexes[gBattlerInMenuId])) + PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff2, gBattlerInMenuId, GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[gBattlerInMenuId])) BattleStringExpandPlaceholders(gText_PkmnsXPreventsSwitching, gStringVar4); } -- cgit v1.2.3 From aa0d8cdaa0b57ed4b625dad321886d52d2b6dbb7 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Sat, 23 Nov 2019 16:51:05 -0500 Subject: battle_message 1 --- src/battle_message.c | 2184 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2184 insertions(+) create mode 100644 src/battle_message.c (limited to 'src') diff --git a/src/battle_message.c b/src/battle_message.c new file mode 100644 index 000000000..2924dc520 --- /dev/null +++ b/src/battle_message.c @@ -0,0 +1,2184 @@ +#include "global.h" +#include "battle_string_ids.h" +#include "battle.h" +#include "battle_anim.h" +#include "string_util.h" +#include "text.h" +#include "window.h" +#include "strings.h" +#include "battle_message.h" +#include "link.h" +#include "event_scripts.h" +#include "event_data.h" +#include "item.h" +#include "battle_tower.h" +#include "trainer_tower.h" +#include "battle_setup.h" +#include "constants/moves.h" +#include "constants/items.h" +#include "constants/trainer_classes.h" + +struct BattleWindowText +{ + u8 fillValue; + u8 fontId; + u8 x; + u8 y; + u8 letterSpacing; + u8 lineSpacing; + u8 speed; + u8 fgColor; + u8 bgColor; + u8 shadowColor; +}; + +EWRAM_DATA u8 sBattlerAbilities[MAX_BATTLERS_COUNT] = {}; +EWRAM_DATA struct BattleMsgData *gBattleMsgDataPtr = NULL; + +void ChooseMoveUsedParticle(u8 *textPtr); +void ChooseTypeOfMoveUsedString(u8 *textPtr); +void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst); + +const u8 gUnknown_83FB218[] = _(""); // @ 83FB218 +const u8 gUnknown_83FB219[] = _("{B_TRAINER1_LOSE_TEXT}"); // @ 83FB219 +const u8 gUnknown_83FB21C[] = _("{B_TRAINER2_CLASS}"); // @ 83FB21C +const u8 gUnknown_83FB21F[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON1_NAME}, come back!"); // @ 83FB21F +const u8 gUnknown_83FB232[] = _("{B_TRAINER1_WIN_TEXT}"); // @ 83FB232 +const u8 gUnknown_83FB235[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON2_NAME}, come back!"); // @ 83FB235 +const u8 gUnknown_83FB248[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON1_NAME} and\n{B_OPPONENT_MON2_NAME}, come back!"); // @ 83FB248 +const u8 gUnknown_83FB262[] = _("{B_TRAINER2_NAME}"); // @ 83FB262 +const u8 gUnknown_83FB265[] = _("{B_BUFF1} gained{B_BUFF2}\n{B_TRAINER2_LOSE_TEXT} EXP. Points!\p"); // @ 83FB265 +const u8 gUnknown_83FB282[] = _(""); // @ 83FB282 +const u8 gUnknown_83FB283[] = _(" a boosted"); // @ 83FB283 +const u8 gUnknown_83FB28E[] = _("{B_BUFF1} grew to\nLV. {B_BUFF2}!{WAIT_SE}\p"); // @ 83FB28E +const u8 gUnknown_83FB2A4[] = _("{B_BUFF1} learned\n{B_BUFF2}!{WAIT_SE}\p"); // @ 83FB2A4 +const u8 gUnknown_83FB2B6[] = _("{B_BUFF1} is trying to\nlearn {B_BUFF2}.\p"); // @ 83FB2B6 +const u8 gUnknown_83FB2D1[] = _("But, {B_BUFF1} can't learn\nmore than four moves.\p"); // @ 83FB2D1 +const u8 gUnknown_83FB2FC[] = _("Delete a move to make\nroom for {B_BUFF2}?"); // @ 83FB2FC +const u8 gUnknown_83FB31F[] = _("{B_BUFF1} forgot\n{B_BUFF2}.\p"); // @ 83FB31F +const u8 gUnknown_83FB32E[] = _("{PAUSE 32}Stop learning\n{B_BUFF2}?"); // @ 83FB32E +const u8 gUnknown_83FB343[] = _("{B_BUFF1} did not learn\n{B_BUFF2}.\p"); // @ 83FB343 +const u8 gUnknown_83FB359[] = _("Use next POKéMON?"); // @ 83FB359 +const u8 gUnknown_83FB36B[] = _("{B_ATK_NAME_WITH_PREFIX}'s\nattack missed!"); // @ 83FB36B +const u8 gUnknown_83FB37F[] = _("{B_DEF_NAME_WITH_PREFIX}\nprotected itself!"); // @ 83FB37F +const u8 gUnknown_83FB394[] = _("{B_DEF_NAME_WITH_PREFIX} avoided\ndamage with {B_DEF_ABILITY}!"); // @ 83FB394 +const u8 gUnknown_83FB3AF[] = _("{B_DEF_NAME_WITH_PREFIX} makes GROUND\nmoves miss with {B_DEF_ABILITY}!"); // @ 83FB3AF +const u8 gUnknown_83FB3D3[] = _("{B_DEF_NAME_WITH_PREFIX} avoided\nthe attack!"); // @ 83FB3D3 +const u8 gUnknown_83FB3EA[] = _("It doesn't affect\n{B_DEF_NAME_WITH_PREFIX}…"); // @ 83FB3EA +const u8 gUnknown_83FB400[] = _("{B_ATK_NAME_WITH_PREFIX}\nfainted!\p"); // @ 83FB400 +const u8 gUnknown_83FB40D[] = _("{B_DEF_NAME_WITH_PREFIX}\nfainted!\p"); // @ 83FB40D +const u8 gUnknown_83FB41A[] = _("{B_PLAYER_NAME} got ¥{B_BUFF1}\nfor winning!\p"); // @ 83FB41A +const u8 gUnknown_83FB433[] = _("{B_PLAYER_NAME} is out of\nusable POKéMON!\p"); // @ 83FB433 +const u8 gUnknown_83FB451[] = _("{B_PLAYER_NAME} panicked and lost ¥{B_BUFF1}…\p… … … …\p{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); // @ 83FB451 +const u8 gUnknown_83FB484[] = _("{B_PLAYER_NAME} is out of\nusable POKéMON!\pPlayer lost against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!{PAUSE_UNTIL_PRESS}"); // @ 83FB484 +const u8 gUnknown_83FB4BE[] = _("{B_PLAYER_NAME} paid ¥{B_BUFF1} as the prize\nmoney…\p… … … …\p{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); // @ 83FB4BE +const u8 gUnknown_83FB4F7[] = _("{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); // @ 83FB4F7 +const u8 gUnknown_83FB508[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} prevents\nescape with {B_SCR_ACTIVE_ABILITY}!\p"); // @ 83FB508 +const u8 gUnknown_83FB525[] = _("Can't escape!\p"); // @ 83FB525 +const u8 gUnknown_83FB534[] = _("{B_ATK_NAME_WITH_PREFIX} can't escape!"); // @ 83FB534 +const u8 gUnknown_83FB545[] = _("Hit {B_BUFF1} time(s)!"); // @ 83FB545 +const u8 gUnknown_83FB555[] = _("{B_EFF_NAME_WITH_PREFIX}\nfell asleep!"); // @ 83FB555 +const u8 gUnknown_83FB565[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade {B_EFF_NAME_WITH_PREFIX} sleep!"); // @ 83FB565 +const u8 gUnknown_83FB57C[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready asleep!"); // @ 83FB57C +const u8 gUnknown_83FB592[] = _("{B_ATK_NAME_WITH_PREFIX} is\nalready asleep!"); // @ 83FB592 +const u8 gUnknown_83FB5A8[] = _("{B_DEF_NAME_WITH_PREFIX}\nwasn't affected!"); // @ 83FB5A8 +const u8 gUnknown_83FB5BC[] = _("{B_EFF_NAME_WITH_PREFIX}\nwas poisoned!"); // @ 83FB5BC +const u8 gUnknown_83FB5CD[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\npoisoned {B_EFF_NAME_WITH_PREFIX}!"); // @ 83FB5CD +const u8 gUnknown_83FB5E2[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby poison!"); // @ 83FB5E2 +const u8 gUnknown_83FB5F8[] = _("{B_DEF_NAME_WITH_PREFIX} is already\npoisoned."); // @ 83FB5F8 +const u8 gUnknown_83FB610[] = _("{B_EFF_NAME_WITH_PREFIX} is badly\npoisoned!"); // @ 83FB610 +const u8 gUnknown_83FB626[] = _("{B_DEF_NAME_WITH_PREFIX} had its\nenergy drained!"); // @ 83FB626 +const u8 gUnknown_83FB641[] = _("{B_EFF_NAME_WITH_PREFIX} was burned!"); // @ 83FB641 +const u8 gUnknown_83FB650[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nburned {B_EFF_NAME_WITH_PREFIX}!"); // @ 83FB650 +const u8 gUnknown_83FB663[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby its burn!"); // @ 83FB663 +const u8 gUnknown_83FB67B[] = _("{B_DEF_NAME_WITH_PREFIX} already\nhas a burn."); // @ 83FB67B +const u8 gUnknown_83FB692[] = _("{B_EFF_NAME_WITH_PREFIX} was\nfrozen solid!"); // @ 83FB692 +const u8 gUnknown_83FB6A7[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nfroze {B_EFF_NAME_WITH_PREFIX} solid!"); // @ 83FB6A7 +const u8 gUnknown_83FB6BF[] = _("{B_ATK_NAME_WITH_PREFIX} is\nfrozen solid!"); // @ 83FB6BF +const u8 gUnknown_83FB6D3[] = _("{B_DEF_NAME_WITH_PREFIX} was\ndefrosted!"); // @ 83FB6D3 +const u8 gUnknown_83FB6E5[] = _("{B_ATK_NAME_WITH_PREFIX} was\ndefrosted!"); // @ 83FB6E5 +const u8 gUnknown_83FB6F7[] = _("{B_ATK_NAME_WITH_PREFIX} was\ndefrosted by {B_CURRENT_MOVE}!"); // @ 83FB6F7 +const u8 gUnknown_83FB70F[] = _("{B_EFF_NAME_WITH_PREFIX} is paralyzed!\nIt may be unable to move!"); // @ 83FB70F +const u8 gUnknown_83FB73A[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nparalyzed {B_EFF_NAME_WITH_PREFIX}!\lIt may be unable to move!"); // @ 83FB73A +const u8 gUnknown_83FB76A[] = _("{B_ATK_NAME_WITH_PREFIX} is paralyzed!\nIt can't move!"); // @ 83FB76A +const u8 gUnknown_83FB78A[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready paralyzed!"); // @ 83FB78A +const u8 gUnknown_83FB7A3[] = _("{B_DEF_NAME_WITH_PREFIX} was\nhealed of paralysis!"); // @ 83FB7A3 +const u8 gUnknown_83FB7BF[] = _("{B_DEF_NAME_WITH_PREFIX}'s\ndream was eaten!"); // @ 83FB7BF +const u8 gUnknown_83FB7D5[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\nwon't go higher!"); // @ 83FB7D5 +const u8 gUnknown_83FB7EE[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\nwon't go lower!"); // @ 83FB7EE +const u8 gUnknown_83FB806[] = _("Your team's {B_BUFF1}\nstopped working!"); // @ 83FB806 +const u8 gUnknown_83FB826[] = _("The foe's {B_BUFF1}\nstopped working!"); // @ 83FB826 +const u8 gUnknown_83FB844[] = _("{B_ATK_NAME_WITH_PREFIX} is\nconfused!"); // @ 83FB844 +const u8 gUnknown_83FB854[] = _("{B_ATK_NAME_WITH_PREFIX} snapped\nout of confusion!"); // @ 83FB854 +const u8 gUnknown_83FB871[] = _("{B_EFF_NAME_WITH_PREFIX} became\nconfused!"); // @ 83FB871 +const u8 gUnknown_83FB885[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready confused!"); // @ 83FB885 +const u8 gUnknown_83FB89D[] = _("{B_DEF_NAME_WITH_PREFIX}\nfell in love!"); // @ 83FB89D +const u8 gUnknown_83FB8AE[] = _("{B_ATK_NAME_WITH_PREFIX} is in love\nwith {B_SCR_ACTIVE_NAME_WITH_PREFIX}!"); // @ 83FB8AE +const u8 gUnknown_83FB8C5[] = _("{B_ATK_NAME_WITH_PREFIX} is\nimmobilized by love!"); // @ 83FB8C5 +const u8 gUnknown_83FB8E0[] = _("{B_DEF_NAME_WITH_PREFIX} was\nblown away!"); // @ 83FB8E0 +const u8 gUnknown_83FB8F3[] = _("{B_ATK_NAME_WITH_PREFIX} transformed\ninto the {B_BUFF1} type!"); // @ 83FB8F3 +const u8 gUnknown_83FB914[] = _("{B_ATK_NAME_WITH_PREFIX} flinched!"); // @ 83FB914 +const u8 gUnknown_83FB921[] = _("{B_DEF_NAME_WITH_PREFIX} regained\nhealth!"); // @ 83FB921 +const u8 gUnknown_83FB935[] = _("{B_DEF_NAME_WITH_PREFIX}'s\nHP is full!"); // @ 83FB935 +const u8 gUnknown_83FB946[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised SP. DEF!"); // @ 83FB946 +const u8 gUnknown_83FB95E[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised SP. DEF a little!"); // @ 83FB95E +const u8 gUnknown_83FB97F[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised DEFENSE!"); // @ 83FB97F +const u8 gUnknown_83FB997[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised DEFENSE a little!"); // @ 83FB997 +const u8 gUnknown_83FB9B8[] = _("{B_ATK_PREFIX2}'s party is covered\nby a veil!"); // @ 83FB9B8 +const u8 gUnknown_83FB9D9[] = _("{B_DEF_NAME_WITH_PREFIX}'s party is protected\nby SAFEGUARD!"); // @ 83FB9D9 +const u8 gUnknown_83FB9FF[] = _("{B_ATK_PREFIX3}'s party is no longer\nprotected by SAFEGUARD!"); // @ 83FB9FF +const u8 gUnknown_83FBA2F[] = _("{B_ATK_NAME_WITH_PREFIX} went\nto sleep!"); // @ 83FBA2F +const u8 gUnknown_83FBA41[] = _("{B_ATK_NAME_WITH_PREFIX} slept and\nbecame healthy!"); // @ 83FBA41 +const u8 gUnknown_83FBA5E[] = _("{B_ATK_NAME_WITH_PREFIX} whipped\nup a whirlwind!"); // @ 83FBA5E +const u8 gUnknown_83FBA79[] = _("{B_ATK_NAME_WITH_PREFIX} took\nin sunlight!"); // @ 83FBA79 +const u8 gUnknown_83FBA8E[] = _("{B_ATK_NAME_WITH_PREFIX} lowered\nits head!"); // @ 83FBA8E +const u8 gUnknown_83FBAA3[] = _("{B_ATK_NAME_WITH_PREFIX} is glowing!"); // @ 83FBAA3 +const u8 gUnknown_83FBAB2[] = _("{B_ATK_NAME_WITH_PREFIX} flew\nup high!"); // @ 83FBAB2 +const u8 gUnknown_83FBAC3[] = _("{B_ATK_NAME_WITH_PREFIX} dug a hole!"); // @ 83FBAC3 +const u8 gUnknown_83FBAD2[] = _("{B_ATK_NAME_WITH_PREFIX} hid\nunderwater!"); // @ 83FBAD2 +const u8 gUnknown_83FBAE5[] = _("{B_ATK_NAME_WITH_PREFIX} sprang up!"); // @ 83FBAE5 +const u8 gUnknown_83FBAF3[] = _("{B_DEF_NAME_WITH_PREFIX} was squeezed by\n{B_ATK_NAME_WITH_PREFIX}'s BIND!"); // @ 83FBAF3 +const u8 gUnknown_83FBB11[] = _("{B_DEF_NAME_WITH_PREFIX} was trapped\nin the vortex!"); // @ 83FBB11 +const u8 gUnknown_83FBB2F[] = _("{B_DEF_NAME_WITH_PREFIX} was trapped\nby SAND TOMB!"); // @ 83FBB2F +const u8 gUnknown_83FBB4C[] = _("{B_DEF_NAME_WITH_PREFIX} was WRAPPED by\n{B_ATK_NAME_WITH_PREFIX}!"); // @ 83FBB4C +const u8 gUnknown_83FBB62[] = _("{B_ATK_NAME_WITH_PREFIX} CLAMPED\n{B_DEF_NAME_WITH_PREFIX}!"); // @ 83FBB62 +const u8 gUnknown_83FBB71[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby {B_BUFF1}!"); // @ 83FBB71 +const u8 gUnknown_83FBB83[] = _("{B_ATK_NAME_WITH_PREFIX} was freed\nfrom {B_BUFF1}!"); // @ 83FBB83 +const u8 gUnknown_83FBB99[] = _("{B_ATK_NAME_WITH_PREFIX} kept going\nand crashed!"); // @ 83FBB99 +const u8 BattleText_MistShroud[] = _("{B_ATK_PREFIX2} became\nshrouded in MIST!"); // @ 83FBBB4 +const u8 gUnknown_83FBBD0[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} is protected\nby MIST!"); // @ 83FBBD0 +const u8 BattleText_GetPumped[] = _("{B_ATK_NAME_WITH_PREFIX} is getting\npumped!"); // @ 83FBBE9 +const u8 gUnknown_83FBBFF[] = _("{B_ATK_NAME_WITH_PREFIX} is hit\nwith recoil!"); // @ 83FBBFF +const u8 gUnknown_83FBC16[] = _("{B_ATK_NAME_WITH_PREFIX} protected\nitself!"); // @ 83FBC16 +const u8 gUnknown_83FBC2B[] = _("{B_ATK_NAME_WITH_PREFIX} is buffeted\nby the sandstorm!"); // @ 83FBC2B +const u8 gUnknown_83FBC4C[] = _("{B_ATK_NAME_WITH_PREFIX} is pelted\nby HAIL!"); // @ 83FBC4C +const u8 gUnknown_83FBC62[] = _("{B_ATK_PREFIX1}'s {B_BUFF1}\nwore off!"); // @ 83FBC62 +const u8 gUnknown_83FBC74[] = _("{B_DEF_NAME_WITH_PREFIX} was seeded!"); // @ 83FBC74 +const u8 gUnknown_83FBC83[] = _("{B_DEF_NAME_WITH_PREFIX} evaded\nthe attack!"); // @ 83FBC83 +const u8 gUnknown_83FBC99[] = _("{B_ATK_NAME_WITH_PREFIX}'s health is\nsapped by LEECH SEED!"); // @ 83FBC99 +const u8 gUnknown_83FBCBE[] = _("{B_ATK_NAME_WITH_PREFIX} is fast\nasleep."); // @ 83FBCBE +const u8 gUnknown_83FBCD1[] = _("{B_ATK_NAME_WITH_PREFIX} woke up!"); // @ 83FBCD1 +const u8 gUnknown_83FBCDD[] = _("But {B_SCR_ACTIVE_NAME_WITH_PREFIX}'s UPROAR\nkept it awake!"); // @ 83FBCDD +const u8 gUnknown_83FBCFC[] = _("{B_ATK_NAME_WITH_PREFIX} woke up\nin the UPROAR!"); // @ 83FBCFC +const u8 gUnknown_83FBD16[] = _("{B_ATK_NAME_WITH_PREFIX} caused\nan UPROAR!"); // @ 83FBD16 +const u8 gUnknown_83FBD2B[] = _("{B_ATK_NAME_WITH_PREFIX} is making\nan UPROAR!"); // @ 83FBD2B +const u8 gUnknown_83FBD43[] = _("{B_ATK_NAME_WITH_PREFIX} calmed down."); // @ 83FBD43 +const u8 gUnknown_83FBD53[] = _("But {B_DEF_NAME_WITH_PREFIX} can't\nsleep in an UPROAR!"); // @ 83FBD53 +const u8 gUnknown_83FBD74[] = _("{B_ATK_NAME_WITH_PREFIX} STOCKPILED\n{B_BUFF1}!"); // @ 83FBD74 +const u8 gUnknown_83FBD86[] = _("{B_ATK_NAME_WITH_PREFIX} can't\nSTOCKPILE any more!"); // @ 83FBD86 +const u8 gUnknown_83FBDA3[] = _("But {B_DEF_NAME_WITH_PREFIX} can't\nsleep in an UPROAR!"); // @ 83FBDA3 +const u8 gUnknown_83FBDC4[] = _("But the UPROAR kept\n{B_DEF_NAME_WITH_PREFIX} awake!"); // @ 83FBDC4 +const u8 gUnknown_83FBDE2[] = _("{B_DEF_NAME_WITH_PREFIX} stayed awake\nusing its {B_DEF_ABILITY}!"); // @ 83FBDE2 +const u8 gUnknown_83FBE00[] = _("{B_ATK_NAME_WITH_PREFIX} is storing\nenergy!"); // @ 83FBE00 +const u8 gUnknown_83FBE16[] = _("{B_ATK_NAME_WITH_PREFIX} unleashed\nenergy!"); // @ 83FBE16 +const u8 gUnknown_83FBE2B[] = _("{B_ATK_NAME_WITH_PREFIX} became\nconfused due to fatigue!"); // @ 83FBE2B +const u8 gUnknown_83FBE4E[] = _("{B_PLAYER_NAME} picked up\n¥{B_BUFF1}!\p"); // @ 83FBE4E +const u8 gUnknown_83FBE61[] = _("{B_DEF_NAME_WITH_PREFIX} is\nunaffected!"); // @ 83FBE61 +const u8 gUnknown_83FBE73[] = _("{B_ATK_NAME_WITH_PREFIX} transformed\ninto {B_BUFF1}!"); // @ 83FBE73 +const u8 gUnknown_83FBE8B[] = _("{B_ATK_NAME_WITH_PREFIX} made\na SUBSTITUTE!"); // @ 83FBE8B +const u8 gUnknown_83FBEA1[] = _("{B_ATK_NAME_WITH_PREFIX} already\nhas a SUBSTITUTE!"); // @ 83FBEA1 +const u8 gUnknown_83FBEBE[] = _("The SUBSTITUTE took damage\nfor {B_DEF_NAME_WITH_PREFIX}!\p"); // @ 83FBEBE +const u8 gUnknown_83FBEE2[] = _("{B_DEF_NAME_WITH_PREFIX}'s\nSUBSTITUTE faded!\p"); // @ 83FBEE2 +const u8 gUnknown_83FBEFA[] = _("{B_ATK_NAME_WITH_PREFIX} must\nrecharge!"); // @ 83FBEFA +const u8 gUnknown_83FBF0C[] = _("{B_DEF_NAME_WITH_PREFIX}'s RAGE\nis building!"); // @ 83FBF0C +const u8 gUnknown_83FBF23[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\nwas disabled!"); // @ 83FBF23 +const u8 gUnknown_83FBF39[] = _("{B_ATK_NAME_WITH_PREFIX} is disabled\nno more!"); // @ 83FBF39 +const u8 gUnknown_83FBF51[] = _("{B_DEF_NAME_WITH_PREFIX} got\nan ENCORE!"); // @ 83FBF51 +const u8 gUnknown_83FBF63[] = _("{B_ATK_NAME_WITH_PREFIX}'s ENCORE\nended!"); // @ 83FBF63 +const u8 gUnknown_83FBF76[] = _("{B_ATK_NAME_WITH_PREFIX} took aim\nat {B_DEF_NAME_WITH_PREFIX}!"); // @ 83FBF76 +const u8 gUnknown_83FBF89[] = _("{B_ATK_NAME_WITH_PREFIX} SKETCHED\n{B_BUFF1}!"); // @ 83FBF89 +const u8 gUnknown_83FBF99[] = _("{B_ATK_NAME_WITH_PREFIX} is trying\nto take its foe with it!"); // @ 83FBF99 +const u8 gUnknown_83FBFBF[] = _("{B_DEF_NAME_WITH_PREFIX} took\n{B_ATK_NAME_WITH_PREFIX} with it!"); // @ 83FBFBF +const u8 gUnknown_83FBFD3[] = _("Reduced {B_DEF_NAME_WITH_PREFIX}'s\n{B_BUFF1} by {B_BUFF2}!"); // @ 83FBFD3 +const u8 gUnknown_83FBFEA[] = _("{B_ATK_NAME_WITH_PREFIX} stole\n{B_DEF_NAME_WITH_PREFIX}'s {B_LAST_ITEM}!"); // @ 83FBFEA +const u8 gUnknown_83FBFFC[] = _("{B_DEF_NAME_WITH_PREFIX} can't\nescape now!"); // @ 83FBFFC +const u8 gUnknown_83FC011[] = _("{B_DEF_NAME_WITH_PREFIX} fell into\na NIGHTMARE!"); // @ 83FC011 +const u8 gUnknown_83FC02B[] = _("{B_ATK_NAME_WITH_PREFIX} is locked\nin a NIGHTMARE!"); // @ 83FC02B +const u8 gUnknown_83FC048[] = _("{B_ATK_NAME_WITH_PREFIX} cut its own HP and\nlaid a CURSE on {B_DEF_NAME_WITH_PREFIX}!"); // @ 83FC048 +const u8 gUnknown_83FC072[] = _("{B_ATK_NAME_WITH_PREFIX} is afflicted\nby the CURSE!"); // @ 83FC072 +const u8 gUnknown_83FC090[] = _("SPIKES were scattered all around\nthe opponent's side!"); // @ 83FC090 +const u8 gUnknown_83FC0C6[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} is hurt\nby SPIKES!"); // @ 83FC0C6 +const u8 gUnknown_83FC0DC[] = _("{B_ATK_NAME_WITH_PREFIX} identified\n{B_DEF_NAME_WITH_PREFIX}!"); // @ 83FC0DC +const u8 gUnknown_83FC0EE[] = _("{B_ATK_NAME_WITH_PREFIX}'s PERISH count\nfell to {B_BUFF1}!"); // @ 83FC0EE +const u8 gUnknown_83FC10C[] = _("{B_ATK_NAME_WITH_PREFIX} braced\nitself!"); // @ 83FC10C +const u8 gUnknown_83FC11E[] = _("{B_DEF_NAME_WITH_PREFIX} ENDURED\nthe hit!"); // @ 83FC11E +const u8 gUnknown_83FC132[] = _("MAGNITUDE {B_BUFF1}!"); // @ 83FC132 +const u8 gUnknown_83FC140[] = _("{B_ATK_NAME_WITH_PREFIX} cut its own HP\nand maximized ATTACK!"); // @ 83FC140 +const u8 gUnknown_83FC168[] = _("{B_ATK_NAME_WITH_PREFIX} copied\n{B_DEF_NAME_WITH_PREFIX}'s stat changes!"); // @ 83FC168 +const u8 gUnknown_83FC185[] = _("{B_ATK_NAME_WITH_PREFIX} got free of\n{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}!"); // @ 83FC185 +const u8 gUnknown_83FC19D[] = _("{B_ATK_NAME_WITH_PREFIX} shed\nLEECH SEED!"); // @ 83FC19D +const u8 gUnknown_83FC1B1[] = _("{B_ATK_NAME_WITH_PREFIX} blew away\nSPIKES!"); // @ 83FC1B1 +const u8 gUnknown_83FC1C6[] = _("{B_ATK_NAME_WITH_PREFIX} fled from\nbattle!"); // @ 83FC1C6 +const u8 gUnknown_83FC1DB[] = _("{B_ATK_NAME_WITH_PREFIX} foresaw\nan attack!"); // @ 83FC1DB +const u8 gUnknown_83FC1F1[] = _("{B_DEF_NAME_WITH_PREFIX} took the\n{B_BUFF1} attack!"); // @ 83FC1F1 +const u8 gUnknown_83FC208[] = _("{B_ATK_NAME_WITH_PREFIX} chose\n{B_CURRENT_MOVE} as its destiny!"); // @ 83FC208 +const u8 gUnknown_83FC224[] = _("{B_BUFF1}'s attack!"); // @ 83FC224 +const u8 gUnknown_83FC231[] = _("{B_ATK_NAME_WITH_PREFIX} became the\ncenter of attention!"); // @ 83FC231 +const u8 gUnknown_83FC254[] = _("{B_ATK_NAME_WITH_PREFIX} began\ncharging power!"); // @ 83FC254 +const u8 gUnknown_83FC26D[] = _("NATURE POWER turned into\n{B_CURRENT_MOVE}!"); // @ 83FC26D +const u8 gUnknown_83FC28A[] = _("{B_ATK_NAME_WITH_PREFIX}'s status\nreturned to normal!"); // @ 83FC28A +const u8 gUnknown_83FC2AA[] = _("{B_DEF_NAME_WITH_PREFIX} was subjected\nto TORMENT!"); // @ 83FC2AA +const u8 gUnknown_83FC2C7[] = _("{B_ATK_NAME_WITH_PREFIX} is tightening\nits focus!"); // @ 83FC2C7 +const u8 gUnknown_83FC2E3[] = _("{B_DEF_NAME_WITH_PREFIX} fell for\nthe TAUNT!"); // @ 83FC2E3 +const u8 gUnknown_83FC2FA[] = _("{B_ATK_NAME_WITH_PREFIX} is ready to\nhelp {B_DEF_NAME_WITH_PREFIX}!"); // @ 83FC2FA +const u8 gUnknown_83FC312[] = _("{B_ATK_NAME_WITH_PREFIX} switched\nitems with its opponent!"); // @ 83FC312 +const u8 gUnknown_83FC337[] = _("{B_ATK_NAME_WITH_PREFIX} obtained\n{B_BUFF1}."); // @ 83FC337 +const u8 gUnknown_83FC347[] = _("{B_DEF_NAME_WITH_PREFIX} obtained\n{B_BUFF2}."); // @ 83FC347 +const u8 gUnknown_83FC357[] = _("{B_ATK_NAME_WITH_PREFIX} obtained\n{B_BUFF1}.\p{B_DEF_NAME_WITH_PREFIX} obtained\n{B_BUFF2}."); // @ 83FC357 +const u8 gUnknown_83FC377[] = _("{B_ATK_NAME_WITH_PREFIX} copied\n{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}!"); // @ 83FC377 +const u8 gUnknown_83FC38A[] = _("{B_ATK_NAME_WITH_PREFIX} made a WISH!"); // @ 83FC38A +const u8 gUnknown_83FC39A[] = _("{B_BUFF1}'s WISH\ncame true!"); // @ 83FC39A +const u8 gUnknown_83FC3AF[] = _("{B_ATK_NAME_WITH_PREFIX} planted its roots!"); // @ 83FC3AF +const u8 gUnknown_83FC3C5[] = _("{B_ATK_NAME_WITH_PREFIX} absorbed\nnutrients with its roots!"); // @ 83FC3C5 +const u8 gUnknown_83FC3EB[] = _("{B_DEF_NAME_WITH_PREFIX} anchored\nitself with its roots!"); // @ 83FC3EB +const u8 gUnknown_83FC40E[] = _("{B_ATK_NAME_WITH_PREFIX} made\n{B_DEF_NAME_WITH_PREFIX} drowsy!"); // @ 83FC40E +const u8 gUnknown_83FC421[] = _("{B_ATK_NAME_WITH_PREFIX} knocked off\n{B_DEF_NAME_WITH_PREFIX}'s {B_LAST_ITEM}!"); // @ 83FC421 +const u8 gUnknown_83FC439[] = _("{B_ATK_NAME_WITH_PREFIX} swapped abilities\nwith its opponent!"); // @ 83FC439 +const u8 gUnknown_83FC461[] = _("{B_ATK_NAME_WITH_PREFIX} sealed the\nopponent's moveシsス!"); // @ 83FC461 +const u8 gUnknown_83FC483[] = _("{B_ATK_NAME_WITH_PREFIX} wants the\nopponent to bear a GRUDGE!"); // @ 83FC483 +const u8 gUnknown_83FC4AB[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1} lost\nall its PP due to the GRUDGE!"); // @ 83FC4AB +const u8 gUnknown_83FC4D6[] = _("{B_ATK_NAME_WITH_PREFIX} shrouded\nitself in {B_CURRENT_MOVE}!"); // @ 83FC4D6 +const u8 gUnknown_83FC4F0[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_CURRENT_MOVE}\nwas bounced back by MAGIC COAT!"); // @ 83FC4F0 +const u8 gUnknown_83FC518[] = _("{B_ATK_NAME_WITH_PREFIX} waits for its foe\nto make a move!"); // @ 83FC518 +const u8 gUnknown_83FC53D[] = _("{B_DEF_NAME_WITH_PREFIX} SNATCHED\n{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s move!"); // @ 83FC53D +const u8 gUnknown_83FC554[] = _("Electricity's power was\nweakened!"); // @ 83FC554 +const u8 gUnknown_83FC576[] = _("Fire's power was\nweakened!"); // @ 83FC576 +const u8 gUnknown_83FC591[] = _("{B_ATK_NAME_WITH_PREFIX} found\none {B_LAST_ITEM}!"); // @ 83FC591 +const u8 gUnknown_83FC5A2[] = _("A soothing aroma wafted\nthrough the area!"); // @ 83FC5A2 +const u8 gUnknown_83FC5CC[] = _("Items can't be used now.{PAUSE 64}"); // @ 83FC5CC +const u8 gUnknown_83FC5E8[] = _("For {B_SCR_ACTIVE_NAME_WITH_PREFIX},\n{B_LAST_ITEM} {B_BUFF1}"); // @ 83FC5E8 +const u8 gUnknown_83FC5F6[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} used\n{B_LAST_ITEM} to hustle!"); // @ 83FC5F6 +const u8 gUnknown_83FC60C[] = _("{B_ATK_NAME_WITH_PREFIX} lost its\nfocus and couldn't move!"); // @ 83FC60C +const u8 gUnknown_83FC631[] = _("{B_DEF_NAME_WITH_PREFIX} was\ndragged out!\p"); // @ 83FC631 +const u8 gUnknown_83FC646[] = _("The wall shattered!"); // @ 83FC646 +const u8 gUnknown_83FC65A[] = _("But it had no effect!"); // @ 83FC65A +const u8 gUnknown_83FC670[] = _("{B_ACTIVE_NAME_WITH_PREFIX} has no\nmoves left!\p"); // @ 83FC670 +const u8 gUnknown_83FC687[] = _("{B_ACTIVE_NAME_WITH_PREFIX}'s {B_CURRENT_MOVE}\nis disabled!\p"); // @ 83FC687 +const u8 gUnknown_83FC69D[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use the same\nmove in a row due to the TORMENT!\p"); // @ 83FC69D +const u8 gUnknown_83FC6D6[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use\n{B_CURRENT_MOVE} after the TAUNT!\p"); // @ 83FC6D6 +const u8 gUnknown_83FC6F8[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use the\nsealed {B_CURRENT_MOVE}!\p"); // @ 83FC6F8 +const u8 gUnknown_83FC715[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade it rain!"); // @ 83FC715 +const u8 gUnknown_83FC72B[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nraised its SPEED!"); // @ 83FC72B +const u8 gUnknown_83FC745[] = _("{B_DEF_NAME_WITH_PREFIX} was protected\nby {B_DEF_ABILITY}!"); // @ 83FC745 +const u8 gUnknown_83FC75D[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents {B_ATK_NAME_WITH_PREFIX}\lfrom using {B_CURRENT_MOVE}!"); // @ 83FC75D +const u8 gUnknown_83FC780[] = _("{B_DEF_NAME_WITH_PREFIX} restored HP\nusing its {B_DEF_ABILITY}!"); // @ 83FC780 +const u8 gUnknown_83FC79D[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade {B_CURRENT_MOVE} useless!"); // @ 83FC79D +const u8 gUnknown_83FC7B6[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade it the {B_BUFF1} type!"); // @ 83FC7B6 +const u8 gUnknown_83FC7D3[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents paralysis!"); // @ 83FC7D3 +const u8 gUnknown_83FC7EF[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents romance!"); // @ 83FC7EF +const u8 gUnknown_83FC809[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents poisoning!"); // @ 83FC809 +const u8 gUnknown_83FC825[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents confusion!"); // @ 83FC825 +const u8 gUnknown_83FC841[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nraised its FIRE power!"); // @ 83FC841 +const u8 gUnknown_83FC860[] = _("{B_DEF_NAME_WITH_PREFIX} anchors\nitself with {B_DEF_ABILITY}!"); // @ 83FC860 +const u8 gUnknown_83FC87B[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncuts {B_DEF_NAME_WITH_PREFIX}'s ATTACK!"); // @ 83FC87B +const u8 gUnknown_83FC895[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nprevents stat loss!"); // @ 83FC895 +const u8 gUnknown_83FC8B1[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nhurt {B_ATK_NAME_WITH_PREFIX}!"); // @ 83FC8B1 +const u8 gUnknown_83FC8C2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} TRACED\n{B_BUFF1}'s {B_BUFF2}!"); // @ 83FC8C2 +const u8 gUnknown_83FC8D5[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_EFF_ABILITY}\nprevents burns!"); // @ 83FC8D5 +const u8 gUnknown_83FC8ED[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nblocks {B_CURRENT_MOVE}!"); // @ 83FC8ED +const u8 gUnknown_83FC900[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nblocks {B_CURRENT_MOVE}!"); // @ 83FC900 +const u8 gUnknown_83FC913[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_ATK_ABILITY}\nrestored its HP a little!"); // @ 83FC913 +const u8 gUnknown_83FC935[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nwhipped up a sandstorm!"); // @ 83FC935 +const u8 gUnknown_83FC955[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nintensified the sun's rays!"); // @ 83FC955 +const u8 gUnknown_83FC979[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nprevents {B_BUFF1} loss!"); // @ 83FC979 +const u8 gUnknown_83FC993[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\ninfatuated {B_ATK_NAME_WITH_PREFIX}!"); // @ 83FC993 +const u8 gUnknown_83FC9AA[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade {B_CURRENT_MOVE} ineffective!"); // @ 83FC9AA +const u8 gUnknown_83FC9C7[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncured its {B_BUFF1} problem!"); // @ 83FC9C7 +const u8 gUnknown_83FC9E5[] = _("It sucked up the\nLIQUID OOZE!"); // @ 83FC9E5 +const u8 gUnknown_83FCA03[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} transformed!"); // @ 83FCA03 +const u8 gUnknown_83FCA13[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\ntook the attack!"); // @ 83FCA13 +const u8 gText_PkmnsXPreventsSwitching[] = _("{B_BUFF1}'s {B_LAST_ABILITY}\nprevents switching!\p"); // @ 83FCA2C +const u8 gUnknown_83FCA49[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevented {B_SCR_ACTIVE_NAME_WITH_PREFIX}'s\l{B_BUFF1} from working!"); // @ 83FCA49 +const u8 gUnknown_83FCA71[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade it ineffective!"); // @ 83FCA71 +const u8 gUnknown_83FCA8E[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_EFF_ABILITY}\nprevents flinching!"); // @ 83FCA8E +const u8 gUnknown_83FCAAA[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_ATK_ABILITY}\nprevents {B_DEF_NAME_WITH_PREFIX}'s\l{B_DEF_ABILITY} from working!"); // @ 83FCAAA +const u8 gUnknown_83FCAD1[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncured its {B_BUFF1} problem!"); // @ 83FCAD1 +const u8 gUnknown_83FCAEF[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nhad no effect on {B_EFF_NAME_WITH_PREFIX}!"); // @ 83FCAEF +const u8 gUnknown_83FCB0C[] = _("{B_ATK_NAME_WITH_PREFIX} is too scared to move!"); // @ 83FCB0C +const u8 gUnknown_83FCB26[] = _("GHOST: Get out…… Get out……"); // @ 83FCB26 +const u8 gUnknown_83FCB41[] = _("sharply "); // @ 83FCB41 +const u8 BattleText_Rose[] = _("rose!"); // @ 83FCB4A +const u8 gUnknown_83FCB50[] = _("harshly "); // @ 83FCB50 +const u8 gUnknown_83FCB59[] = _("fell!"); // @ 83FCB59 +const u8 gUnknown_83FCB5F[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); // @ 83FCB5F +const u8 BattleText_UnknownString3[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); // @ 83FCB6A +const u8 gUnknown_83FCB75[] = _("Using {B_LAST_ITEM}, the {B_BUFF1}\nof {B_SCR_ACTIVE_NAME_WITH_PREFIX} {B_BUFF2}"); // @ 83FCB75 +const u8 gUnknown_83FCB8F[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); // @ 83FCB8F +const u8 gUnknown_83FCB9A[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); // @ 83FCB9A +const u8 gUnknown_83FCBA5[] = _("{B_ATK_NAME_WITH_PREFIX}'s stats won't\ngo any higher!"); // @ 83FCBA5 +const u8 gUnknown_83FCBC5[] = _("{B_DEF_NAME_WITH_PREFIX}'s stats won't\ngo any lower!"); // @ 83FCBC5 +const u8 gUnknown_83FCBE4[] = _("A critical hit!"); // @ 83FCBE4 +const u8 gUnknown_83FCBF4[] = _("It's a one-hit KO!"); // @ 83FCBF4 +const u8 gUnknown_83FCC07[] = _("{PAUSE 32}1, {PAUSE 15}2, and{PAUSE 15}… {PAUSE 15}… {PAUSE 15}… {PAUSE 15}{PLAY_SE SE_KON}Poof!\p"); // @ 83FCC07 +const u8 gUnknown_83FCC33[] = _("And…\p"); // @ 83FCC33 +const u8 gUnknown_83FCC39[] = _("HM moves can't be\nforgotten now.\p"); // @ 83FCC39 +const u8 gUnknown_83FCC5B[] = _("It's not very effective…"); // @ 83FCC5B +const u8 gUnknown_83FCC74[] = _("It's super effective!"); // @ 83FCC74 +const u8 sText_GotAwaySafely[] = _("{PLAY_SE SE_NIGERU}Got away safely!\p"); // @ 83FCC8A +const u8 gUnknown_83FCCA0[] = _("{PLAY_SE SE_NIGERU}{B_ATK_NAME_WITH_PREFIX} fled\nusing its {B_LAST_ITEM}!\p"); // @ 83FCCA0 +const u8 gUnknown_83FCCBB[] = _("{PLAY_SE SE_NIGERU}{B_ATK_NAME_WITH_PREFIX} fled\nusing {B_ATK_ABILITY}!\p"); // @ 83FCCBB +const u8 gUnknown_83FCCD2[] = _("{PLAY_SE SE_NIGERU}Wild {B_BUFF1} fled!"); // @ 83FCCD2 +const u8 sText_PlayerDefeatedLinkTrainer[] = _("Player defeated\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCCE4 +const u8 sText_TwoLinkTrainersDefeated[] = _("Player beat {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); // @ 83FCCF8 +const u8 sText_PlayerLostAgainstLinkTrainer[] = _("Player lost against\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCD0F +const u8 sText_PlayerLostToTwo[] = _("Player lost to {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); // @ 83FCD27 +const u8 sText_PlayerBattledToDrawLinkTrainer[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCD41 +const u8 sText_PlayerBattledToDrawVsTwo[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}!"); // @ 83FCD66 +const u8 gUnknown_83FCD92[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} fled!"); // @ 83FCD92 +const u8 sText_TwoWildFled[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} and\n{B_LINK_OPPONENT2_NAME} fled!"); // @ 83FCD9F +const u8 gUnknown_83FCDB3[] = _("No! There's no running\nfrom a TRAINER battle!\p"); // @ 83FCDB3 +const u8 gUnknown_83FCDE2[] = _("Can't escape!\p"); // @ 83FCDE2 +const u8 gUnknown_83FCDF1[] = _(""); // @ 83FCDF1 +const u8 gUnknown_83FCDF2[] = _("But nothing happened!"); // @ 83FCDF2 +const u8 gUnknown_83FCE08[] = _("But it failed!"); // @ 83FCE08 +const u8 gUnknown_83FCE17[] = _("It hurt itself in its\nconfusion!"); // @ 83FCE17 +const u8 gUnknown_83FCE38[] = _("The MIRROR MOVE failed!"); // @ 83FCE38 +const u8 gUnknown_83FCE50[] = _("It started to rain!"); // @ 83FCE50 +const u8 gUnknown_83FCE64[] = _("A downpour started!"); // @ 83FCE64 +const u8 gUnknown_83FCE78[] = _("Rain continues to fall."); // @ 83FCE78 +const u8 gUnknown_83FCE90[] = _("The downpour continues."); // @ 83FCE90 +const u8 gUnknown_83FCEA8[] = _("The rain stopped."); // @ 83FCEA8 +const u8 gUnknown_83FCEBA[] = _("A sandstorm brewed!"); // @ 83FCEBA +const u8 gUnknown_83FCECE[] = _("The sandstorm rages."); // @ 83FCECE +const u8 gUnknown_83FCEE3[] = _("The sandstorm subsided."); // @ 83FCEE3 +const u8 gUnknown_83FCEFB[] = _("The sunlight got bright!"); // @ 83FCEFB +const u8 gUnknown_83FCF14[] = _("The sunlight is strong."); // @ 83FCF14 +const u8 gUnknown_83FCF2C[] = _("The sunlight faded."); // @ 83FCF2C +const u8 gUnknown_83FCF40[] = _("It started to hail!"); // @ 83FCF40 +const u8 gUnknown_83FCF54[] = _("Hail continues to fall."); // @ 83FCF54 +const u8 gUnknown_83FCF6C[] = _("The hail stopped."); // @ 83FCF6C +const u8 gUnknown_83FCF7E[] = _("But it failed to SPIT UP\na thing!"); // @ 83FCF7E +const u8 gUnknown_83FCFA0[] = _("But it failed to SWALLOW\na thing!"); // @ 83FCFA0 +const u8 gUnknown_83FCFC2[] = _("The wind turned into a\nHEAT WAVE!"); // @ 83FCFC2 +const u8 gUnknown_83FCFE4[] = _("All stat changes were\neliminated!"); // @ 83FCFE4 +const u8 gUnknown_83FD006[] = _("Coins scattered everywhere!"); // @ 83FD006 +const u8 gUnknown_83FD022[] = _("It was too weak to make\na SUBSTITUTE!"); // @ 83FD022 +const u8 gUnknown_83FD048[] = _("The battlers shared\ntheir pain!"); // @ 83FD048 +const u8 gUnknown_83FD068[] = _("A bell chimed!"); // @ 83FD068 +const u8 gUnknown_83FD077[] = _("All affected POKéMON will\nfaint in three turns!"); // @ 83FD077 +const u8 gUnknown_83FD0A7[] = _("There's no PP left for\nthis move!\p"); // @ 83FD0A7 +const u8 gUnknown_83FD0CA[] = _("But there was no PP left\nfor the move!"); // @ 83FD0CA +const u8 gUnknown_83FD0F1[] = _("{B_ATK_NAME_WITH_PREFIX} ignored\norders while asleep!"); // @ 83FD0F1 +const u8 gUnknown_83FD111[] = _("{B_ATK_NAME_WITH_PREFIX} ignored\norders!"); // @ 83FD111 +const u8 gUnknown_83FD124[] = _("{B_ATK_NAME_WITH_PREFIX} began to nap!"); // @ 83FD124 +const u8 gUnknown_83FD135[] = _("{B_ATK_NAME_WITH_PREFIX} is\nloafing around!"); // @ 83FD135 +const u8 gUnknown_83FD14B[] = _("{B_ATK_NAME_WITH_PREFIX} won't\nobey!"); // @ 83FD14B +const u8 gUnknown_83FD15A[] = _("{B_ATK_NAME_WITH_PREFIX} turned away!"); // @ 83FD15A +const u8 gUnknown_83FD16A[] = _("{B_ATK_NAME_WITH_PREFIX} pretended\nnot to notice!"); // @ 83FD16A +const u8 gUnknown_83FD186[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} is\nabout to use {B_BUFF2}.\pWill {B_PLAYER_NAME} change\nPOKéMON?"); // @ 83FD186 +const u8 gUnknown_83FD1B8[] = _("{B_ATK_NAME_WITH_PREFIX} learned\n{B_BUFF1}!"); // @ 83FD1B8 +const u8 sText_PlayerDefeatedLinkTrainerTrainer1[] = _("Player defeated\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!\p"); // @ 83FD1C7 +const u8 gUnknown_83FD1DF[] = _("{B_PLAYER_NAME} threw a ROCK\nat the {B_OPPONENT_MON1_NAME}!"); // @ 83FD1DF +const u8 gUnknown_83FD1FA[] = _("{B_PLAYER_NAME} threw some BAIT\nat the {B_OPPONENT_MON1_NAME}!"); // @ 83FD1FA +const u8 gUnknown_83FD218[] = _("{B_OPPONENT_MON1_NAME} is watching\ncarefully!"); // @ 83FD218 +const u8 gUnknown_83FD232[] = _("{B_OPPONENT_MON1_NAME} is angry!"); // @ 83FD232 +const u8 gUnknown_83FD23F[] = _("{B_OPPONENT_MON1_NAME} is eating!"); // @ 83FD23F +const u8 gUnknown_83FD24D[] = _("{PLAY_SE SE_PINPON}ANNOUNCER: You're out of\nSAFARI BALLS! Game over!\p"); // @ 83FD24D +const u8 sText_WildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); // @ 83FD284 +const u8 sText_WildPkmnAppeared2[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); // @ 83FD297 +const u8 sText_WildPkmnAppearedPause[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!{PAUSE 127}"); // @ 83FD2AA +const u8 sText_TwoWildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} and\n{B_OPPONENT_MON2_NAME} appeared!\p"); // @ 83FD2BF +const u8 gUnknown_83FD2D9[] = _("The GHOST appeared!\pDarn!\nThe GHOST can't be ID'd!\p"); // @ 83FD2D9 +const u8 gUnknown_83FD30D[] = _("The GHOST appeared!\p"); // @ 83FD30D +const u8 gUnknown_83FD322[] = _("SILPH SCOPE unveiled the GHOST's\nidentity!"); // @ 83FD322 +const u8 gUnknown_83FD34D[] = _("The GHOST was MAROWAK!\p\n"); // @ 83FD34D +const u8 sText_Trainer1WantsToBattle[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwould like to battle!\p"); // @ 83FD366 +const u8 sText_LinkTrainerWantsToBattle[] = _("{B_LINK_OPPONENT1_NAME}\nwants to battle!"); // @ 83FD383 +const u8 sText_TwoLinkTrainersWantToBattle[] = _("{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}\nwant to battle!"); // @ 83FD397 +const u8 sText_Trainer1SentOutPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME}!{PAUSE 60}"); // @ 83FD3B1 +const u8 sText_Trainer1SentOutTwoPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!{PAUSE 60}"); // @ 83FD3C7 +const u8 sText_Trainer1SentOutPkmn2[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_BUFF1}!"); // @ 83FD3E4 +const u8 sText_LinkTrainerSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME}!"); // @ 83FD3F7 +const u8 sText_LinkTrainerSentOutTwoPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!"); // @ 83FD407 +const u8 sText_TwoLinkTrainersSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out {B_LINK_OPPONENT_MON1_NAME}!\n{B_LINK_OPPONENT2_NAME} sent out {B_LINK_OPPONENT_MON2_NAME}!"); // @ 83FD41E +const u8 sText_LinkTrainerSentOutPkmn2[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_BUFF1}!"); // @ 83FD43E +const u8 sText_LinkTrainerMultiSentOutPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} sent out\n{B_BUFF1}!"); // @ 83FD44E +const u8 sText_GoPkmn[] = _("Go! {B_PLAYER_MON1_NAME}!"); // @ 83FD45E +const u8 sText_GoTwoPkmn[] = _("Go! {B_PLAYER_MON1_NAME} and\n{B_PLAYER_MON2_NAME}!"); // @ 83FD466 +const u8 sText_GoPkmn2[] = _("Go! {B_BUFF1}!"); // @ 83FD475 +const u8 sText_DoItPkmn[] = _("Do it! {B_BUFF1}!"); // @ 83FD47D +const u8 sText_GoForItPkmn[] = _("Go for it, {B_BUFF1}!"); // @ 83FD488 +const u8 sText_YourFoesWeakGetEmPkmn[] = _("Your foe's weak!\nGet 'em, {B_BUFF1}!"); // @ 83FD497 +const u8 sText_LinkPartnerSentOutPkmnGoPkmn[] = _("{B_LINK_PARTNER_NAME} sent out {B_LINK_PLAYER_MON2_NAME}!\nGo! {B_LINK_PLAYER_MON1_NAME}!"); // @ 83FD4B5 +const u8 sText_PkmnThatsEnough[] = _("{B_BUFF1}, that's enough!\nCome back!"); // @ 83FD4CD +const u8 sText_PkmnComeBack[] = _("{B_BUFF1}, come back!"); // @ 83FD4EB +const u8 sText_PkmnOkComeBack[] = _("{B_BUFF1}, OK!\nCome back!"); // @ 83FD4FA +const u8 sText_PkmnGoodComeBack[] = _("{B_BUFF1}, good!\nCome back!"); // @ 83FD50D +const u8 sText_Trainer1WithdrewPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwithdrew {B_BUFF1}!"); // @ 83FD522 +const u8 sText_LinkTrainer1WithdrewPkmn[] = _("{B_LINK_OPPONENT1_NAME} withdrew\n{B_BUFF1}!"); // @ 83FD535 +const u8 sText_LinkTrainer2WithdrewPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} withdrew\n{B_BUFF1}!"); // @ 83FD545 +const u8 sText_WildPkmnPrefix[] = _("Wild "); // @ 83FD555 +const u8 sText_FoePkmnPrefix[] = _("Foe "); // @ 83FD55B +const u8 sText_FoePkmnPrefix2[] = _("Foe"); // @ 83FD560 +const u8 sText_AllyPkmnPrefix[] = _("Ally"); // @ 83FD564 +const u8 sText_FoePkmnPrefix3[] = _("Foe"); // @ 83FD569 +const u8 sText_AllyPkmnPrefix2[] = _("Ally"); // @ 83FD56D +const u8 sText_FoePkmnPrefix4[] = _("Foe"); // @ 83FD572 +const u8 sText_AllyPkmnPrefix3[] = _("Ally"); // @ 83FD576 +const u8 sText_AttackerUsedX[] = _("{B_ATK_NAME_WITH_PREFIX} used\n{B_BUFF2}"); // @ 83FD57B +const u8 sText_ExclamationMark[] = _("!"); // @ 83FD586 +const u8 sText_ExclamationMark2[] = _("!"); // @ 83FD588 +const u8 sText_ExclamationMark3[] = _("!"); // @ 83FD58A +const u8 sText_ExclamationMark4[] = _("!"); // @ 83FD58C +const u8 sText_ExclamationMark5[] = _("!"); // @ 83FD58E + +const u8 sText_HP2[] = _("HP"); // @ 83FD590 +const u8 sText_Attack2[] = _("ATTACK"); // @ 83FD593 +const u8 sText_Defense2[] = _("DEFENSE"); // @ 83FD59A +const u8 sText_Speed[] = _("SPEED"); // @ 83FD5A2 +const u8 sText_SpAtk2[] = _("SP. ATK"); // @ 83FD5A8 +const u8 sText_SpDef2[] = _("SP. DEF"); // @ 83FD5B0 +const u8 sText_Accuracy[] = _("accuracy"); // @ 83FD5B8 +const u8 sText_Evasiveness[] = _("evasiveness"); // @ 83FD5C1 + +const u8 *const gUnknown_83FD5D0[] = { + sText_HP2, + sText_Attack2, + sText_Defense2, + sText_Speed, + sText_SpAtk2, + sText_SpDef2, + sText_Accuracy, + sText_Evasiveness +}; + +const u8 sText_PokeblockWasTooSpicy[] = _("was too spicy!"); // +const u8 sText_PokeblockWasTooDry[] = _("was too dry!"); // @ 83FD5FF +const u8 sText_PokeblockWasTooSweet[] = _("was too sweet!"); // @ 83FD60C +const u8 sText_PokeblockWasTooBitter[] = _("was too bitter!"); // @ 83FD61B +const u8 sText_PokeblockWasTooSour[] = _("was too sour!"); // @ 83FD62B + +const u8 *const gUnknown_83FD63C[] = { + sText_PokeblockWasTooSpicy, + sText_PokeblockWasTooDry, + sText_PokeblockWasTooSweet, + sText_PokeblockWasTooBitter, + sText_PokeblockWasTooSour +}; + +const u8 sText_PlayerUsedItem[] = _("{B_PLAYER_NAME} used\n{B_LAST_ITEM}!"); // @ 83FD650 +const u8 sText_OldManUsedItem[] = _("The old man used\n{B_LAST_ITEM}!"); // @ 83FD65C +const u8 sText_PokeDudeUsedItem[] = _("The POKé DUDE used\n{B_LAST_ITEM}!"); // @ 83FD671 +const u8 sText_Trainer1UsedItem[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nused {B_LAST_ITEM}!"); // @ 83FD688 +const u8 sText_TrainerBlockedBall[] = _("The TRAINER blocked the BALL!"); // @ 83FD697 +const u8 sText_DontBeAThief[] = _("Don't be a thief!"); // @ 83FD6B5 +const u8 sText_ItDodgedBall[] = _("It dodged the thrown BALL!\nThis POKéMON can't be caught!"); // @ 83FD6C7 +const u8 sText_YouMissedPkmn[] = _("You missed the POKéMON!"); // @ 83FD700 +const u8 sText_PkmnBrokeFree[] = _("Oh, no!\nThe POKéMON broke free!"); // @ 83FD718 +const u8 sText_ItAppearedCaught[] = _("Aww!\nIt appeared to be caught!"); // @ 83FD738 +const u8 sText_AarghAlmostHadIt[] = _("Aargh!\nAlmost had it!"); // @ 83FD757 +const u8 sText_ShootSoClose[] = _("Shoot!\nIt was so close, too!"); // @ 83FD76D +const u8 gUnknown_83FD78A[] = _("よけられた!\nこいつは つかまりそうにないぞ!"); // @ 83FD78A +const u8 sText_GotchaPkmnCaught[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}\p"); // @ 83FD7A2 +const u8 sText_GotchaPkmnCaught2[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}{PAUSE 127}"); // @ 83FD7C0 +const u8 sText_GiveNicknameCaptured[] = _("Give a nickname to the\ncaptured {B_OPPONENT_MON1_NAME}?"); // @ 83FD7E0 +const u8 sText_PkmnSentToPC[] = _("{B_OPPONENT_MON1_NAME} was sent to\n{B_PC_CREATOR_NAME} PC."); // @ 83FD804 +const u8 sText_Someones[] = _("someone's"); // @ 83FD81A +const u8 sText_Bills[] = _("BILL's"); // @ 83FD824 +const u8 gUnknown_83FD82B[] = _("{B_OPPONENT_MON1_NAME}'s data was\nadded to the POKéDEX.\p"); // @ 83FD82B +const u8 gUnknown_83FD850[] = _("It is raining."); // @ 83FD850 +const u8 gUnknown_83FD85F[] = _("A sandstorm is raging."); // @ 83FD85F +const u8 gUnknown_83FD876[] = _("The BOX is full!\nYou can't catch any more!\p"); // @ 83FD876 +const u8 sText_EnigmaBerry[] = _("ENIGMA BERRY"); // @ 83FD8A2 +const u8 sText_BerrySuffix[] = _(" BERRY"); // @ 83FD8AF +const u8 gUnknown_83FD8B6[] = _("ナゾ"); // @ 83FD8B6 +const u8 gUnknown_83FD8B9[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured paralysis!"); // @ 83FD8B9 +const u8 gUnknown_83FD8D2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured poison!"); // @ 83FD8D2 +const u8 gUnknown_83FD8E8[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nhealed its burn!"); // @ 83FD8E8 +const u8 gUnknown_83FD901[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ndefrosted it!"); // @ 83FD901 +const u8 gUnknown_83FD917[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nwoke it from its sleep!"); // @ 83FD917 +const u8 gUnknown_83FD937[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nsnapped it out of confusion!"); // @ 83FD937 +const u8 gUnknown_83FD95C[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured its {B_BUFF1} problem!"); // @ 83FD95C +const u8 gUnknown_83FD97A[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nnormalized its status!"); // @ 83FD97A +const u8 gUnknown_83FD999[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored health!"); // @ 83FD999 +const u8 gUnknown_83FD9B2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored {B_BUFF1}'s PP!"); // @ 83FD9B2 +const u8 gUnknown_83FD9CC[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored its status!"); // @ 83FD9CC +const u8 gUnknown_83FD9E9[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored its HP a little!"); // @ 83FD9E9 +const u8 gUnknown_83FDA0B[] = _("{B_LAST_ITEM}'s effect allows only\n{B_CURRENT_MOVE} to be used!\p"); // @ 83FDA0B +const u8 gUnknown_83FDA33[] = _("{B_DEF_NAME_WITH_PREFIX} hung on\nusing its {B_LAST_ITEM}!"); // @ 83FDA33 +const u8 gUnknown_83FDA4C[] = _(""); // @ 83FDA4C +const u8 gUnknown_83FDA4D[] = _("{B_PLAYER_NAME} played the {B_LAST_ITEM}.\pNow, that's a catchy tune!"); // @ 83FDA4D +const u8 gUnknown_83FDA7A[] = _("{B_PLAYER_NAME} played the\n{B_LAST_ITEM}."); // @ 83FDA7A +const u8 gUnknown_83FDA8C[] = _("The POKéMON hearing the FLUTE\nawoke!"); // @ 83FDA8C +const u8 gUnknown_83FDAB1[] = _("You throw a BALL now, right?\nI… I'll do my best!"); // @ 83FDAB1 +const u8 gUnknown_83FDAE2[] = _("OAK: Oh, for Pete's sake…\nSo pushy, as always.\p{B_PLAYER_NAME}.\pYou've never had a POKéMON battle\nbefore, have you?\pA POKéMON battle is when TRAINERS\npit their POKéMON against each\lother.\p"); // @ 83FDAE2 +const u8 gUnknown_83FDB92[] = _("The TRAINER that makes the other\nTRAINER's POKéMON faint by lowering\ltheir HP to “0,” wins.\p"); // @ 83FDB92 +const u8 gUnknown_83FDBEF[] = _("But rather than talking about it,\nyou'll learn more from experience.\pTry battling and see for yourself.\p"); // @ 83FDBEF +const u8 gUnknown_83FDC58[] = _("OAK: Inflicting damage on the foe\nis the key to any battle.\p"); // @ 83FDC58 +const u8 gUnknown_83FDC95[] = _("OAK: Lowering the foe's stats\nwill put you at an advantage.\p"); // @ 83FDC95 +const u8 gUnknown_83FDCD2[] = _("OAK: Keep your eyes on your\nPOKéMON's HP.\pIt will faint if the HP drops to\n“0.”\p"); // @ 83FDCD2 +const u8 gUnknown_83FDD23[] = _("OAK: No! There's no running away\nfrom a TRAINER POKéMON battle!\p"); // @ 83FDD23 +const u8 gUnknown_83FDD64[] = _("OAK: Hm! Excellent!\pIf you win, you earn prize money,\nand your POKéMON will grow!\pBattle other TRAINERS and make\nyour POKéMON strong!\p"); // @ 83FDD64 +const u8 gUnknown_83FDDEB[] = _("OAK: Hm…\nHow disappointing…\pIf you win, you earn prize money,\nand your POKéMON grow.\pBut if you lose, {B_PLAYER_NAME}, you end\nup paying prize money…\pHowever, since you had no warning\nthis time, I'll pay for you.\pBut things won't be this way once\nyou step outside these doors.\pThat's why you must strengthen your\nPOKéMON by battling wild POKéMON.\p"); // @ 83FDDEB + +const u8 *const gBattleStringsTable[] = { + gUnknown_83FB219, + gUnknown_83FB265, + gUnknown_83FB28E, + gUnknown_83FB2A4, + gUnknown_83FB2B6, + gUnknown_83FB2D1, + gUnknown_83FB2FC, + gUnknown_83FB31F, + gUnknown_83FB32E, + gUnknown_83FB343, + gUnknown_83FD1B8, + gUnknown_83FB36B, + gUnknown_83FB37F, + gUnknown_83FCBA5, + gUnknown_83FB394, + gUnknown_83FB3EA, + gUnknown_83FB400, + gUnknown_83FB40D, + gUnknown_83FB41A, + gUnknown_83FB433, + gUnknown_83FB451, + gUnknown_83FB508, + gUnknown_83FB545, + gUnknown_83FB555, + gUnknown_83FB565, + gUnknown_83FB57C, + gUnknown_83FB592, + gUnknown_83FB5A8, + gUnknown_83FB5BC, + gUnknown_83FB5CD, + gUnknown_83FB5E2, + gUnknown_83FB5F8, + gUnknown_83FB610, + gUnknown_83FB626, + gUnknown_83FB641, + gUnknown_83FB650, + gUnknown_83FB663, + gUnknown_83FB692, + gUnknown_83FB6A7, + gUnknown_83FB6BF, + gUnknown_83FB6D3, + gUnknown_83FB6E5, + gUnknown_83FB6F7, + gUnknown_83FB70F, + gUnknown_83FB73A, + gUnknown_83FB76A, + gUnknown_83FB78A, + gUnknown_83FB7A3, + gUnknown_83FB7BF, + gUnknown_83FB7D5, + gUnknown_83FB7EE, + gUnknown_83FB806, + gUnknown_83FB826, + gUnknown_83FB844, + gUnknown_83FB854, + gUnknown_83FB871, + gUnknown_83FB885, + gUnknown_83FB89D, + gUnknown_83FB8AE, + gUnknown_83FB8C5, + gUnknown_83FB8E0, + gUnknown_83FB8F3, + gUnknown_83FB914, + gUnknown_83FB921, + gUnknown_83FB935, + gUnknown_83FB946, + gUnknown_83FB97F, + gUnknown_83FB9B8, + gUnknown_83FB9D9, + gUnknown_83FB9FF, + gUnknown_83FBA2F, + gUnknown_83FBA41, + gUnknown_83FBA5E, + gUnknown_83FBA79, + gUnknown_83FBA8E, + gUnknown_83FBAA3, + gUnknown_83FBAB2, + gUnknown_83FBAC3, + gUnknown_83FBAF3, + gUnknown_83FBB11, + gUnknown_83FBB4C, + gUnknown_83FBB62, + gUnknown_83FBB71, + gUnknown_83FBB83, + gUnknown_83FBB99, + BattleText_MistShroud, + gUnknown_83FBBD0, + BattleText_GetPumped, + gUnknown_83FBBFF, + gUnknown_83FBC16, + gUnknown_83FBC2B, + gUnknown_83FBC4C, + gUnknown_83FBC74, + gUnknown_83FBC83, + gUnknown_83FBC99, + gUnknown_83FBCBE, + gUnknown_83FBCD1, + gUnknown_83FBCDD, + gUnknown_83FBCFC, + gUnknown_83FBD16, + gUnknown_83FBD2B, + gUnknown_83FBD43, + gUnknown_83FBD53, + gUnknown_83FBD74, + gUnknown_83FBD86, + gUnknown_83FBDA3, + gUnknown_83FBDC4, + gUnknown_83FBDE2, + gUnknown_83FBE00, + gUnknown_83FBE16, + gUnknown_83FBE2B, + gUnknown_83FBE4E, + gUnknown_83FBE61, + gUnknown_83FBE73, + gUnknown_83FBE8B, + gUnknown_83FBEA1, + gUnknown_83FBEBE, + gUnknown_83FBEE2, + gUnknown_83FBEFA, + gUnknown_83FBF0C, + gUnknown_83FBF23, + gUnknown_83FC687, + gUnknown_83FBF39, + gUnknown_83FBF51, + gUnknown_83FBF63, + gUnknown_83FBF76, + gUnknown_83FBF89, + gUnknown_83FBF99, + gUnknown_83FBFBF, + gUnknown_83FBFD3, + gUnknown_83FBFEA, + gUnknown_83FBFFC, + gUnknown_83FC011, + gUnknown_83FC02B, + gUnknown_83FC048, + gUnknown_83FC072, + gUnknown_83FC090, + gUnknown_83FC0C6, + gUnknown_83FC0DC, + gUnknown_83FC0EE, + gUnknown_83FC10C, + gUnknown_83FC11E, + gUnknown_83FC132, + gUnknown_83FC140, + gUnknown_83FC168, + gUnknown_83FC185, + gUnknown_83FC19D, + gUnknown_83FC1B1, + gUnknown_83FC1C6, + gUnknown_83FC1DB, + gUnknown_83FC1F1, + gUnknown_83FC224, + gUnknown_83FC231, + gUnknown_83FC254, + gUnknown_83FC26D, + gUnknown_83FC28A, + gUnknown_83FC670, + gUnknown_83FC2AA, + gUnknown_83FC69D, + gUnknown_83FC2C7, + gUnknown_83FC2E3, + gUnknown_83FC6D6, + gUnknown_83FC2FA, + gUnknown_83FC312, + gUnknown_83FC377, + gUnknown_83FC38A, + gUnknown_83FC39A, + gUnknown_83FC3AF, + gUnknown_83FC3C5, + gUnknown_83FC3EB, + gUnknown_83FC40E, + gUnknown_83FC421, + gUnknown_83FC439, + gUnknown_83FC461, + gUnknown_83FC6F8, + gUnknown_83FC483, + gUnknown_83FC4AB, + gUnknown_83FC4D6, + gUnknown_83FC4F0, + gUnknown_83FC518, + gUnknown_83FC53D, + gUnknown_83FC715, + gUnknown_83FC72B, + gUnknown_83FC745, + gUnknown_83FC75D, + gUnknown_83FC780, + gUnknown_83FC7B6, + gUnknown_83FC7D3, + gUnknown_83FC7EF, + gUnknown_83FC809, + gUnknown_83FC825, + gUnknown_83FC841, + gUnknown_83FC860, + gUnknown_83FC87B, + gUnknown_83FC895, + gUnknown_83FC8B1, + gUnknown_83FC8C2, + gUnknown_83FCB41, + BattleText_Rose, + gUnknown_83FCB50, + gUnknown_83FCB59, + gUnknown_83FCB5F, + BattleText_UnknownString3, + gUnknown_83FCB8F, + gUnknown_83FCB9A, + gUnknown_83FCBE4, + gUnknown_83FCBF4, + gUnknown_83FCC07, + gUnknown_83FCC33, + gUnknown_83FCC5B, + gUnknown_83FCC74, + sText_GotAwaySafely, + gUnknown_83FCCD2, + gUnknown_83FCDB3, + gUnknown_83FCDE2, + gUnknown_83FCDF1, + gUnknown_83FCDF2, + gUnknown_83FCE08, + gUnknown_83FCE17, + gUnknown_83FCE38, + gUnknown_83FCE50, + gUnknown_83FCE64, + gUnknown_83FCE78, + gUnknown_83FCE90, + gUnknown_83FCEA8, + gUnknown_83FCEBA, + gUnknown_83FCECE, + gUnknown_83FCEE3, + gUnknown_83FCEFB, + gUnknown_83FCF14, + gUnknown_83FCF2C, + gUnknown_83FCF40, + gUnknown_83FCF54, + gUnknown_83FCF6C, + gUnknown_83FCF7E, + gUnknown_83FCFA0, + gUnknown_83FCFC2, + gUnknown_83FCFE4, + gUnknown_83FD006, + gUnknown_83FD022, + gUnknown_83FD048, + gUnknown_83FD068, + gUnknown_83FD077, + gUnknown_83FD0A7, + gUnknown_83FD0CA, + sText_PlayerUsedItem, + sText_OldManUsedItem, + sText_TrainerBlockedBall, + sText_DontBeAThief, + sText_ItDodgedBall, + sText_YouMissedPkmn, + sText_PkmnBrokeFree, + sText_ItAppearedCaught, + sText_AarghAlmostHadIt, + sText_ShootSoClose, + sText_GotchaPkmnCaught, + sText_GotchaPkmnCaught2, + sText_GiveNicknameCaptured, + sText_PkmnSentToPC, + gUnknown_83FD82B, + gUnknown_83FD850, + gUnknown_83FD85F, + gUnknown_83FB525, + gUnknown_83FD0F1, + gUnknown_83FD111, + gUnknown_83FD124, + gUnknown_83FD135, + gUnknown_83FD14B, + gUnknown_83FD15A, + gUnknown_83FD16A, + gUnknown_83FD186, + gUnknown_83FD1DF, + gUnknown_83FD1FA, + gUnknown_83FD218, + gUnknown_83FD232, + gUnknown_83FD23F, + gUnknown_83FB218, + gUnknown_83FB218, + gUnknown_83FD24D, + gUnknown_83FD8B9, + gUnknown_83FD8D2, + gUnknown_83FD8E8, + gUnknown_83FD901, + gUnknown_83FD917, + gUnknown_83FD937, + gUnknown_83FD95C, + gUnknown_83FD999, + gUnknown_83FD9B2, + gUnknown_83FD9CC, + gUnknown_83FD9E9, + gUnknown_83FDA0B, + gUnknown_83FDA33, + gUnknown_83FDA4C, + gUnknown_83FC8D5, + gUnknown_83FC8ED, + gUnknown_83FC913, + gUnknown_83FC935, + gUnknown_83FC979, + gUnknown_83FC993, + gUnknown_83FC9AA, + gUnknown_83FC9C7, + gUnknown_83FC9E5, + gUnknown_83FCA03, + gUnknown_83FC554, + gUnknown_83FC576, + gUnknown_83FBAD2, + gUnknown_83FBAE5, + gUnknown_83FCC39, + gUnknown_83FC591, + sText_PlayerDefeatedLinkTrainerTrainer1, + gUnknown_83FC5A2, + gUnknown_83FC5CC, + gUnknown_83FC5E8, + gUnknown_83FCB75, + gUnknown_83FC5F6, + gUnknown_83FC79D, + gUnknown_83FBB2F, + gUnknown_83FB282, + gUnknown_83FB283, + gUnknown_83FC955, + gUnknown_83FB3AF, + gUnknown_83FDAB1, + gUnknown_83FCA13, + gUnknown_83FC208, + gUnknown_83FC60C, + gUnknown_83FB359, + gUnknown_83FCCA0, + gUnknown_83FCCBB, + gUnknown_83FC631, + gUnknown_83FCA49, + gUnknown_83FD97A, + sText_Trainer1UsedItem, + gUnknown_83FD876, + gUnknown_83FB3D3, + gUnknown_83FCA71, + gUnknown_83FCA8E, + gUnknown_83FB67B, + gUnknown_83FCBC5, + gUnknown_83FC900, + gUnknown_83FBC62, + gUnknown_83FB997, + gUnknown_83FB95E, + gUnknown_83FC646, + gUnknown_83FCAAA, + gUnknown_83FCAD1, + gUnknown_83FB534, + gUnknown_83FC337, + gUnknown_83FC347, + gUnknown_83FC357, + gUnknown_83FC65A, + gUnknown_83FCAEF, + gUnknown_83FDD64, + gUnknown_83FDDEB, + gUnknown_83FB484, + gUnknown_83FB4BE, + Text_1A5CF1, + Text_1A5D31, + Text_1A5D6E, + Text_1A5DB1, + sText_PokeDudeUsedItem, + gUnknown_83FDA4D, + gUnknown_83FDA7A, + gUnknown_83FDA8C, + gUnknown_83FB21C, + gUnknown_83FB262, + gUnknown_83FB4F7, + gUnknown_83FCB0C, + gUnknown_83FCB26, + gUnknown_83FD322, + gUnknown_83FD34D, + gUnknown_83FB21F, + gUnknown_83FB232, + gUnknown_83FB235, + gUnknown_83FB248 +}; + +const u16 gMissStringIds[] = { + STRINGID_ATTACKMISSED, + STRINGID_PKMNPROTECTEDITSELF, + STRINGID_PKMNAVOIDEDATTACK, + STRINGID_AVOIDEDDAMAGE, + STRINGID_PKMNMAKESGROUNDMISS +}; + +const u16 gNoEscapeStringIds[] = { + STRINGID_CANTESCAPE, + STRINGID_DONTLEAVEBIRCH, + STRINGID_PREVENTSESCAPE, + STRINGID_CANTESCAPE2, + STRINGID_ATTACKERCANTESCAPE +}; + +const u16 gMoveWeatherChangeStringIds[] = { + STRINGID_STARTEDTORAIN, + STRINGID_DOWNPOURSTARTED, + STRINGID_BUTITFAILED, + STRINGID_SANDSTORMBREWED, + STRINGID_SUNLIGHTGOTBRIGHT, + STRINGID_STARTEDHAIL +}; + +const u16 gSandStormHailContinuesStringIds[] = { + STRINGID_SANDSTORMRAGES, + STRINGID_HAILCONTINUES +}; + +const u16 gSandStormHailDmgStringIds[] = { + STRINGID_PKMNBUFFETEDBYSANDSTORM, + STRINGID_PKMNPELTEDBYHAIL +}; + +const u16 gSandStormHailEndStringIds[] = { + STRINGID_SANDSTORMSUBSIDED, + STRINGID_HAILSTOPPED +}; + +const u16 gRainContinuesStringIds[] = { + STRINGID_RAINCONTINUES, + STRINGID_DOWNPOURCONTINUES, + STRINGID_RAINSTOPPED +}; + +const u16 gProtectLikeUsedStringIds[] = { + STRINGID_PKMNPROTECTEDITSELF2, + STRINGID_PKMNBRACEDITSELF, + STRINGID_BUTITFAILED +}; + +const u16 gReflectLightScreenSafeguardStringIds[] = { + STRINGID_BUTITFAILED, + STRINGID_PKMNRAISEDDEF, + STRINGID_PKMNRAISEDDEFALITTLE, + STRINGID_PKMNRAISEDSPDEF, + STRINGID_PKMNRAISEDSPDEFALITTLE, + STRINGID_PKMNCOVEREDBYVEIL +}; + +const u16 gLeechSeedStringIds[] = { + STRINGID_PKMNSEEDED, + STRINGID_PKMNEVADEDATTACK, + STRINGID_ITDOESNTAFFECT, + STRINGID_PKMNSAPPEDBYLEECHSEED, + STRINGID_ITSUCKEDLIQUIDOOZE +}; + +const u16 gRestUsedStringIds[] = { + STRINGID_PKMNWENTTOSLEEP, + STRINGID_PKMNSLEPTHEALTHY +}; + +const u16 gUproarOverTurnStringIds[] = { + STRINGID_PKMNMAKINGUPROAR, + STRINGID_PKMNCALMEDDOWN +}; + +const u16 gStockpileUsedStringIds[] = { + STRINGID_PKMNSTOCKPILED, + STRINGID_PKMNCANTSTOCKPILE +}; + +const u16 gWokeUpStringIds[] = { + STRINGID_PKMNWOKEUP, + STRINGID_PKMNWOKEUPINUPROAR +}; + +const u16 gSwallowFailStringIds[] = { + STRINGID_FAILEDTOSWALLOW, + STRINGID_PKMNHPFULL +}; + +const u16 gUproarAwakeStringIds[] = { + STRINGID_PKMNCANTSLEEPINUPROAR2, + STRINGID_UPROARKEPTPKMNAWAKE, + STRINGID_PKMNSTAYEDAWAKEUSING +}; + +const u16 gStatUpStringIds[] = { + STRINGID_PKMNSSTATCHANGED, + STRINGID_PKMNSSTATCHANGED2, + STRINGID_STATSWONTINCREASE, + STRINGID_EMPTYSTRING3, + STRINGID_USINGXTHEYOFZN, + STRINGID_PKMNUSEDXTOGETPUMPED +}; + +const u16 gStatDownStringIds[] = { + STRINGID_PKMNSSTATCHANGED3, + STRINGID_PKMNSSTATCHANGED4, + STRINGID_STATSWONTDECREASE, + STRINGID_EMPTYSTRING3 +}; + +const u16 gFirstTurnOfTwoStringIds[] = { + STRINGID_PKMNWHIPPEDWHIRLWIND, + STRINGID_PKMNTOOKSUNLIGHT, + STRINGID_PKMNLOWEREDHEAD, + STRINGID_PKMNISGLOWING, + STRINGID_PKMNFLEWHIGH, + STRINGID_PKMNDUGHOLE, + STRINGID_PKMNHIDUNDERWATER, + STRINGID_PKMNSPRANGUP +}; + +const u16 gWrappedStringIds[] = { + STRINGID_PKMNSQUEEZEDBYBIND, + STRINGID_PKMNWRAPPEDBY, + STRINGID_PKMNTRAPPEDINVORTEX, + STRINGID_PKMNCLAMPED, + STRINGID_PKMNTRAPPEDINVORTEX, + STRINGID_PKMNTRAPPEDBYSANDTOMB +}; + +const u16 gMistUsedStringIds[] = { + STRINGID_PKMNSHROUDEDINMIST, + STRINGID_BUTITFAILED +}; + +const u16 gFocusEnergyUsedStringIds[] = { + STRINGID_PKMNGETTINGPUMPED, + STRINGID_BUTITFAILED +}; + +const u16 gTransformUsedStringIds[] = { + STRINGID_PKMNTRANSFORMEDINTO, + STRINGID_BUTITFAILED +}; + +const u16 gSubsituteUsedStringIds[] = { + STRINGID_PKMNMADESUBSTITUTE, + STRINGID_TOOWEAKFORSUBSTITUTE +}; + +const u16 gGotPoisonedStringIds[] = { + STRINGID_PKMNWASPOISONED, + STRINGID_PKMNPOISONEDBY +}; + +const u16 gGotParalyzedStringIds[] = { + STRINGID_PKMNWASPARALYZED, + STRINGID_PKMNWASPARALYZEDBY +}; + +const u16 gFellAsleepStringIds[] = { + STRINGID_PKMNFELLASLEEP, + STRINGID_PKMNMADESLEEP +}; + +const u16 gGotBurnedStringIds[] = { + STRINGID_PKMNWASBURNED, + STRINGID_PKMNBURNEDBY +}; + +const u16 gGotFrozenStringIds[] = { + STRINGID_PKMNWASFROZEN, + STRINGID_PKMNFROZENBY +}; + +const u16 gGotDefrostedStringIds[] = { + STRINGID_PKMNWASDEFROSTED2, + STRINGID_PKMNWASDEFROSTEDBY +}; + +const u16 gKOFailedStringIds[] = { + STRINGID_ATTACKMISSED, + STRINGID_PKMNUNAFFECTED +}; + +const u16 gAttractUsedStringIds[] = { + STRINGID_PKMNFELLINLOVE, + STRINGID_PKMNSXINFATUATEDY +}; + +const u16 gLeechSeedDrainStringIds[] = { + STRINGID_PKMNENERGYDRAINED, + STRINGID_ITSUCKEDLIQUIDOOZE +}; + +const u16 gSportsUsedStringIds[] = { + STRINGID_ELECTRICITYWEAKENED, + STRINGID_FIREWEAKENED +}; + +const u16 gPartyStatusHealStringIds[] = { + STRINGID_BELLCHIMED, + STRINGID_BELLCHIMED, + STRINGID_BELLCHIMED, + STRINGID_BELLCHIMED, + STRINGID_SOOTHINGAROMA +}; + +const u16 gFutureMoveUsedStringIds[] = { + STRINGID_PKMNFORESAWATTACK, + STRINGID_PKMNCHOSEXASDESTINY +}; + +const u16 gBallEscapeStringIds[] = { + STRINGID_PKMNBROKEFREE, + STRINGID_ITAPPEAREDCAUGHT, + STRINGID_AARGHALMOSTHADIT, + STRINGID_SHOOTSOCLOSE +}; + +const u16 gWeatherContinuesStringIds[] = { + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_SANDSTORMISRAGING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_SUNLIGHTSTRONG, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING, + STRINGID_ITISRAINING +}; + +const u16 gInobedientStringIds[] = { + STRINGID_PKMNLOAFING, + STRINGID_PKMNWONTOBEY, + STRINGID_PKMNTURNEDAWAY, + STRINGID_PKMNPRETENDNOTNOTICE +}; + +const u16 gSafariPokeblockResultStringIds[] = { + STRINGID_PKMNWATCHINGCAREFULLY, + STRINGID_PKMNANGRY, + STRINGID_PKMNEATING +}; + +const u16 gTrainerItemCuredStatusStringIds[] = { + STRINGID_PKMNSITEMSNAPPEDOUT, + STRINGID_PKMNSITEMCUREDPARALYSIS, + STRINGID_PKMNSITEMDEFROSTEDIT, + STRINGID_PKMNSITEMHEALEDBURN, + STRINGID_PKMNSITEMCUREDPOISON, + STRINGID_PKMNSITEMWOKEIT +}; + +const u16 gBerryEffectStringIds[] = { + STRINGID_PKMNSITEMCUREDPROBLEM, + STRINGID_PKMNSITEMNORMALIZEDSTATUS +}; + +const u16 gBRNPreventionStringIds[] = { + STRINGID_PKMNSXPREVENTSBURNS, + STRINGID_PKMNSXPREVENTSYSZ, + STRINGID_PKMNSXHADNOEFFECTONY +}; + +const u16 gPRLZPreventionStringIds[] = { + STRINGID_PKMNPREVENTSPARALYSISWITH, + STRINGID_PKMNSXPREVENTSYSZ, + STRINGID_PKMNSXHADNOEFFECTONY +}; + +const u16 gPSNPreventionStringIds[] = { + STRINGID_PKMNPREVENTSPOISONINGWITH, + STRINGID_PKMNSXPREVENTSYSZ, + STRINGID_PKMNSXHADNOEFFECTONY +}; + +const u16 gItemSwapStringIds[] = { + STRINGID_PKMNOBTAINEDX, + STRINGID_PKMNOBTAINEDX2, + STRINGID_PKMNOBTAINEDXYOBTAINEDZ +}; + +const u16 gFlashFireStringIds[] = { + STRINGID_PKMNRAISEDFIREPOWERWITH, + STRINGID_PKMNSXMADEYINEFFECTIVE +}; + +const u16 gCaughtMonStringIds[] = { + STRINGID_PKMNTRANSFERREDSOMEONESPC, + STRINGID_PKMNTRANSFERREDBILLSPC, + STRINGID_PKMNBOXSOMEONESPCFULL, + STRINGID_PKMNBOXBILLSPCFULL +}; + +const u16 gDoubleBattleRecallStrings[] = { + STRINGID_TRAINER1MON1COMEBACK, + STRINGID_TRAINER1MON1COMEBACK, + STRINGID_TRAINER1MON2COMEBACK, + STRINGID_TRAINER1MON1AND2COMEBACK +}; + +const u16 gTrappingMoves[] = { + MOVE_BIND, + MOVE_WRAP, + MOVE_FIRE_SPIN, + MOVE_CLAMP, + MOVE_WHIRLPOOL, + MOVE_SAND_TOMB, + 0xFFFF +}; + +const u8 gText_PkmnIsEvolving[] = _("What?\n{STR_VAR_1} is evolving!"); // @ 83FE672 +const u8 gText_CongratsPkmnEvolved[] = _("Congratulations! Your {STR_VAR_1}\nevolved into {STR_VAR_2}!{WAIT_SE}\p"); // @ 83FE688 +const u8 gText_PkmnStoppedEvolving[] = _("Huh? {STR_VAR_1}\nstopped evolving!\p"); // @ 83FE6B5 +const u8 gText_EllipsisQuestionMark[] = _("……?\p"); // @ 83FE6D0 +const u8 gText_WhatWillPkmnDo[] = _("What will\n{B_ACTIVE_NAME_WITH_PREFIX} do?"); // @ 83FE6D5 +const u8 gUnknown_83FE6E6[] = _("What will {B_PLAYER_NAME}\nthrow?"); // @ 83FE6E6 +const u8 gUnknown_83FE6FA[] = _("What will the\nold man do?"); // @ 83FE6FA +const u8 gText_LinkStandby[] = _("{PAUSE 16}Link standby…"); // @ 83FE714 +const u8 gUnknown_83FE725[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}FIGHT{CLEAR_TO 56}BAG\nPOKéMON{CLEAR_TO 56}RUN"); // @ 83FE725 +const u8 gUnknown_83FE747[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}BALL{CLEAR_TO 56}BAIT\nROCK{CLEAR_TO 56}RUN"); // @ 83FE747 +const u8 gText_MoveInterfacePP[] = _("PP "); // @ 83FE766 +const u8 gText_MoveInterfaceType[] = _("TYPE/"); // @ 83FE76A +const u8 gUnknown_83FE770[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}"); // @ 83FE770 +const u8 gUnknown_83FE779[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}どの わざを\nわすれさせたい?"); // @ 83FE779 +const u8 gText_BattleYesNoChoice[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}Yes\nNo"); // @ 83FE791 +const u8 gText_BattleSwitchWhich[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}Switch\nwhich?"); // @ 83FE7A0 +const u8 gUnknown_83FE7B6[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}"); // @ 83FE7B6 +const u8 gUnknown_83FE7BF[] = _("{RIGHT_ARROW_2}"); // @ 83FE7BF +const u8 gUnknown_83FE7C2[] = _("{PLUS}"); // @ 83FE7C2 +const u8 gUnknown_83FE7C5[] = _("-"); // @ 83FE7C5 + +const u8 gUnknown_83FE7C7[] = _("{SIZE 0}Max{SIZE 2} HP"); // @ 83FE7C7 +const u8 gUnknown_83FE7D4[] = _("ATTACK "); // @ 83FE7D4 +const u8 gUnknown_83FE7DC[] = _("DEFENSE"); // @ 83FE7DC +const u8 gUnknown_83FE7E4[] = _("SP. ATK"); // @ 83FE7E4 +const u8 gUnknown_83FE7EC[] = _("SP. DEF"); // @ 83FE7EC + +const u8 *const gUnknown_83FE7F4[] = { + gUnknown_83FE7C7, + gUnknown_83FE7E4, + gUnknown_83FE7D4, + gUnknown_83FE7EC, + gUnknown_83FE7DC, + sText_Speed +}; + +const u8 gUnknown_83FE80C[] = _("{HIGHLIGHT 2}SAFARI BALLS"); // +const u8 gText_HighlightRed_Left[] = _("{HIGHLIGHT 2}Left: "); // @ 83FE81C +const u8 gText_HighlightRed[] = _("{HIGHLIGHT 2}"); // @ 83FE826 +const u8 gText_Sleep[] = _("sleep"); // @ 83FE82A +const u8 gText_Poison[] = _("poison"); // @ 83FE830 +const u8 gText_Burn[] = _("burn"); // @ 83FE837 +const u8 gText_Paralysis[] = _("paralysis"); // @ 83FE83C +const u8 gText_Ice[] = _("ice"); // @ 83FE846 +const u8 gText_Confusion[] = _("confusion"); // @ 83FE84A +const u8 gText_Love[] = _("love"); // @ 83FE854 +const u8 gUnknown_83FE859[] = _(" "); // @ 83FE859 +const u8 gUnknown_83FE85C[] = _("\n"); // @ 83FE85C +const u8 gUnknown_83FE85E[] = _("\n"); // @ 83FE85E +const u8 gUnknown_83FE860[] = _(" is"); // @ 83FE860 +const u8 gUnknown_83FE864[] = _(" is"); // @ 83FE864 +const u8 gText_BadEgg[] = _("Bad EGG"); // @ 83FE868 +const u8 gUnknown_83FE870[] = _("ミツル"); // @ 83FE870 +const u8 gUnknown_83FE874[] = _("{HIGHLIGHT 0}Win"); // @ 83FE874 +const u8 gUnknown_83FE87B[] = _("{HIGHLIGHT 0}Loss"); // @ 83FE87B +const u8 gUnknown_83FE883[] = _("{HIGHLIGHT 0}Draw"); // @ 83FE883 +const u8 gUnknown_83FE88B[] = _(" is"); // @ 83FE88B +const u8 gUnknown_83FE88F[] = _("'s"); // @ 83FE88F +const u8 gUnknown_83FE892[] = _("a NORMAL move"); // @ 83FE892 +const u8 gUnknown_83FE8A0[] = _("a FIGHTING move"); // @ 83FE8A0 +const u8 gUnknown_83FE8B0[] = _("a FLYING move"); // @ 83FE8B0 +const u8 gUnknown_83FE8BE[] = _("a POISON move"); // @ 83FE8BE +const u8 gUnknown_83FE8CC[] = _("a GROUND move"); // @ 83FE8CC +const u8 gUnknown_83FE8DA[] = _("a ROCK move"); // @ 83FE8DA +const u8 gUnknown_83FE8E6[] = _("a BUG move"); // @ 83FE8E6 +const u8 gUnknown_83FE8F1[] = _("a GHOST move"); // @ 83FE8F1 +const u8 gUnknown_83FE8FE[] = _("a STEEL move"); // @ 83FE8FE +const u8 gUnknown_83FE90B[] = _("a ??? move"); // @ 83FE90B +const u8 gUnknown_83FE916[] = _("a FIRE move"); // @ 83FE916 +const u8 gUnknown_83FE922[] = _("a WATER move"); // @ 83FE922 +const u8 gUnknown_83FE92F[] = _("a GRASS move"); // @ 83FE92F +const u8 gUnknown_83FE93C[] = _("an ELECTRIC move"); // @ 83FE93C +const u8 gUnknown_83FE94D[] = _("a PSYCHIC move"); // @ 83FE94D +const u8 gUnknown_83FE95C[] = _("an ICE move"); // @ 83FE95C +const u8 gUnknown_83FE968[] = _("a DRAGON move"); // @ 83FE968 +const u8 gUnknown_83FE976[] = _("a DARK move"); // @ 83FE976 +const u8 gUnknown_83FE982[] = _("TIME BOARD"); // @ 83FE982 +const u8 gUnknown_83FE98D[] = _("CLEAR TIME"); // @ 83FE98D +const u8 gUnknown_83FE998[] = _("{STR_VAR_1}MIN. {STR_VAR_2}.{STR_VAR_3}SEC."); // @ 83FE998 +const u8 gUnknown_83FE9A9[] = _("1F"); // @ 83FE9A9 +const u8 gUnknown_83FE9AC[] = _("2F"); // @ 83FE9AC +const u8 gUnknown_83FE9AF[] = _("3F"); // @ 83FE9AF +const u8 gUnknown_83FE9B2[] = _("4F"); // @ 83FE9B2 +const u8 gUnknown_83FE9B5[] = _("5F"); // @ 83FE9B5 +const u8 gUnknown_83FE9B8[] = _("6F"); // @ 83FE9B8 +const u8 gUnknown_83FE9BB[] = _("7F"); // @ 83FE9BB +const u8 gUnknown_83FE9BE[] = _("8F"); // @ 83FE9BE + +const u8 *const gUnknown_83FE9C4[] = { + gOtherText_Single, + gOtherText_Double, + gOtherText_Knockout, + gOtherText_Mixed +}; + +const u8 gUnknown_83FE9D4[] = _("{PLAY_SE SE_NIGERU}{B_TRAINER1_CLASS} {B_TRAINER1_NAME} fled!"); // +const u8 sText_PlayerLostAgainstTrainer1[] = _("Player lost against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); // @ 83FE9E4 +const u8 sText_PlayerBattledToDrawTrainer1[] = _("Player battled to a draw against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); // @ 83FE9FF + +const u8 *const sATypeMove_Table[] = { + gUnknown_83FE892, + gUnknown_83FE8A0, + gUnknown_83FE8B0, + gUnknown_83FE8BE, + gUnknown_83FE8CC, + gUnknown_83FE8DA, + gUnknown_83FE8E6, + gUnknown_83FE8F1, + gUnknown_83FE8FE, + gUnknown_83FE90B, + gUnknown_83FE916, + gUnknown_83FE922, + gUnknown_83FE92F, + gUnknown_83FE93C, + gUnknown_83FE94D, + gUnknown_83FE95C, + gUnknown_83FE968, + gUnknown_83FE976 +}; + +const u16 gUnknown_83FEA70[] = { + MOVE_SWORDS_DANCE, + MOVE_STRENGTH, + MOVE_GROWTH, + MOVE_HARDEN, + MOVE_MINIMIZE, + MOVE_SMOKESCREEN, + MOVE_WITHDRAW, + MOVE_DEFENSE_CURL, + MOVE_EGG_BOMB, + MOVE_SMOG, + MOVE_BONE_CLUB, + MOVE_FLASH, + MOVE_SPLASH, + MOVE_ACID_ARMOR, + MOVE_BONEMERANG, + MOVE_REST, + MOVE_SHARPEN, + MOVE_SUBSTITUTE, + MOVE_MIND_READER, + MOVE_SNORE, + MOVE_PROTECT, + MOVE_SPIKES, + MOVE_ENDURE, + MOVE_ROLLOUT, + MOVE_SWAGGER, + MOVE_SLEEP_TALK, + MOVE_HIDDEN_POWER, + MOVE_PSYCH_UP, + MOVE_EXTREME_SPEED, + MOVE_FOLLOW_ME, + MOVE_TRICK, + MOVE_ASSIST, + MOVE_INGRAIN, + MOVE_KNOCK_OFF, + MOVE_CAMOUFLAGE, + MOVE_ASTONISH, + MOVE_ODOR_SLEUTH, + MOVE_GRASS_WHISTLE, + MOVE_SHEER_COLD, + MOVE_MUDDY_WATER, + MOVE_IRON_DEFENSE, + MOVE_BOUNCE, + MOVE_NONE, + + MOVE_TELEPORT, + MOVE_RECOVER, + MOVE_BIDE, + MOVE_AMNESIA, + MOVE_FLAIL, + MOVE_TAUNT, + MOVE_BULK_UP, + MOVE_NONE, + + MOVE_MEDITATE, + MOVE_AGILITY, + MOVE_MIMIC, + MOVE_DOUBLE_TEAM, + MOVE_BARRAGE, + MOVE_TRANSFORM, + MOVE_STRUGGLE, + MOVE_SCARY_FACE, + MOVE_CHARGE, + MOVE_WISH, + MOVE_BRICK_BREAK, + MOVE_YAWN, + MOVE_FEATHER_DANCE, + MOVE_TEETER_DANCE, + MOVE_MUD_SPORT, + MOVE_FAKE_TEARS, + MOVE_WATER_SPORT, + MOVE_CALM_MIND, + MOVE_NONE, + + MOVE_POUND, + MOVE_SCRATCH, + MOVE_VICE_GRIP, + MOVE_WING_ATTACK, + MOVE_FLY, + MOVE_BIND, + MOVE_SLAM, + MOVE_HORN_ATTACK, + MOVE_WRAP, + MOVE_THRASH, + MOVE_TAIL_WHIP, + MOVE_LEER, + MOVE_BITE, + MOVE_GROWL, + MOVE_ROAR, + MOVE_SING, + MOVE_PECK, + MOVE_ABSORB, + MOVE_STRING_SHOT, + MOVE_EARTHQUAKE, + MOVE_FISSURE, + MOVE_DIG, + MOVE_TOXIC, + MOVE_SCREECH, + MOVE_METRONOME, + MOVE_LICK, + MOVE_CLAMP, + MOVE_CONSTRICT, + MOVE_POISON_GAS, + MOVE_BUBBLE, + MOVE_SLASH, + MOVE_SPIDER_WEB, + MOVE_NIGHTMARE, + MOVE_CURSE, + MOVE_FORESIGHT, + MOVE_CHARM, + MOVE_ATTRACT, + MOVE_ROCK_SMASH, + MOVE_UPROAR, + MOVE_SPIT_UP, + MOVE_SWALLOW, + MOVE_TORMENT, + MOVE_FLATTER, + MOVE_ROLE_PLAY, + MOVE_ENDEAVOR, + MOVE_TICKLE, + MOVE_COVET, + MOVE_NONE +}; + +// code +void BufferStringBattle(u16 stringID) +{ + s32 i; + const u8 *stringPtr = NULL; + + gBattleMsgDataPtr = (struct BattleMsgData*)(&gBattleBufferA[gActiveBattler][4]); + gLastUsedItem = gBattleMsgDataPtr->lastItem; + gLastUsedAbility = gBattleMsgDataPtr->lastAbility; + gBattleScripting.battler = gBattleMsgDataPtr->scrActive; + *(&gBattleStruct->field_52) = gBattleMsgDataPtr->unk1605E; + *(&gBattleStruct->hpScale) = gBattleMsgDataPtr->hpScale; + gPotentialItemEffectBattler = gBattleMsgDataPtr->itemEffectBattler; + *(&gBattleStruct->stringMoveType) = gBattleMsgDataPtr->moveType; + + for (i = 0; i < MAX_BATTLERS_COUNT; i++) + { + sBattlerAbilities[i] = gBattleMsgDataPtr->abilities[i]; + } + for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; i++) + { + gBattleTextBuff1[i] = gBattleMsgDataPtr->textBuffs[0][i]; + gBattleTextBuff2[i] = gBattleMsgDataPtr->textBuffs[1][i]; + gBattleTextBuff3[i] = gBattleMsgDataPtr->textBuffs[2][i]; + } + + switch (stringID) + { + case STRINGID_INTROMSG: // first battle msg + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + stringPtr = sText_TwoLinkTrainersWantToBattle; + } + else + { + if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + stringPtr = sText_Trainer1WantsToBattle; + else + stringPtr = sText_LinkTrainerWantsToBattle; + } + } + else + { + stringPtr = sText_Trainer1WantsToBattle; + } + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_GHOST) + { + if (gBattleTypeFlags & BATTLE_TYPE_LEGENDARY) + stringPtr = gUnknown_83FD30D; + else + stringPtr = gUnknown_83FD2D9; + } + else if (gBattleTypeFlags & BATTLE_TYPE_LEGENDARY) + stringPtr = sText_WildPkmnAppeared2; + else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) // interesting, looks like they had something planned for wild double battles + stringPtr = sText_TwoWildPkmnAppeared; + else if (gBattleTypeFlags & BATTLE_TYPE_OLD_MAN_TUTORIAL) + stringPtr = sText_WildPkmnAppearedPause; + else + stringPtr = sText_WildPkmnAppeared; + } + break; + case STRINGID_INTROSENDOUT: // poke first send-out + if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + { + if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = sText_LinkPartnerSentOutPkmnGoPkmn; + else + stringPtr = sText_GoTwoPkmn; + } + else + { + stringPtr = sText_GoPkmn; + } + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = sText_TwoLinkTrainersSentOutPkmn; + else if (gBattleTypeFlags & BATTLE_TYPE_LINK) + stringPtr = sText_LinkTrainerSentOutTwoPkmn; + else + stringPtr = sText_Trainer1SentOutTwoPkmn; + } + else + { + if (!(gBattleTypeFlags & BATTLE_TYPE_LINK)) + stringPtr = sText_Trainer1SentOutPkmn; + else if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + stringPtr = sText_Trainer1SentOutPkmn; + else + stringPtr = sText_LinkTrainerSentOutPkmn; + } + } + break; + case STRINGID_RETURNMON: // sending poke to ball msg + if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + { + if (*(&gBattleStruct->hpScale) == 0) + stringPtr = sText_PkmnThatsEnough; + else if (*(&gBattleStruct->hpScale) == 1 || gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + stringPtr = sText_PkmnComeBack; + else if (*(&gBattleStruct->hpScale) == 2) + stringPtr = sText_PkmnOkComeBack; + else + stringPtr = sText_PkmnGoodComeBack; + } + else + { + if (gTrainerBattleOpponent_A == TRAINER_LINK_OPPONENT) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = sText_LinkTrainer2WithdrewPkmn; + else + stringPtr = sText_LinkTrainer1WithdrewPkmn; + } + else + { + stringPtr = sText_Trainer1WithdrewPkmn; + } + } + break; + case STRINGID_SWITCHINMON: // switch-in msg + if (GetBattlerSide(gBattleScripting.battler) == B_SIDE_PLAYER) + { + if (*(&gBattleStruct->hpScale) == 0 || gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + stringPtr = sText_GoPkmn2; + else if (*(&gBattleStruct->hpScale) == 1) + stringPtr = sText_DoItPkmn; + else if (*(&gBattleStruct->hpScale) == 2) + stringPtr = sText_GoForItPkmn; + else + stringPtr = sText_YourFoesWeakGetEmPkmn; + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = sText_LinkTrainerMultiSentOutPkmn; + else if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + stringPtr = sText_Trainer1SentOutPkmn2; + else + stringPtr = sText_LinkTrainerSentOutPkmn2; + } + else + { + stringPtr = sText_Trainer1SentOutPkmn2; + } + } + break; + case STRINGID_USEDMOVE: // pokemon used a move msg + ChooseMoveUsedParticle(gBattleTextBuff1); // buff1 doesn't appear in the string, leftover from japanese move names + + if (gBattleMsgDataPtr->currentMove >= MOVES_COUNT) + StringCopy(gBattleTextBuff2, sATypeMove_Table[*(&gBattleStruct->stringMoveType)]); + else + StringCopy(gBattleTextBuff2, gMoveNames[gBattleMsgDataPtr->currentMove]); + + ChooseTypeOfMoveUsedString(gBattleTextBuff2); + stringPtr = sText_AttackerUsedX; + break; + case STRINGID_BATTLEEND: // battle end + if (gBattleTextBuff1[0] & B_OUTCOME_LINK_BATTLE_RAN) + { + gBattleTextBuff1[0] &= ~(B_OUTCOME_LINK_BATTLE_RAN); + if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT && gBattleTextBuff1[0] != B_OUTCOME_DREW) + gBattleTextBuff1[0] ^= (B_OUTCOME_LOST | B_OUTCOME_WON); + + if (gBattleTextBuff1[0] == B_OUTCOME_LOST || gBattleTextBuff1[0] == B_OUTCOME_DREW) + stringPtr = sText_GotAwaySafely; + else if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = sText_TwoWildFled; + else if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + stringPtr = gUnknown_83FE9D4; + else + stringPtr = gUnknown_83FCD92; + } + else + { + if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT && gBattleTextBuff1[0] != B_OUTCOME_DREW) + gBattleTextBuff1[0] ^= (B_OUTCOME_LOST | B_OUTCOME_WON); + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + switch (gBattleTextBuff1[0]) + { + case B_OUTCOME_WON: + stringPtr = sText_TwoLinkTrainersDefeated; + break; + case B_OUTCOME_LOST: + stringPtr = sText_PlayerLostToTwo; + break; + case B_OUTCOME_DREW: + stringPtr = sText_PlayerBattledToDrawVsTwo; + break; + } + } + else if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + { + switch (gBattleTextBuff1[0]) + { + case B_OUTCOME_WON: + stringPtr = sText_PlayerDefeatedLinkTrainerTrainer1; + break; + case B_OUTCOME_LOST: + stringPtr = sText_PlayerLostAgainstTrainer1; + break; + case B_OUTCOME_DREW: + stringPtr = sText_PlayerBattledToDrawTrainer1; + break; + } + } + else + { + switch (gBattleTextBuff1[0]) + { + case B_OUTCOME_WON: + stringPtr = sText_PlayerDefeatedLinkTrainer; + break; + case B_OUTCOME_LOST: + stringPtr = sText_PlayerLostAgainstLinkTrainer; + break; + case B_OUTCOME_DREW: + stringPtr = sText_PlayerBattledToDrawLinkTrainer; + break; + } + } + } + break; + default: // load a string from the table + if (stringID >= BATTLESTRINGS_COUNT + BATTLESTRINGS_ID_ADDER) + { + gDisplayedStringBattle[0] = EOS; + return; + } + else + { + stringPtr = gBattleStringsTable[stringID - BATTLESTRINGS_ID_ADDER]; + } + break; + } + + BattleStringExpandPlaceholdersToDisplayedString(stringPtr); +} + +u32 BattleStringExpandPlaceholdersToDisplayedString(const u8* src) +{ + BattleStringExpandPlaceholders(src, gDisplayedStringBattle); +} + +const u8* TryGetStatusString(u8 *src) +{ + u32 i; + u8 status[] = _("$$$$$$$"); + u32 chars1, chars2; + u8* statusPtr; + + statusPtr = status; + for (i = 0; i < 8; i++) + { + if (*src == EOS) + break; + *statusPtr = *src; + src++; + statusPtr++; + } + + chars1 = *(u32*)(&status[0]); + chars2 = *(u32*)(&status[4]); + + for (i = 0; i < ARRAY_COUNT(gStatusConditionStringsTable); i++) + { + if (chars1 == *(u32*)(&gStatusConditionStringsTable[i][0][0]) + && chars2 == *(u32*)(&gStatusConditionStringsTable[i][0][4])) + return gStatusConditionStringsTable[i][1]; + } + return NULL; +} + +#define HANDLE_NICKNAME_STRING_CASE(battlerId, monIndex) \ + if (GetBattlerSide(battlerId) != B_SIDE_PLAYER) \ + { \ + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) \ + toCpy = sText_FoePkmnPrefix; \ + else \ + toCpy = sText_WildPkmnPrefix; \ + while (*toCpy != EOS) \ + { \ + dst[dstID] = *toCpy; \ + dstID++; \ + toCpy++; \ + } \ + GetMonData(&gEnemyParty[monIndex], MON_DATA_NICKNAME, text); \ + } \ + else \ + { \ + GetMonData(&gPlayerParty[monIndex], MON_DATA_NICKNAME, text); \ + } \ + StringGetEnd10(text); \ + toCpy = text; + +u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst) +{ + u32 dstID = 0; // if they used dstID, why not use srcID as well? + const u8 *toCpy = NULL; + u8 text[30]; + u8 multiplayerId; + s32 i; + + multiplayerId = GetMultiplayerId(); + + while (*src != EOS) + { + if (*src == PLACEHOLDER_BEGIN) + { + src++; + switch (*src) + { + case B_TXT_BUFF1: + if (gBattleTextBuff1[0] == B_BUFF_PLACEHOLDER_BEGIN) + { + ExpandBattleTextBuffPlaceholders(gBattleTextBuff1, gStringVar1); + toCpy = gStringVar1; + } + else + { + toCpy = TryGetStatusString(gBattleTextBuff1); + if (toCpy == NULL) + toCpy = gBattleTextBuff1; + } + break; + case B_TXT_BUFF2: + if (gBattleTextBuff2[0] == B_BUFF_PLACEHOLDER_BEGIN) + { + ExpandBattleTextBuffPlaceholders(gBattleTextBuff2, gStringVar2); + toCpy = gStringVar2; + } + else + toCpy = gBattleTextBuff2; + break; + case B_TXT_BUFF3: + if (gBattleTextBuff3[0] == B_BUFF_PLACEHOLDER_BEGIN) + { + ExpandBattleTextBuffPlaceholders(gBattleTextBuff3, gStringVar3); + toCpy = gStringVar3; + } + else + toCpy = gBattleTextBuff3; + break; + case B_TXT_COPY_VAR_1: + toCpy = gStringVar1; + break; + case B_TXT_COPY_VAR_2: + toCpy = gStringVar2; + break; + case B_TXT_COPY_VAR_3: + toCpy = gStringVar3; + break; + case B_TXT_PLAYER_MON1_NAME: // first player poke name + GetMonData(&gPlayerParty[gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]], + MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_OPPONENT_MON1_NAME: // first enemy poke name + GetMonData(&gEnemyParty[gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)]], + MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_PLAYER_MON2_NAME: // second player poke name + GetMonData(&gPlayerParty[gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT)]], + MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_OPPONENT_MON2_NAME: // second enemy poke name + GetMonData(&gEnemyParty[gBattlerPartyIndexes[GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT)]], + MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_LINK_PLAYER_MON1_NAME: // link first player poke name + GetMonData(&gPlayerParty[gBattlerPartyIndexes[gLinkPlayers[multiplayerId].id]], + MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_LINK_OPPONENT_MON1_NAME: // link first opponent poke name + GetMonData(&gEnemyParty[gBattlerPartyIndexes[gLinkPlayers[multiplayerId].id ^ 1]], + MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_LINK_PLAYER_MON2_NAME: // link second player poke name + GetMonData(&gPlayerParty[gBattlerPartyIndexes[gLinkPlayers[multiplayerId].id ^ 2]], + MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_LINK_OPPONENT_MON2_NAME: // link second opponent poke name + GetMonData(&gEnemyParty[gBattlerPartyIndexes[gLinkPlayers[multiplayerId].id ^ 3]], + MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_ATK_NAME_WITH_PREFIX_MON1: // attacker name with prefix, only battlerId 0/1 + HANDLE_NICKNAME_STRING_CASE(gBattlerAttacker, + gBattlerPartyIndexes[GetBattlerAtPosition(GET_BATTLER_SIDE(gBattlerAttacker))]) + break; + case B_TXT_ATK_PARTNER_NAME: // attacker partner name + if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER) + GetMonData( + &gPlayerParty[gBattlerPartyIndexes[GetBattlerAtPosition(GET_BATTLER_SIDE(gBattlerAttacker)) + + 2]], MON_DATA_NICKNAME, text); + else + GetMonData( + &gEnemyParty[gBattlerPartyIndexes[GetBattlerAtPosition(GET_BATTLER_SIDE(gBattlerAttacker)) + + 2]], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case B_TXT_ATK_NAME_WITH_PREFIX: // attacker name with prefix + HANDLE_NICKNAME_STRING_CASE(gBattlerAttacker, gBattlerPartyIndexes[gBattlerAttacker]) + break; + case B_TXT_DEF_NAME_WITH_PREFIX: // target name with prefix + HANDLE_NICKNAME_STRING_CASE(gBattlerTarget, gBattlerPartyIndexes[gBattlerTarget]) + break; + case B_TXT_EFF_NAME_WITH_PREFIX: // effect battlerId name with prefix + HANDLE_NICKNAME_STRING_CASE(gEffectBattler, gBattlerPartyIndexes[gEffectBattler]) + break; + case B_TXT_ACTIVE_NAME_WITH_PREFIX: // active battlerId name with prefix + HANDLE_NICKNAME_STRING_CASE(gActiveBattler, gBattlerPartyIndexes[gActiveBattler]) + break; + case B_TXT_SCR_ACTIVE_NAME_WITH_PREFIX: // scripting active battlerId name with prefix + HANDLE_NICKNAME_STRING_CASE(gBattleScripting.battler, gBattlerPartyIndexes[gBattleScripting.battler]) + break; + case B_TXT_CURRENT_MOVE: // current move name + if (gBattleMsgDataPtr->currentMove >= MOVES_COUNT) + toCpy = (const u8 *)&sATypeMove_Table[gBattleStruct->stringMoveType]; + else + toCpy = gMoveNames[gBattleMsgDataPtr->currentMove]; + break; + case B_TXT_LAST_MOVE: // originally used move name + if (gBattleMsgDataPtr->originallyUsedMove >= MOVES_COUNT) + toCpy = (const u8 *)&sATypeMove_Table[gBattleStruct->stringMoveType]; + else + toCpy = gMoveNames[gBattleMsgDataPtr->originallyUsedMove]; + break; + case B_TXT_LAST_ITEM: // last used item + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (gLastUsedItem == ITEM_ENIGMA_BERRY) + { + if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + if ((gBattleStruct->multiplayerId != 0 && (gPotentialItemEffectBattler & BIT_SIDE)) + || (gBattleStruct->multiplayerId == 0 && !(gPotentialItemEffectBattler & BIT_SIDE))) + { + StringCopy(text, gEnigmaBerries[gPotentialItemEffectBattler].name); + StringAppend(text, sText_BerrySuffix); + toCpy = text; + } + else + { + toCpy = sText_EnigmaBerry; + } + } + else + { + if (gLinkPlayers[gBattleStruct->multiplayerId].id == gPotentialItemEffectBattler) + { + StringCopy(text, gEnigmaBerries[gPotentialItemEffectBattler].name); + StringAppend(text, sText_BerrySuffix); + toCpy = text; + } + else + toCpy = sText_EnigmaBerry; + } + } + else + { + CopyItemName(gLastUsedItem, text); + toCpy = text; + } + } + else + { + CopyItemName(gLastUsedItem, text); + toCpy = text; + } + break; + case B_TXT_LAST_ABILITY: // last used ability + toCpy = gAbilityNames[gLastUsedAbility]; + break; + case B_TXT_ATK_ABILITY: // attacker ability + toCpy = gAbilityNames[sBattlerAbilities[gBattlerAttacker]]; + break; + case B_TXT_DEF_ABILITY: // target ability + toCpy = gAbilityNames[sBattlerAbilities[gBattlerTarget]]; + break; + case B_TXT_SCR_ACTIVE_ABILITY: // scripting active ability + toCpy = gAbilityNames[sBattlerAbilities[gBattleScripting.battler]]; + break; + case B_TXT_EFF_ABILITY: // effect battlerId ability + toCpy = gAbilityNames[sBattlerAbilities[gEffectBattler]]; + break; + case B_TXT_TRAINER1_CLASS: // trainer class name + if (gTrainerBattleOpponent_A == SECRET_BASE_OPPONENT) + toCpy = gTrainerClassNames[GetSecretBaseTrainerNameIndex()]; + else if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + toCpy = gTrainerClassNames[sub_80447F0()]; + else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + toCpy = gTrainerClassNames[GetBattleTowerTrainerClassNameId()]; + else if (gBattleTypeFlags & BATTLE_TYPE_TRAINER_TOWER) + toCpy = gTrainerClassNames[sub_815DA10()]; + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + toCpy = gTrainerClassNames[GetEreaderTrainerClassId()]; + else + toCpy = gTrainerClassNames[gTrainers[gTrainerBattleOpponent_A].trainerClass]; + break; + case B_TXT_TRAINER1_NAME: // trainer1 name + if (gTrainerBattleOpponent_A == SECRET_BASE_OPPONENT) + { + for (i = 0; i < (s32) ARRAY_COUNT(gBattleResources->secretBase->trainerName); i++) + text[i] = gBattleResources->secretBase->trainerName[i]; + text[i] = EOS; + toCpy = text; + } + if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + { + toCpy = gLinkPlayers[multiplayerId ^ BIT_SIDE].name; + } + else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + { + GetBattleTowerTrainerName(text); + } + else if (gBattleTypeFlags & BATTLE_TYPE_TRAINER_TOWER) + { + sub_815DA28(text); + toCpy = text; + } + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + { + CopyEReaderTrainerName5(text); + toCpy = text; + } + else + { + if (gTrainers[gTrainerBattleOpponent_A].trainerClass == CLASS_RIVAL + || gTrainers[gTrainerBattleOpponent_A].trainerClass == CLASS_RIVAL_2 + || gTrainers[gTrainerBattleOpponent_A].trainerClass == CLASS_CHAMPION_2) + toCpy = GetExpandedPlaceholder(6); + else + toCpy = gTrainers[gTrainerBattleOpponent_A].trainerName; + } + break; + case B_TXT_LINK_PLAYER_NAME: // link player name + toCpy = gLinkPlayers[multiplayerId].name; + break; + case B_TXT_LINK_PARTNER_NAME: // link partner name + toCpy = gLinkPlayers[GetBattlerMultiplayerId(BATTLE_PARTNER(gLinkPlayers[multiplayerId].id))].name; + break; + case B_TXT_LINK_OPPONENT1_NAME: // link opponent 1 name + toCpy = gLinkPlayers[GetBattlerMultiplayerId(BATTLE_OPPOSITE(gLinkPlayers[multiplayerId].id))].name; + break; + case B_TXT_LINK_OPPONENT2_NAME: // link opponent 2 name + toCpy = gLinkPlayers[GetBattlerMultiplayerId( + BATTLE_PARTNER(BATTLE_OPPOSITE(gLinkPlayers[multiplayerId].id)))].name; + break; + case B_TXT_LINK_SCR_TRAINER_NAME: // link scripting active name + toCpy = gLinkPlayers[GetBattlerMultiplayerId(gBattleScripting.battler)].name; + break; + case B_TXT_PLAYER_NAME: // player name + toCpy = gSaveBlock2Ptr->playerName; + break; + case B_TXT_TRAINER1_LOSE_TEXT: // trainerA lose text + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER_TOWER) + { + sub_815DC40(gStringVar4, 0); + toCpy = gStringVar4; + } + else + { + toCpy = GetTrainerALoseText(); + } + break; + case B_TXT_TRAINER1_WIN_TEXT: // trainerA win text + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER_TOWER) + { + sub_815DBF4(gStringVar4, 0); + toCpy = gStringVar4; + } + else + { + toCpy = GetTrainerWonSpeech(); + } + break; + case B_TXT_TRAINER2_LOSE_TEXT: + sub_815DC40(gStringVar4, 1); + toCpy = gStringVar4; + break; + case B_TXT_TRAINER2_WIN_TEXT: + sub_815DBF4(gStringVar4, 1); + toCpy = gStringVar4; + break; + case B_TXT_26: // ? + HANDLE_NICKNAME_STRING_CASE(gBattleScripting.battler, *(&gBattleStruct->field_52)) + break; + case B_TXT_PC_CREATOR_NAME: // lanette pc + if (FlagGet(FLAG_SYS_NOT_SOMEONES_PC)) + toCpy = sText_Bills; + else + toCpy = sText_Someones; + break; + case B_TXT_ATK_PREFIX2: + if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER) + toCpy = sText_AllyPkmnPrefix2; + else + toCpy = sText_FoePkmnPrefix3; + break; + case B_TXT_DEF_PREFIX2: + if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER) + toCpy = sText_AllyPkmnPrefix2; + else + toCpy = sText_FoePkmnPrefix3; + break; + case B_TXT_ATK_PREFIX1: + if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER) + toCpy = sText_AllyPkmnPrefix; + else + toCpy = sText_FoePkmnPrefix2; + break; + case B_TXT_DEF_PREFIX1: + if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER) + toCpy = sText_AllyPkmnPrefix; + else + toCpy = sText_FoePkmnPrefix2; + break; + case B_TXT_ATK_PREFIX3: + if (GetBattlerSide(gBattlerAttacker) == B_SIDE_PLAYER) + toCpy = sText_AllyPkmnPrefix3; + else + toCpy = sText_FoePkmnPrefix4; + break; + case B_TXT_DEF_PREFIX3: + if (GetBattlerSide(gBattlerTarget) == B_SIDE_PLAYER) + toCpy = sText_AllyPkmnPrefix3; + else + toCpy = sText_FoePkmnPrefix4; + break; + } + + // missing if (toCpy != NULL) check + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + if (*src == B_TXT_TRAINER1_LOSE_TEXT || *src == B_TXT_TRAINER1_WIN_TEXT + || *src == B_TXT_TRAINER2_LOSE_TEXT || *src == B_TXT_TRAINER2_WIN_TEXT) + { + dst[dstID] = EXT_CTRL_CODE_BEGIN; + dstID++; + dst[dstID] = 9; + dstID++; + } + } + else + { + dst[dstID] = *src; + dstID++; + } + src++; + } + + dst[dstID] = *src; + dstID++; + + return dstID; +} + +const struct BattleWindowText gUnknown_83FEB64[] = { + {PIXEL_FILL(0xf), 2, 0x02, 2, 0, 2, 1, 0x1, 0xf, 0x6}, + {PIXEL_FILL(0xf), 2, 0x02, 2, 0, 2, 0, 0x1, 0xf, 0x6}, + {PIXEL_FILL(0xe), 1, 0x00, 2, 0, 2, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 0, 0x00, 1, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 0, 0x00, 1, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 0, 0x00, 1, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 0, 0x00, 1, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 0, 0x00, 2, 0, 0, 0, 0xc, 0xe, 0xb}, + {PIXEL_FILL(0xe), 0, 0x00, 2, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 1, 0x0a, 2, 0, 2, 0, 0xc, 0xe, 0xb}, + {PIXEL_FILL(0xe), 1, 0x00, 2, 0, 2, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 1, 0x00, 2, 0, 2, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 2, 0x00, 0, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0x0), 0, 0x20, 0, 0, 0, 0, 0x1, 0x0, 0x2}, + {PIXEL_FILL(0xe), 2, 0x00, 2, 1, 2, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 2, 0x00, 2, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 2, 0x00, 2, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 2, 0x00, 2, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 2, 0x00, 2, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 2, 0x00, 2, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0xe), 2, 0x00, 2, 0, 0, 0, 0xd, 0xe, 0xf}, + {PIXEL_FILL(0x0), 2, 0x00, 2, 0, 0, 0, 0x1, 0x0, 0x6}, + {PIXEL_FILL(0x0), 2, 0x00, 2, 0, 0, 0, 0x1, 0x0, 0x6}, + {PIXEL_FILL(0x0), 2, 0x00, 2, 0, 0, 0, 0x1, 0x0, 0x6}, + {PIXEL_FILL(0x1), 4, 0x00, 1, 0, 1, 1, 0x2, 0x1, 0x3} +}; + +const u8 gUnknown_83FEC90[] = {0x04, 0x05, 0x02, 0x02}; -- cgit v1.2.3 From 87421614319b80a364a1e2d2afe9526559d476ca Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Sat, 23 Nov 2019 18:12:33 -0500 Subject: battle_message 2 --- src/battle_message.c | 533 +++++++++++++++++++++++++++++++++++++++++---------- src/pokemon.c | 2 +- 2 files changed, 433 insertions(+), 102 deletions(-) (limited to 'src') diff --git a/src/battle_message.c b/src/battle_message.c index 2924dc520..e9a0c74b3 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -1,6 +1,7 @@ #include "global.h" #include "battle_string_ids.h" #include "battle.h" +#include "palette.h" #include "battle_anim.h" #include "string_util.h" #include "text.h" @@ -14,6 +15,10 @@ #include "battle_tower.h" #include "trainer_tower.h" #include "battle_setup.h" +#include "field_specials.h" +#include "new_menu_helpers.h" +#include "battle_controllers.h" +#include "graphics.h" #include "constants/moves.h" #include "constants/items.h" #include "constants/trainer_classes.h" @@ -32,12 +37,12 @@ struct BattleWindowText u8 shadowColor; }; -EWRAM_DATA u8 sBattlerAbilities[MAX_BATTLERS_COUNT] = {}; -EWRAM_DATA struct BattleMsgData *gBattleMsgDataPtr = NULL; +static EWRAM_DATA u8 sBattlerAbilities[MAX_BATTLERS_COUNT] = {}; +static EWRAM_DATA struct BattleMsgData *gBattleMsgDataPtr = NULL; -void ChooseMoveUsedParticle(u8 *textPtr); -void ChooseTypeOfMoveUsedString(u8 *textPtr); -void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst); +static void ChooseMoveUsedParticle(u8 *textPtr); +static void ChooseTypeOfMoveUsedString(u8 *textPtr); +static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst); const u8 gUnknown_83FB218[] = _(""); // @ 83FB218 const u8 gUnknown_83FB219[] = _("{B_TRAINER1_LOSE_TEXT}"); // @ 83FB219 @@ -314,18 +319,18 @@ const u8 gUnknown_83FCC33[] = _("And…\p"); // @ 83FCC33 const u8 gUnknown_83FCC39[] = _("HM moves can't be\nforgotten now.\p"); // @ 83FCC39 const u8 gUnknown_83FCC5B[] = _("It's not very effective…"); // @ 83FCC5B const u8 gUnknown_83FCC74[] = _("It's super effective!"); // @ 83FCC74 -const u8 sText_GotAwaySafely[] = _("{PLAY_SE SE_NIGERU}Got away safely!\p"); // @ 83FCC8A +static const u8 sText_GotAwaySafely[] = _("{PLAY_SE SE_NIGERU}Got away safely!\p"); // @ 83FCC8A const u8 gUnknown_83FCCA0[] = _("{PLAY_SE SE_NIGERU}{B_ATK_NAME_WITH_PREFIX} fled\nusing its {B_LAST_ITEM}!\p"); // @ 83FCCA0 const u8 gUnknown_83FCCBB[] = _("{PLAY_SE SE_NIGERU}{B_ATK_NAME_WITH_PREFIX} fled\nusing {B_ATK_ABILITY}!\p"); // @ 83FCCBB const u8 gUnknown_83FCCD2[] = _("{PLAY_SE SE_NIGERU}Wild {B_BUFF1} fled!"); // @ 83FCCD2 -const u8 sText_PlayerDefeatedLinkTrainer[] = _("Player defeated\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCCE4 -const u8 sText_TwoLinkTrainersDefeated[] = _("Player beat {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); // @ 83FCCF8 -const u8 sText_PlayerLostAgainstLinkTrainer[] = _("Player lost against\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCD0F -const u8 sText_PlayerLostToTwo[] = _("Player lost to {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); // @ 83FCD27 -const u8 sText_PlayerBattledToDrawLinkTrainer[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCD41 -const u8 sText_PlayerBattledToDrawVsTwo[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}!"); // @ 83FCD66 +static const u8 sText_PlayerDefeatedLinkTrainer[] = _("Player defeated\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCCE4 +static const u8 sText_TwoLinkTrainersDefeated[] = _("Player beat {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); // @ 83FCCF8 +static const u8 sText_PlayerLostAgainstLinkTrainer[] = _("Player lost against\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCD0F +static const u8 sText_PlayerLostToTwo[] = _("Player lost to {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); // @ 83FCD27 +static const u8 sText_PlayerBattledToDrawLinkTrainer[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCD41 +static const u8 sText_PlayerBattledToDrawVsTwo[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}!"); // @ 83FCD66 const u8 gUnknown_83FCD92[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} fled!"); // @ 83FCD92 -const u8 sText_TwoWildFled[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} and\n{B_LINK_OPPONENT2_NAME} fled!"); // @ 83FCD9F +static const u8 sText_TwoWildFled[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} and\n{B_LINK_OPPONENT2_NAME} fled!"); // @ 83FCD9F const u8 gUnknown_83FCDB3[] = _("No! There's no running\nfrom a TRAINER battle!\p"); // @ 83FCDB3 const u8 gUnknown_83FCDE2[] = _("Can't escape!\p"); // @ 83FCDE2 const u8 gUnknown_83FCDF1[] = _(""); // @ 83FCDF1 @@ -367,71 +372,71 @@ const u8 gUnknown_83FD15A[] = _("{B_ATK_NAME_WITH_PREFIX} turned away!"); // @ const u8 gUnknown_83FD16A[] = _("{B_ATK_NAME_WITH_PREFIX} pretended\nnot to notice!"); // @ 83FD16A const u8 gUnknown_83FD186[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} is\nabout to use {B_BUFF2}.\pWill {B_PLAYER_NAME} change\nPOKéMON?"); // @ 83FD186 const u8 gUnknown_83FD1B8[] = _("{B_ATK_NAME_WITH_PREFIX} learned\n{B_BUFF1}!"); // @ 83FD1B8 -const u8 sText_PlayerDefeatedLinkTrainerTrainer1[] = _("Player defeated\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!\p"); // @ 83FD1C7 +static const u8 sText_PlayerDefeatedLinkTrainerTrainer1[] = _("Player defeated\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!\p"); // @ 83FD1C7 const u8 gUnknown_83FD1DF[] = _("{B_PLAYER_NAME} threw a ROCK\nat the {B_OPPONENT_MON1_NAME}!"); // @ 83FD1DF const u8 gUnknown_83FD1FA[] = _("{B_PLAYER_NAME} threw some BAIT\nat the {B_OPPONENT_MON1_NAME}!"); // @ 83FD1FA const u8 gUnknown_83FD218[] = _("{B_OPPONENT_MON1_NAME} is watching\ncarefully!"); // @ 83FD218 const u8 gUnknown_83FD232[] = _("{B_OPPONENT_MON1_NAME} is angry!"); // @ 83FD232 const u8 gUnknown_83FD23F[] = _("{B_OPPONENT_MON1_NAME} is eating!"); // @ 83FD23F const u8 gUnknown_83FD24D[] = _("{PLAY_SE SE_PINPON}ANNOUNCER: You're out of\nSAFARI BALLS! Game over!\p"); // @ 83FD24D -const u8 sText_WildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); // @ 83FD284 -const u8 sText_WildPkmnAppeared2[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); // @ 83FD297 -const u8 sText_WildPkmnAppearedPause[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!{PAUSE 127}"); // @ 83FD2AA -const u8 sText_TwoWildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} and\n{B_OPPONENT_MON2_NAME} appeared!\p"); // @ 83FD2BF +static const u8 sText_WildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); // @ 83FD284 +static const u8 sText_WildPkmnAppeared2[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); // @ 83FD297 +static const u8 sText_WildPkmnAppearedPause[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!{PAUSE 127}"); // @ 83FD2AA +static const u8 sText_TwoWildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} and\n{B_OPPONENT_MON2_NAME} appeared!\p"); // @ 83FD2BF const u8 gUnknown_83FD2D9[] = _("The GHOST appeared!\pDarn!\nThe GHOST can't be ID'd!\p"); // @ 83FD2D9 const u8 gUnknown_83FD30D[] = _("The GHOST appeared!\p"); // @ 83FD30D const u8 gUnknown_83FD322[] = _("SILPH SCOPE unveiled the GHOST's\nidentity!"); // @ 83FD322 const u8 gUnknown_83FD34D[] = _("The GHOST was MAROWAK!\p\n"); // @ 83FD34D -const u8 sText_Trainer1WantsToBattle[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwould like to battle!\p"); // @ 83FD366 -const u8 sText_LinkTrainerWantsToBattle[] = _("{B_LINK_OPPONENT1_NAME}\nwants to battle!"); // @ 83FD383 -const u8 sText_TwoLinkTrainersWantToBattle[] = _("{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}\nwant to battle!"); // @ 83FD397 -const u8 sText_Trainer1SentOutPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME}!{PAUSE 60}"); // @ 83FD3B1 -const u8 sText_Trainer1SentOutTwoPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!{PAUSE 60}"); // @ 83FD3C7 -const u8 sText_Trainer1SentOutPkmn2[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_BUFF1}!"); // @ 83FD3E4 -const u8 sText_LinkTrainerSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME}!"); // @ 83FD3F7 -const u8 sText_LinkTrainerSentOutTwoPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!"); // @ 83FD407 -const u8 sText_TwoLinkTrainersSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out {B_LINK_OPPONENT_MON1_NAME}!\n{B_LINK_OPPONENT2_NAME} sent out {B_LINK_OPPONENT_MON2_NAME}!"); // @ 83FD41E -const u8 sText_LinkTrainerSentOutPkmn2[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_BUFF1}!"); // @ 83FD43E -const u8 sText_LinkTrainerMultiSentOutPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} sent out\n{B_BUFF1}!"); // @ 83FD44E -const u8 sText_GoPkmn[] = _("Go! {B_PLAYER_MON1_NAME}!"); // @ 83FD45E -const u8 sText_GoTwoPkmn[] = _("Go! {B_PLAYER_MON1_NAME} and\n{B_PLAYER_MON2_NAME}!"); // @ 83FD466 -const u8 sText_GoPkmn2[] = _("Go! {B_BUFF1}!"); // @ 83FD475 -const u8 sText_DoItPkmn[] = _("Do it! {B_BUFF1}!"); // @ 83FD47D -const u8 sText_GoForItPkmn[] = _("Go for it, {B_BUFF1}!"); // @ 83FD488 -const u8 sText_YourFoesWeakGetEmPkmn[] = _("Your foe's weak!\nGet 'em, {B_BUFF1}!"); // @ 83FD497 -const u8 sText_LinkPartnerSentOutPkmnGoPkmn[] = _("{B_LINK_PARTNER_NAME} sent out {B_LINK_PLAYER_MON2_NAME}!\nGo! {B_LINK_PLAYER_MON1_NAME}!"); // @ 83FD4B5 -const u8 sText_PkmnThatsEnough[] = _("{B_BUFF1}, that's enough!\nCome back!"); // @ 83FD4CD -const u8 sText_PkmnComeBack[] = _("{B_BUFF1}, come back!"); // @ 83FD4EB -const u8 sText_PkmnOkComeBack[] = _("{B_BUFF1}, OK!\nCome back!"); // @ 83FD4FA +static const u8 sText_Trainer1WantsToBattle[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwould like to battle!\p"); // @ 83FD366 +static const u8 sText_LinkTrainerWantsToBattle[] = _("{B_LINK_OPPONENT1_NAME}\nwants to battle!"); // @ 83FD383 +static const u8 sText_TwoLinkTrainersWantToBattle[] = _("{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}\nwant to battle!"); // @ 83FD397 +static const u8 sText_Trainer1SentOutPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME}!{PAUSE 60}"); // @ 83FD3B1 +static const u8 sText_Trainer1SentOutTwoPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!{PAUSE 60}"); // @ 83FD3C7 +static const u8 sText_Trainer1SentOutPkmn2[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_BUFF1}!"); // @ 83FD3E4 +static const u8 sText_LinkTrainerSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME}!"); // @ 83FD3F7 +static const u8 sText_LinkTrainerSentOutTwoPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!"); // @ 83FD407 +static const u8 sText_TwoLinkTrainersSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out {B_LINK_OPPONENT_MON1_NAME}!\n{B_LINK_OPPONENT2_NAME} sent out {B_LINK_OPPONENT_MON2_NAME}!"); // @ 83FD41E +static const u8 sText_LinkTrainerSentOutPkmn2[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_BUFF1}!"); // @ 83FD43E +static const u8 sText_LinkTrainerMultiSentOutPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} sent out\n{B_BUFF1}!"); // @ 83FD44E +static const u8 sText_GoPkmn[] = _("Go! {B_PLAYER_MON1_NAME}!"); // @ 83FD45E +static const u8 sText_GoTwoPkmn[] = _("Go! {B_PLAYER_MON1_NAME} and\n{B_PLAYER_MON2_NAME}!"); // @ 83FD466 +static const u8 sText_GoPkmn2[] = _("Go! {B_BUFF1}!"); // @ 83FD475 +static const u8 sText_DoItPkmn[] = _("Do it! {B_BUFF1}!"); // @ 83FD47D +static const u8 sText_GoForItPkmn[] = _("Go for it, {B_BUFF1}!"); // @ 83FD488 +static const u8 sText_YourFoesWeakGetEmPkmn[] = _("Your foe's weak!\nGet 'em, {B_BUFF1}!"); // @ 83FD497 +static const u8 sText_LinkPartnerSentOutPkmnGoPkmn[] = _("{B_LINK_PARTNER_NAME} sent out {B_LINK_PLAYER_MON2_NAME}!\nGo! {B_LINK_PLAYER_MON1_NAME}!"); // @ 83FD4B5 +static const u8 sText_PkmnThatsEnough[] = _("{B_BUFF1}, that's enough!\nCome back!"); // @ 83FD4CD +static const u8 sText_PkmnComeBack[] = _("{B_BUFF1}, come back!"); // @ 83FD4EB +static const u8 sText_PkmnOkComeBack[] = _("{B_BUFF1}, OK!\nCome back!"); // @ 83FD4FA const u8 sText_PkmnGoodComeBack[] = _("{B_BUFF1}, good!\nCome back!"); // @ 83FD50D -const u8 sText_Trainer1WithdrewPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwithdrew {B_BUFF1}!"); // @ 83FD522 -const u8 sText_LinkTrainer1WithdrewPkmn[] = _("{B_LINK_OPPONENT1_NAME} withdrew\n{B_BUFF1}!"); // @ 83FD535 -const u8 sText_LinkTrainer2WithdrewPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} withdrew\n{B_BUFF1}!"); // @ 83FD545 -const u8 sText_WildPkmnPrefix[] = _("Wild "); // @ 83FD555 -const u8 sText_FoePkmnPrefix[] = _("Foe "); // @ 83FD55B -const u8 sText_FoePkmnPrefix2[] = _("Foe"); // @ 83FD560 -const u8 sText_AllyPkmnPrefix[] = _("Ally"); // @ 83FD564 -const u8 sText_FoePkmnPrefix3[] = _("Foe"); // @ 83FD569 -const u8 sText_AllyPkmnPrefix2[] = _("Ally"); // @ 83FD56D -const u8 sText_FoePkmnPrefix4[] = _("Foe"); // @ 83FD572 -const u8 sText_AllyPkmnPrefix3[] = _("Ally"); // @ 83FD576 -const u8 sText_AttackerUsedX[] = _("{B_ATK_NAME_WITH_PREFIX} used\n{B_BUFF2}"); // @ 83FD57B -const u8 sText_ExclamationMark[] = _("!"); // @ 83FD586 -const u8 sText_ExclamationMark2[] = _("!"); // @ 83FD588 -const u8 sText_ExclamationMark3[] = _("!"); // @ 83FD58A -const u8 sText_ExclamationMark4[] = _("!"); // @ 83FD58C -const u8 sText_ExclamationMark5[] = _("!"); // @ 83FD58E - -const u8 sText_HP2[] = _("HP"); // @ 83FD590 -const u8 sText_Attack2[] = _("ATTACK"); // @ 83FD593 -const u8 sText_Defense2[] = _("DEFENSE"); // @ 83FD59A -const u8 sText_Speed[] = _("SPEED"); // @ 83FD5A2 -const u8 sText_SpAtk2[] = _("SP. ATK"); // @ 83FD5A8 -const u8 sText_SpDef2[] = _("SP. DEF"); // @ 83FD5B0 -const u8 sText_Accuracy[] = _("accuracy"); // @ 83FD5B8 -const u8 sText_Evasiveness[] = _("evasiveness"); // @ 83FD5C1 - -const u8 *const gUnknown_83FD5D0[] = { +static const u8 sText_Trainer1WithdrewPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwithdrew {B_BUFF1}!"); // @ 83FD522 +static const u8 sText_LinkTrainer1WithdrewPkmn[] = _("{B_LINK_OPPONENT1_NAME} withdrew\n{B_BUFF1}!"); // @ 83FD535 +static const u8 sText_LinkTrainer2WithdrewPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} withdrew\n{B_BUFF1}!"); // @ 83FD545 +static const u8 sText_WildPkmnPrefix[] = _("Wild "); // @ 83FD555 +static const u8 sText_FoePkmnPrefix[] = _("Foe "); // @ 83FD55B +static const u8 sText_FoePkmnPrefix2[] = _("Foe"); // @ 83FD560 +static const u8 sText_AllyPkmnPrefix[] = _("Ally"); // @ 83FD564 +static const u8 sText_FoePkmnPrefix3[] = _("Foe"); // @ 83FD569 +static const u8 sText_AllyPkmnPrefix2[] = _("Ally"); // @ 83FD56D +static const u8 sText_FoePkmnPrefix4[] = _("Foe"); // @ 83FD572 +static const u8 sText_AllyPkmnPrefix3[] = _("Ally"); // @ 83FD576 +static const u8 sText_AttackerUsedX[] = _("{B_ATK_NAME_WITH_PREFIX} used\n{B_BUFF2}"); // @ 83FD57B +static const u8 sText_ExclamationMark[] = _("!"); // @ 83FD586 +static const u8 sText_ExclamationMark2[] = _("!"); // @ 83FD588 +static const u8 sText_ExclamationMark3[] = _("!"); // @ 83FD58A +static const u8 sText_ExclamationMark4[] = _("!"); // @ 83FD58C +static const u8 sText_ExclamationMark5[] = _("!"); // @ 83FD58E + +static const u8 sText_HP2[] = _("HP"); // @ 83FD590 +static const u8 sText_Attack2[] = _("ATTACK"); // @ 83FD593 +static const u8 sText_Defense2[] = _("DEFENSE"); // @ 83FD59A +static const u8 sText_Speed[] = _("SPEED"); // @ 83FD5A2 +static const u8 sText_SpAtk2[] = _("SP. ATK"); // @ 83FD5A8 +static const u8 sText_SpDef2[] = _("SP. DEF"); // @ 83FD5B0 +static const u8 sText_Accuracy[] = _("accuracy"); // @ 83FD5B8 +static const u8 sText_Evasiveness[] = _("evasiveness"); // @ 83FD5C1 + +const u8 *const gStatNamesTable[] = { sText_HP2, sText_Attack2, sText_Defense2, @@ -442,13 +447,13 @@ const u8 *const gUnknown_83FD5D0[] = { sText_Evasiveness }; -const u8 sText_PokeblockWasTooSpicy[] = _("was too spicy!"); // -const u8 sText_PokeblockWasTooDry[] = _("was too dry!"); // @ 83FD5FF -const u8 sText_PokeblockWasTooSweet[] = _("was too sweet!"); // @ 83FD60C -const u8 sText_PokeblockWasTooBitter[] = _("was too bitter!"); // @ 83FD61B -const u8 sText_PokeblockWasTooSour[] = _("was too sour!"); // @ 83FD62B +static const u8 sText_PokeblockWasTooSpicy[] = _("was too spicy!"); // +static const u8 sText_PokeblockWasTooDry[] = _("was too dry!"); // @ 83FD5FF +static const u8 sText_PokeblockWasTooSweet[] = _("was too sweet!"); // @ 83FD60C +static const u8 sText_PokeblockWasTooBitter[] = _("was too bitter!"); // @ 83FD61B +static const u8 sText_PokeblockWasTooSour[] = _("was too sour!"); // @ 83FD62B -const u8 *const gUnknown_83FD63C[] = { +const u8 *const gPokeblockWasTooXStringTable[] = { sText_PokeblockWasTooSpicy, sText_PokeblockWasTooDry, sText_PokeblockWasTooSweet, @@ -456,31 +461,31 @@ const u8 *const gUnknown_83FD63C[] = { sText_PokeblockWasTooSour }; -const u8 sText_PlayerUsedItem[] = _("{B_PLAYER_NAME} used\n{B_LAST_ITEM}!"); // @ 83FD650 -const u8 sText_OldManUsedItem[] = _("The old man used\n{B_LAST_ITEM}!"); // @ 83FD65C -const u8 sText_PokeDudeUsedItem[] = _("The POKé DUDE used\n{B_LAST_ITEM}!"); // @ 83FD671 -const u8 sText_Trainer1UsedItem[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nused {B_LAST_ITEM}!"); // @ 83FD688 -const u8 sText_TrainerBlockedBall[] = _("The TRAINER blocked the BALL!"); // @ 83FD697 -const u8 sText_DontBeAThief[] = _("Don't be a thief!"); // @ 83FD6B5 -const u8 sText_ItDodgedBall[] = _("It dodged the thrown BALL!\nThis POKéMON can't be caught!"); // @ 83FD6C7 -const u8 sText_YouMissedPkmn[] = _("You missed the POKéMON!"); // @ 83FD700 -const u8 sText_PkmnBrokeFree[] = _("Oh, no!\nThe POKéMON broke free!"); // @ 83FD718 -const u8 sText_ItAppearedCaught[] = _("Aww!\nIt appeared to be caught!"); // @ 83FD738 -const u8 sText_AarghAlmostHadIt[] = _("Aargh!\nAlmost had it!"); // @ 83FD757 -const u8 sText_ShootSoClose[] = _("Shoot!\nIt was so close, too!"); // @ 83FD76D +static const u8 sText_PlayerUsedItem[] = _("{B_PLAYER_NAME} used\n{B_LAST_ITEM}!"); // @ 83FD650 +static const u8 sText_OldManUsedItem[] = _("The old man used\n{B_LAST_ITEM}!"); // @ 83FD65C +static const u8 sText_PokeDudeUsedItem[] = _("The POKé DUDE used\n{B_LAST_ITEM}!"); // @ 83FD671 +static const u8 sText_Trainer1UsedItem[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nused {B_LAST_ITEM}!"); // @ 83FD688 +static const u8 sText_TrainerBlockedBall[] = _("The TRAINER blocked the BALL!"); // @ 83FD697 +static const u8 sText_DontBeAThief[] = _("Don't be a thief!"); // @ 83FD6B5 +static const u8 sText_ItDodgedBall[] = _("It dodged the thrown BALL!\nThis POKéMON can't be caught!"); // @ 83FD6C7 +static const u8 sText_YouMissedPkmn[] = _("You missed the POKéMON!"); // @ 83FD700 +static const u8 sText_PkmnBrokeFree[] = _("Oh, no!\nThe POKéMON broke free!"); // @ 83FD718 +static const u8 sText_ItAppearedCaught[] = _("Aww!\nIt appeared to be caught!"); // @ 83FD738 +static const u8 sText_AarghAlmostHadIt[] = _("Aargh!\nAlmost had it!"); // @ 83FD757 +static const u8 sText_ShootSoClose[] = _("Shoot!\nIt was so close, too!"); // @ 83FD76D const u8 gUnknown_83FD78A[] = _("よけられた!\nこいつは つかまりそうにないぞ!"); // @ 83FD78A -const u8 sText_GotchaPkmnCaught[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}\p"); // @ 83FD7A2 -const u8 sText_GotchaPkmnCaught2[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}{PAUSE 127}"); // @ 83FD7C0 -const u8 sText_GiveNicknameCaptured[] = _("Give a nickname to the\ncaptured {B_OPPONENT_MON1_NAME}?"); // @ 83FD7E0 -const u8 sText_PkmnSentToPC[] = _("{B_OPPONENT_MON1_NAME} was sent to\n{B_PC_CREATOR_NAME} PC."); // @ 83FD804 -const u8 sText_Someones[] = _("someone's"); // @ 83FD81A -const u8 sText_Bills[] = _("BILL's"); // @ 83FD824 +static const u8 sText_GotchaPkmnCaught[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}\p"); // @ 83FD7A2 +static const u8 sText_GotchaPkmnCaught2[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}{PAUSE 127}"); // @ 83FD7C0 +static const u8 sText_GiveNicknameCaptured[] = _("Give a nickname to the\ncaptured {B_OPPONENT_MON1_NAME}?"); // @ 83FD7E0 +static const u8 sText_PkmnSentToPC[] = _("{B_OPPONENT_MON1_NAME} was sent to\n{B_PC_CREATOR_NAME} PC."); // @ 83FD804 +static const u8 sText_Someones[] = _("someone's"); // @ 83FD81A +static const u8 sText_Bills[] = _("BILL's"); // @ 83FD824 const u8 gUnknown_83FD82B[] = _("{B_OPPONENT_MON1_NAME}'s data was\nadded to the POKéDEX.\p"); // @ 83FD82B const u8 gUnknown_83FD850[] = _("It is raining."); // @ 83FD850 const u8 gUnknown_83FD85F[] = _("A sandstorm is raging."); // @ 83FD85F const u8 gUnknown_83FD876[] = _("The BOX is full!\nYou can't catch any more!\p"); // @ 83FD876 -const u8 sText_EnigmaBerry[] = _("ENIGMA BERRY"); // @ 83FD8A2 -const u8 sText_BerrySuffix[] = _(" BERRY"); // @ 83FD8AF +static const u8 sText_EnigmaBerry[] = _("ENIGMA BERRY"); // @ 83FD8A2 +static const u8 sText_BerrySuffix[] = _(" BERRY"); // @ 83FD8AF const u8 gUnknown_83FD8B6[] = _("ナゾ"); // @ 83FD8B6 const u8 gUnknown_83FD8B9[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured paralysis!"); // @ 83FD8B9 const u8 gUnknown_83FD8D2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured poison!"); // @ 83FD8D2 @@ -1269,8 +1274,8 @@ const u8 gUnknown_83FE870[] = _("ミツル"); // @ 83FE870 const u8 gUnknown_83FE874[] = _("{HIGHLIGHT 0}Win"); // @ 83FE874 const u8 gUnknown_83FE87B[] = _("{HIGHLIGHT 0}Loss"); // @ 83FE87B const u8 gUnknown_83FE883[] = _("{HIGHLIGHT 0}Draw"); // @ 83FE883 -const u8 gUnknown_83FE88B[] = _(" is"); // @ 83FE88B -const u8 gUnknown_83FE88F[] = _("'s"); // @ 83FE88F +static const u8 sText_SpaceIs[] = _(" is"); // @ 83FE88B +static const u8 sText_ApostropheS[] = _("'s"); // @ 83FE88F const u8 gUnknown_83FE892[] = _("a NORMAL move"); // @ 83FE892 const u8 gUnknown_83FE8A0[] = _("a FIGHTING move"); // @ 83FE8A0 const u8 gUnknown_83FE8B0[] = _("a FLYING move"); // @ 83FE8B0 @@ -1309,10 +1314,10 @@ const u8 *const gUnknown_83FE9C4[] = { }; const u8 gUnknown_83FE9D4[] = _("{PLAY_SE SE_NIGERU}{B_TRAINER1_CLASS} {B_TRAINER1_NAME} fled!"); // -const u8 sText_PlayerLostAgainstTrainer1[] = _("Player lost against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); // @ 83FE9E4 -const u8 sText_PlayerBattledToDrawTrainer1[] = _("Player battled to a draw against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); // @ 83FE9FF +static const u8 sText_PlayerLostAgainstTrainer1[] = _("Player lost against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); // @ 83FE9E4 +static const u8 sText_PlayerBattledToDrawTrainer1[] = _("Player battled to a draw against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); // @ 83FE9FF -const u8 *const sATypeMove_Table[] = { +static const u8 *const sATypeMove_Table[] = { gUnknown_83FE892, gUnknown_83FE8A0, gUnknown_83FE8B0, @@ -1333,7 +1338,7 @@ const u8 *const sATypeMove_Table[] = { gUnknown_83FE976 }; -const u16 gUnknown_83FEA70[] = { +static const u16 sGrammarMoveUsedTable[] = { MOVE_SWORDS_DANCE, MOVE_STRENGTH, MOVE_GROWTH, @@ -1719,7 +1724,7 @@ u32 BattleStringExpandPlaceholdersToDisplayedString(const u8* src) BattleStringExpandPlaceholders(src, gDisplayedStringBattle); } -const u8* TryGetStatusString(u8 *src) +static const u8* TryGetStatusString(u8 *src) { u32 i; u8 status[] = _("$$$$$$$"); @@ -2153,7 +2158,201 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst) return dstID; } -const struct BattleWindowText gUnknown_83FEB64[] = { +static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst) +{ + u32 srcID = 1; + u32 value = 0; + u8 text[12]; + u16 hword; + + *dst = EOS; + while (src[srcID] != B_BUFF_EOS) + { + switch (src[srcID]) + { + case B_BUFF_STRING: // battle string + hword = T1_READ_16(&src[srcID + 1]); + StringAppend(dst, gBattleStringsTable[hword - BATTLESTRINGS_ID_ADDER]); + srcID += 3; + break; + case B_BUFF_NUMBER: // int to string + switch (src[srcID + 1]) + { + case 1: + value = src[srcID + 3]; + break; + case 2: + value = T1_READ_16(&src[srcID + 3]); + break; + case 4: + value = T1_READ_32(&src[srcID + 3]); + break; + } + ConvertIntToDecimalStringN(dst, value, STR_CONV_MODE_LEFT_ALIGN, src[srcID + 2]); + srcID += src[srcID + 1] + 3; + break; + case B_BUFF_MOVE: // move name + StringAppend(dst, gMoveNames[T1_READ_16(&src[srcID + 1])]); + srcID += 3; + break; + case B_BUFF_TYPE: // type name + StringAppend(dst, gTypeNames[src[srcID + 1]]); + srcID += 2; + break; + case B_BUFF_MON_NICK_WITH_PREFIX: // poke nick with prefix + if (GetBattlerSide(src[srcID + 1]) == B_SIDE_PLAYER) + { + GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, text); + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + StringAppend(dst, sText_FoePkmnPrefix); + else + StringAppend(dst, sText_WildPkmnPrefix); + + GetMonData(&gEnemyParty[src[srcID + 2]], MON_DATA_NICKNAME, text); + } + StringGetEnd10(text); + StringAppend(dst, text); + srcID += 3; + break; + case B_BUFF_STAT: // stats + StringAppend(dst, gStatNamesTable[src[srcID + 1]]); + srcID += 2; + break; + case B_BUFF_SPECIES: // species name + GetSpeciesName(dst, T1_READ_16(&src[srcID + 1])); + srcID += 3; + break; + case B_BUFF_MON_NICK: // poke nick without prefix + if (GetBattlerSide(src[srcID + 1]) == B_SIDE_PLAYER) + GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, dst); + else + GetMonData(&gEnemyParty[src[srcID + 2]], MON_DATA_NICKNAME, dst); + StringGetEnd10(dst); + srcID += 3; + break; + case B_BUFF_NEGATIVE_FLAVOR: // flavor table + StringAppend(dst, gPokeblockWasTooXStringTable[src[srcID + 1]]); + srcID += 2; + break; + case B_BUFF_ABILITY: // ability names + StringAppend(dst, gAbilityNames[src[srcID + 1]]); + srcID += 2; + break; + case B_BUFF_ITEM: // item name + hword = T1_READ_16(&src[srcID + 1]); + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (hword == ITEM_ENIGMA_BERRY) + { + if (gLinkPlayers[gBattleStruct->multiplayerId].id == gPotentialItemEffectBattler) + { + StringCopy(dst, gEnigmaBerries[gPotentialItemEffectBattler].name); + StringAppend(dst, sText_BerrySuffix); + } + else + { + StringAppend(dst, sText_EnigmaBerry); + } + } + else + { + CopyItemName(hword, dst); + } + } + else + { + CopyItemName(hword, dst); + } + srcID += 3; + break; + } + } +} + +// Loads one of two text strings into the provided buffer. This is functionally +// unused, since the value loaded into the buffer is not read; it loaded one of +// two particles (either "は" or "の") which works in tandem with ChooseTypeOfMoveUsedString +// below to effect changes in the meaning of the line. +static void ChooseMoveUsedParticle(u8* textBuff) +{ + s32 counter = 0; + u32 i = 0; + + while (counter != MAX_MON_MOVES) + { + if (sGrammarMoveUsedTable[i] == 0) + counter++; + if (sGrammarMoveUsedTable[i++] == gBattleMsgDataPtr->currentMove) + break; + } + + if (counter >= 0) + { + if (counter <= 2) + StringCopy(textBuff, sText_SpaceIs); // is + else if (counter <= MAX_MON_MOVES) + StringCopy(textBuff, sText_ApostropheS); // 's + } +} + +// Appends "!" to the text buffer `dst`. In the original Japanese this looked +// into the table of moves at sGrammarMoveUsedTable and varied the line accordingly. +// +// sText_ExclamationMark was a plain "!", used for any attack not on the list. +// It resulted in the translation "'s !". +// +// sText_ExclamationMark2 was "を つかった！". This resulted in the translation +// " used !", which was used for all attacks in English. +// +// sText_ExclamationMark3 was "した！". This was used for those moves whose +// names were verbs, such as Recover, and resulted in translations like " +// recovered itself!". +// +// sText_ExclamationMark4 was "を した！" This resulted in a translation of +// " did an !". +// +// sText_ExclamationMark5 was " こうげき！" This resulted in a translation of +// "'s attack!". +static void ChooseTypeOfMoveUsedString(u8* dst) +{ + s32 counter = 0; + s32 i = 0; + + while (*dst != EOS) + dst++; + + while (counter != MAX_MON_MOVES) + { + if (sGrammarMoveUsedTable[i] == MOVE_NONE) + counter++; + if (sGrammarMoveUsedTable[i++] == gBattleMsgDataPtr->currentMove) + break; + } + + switch (counter) + { + case 0: + StringCopy(dst, sText_ExclamationMark); + break; + case 1: + StringCopy(dst, sText_ExclamationMark2); + break; + case 2: + StringCopy(dst, sText_ExclamationMark3); + break; + case 3: + StringCopy(dst, sText_ExclamationMark4); + break; + case 4: + StringCopy(dst, sText_ExclamationMark5); + break; + } +} + +static const struct BattleWindowText sTextOnWindowsInfo_Normal[] = { {PIXEL_FILL(0xf), 2, 0x02, 2, 0, 2, 1, 0x1, 0xf, 0x6}, {PIXEL_FILL(0xf), 2, 0x02, 2, 0, 2, 0, 0x1, 0xf, 0x6}, {PIXEL_FILL(0xe), 1, 0x00, 2, 0, 2, 0, 0xd, 0xe, 0xf}, @@ -2182,3 +2381,135 @@ const struct BattleWindowText gUnknown_83FEB64[] = { }; const u8 gUnknown_83FEC90[] = {0x04, 0x05, 0x02, 0x02}; + +void BattlePutTextOnWindow(const u8 *text, u8 windowId) { + bool32 copyToVram; + struct TextPrinterTemplate printerTemplate; + u8 speed; + int x; + u8 context; + + u8 textFlags = windowId & 0xC0; + windowId &= 0x3F; + if (!(textFlags & 0x80)) + FillWindowPixelBuffer(windowId, sTextOnWindowsInfo_Normal[windowId].fillValue); + if (textFlags & 0x40) { + context = ContextNpcGetTextColor(); + printerTemplate.fontId = gUnknown_83FEC90[context]; + } + else { + printerTemplate.fontId = sTextOnWindowsInfo_Normal[windowId].fontId; + } + switch (windowId) + { + case 15 ... 20: + x = (48 - GetStringWidth(sTextOnWindowsInfo_Normal[windowId].fontId, text, + sTextOnWindowsInfo_Normal[windowId].letterSpacing)) / 2; + break; + case 21 ... 23: + x = (64 - GetStringWidth(sTextOnWindowsInfo_Normal[windowId].fontId, text, + sTextOnWindowsInfo_Normal[windowId].letterSpacing)) / 2; + break; + default: + x = sTextOnWindowsInfo_Normal[windowId].x; + break; + } + if (x < 0) + x = 0; + printerTemplate.currentChar = text; + printerTemplate.windowId = windowId; + printerTemplate.x = x; + printerTemplate.y = sTextOnWindowsInfo_Normal[windowId].y; + printerTemplate.currentX = printerTemplate.x; + printerTemplate.currentY = printerTemplate.y; + printerTemplate.letterSpacing = sTextOnWindowsInfo_Normal[windowId].letterSpacing; + printerTemplate.lineSpacing = sTextOnWindowsInfo_Normal[windowId].lineSpacing; + printerTemplate.unk = 0; + printerTemplate.fgColor = sTextOnWindowsInfo_Normal[windowId].fgColor; + printerTemplate.bgColor = sTextOnWindowsInfo_Normal[windowId].bgColor; + printerTemplate.shadowColor = sTextOnWindowsInfo_Normal[windowId].shadowColor; + if (windowId == 24) + gTextFlags.useAlternateDownArrow = FALSE; + else + gTextFlags.useAlternateDownArrow = TRUE; + + if ((gBattleTypeFlags & BATTLE_TYPE_LINK) || ((gBattleTypeFlags & BATTLE_TYPE_POKEDUDE) && windowId != 24)) + gTextFlags.autoScroll = TRUE; + else + gTextFlags.autoScroll = FALSE; + + if (windowId == 0 || windowId == 24) + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + speed = 1; + else + speed = GetTextSpeedSetting(); + gTextFlags.canABSpeedUpPrint = TRUE; + } + else + { + speed = sTextOnWindowsInfo_Normal[windowId].speed; + gTextFlags.canABSpeedUpPrint = FALSE; + } + + AddTextPrinter(&printerTemplate, speed, NULL); + if (!(textFlags & 0x80)) + { + PutWindowTilemap(windowId); + CopyWindowToVram(windowId, 3); + } +} + +bool8 sub_80D89B0(u16 stringId) +{ + if (stringId == STRINGID_TRAINER1LOSETEXT || stringId == STRINGID_TRAINER2CLASS || stringId == STRINGID_TRAINER1WINTEXT || stringId == STRINGID_TRAINER2NAME) + return TRUE; + return FALSE; +} + +void SetPpNumbersPaletteInMoveSelection(void) +{ + struct ChooseMoveStruct *chooseMoveStruct = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBattler][4]); + const u16 *palPtr = gUnknown_8D2FBB4; + u8 var = GetCurrentPpToMaxPpState(chooseMoveStruct->currentPp[gMoveSelectionCursor[gActiveBattler]], + chooseMoveStruct->maxPp[gMoveSelectionCursor[gActiveBattler]]); + + gPlttBufferUnfaded[92] = palPtr[(var * 2) + 0]; + gPlttBufferUnfaded[91] = palPtr[(var * 2) + 1]; + + CpuCopy16(&gPlttBufferUnfaded[92], &gPlttBufferFaded[92], sizeof(u16)); + CpuCopy16(&gPlttBufferUnfaded[91], &gPlttBufferFaded[91], sizeof(u16)); +} + +u8 GetCurrentPpToMaxPpState(u8 currentPp, u8 maxPp) +{ + if (maxPp == currentPp) + { + return 3; + } + else if (maxPp <= 2) + { + if (currentPp > 1) + return 3; + else + return 2 - currentPp; + } + else if (maxPp <= 7) + { + if (currentPp > 2) + return 3; + else + return 2 - currentPp; + } + else + { + if (currentPp == 0) + return 2; + if (currentPp <= maxPp / 4) + return 1; + if (currentPp > maxPp / 2) + return 3; + } + + return 0; +} diff --git a/src/pokemon.c b/src/pokemon.c index 33a3f387e..001505164 100644 --- a/src/pokemon.c +++ b/src/pokemon.c @@ -4796,7 +4796,7 @@ u8 GetItemEffectParamOffset(u16 itemId, u8 effectByte, u8 effectBit) static void sub_8042D50(int stat) { gBattlerTarget = gBattlerInMenuId; - StringCopy(gBattleTextBuff1, gUnknown_83FD5D0[gUnknown_825DFF0[stat]]); + StringCopy(gBattleTextBuff1, gStatNamesTable[gUnknown_825DFF0[stat]]); StringCopy(gBattleTextBuff2, BattleText_Rose); BattleStringExpandPlaceholdersToDisplayedString(BattleText_UnknownString3); } -- cgit v1.2.3 From 058999f49bd7d81487590ff75688dfe10c4eef96 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Sat, 23 Nov 2019 19:21:31 -0500 Subject: Address review comments --- src/battle_message.c | 1216 +++++++++++++++++++++++++------------------------- src/pokemon.c | 8 +- 2 files changed, 612 insertions(+), 612 deletions(-) (limited to 'src') diff --git a/src/battle_message.c b/src/battle_message.c index e9a0c74b3..396c4c7f0 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -38,403 +38,403 @@ struct BattleWindowText }; static EWRAM_DATA u8 sBattlerAbilities[MAX_BATTLERS_COUNT] = {}; -static EWRAM_DATA struct BattleMsgData *gBattleMsgDataPtr = NULL; +static EWRAM_DATA struct BattleMsgData *sBattleMsgDataPtr = NULL; static void ChooseMoveUsedParticle(u8 *textPtr); static void ChooseTypeOfMoveUsedString(u8 *textPtr); static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst); -const u8 gUnknown_83FB218[] = _(""); // @ 83FB218 -const u8 gUnknown_83FB219[] = _("{B_TRAINER1_LOSE_TEXT}"); // @ 83FB219 -const u8 gUnknown_83FB21C[] = _("{B_TRAINER2_CLASS}"); // @ 83FB21C -const u8 gUnknown_83FB21F[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON1_NAME}, come back!"); // @ 83FB21F -const u8 gUnknown_83FB232[] = _("{B_TRAINER1_WIN_TEXT}"); // @ 83FB232 -const u8 gUnknown_83FB235[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON2_NAME}, come back!"); // @ 83FB235 -const u8 gUnknown_83FB248[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON1_NAME} and\n{B_OPPONENT_MON2_NAME}, come back!"); // @ 83FB248 -const u8 gUnknown_83FB262[] = _("{B_TRAINER2_NAME}"); // @ 83FB262 -const u8 gUnknown_83FB265[] = _("{B_BUFF1} gained{B_BUFF2}\n{B_TRAINER2_LOSE_TEXT} EXP. Points!\p"); // @ 83FB265 -const u8 gUnknown_83FB282[] = _(""); // @ 83FB282 -const u8 gUnknown_83FB283[] = _(" a boosted"); // @ 83FB283 -const u8 gUnknown_83FB28E[] = _("{B_BUFF1} grew to\nLV. {B_BUFF2}!{WAIT_SE}\p"); // @ 83FB28E -const u8 gUnknown_83FB2A4[] = _("{B_BUFF1} learned\n{B_BUFF2}!{WAIT_SE}\p"); // @ 83FB2A4 -const u8 gUnknown_83FB2B6[] = _("{B_BUFF1} is trying to\nlearn {B_BUFF2}.\p"); // @ 83FB2B6 -const u8 gUnknown_83FB2D1[] = _("But, {B_BUFF1} can't learn\nmore than four moves.\p"); // @ 83FB2D1 -const u8 gUnknown_83FB2FC[] = _("Delete a move to make\nroom for {B_BUFF2}?"); // @ 83FB2FC -const u8 gUnknown_83FB31F[] = _("{B_BUFF1} forgot\n{B_BUFF2}.\p"); // @ 83FB31F -const u8 gUnknown_83FB32E[] = _("{PAUSE 32}Stop learning\n{B_BUFF2}?"); // @ 83FB32E -const u8 gUnknown_83FB343[] = _("{B_BUFF1} did not learn\n{B_BUFF2}.\p"); // @ 83FB343 -const u8 gUnknown_83FB359[] = _("Use next POKéMON?"); // @ 83FB359 -const u8 gUnknown_83FB36B[] = _("{B_ATK_NAME_WITH_PREFIX}'s\nattack missed!"); // @ 83FB36B -const u8 gUnknown_83FB37F[] = _("{B_DEF_NAME_WITH_PREFIX}\nprotected itself!"); // @ 83FB37F -const u8 gUnknown_83FB394[] = _("{B_DEF_NAME_WITH_PREFIX} avoided\ndamage with {B_DEF_ABILITY}!"); // @ 83FB394 -const u8 gUnknown_83FB3AF[] = _("{B_DEF_NAME_WITH_PREFIX} makes GROUND\nmoves miss with {B_DEF_ABILITY}!"); // @ 83FB3AF -const u8 gUnknown_83FB3D3[] = _("{B_DEF_NAME_WITH_PREFIX} avoided\nthe attack!"); // @ 83FB3D3 -const u8 gUnknown_83FB3EA[] = _("It doesn't affect\n{B_DEF_NAME_WITH_PREFIX}…"); // @ 83FB3EA -const u8 gUnknown_83FB400[] = _("{B_ATK_NAME_WITH_PREFIX}\nfainted!\p"); // @ 83FB400 -const u8 gUnknown_83FB40D[] = _("{B_DEF_NAME_WITH_PREFIX}\nfainted!\p"); // @ 83FB40D -const u8 gUnknown_83FB41A[] = _("{B_PLAYER_NAME} got ¥{B_BUFF1}\nfor winning!\p"); // @ 83FB41A -const u8 gUnknown_83FB433[] = _("{B_PLAYER_NAME} is out of\nusable POKéMON!\p"); // @ 83FB433 -const u8 gUnknown_83FB451[] = _("{B_PLAYER_NAME} panicked and lost ¥{B_BUFF1}…\p… … … …\p{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); // @ 83FB451 -const u8 gUnknown_83FB484[] = _("{B_PLAYER_NAME} is out of\nusable POKéMON!\pPlayer lost against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!{PAUSE_UNTIL_PRESS}"); // @ 83FB484 -const u8 gUnknown_83FB4BE[] = _("{B_PLAYER_NAME} paid ¥{B_BUFF1} as the prize\nmoney…\p… … … …\p{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); // @ 83FB4BE -const u8 gUnknown_83FB4F7[] = _("{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); // @ 83FB4F7 -const u8 gUnknown_83FB508[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} prevents\nescape with {B_SCR_ACTIVE_ABILITY}!\p"); // @ 83FB508 -const u8 gUnknown_83FB525[] = _("Can't escape!\p"); // @ 83FB525 -const u8 gUnknown_83FB534[] = _("{B_ATK_NAME_WITH_PREFIX} can't escape!"); // @ 83FB534 -const u8 gUnknown_83FB545[] = _("Hit {B_BUFF1} time(s)!"); // @ 83FB545 -const u8 gUnknown_83FB555[] = _("{B_EFF_NAME_WITH_PREFIX}\nfell asleep!"); // @ 83FB555 -const u8 gUnknown_83FB565[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade {B_EFF_NAME_WITH_PREFIX} sleep!"); // @ 83FB565 -const u8 gUnknown_83FB57C[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready asleep!"); // @ 83FB57C -const u8 gUnknown_83FB592[] = _("{B_ATK_NAME_WITH_PREFIX} is\nalready asleep!"); // @ 83FB592 -const u8 gUnknown_83FB5A8[] = _("{B_DEF_NAME_WITH_PREFIX}\nwasn't affected!"); // @ 83FB5A8 -const u8 gUnknown_83FB5BC[] = _("{B_EFF_NAME_WITH_PREFIX}\nwas poisoned!"); // @ 83FB5BC -const u8 gUnknown_83FB5CD[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\npoisoned {B_EFF_NAME_WITH_PREFIX}!"); // @ 83FB5CD -const u8 gUnknown_83FB5E2[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby poison!"); // @ 83FB5E2 -const u8 gUnknown_83FB5F8[] = _("{B_DEF_NAME_WITH_PREFIX} is already\npoisoned."); // @ 83FB5F8 -const u8 gUnknown_83FB610[] = _("{B_EFF_NAME_WITH_PREFIX} is badly\npoisoned!"); // @ 83FB610 -const u8 gUnknown_83FB626[] = _("{B_DEF_NAME_WITH_PREFIX} had its\nenergy drained!"); // @ 83FB626 -const u8 gUnknown_83FB641[] = _("{B_EFF_NAME_WITH_PREFIX} was burned!"); // @ 83FB641 -const u8 gUnknown_83FB650[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nburned {B_EFF_NAME_WITH_PREFIX}!"); // @ 83FB650 -const u8 gUnknown_83FB663[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby its burn!"); // @ 83FB663 -const u8 gUnknown_83FB67B[] = _("{B_DEF_NAME_WITH_PREFIX} already\nhas a burn."); // @ 83FB67B -const u8 gUnknown_83FB692[] = _("{B_EFF_NAME_WITH_PREFIX} was\nfrozen solid!"); // @ 83FB692 -const u8 gUnknown_83FB6A7[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nfroze {B_EFF_NAME_WITH_PREFIX} solid!"); // @ 83FB6A7 -const u8 gUnknown_83FB6BF[] = _("{B_ATK_NAME_WITH_PREFIX} is\nfrozen solid!"); // @ 83FB6BF -const u8 gUnknown_83FB6D3[] = _("{B_DEF_NAME_WITH_PREFIX} was\ndefrosted!"); // @ 83FB6D3 -const u8 gUnknown_83FB6E5[] = _("{B_ATK_NAME_WITH_PREFIX} was\ndefrosted!"); // @ 83FB6E5 -const u8 gUnknown_83FB6F7[] = _("{B_ATK_NAME_WITH_PREFIX} was\ndefrosted by {B_CURRENT_MOVE}!"); // @ 83FB6F7 -const u8 gUnknown_83FB70F[] = _("{B_EFF_NAME_WITH_PREFIX} is paralyzed!\nIt may be unable to move!"); // @ 83FB70F -const u8 gUnknown_83FB73A[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nparalyzed {B_EFF_NAME_WITH_PREFIX}!\lIt may be unable to move!"); // @ 83FB73A -const u8 gUnknown_83FB76A[] = _("{B_ATK_NAME_WITH_PREFIX} is paralyzed!\nIt can't move!"); // @ 83FB76A -const u8 gUnknown_83FB78A[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready paralyzed!"); // @ 83FB78A -const u8 gUnknown_83FB7A3[] = _("{B_DEF_NAME_WITH_PREFIX} was\nhealed of paralysis!"); // @ 83FB7A3 -const u8 gUnknown_83FB7BF[] = _("{B_DEF_NAME_WITH_PREFIX}'s\ndream was eaten!"); // @ 83FB7BF -const u8 gUnknown_83FB7D5[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\nwon't go higher!"); // @ 83FB7D5 -const u8 gUnknown_83FB7EE[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\nwon't go lower!"); // @ 83FB7EE -const u8 gUnknown_83FB806[] = _("Your team's {B_BUFF1}\nstopped working!"); // @ 83FB806 -const u8 gUnknown_83FB826[] = _("The foe's {B_BUFF1}\nstopped working!"); // @ 83FB826 -const u8 gUnknown_83FB844[] = _("{B_ATK_NAME_WITH_PREFIX} is\nconfused!"); // @ 83FB844 -const u8 gUnknown_83FB854[] = _("{B_ATK_NAME_WITH_PREFIX} snapped\nout of confusion!"); // @ 83FB854 -const u8 gUnknown_83FB871[] = _("{B_EFF_NAME_WITH_PREFIX} became\nconfused!"); // @ 83FB871 -const u8 gUnknown_83FB885[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready confused!"); // @ 83FB885 -const u8 gUnknown_83FB89D[] = _("{B_DEF_NAME_WITH_PREFIX}\nfell in love!"); // @ 83FB89D -const u8 gUnknown_83FB8AE[] = _("{B_ATK_NAME_WITH_PREFIX} is in love\nwith {B_SCR_ACTIVE_NAME_WITH_PREFIX}!"); // @ 83FB8AE -const u8 gUnknown_83FB8C5[] = _("{B_ATK_NAME_WITH_PREFIX} is\nimmobilized by love!"); // @ 83FB8C5 -const u8 gUnknown_83FB8E0[] = _("{B_DEF_NAME_WITH_PREFIX} was\nblown away!"); // @ 83FB8E0 -const u8 gUnknown_83FB8F3[] = _("{B_ATK_NAME_WITH_PREFIX} transformed\ninto the {B_BUFF1} type!"); // @ 83FB8F3 -const u8 gUnknown_83FB914[] = _("{B_ATK_NAME_WITH_PREFIX} flinched!"); // @ 83FB914 -const u8 gUnknown_83FB921[] = _("{B_DEF_NAME_WITH_PREFIX} regained\nhealth!"); // @ 83FB921 -const u8 gUnknown_83FB935[] = _("{B_DEF_NAME_WITH_PREFIX}'s\nHP is full!"); // @ 83FB935 -const u8 gUnknown_83FB946[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised SP. DEF!"); // @ 83FB946 -const u8 gUnknown_83FB95E[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised SP. DEF a little!"); // @ 83FB95E -const u8 gUnknown_83FB97F[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised DEFENSE!"); // @ 83FB97F -const u8 gUnknown_83FB997[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised DEFENSE a little!"); // @ 83FB997 -const u8 gUnknown_83FB9B8[] = _("{B_ATK_PREFIX2}'s party is covered\nby a veil!"); // @ 83FB9B8 -const u8 gUnknown_83FB9D9[] = _("{B_DEF_NAME_WITH_PREFIX}'s party is protected\nby SAFEGUARD!"); // @ 83FB9D9 -const u8 gUnknown_83FB9FF[] = _("{B_ATK_PREFIX3}'s party is no longer\nprotected by SAFEGUARD!"); // @ 83FB9FF -const u8 gUnknown_83FBA2F[] = _("{B_ATK_NAME_WITH_PREFIX} went\nto sleep!"); // @ 83FBA2F -const u8 gUnknown_83FBA41[] = _("{B_ATK_NAME_WITH_PREFIX} slept and\nbecame healthy!"); // @ 83FBA41 -const u8 gUnknown_83FBA5E[] = _("{B_ATK_NAME_WITH_PREFIX} whipped\nup a whirlwind!"); // @ 83FBA5E -const u8 gUnknown_83FBA79[] = _("{B_ATK_NAME_WITH_PREFIX} took\nin sunlight!"); // @ 83FBA79 -const u8 gUnknown_83FBA8E[] = _("{B_ATK_NAME_WITH_PREFIX} lowered\nits head!"); // @ 83FBA8E -const u8 gUnknown_83FBAA3[] = _("{B_ATK_NAME_WITH_PREFIX} is glowing!"); // @ 83FBAA3 -const u8 gUnknown_83FBAB2[] = _("{B_ATK_NAME_WITH_PREFIX} flew\nup high!"); // @ 83FBAB2 -const u8 gUnknown_83FBAC3[] = _("{B_ATK_NAME_WITH_PREFIX} dug a hole!"); // @ 83FBAC3 -const u8 gUnknown_83FBAD2[] = _("{B_ATK_NAME_WITH_PREFIX} hid\nunderwater!"); // @ 83FBAD2 -const u8 gUnknown_83FBAE5[] = _("{B_ATK_NAME_WITH_PREFIX} sprang up!"); // @ 83FBAE5 -const u8 gUnknown_83FBAF3[] = _("{B_DEF_NAME_WITH_PREFIX} was squeezed by\n{B_ATK_NAME_WITH_PREFIX}'s BIND!"); // @ 83FBAF3 -const u8 gUnknown_83FBB11[] = _("{B_DEF_NAME_WITH_PREFIX} was trapped\nin the vortex!"); // @ 83FBB11 -const u8 gUnknown_83FBB2F[] = _("{B_DEF_NAME_WITH_PREFIX} was trapped\nby SAND TOMB!"); // @ 83FBB2F -const u8 gUnknown_83FBB4C[] = _("{B_DEF_NAME_WITH_PREFIX} was WRAPPED by\n{B_ATK_NAME_WITH_PREFIX}!"); // @ 83FBB4C -const u8 gUnknown_83FBB62[] = _("{B_ATK_NAME_WITH_PREFIX} CLAMPED\n{B_DEF_NAME_WITH_PREFIX}!"); // @ 83FBB62 -const u8 gUnknown_83FBB71[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby {B_BUFF1}!"); // @ 83FBB71 -const u8 gUnknown_83FBB83[] = _("{B_ATK_NAME_WITH_PREFIX} was freed\nfrom {B_BUFF1}!"); // @ 83FBB83 -const u8 gUnknown_83FBB99[] = _("{B_ATK_NAME_WITH_PREFIX} kept going\nand crashed!"); // @ 83FBB99 -const u8 BattleText_MistShroud[] = _("{B_ATK_PREFIX2} became\nshrouded in MIST!"); // @ 83FBBB4 -const u8 gUnknown_83FBBD0[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} is protected\nby MIST!"); // @ 83FBBD0 -const u8 BattleText_GetPumped[] = _("{B_ATK_NAME_WITH_PREFIX} is getting\npumped!"); // @ 83FBBE9 -const u8 gUnknown_83FBBFF[] = _("{B_ATK_NAME_WITH_PREFIX} is hit\nwith recoil!"); // @ 83FBBFF -const u8 gUnknown_83FBC16[] = _("{B_ATK_NAME_WITH_PREFIX} protected\nitself!"); // @ 83FBC16 -const u8 gUnknown_83FBC2B[] = _("{B_ATK_NAME_WITH_PREFIX} is buffeted\nby the sandstorm!"); // @ 83FBC2B -const u8 gUnknown_83FBC4C[] = _("{B_ATK_NAME_WITH_PREFIX} is pelted\nby HAIL!"); // @ 83FBC4C -const u8 gUnknown_83FBC62[] = _("{B_ATK_PREFIX1}'s {B_BUFF1}\nwore off!"); // @ 83FBC62 -const u8 gUnknown_83FBC74[] = _("{B_DEF_NAME_WITH_PREFIX} was seeded!"); // @ 83FBC74 -const u8 gUnknown_83FBC83[] = _("{B_DEF_NAME_WITH_PREFIX} evaded\nthe attack!"); // @ 83FBC83 -const u8 gUnknown_83FBC99[] = _("{B_ATK_NAME_WITH_PREFIX}'s health is\nsapped by LEECH SEED!"); // @ 83FBC99 -const u8 gUnknown_83FBCBE[] = _("{B_ATK_NAME_WITH_PREFIX} is fast\nasleep."); // @ 83FBCBE -const u8 gUnknown_83FBCD1[] = _("{B_ATK_NAME_WITH_PREFIX} woke up!"); // @ 83FBCD1 -const u8 gUnknown_83FBCDD[] = _("But {B_SCR_ACTIVE_NAME_WITH_PREFIX}'s UPROAR\nkept it awake!"); // @ 83FBCDD -const u8 gUnknown_83FBCFC[] = _("{B_ATK_NAME_WITH_PREFIX} woke up\nin the UPROAR!"); // @ 83FBCFC -const u8 gUnknown_83FBD16[] = _("{B_ATK_NAME_WITH_PREFIX} caused\nan UPROAR!"); // @ 83FBD16 -const u8 gUnknown_83FBD2B[] = _("{B_ATK_NAME_WITH_PREFIX} is making\nan UPROAR!"); // @ 83FBD2B -const u8 gUnknown_83FBD43[] = _("{B_ATK_NAME_WITH_PREFIX} calmed down."); // @ 83FBD43 -const u8 gUnknown_83FBD53[] = _("But {B_DEF_NAME_WITH_PREFIX} can't\nsleep in an UPROAR!"); // @ 83FBD53 -const u8 gUnknown_83FBD74[] = _("{B_ATK_NAME_WITH_PREFIX} STOCKPILED\n{B_BUFF1}!"); // @ 83FBD74 -const u8 gUnknown_83FBD86[] = _("{B_ATK_NAME_WITH_PREFIX} can't\nSTOCKPILE any more!"); // @ 83FBD86 -const u8 gUnknown_83FBDA3[] = _("But {B_DEF_NAME_WITH_PREFIX} can't\nsleep in an UPROAR!"); // @ 83FBDA3 -const u8 gUnknown_83FBDC4[] = _("But the UPROAR kept\n{B_DEF_NAME_WITH_PREFIX} awake!"); // @ 83FBDC4 -const u8 gUnknown_83FBDE2[] = _("{B_DEF_NAME_WITH_PREFIX} stayed awake\nusing its {B_DEF_ABILITY}!"); // @ 83FBDE2 -const u8 gUnknown_83FBE00[] = _("{B_ATK_NAME_WITH_PREFIX} is storing\nenergy!"); // @ 83FBE00 -const u8 gUnknown_83FBE16[] = _("{B_ATK_NAME_WITH_PREFIX} unleashed\nenergy!"); // @ 83FBE16 -const u8 gUnknown_83FBE2B[] = _("{B_ATK_NAME_WITH_PREFIX} became\nconfused due to fatigue!"); // @ 83FBE2B -const u8 gUnknown_83FBE4E[] = _("{B_PLAYER_NAME} picked up\n¥{B_BUFF1}!\p"); // @ 83FBE4E -const u8 gUnknown_83FBE61[] = _("{B_DEF_NAME_WITH_PREFIX} is\nunaffected!"); // @ 83FBE61 -const u8 gUnknown_83FBE73[] = _("{B_ATK_NAME_WITH_PREFIX} transformed\ninto {B_BUFF1}!"); // @ 83FBE73 -const u8 gUnknown_83FBE8B[] = _("{B_ATK_NAME_WITH_PREFIX} made\na SUBSTITUTE!"); // @ 83FBE8B -const u8 gUnknown_83FBEA1[] = _("{B_ATK_NAME_WITH_PREFIX} already\nhas a SUBSTITUTE!"); // @ 83FBEA1 -const u8 gUnknown_83FBEBE[] = _("The SUBSTITUTE took damage\nfor {B_DEF_NAME_WITH_PREFIX}!\p"); // @ 83FBEBE -const u8 gUnknown_83FBEE2[] = _("{B_DEF_NAME_WITH_PREFIX}'s\nSUBSTITUTE faded!\p"); // @ 83FBEE2 -const u8 gUnknown_83FBEFA[] = _("{B_ATK_NAME_WITH_PREFIX} must\nrecharge!"); // @ 83FBEFA -const u8 gUnknown_83FBF0C[] = _("{B_DEF_NAME_WITH_PREFIX}'s RAGE\nis building!"); // @ 83FBF0C -const u8 gUnknown_83FBF23[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\nwas disabled!"); // @ 83FBF23 -const u8 gUnknown_83FBF39[] = _("{B_ATK_NAME_WITH_PREFIX} is disabled\nno more!"); // @ 83FBF39 -const u8 gUnknown_83FBF51[] = _("{B_DEF_NAME_WITH_PREFIX} got\nan ENCORE!"); // @ 83FBF51 -const u8 gUnknown_83FBF63[] = _("{B_ATK_NAME_WITH_PREFIX}'s ENCORE\nended!"); // @ 83FBF63 -const u8 gUnknown_83FBF76[] = _("{B_ATK_NAME_WITH_PREFIX} took aim\nat {B_DEF_NAME_WITH_PREFIX}!"); // @ 83FBF76 -const u8 gUnknown_83FBF89[] = _("{B_ATK_NAME_WITH_PREFIX} SKETCHED\n{B_BUFF1}!"); // @ 83FBF89 -const u8 gUnknown_83FBF99[] = _("{B_ATK_NAME_WITH_PREFIX} is trying\nto take its foe with it!"); // @ 83FBF99 -const u8 gUnknown_83FBFBF[] = _("{B_DEF_NAME_WITH_PREFIX} took\n{B_ATK_NAME_WITH_PREFIX} with it!"); // @ 83FBFBF -const u8 gUnknown_83FBFD3[] = _("Reduced {B_DEF_NAME_WITH_PREFIX}'s\n{B_BUFF1} by {B_BUFF2}!"); // @ 83FBFD3 -const u8 gUnknown_83FBFEA[] = _("{B_ATK_NAME_WITH_PREFIX} stole\n{B_DEF_NAME_WITH_PREFIX}'s {B_LAST_ITEM}!"); // @ 83FBFEA -const u8 gUnknown_83FBFFC[] = _("{B_DEF_NAME_WITH_PREFIX} can't\nescape now!"); // @ 83FBFFC -const u8 gUnknown_83FC011[] = _("{B_DEF_NAME_WITH_PREFIX} fell into\na NIGHTMARE!"); // @ 83FC011 -const u8 gUnknown_83FC02B[] = _("{B_ATK_NAME_WITH_PREFIX} is locked\nin a NIGHTMARE!"); // @ 83FC02B -const u8 gUnknown_83FC048[] = _("{B_ATK_NAME_WITH_PREFIX} cut its own HP and\nlaid a CURSE on {B_DEF_NAME_WITH_PREFIX}!"); // @ 83FC048 -const u8 gUnknown_83FC072[] = _("{B_ATK_NAME_WITH_PREFIX} is afflicted\nby the CURSE!"); // @ 83FC072 -const u8 gUnknown_83FC090[] = _("SPIKES were scattered all around\nthe opponent's side!"); // @ 83FC090 -const u8 gUnknown_83FC0C6[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} is hurt\nby SPIKES!"); // @ 83FC0C6 -const u8 gUnknown_83FC0DC[] = _("{B_ATK_NAME_WITH_PREFIX} identified\n{B_DEF_NAME_WITH_PREFIX}!"); // @ 83FC0DC -const u8 gUnknown_83FC0EE[] = _("{B_ATK_NAME_WITH_PREFIX}'s PERISH count\nfell to {B_BUFF1}!"); // @ 83FC0EE -const u8 gUnknown_83FC10C[] = _("{B_ATK_NAME_WITH_PREFIX} braced\nitself!"); // @ 83FC10C -const u8 gUnknown_83FC11E[] = _("{B_DEF_NAME_WITH_PREFIX} ENDURED\nthe hit!"); // @ 83FC11E -const u8 gUnknown_83FC132[] = _("MAGNITUDE {B_BUFF1}!"); // @ 83FC132 -const u8 gUnknown_83FC140[] = _("{B_ATK_NAME_WITH_PREFIX} cut its own HP\nand maximized ATTACK!"); // @ 83FC140 -const u8 gUnknown_83FC168[] = _("{B_ATK_NAME_WITH_PREFIX} copied\n{B_DEF_NAME_WITH_PREFIX}'s stat changes!"); // @ 83FC168 -const u8 gUnknown_83FC185[] = _("{B_ATK_NAME_WITH_PREFIX} got free of\n{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}!"); // @ 83FC185 -const u8 gUnknown_83FC19D[] = _("{B_ATK_NAME_WITH_PREFIX} shed\nLEECH SEED!"); // @ 83FC19D -const u8 gUnknown_83FC1B1[] = _("{B_ATK_NAME_WITH_PREFIX} blew away\nSPIKES!"); // @ 83FC1B1 -const u8 gUnknown_83FC1C6[] = _("{B_ATK_NAME_WITH_PREFIX} fled from\nbattle!"); // @ 83FC1C6 -const u8 gUnknown_83FC1DB[] = _("{B_ATK_NAME_WITH_PREFIX} foresaw\nan attack!"); // @ 83FC1DB -const u8 gUnknown_83FC1F1[] = _("{B_DEF_NAME_WITH_PREFIX} took the\n{B_BUFF1} attack!"); // @ 83FC1F1 -const u8 gUnknown_83FC208[] = _("{B_ATK_NAME_WITH_PREFIX} chose\n{B_CURRENT_MOVE} as its destiny!"); // @ 83FC208 -const u8 gUnknown_83FC224[] = _("{B_BUFF1}'s attack!"); // @ 83FC224 -const u8 gUnknown_83FC231[] = _("{B_ATK_NAME_WITH_PREFIX} became the\ncenter of attention!"); // @ 83FC231 -const u8 gUnknown_83FC254[] = _("{B_ATK_NAME_WITH_PREFIX} began\ncharging power!"); // @ 83FC254 -const u8 gUnknown_83FC26D[] = _("NATURE POWER turned into\n{B_CURRENT_MOVE}!"); // @ 83FC26D -const u8 gUnknown_83FC28A[] = _("{B_ATK_NAME_WITH_PREFIX}'s status\nreturned to normal!"); // @ 83FC28A -const u8 gUnknown_83FC2AA[] = _("{B_DEF_NAME_WITH_PREFIX} was subjected\nto TORMENT!"); // @ 83FC2AA -const u8 gUnknown_83FC2C7[] = _("{B_ATK_NAME_WITH_PREFIX} is tightening\nits focus!"); // @ 83FC2C7 -const u8 gUnknown_83FC2E3[] = _("{B_DEF_NAME_WITH_PREFIX} fell for\nthe TAUNT!"); // @ 83FC2E3 -const u8 gUnknown_83FC2FA[] = _("{B_ATK_NAME_WITH_PREFIX} is ready to\nhelp {B_DEF_NAME_WITH_PREFIX}!"); // @ 83FC2FA -const u8 gUnknown_83FC312[] = _("{B_ATK_NAME_WITH_PREFIX} switched\nitems with its opponent!"); // @ 83FC312 -const u8 gUnknown_83FC337[] = _("{B_ATK_NAME_WITH_PREFIX} obtained\n{B_BUFF1}."); // @ 83FC337 -const u8 gUnknown_83FC347[] = _("{B_DEF_NAME_WITH_PREFIX} obtained\n{B_BUFF2}."); // @ 83FC347 -const u8 gUnknown_83FC357[] = _("{B_ATK_NAME_WITH_PREFIX} obtained\n{B_BUFF1}.\p{B_DEF_NAME_WITH_PREFIX} obtained\n{B_BUFF2}."); // @ 83FC357 -const u8 gUnknown_83FC377[] = _("{B_ATK_NAME_WITH_PREFIX} copied\n{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}!"); // @ 83FC377 -const u8 gUnknown_83FC38A[] = _("{B_ATK_NAME_WITH_PREFIX} made a WISH!"); // @ 83FC38A -const u8 gUnknown_83FC39A[] = _("{B_BUFF1}'s WISH\ncame true!"); // @ 83FC39A -const u8 gUnknown_83FC3AF[] = _("{B_ATK_NAME_WITH_PREFIX} planted its roots!"); // @ 83FC3AF -const u8 gUnknown_83FC3C5[] = _("{B_ATK_NAME_WITH_PREFIX} absorbed\nnutrients with its roots!"); // @ 83FC3C5 -const u8 gUnknown_83FC3EB[] = _("{B_DEF_NAME_WITH_PREFIX} anchored\nitself with its roots!"); // @ 83FC3EB -const u8 gUnknown_83FC40E[] = _("{B_ATK_NAME_WITH_PREFIX} made\n{B_DEF_NAME_WITH_PREFIX} drowsy!"); // @ 83FC40E -const u8 gUnknown_83FC421[] = _("{B_ATK_NAME_WITH_PREFIX} knocked off\n{B_DEF_NAME_WITH_PREFIX}'s {B_LAST_ITEM}!"); // @ 83FC421 -const u8 gUnknown_83FC439[] = _("{B_ATK_NAME_WITH_PREFIX} swapped abilities\nwith its opponent!"); // @ 83FC439 -const u8 gUnknown_83FC461[] = _("{B_ATK_NAME_WITH_PREFIX} sealed the\nopponent's moveシsス!"); // @ 83FC461 -const u8 gUnknown_83FC483[] = _("{B_ATK_NAME_WITH_PREFIX} wants the\nopponent to bear a GRUDGE!"); // @ 83FC483 -const u8 gUnknown_83FC4AB[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1} lost\nall its PP due to the GRUDGE!"); // @ 83FC4AB -const u8 gUnknown_83FC4D6[] = _("{B_ATK_NAME_WITH_PREFIX} shrouded\nitself in {B_CURRENT_MOVE}!"); // @ 83FC4D6 -const u8 gUnknown_83FC4F0[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_CURRENT_MOVE}\nwas bounced back by MAGIC COAT!"); // @ 83FC4F0 -const u8 gUnknown_83FC518[] = _("{B_ATK_NAME_WITH_PREFIX} waits for its foe\nto make a move!"); // @ 83FC518 -const u8 gUnknown_83FC53D[] = _("{B_DEF_NAME_WITH_PREFIX} SNATCHED\n{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s move!"); // @ 83FC53D -const u8 gUnknown_83FC554[] = _("Electricity's power was\nweakened!"); // @ 83FC554 -const u8 gUnknown_83FC576[] = _("Fire's power was\nweakened!"); // @ 83FC576 -const u8 gUnknown_83FC591[] = _("{B_ATK_NAME_WITH_PREFIX} found\none {B_LAST_ITEM}!"); // @ 83FC591 -const u8 gUnknown_83FC5A2[] = _("A soothing aroma wafted\nthrough the area!"); // @ 83FC5A2 -const u8 gUnknown_83FC5CC[] = _("Items can't be used now.{PAUSE 64}"); // @ 83FC5CC -const u8 gUnknown_83FC5E8[] = _("For {B_SCR_ACTIVE_NAME_WITH_PREFIX},\n{B_LAST_ITEM} {B_BUFF1}"); // @ 83FC5E8 -const u8 gUnknown_83FC5F6[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} used\n{B_LAST_ITEM} to hustle!"); // @ 83FC5F6 -const u8 gUnknown_83FC60C[] = _("{B_ATK_NAME_WITH_PREFIX} lost its\nfocus and couldn't move!"); // @ 83FC60C -const u8 gUnknown_83FC631[] = _("{B_DEF_NAME_WITH_PREFIX} was\ndragged out!\p"); // @ 83FC631 -const u8 gUnknown_83FC646[] = _("The wall shattered!"); // @ 83FC646 -const u8 gUnknown_83FC65A[] = _("But it had no effect!"); // @ 83FC65A -const u8 gUnknown_83FC670[] = _("{B_ACTIVE_NAME_WITH_PREFIX} has no\nmoves left!\p"); // @ 83FC670 -const u8 gUnknown_83FC687[] = _("{B_ACTIVE_NAME_WITH_PREFIX}'s {B_CURRENT_MOVE}\nis disabled!\p"); // @ 83FC687 -const u8 gUnknown_83FC69D[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use the same\nmove in a row due to the TORMENT!\p"); // @ 83FC69D -const u8 gUnknown_83FC6D6[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use\n{B_CURRENT_MOVE} after the TAUNT!\p"); // @ 83FC6D6 -const u8 gUnknown_83FC6F8[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use the\nsealed {B_CURRENT_MOVE}!\p"); // @ 83FC6F8 -const u8 gUnknown_83FC715[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade it rain!"); // @ 83FC715 -const u8 gUnknown_83FC72B[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nraised its SPEED!"); // @ 83FC72B -const u8 gUnknown_83FC745[] = _("{B_DEF_NAME_WITH_PREFIX} was protected\nby {B_DEF_ABILITY}!"); // @ 83FC745 -const u8 gUnknown_83FC75D[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents {B_ATK_NAME_WITH_PREFIX}\lfrom using {B_CURRENT_MOVE}!"); // @ 83FC75D -const u8 gUnknown_83FC780[] = _("{B_DEF_NAME_WITH_PREFIX} restored HP\nusing its {B_DEF_ABILITY}!"); // @ 83FC780 -const u8 gUnknown_83FC79D[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade {B_CURRENT_MOVE} useless!"); // @ 83FC79D -const u8 gUnknown_83FC7B6[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade it the {B_BUFF1} type!"); // @ 83FC7B6 -const u8 gUnknown_83FC7D3[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents paralysis!"); // @ 83FC7D3 -const u8 gUnknown_83FC7EF[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents romance!"); // @ 83FC7EF -const u8 gUnknown_83FC809[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents poisoning!"); // @ 83FC809 -const u8 gUnknown_83FC825[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents confusion!"); // @ 83FC825 -const u8 gUnknown_83FC841[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nraised its FIRE power!"); // @ 83FC841 -const u8 gUnknown_83FC860[] = _("{B_DEF_NAME_WITH_PREFIX} anchors\nitself with {B_DEF_ABILITY}!"); // @ 83FC860 -const u8 gUnknown_83FC87B[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncuts {B_DEF_NAME_WITH_PREFIX}'s ATTACK!"); // @ 83FC87B -const u8 gUnknown_83FC895[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nprevents stat loss!"); // @ 83FC895 -const u8 gUnknown_83FC8B1[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nhurt {B_ATK_NAME_WITH_PREFIX}!"); // @ 83FC8B1 -const u8 gUnknown_83FC8C2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} TRACED\n{B_BUFF1}'s {B_BUFF2}!"); // @ 83FC8C2 -const u8 gUnknown_83FC8D5[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_EFF_ABILITY}\nprevents burns!"); // @ 83FC8D5 -const u8 gUnknown_83FC8ED[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nblocks {B_CURRENT_MOVE}!"); // @ 83FC8ED -const u8 gUnknown_83FC900[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nblocks {B_CURRENT_MOVE}!"); // @ 83FC900 -const u8 gUnknown_83FC913[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_ATK_ABILITY}\nrestored its HP a little!"); // @ 83FC913 -const u8 gUnknown_83FC935[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nwhipped up a sandstorm!"); // @ 83FC935 -const u8 gUnknown_83FC955[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nintensified the sun's rays!"); // @ 83FC955 -const u8 gUnknown_83FC979[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nprevents {B_BUFF1} loss!"); // @ 83FC979 -const u8 gUnknown_83FC993[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\ninfatuated {B_ATK_NAME_WITH_PREFIX}!"); // @ 83FC993 -const u8 gUnknown_83FC9AA[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade {B_CURRENT_MOVE} ineffective!"); // @ 83FC9AA -const u8 gUnknown_83FC9C7[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncured its {B_BUFF1} problem!"); // @ 83FC9C7 -const u8 gUnknown_83FC9E5[] = _("It sucked up the\nLIQUID OOZE!"); // @ 83FC9E5 -const u8 gUnknown_83FCA03[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} transformed!"); // @ 83FCA03 -const u8 gUnknown_83FCA13[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\ntook the attack!"); // @ 83FCA13 -const u8 gText_PkmnsXPreventsSwitching[] = _("{B_BUFF1}'s {B_LAST_ABILITY}\nprevents switching!\p"); // @ 83FCA2C -const u8 gUnknown_83FCA49[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevented {B_SCR_ACTIVE_NAME_WITH_PREFIX}'s\l{B_BUFF1} from working!"); // @ 83FCA49 -const u8 gUnknown_83FCA71[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade it ineffective!"); // @ 83FCA71 -const u8 gUnknown_83FCA8E[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_EFF_ABILITY}\nprevents flinching!"); // @ 83FCA8E -const u8 gUnknown_83FCAAA[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_ATK_ABILITY}\nprevents {B_DEF_NAME_WITH_PREFIX}'s\l{B_DEF_ABILITY} from working!"); // @ 83FCAAA -const u8 gUnknown_83FCAD1[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncured its {B_BUFF1} problem!"); // @ 83FCAD1 -const u8 gUnknown_83FCAEF[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nhad no effect on {B_EFF_NAME_WITH_PREFIX}!"); // @ 83FCAEF -const u8 gUnknown_83FCB0C[] = _("{B_ATK_NAME_WITH_PREFIX} is too scared to move!"); // @ 83FCB0C -const u8 gUnknown_83FCB26[] = _("GHOST: Get out…… Get out……"); // @ 83FCB26 -const u8 gUnknown_83FCB41[] = _("sharply "); // @ 83FCB41 -const u8 BattleText_Rose[] = _("rose!"); // @ 83FCB4A -const u8 gUnknown_83FCB50[] = _("harshly "); // @ 83FCB50 -const u8 gUnknown_83FCB59[] = _("fell!"); // @ 83FCB59 -const u8 gUnknown_83FCB5F[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); // @ 83FCB5F -const u8 BattleText_UnknownString3[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); // @ 83FCB6A -const u8 gUnknown_83FCB75[] = _("Using {B_LAST_ITEM}, the {B_BUFF1}\nof {B_SCR_ACTIVE_NAME_WITH_PREFIX} {B_BUFF2}"); // @ 83FCB75 -const u8 gUnknown_83FCB8F[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); // @ 83FCB8F -const u8 gUnknown_83FCB9A[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); // @ 83FCB9A -const u8 gUnknown_83FCBA5[] = _("{B_ATK_NAME_WITH_PREFIX}'s stats won't\ngo any higher!"); // @ 83FCBA5 -const u8 gUnknown_83FCBC5[] = _("{B_DEF_NAME_WITH_PREFIX}'s stats won't\ngo any lower!"); // @ 83FCBC5 -const u8 gUnknown_83FCBE4[] = _("A critical hit!"); // @ 83FCBE4 -const u8 gUnknown_83FCBF4[] = _("It's a one-hit KO!"); // @ 83FCBF4 -const u8 gUnknown_83FCC07[] = _("{PAUSE 32}1, {PAUSE 15}2, and{PAUSE 15}… {PAUSE 15}… {PAUSE 15}… {PAUSE 15}{PLAY_SE SE_KON}Poof!\p"); // @ 83FCC07 -const u8 gUnknown_83FCC33[] = _("And…\p"); // @ 83FCC33 -const u8 gUnknown_83FCC39[] = _("HM moves can't be\nforgotten now.\p"); // @ 83FCC39 -const u8 gUnknown_83FCC5B[] = _("It's not very effective…"); // @ 83FCC5B -const u8 gUnknown_83FCC74[] = _("It's super effective!"); // @ 83FCC74 -static const u8 sText_GotAwaySafely[] = _("{PLAY_SE SE_NIGERU}Got away safely!\p"); // @ 83FCC8A -const u8 gUnknown_83FCCA0[] = _("{PLAY_SE SE_NIGERU}{B_ATK_NAME_WITH_PREFIX} fled\nusing its {B_LAST_ITEM}!\p"); // @ 83FCCA0 -const u8 gUnknown_83FCCBB[] = _("{PLAY_SE SE_NIGERU}{B_ATK_NAME_WITH_PREFIX} fled\nusing {B_ATK_ABILITY}!\p"); // @ 83FCCBB -const u8 gUnknown_83FCCD2[] = _("{PLAY_SE SE_NIGERU}Wild {B_BUFF1} fled!"); // @ 83FCCD2 -static const u8 sText_PlayerDefeatedLinkTrainer[] = _("Player defeated\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCCE4 -static const u8 sText_TwoLinkTrainersDefeated[] = _("Player beat {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); // @ 83FCCF8 -static const u8 sText_PlayerLostAgainstLinkTrainer[] = _("Player lost against\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCD0F -static const u8 sText_PlayerLostToTwo[] = _("Player lost to {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); // @ 83FCD27 -static const u8 sText_PlayerBattledToDrawLinkTrainer[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME}!"); // @ 83FCD41 -static const u8 sText_PlayerBattledToDrawVsTwo[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}!"); // @ 83FCD66 -const u8 gUnknown_83FCD92[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} fled!"); // @ 83FCD92 -static const u8 sText_TwoWildFled[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} and\n{B_LINK_OPPONENT2_NAME} fled!"); // @ 83FCD9F -const u8 gUnknown_83FCDB3[] = _("No! There's no running\nfrom a TRAINER battle!\p"); // @ 83FCDB3 -const u8 gUnknown_83FCDE2[] = _("Can't escape!\p"); // @ 83FCDE2 -const u8 gUnknown_83FCDF1[] = _(""); // @ 83FCDF1 -const u8 gUnknown_83FCDF2[] = _("But nothing happened!"); // @ 83FCDF2 -const u8 gUnknown_83FCE08[] = _("But it failed!"); // @ 83FCE08 -const u8 gUnknown_83FCE17[] = _("It hurt itself in its\nconfusion!"); // @ 83FCE17 -const u8 gUnknown_83FCE38[] = _("The MIRROR MOVE failed!"); // @ 83FCE38 -const u8 gUnknown_83FCE50[] = _("It started to rain!"); // @ 83FCE50 -const u8 gUnknown_83FCE64[] = _("A downpour started!"); // @ 83FCE64 -const u8 gUnknown_83FCE78[] = _("Rain continues to fall."); // @ 83FCE78 -const u8 gUnknown_83FCE90[] = _("The downpour continues."); // @ 83FCE90 -const u8 gUnknown_83FCEA8[] = _("The rain stopped."); // @ 83FCEA8 -const u8 gUnknown_83FCEBA[] = _("A sandstorm brewed!"); // @ 83FCEBA -const u8 gUnknown_83FCECE[] = _("The sandstorm rages."); // @ 83FCECE -const u8 gUnknown_83FCEE3[] = _("The sandstorm subsided."); // @ 83FCEE3 -const u8 gUnknown_83FCEFB[] = _("The sunlight got bright!"); // @ 83FCEFB -const u8 gUnknown_83FCF14[] = _("The sunlight is strong."); // @ 83FCF14 -const u8 gUnknown_83FCF2C[] = _("The sunlight faded."); // @ 83FCF2C -const u8 gUnknown_83FCF40[] = _("It started to hail!"); // @ 83FCF40 -const u8 gUnknown_83FCF54[] = _("Hail continues to fall."); // @ 83FCF54 -const u8 gUnknown_83FCF6C[] = _("The hail stopped."); // @ 83FCF6C -const u8 gUnknown_83FCF7E[] = _("But it failed to SPIT UP\na thing!"); // @ 83FCF7E -const u8 gUnknown_83FCFA0[] = _("But it failed to SWALLOW\na thing!"); // @ 83FCFA0 -const u8 gUnknown_83FCFC2[] = _("The wind turned into a\nHEAT WAVE!"); // @ 83FCFC2 -const u8 gUnknown_83FCFE4[] = _("All stat changes were\neliminated!"); // @ 83FCFE4 -const u8 gUnknown_83FD006[] = _("Coins scattered everywhere!"); // @ 83FD006 -const u8 gUnknown_83FD022[] = _("It was too weak to make\na SUBSTITUTE!"); // @ 83FD022 -const u8 gUnknown_83FD048[] = _("The battlers shared\ntheir pain!"); // @ 83FD048 -const u8 gUnknown_83FD068[] = _("A bell chimed!"); // @ 83FD068 -const u8 gUnknown_83FD077[] = _("All affected POKéMON will\nfaint in three turns!"); // @ 83FD077 -const u8 gUnknown_83FD0A7[] = _("There's no PP left for\nthis move!\p"); // @ 83FD0A7 -const u8 gUnknown_83FD0CA[] = _("But there was no PP left\nfor the move!"); // @ 83FD0CA -const u8 gUnknown_83FD0F1[] = _("{B_ATK_NAME_WITH_PREFIX} ignored\norders while asleep!"); // @ 83FD0F1 -const u8 gUnknown_83FD111[] = _("{B_ATK_NAME_WITH_PREFIX} ignored\norders!"); // @ 83FD111 -const u8 gUnknown_83FD124[] = _("{B_ATK_NAME_WITH_PREFIX} began to nap!"); // @ 83FD124 -const u8 gUnknown_83FD135[] = _("{B_ATK_NAME_WITH_PREFIX} is\nloafing around!"); // @ 83FD135 -const u8 gUnknown_83FD14B[] = _("{B_ATK_NAME_WITH_PREFIX} won't\nobey!"); // @ 83FD14B -const u8 gUnknown_83FD15A[] = _("{B_ATK_NAME_WITH_PREFIX} turned away!"); // @ 83FD15A -const u8 gUnknown_83FD16A[] = _("{B_ATK_NAME_WITH_PREFIX} pretended\nnot to notice!"); // @ 83FD16A -const u8 gUnknown_83FD186[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} is\nabout to use {B_BUFF2}.\pWill {B_PLAYER_NAME} change\nPOKéMON?"); // @ 83FD186 -const u8 gUnknown_83FD1B8[] = _("{B_ATK_NAME_WITH_PREFIX} learned\n{B_BUFF1}!"); // @ 83FD1B8 -static const u8 sText_PlayerDefeatedLinkTrainerTrainer1[] = _("Player defeated\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!\p"); // @ 83FD1C7 -const u8 gUnknown_83FD1DF[] = _("{B_PLAYER_NAME} threw a ROCK\nat the {B_OPPONENT_MON1_NAME}!"); // @ 83FD1DF -const u8 gUnknown_83FD1FA[] = _("{B_PLAYER_NAME} threw some BAIT\nat the {B_OPPONENT_MON1_NAME}!"); // @ 83FD1FA -const u8 gUnknown_83FD218[] = _("{B_OPPONENT_MON1_NAME} is watching\ncarefully!"); // @ 83FD218 -const u8 gUnknown_83FD232[] = _("{B_OPPONENT_MON1_NAME} is angry!"); // @ 83FD232 -const u8 gUnknown_83FD23F[] = _("{B_OPPONENT_MON1_NAME} is eating!"); // @ 83FD23F -const u8 gUnknown_83FD24D[] = _("{PLAY_SE SE_PINPON}ANNOUNCER: You're out of\nSAFARI BALLS! Game over!\p"); // @ 83FD24D -static const u8 sText_WildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); // @ 83FD284 -static const u8 sText_WildPkmnAppeared2[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); // @ 83FD297 -static const u8 sText_WildPkmnAppearedPause[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!{PAUSE 127}"); // @ 83FD2AA -static const u8 sText_TwoWildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} and\n{B_OPPONENT_MON2_NAME} appeared!\p"); // @ 83FD2BF -const u8 gUnknown_83FD2D9[] = _("The GHOST appeared!\pDarn!\nThe GHOST can't be ID'd!\p"); // @ 83FD2D9 -const u8 gUnknown_83FD30D[] = _("The GHOST appeared!\p"); // @ 83FD30D -const u8 gUnknown_83FD322[] = _("SILPH SCOPE unveiled the GHOST's\nidentity!"); // @ 83FD322 -const u8 gUnknown_83FD34D[] = _("The GHOST was MAROWAK!\p\n"); // @ 83FD34D -static const u8 sText_Trainer1WantsToBattle[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwould like to battle!\p"); // @ 83FD366 -static const u8 sText_LinkTrainerWantsToBattle[] = _("{B_LINK_OPPONENT1_NAME}\nwants to battle!"); // @ 83FD383 -static const u8 sText_TwoLinkTrainersWantToBattle[] = _("{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}\nwant to battle!"); // @ 83FD397 -static const u8 sText_Trainer1SentOutPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME}!{PAUSE 60}"); // @ 83FD3B1 -static const u8 sText_Trainer1SentOutTwoPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!{PAUSE 60}"); // @ 83FD3C7 -static const u8 sText_Trainer1SentOutPkmn2[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_BUFF1}!"); // @ 83FD3E4 -static const u8 sText_LinkTrainerSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME}!"); // @ 83FD3F7 -static const u8 sText_LinkTrainerSentOutTwoPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!"); // @ 83FD407 -static const u8 sText_TwoLinkTrainersSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out {B_LINK_OPPONENT_MON1_NAME}!\n{B_LINK_OPPONENT2_NAME} sent out {B_LINK_OPPONENT_MON2_NAME}!"); // @ 83FD41E -static const u8 sText_LinkTrainerSentOutPkmn2[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_BUFF1}!"); // @ 83FD43E -static const u8 sText_LinkTrainerMultiSentOutPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} sent out\n{B_BUFF1}!"); // @ 83FD44E -static const u8 sText_GoPkmn[] = _("Go! {B_PLAYER_MON1_NAME}!"); // @ 83FD45E -static const u8 sText_GoTwoPkmn[] = _("Go! {B_PLAYER_MON1_NAME} and\n{B_PLAYER_MON2_NAME}!"); // @ 83FD466 -static const u8 sText_GoPkmn2[] = _("Go! {B_BUFF1}!"); // @ 83FD475 -static const u8 sText_DoItPkmn[] = _("Do it! {B_BUFF1}!"); // @ 83FD47D -static const u8 sText_GoForItPkmn[] = _("Go for it, {B_BUFF1}!"); // @ 83FD488 -static const u8 sText_YourFoesWeakGetEmPkmn[] = _("Your foe's weak!\nGet 'em, {B_BUFF1}!"); // @ 83FD497 -static const u8 sText_LinkPartnerSentOutPkmnGoPkmn[] = _("{B_LINK_PARTNER_NAME} sent out {B_LINK_PLAYER_MON2_NAME}!\nGo! {B_LINK_PLAYER_MON1_NAME}!"); // @ 83FD4B5 -static const u8 sText_PkmnThatsEnough[] = _("{B_BUFF1}, that's enough!\nCome back!"); // @ 83FD4CD -static const u8 sText_PkmnComeBack[] = _("{B_BUFF1}, come back!"); // @ 83FD4EB -static const u8 sText_PkmnOkComeBack[] = _("{B_BUFF1}, OK!\nCome back!"); // @ 83FD4FA -const u8 sText_PkmnGoodComeBack[] = _("{B_BUFF1}, good!\nCome back!"); // @ 83FD50D -static const u8 sText_Trainer1WithdrewPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwithdrew {B_BUFF1}!"); // @ 83FD522 -static const u8 sText_LinkTrainer1WithdrewPkmn[] = _("{B_LINK_OPPONENT1_NAME} withdrew\n{B_BUFF1}!"); // @ 83FD535 -static const u8 sText_LinkTrainer2WithdrewPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} withdrew\n{B_BUFF1}!"); // @ 83FD545 -static const u8 sText_WildPkmnPrefix[] = _("Wild "); // @ 83FD555 -static const u8 sText_FoePkmnPrefix[] = _("Foe "); // @ 83FD55B -static const u8 sText_FoePkmnPrefix2[] = _("Foe"); // @ 83FD560 -static const u8 sText_AllyPkmnPrefix[] = _("Ally"); // @ 83FD564 -static const u8 sText_FoePkmnPrefix3[] = _("Foe"); // @ 83FD569 -static const u8 sText_AllyPkmnPrefix2[] = _("Ally"); // @ 83FD56D -static const u8 sText_FoePkmnPrefix4[] = _("Foe"); // @ 83FD572 -static const u8 sText_AllyPkmnPrefix3[] = _("Ally"); // @ 83FD576 -static const u8 sText_AttackerUsedX[] = _("{B_ATK_NAME_WITH_PREFIX} used\n{B_BUFF2}"); // @ 83FD57B -static const u8 sText_ExclamationMark[] = _("!"); // @ 83FD586 -static const u8 sText_ExclamationMark2[] = _("!"); // @ 83FD588 -static const u8 sText_ExclamationMark3[] = _("!"); // @ 83FD58A -static const u8 sText_ExclamationMark4[] = _("!"); // @ 83FD58C -static const u8 sText_ExclamationMark5[] = _("!"); // @ 83FD58E - -static const u8 sText_HP2[] = _("HP"); // @ 83FD590 -static const u8 sText_Attack2[] = _("ATTACK"); // @ 83FD593 -static const u8 sText_Defense2[] = _("DEFENSE"); // @ 83FD59A -static const u8 sText_Speed[] = _("SPEED"); // @ 83FD5A2 -static const u8 sText_SpAtk2[] = _("SP. ATK"); // @ 83FD5A8 -static const u8 sText_SpDef2[] = _("SP. DEF"); // @ 83FD5B0 -static const u8 sText_Accuracy[] = _("accuracy"); // @ 83FD5B8 -static const u8 sText_Evasiveness[] = _("evasiveness"); // @ 83FD5C1 +const u8 gUnknown_83FB218[] = _(""); +const u8 gUnknown_83FB219[] = _("{B_TRAINER1_LOSE_TEXT}"); +const u8 gUnknown_83FB21C[] = _("{B_TRAINER2_CLASS}"); +const u8 gUnknown_83FB21F[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON1_NAME}, come back!"); +const u8 gUnknown_83FB232[] = _("{B_TRAINER1_WIN_TEXT}"); +const u8 gUnknown_83FB235[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON2_NAME}, come back!"); +const u8 gUnknown_83FB248[] = _("{B_TRAINER1_NAME}: {B_OPPONENT_MON1_NAME} and\n{B_OPPONENT_MON2_NAME}, come back!"); +const u8 gUnknown_83FB262[] = _("{B_TRAINER2_NAME}"); +const u8 gUnknown_83FB265[] = _("{B_BUFF1} gained{B_BUFF2}\n{B_TRAINER2_LOSE_TEXT} EXP. Points!\p"); +const u8 gUnknown_83FB282[] = _(""); +const u8 gUnknown_83FB283[] = _(" a boosted"); +const u8 gUnknown_83FB28E[] = _("{B_BUFF1} grew to\nLV. {B_BUFF2}!{WAIT_SE}\p"); +const u8 gUnknown_83FB2A4[] = _("{B_BUFF1} learned\n{B_BUFF2}!{WAIT_SE}\p"); +const u8 gUnknown_83FB2B6[] = _("{B_BUFF1} is trying to\nlearn {B_BUFF2}.\p"); +const u8 gUnknown_83FB2D1[] = _("But, {B_BUFF1} can't learn\nmore than four moves.\p"); +const u8 gUnknown_83FB2FC[] = _("Delete a move to make\nroom for {B_BUFF2}?"); +const u8 gUnknown_83FB31F[] = _("{B_BUFF1} forgot\n{B_BUFF2}.\p"); +const u8 gUnknown_83FB32E[] = _("{PAUSE 32}Stop learning\n{B_BUFF2}?"); +const u8 gUnknown_83FB343[] = _("{B_BUFF1} did not learn\n{B_BUFF2}.\p"); +const u8 gUnknown_83FB359[] = _("Use next POKéMON?"); +const u8 gUnknown_83FB36B[] = _("{B_ATK_NAME_WITH_PREFIX}'s\nattack missed!"); +const u8 gUnknown_83FB37F[] = _("{B_DEF_NAME_WITH_PREFIX}\nprotected itself!"); +const u8 gUnknown_83FB394[] = _("{B_DEF_NAME_WITH_PREFIX} avoided\ndamage with {B_DEF_ABILITY}!"); +const u8 gUnknown_83FB3AF[] = _("{B_DEF_NAME_WITH_PREFIX} makes GROUND\nmoves miss with {B_DEF_ABILITY}!"); +const u8 gUnknown_83FB3D3[] = _("{B_DEF_NAME_WITH_PREFIX} avoided\nthe attack!"); +const u8 gUnknown_83FB3EA[] = _("It doesn't affect\n{B_DEF_NAME_WITH_PREFIX}…"); +const u8 gUnknown_83FB400[] = _("{B_ATK_NAME_WITH_PREFIX}\nfainted!\p"); +const u8 gUnknown_83FB40D[] = _("{B_DEF_NAME_WITH_PREFIX}\nfainted!\p"); +const u8 gUnknown_83FB41A[] = _("{B_PLAYER_NAME} got ¥{B_BUFF1}\nfor winning!\p"); +const u8 gUnknown_83FB433[] = _("{B_PLAYER_NAME} is out of\nusable POKéMON!\p"); +const u8 gUnknown_83FB451[] = _("{B_PLAYER_NAME} panicked and lost ¥{B_BUFF1}…\p… … … …\p{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); +const u8 gUnknown_83FB484[] = _("{B_PLAYER_NAME} is out of\nusable POKéMON!\pPlayer lost against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!{PAUSE_UNTIL_PRESS}"); +const u8 gUnknown_83FB4BE[] = _("{B_PLAYER_NAME} paid ¥{B_BUFF1} as the prize\nmoney…\p… … … …\p{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); +const u8 gUnknown_83FB4F7[] = _("{B_PLAYER_NAME} whited out!{PAUSE_UNTIL_PRESS}"); +const u8 gUnknown_83FB508[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} prevents\nescape with {B_SCR_ACTIVE_ABILITY}!\p"); +const u8 gUnknown_83FB525[] = _("Can't escape!\p"); +const u8 gUnknown_83FB534[] = _("{B_ATK_NAME_WITH_PREFIX} can't escape!"); +const u8 gUnknown_83FB545[] = _("Hit {B_BUFF1} time(s)!"); +const u8 gUnknown_83FB555[] = _("{B_EFF_NAME_WITH_PREFIX}\nfell asleep!"); +const u8 gUnknown_83FB565[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade {B_EFF_NAME_WITH_PREFIX} sleep!"); +const u8 gUnknown_83FB57C[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready asleep!"); +const u8 gUnknown_83FB592[] = _("{B_ATK_NAME_WITH_PREFIX} is\nalready asleep!"); +const u8 gUnknown_83FB5A8[] = _("{B_DEF_NAME_WITH_PREFIX}\nwasn't affected!"); +const u8 gUnknown_83FB5BC[] = _("{B_EFF_NAME_WITH_PREFIX}\nwas poisoned!"); +const u8 gUnknown_83FB5CD[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\npoisoned {B_EFF_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FB5E2[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby poison!"); +const u8 gUnknown_83FB5F8[] = _("{B_DEF_NAME_WITH_PREFIX} is already\npoisoned."); +const u8 gUnknown_83FB610[] = _("{B_EFF_NAME_WITH_PREFIX} is badly\npoisoned!"); +const u8 gUnknown_83FB626[] = _("{B_DEF_NAME_WITH_PREFIX} had its\nenergy drained!"); +const u8 gUnknown_83FB641[] = _("{B_EFF_NAME_WITH_PREFIX} was burned!"); +const u8 gUnknown_83FB650[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nburned {B_EFF_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FB663[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby its burn!"); +const u8 gUnknown_83FB67B[] = _("{B_DEF_NAME_WITH_PREFIX} already\nhas a burn."); +const u8 gUnknown_83FB692[] = _("{B_EFF_NAME_WITH_PREFIX} was\nfrozen solid!"); +const u8 gUnknown_83FB6A7[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nfroze {B_EFF_NAME_WITH_PREFIX} solid!"); +const u8 gUnknown_83FB6BF[] = _("{B_ATK_NAME_WITH_PREFIX} is\nfrozen solid!"); +const u8 gUnknown_83FB6D3[] = _("{B_DEF_NAME_WITH_PREFIX} was\ndefrosted!"); +const u8 gUnknown_83FB6E5[] = _("{B_ATK_NAME_WITH_PREFIX} was\ndefrosted!"); +const u8 gUnknown_83FB6F7[] = _("{B_ATK_NAME_WITH_PREFIX} was\ndefrosted by {B_CURRENT_MOVE}!"); +const u8 gUnknown_83FB70F[] = _("{B_EFF_NAME_WITH_PREFIX} is paralyzed!\nIt may be unable to move!"); +const u8 gUnknown_83FB73A[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nparalyzed {B_EFF_NAME_WITH_PREFIX}!\lIt may be unable to move!"); +const u8 gUnknown_83FB76A[] = _("{B_ATK_NAME_WITH_PREFIX} is paralyzed!\nIt can't move!"); +const u8 gUnknown_83FB78A[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready paralyzed!"); +const u8 gUnknown_83FB7A3[] = _("{B_DEF_NAME_WITH_PREFIX} was\nhealed of paralysis!"); +const u8 gUnknown_83FB7BF[] = _("{B_DEF_NAME_WITH_PREFIX}'s\ndream was eaten!"); +const u8 gUnknown_83FB7D5[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\nwon't go higher!"); +const u8 gUnknown_83FB7EE[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\nwon't go lower!"); +const u8 gUnknown_83FB806[] = _("Your team's {B_BUFF1}\nstopped working!"); +const u8 gUnknown_83FB826[] = _("The foe's {B_BUFF1}\nstopped working!"); +const u8 gUnknown_83FB844[] = _("{B_ATK_NAME_WITH_PREFIX} is\nconfused!"); +const u8 gUnknown_83FB854[] = _("{B_ATK_NAME_WITH_PREFIX} snapped\nout of confusion!"); +const u8 gUnknown_83FB871[] = _("{B_EFF_NAME_WITH_PREFIX} became\nconfused!"); +const u8 gUnknown_83FB885[] = _("{B_DEF_NAME_WITH_PREFIX} is\nalready confused!"); +const u8 gUnknown_83FB89D[] = _("{B_DEF_NAME_WITH_PREFIX}\nfell in love!"); +const u8 gUnknown_83FB8AE[] = _("{B_ATK_NAME_WITH_PREFIX} is in love\nwith {B_SCR_ACTIVE_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FB8C5[] = _("{B_ATK_NAME_WITH_PREFIX} is\nimmobilized by love!"); +const u8 gUnknown_83FB8E0[] = _("{B_DEF_NAME_WITH_PREFIX} was\nblown away!"); +const u8 gUnknown_83FB8F3[] = _("{B_ATK_NAME_WITH_PREFIX} transformed\ninto the {B_BUFF1} type!"); +const u8 gUnknown_83FB914[] = _("{B_ATK_NAME_WITH_PREFIX} flinched!"); +const u8 gUnknown_83FB921[] = _("{B_DEF_NAME_WITH_PREFIX} regained\nhealth!"); +const u8 gUnknown_83FB935[] = _("{B_DEF_NAME_WITH_PREFIX}'s\nHP is full!"); +const u8 gUnknown_83FB946[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised SP. DEF!"); +const u8 gUnknown_83FB95E[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised SP. DEF a little!"); +const u8 gUnknown_83FB97F[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised DEFENSE!"); +const u8 gUnknown_83FB997[] = _("{B_ATK_PREFIX2}'s {B_CURRENT_MOVE}\nraised DEFENSE a little!"); +const u8 gUnknown_83FB9B8[] = _("{B_ATK_PREFIX2}'s party is covered\nby a veil!"); +const u8 gUnknown_83FB9D9[] = _("{B_DEF_NAME_WITH_PREFIX}'s party is protected\nby SAFEGUARD!"); +const u8 gUnknown_83FB9FF[] = _("{B_ATK_PREFIX3}'s party is no longer\nprotected by SAFEGUARD!"); +const u8 gUnknown_83FBA2F[] = _("{B_ATK_NAME_WITH_PREFIX} went\nto sleep!"); +const u8 gUnknown_83FBA41[] = _("{B_ATK_NAME_WITH_PREFIX} slept and\nbecame healthy!"); +const u8 gUnknown_83FBA5E[] = _("{B_ATK_NAME_WITH_PREFIX} whipped\nup a whirlwind!"); +const u8 gUnknown_83FBA79[] = _("{B_ATK_NAME_WITH_PREFIX} took\nin sunlight!"); +const u8 gUnknown_83FBA8E[] = _("{B_ATK_NAME_WITH_PREFIX} lowered\nits head!"); +const u8 gUnknown_83FBAA3[] = _("{B_ATK_NAME_WITH_PREFIX} is glowing!"); +const u8 gUnknown_83FBAB2[] = _("{B_ATK_NAME_WITH_PREFIX} flew\nup high!"); +const u8 gUnknown_83FBAC3[] = _("{B_ATK_NAME_WITH_PREFIX} dug a hole!"); +const u8 gUnknown_83FBAD2[] = _("{B_ATK_NAME_WITH_PREFIX} hid\nunderwater!"); +const u8 gUnknown_83FBAE5[] = _("{B_ATK_NAME_WITH_PREFIX} sprang up!"); +const u8 gUnknown_83FBAF3[] = _("{B_DEF_NAME_WITH_PREFIX} was squeezed by\n{B_ATK_NAME_WITH_PREFIX}'s BIND!"); +const u8 gUnknown_83FBB11[] = _("{B_DEF_NAME_WITH_PREFIX} was trapped\nin the vortex!"); +const u8 gUnknown_83FBB2F[] = _("{B_DEF_NAME_WITH_PREFIX} was trapped\nby SAND TOMB!"); +const u8 gUnknown_83FBB4C[] = _("{B_DEF_NAME_WITH_PREFIX} was WRAPPED by\n{B_ATK_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FBB62[] = _("{B_ATK_NAME_WITH_PREFIX} CLAMPED\n{B_DEF_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FBB71[] = _("{B_ATK_NAME_WITH_PREFIX} is hurt\nby {B_BUFF1}!"); +const u8 gUnknown_83FBB83[] = _("{B_ATK_NAME_WITH_PREFIX} was freed\nfrom {B_BUFF1}!"); +const u8 gUnknown_83FBB99[] = _("{B_ATK_NAME_WITH_PREFIX} kept going\nand crashed!"); +const u8 gBattleText_MistShroud[] = _("{B_ATK_PREFIX2} became\nshrouded in MIST!"); +const u8 gUnknown_83FBBD0[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} is protected\nby MIST!"); +const u8 gBattleText_GetPumped[] = _("{B_ATK_NAME_WITH_PREFIX} is getting\npumped!"); +const u8 gUnknown_83FBBFF[] = _("{B_ATK_NAME_WITH_PREFIX} is hit\nwith recoil!"); +const u8 gUnknown_83FBC16[] = _("{B_ATK_NAME_WITH_PREFIX} protected\nitself!"); +const u8 gUnknown_83FBC2B[] = _("{B_ATK_NAME_WITH_PREFIX} is buffeted\nby the sandstorm!"); +const u8 gUnknown_83FBC4C[] = _("{B_ATK_NAME_WITH_PREFIX} is pelted\nby HAIL!"); +const u8 gUnknown_83FBC62[] = _("{B_ATK_PREFIX1}'s {B_BUFF1}\nwore off!"); +const u8 gUnknown_83FBC74[] = _("{B_DEF_NAME_WITH_PREFIX} was seeded!"); +const u8 gUnknown_83FBC83[] = _("{B_DEF_NAME_WITH_PREFIX} evaded\nthe attack!"); +const u8 gUnknown_83FBC99[] = _("{B_ATK_NAME_WITH_PREFIX}'s health is\nsapped by LEECH SEED!"); +const u8 gUnknown_83FBCBE[] = _("{B_ATK_NAME_WITH_PREFIX} is fast\nasleep."); +const u8 gUnknown_83FBCD1[] = _("{B_ATK_NAME_WITH_PREFIX} woke up!"); +const u8 gUnknown_83FBCDD[] = _("But {B_SCR_ACTIVE_NAME_WITH_PREFIX}'s UPROAR\nkept it awake!"); +const u8 gUnknown_83FBCFC[] = _("{B_ATK_NAME_WITH_PREFIX} woke up\nin the UPROAR!"); +const u8 gUnknown_83FBD16[] = _("{B_ATK_NAME_WITH_PREFIX} caused\nan UPROAR!"); +const u8 gUnknown_83FBD2B[] = _("{B_ATK_NAME_WITH_PREFIX} is making\nan UPROAR!"); +const u8 gUnknown_83FBD43[] = _("{B_ATK_NAME_WITH_PREFIX} calmed down."); +const u8 gUnknown_83FBD53[] = _("But {B_DEF_NAME_WITH_PREFIX} can't\nsleep in an UPROAR!"); +const u8 gUnknown_83FBD74[] = _("{B_ATK_NAME_WITH_PREFIX} STOCKPILED\n{B_BUFF1}!"); +const u8 gUnknown_83FBD86[] = _("{B_ATK_NAME_WITH_PREFIX} can't\nSTOCKPILE any more!"); +const u8 gUnknown_83FBDA3[] = _("But {B_DEF_NAME_WITH_PREFIX} can't\nsleep in an UPROAR!"); +const u8 gUnknown_83FBDC4[] = _("But the UPROAR kept\n{B_DEF_NAME_WITH_PREFIX} awake!"); +const u8 gUnknown_83FBDE2[] = _("{B_DEF_NAME_WITH_PREFIX} stayed awake\nusing its {B_DEF_ABILITY}!"); +const u8 gUnknown_83FBE00[] = _("{B_ATK_NAME_WITH_PREFIX} is storing\nenergy!"); +const u8 gUnknown_83FBE16[] = _("{B_ATK_NAME_WITH_PREFIX} unleashed\nenergy!"); +const u8 gUnknown_83FBE2B[] = _("{B_ATK_NAME_WITH_PREFIX} became\nconfused due to fatigue!"); +const u8 gUnknown_83FBE4E[] = _("{B_PLAYER_NAME} picked up\n¥{B_BUFF1}!\p"); +const u8 gUnknown_83FBE61[] = _("{B_DEF_NAME_WITH_PREFIX} is\nunaffected!"); +const u8 gUnknown_83FBE73[] = _("{B_ATK_NAME_WITH_PREFIX} transformed\ninto {B_BUFF1}!"); +const u8 gUnknown_83FBE8B[] = _("{B_ATK_NAME_WITH_PREFIX} made\na SUBSTITUTE!"); +const u8 gUnknown_83FBEA1[] = _("{B_ATK_NAME_WITH_PREFIX} already\nhas a SUBSTITUTE!"); +const u8 gUnknown_83FBEBE[] = _("The SUBSTITUTE took damage\nfor {B_DEF_NAME_WITH_PREFIX}!\p"); +const u8 gUnknown_83FBEE2[] = _("{B_DEF_NAME_WITH_PREFIX}'s\nSUBSTITUTE faded!\p"); +const u8 gUnknown_83FBEFA[] = _("{B_ATK_NAME_WITH_PREFIX} must\nrecharge!"); +const u8 gUnknown_83FBF0C[] = _("{B_DEF_NAME_WITH_PREFIX}'s RAGE\nis building!"); +const u8 gUnknown_83FBF23[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\nwas disabled!"); +const u8 gUnknown_83FBF39[] = _("{B_ATK_NAME_WITH_PREFIX} is disabled\nno more!"); +const u8 gUnknown_83FBF51[] = _("{B_DEF_NAME_WITH_PREFIX} got\nan ENCORE!"); +const u8 gUnknown_83FBF63[] = _("{B_ATK_NAME_WITH_PREFIX}'s ENCORE\nended!"); +const u8 gUnknown_83FBF76[] = _("{B_ATK_NAME_WITH_PREFIX} took aim\nat {B_DEF_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FBF89[] = _("{B_ATK_NAME_WITH_PREFIX} SKETCHED\n{B_BUFF1}!"); +const u8 gUnknown_83FBF99[] = _("{B_ATK_NAME_WITH_PREFIX} is trying\nto take its foe with it!"); +const u8 gUnknown_83FBFBF[] = _("{B_DEF_NAME_WITH_PREFIX} took\n{B_ATK_NAME_WITH_PREFIX} with it!"); +const u8 gUnknown_83FBFD3[] = _("Reduced {B_DEF_NAME_WITH_PREFIX}'s\n{B_BUFF1} by {B_BUFF2}!"); +const u8 gUnknown_83FBFEA[] = _("{B_ATK_NAME_WITH_PREFIX} stole\n{B_DEF_NAME_WITH_PREFIX}'s {B_LAST_ITEM}!"); +const u8 gUnknown_83FBFFC[] = _("{B_DEF_NAME_WITH_PREFIX} can't\nescape now!"); +const u8 gUnknown_83FC011[] = _("{B_DEF_NAME_WITH_PREFIX} fell into\na NIGHTMARE!"); +const u8 gUnknown_83FC02B[] = _("{B_ATK_NAME_WITH_PREFIX} is locked\nin a NIGHTMARE!"); +const u8 gUnknown_83FC048[] = _("{B_ATK_NAME_WITH_PREFIX} cut its own HP and\nlaid a CURSE on {B_DEF_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FC072[] = _("{B_ATK_NAME_WITH_PREFIX} is afflicted\nby the CURSE!"); +const u8 gUnknown_83FC090[] = _("SPIKES were scattered all around\nthe opponent's side!"); +const u8 gUnknown_83FC0C6[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} is hurt\nby SPIKES!"); +const u8 gUnknown_83FC0DC[] = _("{B_ATK_NAME_WITH_PREFIX} identified\n{B_DEF_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FC0EE[] = _("{B_ATK_NAME_WITH_PREFIX}'s PERISH count\nfell to {B_BUFF1}!"); +const u8 gUnknown_83FC10C[] = _("{B_ATK_NAME_WITH_PREFIX} braced\nitself!"); +const u8 gUnknown_83FC11E[] = _("{B_DEF_NAME_WITH_PREFIX} ENDURED\nthe hit!"); +const u8 gUnknown_83FC132[] = _("MAGNITUDE {B_BUFF1}!"); +const u8 gUnknown_83FC140[] = _("{B_ATK_NAME_WITH_PREFIX} cut its own HP\nand maximized ATTACK!"); +const u8 gUnknown_83FC168[] = _("{B_ATK_NAME_WITH_PREFIX} copied\n{B_DEF_NAME_WITH_PREFIX}'s stat changes!"); +const u8 gUnknown_83FC185[] = _("{B_ATK_NAME_WITH_PREFIX} got free of\n{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}!"); +const u8 gUnknown_83FC19D[] = _("{B_ATK_NAME_WITH_PREFIX} shed\nLEECH SEED!"); +const u8 gUnknown_83FC1B1[] = _("{B_ATK_NAME_WITH_PREFIX} blew away\nSPIKES!"); +const u8 gUnknown_83FC1C6[] = _("{B_ATK_NAME_WITH_PREFIX} fled from\nbattle!"); +const u8 gUnknown_83FC1DB[] = _("{B_ATK_NAME_WITH_PREFIX} foresaw\nan attack!"); +const u8 gUnknown_83FC1F1[] = _("{B_DEF_NAME_WITH_PREFIX} took the\n{B_BUFF1} attack!"); +const u8 gUnknown_83FC208[] = _("{B_ATK_NAME_WITH_PREFIX} chose\n{B_CURRENT_MOVE} as its destiny!"); +const u8 gUnknown_83FC224[] = _("{B_BUFF1}'s attack!"); +const u8 gUnknown_83FC231[] = _("{B_ATK_NAME_WITH_PREFIX} became the\ncenter of attention!"); +const u8 gUnknown_83FC254[] = _("{B_ATK_NAME_WITH_PREFIX} began\ncharging power!"); +const u8 gUnknown_83FC26D[] = _("NATURE POWER turned into\n{B_CURRENT_MOVE}!"); +const u8 gUnknown_83FC28A[] = _("{B_ATK_NAME_WITH_PREFIX}'s status\nreturned to normal!"); +const u8 gUnknown_83FC2AA[] = _("{B_DEF_NAME_WITH_PREFIX} was subjected\nto TORMENT!"); +const u8 gUnknown_83FC2C7[] = _("{B_ATK_NAME_WITH_PREFIX} is tightening\nits focus!"); +const u8 gUnknown_83FC2E3[] = _("{B_DEF_NAME_WITH_PREFIX} fell for\nthe TAUNT!"); +const u8 gUnknown_83FC2FA[] = _("{B_ATK_NAME_WITH_PREFIX} is ready to\nhelp {B_DEF_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FC312[] = _("{B_ATK_NAME_WITH_PREFIX} switched\nitems with its opponent!"); +const u8 gUnknown_83FC337[] = _("{B_ATK_NAME_WITH_PREFIX} obtained\n{B_BUFF1}."); +const u8 gUnknown_83FC347[] = _("{B_DEF_NAME_WITH_PREFIX} obtained\n{B_BUFF2}."); +const u8 gUnknown_83FC357[] = _("{B_ATK_NAME_WITH_PREFIX} obtained\n{B_BUFF1}.\p{B_DEF_NAME_WITH_PREFIX} obtained\n{B_BUFF2}."); +const u8 gUnknown_83FC377[] = _("{B_ATK_NAME_WITH_PREFIX} copied\n{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}!"); +const u8 gUnknown_83FC38A[] = _("{B_ATK_NAME_WITH_PREFIX} made a WISH!"); +const u8 gUnknown_83FC39A[] = _("{B_BUFF1}'s WISH\ncame true!"); +const u8 gUnknown_83FC3AF[] = _("{B_ATK_NAME_WITH_PREFIX} planted its roots!"); +const u8 gUnknown_83FC3C5[] = _("{B_ATK_NAME_WITH_PREFIX} absorbed\nnutrients with its roots!"); +const u8 gUnknown_83FC3EB[] = _("{B_DEF_NAME_WITH_PREFIX} anchored\nitself with its roots!"); +const u8 gUnknown_83FC40E[] = _("{B_ATK_NAME_WITH_PREFIX} made\n{B_DEF_NAME_WITH_PREFIX} drowsy!"); +const u8 gUnknown_83FC421[] = _("{B_ATK_NAME_WITH_PREFIX} knocked off\n{B_DEF_NAME_WITH_PREFIX}'s {B_LAST_ITEM}!"); +const u8 gUnknown_83FC439[] = _("{B_ATK_NAME_WITH_PREFIX} swapped abilities\nwith its opponent!"); +const u8 gUnknown_83FC461[] = _("{B_ATK_NAME_WITH_PREFIX} sealed the\nopponent's moveシsス!"); +const u8 gUnknown_83FC483[] = _("{B_ATK_NAME_WITH_PREFIX} wants the\nopponent to bear a GRUDGE!"); +const u8 gUnknown_83FC4AB[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1} lost\nall its PP due to the GRUDGE!"); +const u8 gUnknown_83FC4D6[] = _("{B_ATK_NAME_WITH_PREFIX} shrouded\nitself in {B_CURRENT_MOVE}!"); +const u8 gUnknown_83FC4F0[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_CURRENT_MOVE}\nwas bounced back by MAGIC COAT!"); +const u8 gUnknown_83FC518[] = _("{B_ATK_NAME_WITH_PREFIX} waits for its foe\nto make a move!"); +const u8 gUnknown_83FC53D[] = _("{B_DEF_NAME_WITH_PREFIX} SNATCHED\n{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s move!"); +const u8 gUnknown_83FC554[] = _("Electricity's power was\nweakened!"); +const u8 gUnknown_83FC576[] = _("Fire's power was\nweakened!"); +const u8 gUnknown_83FC591[] = _("{B_ATK_NAME_WITH_PREFIX} found\none {B_LAST_ITEM}!"); +const u8 gUnknown_83FC5A2[] = _("A soothing aroma wafted\nthrough the area!"); +const u8 gUnknown_83FC5CC[] = _("Items can't be used now.{PAUSE 64}"); +const u8 gUnknown_83FC5E8[] = _("For {B_SCR_ACTIVE_NAME_WITH_PREFIX},\n{B_LAST_ITEM} {B_BUFF1}"); +const u8 gUnknown_83FC5F6[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} used\n{B_LAST_ITEM} to hustle!"); +const u8 gUnknown_83FC60C[] = _("{B_ATK_NAME_WITH_PREFIX} lost its\nfocus and couldn't move!"); +const u8 gUnknown_83FC631[] = _("{B_DEF_NAME_WITH_PREFIX} was\ndragged out!\p"); +const u8 gUnknown_83FC646[] = _("The wall shattered!"); +const u8 gUnknown_83FC65A[] = _("But it had no effect!"); +const u8 gUnknown_83FC670[] = _("{B_ACTIVE_NAME_WITH_PREFIX} has no\nmoves left!\p"); +const u8 gUnknown_83FC687[] = _("{B_ACTIVE_NAME_WITH_PREFIX}'s {B_CURRENT_MOVE}\nis disabled!\p"); +const u8 gUnknown_83FC69D[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use the same\nmove in a row due to the TORMENT!\p"); +const u8 gUnknown_83FC6D6[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use\n{B_CURRENT_MOVE} after the TAUNT!\p"); +const u8 gUnknown_83FC6F8[] = _("{B_ACTIVE_NAME_WITH_PREFIX} can't use the\nsealed {B_CURRENT_MOVE}!\p"); +const u8 gUnknown_83FC715[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade it rain!"); +const u8 gUnknown_83FC72B[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nraised its SPEED!"); +const u8 gUnknown_83FC745[] = _("{B_DEF_NAME_WITH_PREFIX} was protected\nby {B_DEF_ABILITY}!"); +const u8 gUnknown_83FC75D[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents {B_ATK_NAME_WITH_PREFIX}\lfrom using {B_CURRENT_MOVE}!"); +const u8 gUnknown_83FC780[] = _("{B_DEF_NAME_WITH_PREFIX} restored HP\nusing its {B_DEF_ABILITY}!"); +const u8 gUnknown_83FC79D[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade {B_CURRENT_MOVE} useless!"); +const u8 gUnknown_83FC7B6[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade it the {B_BUFF1} type!"); +const u8 gUnknown_83FC7D3[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents paralysis!"); +const u8 gUnknown_83FC7EF[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents romance!"); +const u8 gUnknown_83FC809[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents poisoning!"); +const u8 gUnknown_83FC825[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevents confusion!"); +const u8 gUnknown_83FC841[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nraised its FIRE power!"); +const u8 gUnknown_83FC860[] = _("{B_DEF_NAME_WITH_PREFIX} anchors\nitself with {B_DEF_ABILITY}!"); +const u8 gUnknown_83FC87B[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncuts {B_DEF_NAME_WITH_PREFIX}'s ATTACK!"); +const u8 gUnknown_83FC895[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nprevents stat loss!"); +const u8 gUnknown_83FC8B1[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nhurt {B_ATK_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FC8C2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} TRACED\n{B_BUFF1}'s {B_BUFF2}!"); +const u8 gUnknown_83FC8D5[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_EFF_ABILITY}\nprevents burns!"); +const u8 gUnknown_83FC8ED[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nblocks {B_CURRENT_MOVE}!"); +const u8 gUnknown_83FC900[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nblocks {B_CURRENT_MOVE}!"); +const u8 gUnknown_83FC913[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_ATK_ABILITY}\nrestored its HP a little!"); +const u8 gUnknown_83FC935[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nwhipped up a sandstorm!"); +const u8 gUnknown_83FC955[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nintensified the sun's rays!"); +const u8 gUnknown_83FC979[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nprevents {B_BUFF1} loss!"); +const u8 gUnknown_83FC993[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\ninfatuated {B_ATK_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FC9AA[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nmade {B_CURRENT_MOVE} ineffective!"); +const u8 gUnknown_83FC9C7[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncured its {B_BUFF1} problem!"); +const u8 gUnknown_83FC9E5[] = _("It sucked up the\nLIQUID OOZE!"); +const u8 gUnknown_83FCA03[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX} transformed!"); +const u8 gUnknown_83FCA13[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\ntook the attack!"); +const u8 gText_PkmnsXPreventsSwitching[] = _("{B_BUFF1}'s {B_LAST_ABILITY}\nprevents switching!\p"); +const u8 gUnknown_83FCA49[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_DEF_ABILITY}\nprevented {B_SCR_ACTIVE_NAME_WITH_PREFIX}'s\l{B_BUFF1} from working!"); +const u8 gUnknown_83FCA71[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nmade it ineffective!"); +const u8 gUnknown_83FCA8E[] = _("{B_EFF_NAME_WITH_PREFIX}'s {B_EFF_ABILITY}\nprevents flinching!"); +const u8 gUnknown_83FCAAA[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_ATK_ABILITY}\nprevents {B_DEF_NAME_WITH_PREFIX}'s\l{B_DEF_ABILITY} from working!"); +const u8 gUnknown_83FCAD1[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\ncured its {B_BUFF1} problem!"); +const u8 gUnknown_83FCAEF[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_SCR_ACTIVE_ABILITY}\nhad no effect on {B_EFF_NAME_WITH_PREFIX}!"); +const u8 gUnknown_83FCB0C[] = _("{B_ATK_NAME_WITH_PREFIX} is too scared to move!"); +const u8 gUnknown_83FCB26[] = _("GHOST: Get out…… Get out……"); +const u8 gUnknown_83FCB41[] = _("sharply "); +const u8 gBattleText_Rose[] = _("rose!"); +const u8 gUnknown_83FCB50[] = _("harshly "); +const u8 gUnknown_83FCB59[] = _("fell!"); +const u8 gUnknown_83FCB5F[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); +const u8 gBattleText_UnknownString3[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); +const u8 gUnknown_83FCB75[] = _("Using {B_LAST_ITEM}, the {B_BUFF1}\nof {B_SCR_ACTIVE_NAME_WITH_PREFIX} {B_BUFF2}"); +const u8 gUnknown_83FCB8F[] = _("{B_ATK_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); +const u8 gUnknown_83FCB9A[] = _("{B_DEF_NAME_WITH_PREFIX}'s {B_BUFF1}\n{B_BUFF2}"); +const u8 gUnknown_83FCBA5[] = _("{B_ATK_NAME_WITH_PREFIX}'s stats won't\ngo any higher!"); +const u8 gUnknown_83FCBC5[] = _("{B_DEF_NAME_WITH_PREFIX}'s stats won't\ngo any lower!"); +const u8 gUnknown_83FCBE4[] = _("A critical hit!"); +const u8 gUnknown_83FCBF4[] = _("It's a one-hit KO!"); +const u8 gUnknown_83FCC07[] = _("{PAUSE 32}1, {PAUSE 15}2, and{PAUSE 15}… {PAUSE 15}… {PAUSE 15}… {PAUSE 15}{PLAY_SE SE_KON}Poof!\p"); +const u8 gUnknown_83FCC33[] = _("And…\p"); +const u8 gUnknown_83FCC39[] = _("HM moves can't be\nforgotten now.\p"); +const u8 gUnknown_83FCC5B[] = _("It's not very effective…"); +const u8 gUnknown_83FCC74[] = _("It's super effective!"); +static const u8 sText_GotAwaySafely[] = _("{PLAY_SE SE_NIGERU}Got away safely!\p"); +const u8 gUnknown_83FCCA0[] = _("{PLAY_SE SE_NIGERU}{B_ATK_NAME_WITH_PREFIX} fled\nusing its {B_LAST_ITEM}!\p"); +const u8 gUnknown_83FCCBB[] = _("{PLAY_SE SE_NIGERU}{B_ATK_NAME_WITH_PREFIX} fled\nusing {B_ATK_ABILITY}!\p"); +const u8 gUnknown_83FCCD2[] = _("{PLAY_SE SE_NIGERU}Wild {B_BUFF1} fled!"); +static const u8 sText_PlayerDefeatedLinkTrainer[] = _("Player defeated\n{B_LINK_OPPONENT1_NAME}!"); +static const u8 sText_TwoLinkTrainersDefeated[] = _("Player beat {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); +static const u8 sText_PlayerLostAgainstLinkTrainer[] = _("Player lost against\n{B_LINK_OPPONENT1_NAME}!"); +static const u8 sText_PlayerLostToTwo[] = _("Player lost to {B_LINK_OPPONENT1_NAME}\nand {B_LINK_OPPONENT2_NAME}!"); +static const u8 sText_PlayerBattledToDrawLinkTrainer[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME}!"); +static const u8 sText_PlayerBattledToDrawVsTwo[] = _("Player battled to a draw against\n{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}!"); +const u8 gUnknown_83FCD92[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} fled!"); +static const u8 sText_TwoWildFled[] = _("{PLAY_SE SE_NIGERU}{B_LINK_OPPONENT1_NAME} and\n{B_LINK_OPPONENT2_NAME} fled!"); +const u8 gUnknown_83FCDB3[] = _("No! There's no running\nfrom a TRAINER battle!\p"); +const u8 gUnknown_83FCDE2[] = _("Can't escape!\p"); +const u8 gUnknown_83FCDF1[] = _(""); +const u8 gUnknown_83FCDF2[] = _("But nothing happened!"); +const u8 gUnknown_83FCE08[] = _("But it failed!"); +const u8 gUnknown_83FCE17[] = _("It hurt itself in its\nconfusion!"); +const u8 gUnknown_83FCE38[] = _("The MIRROR MOVE failed!"); +const u8 gUnknown_83FCE50[] = _("It started to rain!"); +const u8 gUnknown_83FCE64[] = _("A downpour started!"); +const u8 gUnknown_83FCE78[] = _("Rain continues to fall."); +const u8 gUnknown_83FCE90[] = _("The downpour continues."); +const u8 gUnknown_83FCEA8[] = _("The rain stopped."); +const u8 gUnknown_83FCEBA[] = _("A sandstorm brewed!"); +const u8 gUnknown_83FCECE[] = _("The sandstorm rages."); +const u8 gUnknown_83FCEE3[] = _("The sandstorm subsided."); +const u8 gUnknown_83FCEFB[] = _("The sunlight got bright!"); +const u8 gUnknown_83FCF14[] = _("The sunlight is strong."); +const u8 gUnknown_83FCF2C[] = _("The sunlight faded."); +const u8 gUnknown_83FCF40[] = _("It started to hail!"); +const u8 gUnknown_83FCF54[] = _("Hail continues to fall."); +const u8 gUnknown_83FCF6C[] = _("The hail stopped."); +const u8 gUnknown_83FCF7E[] = _("But it failed to SPIT UP\na thing!"); +const u8 gUnknown_83FCFA0[] = _("But it failed to SWALLOW\na thing!"); +const u8 gUnknown_83FCFC2[] = _("The wind turned into a\nHEAT WAVE!"); +const u8 gUnknown_83FCFE4[] = _("All stat changes were\neliminated!"); +const u8 gUnknown_83FD006[] = _("Coins scattered everywhere!"); +const u8 gUnknown_83FD022[] = _("It was too weak to make\na SUBSTITUTE!"); +const u8 gUnknown_83FD048[] = _("The battlers shared\ntheir pain!"); +const u8 gUnknown_83FD068[] = _("A bell chimed!"); +const u8 gUnknown_83FD077[] = _("All affected POKéMON will\nfaint in three turns!"); +const u8 gUnknown_83FD0A7[] = _("There's no PP left for\nthis move!\p"); +const u8 gUnknown_83FD0CA[] = _("But there was no PP left\nfor the move!"); +const u8 gUnknown_83FD0F1[] = _("{B_ATK_NAME_WITH_PREFIX} ignored\norders while asleep!"); +const u8 gUnknown_83FD111[] = _("{B_ATK_NAME_WITH_PREFIX} ignored\norders!"); +const u8 gUnknown_83FD124[] = _("{B_ATK_NAME_WITH_PREFIX} began to nap!"); +const u8 gUnknown_83FD135[] = _("{B_ATK_NAME_WITH_PREFIX} is\nloafing around!"); +const u8 gUnknown_83FD14B[] = _("{B_ATK_NAME_WITH_PREFIX} won't\nobey!"); +const u8 gUnknown_83FD15A[] = _("{B_ATK_NAME_WITH_PREFIX} turned away!"); +const u8 gUnknown_83FD16A[] = _("{B_ATK_NAME_WITH_PREFIX} pretended\nnot to notice!"); +const u8 gUnknown_83FD186[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} is\nabout to use {B_BUFF2}.\pWill {B_PLAYER_NAME} change\nPOKéMON?"); +const u8 gUnknown_83FD1B8[] = _("{B_ATK_NAME_WITH_PREFIX} learned\n{B_BUFF1}!"); +static const u8 sText_PlayerDefeatedLinkTrainerTrainer1[] = _("Player defeated\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!\p"); +const u8 gUnknown_83FD1DF[] = _("{B_PLAYER_NAME} threw a ROCK\nat the {B_OPPONENT_MON1_NAME}!"); +const u8 gUnknown_83FD1FA[] = _("{B_PLAYER_NAME} threw some BAIT\nat the {B_OPPONENT_MON1_NAME}!"); +const u8 gUnknown_83FD218[] = _("{B_OPPONENT_MON1_NAME} is watching\ncarefully!"); +const u8 gUnknown_83FD232[] = _("{B_OPPONENT_MON1_NAME} is angry!"); +const u8 gUnknown_83FD23F[] = _("{B_OPPONENT_MON1_NAME} is eating!"); +const u8 gUnknown_83FD24D[] = _("{PLAY_SE SE_PINPON}ANNOUNCER: You're out of\nSAFARI BALLS! Game over!\p"); +static const u8 sText_WildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); +static const u8 sText_WildPkmnAppeared2[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!\p"); +static const u8 sText_WildPkmnAppearedPause[] = _("Wild {B_OPPONENT_MON1_NAME} appeared!{PAUSE 127}"); +static const u8 sText_TwoWildPkmnAppeared[] = _("Wild {B_OPPONENT_MON1_NAME} and\n{B_OPPONENT_MON2_NAME} appeared!\p"); +const u8 gUnknown_83FD2D9[] = _("The GHOST appeared!\pDarn!\nThe GHOST can't be ID'd!\p"); +const u8 gUnknown_83FD30D[] = _("The GHOST appeared!\p"); +const u8 gUnknown_83FD322[] = _("SILPH SCOPE unveiled the GHOST's\nidentity!"); +const u8 gUnknown_83FD34D[] = _("The GHOST was MAROWAK!\p\n"); +static const u8 sText_Trainer1WantsToBattle[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwould like to battle!\p"); +static const u8 sText_LinkTrainerWantsToBattle[] = _("{B_LINK_OPPONENT1_NAME}\nwants to battle!"); +static const u8 sText_TwoLinkTrainersWantToBattle[] = _("{B_LINK_OPPONENT1_NAME} and {B_LINK_OPPONENT2_NAME}\nwant to battle!"); +static const u8 sText_Trainer1SentOutPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME}!{PAUSE 60}"); +static const u8 sText_Trainer1SentOutTwoPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!{PAUSE 60}"); +static const u8 sText_Trainer1SentOutPkmn2[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME} sent\nout {B_BUFF1}!"); +static const u8 sText_LinkTrainerSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME}!"); +static const u8 sText_LinkTrainerSentOutTwoPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_OPPONENT_MON1_NAME} and {B_OPPONENT_MON2_NAME}!"); +static const u8 sText_TwoLinkTrainersSentOutPkmn[] = _("{B_LINK_OPPONENT1_NAME} sent out {B_LINK_OPPONENT_MON1_NAME}!\n{B_LINK_OPPONENT2_NAME} sent out {B_LINK_OPPONENT_MON2_NAME}!"); +static const u8 sText_LinkTrainerSentOutPkmn2[] = _("{B_LINK_OPPONENT1_NAME} sent out\n{B_BUFF1}!"); +static const u8 sText_LinkTrainerMultiSentOutPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} sent out\n{B_BUFF1}!"); +static const u8 sText_GoPkmn[] = _("Go! {B_PLAYER_MON1_NAME}!"); +static const u8 sText_GoTwoPkmn[] = _("Go! {B_PLAYER_MON1_NAME} and\n{B_PLAYER_MON2_NAME}!"); +static const u8 sText_GoPkmn2[] = _("Go! {B_BUFF1}!"); +static const u8 sText_DoItPkmn[] = _("Do it! {B_BUFF1}!"); +static const u8 sText_GoForItPkmn[] = _("Go for it, {B_BUFF1}!"); +static const u8 sText_YourFoesWeakGetEmPkmn[] = _("Your foe's weak!\nGet 'em, {B_BUFF1}!"); +static const u8 sText_LinkPartnerSentOutPkmnGoPkmn[] = _("{B_LINK_PARTNER_NAME} sent out {B_LINK_PLAYER_MON2_NAME}!\nGo! {B_LINK_PLAYER_MON1_NAME}!"); +static const u8 sText_PkmnThatsEnough[] = _("{B_BUFF1}, that's enough!\nCome back!"); +static const u8 sText_PkmnComeBack[] = _("{B_BUFF1}, come back!"); +static const u8 sText_PkmnOkComeBack[] = _("{B_BUFF1}, OK!\nCome back!"); +const u8 sText_PkmnGoodComeBack[] = _("{B_BUFF1}, good!\nCome back!"); +static const u8 sText_Trainer1WithdrewPkmn[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nwithdrew {B_BUFF1}!"); +static const u8 sText_LinkTrainer1WithdrewPkmn[] = _("{B_LINK_OPPONENT1_NAME} withdrew\n{B_BUFF1}!"); +static const u8 sText_LinkTrainer2WithdrewPkmn[] = _("{B_LINK_SCR_TRAINER_NAME} withdrew\n{B_BUFF1}!"); +static const u8 sText_WildPkmnPrefix[] = _("Wild "); +static const u8 sText_FoePkmnPrefix[] = _("Foe "); +static const u8 sText_FoePkmnPrefix2[] = _("Foe"); +static const u8 sText_AllyPkmnPrefix[] = _("Ally"); +static const u8 sText_FoePkmnPrefix3[] = _("Foe"); +static const u8 sText_AllyPkmnPrefix2[] = _("Ally"); +static const u8 sText_FoePkmnPrefix4[] = _("Foe"); +static const u8 sText_AllyPkmnPrefix3[] = _("Ally"); +static const u8 sText_AttackerUsedX[] = _("{B_ATK_NAME_WITH_PREFIX} used\n{B_BUFF2}"); +static const u8 sText_ExclamationMark[] = _("!"); +static const u8 sText_ExclamationMark2[] = _("!"); +static const u8 sText_ExclamationMark3[] = _("!"); +static const u8 sText_ExclamationMark4[] = _("!"); +static const u8 sText_ExclamationMark5[] = _("!"); + +static const u8 sText_HP2[] = _("HP"); +static const u8 sText_Attack2[] = _("ATTACK"); +static const u8 sText_Defense2[] = _("DEFENSE"); +static const u8 sText_Speed[] = _("SPEED"); +static const u8 sText_SpAtk2[] = _("SP. ATK"); +static const u8 sText_SpDef2[] = _("SP. DEF"); +static const u8 sText_Accuracy[] = _("accuracy"); +static const u8 sText_Evasiveness[] = _("evasiveness"); const u8 *const gStatNamesTable[] = { sText_HP2, @@ -448,10 +448,10 @@ const u8 *const gStatNamesTable[] = { }; static const u8 sText_PokeblockWasTooSpicy[] = _("was too spicy!"); // -static const u8 sText_PokeblockWasTooDry[] = _("was too dry!"); // @ 83FD5FF -static const u8 sText_PokeblockWasTooSweet[] = _("was too sweet!"); // @ 83FD60C -static const u8 sText_PokeblockWasTooBitter[] = _("was too bitter!"); // @ 83FD61B -static const u8 sText_PokeblockWasTooSour[] = _("was too sour!"); // @ 83FD62B +static const u8 sText_PokeblockWasTooDry[] = _("was too dry!"); +static const u8 sText_PokeblockWasTooSweet[] = _("was too sweet!"); +static const u8 sText_PokeblockWasTooBitter[] = _("was too bitter!"); +static const u8 sText_PokeblockWasTooSour[] = _("was too sour!"); const u8 *const gPokeblockWasTooXStringTable[] = { sText_PokeblockWasTooSpicy, @@ -461,60 +461,60 @@ const u8 *const gPokeblockWasTooXStringTable[] = { sText_PokeblockWasTooSour }; -static const u8 sText_PlayerUsedItem[] = _("{B_PLAYER_NAME} used\n{B_LAST_ITEM}!"); // @ 83FD650 -static const u8 sText_OldManUsedItem[] = _("The old man used\n{B_LAST_ITEM}!"); // @ 83FD65C -static const u8 sText_PokeDudeUsedItem[] = _("The POKé DUDE used\n{B_LAST_ITEM}!"); // @ 83FD671 -static const u8 sText_Trainer1UsedItem[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nused {B_LAST_ITEM}!"); // @ 83FD688 -static const u8 sText_TrainerBlockedBall[] = _("The TRAINER blocked the BALL!"); // @ 83FD697 -static const u8 sText_DontBeAThief[] = _("Don't be a thief!"); // @ 83FD6B5 -static const u8 sText_ItDodgedBall[] = _("It dodged the thrown BALL!\nThis POKéMON can't be caught!"); // @ 83FD6C7 -static const u8 sText_YouMissedPkmn[] = _("You missed the POKéMON!"); // @ 83FD700 -static const u8 sText_PkmnBrokeFree[] = _("Oh, no!\nThe POKéMON broke free!"); // @ 83FD718 -static const u8 sText_ItAppearedCaught[] = _("Aww!\nIt appeared to be caught!"); // @ 83FD738 -static const u8 sText_AarghAlmostHadIt[] = _("Aargh!\nAlmost had it!"); // @ 83FD757 -static const u8 sText_ShootSoClose[] = _("Shoot!\nIt was so close, too!"); // @ 83FD76D -const u8 gUnknown_83FD78A[] = _("よけられた!\nこいつは つかまりそうにないぞ!"); // @ 83FD78A -static const u8 sText_GotchaPkmnCaught[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}\p"); // @ 83FD7A2 -static const u8 sText_GotchaPkmnCaught2[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}{PAUSE 127}"); // @ 83FD7C0 -static const u8 sText_GiveNicknameCaptured[] = _("Give a nickname to the\ncaptured {B_OPPONENT_MON1_NAME}?"); // @ 83FD7E0 -static const u8 sText_PkmnSentToPC[] = _("{B_OPPONENT_MON1_NAME} was sent to\n{B_PC_CREATOR_NAME} PC."); // @ 83FD804 -static const u8 sText_Someones[] = _("someone's"); // @ 83FD81A -static const u8 sText_Bills[] = _("BILL's"); // @ 83FD824 -const u8 gUnknown_83FD82B[] = _("{B_OPPONENT_MON1_NAME}'s data was\nadded to the POKéDEX.\p"); // @ 83FD82B -const u8 gUnknown_83FD850[] = _("It is raining."); // @ 83FD850 -const u8 gUnknown_83FD85F[] = _("A sandstorm is raging."); // @ 83FD85F -const u8 gUnknown_83FD876[] = _("The BOX is full!\nYou can't catch any more!\p"); // @ 83FD876 -static const u8 sText_EnigmaBerry[] = _("ENIGMA BERRY"); // @ 83FD8A2 -static const u8 sText_BerrySuffix[] = _(" BERRY"); // @ 83FD8AF -const u8 gUnknown_83FD8B6[] = _("ナゾ"); // @ 83FD8B6 -const u8 gUnknown_83FD8B9[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured paralysis!"); // @ 83FD8B9 -const u8 gUnknown_83FD8D2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured poison!"); // @ 83FD8D2 -const u8 gUnknown_83FD8E8[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nhealed its burn!"); // @ 83FD8E8 -const u8 gUnknown_83FD901[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ndefrosted it!"); // @ 83FD901 -const u8 gUnknown_83FD917[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nwoke it from its sleep!"); // @ 83FD917 -const u8 gUnknown_83FD937[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nsnapped it out of confusion!"); // @ 83FD937 -const u8 gUnknown_83FD95C[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured its {B_BUFF1} problem!"); // @ 83FD95C -const u8 gUnknown_83FD97A[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nnormalized its status!"); // @ 83FD97A -const u8 gUnknown_83FD999[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored health!"); // @ 83FD999 -const u8 gUnknown_83FD9B2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored {B_BUFF1}'s PP!"); // @ 83FD9B2 -const u8 gUnknown_83FD9CC[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored its status!"); // @ 83FD9CC -const u8 gUnknown_83FD9E9[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored its HP a little!"); // @ 83FD9E9 -const u8 gUnknown_83FDA0B[] = _("{B_LAST_ITEM}'s effect allows only\n{B_CURRENT_MOVE} to be used!\p"); // @ 83FDA0B -const u8 gUnknown_83FDA33[] = _("{B_DEF_NAME_WITH_PREFIX} hung on\nusing its {B_LAST_ITEM}!"); // @ 83FDA33 -const u8 gUnknown_83FDA4C[] = _(""); // @ 83FDA4C -const u8 gUnknown_83FDA4D[] = _("{B_PLAYER_NAME} played the {B_LAST_ITEM}.\pNow, that's a catchy tune!"); // @ 83FDA4D -const u8 gUnknown_83FDA7A[] = _("{B_PLAYER_NAME} played the\n{B_LAST_ITEM}."); // @ 83FDA7A -const u8 gUnknown_83FDA8C[] = _("The POKéMON hearing the FLUTE\nawoke!"); // @ 83FDA8C -const u8 gUnknown_83FDAB1[] = _("You throw a BALL now, right?\nI… I'll do my best!"); // @ 83FDAB1 -const u8 gUnknown_83FDAE2[] = _("OAK: Oh, for Pete's sake…\nSo pushy, as always.\p{B_PLAYER_NAME}.\pYou've never had a POKéMON battle\nbefore, have you?\pA POKéMON battle is when TRAINERS\npit their POKéMON against each\lother.\p"); // @ 83FDAE2 -const u8 gUnknown_83FDB92[] = _("The TRAINER that makes the other\nTRAINER's POKéMON faint by lowering\ltheir HP to “0,” wins.\p"); // @ 83FDB92 -const u8 gUnknown_83FDBEF[] = _("But rather than talking about it,\nyou'll learn more from experience.\pTry battling and see for yourself.\p"); // @ 83FDBEF -const u8 gUnknown_83FDC58[] = _("OAK: Inflicting damage on the foe\nis the key to any battle.\p"); // @ 83FDC58 -const u8 gUnknown_83FDC95[] = _("OAK: Lowering the foe's stats\nwill put you at an advantage.\p"); // @ 83FDC95 -const u8 gUnknown_83FDCD2[] = _("OAK: Keep your eyes on your\nPOKéMON's HP.\pIt will faint if the HP drops to\n“0.”\p"); // @ 83FDCD2 -const u8 gUnknown_83FDD23[] = _("OAK: No! There's no running away\nfrom a TRAINER POKéMON battle!\p"); // @ 83FDD23 -const u8 gUnknown_83FDD64[] = _("OAK: Hm! Excellent!\pIf you win, you earn prize money,\nand your POKéMON will grow!\pBattle other TRAINERS and make\nyour POKéMON strong!\p"); // @ 83FDD64 -const u8 gUnknown_83FDDEB[] = _("OAK: Hm…\nHow disappointing…\pIf you win, you earn prize money,\nand your POKéMON grow.\pBut if you lose, {B_PLAYER_NAME}, you end\nup paying prize money…\pHowever, since you had no warning\nthis time, I'll pay for you.\pBut things won't be this way once\nyou step outside these doors.\pThat's why you must strengthen your\nPOKéMON by battling wild POKéMON.\p"); // @ 83FDDEB +static const u8 sText_PlayerUsedItem[] = _("{B_PLAYER_NAME} used\n{B_LAST_ITEM}!"); +static const u8 sText_OldManUsedItem[] = _("The old man used\n{B_LAST_ITEM}!"); +static const u8 sText_PokeDudeUsedItem[] = _("The POKé DUDE used\n{B_LAST_ITEM}!"); +static const u8 sText_Trainer1UsedItem[] = _("{B_TRAINER1_CLASS} {B_TRAINER1_NAME}\nused {B_LAST_ITEM}!"); +static const u8 sText_TrainerBlockedBall[] = _("The TRAINER blocked the BALL!"); +static const u8 sText_DontBeAThief[] = _("Don't be a thief!"); +static const u8 sText_ItDodgedBall[] = _("It dodged the thrown BALL!\nThis POKéMON can't be caught!"); +static const u8 sText_YouMissedPkmn[] = _("You missed the POKéMON!"); +static const u8 sText_PkmnBrokeFree[] = _("Oh, no!\nThe POKéMON broke free!"); +static const u8 sText_ItAppearedCaught[] = _("Aww!\nIt appeared to be caught!"); +static const u8 sText_AarghAlmostHadIt[] = _("Aargh!\nAlmost had it!"); +static const u8 sText_ShootSoClose[] = _("Shoot!\nIt was so close, too!"); +const u8 gUnknown_83FD78A[] = _("よけられた!\nこいつは つかまりそうにないぞ!"); +static const u8 sText_GotchaPkmnCaught[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}\p"); +static const u8 sText_GotchaPkmnCaught2[] = _("Gotcha!\n{B_OPPONENT_MON1_NAME} was caught!{WAIT_SE}{PLAY_BGM MUS_GET_YASEI}{PAUSE 127}"); +static const u8 sText_GiveNicknameCaptured[] = _("Give a nickname to the\ncaptured {B_OPPONENT_MON1_NAME}?"); +static const u8 sText_PkmnSentToPC[] = _("{B_OPPONENT_MON1_NAME} was sent to\n{B_PC_CREATOR_NAME} PC."); +static const u8 sText_Someones[] = _("someone's"); +static const u8 sText_Bills[] = _("BILL's"); +const u8 gUnknown_83FD82B[] = _("{B_OPPONENT_MON1_NAME}'s data was\nadded to the POKéDEX.\p"); +const u8 gUnknown_83FD850[] = _("It is raining."); +const u8 gUnknown_83FD85F[] = _("A sandstorm is raging."); +const u8 gUnknown_83FD876[] = _("The BOX is full!\nYou can't catch any more!\p"); +static const u8 sText_EnigmaBerry[] = _("ENIGMA BERRY"); +static const u8 sText_BerrySuffix[] = _(" BERRY"); +const u8 gUnknown_83FD8B6[] = _("ナゾ"); +const u8 gUnknown_83FD8B9[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured paralysis!"); +const u8 gUnknown_83FD8D2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured poison!"); +const u8 gUnknown_83FD8E8[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nhealed its burn!"); +const u8 gUnknown_83FD901[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ndefrosted it!"); +const u8 gUnknown_83FD917[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nwoke it from its sleep!"); +const u8 gUnknown_83FD937[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nsnapped it out of confusion!"); +const u8 gUnknown_83FD95C[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\ncured its {B_BUFF1} problem!"); +const u8 gUnknown_83FD97A[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nnormalized its status!"); +const u8 gUnknown_83FD999[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored health!"); +const u8 gUnknown_83FD9B2[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored {B_BUFF1}'s PP!"); +const u8 gUnknown_83FD9CC[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored its status!"); +const u8 gUnknown_83FD9E9[] = _("{B_SCR_ACTIVE_NAME_WITH_PREFIX}'s {B_LAST_ITEM}\nrestored its HP a little!"); +const u8 gUnknown_83FDA0B[] = _("{B_LAST_ITEM}'s effect allows only\n{B_CURRENT_MOVE} to be used!\p"); +const u8 gUnknown_83FDA33[] = _("{B_DEF_NAME_WITH_PREFIX} hung on\nusing its {B_LAST_ITEM}!"); +const u8 gUnknown_83FDA4C[] = _(""); +const u8 gUnknown_83FDA4D[] = _("{B_PLAYER_NAME} played the {B_LAST_ITEM}.\pNow, that's a catchy tune!"); +const u8 gUnknown_83FDA7A[] = _("{B_PLAYER_NAME} played the\n{B_LAST_ITEM}."); +const u8 gUnknown_83FDA8C[] = _("The POKéMON hearing the FLUTE\nawoke!"); +const u8 gUnknown_83FDAB1[] = _("You throw a BALL now, right?\nI… I'll do my best!"); +const u8 gUnknown_83FDAE2[] = _("OAK: Oh, for Pete's sake…\nSo pushy, as always.\p{B_PLAYER_NAME}.\pYou've never had a POKéMON battle\nbefore, have you?\pA POKéMON battle is when TRAINERS\npit their POKéMON against each\lother.\p"); +const u8 gUnknown_83FDB92[] = _("The TRAINER that makes the other\nTRAINER's POKéMON faint by lowering\ltheir HP to “0,” wins.\p"); +const u8 gUnknown_83FDBEF[] = _("But rather than talking about it,\nyou'll learn more from experience.\pTry battling and see for yourself.\p"); +const u8 gUnknown_83FDC58[] = _("OAK: Inflicting damage on the foe\nis the key to any battle.\p"); +const u8 gUnknown_83FDC95[] = _("OAK: Lowering the foe's stats\nwill put you at an advantage.\p"); +const u8 gUnknown_83FDCD2[] = _("OAK: Keep your eyes on your\nPOKéMON's HP.\pIt will faint if the HP drops to\n“0.”\p"); +const u8 gUnknown_83FDD23[] = _("OAK: No! There's no running away\nfrom a TRAINER POKéMON battle!\p"); +const u8 gUnknown_83FDD64[] = _("OAK: Hm! Excellent!\pIf you win, you earn prize money,\nand your POKéMON will grow!\pBattle other TRAINERS and make\nyour POKéMON strong!\p"); +const u8 gUnknown_83FDDEB[] = _("OAK: Hm…\nHow disappointing…\pIf you win, you earn prize money,\nand your POKéMON grow.\pBut if you lose, {B_PLAYER_NAME}, you end\nup paying prize money…\pHowever, since you had no warning\nthis time, I'll pay for you.\pBut things won't be this way once\nyou step outside these doors.\pThat's why you must strengthen your\nPOKéMON by battling wild POKéMON.\p"); const u8 *const gBattleStringsTable[] = { gUnknown_83FB219, @@ -602,9 +602,9 @@ const u8 *const gBattleStringsTable[] = { gUnknown_83FBB71, gUnknown_83FBB83, gUnknown_83FBB99, - BattleText_MistShroud, + gBattleText_MistShroud, gUnknown_83FBBD0, - BattleText_GetPumped, + gBattleText_GetPumped, gUnknown_83FBBFF, gUnknown_83FBC16, gUnknown_83FBC2B, @@ -715,11 +715,11 @@ const u8 *const gBattleStringsTable[] = { gUnknown_83FC8B1, gUnknown_83FC8C2, gUnknown_83FCB41, - BattleText_Rose, + gBattleText_Rose, gUnknown_83FCB50, gUnknown_83FCB59, gUnknown_83FCB5F, - BattleText_UnknownString3, + gBattleText_UnknownString3, gUnknown_83FCB8F, gUnknown_83FCB9A, gUnknown_83FCBE4, @@ -918,17 +918,17 @@ const u16 gMoveWeatherChangeStringIds[] = { STRINGID_STARTEDHAIL }; -const u16 gSandStormHailContinuesStringIds[] = { +const u16 gSandstormHailContinuesStringIds[] = { STRINGID_SANDSTORMRAGES, STRINGID_HAILCONTINUES }; -const u16 gSandStormHailDmgStringIds[] = { +const u16 gSandstormHailDmgStringIds[] = { STRINGID_PKMNBUFFETEDBYSANDSTORM, STRINGID_PKMNPELTEDBYHAIL }; -const u16 gSandStormHailEndStringIds[] = { +const u16 gSandstormHailEndStringIds[] = { STRINGID_SANDSTORMSUBSIDED, STRINGID_HAILSTOPPED }; @@ -1218,32 +1218,32 @@ const u16 gTrappingMoves[] = { 0xFFFF }; -const u8 gText_PkmnIsEvolving[] = _("What?\n{STR_VAR_1} is evolving!"); // @ 83FE672 -const u8 gText_CongratsPkmnEvolved[] = _("Congratulations! Your {STR_VAR_1}\nevolved into {STR_VAR_2}!{WAIT_SE}\p"); // @ 83FE688 -const u8 gText_PkmnStoppedEvolving[] = _("Huh? {STR_VAR_1}\nstopped evolving!\p"); // @ 83FE6B5 -const u8 gText_EllipsisQuestionMark[] = _("……?\p"); // @ 83FE6D0 -const u8 gText_WhatWillPkmnDo[] = _("What will\n{B_ACTIVE_NAME_WITH_PREFIX} do?"); // @ 83FE6D5 -const u8 gUnknown_83FE6E6[] = _("What will {B_PLAYER_NAME}\nthrow?"); // @ 83FE6E6 -const u8 gUnknown_83FE6FA[] = _("What will the\nold man do?"); // @ 83FE6FA -const u8 gText_LinkStandby[] = _("{PAUSE 16}Link standby…"); // @ 83FE714 -const u8 gUnknown_83FE725[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}FIGHT{CLEAR_TO 56}BAG\nPOKéMON{CLEAR_TO 56}RUN"); // @ 83FE725 -const u8 gUnknown_83FE747[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}BALL{CLEAR_TO 56}BAIT\nROCK{CLEAR_TO 56}RUN"); // @ 83FE747 -const u8 gText_MoveInterfacePP[] = _("PP "); // @ 83FE766 -const u8 gText_MoveInterfaceType[] = _("TYPE/"); // @ 83FE76A -const u8 gUnknown_83FE770[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}"); // @ 83FE770 -const u8 gUnknown_83FE779[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}どの わざを\nわすれさせたい?"); // @ 83FE779 -const u8 gText_BattleYesNoChoice[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}Yes\nNo"); // @ 83FE791 -const u8 gText_BattleSwitchWhich[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}Switch\nwhich?"); // @ 83FE7A0 -const u8 gUnknown_83FE7B6[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}"); // @ 83FE7B6 -const u8 gUnknown_83FE7BF[] = _("{RIGHT_ARROW_2}"); // @ 83FE7BF -const u8 gUnknown_83FE7C2[] = _("{PLUS}"); // @ 83FE7C2 -const u8 gUnknown_83FE7C5[] = _("-"); // @ 83FE7C5 - -const u8 gUnknown_83FE7C7[] = _("{SIZE 0}Max{SIZE 2} HP"); // @ 83FE7C7 -const u8 gUnknown_83FE7D4[] = _("ATTACK "); // @ 83FE7D4 -const u8 gUnknown_83FE7DC[] = _("DEFENSE"); // @ 83FE7DC -const u8 gUnknown_83FE7E4[] = _("SP. ATK"); // @ 83FE7E4 -const u8 gUnknown_83FE7EC[] = _("SP. DEF"); // @ 83FE7EC +const u8 gText_PkmnIsEvolving[] = _("What?\n{STR_VAR_1} is evolving!"); +const u8 gText_CongratsPkmnEvolved[] = _("Congratulations! Your {STR_VAR_1}\nevolved into {STR_VAR_2}!{WAIT_SE}\p"); +const u8 gText_PkmnStoppedEvolving[] = _("Huh? {STR_VAR_1}\nstopped evolving!\p"); +const u8 gText_EllipsisQuestionMark[] = _("……?\p"); +const u8 gText_WhatWillPkmnDo[] = _("What will\n{B_ACTIVE_NAME_WITH_PREFIX} do?"); +const u8 gUnknown_83FE6E6[] = _("What will {B_PLAYER_NAME}\nthrow?"); +const u8 gUnknown_83FE6FA[] = _("What will the\nold man do?"); +const u8 gText_LinkStandby[] = _("{PAUSE 16}Link standby…"); +const u8 gUnknown_83FE725[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}FIGHT{CLEAR_TO 56}BAG\nPOKéMON{CLEAR_TO 56}RUN"); +const u8 gUnknown_83FE747[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}BALL{CLEAR_TO 56}BAIT\nROCK{CLEAR_TO 56}RUN"); +const u8 gText_MoveInterfacePP[] = _("PP "); +const u8 gText_MoveInterfaceType[] = _("TYPE/"); +const u8 gUnknown_83FE770[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}"); +const u8 gUnknown_83FE779[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}どの わざを\nわすれさせたい?"); +const u8 gText_BattleYesNoChoice[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}Yes\nNo"); +const u8 gText_BattleSwitchWhich[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}Switch\nwhich?"); +const u8 gUnknown_83FE7B6[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW 13 14 15}"); +const u8 gUnknown_83FE7BF[] = _("{RIGHT_ARROW_2}"); +const u8 gUnknown_83FE7C2[] = _("{PLUS}"); +const u8 gUnknown_83FE7C5[] = _("-"); + +const u8 gUnknown_83FE7C7[] = _("{SIZE 0}Max{SIZE 2} HP"); +const u8 gUnknown_83FE7D4[] = _("ATTACK "); +const u8 gUnknown_83FE7DC[] = _("DEFENSE"); +const u8 gUnknown_83FE7E4[] = _("SP. ATK"); +const u8 gUnknown_83FE7EC[] = _("SP. DEF"); const u8 *const gUnknown_83FE7F4[] = { gUnknown_83FE7C7, @@ -1255,56 +1255,56 @@ const u8 *const gUnknown_83FE7F4[] = { }; const u8 gUnknown_83FE80C[] = _("{HIGHLIGHT 2}SAFARI BALLS"); // -const u8 gText_HighlightRed_Left[] = _("{HIGHLIGHT 2}Left: "); // @ 83FE81C -const u8 gText_HighlightRed[] = _("{HIGHLIGHT 2}"); // @ 83FE826 -const u8 gText_Sleep[] = _("sleep"); // @ 83FE82A -const u8 gText_Poison[] = _("poison"); // @ 83FE830 -const u8 gText_Burn[] = _("burn"); // @ 83FE837 -const u8 gText_Paralysis[] = _("paralysis"); // @ 83FE83C -const u8 gText_Ice[] = _("ice"); // @ 83FE846 -const u8 gText_Confusion[] = _("confusion"); // @ 83FE84A -const u8 gText_Love[] = _("love"); // @ 83FE854 -const u8 gUnknown_83FE859[] = _(" "); // @ 83FE859 -const u8 gUnknown_83FE85C[] = _("\n"); // @ 83FE85C -const u8 gUnknown_83FE85E[] = _("\n"); // @ 83FE85E -const u8 gUnknown_83FE860[] = _(" is"); // @ 83FE860 -const u8 gUnknown_83FE864[] = _(" is"); // @ 83FE864 -const u8 gText_BadEgg[] = _("Bad EGG"); // @ 83FE868 -const u8 gUnknown_83FE870[] = _("ミツル"); // @ 83FE870 -const u8 gUnknown_83FE874[] = _("{HIGHLIGHT 0}Win"); // @ 83FE874 -const u8 gUnknown_83FE87B[] = _("{HIGHLIGHT 0}Loss"); // @ 83FE87B -const u8 gUnknown_83FE883[] = _("{HIGHLIGHT 0}Draw"); // @ 83FE883 -static const u8 sText_SpaceIs[] = _(" is"); // @ 83FE88B -static const u8 sText_ApostropheS[] = _("'s"); // @ 83FE88F -const u8 gUnknown_83FE892[] = _("a NORMAL move"); // @ 83FE892 -const u8 gUnknown_83FE8A0[] = _("a FIGHTING move"); // @ 83FE8A0 -const u8 gUnknown_83FE8B0[] = _("a FLYING move"); // @ 83FE8B0 -const u8 gUnknown_83FE8BE[] = _("a POISON move"); // @ 83FE8BE -const u8 gUnknown_83FE8CC[] = _("a GROUND move"); // @ 83FE8CC -const u8 gUnknown_83FE8DA[] = _("a ROCK move"); // @ 83FE8DA -const u8 gUnknown_83FE8E6[] = _("a BUG move"); // @ 83FE8E6 -const u8 gUnknown_83FE8F1[] = _("a GHOST move"); // @ 83FE8F1 -const u8 gUnknown_83FE8FE[] = _("a STEEL move"); // @ 83FE8FE -const u8 gUnknown_83FE90B[] = _("a ??? move"); // @ 83FE90B -const u8 gUnknown_83FE916[] = _("a FIRE move"); // @ 83FE916 -const u8 gUnknown_83FE922[] = _("a WATER move"); // @ 83FE922 -const u8 gUnknown_83FE92F[] = _("a GRASS move"); // @ 83FE92F -const u8 gUnknown_83FE93C[] = _("an ELECTRIC move"); // @ 83FE93C -const u8 gUnknown_83FE94D[] = _("a PSYCHIC move"); // @ 83FE94D -const u8 gUnknown_83FE95C[] = _("an ICE move"); // @ 83FE95C -const u8 gUnknown_83FE968[] = _("a DRAGON move"); // @ 83FE968 -const u8 gUnknown_83FE976[] = _("a DARK move"); // @ 83FE976 -const u8 gUnknown_83FE982[] = _("TIME BOARD"); // @ 83FE982 -const u8 gUnknown_83FE98D[] = _("CLEAR TIME"); // @ 83FE98D -const u8 gUnknown_83FE998[] = _("{STR_VAR_1}MIN. {STR_VAR_2}.{STR_VAR_3}SEC."); // @ 83FE998 -const u8 gUnknown_83FE9A9[] = _("1F"); // @ 83FE9A9 -const u8 gUnknown_83FE9AC[] = _("2F"); // @ 83FE9AC -const u8 gUnknown_83FE9AF[] = _("3F"); // @ 83FE9AF -const u8 gUnknown_83FE9B2[] = _("4F"); // @ 83FE9B2 -const u8 gUnknown_83FE9B5[] = _("5F"); // @ 83FE9B5 -const u8 gUnknown_83FE9B8[] = _("6F"); // @ 83FE9B8 -const u8 gUnknown_83FE9BB[] = _("7F"); // @ 83FE9BB -const u8 gUnknown_83FE9BE[] = _("8F"); // @ 83FE9BE +const u8 gText_HighlightRed_Left[] = _("{HIGHLIGHT 2}Left: "); +const u8 gText_HighlightRed[] = _("{HIGHLIGHT 2}"); +const u8 gText_Sleep[] = _("sleep"); +const u8 gText_Poison[] = _("poison"); +const u8 gText_Burn[] = _("burn"); +const u8 gText_Paralysis[] = _("paralysis"); +const u8 gText_Ice[] = _("ice"); +const u8 gText_Confusion[] = _("confusion"); +const u8 gText_Love[] = _("love"); +const u8 gUnknown_83FE859[] = _(" "); +const u8 gUnknown_83FE85C[] = _("\n"); +const u8 gUnknown_83FE85E[] = _("\n"); +const u8 gUnknown_83FE860[] = _(" is"); +const u8 gUnknown_83FE864[] = _(" is"); +const u8 gText_BadEgg[] = _("Bad EGG"); +const u8 gUnknown_83FE870[] = _("ミツル"); +const u8 gUnknown_83FE874[] = _("{HIGHLIGHT 0}Win"); +const u8 gUnknown_83FE87B[] = _("{HIGHLIGHT 0}Loss"); +const u8 gUnknown_83FE883[] = _("{HIGHLIGHT 0}Draw"); +static const u8 sText_SpaceIs[] = _(" is"); +static const u8 sText_ApostropheS[] = _("'s"); +const u8 gUnknown_83FE892[] = _("a NORMAL move"); +const u8 gUnknown_83FE8A0[] = _("a FIGHTING move"); +const u8 gUnknown_83FE8B0[] = _("a FLYING move"); +const u8 gUnknown_83FE8BE[] = _("a POISON move"); +const u8 gUnknown_83FE8CC[] = _("a GROUND move"); +const u8 gUnknown_83FE8DA[] = _("a ROCK move"); +const u8 gUnknown_83FE8E6[] = _("a BUG move"); +const u8 gUnknown_83FE8F1[] = _("a GHOST move"); +const u8 gUnknown_83FE8FE[] = _("a STEEL move"); +const u8 gUnknown_83FE90B[] = _("a ??? move"); +const u8 gUnknown_83FE916[] = _("a FIRE move"); +const u8 gUnknown_83FE922[] = _("a WATER move"); +const u8 gUnknown_83FE92F[] = _("a GRASS move"); +const u8 gUnknown_83FE93C[] = _("an ELECTRIC move"); +const u8 gUnknown_83FE94D[] = _("a PSYCHIC move"); +const u8 gUnknown_83FE95C[] = _("an ICE move"); +const u8 gUnknown_83FE968[] = _("a DRAGON move"); +const u8 gUnknown_83FE976[] = _("a DARK move"); +const u8 gUnknown_83FE982[] = _("TIME BOARD"); +const u8 gUnknown_83FE98D[] = _("CLEAR TIME"); +const u8 gUnknown_83FE998[] = _("{STR_VAR_1}MIN. {STR_VAR_2}.{STR_VAR_3}SEC."); +const u8 gUnknown_83FE9A9[] = _("1F"); +const u8 gUnknown_83FE9AC[] = _("2F"); +const u8 gUnknown_83FE9AF[] = _("3F"); +const u8 gUnknown_83FE9B2[] = _("4F"); +const u8 gUnknown_83FE9B5[] = _("5F"); +const u8 gUnknown_83FE9B8[] = _("6F"); +const u8 gUnknown_83FE9BB[] = _("7F"); +const u8 gUnknown_83FE9BE[] = _("8F"); const u8 *const gUnknown_83FE9C4[] = { gOtherText_Single, @@ -1314,8 +1314,8 @@ const u8 *const gUnknown_83FE9C4[] = { }; const u8 gUnknown_83FE9D4[] = _("{PLAY_SE SE_NIGERU}{B_TRAINER1_CLASS} {B_TRAINER1_NAME} fled!"); // -static const u8 sText_PlayerLostAgainstTrainer1[] = _("Player lost against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); // @ 83FE9E4 -static const u8 sText_PlayerBattledToDrawTrainer1[] = _("Player battled to a draw against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); // @ 83FE9FF +static const u8 sText_PlayerLostAgainstTrainer1[] = _("Player lost against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); +static const u8 sText_PlayerBattledToDrawTrainer1[] = _("Player battled to a draw against\n{B_TRAINER1_CLASS} {B_TRAINER1_NAME}!"); static const u8 *const sATypeMove_Table[] = { gUnknown_83FE892, @@ -1463,32 +1463,32 @@ static const u16 sGrammarMoveUsedTable[] = { }; // code -void BufferStringBattle(u16 stringID) +void BufferStringBattle(u16 stringId) { s32 i; const u8 *stringPtr = NULL; - gBattleMsgDataPtr = (struct BattleMsgData*)(&gBattleBufferA[gActiveBattler][4]); - gLastUsedItem = gBattleMsgDataPtr->lastItem; - gLastUsedAbility = gBattleMsgDataPtr->lastAbility; - gBattleScripting.battler = gBattleMsgDataPtr->scrActive; - *(&gBattleStruct->field_52) = gBattleMsgDataPtr->unk1605E; - *(&gBattleStruct->hpScale) = gBattleMsgDataPtr->hpScale; - gPotentialItemEffectBattler = gBattleMsgDataPtr->itemEffectBattler; - *(&gBattleStruct->stringMoveType) = gBattleMsgDataPtr->moveType; + sBattleMsgDataPtr = (struct BattleMsgData*)(&gBattleBufferA[gActiveBattler][4]); + gLastUsedItem = sBattleMsgDataPtr->lastItem; + gLastUsedAbility = sBattleMsgDataPtr->lastAbility; + gBattleScripting.battler = sBattleMsgDataPtr->scrActive; + *(&gBattleStruct->field_52) = sBattleMsgDataPtr->unk1605E; + *(&gBattleStruct->hpScale) = sBattleMsgDataPtr->hpScale; + gPotentialItemEffectBattler = sBattleMsgDataPtr->itemEffectBattler; + *(&gBattleStruct->stringMoveType) = sBattleMsgDataPtr->moveType; for (i = 0; i < MAX_BATTLERS_COUNT; i++) { - sBattlerAbilities[i] = gBattleMsgDataPtr->abilities[i]; + sBattlerAbilities[i] = sBattleMsgDataPtr->abilities[i]; } for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; i++) { - gBattleTextBuff1[i] = gBattleMsgDataPtr->textBuffs[0][i]; - gBattleTextBuff2[i] = gBattleMsgDataPtr->textBuffs[1][i]; - gBattleTextBuff3[i] = gBattleMsgDataPtr->textBuffs[2][i]; + gBattleTextBuff1[i] = sBattleMsgDataPtr->textBuffs[0][i]; + gBattleTextBuff2[i] = sBattleMsgDataPtr->textBuffs[1][i]; + gBattleTextBuff3[i] = sBattleMsgDataPtr->textBuffs[2][i]; } - switch (stringID) + switch (stringId) { case STRINGID_INTROMSG: // first battle msg if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) @@ -1627,10 +1627,10 @@ void BufferStringBattle(u16 stringID) case STRINGID_USEDMOVE: // pokemon used a move msg ChooseMoveUsedParticle(gBattleTextBuff1); // buff1 doesn't appear in the string, leftover from japanese move names - if (gBattleMsgDataPtr->currentMove >= MOVES_COUNT) + if (sBattleMsgDataPtr->currentMove >= MOVES_COUNT) StringCopy(gBattleTextBuff2, sATypeMove_Table[*(&gBattleStruct->stringMoveType)]); else - StringCopy(gBattleTextBuff2, gMoveNames[gBattleMsgDataPtr->currentMove]); + StringCopy(gBattleTextBuff2, gMoveNames[sBattleMsgDataPtr->currentMove]); ChooseTypeOfMoveUsedString(gBattleTextBuff2); stringPtr = sText_AttackerUsedX; @@ -1704,14 +1704,14 @@ void BufferStringBattle(u16 stringID) } break; default: // load a string from the table - if (stringID >= BATTLESTRINGS_COUNT + BATTLESTRINGS_ID_ADDER) + if (stringId >= BATTLESTRINGS_COUNT + BATTLESTRINGS_ID_ADDER) { gDisplayedStringBattle[0] = EOS; return; } else { - stringPtr = gBattleStringsTable[stringID - BATTLESTRINGS_ID_ADDER]; + stringPtr = gBattleStringsTable[stringId - BATTLESTRINGS_ID_ADDER]; } break; } @@ -1744,7 +1744,7 @@ static const u8* TryGetStatusString(u8 *src) chars1 = *(u32*)(&status[0]); chars2 = *(u32*)(&status[4]); - for (i = 0; i < ARRAY_COUNT(gStatusConditionStringsTable); i++) + for (i = 0; i < NELEMS(gStatusConditionStringsTable); i++) { if (chars1 == *(u32*)(&gStatusConditionStringsTable[i][0][0]) && chars2 == *(u32*)(&gStatusConditionStringsTable[i][0][4])) @@ -1762,8 +1762,8 @@ static const u8* TryGetStatusString(u8 *src) toCpy = sText_WildPkmnPrefix; \ while (*toCpy != EOS) \ { \ - dst[dstID] = *toCpy; \ - dstID++; \ + dst[dstId] = *toCpy; \ + dstId++; \ toCpy++; \ } \ GetMonData(&gEnemyParty[monIndex], MON_DATA_NICKNAME, text); \ @@ -1777,7 +1777,7 @@ static const u8* TryGetStatusString(u8 *src) u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst) { - u32 dstID = 0; // if they used dstID, why not use srcID as well? + u32 dstId = 0; // if they used dstId, why not use srcId as well? const u8 *toCpy = NULL; u8 text[30]; u8 multiplayerId; @@ -1913,16 +1913,16 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst) HANDLE_NICKNAME_STRING_CASE(gBattleScripting.battler, gBattlerPartyIndexes[gBattleScripting.battler]) break; case B_TXT_CURRENT_MOVE: // current move name - if (gBattleMsgDataPtr->currentMove >= MOVES_COUNT) + if (sBattleMsgDataPtr->currentMove >= MOVES_COUNT) toCpy = (const u8 *)&sATypeMove_Table[gBattleStruct->stringMoveType]; else - toCpy = gMoveNames[gBattleMsgDataPtr->currentMove]; + toCpy = gMoveNames[sBattleMsgDataPtr->currentMove]; break; case B_TXT_LAST_MOVE: // originally used move name - if (gBattleMsgDataPtr->originallyUsedMove >= MOVES_COUNT) + if (sBattleMsgDataPtr->originallyUsedMove >= MOVES_COUNT) toCpy = (const u8 *)&sATypeMove_Table[gBattleStruct->stringMoveType]; else - toCpy = gMoveNames[gBattleMsgDataPtr->originallyUsedMove]; + toCpy = gMoveNames[sBattleMsgDataPtr->originallyUsedMove]; break; case B_TXT_LAST_ITEM: // last used item if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -1999,7 +1999,7 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst) case B_TXT_TRAINER1_NAME: // trainer1 name if (gTrainerBattleOpponent_A == SECRET_BASE_OPPONENT) { - for (i = 0; i < (s32) ARRAY_COUNT(gBattleResources->secretBase->trainerName); i++) + for (i = 0; i < (s32)NELEMS(gBattleResources->secretBase->trainerName); i++) text[i] = gBattleResources->secretBase->trainerName[i]; text[i] = EOS; toCpy = text; @@ -2131,78 +2131,78 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst) // missing if (toCpy != NULL) check while (*toCpy != EOS) { - dst[dstID] = *toCpy; - dstID++; + dst[dstId] = *toCpy; + dstId++; toCpy++; } if (*src == B_TXT_TRAINER1_LOSE_TEXT || *src == B_TXT_TRAINER1_WIN_TEXT || *src == B_TXT_TRAINER2_LOSE_TEXT || *src == B_TXT_TRAINER2_WIN_TEXT) { - dst[dstID] = EXT_CTRL_CODE_BEGIN; - dstID++; - dst[dstID] = 9; - dstID++; + dst[dstId] = EXT_CTRL_CODE_BEGIN; + dstId++; + dst[dstId] = 9; + dstId++; } } else { - dst[dstID] = *src; - dstID++; + dst[dstId] = *src; + dstId++; } src++; } - dst[dstID] = *src; - dstID++; + dst[dstId] = *src; + dstId++; - return dstID; + return dstId; } static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst) { - u32 srcID = 1; + u32 srcId = 1; u32 value = 0; u8 text[12]; u16 hword; *dst = EOS; - while (src[srcID] != B_BUFF_EOS) + while (src[srcId] != B_BUFF_EOS) { - switch (src[srcID]) + switch (src[srcId]) { case B_BUFF_STRING: // battle string - hword = T1_READ_16(&src[srcID + 1]); + hword = T1_READ_16(&src[srcId + 1]); StringAppend(dst, gBattleStringsTable[hword - BATTLESTRINGS_ID_ADDER]); - srcID += 3; + srcId += 3; break; case B_BUFF_NUMBER: // int to string - switch (src[srcID + 1]) + switch (src[srcId + 1]) { case 1: - value = src[srcID + 3]; + value = src[srcId + 3]; break; case 2: - value = T1_READ_16(&src[srcID + 3]); + value = T1_READ_16(&src[srcId + 3]); break; case 4: - value = T1_READ_32(&src[srcID + 3]); + value = T1_READ_32(&src[srcId + 3]); break; } - ConvertIntToDecimalStringN(dst, value, STR_CONV_MODE_LEFT_ALIGN, src[srcID + 2]); - srcID += src[srcID + 1] + 3; + ConvertIntToDecimalStringN(dst, value, STR_CONV_MODE_LEFT_ALIGN, src[srcId + 2]); + srcId += src[srcId + 1] + 3; break; case B_BUFF_MOVE: // move name - StringAppend(dst, gMoveNames[T1_READ_16(&src[srcID + 1])]); - srcID += 3; + StringAppend(dst, gMoveNames[T1_READ_16(&src[srcId + 1])]); + srcId += 3; break; case B_BUFF_TYPE: // type name - StringAppend(dst, gTypeNames[src[srcID + 1]]); - srcID += 2; + StringAppend(dst, gTypeNames[src[srcId + 1]]); + srcId += 2; break; case B_BUFF_MON_NICK_WITH_PREFIX: // poke nick with prefix - if (GetBattlerSide(src[srcID + 1]) == B_SIDE_PLAYER) + if (GetBattlerSide(src[srcId + 1]) == B_SIDE_PLAYER) { - GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, text); + GetMonData(&gPlayerParty[src[srcId + 2]], MON_DATA_NICKNAME, text); } else { @@ -2211,38 +2211,38 @@ static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst) else StringAppend(dst, sText_WildPkmnPrefix); - GetMonData(&gEnemyParty[src[srcID + 2]], MON_DATA_NICKNAME, text); + GetMonData(&gEnemyParty[src[srcId + 2]], MON_DATA_NICKNAME, text); } StringGetEnd10(text); StringAppend(dst, text); - srcID += 3; + srcId += 3; break; case B_BUFF_STAT: // stats - StringAppend(dst, gStatNamesTable[src[srcID + 1]]); - srcID += 2; + StringAppend(dst, gStatNamesTable[src[srcId + 1]]); + srcId += 2; break; case B_BUFF_SPECIES: // species name - GetSpeciesName(dst, T1_READ_16(&src[srcID + 1])); - srcID += 3; + GetSpeciesName(dst, T1_READ_16(&src[srcId + 1])); + srcId += 3; break; case B_BUFF_MON_NICK: // poke nick without prefix - if (GetBattlerSide(src[srcID + 1]) == B_SIDE_PLAYER) - GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, dst); + if (GetBattlerSide(src[srcId + 1]) == B_SIDE_PLAYER) + GetMonData(&gPlayerParty[src[srcId + 2]], MON_DATA_NICKNAME, dst); else - GetMonData(&gEnemyParty[src[srcID + 2]], MON_DATA_NICKNAME, dst); + GetMonData(&gEnemyParty[src[srcId + 2]], MON_DATA_NICKNAME, dst); StringGetEnd10(dst); - srcID += 3; + srcId += 3; break; case B_BUFF_NEGATIVE_FLAVOR: // flavor table - StringAppend(dst, gPokeblockWasTooXStringTable[src[srcID + 1]]); - srcID += 2; + StringAppend(dst, gPokeblockWasTooXStringTable[src[srcId + 1]]); + srcId += 2; break; case B_BUFF_ABILITY: // ability names - StringAppend(dst, gAbilityNames[src[srcID + 1]]); - srcID += 2; + StringAppend(dst, gAbilityNames[src[srcId + 1]]); + srcId += 2; break; case B_BUFF_ITEM: // item name - hword = T1_READ_16(&src[srcID + 1]); + hword = T1_READ_16(&src[srcId + 1]); if (gBattleTypeFlags & BATTLE_TYPE_LINK) { if (hword == ITEM_ENIGMA_BERRY) @@ -2266,7 +2266,7 @@ static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst) { CopyItemName(hword, dst); } - srcID += 3; + srcId += 3; break; } } @@ -2285,7 +2285,7 @@ static void ChooseMoveUsedParticle(u8* textBuff) { if (sGrammarMoveUsedTable[i] == 0) counter++; - if (sGrammarMoveUsedTable[i++] == gBattleMsgDataPtr->currentMove) + if (sGrammarMoveUsedTable[i++] == sBattleMsgDataPtr->currentMove) break; } @@ -2328,7 +2328,7 @@ static void ChooseTypeOfMoveUsedString(u8* dst) { if (sGrammarMoveUsedTable[i] == MOVE_NONE) counter++; - if (sGrammarMoveUsedTable[i++] == gBattleMsgDataPtr->currentMove) + if (sGrammarMoveUsedTable[i++] == sBattleMsgDataPtr->currentMove) break; } diff --git a/src/pokemon.c b/src/pokemon.c index 001505164..9f5a6967e 100644 --- a/src/pokemon.c +++ b/src/pokemon.c @@ -4797,8 +4797,8 @@ static void sub_8042D50(int stat) { gBattlerTarget = gBattlerInMenuId; StringCopy(gBattleTextBuff1, gStatNamesTable[gUnknown_825DFF0[stat]]); - StringCopy(gBattleTextBuff2, BattleText_Rose); - BattleStringExpandPlaceholdersToDisplayedString(BattleText_UnknownString3); + StringCopy(gBattleTextBuff2, gBattleText_Rose); + BattleStringExpandPlaceholdersToDisplayedString(gBattleText_UnknownString3); } const u8 *Battle_PrintStatBoosterEffectMessage(u16 itemId) @@ -4837,7 +4837,7 @@ const u8 *Battle_PrintStatBoosterEffectMessage(u16 itemId) else { gBattlerAttacker = gBattlerInMenuId; - BattleStringExpandPlaceholdersToDisplayedString(BattleText_GetPumped); + BattleStringExpandPlaceholdersToDisplayedString(gBattleText_GetPumped); } } } @@ -4845,7 +4845,7 @@ const u8 *Battle_PrintStatBoosterEffectMessage(u16 itemId) if (itemEffect[3] & 0x80) { gBattlerAttacker = gBattlerInMenuId; - BattleStringExpandPlaceholdersToDisplayedString(BattleText_MistShroud); + BattleStringExpandPlaceholdersToDisplayedString(gBattleText_MistShroud); } return gDisplayedStringBattle; -- cgit v1.2.3 From 03ab807aaacd95091a80165533544ca5c4b58128 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Sun, 24 Nov 2019 03:50:28 +0800 Subject: clean up --- src/data/party_menu.h | 240 ++++---- src/data/pokemon/tutor_learnsets.h | 6 +- src/party_menu.c | 1142 ++++++++++++++++++------------------ 3 files changed, 695 insertions(+), 693 deletions(-) (limited to 'src') diff --git a/src/data/party_menu.h b/src/data/party_menu.h index c00fe3613..fa74d1ad8 100644 --- a/src/data/party_menu.h +++ b/src/data/party_menu.h @@ -1,4 +1,4 @@ -const struct BgTemplate sPartyMenuBgTemplates[] = +static const struct BgTemplate sPartyMenuBgTemplates[] = { { .bg = 0, @@ -35,7 +35,7 @@ enum PARTY_BOX_RIGHT_COLUMN, }; -const struct PartyMenuBoxInfoRects sPartyBoxInfoRects[] = +static const struct PartyMenuBoxInfoRects sPartyBoxInfoRects[] = { [PARTY_BOX_LEFT_COLUMN] = { @@ -67,7 +67,7 @@ const struct PartyMenuBoxInfoRects sPartyBoxInfoRects[] = }, }; -const u8 sPartyMenuSpriteCoords[PARTY_LAYOUT_COUNT][PARTY_SIZE][4 * 2] = +static const u8 sPartyMenuSpriteCoords[PARTY_LAYOUT_COUNT][PARTY_SIZE][4 * 2] = { [PARTY_LAYOUT_SINGLE] = { @@ -107,10 +107,10 @@ const u8 sPartyMenuSpriteCoords[PARTY_LAYOUT_COUNT][PARTY_SIZE][4 * 2] = }, }; -const u32 sConfirmButton_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_confirm_button.bin"); -const u32 sCancelButton_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_cancel_button.bin"); +static const u32 sConfirmButton_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_confirm_button.bin"); +static const u32 sCancelButton_Tilemap[] = INCBIN_U32("graphics/interface/party_menu_cancel_button.bin"); -const u8 sFontColorTable[][3] = +static const u8 sFontColorTable[][3] = { {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_LIGHT_GREY, TEXT_COLOR_DARK_GREY}, // Default {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_WHITE, TEXT_COLOR_GREEN}, // Unused @@ -120,7 +120,7 @@ const u8 sFontColorTable[][3] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GREY}, // Unused }; -const struct WindowTemplate sSinglePartyMenuWindowTemplate[] = +static const struct WindowTemplate sSinglePartyMenuWindowTemplate[] = { { .bg = 0, @@ -185,10 +185,10 @@ const struct WindowTemplate sSinglePartyMenuWindowTemplate[] = .paletteNum = 14, .baseBlock = 0x1DF, }, - DUMMY_WIN_TEMPLATE + DUMMY_WIN_TEMPLATE, }; -const struct WindowTemplate sDoublePartyMenuWindowTemplate[] = +static const struct WindowTemplate sDoublePartyMenuWindowTemplate[] = { { .bg = 0, @@ -253,10 +253,10 @@ const struct WindowTemplate sDoublePartyMenuWindowTemplate[] = .paletteNum = 14, .baseBlock = 0x1DF, }, - DUMMY_WIN_TEMPLATE + DUMMY_WIN_TEMPLATE, }; -const struct WindowTemplate sMultiPartyMenuWindowTemplate[] = +static const struct WindowTemplate sMultiPartyMenuWindowTemplate[] = { { .bg = 0, @@ -324,7 +324,7 @@ const struct WindowTemplate sMultiPartyMenuWindowTemplate[] = DUMMY_WIN_TEMPLATE }; -const struct WindowTemplate sShowcaseMultiPartyMenuWindowTemplate[] = +static const struct WindowTemplate sShowcaseMultiPartyMenuWindowTemplate[] = { { .bg = 0, @@ -383,7 +383,7 @@ const struct WindowTemplate sShowcaseMultiPartyMenuWindowTemplate[] = DUMMY_WIN_TEMPLATE }; -const struct WindowTemplate sCancelButtonWindowTemplate = +static const struct WindowTemplate sCancelButtonWindowTemplate = { .bg = 0, .tilemapLeft = 24, @@ -394,7 +394,7 @@ const struct WindowTemplate sCancelButtonWindowTemplate = .baseBlock = 0x1C7, }; -const struct WindowTemplate sMultiCancelButtonWindowTemplate = +static const struct WindowTemplate sMultiCancelButtonWindowTemplate = { .bg = 0, .tilemapLeft = 24, @@ -405,7 +405,7 @@ const struct WindowTemplate sMultiCancelButtonWindowTemplate = .baseBlock = 0x1C7, }; -const struct WindowTemplate sConfirmButtonWindowTemplate = +static const struct WindowTemplate sConfirmButtonWindowTemplate = { .bg = 0, .tilemapLeft = 24, @@ -416,7 +416,7 @@ const struct WindowTemplate sConfirmButtonWindowTemplate = .baseBlock = 0x1D3, }; -const struct WindowTemplate sDefaultPartyMsgWindowTemplate = +static const struct WindowTemplate sDefaultPartyMsgWindowTemplate = { .bg = 2, .tilemapLeft = 1, @@ -427,7 +427,7 @@ const struct WindowTemplate sDefaultPartyMsgWindowTemplate = .baseBlock = 0x24F, }; -const struct WindowTemplate sDoWhatWithMonMsgWindowTemplate = +static const struct WindowTemplate sDoWhatWithMonMsgWindowTemplate = { .bg = 2, .tilemapLeft = 1, @@ -438,7 +438,7 @@ const struct WindowTemplate sDoWhatWithMonMsgWindowTemplate = .baseBlock = 0x279, }; -const struct WindowTemplate sDoWhatWithItemMsgWindowTemplate = +static const struct WindowTemplate sDoWhatWithItemMsgWindowTemplate = { .bg = 2, .tilemapLeft = 1, @@ -449,7 +449,7 @@ const struct WindowTemplate sDoWhatWithItemMsgWindowTemplate = .baseBlock = 0x299, }; -const struct WindowTemplate sDoWhatWithMailMsgWindowTemplate = +static const struct WindowTemplate sDoWhatWithMailMsgWindowTemplate = { .bg = 2, .tilemapLeft = 1, @@ -460,7 +460,7 @@ const struct WindowTemplate sDoWhatWithMailMsgWindowTemplate = .baseBlock = 0x299, }; -const struct WindowTemplate sWhichMoveMsgWindowTemplate = +static const struct WindowTemplate sWhichMoveMsgWindowTemplate = { .bg = 2, .tilemapLeft = 1, @@ -471,7 +471,7 @@ const struct WindowTemplate sWhichMoveMsgWindowTemplate = .baseBlock = 0x299, }; -const struct WindowTemplate sItemGiveTakeWindowTemplate = +static const struct WindowTemplate sItemGiveTakeWindowTemplate = { .bg = 2, .tilemapLeft = 22, @@ -482,7 +482,7 @@ const struct WindowTemplate sItemGiveTakeWindowTemplate = .baseBlock = 0x373, }; -const struct WindowTemplate sMailReadTakeWindowTemplate = +static const struct WindowTemplate sMailReadTakeWindowTemplate = { .bg = 2, .tilemapLeft = 19, @@ -493,7 +493,7 @@ const struct WindowTemplate sMailReadTakeWindowTemplate = .baseBlock = 0x373, }; -const struct WindowTemplate sMoveSelectWindowTemplate = +static const struct WindowTemplate sMoveSelectWindowTemplate = { .bg = 2, .tilemapLeft = 18, @@ -504,7 +504,7 @@ const struct WindowTemplate sMoveSelectWindowTemplate = .baseBlock = 0x2BF, }; -const struct WindowTemplate sPartyMenuYesNoWindowTemplate = +static const struct WindowTemplate sPartyMenuYesNoWindowTemplate = { .bg = 2, .tilemapLeft = 21, @@ -515,7 +515,7 @@ const struct WindowTemplate sPartyMenuYesNoWindowTemplate = .baseBlock = 0x2BF, }; -const struct WindowTemplate sLevelUpStatsWindowTemplate = +static const struct WindowTemplate sLevelUpStatsWindowTemplate = { .bg = 2, .tilemapLeft = 19, @@ -526,7 +526,7 @@ const struct WindowTemplate sLevelUpStatsWindowTemplate = .baseBlock = 0x2BF, }; -const struct WindowTemplate gUnknown_845A170 = +static const struct WindowTemplate gUnknown_845A170 = { .bg = 2, .tilemapLeft = 2, @@ -537,7 +537,7 @@ const struct WindowTemplate gUnknown_845A170 = .baseBlock = 0x1DF, }; -const struct WindowTemplate gUnknown_845A178 = +static const struct WindowTemplate gUnknown_845A178 = { .bg = 2, .tilemapLeft = 0, @@ -548,7 +548,7 @@ const struct WindowTemplate gUnknown_845A178 = .baseBlock = 0x373, }; -const u8 sMainSlotTileNums[] = +static const u8 sMainSlotTileNums[] = { 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, @@ -559,7 +559,7 @@ const u8 sMainSlotTileNums[] = 46, 47, 47, 47, 47, 47, 47, 47, 47, 48, }; -const u8 sMainSlotTileNums_Egg[] = +static const u8 sMainSlotTileNums_Egg[] = { 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, @@ -570,7 +570,7 @@ const u8 sMainSlotTileNums_Egg[] = 46, 47, 47, 47, 47, 47, 47, 47, 47, 48, }; -const u8 sOtherSlotsTileNums[] = +static const u8 sOtherSlotsTileNums[] = { 43, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 45, 49, 33, @@ -580,7 +580,7 @@ const u8 sOtherSlotsTileNums[] = 56, 56, 56, 57, }; -const u8 sOtherSlotsTileNums_Egg[] = +static const u8 sOtherSlotsTileNums_Egg[] = { 43, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 45, 49, 33, @@ -590,7 +590,7 @@ const u8 sOtherSlotsTileNums_Egg[] = 56, 56, 56, 57, }; -const u8 sEmptySlotTileNums[] = +static const u8 sEmptySlotTileNums[] = { 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 30, 0, @@ -600,49 +600,49 @@ const u8 sEmptySlotTileNums[] = 38, 38, 38, 39, }; -const u8 sGenderPalOffsets[] = {11, 12}; +static const u8 sGenderPalOffsets[] = {11, 12}; -const u8 sHPBarPalOffsets[] = {9, 10}; +static const u8 sHPBarPalOffsets[] = {9, 10}; -const u8 sPartyBoxPalOffsets1[] = {4, 5, 6}; +static const u8 sPartyBoxPalOffsets1[] = {4, 5, 6}; -const u8 sPartyBoxPalOffsets2[] = {1, 7, 8}; +static const u8 sPartyBoxPalOffsets2[] = {1, 7, 8}; -const u8 sGenderMalePalIds[] = {59, 60}; +static const u8 sGenderMalePalIds[] = {59, 60}; -const u8 sGenderFemalePalIds[] = {75, 76}; +static const u8 sGenderFemalePalIds[] = {75, 76}; -const u8 sHPBarGreenPalIds[] = {57, 58}; +static const u8 sHPBarGreenPalIds[] = {57, 58}; -const u8 sHPBarYellowPalIds[] = {73, 74}; +static const u8 sHPBarYellowPalIds[] = {73, 74}; -const u8 sHPBarRedPalIds[] = {89, 90}; +static const u8 sHPBarRedPalIds[] = {89, 90}; -const u8 sPartyBoxEmptySlotPalIds1[] = {52, 53, 54}; +static const u8 sPartyBoxEmptySlotPalIds1[] = {52, 53, 54}; -const u8 sPartyBoxMultiPalIds1[] = {68, 69, 70}; +static const u8 sPartyBoxMultiPalIds1[] = {68, 69, 70}; -const u8 sPartyBoxFaintedPalIds1[] = {84, 85, 86}; +static const u8 sPartyBoxFaintedPalIds1[] = {84, 85, 86}; -const u8 sPartyBoxCurrSelectionPalIds1[] = {116, 117, 118}; +static const u8 sPartyBoxCurrSelectionPalIds1[] = {116, 117, 118}; -const u8 sPartyBoxCurrSelectionMultiPalIds[] = {132, 133, 134}; +static const u8 sPartyBoxCurrSelectionMultiPalIds[] = {132, 133, 134}; -const u8 sPartyBoxCurrSelectionFaintedPalIds[] = {148, 149, 150}; +static const u8 sPartyBoxCurrSelectionFaintedPalIds[] = {148, 149, 150}; -const u8 sPartyBoxSelectedForActionPalIds1[] = {100, 101, 102}; +static const u8 sPartyBoxSelectedForActionPalIds1[] = {100, 101, 102}; -const u8 sPartyBoxEmptySlotPalIds2[] = {49, 55, 56}; +static const u8 sPartyBoxEmptySlotPalIds2[] = {49, 55, 56}; -const u8 sPartyBoxMultiPalIds2[] = {65, 71, 72}; +static const u8 sPartyBoxMultiPalIds2[] = {65, 71, 72}; -const u8 sPartyBoxFaintedPalIds2[] = {81, 87, 88}; +static const u8 sPartyBoxFaintedPalIds2[] = {81, 87, 88}; -const u8 sPartyBoxCurrSelectionPalIds2[] = {97, 103, 104}; +static const u8 sPartyBoxCurrSelectionPalIds2[] = {97, 103, 104}; -const u8 sPartyBoxSelectedForActionPalIds2[] = {161, 167, 168}; +static const u8 sPartyBoxSelectedForActionPalIds2[] = {161, 167, 168}; -const u8 *const sActionStringTable[] = +static const u8 *const sActionStringTable[] = { [PARTY_MSG_CHOOSE_MON] = gText_ChoosePokemon, [PARTY_MSG_CHOOSE_MON_OR_CANCEL] = gText_ChoosePokemonCancel, @@ -673,7 +673,7 @@ const u8 *const sActionStringTable[] = [PARTY_MSG_DO_WHAT_WITH_MAIL] = gText_DoWhatWithMail, }; -const u8 *const sDescriptionStringTable[] = +static const u8 *const sDescriptionStringTable[] = { [PARTYBOX_DESC_NO_USE] = gText_NoUse, [PARTYBOX_DESC_ABLE_3] = gText_Able, @@ -687,7 +687,7 @@ const u8 *const sDescriptionStringTable[] = [PARTYBOX_DESC_LEARNED] = gText_Learned, }; -const u8 *const sHMDescriptionTable[] = +static const u8 *const sHMDescriptionTable[] = { gText_LightUpDarkness, gText_CutATreeOrGrass, @@ -703,10 +703,10 @@ const u8 *const sHMDescriptionTable[] = gText_LureWildPokemon, }; -const u32 sHeldItemGfx[] = INCBIN_U32("graphics/interface/hold_icons.4bpp"); -const u16 sHeldItemPalette[] = INCBIN_U16("graphics/interface/hold_icons.gbapal"); +static const u32 sHeldItemGfx[] = INCBIN_U32("graphics/interface/hold_icons.4bpp"); +static const u16 sHeldItemPalette[] = INCBIN_U16("graphics/interface/hold_icons.gbapal"); -const struct OamData sOamData_HeldItem = +static const struct OamData sOamData_HeldItem = { .y = 0, .affineMode = 0, @@ -723,38 +723,38 @@ const struct OamData sOamData_HeldItem = .affineParam = 0, }; -const union AnimCmd sSpriteAnim_HeldItem[] = +static const union AnimCmd sSpriteAnim_HeldItem[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; -const union AnimCmd sSpriteAnim_HeldMail[] = +static const union AnimCmd sSpriteAnim_HeldMail[] = { ANIMCMD_FRAME(1, 1), ANIMCMD_END }; -const union AnimCmd *const sSpriteAnimTable_HeldItem[] = +static const union AnimCmd *const sSpriteAnimTable_HeldItem[] = { sSpriteAnim_HeldItem, sSpriteAnim_HeldMail, }; -const struct SpriteSheet sSpriteSheet_HeldItem = +static const struct SpriteSheet sSpriteSheet_HeldItem = { - sHeldItemGfx, sizeof(sHeldItemGfx), 0xd750 + sHeldItemGfx, sizeof(sHeldItemGfx), 0xD750 }; -const struct SpritePalette sSpritePalette_HeldItem = +static const struct SpritePalette sSpritePalette_HeldItem = { - sHeldItemPalette, 0xd750 + sHeldItemPalette, 0xD750 }; -const struct SpriteTemplate sSpriteTemplate_HeldItem = +static const struct SpriteTemplate sSpriteTemplate_HeldItem = { - 0xd750, - 0xd750, + 0xD750, + 0xD750, &sOamData_HeldItem, sSpriteAnimTable_HeldItem, NULL, @@ -762,7 +762,7 @@ const struct SpriteTemplate sSpriteTemplate_HeldItem = SpriteCallbackDummy, }; -const struct OamData sOamData_MenuPokeball = +static const struct OamData sOamData_MenuPokeball = { .y = 0, .affineMode = 0, @@ -779,36 +779,36 @@ const struct OamData sOamData_MenuPokeball = .affineParam = 0, }; -const union AnimCmd sPokeballAnim_Closed[] = +static const union AnimCmd sPokeballAnim_Closed[] = { ANIMCMD_FRAME(0, 0), ANIMCMD_END }; -const union AnimCmd sPokeballAnim_Open[] = +static const union AnimCmd sPokeballAnim_Open[] = { ANIMCMD_FRAME(16, 0), ANIMCMD_END }; -const union AnimCmd *const sSpriteAnimTable_MenuPokeball[] = +static const union AnimCmd *const sSpriteAnimTable_MenuPokeball[] = { sPokeballAnim_Closed, sPokeballAnim_Open, }; -const struct CompressedSpriteSheet sSpriteSheet_MenuPokeball = +static const struct CompressedSpriteSheet sSpriteSheet_MenuPokeball = { gPartyMenuPokeball_Gfx, 0x400, 0x04b0 }; -const struct CompressedSpritePalette sSpritePalette_MenuPokeball = +static const struct CompressedSpritePalette sSpritePalette_MenuPokeball = { gPartyMenuPokeball_Pal, 0x04b0 }; // Used for the pokeball sprite on each party slot / Cancel button -const struct SpriteTemplate sSpriteTemplate_MenuPokeball = +static const struct SpriteTemplate sSpriteTemplate_MenuPokeball = { .tileTag = 0x04b0, .paletteTag = 0x04b0, @@ -819,7 +819,7 @@ const struct SpriteTemplate sSpriteTemplate_MenuPokeball = .callback = SpriteCallbackDummy, }; -const struct OamData sOamData_MenuPokeballSmall = +static const struct OamData sOamData_MenuPokeballSmall = { .y = 0, .affineMode = 0, @@ -836,44 +836,44 @@ const struct OamData sOamData_MenuPokeballSmall = .affineParam = 0, }; -const union AnimCmd sSmallPokeballAnim_Closed[] = +static const union AnimCmd sSmallPokeballAnim_Closed[] = { ANIMCMD_FRAME(0, 0), ANIMCMD_END }; -const union AnimCmd sSmallPokeballAnim_Open[] = +static const union AnimCmd sSmallPokeballAnim_Open[] = { ANIMCMD_FRAME(4, 0), ANIMCMD_END }; -const union AnimCmd sSmallPokeballAnim_Blank1[] = +static const union AnimCmd sSmallPokeballAnim_Blank1[] = { ANIMCMD_FRAME(8, 0), ANIMCMD_END }; -const union AnimCmd sSmallPokeballAnim_Blank2[] = +static const union AnimCmd sSmallPokeballAnim_Blank2[] = { ANIMCMD_FRAME(12, 0), ANIMCMD_END }; -const union AnimCmd sSmallPokeballAnim_Blank3[] = +static const union AnimCmd sSmallPokeballAnim_Blank3[] = { ANIMCMD_FRAME(16, 0), ANIMCMD_END }; -const union AnimCmd sSmallPokeballAnim_Blank4[] = +static const union AnimCmd sSmallPokeballAnim_Blank4[] = { ANIMCMD_FRAME(20, 0), ANIMCMD_END }; // The blanks below are never used. See SpriteCB_BounceConfirmCancelButton, where they were intended to be used -const union AnimCmd *const sSpriteAnimTable_MenuPokeballSmall[] = +static const union AnimCmd *const sSpriteAnimTable_MenuPokeballSmall[] = { sSmallPokeballAnim_Closed, sSmallPokeballAnim_Open, @@ -883,13 +883,13 @@ const union AnimCmd *const sSpriteAnimTable_MenuPokeballSmall[] = sSmallPokeballAnim_Blank4, }; -const struct CompressedSpriteSheet sSpriteSheet_MenuPokeballSmall = +static const struct CompressedSpriteSheet sSpriteSheet_MenuPokeballSmall = { gPartyMenuPokeballSmall_Gfx, 0x0300, 0x04b1 }; // Used for the pokeball sprite next to Cancel and Confirm when both are present, otherwise sSpriteTemplate_MenuPokeball is used -const struct SpriteTemplate sSpriteTemplate_MenuPokeballSmall = +static const struct SpriteTemplate sSpriteTemplate_MenuPokeballSmall = { .tileTag = 1201, .paletteTag = 1200, @@ -900,7 +900,7 @@ const struct SpriteTemplate sSpriteTemplate_MenuPokeballSmall = .callback = SpriteCallbackDummy, }; -const struct OamData sOamData_StatusCondition = +static const struct OamData sOamData_StatusCondition = { .y = 0, .affineMode = 0, @@ -917,55 +917,55 @@ const struct OamData sOamData_StatusCondition = .affineParam = 0, }; -const union AnimCmd sSpriteAnim_StatusPoison[] = +static const union AnimCmd sSpriteAnim_StatusPoison[] = { ANIMCMD_FRAME(0, 0), ANIMCMD_END }; -const union AnimCmd sSpriteAnim_StatusParalyzed[] = +static const union AnimCmd sSpriteAnim_StatusParalyzed[] = { ANIMCMD_FRAME(4, 0), ANIMCMD_END }; -const union AnimCmd sSpriteAnim_StatusSleep[] = +static const union AnimCmd sSpriteAnim_StatusSleep[] = { ANIMCMD_FRAME(8, 0), ANIMCMD_END }; -const union AnimCmd sSpriteAnim_StatusFrozen[] = +static const union AnimCmd sSpriteAnim_StatusFrozen[] = { ANIMCMD_FRAME(12, 0), ANIMCMD_END }; -const union AnimCmd sSpriteAnim_StatusBurn[] = +static const union AnimCmd sSpriteAnim_StatusBurn[] = { ANIMCMD_FRAME(16, 0), ANIMCMD_END }; -const union AnimCmd sSpriteAnim_StatusPokerus[] = +static const union AnimCmd sSpriteAnim_StatusPokerus[] = { ANIMCMD_FRAME(20, 0), ANIMCMD_END }; -const union AnimCmd sSpriteAnim_StatusFaint[] = +static const union AnimCmd sSpriteAnim_StatusFaint[] = { ANIMCMD_FRAME(24, 0), ANIMCMD_END }; -const union AnimCmd sSpriteAnim_Blank[] = +static const union AnimCmd sSpriteAnim_Blank[] = { ANIMCMD_FRAME(28, 0), ANIMCMD_END }; -const union AnimCmd *const sSpriteTemplate_StatusCondition[] = +static const union AnimCmd *const sSpriteTemplate_StatusCondition[] = { sSpriteAnim_StatusPoison, sSpriteAnim_StatusParalyzed, @@ -977,17 +977,17 @@ const union AnimCmd *const sSpriteTemplate_StatusCondition[] = sSpriteAnim_Blank, }; -const struct CompressedSpriteSheet sSpriteSheet_StatusIcons = +static const struct CompressedSpriteSheet sSpriteSheet_StatusIcons = { gStatusGfx_Icons, 0x400, 1202 }; -const struct CompressedSpritePalette sSpritePalette_StatusIcons = +static const struct CompressedSpritePalette sSpritePalette_StatusIcons = { gStatusPal_Icons, 1202 }; -const struct SpriteTemplate sSpriteTemplate_StatusIcons = +static const struct SpriteTemplate sSpriteTemplate_StatusIcons = { .tileTag = 1202, .paletteTag = 1202, @@ -998,7 +998,7 @@ const struct SpriteTemplate sSpriteTemplate_StatusIcons = .callback = SpriteCallbackDummy, }; -const bool8 sMultiBattlePartnersPartyMask[PARTY_SIZE + 2] = +static const bool8 sMultiBattlePartnersPartyMask[PARTY_SIZE + 2] = { FALSE, TRUE, @@ -1009,7 +1009,7 @@ const bool8 sMultiBattlePartnersPartyMask[PARTY_SIZE + 2] = FALSE, }; -const u16 sTMHMMoves_Duplicate[] = +static const u16 sTMHMMoves_Duplicate[] = { MOVE_FOCUS_PUNCH, MOVE_DRAGON_CLAW, @@ -1111,7 +1111,7 @@ enum FIELD_MOVE_END, }; -struct +static struct { const u8 *text; TaskFunc func; @@ -1149,18 +1149,18 @@ struct [MENU_FIELD_MOVES + FIELD_MOVE_SWEET_SCENT] = {gMoveNames[MOVE_SWEET_SCENT], CursorCB_FieldMove}, }; -const u8 sPartyMenuAction_SummarySwitchCancel[] = {MENU_SUMMARY, MENU_SWITCH, MENU_CANCEL1}; -const u8 sPartyMenuAction_ShiftSummaryCancel[] = {MENU_SHIFT, MENU_SUMMARY, MENU_CANCEL1}; -const u8 sPartyMenuAction_SendOutSummaryCancel[] = {MENU_SEND_OUT, MENU_SUMMARY, MENU_CANCEL1}; -const u8 sPartyMenuAction_SummaryCancel[] = {MENU_SUMMARY, MENU_CANCEL1}; -const u8 sPartyMenuAction_EnterSummaryCancel[] = {MENU_ENTER, MENU_SUMMARY, MENU_CANCEL1}; -const u8 sPartyMenuAction_NoEntrySummaryCancel[] = {MENU_NO_ENTRY, MENU_SUMMARY, MENU_CANCEL1}; -const u8 sPartyMenuAction_StoreSummaryCancel[] = {MENU_STORE, MENU_SUMMARY, MENU_CANCEL1}; -const u8 sPartyMenuAction_GiveTakeItemCancel[] = {MENU_GIVE, MENU_TAKE_ITEM, MENU_CANCEL2}; -const u8 sPartyMenuAction_ReadTakeMailCancel[] = {MENU_READ, MENU_TAKE_MAIL, MENU_CANCEL2}; -const u8 sPartyMenuAction_RegisterSummaryCancel[] = {MENU_REGISTER, MENU_SUMMARY, MENU_CANCEL1}; -const u8 sPartyMenuAction_TradeSummaryCancel1[] = {MENU_TRADE1, MENU_SUMMARY, MENU_CANCEL1}; -const u8 sPartyMenuAction_TradeSummaryCancel2[] = {MENU_TRADE2, MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_SummarySwitchCancel[] = {MENU_SUMMARY, MENU_SWITCH, MENU_CANCEL1}; +static const u8 sPartyMenuAction_ShiftSummaryCancel[] = {MENU_SHIFT, MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_SendOutSummaryCancel[] = {MENU_SEND_OUT, MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_SummaryCancel[] = {MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_EnterSummaryCancel[] = {MENU_ENTER, MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_NoEntrySummaryCancel[] = {MENU_NO_ENTRY, MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_StoreSummaryCancel[] = {MENU_STORE, MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_GiveTakeItemCancel[] = {MENU_GIVE, MENU_TAKE_ITEM, MENU_CANCEL2}; +static const u8 sPartyMenuAction_ReadTakeMailCancel[] = {MENU_READ, MENU_TAKE_MAIL, MENU_CANCEL2}; +static const u8 sPartyMenuAction_RegisterSummaryCancel[] = {MENU_REGISTER, MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_TradeSummaryCancel1[] = {MENU_TRADE1, MENU_SUMMARY, MENU_CANCEL1}; +static const u8 sPartyMenuAction_TradeSummaryCancel2[] = {MENU_TRADE2, MENU_SUMMARY, MENU_CANCEL1}; // IDs for the action lists that appear when a party mon is selected enum @@ -1180,7 +1180,7 @@ enum ACTIONS_SPIN_TRADE, }; -const u8 *const sPartyMenuActions[] = +static const u8 *const sPartyMenuActions[] = { [ACTIONS_NONE] = NULL, [ACTIONS_SWITCH] = sPartyMenuAction_SummarySwitchCancel, @@ -1197,7 +1197,7 @@ const u8 *const sPartyMenuActions[] = [ACTIONS_SPIN_TRADE] = sPartyMenuAction_TradeSummaryCancel2, }; -const u8 sPartyMenuActionCounts[] = +static const u8 sPartyMenuActionCounts[] = { [ACTIONS_NONE] = 0, [ACTIONS_SWITCH] = NELEMS(sPartyMenuAction_SummarySwitchCancel), @@ -1214,13 +1214,13 @@ const u8 sPartyMenuActionCounts[] = [ACTIONS_SPIN_TRADE] = NELEMS(sPartyMenuAction_TradeSummaryCancel2), }; -const u16 sFieldMoves[] = +static const u16 sFieldMoves[] = { MOVE_FLASH, MOVE_CUT, MOVE_FLY, MOVE_STRENGTH, MOVE_SURF, MOVE_ROCK_SMASH, MOVE_WATERFALL, MOVE_TELEPORT, MOVE_DIG, MOVE_MILK_DRINK, MOVE_SOFT_BOILED, MOVE_SWEET_SCENT, FIELD_MOVE_END // this may be misuse of enum. same in emerald }; -struct +static struct { bool8 (*fieldMoveFunc)(void); u8 msgId; @@ -1240,7 +1240,7 @@ struct [FIELD_MOVE_SWEET_SCENT] = {SetUpFieldMove_SweetScent, PARTY_MSG_CANT_USE_HERE}, }; -const u8 *const sUnionRoomTradeMessages[] = +static const u8 *const sUnionRoomTradeMessages[] = { [UR_TRADE_MSG_NOT_MON_PARTNER_WANTS - 1] = gText_NotPkmnOtherTrainerWants, [UR_TRADE_MSG_NOT_EGG - 1] = gText_ThatIsntAnEgg, @@ -1253,7 +1253,7 @@ const u8 *const sUnionRoomTradeMessages[] = [UR_TRADE_MSG_CANT_TRADE_WITH_PARTNER_2 - 1] = gText_CantTradeWithTrainer, }; -const u16 sTMHMMoves[] = +static const u16 sTMHMMoves[] = { MOVE_FOCUS_PUNCH, MOVE_DRAGON_CLAW, diff --git a/src/data/pokemon/tutor_learnsets.h b/src/data/pokemon/tutor_learnsets.h index 3f2fbf6a0..afd3814a5 100644 --- a/src/data/pokemon/tutor_learnsets.h +++ b/src/data/pokemon/tutor_learnsets.h @@ -1,4 +1,4 @@ -const u16 sTutorMoves[TUTOR_MOVE_COUNT] = +static const u16 sTutorMoves[TUTOR_MOVE_COUNT] = { [TUTOR_MOVE_MEGA_PUNCH] = MOVE_MEGA_PUNCH, [TUTOR_MOVE_SWORDS_DANCE] = MOVE_SWORDS_DANCE, @@ -17,9 +17,9 @@ const u16 sTutorMoves[TUTOR_MOVE_COUNT] = [TUTOR_MOVE_SUBSTITUTE] = MOVE_SUBSTITUTE, }; -#define TUTOR(move) (1u << (TUTOR_##move)) +#define TUTOR(move) (1 << (TUTOR_##move)) -const u16 sTutorLearnsets[] = +static const u16 sTutorLearnsets[] = { [SPECIES_NONE] = 0, diff --git a/src/party_menu.c b/src/party_menu.c index 5bee1442e..6f543ca9c 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -138,274 +138,274 @@ struct PartyMenuBox u8 statusSpriteId; }; -void BlitBitmapToPartyWindow_LeftColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, bool8 isEgg); -void BlitBitmapToPartyWindow_RightColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, bool8 isEgg); -void CursorCB_Summary(u8 taskId); -void CursorCB_Switch(u8 taskId); -void CursorCB_Cancel1(u8 taskId); -void CursorCB_Item(u8 taskId); -void CursorCB_Give(u8 taskId); -void CursorCB_TakeItem(u8 taskId); -void CursorCB_Mail(u8 taskId); -void CursorCB_Read(u8 taskId); -void CursorCB_TakeMail(u8 taskId); -void CursorCB_Cancel2(u8 taskId); -void CursorCB_SendMon(u8 taskId); -void CursorCB_Enter(u8 taskId); -void CursorCB_NoEntry(u8 taskId); -void CursorCB_Store(u8 taskId); -void CursorCB_Register(u8 taskId); -void CursorCB_Trade1(u8 taskId); -void CursorCB_Trade2(u8 taskId); -void CursorCB_FieldMove(u8 taskId); -bool8 SetUpFieldMove_Fly(void); -bool8 SetUpFieldMove_Waterfall(void); -bool8 SetUpFieldMove_Surf(void); -void CB2_InitPartyMenu(void); -void ResetPartyMenu(void); -bool8 ShowPartyMenu(void); -void SetPartyMonsAllowedInMinigame(void); -void ExitPartyMenu(void); -bool8 CreatePartyMonSpritesLoop(void); -bool8 AllocPartyMenuBg(void); -bool8 AllocPartyMenuBgGfx(void); -void InitPartyMenuWindows(u8 layout); -void InitPartyMenuBoxes(u8 layout); -void LoadPartyMenuPokeballGfx(void); -void LoadPartyMenuAilmentGfx(void); -bool8 RenderPartyMenuBoxes(void); -void CreateCancelConfirmPokeballSprites(void); -void CreateCancelConfirmWindows(bool8 chooseHalf); -void Task_ExitPartyMenu(u8 taskId); -void FreePartyPointers(void); -void PartyPaletteBufferCopy(u8 offset); -void DisplayPartyPokemonDataForMultiBattle(u8 slot); -void DisplayPartyPokemonDataForChooseHalf(u8 slot); -bool8 DisplayPartyPokemonDataForMoveTutorOrEvolutionItem(u8 slot); -void DisplayPartyPokemonData(u8 slot); -void DisplayPartyPokemonDataForWirelessMinigame(u8 slot); -void LoadPartyBoxPalette(struct PartyMenuBox *menuBox, u8 palFlags); -void DrawEmptySlot(u8 windowId); -void DisplayPartyPokemonNickname(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); -void DisplayPartyPokemonLevelCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); -void DisplayPartyPokemonGenderNidoranCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); -void DisplayPartyPokemonHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); -void DisplayPartyPokemonMaxHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); -void DisplayPartyPokemonHPBarCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox); -void DisplayPartyPokemonDescriptionText(u8 stringId, struct PartyMenuBox *menuBox, u8 c); -bool8 GetBattleEntryEligibility(struct Pokemon *mon); -bool8 IsMonAllowedInMinigame(u8 slot); -void DisplayPartyPokemonDataToTeachMove(u8 slot, u16 item, u8 tutor); -u8 CanMonLearnTMTutor(struct Pokemon *mon, u16 item, u8 tutor); -void DisplayPartyPokemonBarDetail(u8 windowId, const u8 *str, u8 color, const u8 *align); -void DisplayPartyPokemonLevel(u8 level, struct PartyMenuBox *menuBox); -void DisplayPartyPokemonGender(u8 gender, u16 species, u8 *nickname, struct PartyMenuBox *menuBox); -void DisplayPartyPokemonHP(u16 hp, struct PartyMenuBox *menuBox); -void DisplayPartyPokemonMaxHP(u16 maxhp, struct PartyMenuBox *menuBox); -void DisplayPartyPokemonHPBar(u16 hp, u16 maxhp, struct PartyMenuBox *menuBox); -void CreatePartyMonIconSpriteParameterized(u16 species, u32 pid, struct PartyMenuBox *menuBox, u8 priority, bool32 handleDeoxys); -void CreatePartyMonHeldItemSpriteParameterized(u16 species, u16 item, struct PartyMenuBox *menuBox); -void CreatePartyMonPokeballSpriteParameterized(u16 species, struct PartyMenuBox *menuBox); -void CreatePartyMonStatusSpriteParameterized(u16 species, u8 status, struct PartyMenuBox *menuBox); -void CreatePartyMonIconSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox, u32 slot); -void CreatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); -void CreatePartyMonPokeballSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); -void CreatePartyMonStatusSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); -void CreateCancelConfirmPokeballSprites(void); -void DrawCancelConfirmButtons(void); -u8 CreatePokeballButtonSprite(u8 x, u8 y); -u8 CreateSmallPokeballButtonSprite(u8 x, u8 y); -u8 GetPartyBoxPaletteFlags(u8 slot, u8 animNum); -void AnimateSelectedPartyIcon(u8 spriteId, u8 animNum); -void PartyMenuStartSpriteAnim(u8 spriteId, u8 animNum); -void Task_ClosePartyMenuAndSetCB2(u8 taskId); -void UpdatePartyToFieldOrder(void); -s8 *GetCurrentPartySlotPtr(void); -u16 PartyMenuButtonHandler(s8 *slotPtr); -void HandleChooseMonSelection(u8 taskId, s8 *slotPtr); -void HandleChooseMonCancel(u8 taskId, s8 *slotPtr); -void MoveCursorToConfirm(void); -bool8 IsSelectedMonNotEgg(u8 *slotPtr); -void TryTutorSelectedMon(u8 taskId); -void TryGiveMailToSelectedMon(u8 taskId); -void SwitchSelectedMons(u8 taskId); -void TryEnterMonForMinigame(u8 taskId, u8 slot); -void Task_TryCreateSelectionWindow(u8 taskId); -void TryGiveItemOrMailToSelectedMon(u8 taskId); -void PartyMenuRemoveWindow(u8 *ptr); -void CB2_SetUpExitToBattleScreen(void); -void Task_ClosePartyMenuAfterText(u8 taskId); -void FinishTwoMonAction(u8 taskId); -void CancelParticipationPrompt(u8 taskId); -void DisplayCancelChooseMonYesNo(u8 taskId); -void Task_CancelChooseMonYesNo(u8 taskId); -void Task_HandleCancelChooseMonYesNoInput(u8 taskId); -void PartyMenuDisplayYesNoMenu(void); -void Task_ReturnToChooseMonAfterText(u8 taskId); -void UpdateCurrentPartySelection(s8 *slotPtr, s8 movementDir); -void UpdatePartySelectionSingleLayout(s8 *slotPtr, s8 movementDir); -void UpdatePartySelectionDoubleLayout(s8 *slotPtr, s8 movementDir); -s8 GetNewSlotDoubleLayout(s8 slotId, s8 movementDir); -void Task_PrintAndWaitForText(u8 taskId); -void PartyMenuPrintText(const u8 *text); -void sub_8124B60(struct Pokemon *mon, u16 item, u16 item2); -bool16 IsMonAllowedInPokemonJump(struct Pokemon *mon); -bool16 IsMonAllowedInDodrioBerryPicking(struct Pokemon *mon); -void Task_CancelParticipationYesNo(u8 taskId); -void Task_HandleCancelParticipationYesNoInput(u8 taskId); -void Task_TryCreateSelectionWindow(u8 taskId); -u16 GetTutorMove(u8 tutor); -bool8 CanLearnTutorMove(u16 species, u8 tutor); -void CreateSelectionWindow(void); -bool8 ShouldUseChooseMonText(void); -void UpdatePartyMonHPBar(u8 spriteId, struct Pokemon *mon); -void SpriteCB_UpdatePartyMonIcon(struct Sprite *sprite); -void SpriteCB_BouncePartyMonIcon(struct Sprite *sprite); -void SpriteCB_HeldItem(struct Sprite *sprite); -void UpdatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); -void ShowOrHideHeldItemSprite(u16 item, struct PartyMenuBox *menuBox); -void CreateHeldItemSpriteForTrade(u8 spriteId, bool8 isMail); -void SetPartyMonAilmentGfx(struct Pokemon *mon, struct PartyMenuBox *menuBox); -void UpdatePartyMonAilmentGfx(u8 status, struct PartyMenuBox *menuBox); -void SetPartyMonFieldSelectionActions(struct Pokemon *mons, u8 slotId); -u8 GetPartyMenuActionsTypeInBattle(struct Pokemon *mon); -u8 GetPartySlotEntryStatus(s8 slot); -void Task_HandleSelectionMenuInput(u8 taskId); -void CB2_ShowPokemonSummaryScreen(void); -void CB2_ReturnToPartyMenuFromSummaryScreen(void); -void UpdatePartyToBattleOrder(void); -void SlidePartyMenuBoxOneStep(u8 taskId); -void Task_SlideSelectedSlotsOffscreen(u8 taskId); -void SwitchPartyMon(void); -void Task_SlideSelectedSlotsOnscreen(u8 taskId); -void CB2_WriteMailToGiveMon(void); -void Task_SwitchHoldItemsPrompt(u8 taskId); -void Task_GiveHoldItem(u8 taskId); -void Task_UpdateHeldItemSprite(u8 taskId); -void Task_HandleSwitchItemsYesNoInput(u8 taskId); -void Task_SwitchItemsYesNo(u8 taskId); -void Task_WriteMailToGiveMonAfterText(u8 taskId); -void CB2_ReturnToPartyMenuFromWritingMail(void); -void CB2_ReturnToPartyMenuFromWritingMail(void); -void Task_DisplayGaveMailFromPartyMessage(u8 taskId); -void CB2_ReadHeldMail(void); -void CB2_ReturnToPartyMenuFromReadingMail(void); -void Task_SendMailToPCYesNo(u8 taskId); -void Task_HandleSendMailToPCYesNoInput(u8 taskId); -void Task_LoseMailMessageYesNo(u8 taskId); -void Task_HandleLoseMailMessageYesNoInput(u8 taskId); -bool8 TrySwitchInPokemon(void); -void DisplayCantUseFlashMessage(void); -void DisplayCantUseSurfMessage(void); -void Task_CancelAfterAorBPress(u8 taskId); -void DisplayFieldMoveExitAreaMessage(u8 taskId); -void Task_FieldMoveExitAreaYesNo(u8 taskId); -void Task_HandleFieldMoveExitAreaYesNoInput(u8 taskId); -void Task_FieldMoveWaitForFade(u8 taskId); -u16 GetFieldMoveMonSpecies(void); -u8 GetPartyLayoutFromBattleType(void); -void Task_SetSacredAshCB(u8 taskId); -void CB2_ReturnToBagMenu(void); -u8 GetPartyIdFromBattleSlot(u8 slot); -void Task_DisplayHPRestoredMessage(u8 taskId); -void SetSelectedMoveForPPItem(u8 taskId); -void ReturnToUseOnWhichMon(u8 taskId); -void TryUsePPItem(u8 taskId); -void ItemUseCB_LearnedMove(u8 taskId, UNUSED TaskFunc func); -void Task_LearnedMove(u8 taskId); -void Task_ReplaceMoveYesNo(u8 taskId); -void Task_DoLearnedMoveFanfareAfterText(u8 taskId); -void Task_TryLearningNextMove(u8 taskId); -void Task_LearnNextMoveOrClosePartyMenu(u8 taskId); -void Task_HandleReplaceMoveYesNoInput(u8 taskId); -void StopLearningMovePrompt(u8 taskId); -void Task_ShowSummaryScreenToForgetMove(u8 taskId); -void CB2_ShowSummaryScreenToForgetMove(void); -void CB2_ReturnToPartyMenuWhileLearningMove(void); -void Task_ReturnToPartyMenuWhileLearningMove(u8 taskId); -void DisplayPartyMenuForgotMoveMessage(u8 taskId); -void Task_PartyMenuReplaceMove(u8 taskId); -void Task_StopLearningMoveYesNo(u8 taskId); -void Task_HandleStopLearningMoveYesNoInput(u8 taskId); -void Task_TryLearningNextMoveAfterText(u8 taskId); -void ItemUseCB_RareCandyStep(u8 taskId, UNUSED TaskFunc func); -void Task_DisplayLevelUpStatsPg1(u8 taskId); -void Task_DisplayLevelUpStatsPg2(u8 taskId); -void UpdateMonDisplayInfoAfterRareCandy(u8 slot, struct Pokemon *mon); -void DisplayLevelUpStatsPg1(u8 taskId); -void DisplayLevelUpStatsPg2(u8 taskId); -void Task_TryLearnNewMoves(u8 taskId); -void PartyMenuTryEvolution(u8 taskId); -void DisplayMonNeedsToReplaceMove(u8 taskId); -void DisplayMonLearnedMove(u8 taskId, u16 move); -void Task_SacredAshDisplayHPRestored(u8 taskId); -void Task_SacredAshLoop(u8 taskId); -void UseSacredAsh(u8 taskId); -void CB2_ReturnToBerryPouchMenu(void); -void CB2_ReturnToTMCaseMenu(void); -void GiveItemOrMailToSelectedMon(u8 taskId); -void RemoveItemToGiveFromBag(u16 item); -void DisplayItemMustBeRemovedFirstMessage(u8 taskId); -void CB2_WriteMailToGiveMonFromBag(void); -void GiveItemToSelectedMon(u8 taskId); -void Task_UpdateHeldItemSpriteAndClosePartyMenu(u8 taskId); -void Task_SwitchItemsFromBagYesNo(u8 taskId); -void CB2_ReturnToPartyOrBagMenuFromWritingMail(void); -bool8 ReturnGiveItemToBagOrPC(u16 item); -void Task_DisplayGaveMailFromBagMessage(u8 taskId); -void Task_HandleSwitchItemsFromBagYesNoInput(u8 taskId); -void Task_ValidateChosenHalfParty(u8 taskId); -bool8 HasPartySlotAlreadyBeenSelected(u8 slot); -void Task_ContinueChoosingHalfParty(u8 taskId); -void BufferBattlePartyOrder(u8 *partyBattleOrder, u8 flankId); -void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battlerId); -void Task_InitMultiPartnerPartySlideIn(u8 taskId); -void Task_WaitAfterMultiPartnerPartySlideIn(u8 taskId); -void SlideMultiPartyMenuBoxSpritesOneStep(u8 taskId); -void Task_MultiPartnerPartySlideIn(u8 taskId); -bool8 CB2_FadeFromPartyMenu(void); -void Task_PartyMenuWaitForFade(u8 taskId); -void sub_8120C6C(u8 taskId); -void sub_8120CA8(u8 taskId); -void sub_8120CD8(u8 taskId); -void sub_8120D08(u8 taskId); -void sub_8120D40(u8 taskId); -void sub_8120D7C(u8 taskId); -void sub_8120DAC(u8 taskId); -void sub_8120DE0(u8 taskId); -void sub_8120E1C(u8 taskId); -void sub_8120E58(u8 taskId); -void sub_8120EE0(u8 taskId); -void sub_8120FF0(u8 taskId); -bool8 sub_8120F78(u8 taskId); -void sub_8120FB0(void); -void sub_8122084(u8 windowId, const u8 *str); -u8 sub_81220D4(void); -void sub_8122110(u8 windowId); -void sub_812358C(void); -void sub_8124BB0(struct Pokemon *mon, u8 fieldMove); -void sub_8124DE0(void); -void sub_8124E48(void); -void sub_812580C(u8 taskId); -void sub_8125898(u8 taskId, UNUSED TaskFunc func); -void sub_8125F4C(u8 taskId, UNUSED TaskFunc func); -void sub_8125F5C(u8 taskId); -void sub_8126BD4(void); -bool8 sub_8126C24(void); - -EWRAM_DATA struct PartyMenuInternal *sPartyMenuInternal = NULL; +static void BlitBitmapToPartyWindow_LeftColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, bool8 isEgg); +static void BlitBitmapToPartyWindow_RightColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, bool8 isEgg); +static void CursorCB_Summary(u8 taskId); +static void CursorCB_Switch(u8 taskId); +static void CursorCB_Cancel1(u8 taskId); +static void CursorCB_Item(u8 taskId); +static void CursorCB_Give(u8 taskId); +static void CursorCB_TakeItem(u8 taskId); +static void CursorCB_Mail(u8 taskId); +static void CursorCB_Read(u8 taskId); +static void CursorCB_TakeMail(u8 taskId); +static void CursorCB_Cancel2(u8 taskId); +static void CursorCB_SendMon(u8 taskId); +static void CursorCB_Enter(u8 taskId); +static void CursorCB_NoEntry(u8 taskId); +static void CursorCB_Store(u8 taskId); +static void CursorCB_Register(u8 taskId); +static void CursorCB_Trade1(u8 taskId); +static void CursorCB_Trade2(u8 taskId); +static void CursorCB_FieldMove(u8 taskId); +static bool8 SetUpFieldMove_Fly(void); +static bool8 SetUpFieldMove_Waterfall(void); +static bool8 SetUpFieldMove_Surf(void); +static void CB2_InitPartyMenu(void); +static void ResetPartyMenu(void); +static bool8 ShowPartyMenu(void); +static void SetPartyMonsAllowedInMinigame(void); +static void ExitPartyMenu(void); +static bool8 CreatePartyMonSpritesLoop(void); +static bool8 AllocPartyMenuBg(void); +static bool8 AllocPartyMenuBgGfx(void); +static void InitPartyMenuWindows(u8 layout); +static void InitPartyMenuBoxes(u8 layout); +static void LoadPartyMenuPokeballGfx(void); +static void LoadPartyMenuAilmentGfx(void); +static bool8 RenderPartyMenuBoxes(void); +static void CreateCancelConfirmPokeballSprites(void); +static void CreateCancelConfirmWindows(bool8 chooseHalf); +static void Task_ExitPartyMenu(u8 taskId); +static void FreePartyPointers(void); +static void PartyPaletteBufferCopy(u8 offset); +static void DisplayPartyPokemonDataForMultiBattle(u8 slot); +static void DisplayPartyPokemonDataForChooseHalf(u8 slot); +static bool8 DisplayPartyPokemonDataForMoveTutorOrEvolutionItem(u8 slot); +static void DisplayPartyPokemonData(u8 slot); +static void DisplayPartyPokemonDataForWirelessMinigame(u8 slot); +static void LoadPartyBoxPalette(struct PartyMenuBox *menuBox, u8 palFlags); +static void DrawEmptySlot(u8 windowId); +static void DisplayPartyPokemonNickname(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +static void DisplayPartyPokemonLevelCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +static void DisplayPartyPokemonGenderNidoranCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +static void DisplayPartyPokemonHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +static void DisplayPartyPokemonMaxHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c); +static void DisplayPartyPokemonHPBarCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox); +static void DisplayPartyPokemonDescriptionText(u8 stringId, struct PartyMenuBox *menuBox, u8 c); +static bool8 GetBattleEntryEligibility(struct Pokemon *mon); +static bool8 IsMonAllowedInMinigame(u8 slot); +static void DisplayPartyPokemonDataToTeachMove(u8 slot, u16 item, u8 tutor); +static u8 CanMonLearnTMTutor(struct Pokemon *mon, u16 item, u8 tutor); +static void DisplayPartyPokemonBarDetail(u8 windowId, const u8 *str, u8 color, const u8 *align); +static void DisplayPartyPokemonLevel(u8 level, struct PartyMenuBox *menuBox); +static void DisplayPartyPokemonGender(u8 gender, u16 species, u8 *nickname, struct PartyMenuBox *menuBox); +static void DisplayPartyPokemonHP(u16 hp, struct PartyMenuBox *menuBox); +static void DisplayPartyPokemonMaxHP(u16 maxhp, struct PartyMenuBox *menuBox); +static void DisplayPartyPokemonHPBar(u16 hp, u16 maxhp, struct PartyMenuBox *menuBox); +static void CreatePartyMonIconSpriteParameterized(u16 species, u32 pid, struct PartyMenuBox *menuBox, u8 priority, bool32 handleDeoxys); +static void CreatePartyMonHeldItemSpriteParameterized(u16 species, u16 item, struct PartyMenuBox *menuBox); +static void CreatePartyMonPokeballSpriteParameterized(u16 species, struct PartyMenuBox *menuBox); +static void CreatePartyMonStatusSpriteParameterized(u16 species, u8 status, struct PartyMenuBox *menuBox); +static void CreatePartyMonIconSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox, u32 slot); +static void CreatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); +static void CreatePartyMonPokeballSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); +static void CreatePartyMonStatusSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); +static void CreateCancelConfirmPokeballSprites(void); +static void DrawCancelConfirmButtons(void); +static u8 CreatePokeballButtonSprite(u8 x, u8 y); +static u8 CreateSmallPokeballButtonSprite(u8 x, u8 y); +static u8 GetPartyBoxPaletteFlags(u8 slot, u8 animNum); +static void AnimateSelectedPartyIcon(u8 spriteId, u8 animNum); +static void PartyMenuStartSpriteAnim(u8 spriteId, u8 animNum); +static void Task_ClosePartyMenuAndSetCB2(u8 taskId); +static void UpdatePartyToFieldOrder(void); +static s8 *GetCurrentPartySlotPtr(void); +static u16 PartyMenuButtonHandler(s8 *slotPtr); +static void HandleChooseMonSelection(u8 taskId, s8 *slotPtr); +static void HandleChooseMonCancel(u8 taskId, s8 *slotPtr); +static void MoveCursorToConfirm(void); +static bool8 IsSelectedMonNotEgg(u8 *slotPtr); +static void TryTutorSelectedMon(u8 taskId); +static void TryGiveMailToSelectedMon(u8 taskId); +static void SwitchSelectedMons(u8 taskId); +static void TryEnterMonForMinigame(u8 taskId, u8 slot); +static void Task_TryCreateSelectionWindow(u8 taskId); +static void TryGiveItemOrMailToSelectedMon(u8 taskId); +static void PartyMenuRemoveWindow(u8 *ptr); +static void CB2_SetUpExitToBattleScreen(void); +static void Task_ClosePartyMenuAfterText(u8 taskId); +static void FinishTwoMonAction(u8 taskId); +static void CancelParticipationPrompt(u8 taskId); +static void DisplayCancelChooseMonYesNo(u8 taskId); +static void Task_CancelChooseMonYesNo(u8 taskId); +static void Task_HandleCancelChooseMonYesNoInput(u8 taskId); +static void PartyMenuDisplayYesNoMenu(void); +static void Task_ReturnToChooseMonAfterText(u8 taskId); +static void UpdateCurrentPartySelection(s8 *slotPtr, s8 movementDir); +static void UpdatePartySelectionSingleLayout(s8 *slotPtr, s8 movementDir); +static void UpdatePartySelectionDoubleLayout(s8 *slotPtr, s8 movementDir); +static s8 GetNewSlotDoubleLayout(s8 slotId, s8 movementDir); +static void Task_PrintAndWaitForText(u8 taskId); +static void PartyMenuPrintText(const u8 *text); +static void sub_8124B60(struct Pokemon *mon, u16 item, u16 item2); +static bool16 IsMonAllowedInPokemonJump(struct Pokemon *mon); +static bool16 IsMonAllowedInDodrioBerryPicking(struct Pokemon *mon); +static void Task_CancelParticipationYesNo(u8 taskId); +static void Task_HandleCancelParticipationYesNoInput(u8 taskId); +static void Task_TryCreateSelectionWindow(u8 taskId); +static u16 GetTutorMove(u8 tutor); +static bool8 CanLearnTutorMove(u16 species, u8 tutor); +static void CreateSelectionWindow(void); +static bool8 ShouldUseChooseMonText(void); +static void UpdatePartyMonHPBar(u8 spriteId, struct Pokemon *mon); +static void SpriteCB_UpdatePartyMonIcon(struct Sprite *sprite); +static void SpriteCB_BouncePartyMonIcon(struct Sprite *sprite); +static void SpriteCB_HeldItem(struct Sprite *sprite); +static void UpdatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox); +static void ShowOrHideHeldItemSprite(u16 item, struct PartyMenuBox *menuBox); +static void CreateHeldItemSpriteForTrade(u8 spriteId, bool8 isMail); +static void SetPartyMonAilmentGfx(struct Pokemon *mon, struct PartyMenuBox *menuBox); +static void UpdatePartyMonAilmentGfx(u8 status, struct PartyMenuBox *menuBox); +static void SetPartyMonFieldSelectionActions(struct Pokemon *mons, u8 slotId); +static u8 GetPartyMenuActionsTypeInBattle(struct Pokemon *mon); +static u8 GetPartySlotEntryStatus(s8 slot); +static void Task_HandleSelectionMenuInput(u8 taskId); +static void CB2_ShowPokemonSummaryScreen(void); +static void CB2_ReturnToPartyMenuFromSummaryScreen(void); +static void UpdatePartyToBattleOrder(void); +static void SlidePartyMenuBoxOneStep(u8 taskId); +static void Task_SlideSelectedSlotsOffscreen(u8 taskId); +static void SwitchPartyMon(void); +static void Task_SlideSelectedSlotsOnscreen(u8 taskId); +static void CB2_WriteMailToGiveMon(void); +static void Task_SwitchHoldItemsPrompt(u8 taskId); +static void Task_GiveHoldItem(u8 taskId); +static void Task_UpdateHeldItemSprite(u8 taskId); +static void Task_HandleSwitchItemsYesNoInput(u8 taskId); +static void Task_SwitchItemsYesNo(u8 taskId); +static void Task_WriteMailToGiveMonAfterText(u8 taskId); +static void CB2_ReturnToPartyMenuFromWritingMail(void); +static void CB2_ReturnToPartyMenuFromWritingMail(void); +static void Task_DisplayGaveMailFromPartyMessage(u8 taskId); +static void CB2_ReadHeldMail(void); +static void CB2_ReturnToPartyMenuFromReadingMail(void); +static void Task_SendMailToPCYesNo(u8 taskId); +static void Task_HandleSendMailToPCYesNoInput(u8 taskId); +static void Task_LoseMailMessageYesNo(u8 taskId); +static void Task_HandleLoseMailMessageYesNoInput(u8 taskId); +static bool8 TrySwitchInPokemon(void); +static void DisplayCantUseFlashMessage(void); +static void DisplayCantUseSurfMessage(void); +static void Task_CancelAfterAorBPress(u8 taskId); +static void DisplayFieldMoveExitAreaMessage(u8 taskId); +static void Task_FieldMoveExitAreaYesNo(u8 taskId); +static void Task_HandleFieldMoveExitAreaYesNoInput(u8 taskId); +static void Task_FieldMoveWaitForFade(u8 taskId); +static u16 GetFieldMoveMonSpecies(void); +static u8 GetPartyLayoutFromBattleType(void); +static void Task_SetSacredAshCB(u8 taskId); +static void CB2_ReturnToBagMenu(void); +static u8 GetPartyIdFromBattleSlot(u8 slot); +static void Task_DisplayHPRestoredMessage(u8 taskId); +static void SetSelectedMoveForPPItem(u8 taskId); +static void ReturnToUseOnWhichMon(u8 taskId); +static void TryUsePPItem(u8 taskId); +static void ItemUseCB_LearnedMove(u8 taskId, UNUSED TaskFunc func); +static void Task_LearnedMove(u8 taskId); +static void Task_ReplaceMoveYesNo(u8 taskId); +static void Task_DoLearnedMoveFanfareAfterText(u8 taskId); +static void Task_TryLearningNextMove(u8 taskId); +static void Task_LearnNextMoveOrClosePartyMenu(u8 taskId); +static void Task_HandleReplaceMoveYesNoInput(u8 taskId); +static void StopLearningMovePrompt(u8 taskId); +static void Task_ShowSummaryScreenToForgetMove(u8 taskId); +static void CB2_ShowSummaryScreenToForgetMove(void); +static void CB2_ReturnToPartyMenuWhileLearningMove(void); +static void Task_ReturnToPartyMenuWhileLearningMove(u8 taskId); +static void DisplayPartyMenuForgotMoveMessage(u8 taskId); +static void Task_PartyMenuReplaceMove(u8 taskId); +static void Task_StopLearningMoveYesNo(u8 taskId); +static void Task_HandleStopLearningMoveYesNoInput(u8 taskId); +static void Task_TryLearningNextMoveAfterText(u8 taskId); +static void ItemUseCB_RareCandyStep(u8 taskId, UNUSED TaskFunc func); +static void Task_DisplayLevelUpStatsPg1(u8 taskId); +static void Task_DisplayLevelUpStatsPg2(u8 taskId); +static void UpdateMonDisplayInfoAfterRareCandy(u8 slot, struct Pokemon *mon); +static void DisplayLevelUpStatsPg1(u8 taskId); +static void DisplayLevelUpStatsPg2(u8 taskId); +static void Task_TryLearnNewMoves(u8 taskId); +static void PartyMenuTryEvolution(u8 taskId); +static void DisplayMonNeedsToReplaceMove(u8 taskId); +static void DisplayMonLearnedMove(u8 taskId, u16 move); +static void Task_SacredAshDisplayHPRestored(u8 taskId); +static void Task_SacredAshLoop(u8 taskId); +static void UseSacredAsh(u8 taskId); +static void CB2_ReturnToBerryPouchMenu(void); +static void CB2_ReturnToTMCaseMenu(void); +static void GiveItemOrMailToSelectedMon(u8 taskId); +static void RemoveItemToGiveFromBag(u16 item); +static void DisplayItemMustBeRemovedFirstMessage(u8 taskId); +static void CB2_WriteMailToGiveMonFromBag(void); +static void GiveItemToSelectedMon(u8 taskId); +static void Task_UpdateHeldItemSpriteAndClosePartyMenu(u8 taskId); +static void Task_SwitchItemsFromBagYesNo(u8 taskId); +static void CB2_ReturnToPartyOrBagMenuFromWritingMail(void); +static bool8 ReturnGiveItemToBagOrPC(u16 item); +static void Task_DisplayGaveMailFromBagMessage(u8 taskId); +static void Task_HandleSwitchItemsFromBagYesNoInput(u8 taskId); +static void Task_ValidateChosenHalfParty(u8 taskId); +static bool8 HasPartySlotAlreadyBeenSelected(u8 slot); +static void Task_ContinueChoosingHalfParty(u8 taskId); +static void BufferBattlePartyOrder(u8 *partyBattleOrder, u8 flankId); +static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battlerId); +static void Task_InitMultiPartnerPartySlideIn(u8 taskId); +static void Task_WaitAfterMultiPartnerPartySlideIn(u8 taskId); +static void SlideMultiPartyMenuBoxSpritesOneStep(u8 taskId); +static void Task_MultiPartnerPartySlideIn(u8 taskId); +static bool8 CB2_FadeFromPartyMenu(void); +static void Task_PartyMenuWaitForFade(u8 taskId); +static void sub_8120C6C(u8 taskId); +static void sub_8120CA8(u8 taskId); +static void sub_8120CD8(u8 taskId); +static void sub_8120D08(u8 taskId); +static void sub_8120D40(u8 taskId); +static void sub_8120D7C(u8 taskId); +static void sub_8120DAC(u8 taskId); +static void sub_8120DE0(u8 taskId); +static void sub_8120E1C(u8 taskId); +static void sub_8120E58(u8 taskId); +static void sub_8120EE0(u8 taskId); +static void sub_8120FF0(u8 taskId); +static bool8 sub_8120F78(u8 taskId); +static void sub_8120FB0(void); +static void sub_8122084(u8 windowId, const u8 *str); +static u8 sub_81220D4(void); +static void sub_8122110(u8 windowId); +static void sub_812358C(void); +static void sub_8124BB0(struct Pokemon *mon, u8 fieldMove); +static void sub_8124DE0(void); +static void sub_8124E48(void); +static void sub_812580C(u8 taskId); +static void sub_8125898(u8 taskId, UNUSED TaskFunc func); +static void sub_8125F4C(u8 taskId, UNUSED TaskFunc func); +static void sub_8125F5C(u8 taskId); +static void sub_8126BD4(void); +static bool8 sub_8126C24(void); + +static EWRAM_DATA struct PartyMenuInternal *sPartyMenuInternal = NULL; EWRAM_DATA struct PartyMenu gPartyMenu = {0}; -EWRAM_DATA struct PartyMenuBox *sPartyMenuBoxes = NULL; -EWRAM_DATA u8 *sPartyBgGfxTilemap = NULL; -EWRAM_DATA u8 *sPartyBgTilemapBuffer = NULL; +static EWRAM_DATA struct PartyMenuBox *sPartyMenuBoxes = NULL; +static EWRAM_DATA u8 *sPartyBgGfxTilemap = NULL; +static EWRAM_DATA u8 *sPartyBgTilemapBuffer = NULL; EWRAM_DATA bool8 gPartyMenuUseExitCallback = FALSE; EWRAM_DATA u8 gSelectedMonPartyId = 0; EWRAM_DATA MainCallback gPostMenuFieldCallback = NULL; -EWRAM_DATA u16 *sSlot1TilemapBuffer = NULL; // for switching party slots -EWRAM_DATA u16 *sSlot2TilemapBuffer = NULL; -EWRAM_DATA struct Pokemon *sSacredAshQuestLogMonBackup = NULL; +static EWRAM_DATA u16 *sSlot1TilemapBuffer = NULL; // for switching party slots +static EWRAM_DATA u16 *sSlot2TilemapBuffer = NULL; +static EWRAM_DATA struct Pokemon *sSacredAshQuestLogMonBackup = NULL; EWRAM_DATA u8 gSelectedOrderFromParty[3] = {0}; -EWRAM_DATA u16 sPartyMenuItemId = ITEM_NONE; +static EWRAM_DATA u16 sPartyMenuItemId = ITEM_NONE; ALIGNED(4) EWRAM_DATA u8 gBattlePartyCurrentOrder[PARTY_SIZE / 2] = {0}; // bits 0-3 are the current pos of Slot 1, 4-7 are Slot 2, and so on void (*gItemUseCB)(u8, TaskFunc); @@ -452,7 +452,7 @@ void InitPartyMenu(u8 menuType, u8 layout, u8 partyAction, bool8 keepCursorPos, } } -void CB2_UpdatePartyMenu(void) +static void CB2_UpdatePartyMenu(void) { RunTasks(); AnimateSprites(); @@ -461,14 +461,14 @@ void CB2_UpdatePartyMenu(void) UpdatePaletteFade(); } -void VBlankCB_PartyMenu(void) +static void VBlankCB_PartyMenu(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -void CB2_InitPartyMenu(void) +static void CB2_InitPartyMenu(void) { while (TRUE) { @@ -477,7 +477,7 @@ void CB2_InitPartyMenu(void) } } -bool8 ShowPartyMenu(void) +static bool8 ShowPartyMenu(void) { switch (gMain.state) { @@ -602,7 +602,7 @@ bool8 ShowPartyMenu(void) return FALSE; } -void ExitPartyMenu(void) +static void ExitPartyMenu(void) { BeginNormalPaletteFade(0xFFFFFFFF, -2, 0, 16, RGB_BLACK); CreateTask(Task_ExitPartyMenu, 0); @@ -610,7 +610,7 @@ void ExitPartyMenu(void) SetMainCallback2(CB2_UpdatePartyMenu); } -void Task_ExitPartyMenu(u8 taskId) +static void Task_ExitPartyMenu(u8 taskId) { if (!gPaletteFade.active) { @@ -620,7 +620,7 @@ void Task_ExitPartyMenu(u8 taskId) } } -void ResetPartyMenu(void) +static void ResetPartyMenu(void) { sPartyMenuInternal = NULL; sPartyBgTilemapBuffer = NULL; @@ -628,7 +628,7 @@ void ResetPartyMenu(void) sPartyBgGfxTilemap = NULL; } -bool8 AllocPartyMenuBg(void) +static bool8 AllocPartyMenuBg(void) { ResetAllBgsCoordinatesAndBgCntRegs(); sPartyBgTilemapBuffer = Alloc(0x800); @@ -647,7 +647,7 @@ bool8 AllocPartyMenuBg(void) return TRUE; } -bool8 AllocPartyMenuBgGfx(void) +static bool8 AllocPartyMenuBgGfx(void) { u32 sizeout; @@ -696,14 +696,14 @@ bool8 AllocPartyMenuBgGfx(void) return FALSE; } -void PartyPaletteBufferCopy(u8 offset) +static void PartyPaletteBufferCopy(u8 offset) { offset *= 16; CpuCopy16(&gPlttBufferUnfaded[0x30], &gPlttBufferUnfaded[offset], 32); CpuCopy16(&gPlttBufferUnfaded[0x30], &gPlttBufferFaded[offset], 32); } -void FreePartyPointers(void) +static void FreePartyPointers(void) { if (sPartyMenuInternal) Free(sPartyMenuInternal); @@ -716,7 +716,7 @@ void FreePartyPointers(void) FreeAllWindowBuffers(); } -void InitPartyMenuBoxes(u8 layout) +static void InitPartyMenuBoxes(u8 layout) { u8 i; @@ -735,7 +735,7 @@ void InitPartyMenuBoxes(u8 layout) sPartyMenuBoxes[1].infoRects = &sPartyBoxInfoRects[PARTY_BOX_LEFT_COLUMN]; } -void RenderPartyMenuBox(u8 slot) +static void RenderPartyMenuBox(u8 slot) { if (gPartyMenu.menuType == PARTY_MENU_TYPE_MULTI_SHOWCASE && slot >= MULTI_PARTY_SIZE) { @@ -772,7 +772,7 @@ void RenderPartyMenuBox(u8 slot) } } -void DisplayPartyPokemonData(u8 slot) +static void DisplayPartyPokemonData(u8 slot) { if (GetMonData(&gPlayerParty[slot], MON_DATA_IS_EGG)) { @@ -791,7 +791,7 @@ void DisplayPartyPokemonData(u8 slot) } } -void DisplayPartyPokemonDescriptionData(u8 slot, u8 stringId) +static void DisplayPartyPokemonDescriptionData(u8 slot, u8 stringId) { struct Pokemon *mon = &gPlayerParty[slot]; @@ -805,7 +805,7 @@ void DisplayPartyPokemonDescriptionData(u8 slot, u8 stringId) DisplayPartyPokemonDescriptionText(stringId, &sPartyMenuBoxes[slot], 0); } -void DisplayPartyPokemonDataForChooseHalf(u8 slot) +static void DisplayPartyPokemonDataForChooseHalf(u8 slot) { u8 i; struct Pokemon *mon = &gPlayerParty[slot]; @@ -834,7 +834,7 @@ void DisplayPartyPokemonDataForChooseHalf(u8 slot) } } -void DisplayPartyPokemonDataForWirelessMinigame(u8 slot) +static void DisplayPartyPokemonDataForWirelessMinigame(u8 slot) { if (IsMonAllowedInMinigame(slot) == TRUE) DisplayPartyPokemonDescriptionData(slot, PARTYBOX_DESC_ABLE); @@ -843,7 +843,7 @@ void DisplayPartyPokemonDataForWirelessMinigame(u8 slot) } // Returns TRUE if teaching move or cant evolve with item (i.e. description data is shown), FALSE otherwise -bool8 DisplayPartyPokemonDataForMoveTutorOrEvolutionItem(u8 slot) +static bool8 DisplayPartyPokemonDataForMoveTutorOrEvolutionItem(u8 slot) { struct Pokemon *currentPokemon = &gPlayerParty[slot]; u16 item = gSpecialVar_ItemId; @@ -876,7 +876,7 @@ bool8 DisplayPartyPokemonDataForMoveTutorOrEvolutionItem(u8 slot) return TRUE; } -void DisplayPartyPokemonDataToTeachMove(u8 slot, u16 item, u8 tutor) +static void DisplayPartyPokemonDataToTeachMove(u8 slot, u16 item, u8 tutor) { switch (CanMonLearnTMTutor(&gPlayerParty[slot], item, tutor)) { @@ -893,7 +893,7 @@ void DisplayPartyPokemonDataToTeachMove(u8 slot, u16 item, u8 tutor) } } -void DisplayPartyPokemonDataForMultiBattle(u8 slot) +static void DisplayPartyPokemonDataForMultiBattle(u8 slot) { struct PartyMenuBox *menuBox = &sPartyMenuBoxes[slot]; u8 actualSlot = slot - (3); @@ -918,7 +918,7 @@ void DisplayPartyPokemonDataForMultiBattle(u8 slot) } } -bool8 RenderPartyMenuBoxes(void) +static bool8 RenderPartyMenuBoxes(void) { RenderPartyMenuBox(sPartyMenuInternal->data[0]); if (++sPartyMenuInternal->data[0] == PARTY_SIZE) @@ -927,12 +927,12 @@ bool8 RenderPartyMenuBoxes(void) return FALSE; } -u8 *GetPartyMenuBgTile(u16 tileId) +static u8 *GetPartyMenuBgTile(u16 tileId) { return &sPartyBgGfxTilemap[tileId << 5]; } -void CreatePartyMonSprites(u8 slot) +static void CreatePartyMonSprites(u8 slot) { u8 actualSlot; @@ -962,7 +962,7 @@ void CreatePartyMonSprites(u8 slot) } } -bool8 CreatePartyMonSpritesLoop(void) +static bool8 CreatePartyMonSpritesLoop(void) { CreatePartyMonSprites(sPartyMenuInternal->data[0]); if (++sPartyMenuInternal->data[0] == PARTY_SIZE) @@ -971,7 +971,7 @@ bool8 CreatePartyMonSpritesLoop(void) return FALSE; } -void CreateCancelConfirmPokeballSprites(void) +static void CreateCancelConfirmPokeballSprites(void) { if (gPartyMenu.menuType == PARTY_MENU_TYPE_MULTI_SHOWCASE) { @@ -1039,7 +1039,7 @@ void AnimatePartySlot(u8 slot, u8 animNum) ScheduleBgCopyTilemapToVram(1); } -u8 GetPartyBoxPaletteFlags(u8 slot, u8 animNum) +static u8 GetPartyBoxPaletteFlags(u8 slot, u8 animNum) { u8 palFlags = 0; @@ -1062,7 +1062,7 @@ u8 GetPartyBoxPaletteFlags(u8 slot, u8 animNum) return palFlags; } -void DrawCancelConfirmButtons(void) +static void DrawCancelConfirmButtons(void) { CopyToBgTilemapBufferRect_ChangePalette(1, sConfirmButton_Tilemap, 23, 16, 7, 2, 17); CopyToBgTilemapBufferRect_ChangePalette(1, sCancelButton_Tilemap, 23, 18, 7, 2, 17); @@ -1077,7 +1077,7 @@ bool8 IsMultiBattle(void) return FALSE; } -void SwapPartyPokemon(struct Pokemon *mon1, struct Pokemon *mon2) +static void SwapPartyPokemon(struct Pokemon *mon1, struct Pokemon *mon2) { struct Pokemon *buffer = Alloc(sizeof(struct Pokemon)); @@ -1087,13 +1087,13 @@ void SwapPartyPokemon(struct Pokemon *mon1, struct Pokemon *mon2) Free(buffer); } -void Task_ClosePartyMenu(u8 taskId) +static void Task_ClosePartyMenu(u8 taskId) { BeginNormalPaletteFade(0xFFFFFFFF, -2, 0, 16, RGB_BLACK); gTasks[taskId].func = Task_ClosePartyMenuAndSetCB2; } -void Task_ClosePartyMenuAndSetCB2(u8 taskId) +static void Task_ClosePartyMenuAndSetCB2(u8 taskId) { if (!gPaletteFade.active) { @@ -1143,7 +1143,7 @@ void Task_HandleChooseMonInput(u8 taskId) } } -s8 *GetCurrentPartySlotPtr(void) +static s8 *GetCurrentPartySlotPtr(void) { if (gPartyMenu.action == PARTY_ACTION_SWITCH || gPartyMenu.action == PARTY_ACTION_SOFTBOILED) return &gPartyMenu.slotId2; @@ -1151,7 +1151,7 @@ s8 *GetCurrentPartySlotPtr(void) return &gPartyMenu.slotId; } -void HandleChooseMonSelection(u8 taskId, s8 *slotPtr) +static void HandleChooseMonSelection(u8 taskId, s8 *slotPtr) { if (*slotPtr == PARTY_SIZE) { @@ -1220,7 +1220,7 @@ void HandleChooseMonSelection(u8 taskId, s8 *slotPtr) } } -bool8 IsSelectedMonNotEgg(u8 *slotPtr) +static bool8 IsSelectedMonNotEgg(u8 *slotPtr) { if (GetMonData(&gPlayerParty[*slotPtr], MON_DATA_IS_EGG) == TRUE) { @@ -1230,7 +1230,7 @@ bool8 IsSelectedMonNotEgg(u8 *slotPtr) return TRUE; } -void HandleChooseMonCancel(u8 taskId, s8 *slotPtr) +static void HandleChooseMonCancel(u8 taskId, s8 *slotPtr) { switch (gPartyMenu.action) { @@ -1264,7 +1264,7 @@ void HandleChooseMonCancel(u8 taskId, s8 *slotPtr) } } -void DisplayCancelChooseMonYesNo(u8 taskId) +static void DisplayCancelChooseMonYesNo(u8 taskId) { PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); StringExpandPlaceholders(gStringVar4, gUnknown_84176CF); @@ -1272,7 +1272,7 @@ void DisplayCancelChooseMonYesNo(u8 taskId) gTasks[taskId].func = Task_CancelChooseMonYesNo; } -void Task_CancelChooseMonYesNo(u8 taskId) +static void Task_CancelChooseMonYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -1281,7 +1281,7 @@ void Task_CancelChooseMonYesNo(u8 taskId) } } -void Task_HandleCancelChooseMonYesNoInput(u8 taskId) +static void Task_HandleCancelChooseMonYesNoInput(u8 taskId) { switch (Menu_ProcessInputNoWrapClearOnChoose()) { @@ -1300,7 +1300,7 @@ void Task_HandleCancelChooseMonYesNoInput(u8 taskId) } } -u16 PartyMenuButtonHandler(s8 *slotPtr) +static u16 PartyMenuButtonHandler(s8 *slotPtr) { s8 movementDir; @@ -1346,7 +1346,7 @@ u16 PartyMenuButtonHandler(s8 *slotPtr) return JOY_NEW(A_BUTTON | B_BUTTON); } -void UpdateCurrentPartySelection(s8 *slotPtr, s8 movementDir) +static void UpdateCurrentPartySelection(s8 *slotPtr, s8 movementDir) { s8 newSlotId = *slotPtr; u8 layout = gPartyMenu.layout; @@ -1363,7 +1363,7 @@ void UpdateCurrentPartySelection(s8 *slotPtr, s8 movementDir) } } -void UpdatePartySelectionSingleLayout(s8 *slotPtr, s8 movementDir) +static void UpdatePartySelectionSingleLayout(s8 *slotPtr, s8 movementDir) { // PARTY_SIZE + 1 is Cancel, PARTY_SIZE is Confirm switch (movementDir) @@ -1428,7 +1428,7 @@ void UpdatePartySelectionSingleLayout(s8 *slotPtr, s8 movementDir) } } -void UpdatePartySelectionDoubleLayout(s8 *slotPtr, s8 movementDir) +static void UpdatePartySelectionDoubleLayout(s8 *slotPtr, s8 movementDir) { // PARTY_SIZE + 1 is Cancel, PARTY_SIZE is Confirm // newSlot is used temporarily as a movement direction during its later assignment @@ -1526,7 +1526,7 @@ void UpdatePartySelectionDoubleLayout(s8 *slotPtr, s8 movementDir) } } -s8 GetNewSlotDoubleLayout(s8 slotId, s8 movementDir) +static s8 GetNewSlotDoubleLayout(s8 slotId, s8 movementDir) { while (TRUE) { @@ -1556,7 +1556,7 @@ u8 DisplayPartyMenuMessage(const u8 *str, bool8 keepOpen) return taskId; } -void Task_PrintAndWaitForText(u8 taskId) +static void Task_PrintAndWaitForText(u8 taskId) { if (RunTextPrinters_CheckActive(6) != TRUE) { @@ -1576,7 +1576,7 @@ bool8 IsPartyMenuTextPrinterActive(void) return FuncIsActiveTask(Task_PrintAndWaitForText); } -void Task_WaitForLinkAndReturnToChooseMon(u8 taskId) +static void Task_WaitForLinkAndReturnToChooseMon(u8 taskId) { if (sub_80BF748() != TRUE) { @@ -1585,7 +1585,7 @@ void Task_WaitForLinkAndReturnToChooseMon(u8 taskId) } } -void Task_ReturnToChooseMonAfterText(u8 taskId) +static void Task_ReturnToChooseMonAfterText(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -1603,7 +1603,7 @@ void Task_ReturnToChooseMonAfterText(u8 taskId) } } -void DisplayGaveHeldItemMessage(struct Pokemon *mon, u16 item, bool8 keepOpen, u8 a4) +static void DisplayGaveHeldItemMessage(struct Pokemon *mon, u16 item, bool8 keepOpen, u8 a4) { if (!a4) ItemUse_SetQuestLogEvent(5, mon, item, 0xFFFF); @@ -1618,7 +1618,7 @@ void DisplayGaveHeldItemMessage(struct Pokemon *mon, u16 item, bool8 keepOpen, u ScheduleBgCopyTilemapToVram(2); } -void DisplayTookHeldItemMessage(struct Pokemon *mon, u16 item, bool8 keepOpen) +static void DisplayTookHeldItemMessage(struct Pokemon *mon, u16 item, bool8 keepOpen) { ItemUse_SetQuestLogEvent(8, mon, item, 0xFFFF); GetMonNickname(mon, gStringVar1); @@ -1628,7 +1628,7 @@ void DisplayTookHeldItemMessage(struct Pokemon *mon, u16 item, bool8 keepOpen) ScheduleBgCopyTilemapToVram(2); } -void DisplayAlreadyHoldingItemSwitchMessage(struct Pokemon *mon, u16 item, bool8 keepOpen) +static void DisplayAlreadyHoldingItemSwitchMessage(struct Pokemon *mon, u16 item, bool8 keepOpen) { GetMonNickname(mon, gStringVar1); CopyItemName(item, gStringVar2); @@ -1637,7 +1637,7 @@ void DisplayAlreadyHoldingItemSwitchMessage(struct Pokemon *mon, u16 item, bool8 ScheduleBgCopyTilemapToVram(2); } -void DisplaySwitchedHeldItemMessage(u16 item, u16 item2, bool8 keepOpen) +static void DisplaySwitchedHeldItemMessage(u16 item, u16 item2, bool8 keepOpen) { sub_8124B60(&gPlayerParty[gPartyMenu.slotId], item2, item); CopyItemName(item, gStringVar1); @@ -1647,7 +1647,7 @@ void DisplaySwitchedHeldItemMessage(u16 item, u16 item2, bool8 keepOpen) ScheduleBgCopyTilemapToVram(2); } -void GiveItemToMon(struct Pokemon *mon, u16 item) +static void GiveItemToMon(struct Pokemon *mon, u16 item) { u8 itemBytes[2]; @@ -1661,7 +1661,7 @@ void GiveItemToMon(struct Pokemon *mon, u16 item) SetMonData(mon, MON_DATA_HELD_ITEM, itemBytes); } -u8 TryTakeMonItem(struct Pokemon *mon) +static u8 TryTakeMonItem(struct Pokemon *mon) { u16 item = GetMonData(mon, MON_DATA_HELD_ITEM); @@ -1674,7 +1674,7 @@ u8 TryTakeMonItem(struct Pokemon *mon) return 2; } -void BufferBagFullCantTakeItemMessage(u16 itemId) +static void BufferBagFullCantTakeItemMessage(u16 itemId) { const u8 *string; @@ -1701,7 +1701,7 @@ void BufferBagFullCantTakeItemMessage(u16 itemId) #define tPartyId data[4] #define tStartHP data[5] -void Task_PartyMenuModifyHP(u8 taskId) +static void Task_PartyMenuModifyHP(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -1733,7 +1733,9 @@ void PartyMenuModifyHP(u8 taskId, u8 slot, s8 hpIncrement, s16 hpDifference, Tas SetTaskFuncWithFollowupFunc(taskId, Task_PartyMenuModifyHP, task); } -void ResetHPTaskData(u8 taskId, u8 caseId, u32 hp) +// The usage of hp in this function is mostly nonsense +// Because caseId is always passed 0, none of the other cases ever occur +static void ResetHPTaskData(u8 taskId, u8 caseId, u32 hp) { s16 *data = gTasks[taskId].data; @@ -1797,7 +1799,7 @@ u8 GetMonAilment(struct Pokemon *mon) return AILMENT_NONE; } -void SetPartyMonsAllowedInMinigame(void) +static void SetPartyMonsAllowedInMinigame(void) { u16 *ptr; @@ -1820,7 +1822,7 @@ void SetPartyMonsAllowedInMinigame(void) } } -bool16 IsMonAllowedInPokemonJump(struct Pokemon *mon) +static bool16 IsMonAllowedInPokemonJump(struct Pokemon *mon) { if (GetMonData(mon, MON_DATA_IS_EGG) != TRUE && IsSpeciesAllowedInPokemonJump(GetMonData(mon, MON_DATA_SPECIES))) return TRUE; @@ -1828,21 +1830,21 @@ bool16 IsMonAllowedInPokemonJump(struct Pokemon *mon) } -bool16 IsMonAllowedInDodrioBerryPicking(struct Pokemon *mon) +static bool16 IsMonAllowedInDodrioBerryPicking(struct Pokemon *mon) { if (GetMonData(mon, MON_DATA_IS_EGG) != TRUE && GetMonData(mon, MON_DATA_SPECIES) == SPECIES_DODRIO) return TRUE; return FALSE; } -bool8 IsMonAllowedInMinigame(u8 slot) +static bool8 IsMonAllowedInMinigame(u8 slot) { if (!((gPartyMenu.data1 >> slot) & 1)) return FALSE; return TRUE; } -void TryEnterMonForMinigame(u8 taskId, u8 slot) +static void TryEnterMonForMinigame(u8 taskId, u8 slot) { if (IsMonAllowedInMinigame(slot) == TRUE) { @@ -1859,14 +1861,14 @@ void TryEnterMonForMinigame(u8 taskId, u8 slot) } } -void CancelParticipationPrompt(u8 taskId) +static void CancelParticipationPrompt(u8 taskId) { DisplayPartyMenuMessage(gText_CancelParticipation, TRUE); ScheduleBgCopyTilemapToVram(2); gTasks[taskId].func = Task_CancelParticipationYesNo; } -void Task_CancelParticipationYesNo(u8 taskId) +static void Task_CancelParticipationYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -1875,7 +1877,7 @@ void Task_CancelParticipationYesNo(u8 taskId) } } -void Task_HandleCancelParticipationYesNoInput(u8 taskId) +static void Task_HandleCancelParticipationYesNoInput(u8 taskId) { switch (Menu_ProcessInputNoWrapClearOnChoose()) { @@ -1892,7 +1894,7 @@ void Task_HandleCancelParticipationYesNoInput(u8 taskId) } } -u8 CanMonLearnTMTutor(struct Pokemon *mon, u16 item, u8 tutor) +static u8 CanMonLearnTMTutor(struct Pokemon *mon, u16 item, u8 tutor) { u16 move; @@ -1923,7 +1925,7 @@ u8 CanMonLearnTMTutor(struct Pokemon *mon, u16 item, u8 tutor) return CAN_LEARN_MOVE; } -u16 GetTutorMove(u8 tutor) +static u16 GetTutorMove(u8 tutor) { switch (tutor) { @@ -1938,7 +1940,7 @@ u16 GetTutorMove(u8 tutor) } } -bool8 CanLearnTutorMove(u16 species, u8 tutor) +static bool8 CanLearnTutorMove(u16 species, u8 tutor) { switch (tutor) { @@ -1965,31 +1967,31 @@ bool8 CanLearnTutorMove(u16 species, u8 tutor) } } -void sub_8120C3C(u8 taskId) +static void sub_8120C3C(u8 taskId) { if (!gPaletteFade.active) gTasks[taskId].func = sub_8120C6C; } -void sub_8120C6C(u8 taskId) +static void sub_8120C6C(u8 taskId) { BeginNormalPaletteFade(0xFFFF1FFF, 4, 0, 6, RGB_BLACK); gTasks[taskId].func = sub_8120CA8; } -void sub_8120CA8(u8 taskId) +static void sub_8120CA8(u8 taskId) { if (!gPaletteFade.active) gTasks[taskId].func = sub_8120CD8; } -void sub_8120CD8(u8 taskId) +static void sub_8120CD8(u8 taskId) { gTasks[taskId].data[0] = sub_81220D4(); gTasks[taskId].func = sub_8120D08; } -void sub_8120D08(u8 taskId) +static void sub_8120D08(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -1997,19 +1999,19 @@ void sub_8120D08(u8 taskId) gTasks[taskId].func = sub_8120D40; } -void sub_8120D40(u8 taskId) +static void sub_8120D40(u8 taskId) { BeginNormalPaletteFade(0xFFFF0008, 4, 6, 0, RGB_BLACK); gTasks[taskId].func = sub_8120D7C; } -void sub_8120D7C(u8 taskId) +static void sub_8120D7C(u8 taskId) { if (!gPaletteFade.active) gTasks[taskId].func = sub_8120DAC; } -void sub_8120DAC(u8 taskId) +static void sub_8120DAC(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -2017,7 +2019,7 @@ void sub_8120DAC(u8 taskId) gTasks[taskId].func = sub_8120DE0; } -void sub_8120DE0(u8 taskId) +static void sub_8120DE0(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -2028,13 +2030,13 @@ void sub_8120DE0(u8 taskId) } } -void sub_8120E1C(u8 taskId) +static void sub_8120E1C(u8 taskId) { BeginNormalPaletteFade(0x0000FFF7, 4, 6, 0, RGB_BLACK); gTasks[taskId].func = sub_8120E58; } -void sub_8120E58(u8 taskId) +static void sub_8120E58(u8 taskId) { if (!gPaletteFade.active) { @@ -2048,7 +2050,7 @@ void sub_8120E58(u8 taskId) } } -void sub_8120EBC(u8 taskId) +static void sub_8120EBC(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -2056,7 +2058,7 @@ void sub_8120EBC(u8 taskId) gTasks[taskId].func = sub_8120EE0; } -void sub_8120EE0(u8 taskId) +static void sub_8120EE0(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -2080,7 +2082,7 @@ void sub_8120EE0(u8 taskId) } } -bool8 sub_8120F78(u8 taskId) +static bool8 sub_8120F78(u8 taskId) { if (JOY_NEW(B_BUTTON)) { @@ -2091,7 +2093,7 @@ bool8 sub_8120F78(u8 taskId) return FALSE; } -void sub_8120FB0(void) +static void sub_8120FB0(void) { FreeRestoreBattleData(); LoadPlayerParty(); @@ -2099,7 +2101,7 @@ void sub_8120FB0(void) SetMainCallback2(CB2_ReturnToTeachyTV); } -void sub_8120FCC(u8 taskId) +static void sub_8120FCC(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -2107,7 +2109,7 @@ void sub_8120FCC(u8 taskId) gTasks[taskId].func = sub_8120FF0; } -void sub_8120FF0(u8 taskId) +static void sub_8120FF0(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -2125,7 +2127,7 @@ void sub_8120FF0(u8 taskId) } } -void InitPartyMenuWindows(u8 layout) +static void InitPartyMenuWindows(u8 layout) { u8 i; @@ -2153,7 +2155,7 @@ void InitPartyMenuWindows(u8 layout) LoadPalette(stdpal_get(0), 0xE0, 0x20); } -void CreateCancelConfirmWindows(bool8 chooseHalf) +static void CreateCancelConfirmWindows(bool8 chooseHalf) { u8 confirmWindowId; u8 cancelWindowId; @@ -2194,12 +2196,12 @@ void CreateCancelConfirmWindows(bool8 chooseHalf) } } -u16 *GetPartyMenuPalBufferPtr(u8 paletteId) +static u16 *GetPartyMenuPalBufferPtr(u8 paletteId) { return &sPartyMenuInternal->palBuffer[paletteId]; } -void BlitBitmapToPartyWindow(u8 windowId, const u8 *b, u8 c, u8 x, u8 y, u8 width, u8 height) +static void BlitBitmapToPartyWindow(u8 windowId, const u8 *b, u8 c, u8 x, u8 y, u8 width, u8 height) { u8 *pixels = AllocZeroed(height * width * 32); u8 i, j; @@ -2214,7 +2216,7 @@ void BlitBitmapToPartyWindow(u8 windowId, const u8 *b, u8 c, u8 x, u8 y, u8 widt } } -void BlitBitmapToPartyWindow_LeftColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, u8 isEgg) +static void BlitBitmapToPartyWindow_LeftColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, u8 isEgg) { if (width == 0 && height == 0) { @@ -2227,7 +2229,7 @@ void BlitBitmapToPartyWindow_LeftColumn(u8 windowId, u8 x, u8 y, u8 width, u8 he BlitBitmapToPartyWindow(windowId, sMainSlotTileNums_Egg, 10, x, y, width, height); } -void BlitBitmapToPartyWindow_RightColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, u8 isEgg) +static void BlitBitmapToPartyWindow_RightColumn(u8 windowId, u8 x, u8 y, u8 width, u8 height, u8 isEgg) { if (width == 0 && height == 0) { @@ -2240,7 +2242,7 @@ void BlitBitmapToPartyWindow_RightColumn(u8 windowId, u8 x, u8 y, u8 width, u8 h BlitBitmapToPartyWindow(windowId, sOtherSlotsTileNums_Egg, 18, x, y, width, height); } -void DrawEmptySlot(u8 windowId) +static void DrawEmptySlot(u8 windowId) { BlitBitmapToPartyWindow(windowId, sEmptySlotTileNums, 18, 0, 0, 18, 3); } @@ -2252,7 +2254,7 @@ void DrawEmptySlot(u8 windowId) LoadPalette(GetPartyMenuPalBufferPtr(paletteIds[2]), paletteOffsets[2] + palNum, 2); \ } -void LoadPartyBoxPalette(struct PartyMenuBox *menuBox, u8 palFlags) +static void LoadPartyBoxPalette(struct PartyMenuBox *menuBox, u8 palFlags) { u8 palNum = GetWindowAttribute(menuBox->windowId, WINDOW_PALETTE_NUM) * 16; @@ -2325,12 +2327,12 @@ void LoadPartyBoxPalette(struct PartyMenuBox *menuBox, u8 palFlags) } } -void DisplayPartyPokemonBarDetail(u8 windowId, const u8 *str, u8 color, const u8 *align) +static void DisplayPartyPokemonBarDetail(u8 windowId, const u8 *str, u8 color, const u8 *align) { AddTextPrinterParameterized3(windowId, 0, align[0], align[1], sFontColorTable[color], 0, str); } -void DisplayPartyPokemonNickname(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +static void DisplayPartyPokemonNickname(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) { u8 nickname[POKEMON_NAME_LENGTH + 1]; @@ -2343,7 +2345,7 @@ void DisplayPartyPokemonNickname(struct Pokemon *mon, struct PartyMenuBox *menuB } } -void DisplayPartyPokemonLevelCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +static void DisplayPartyPokemonLevelCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) { if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) { @@ -2359,7 +2361,7 @@ void DisplayPartyPokemonLevelCheck(struct Pokemon *mon, struct PartyMenuBox *men } } -void DisplayPartyPokemonLevel(u8 level, struct PartyMenuBox *menuBox) +static void DisplayPartyPokemonLevel(u8 level, struct PartyMenuBox *menuBox) { ConvertIntToDecimalStringN(gStringVar2, level, STR_CONV_MODE_LEFT_ALIGN, 3); StringCopy(gStringVar1, gText_Lv); @@ -2367,7 +2369,7 @@ void DisplayPartyPokemonLevel(u8 level, struct PartyMenuBox *menuBox) DisplayPartyPokemonBarDetail(menuBox->windowId, gStringVar1, 0, &menuBox->infoRects->dimensions[4]); } -void DisplayPartyPokemonGenderNidoranCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +static void DisplayPartyPokemonGenderNidoranCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) { u8 nickname[POKEMON_NAME_LENGTH + 1]; @@ -2377,7 +2379,7 @@ void DisplayPartyPokemonGenderNidoranCheck(struct Pokemon *mon, struct PartyMenu DisplayPartyPokemonGender(GetMonGender(mon), GetMonData(mon, MON_DATA_SPECIES), nickname, menuBox); } -void DisplayPartyPokemonGender(u8 gender, u16 species, u8 *nickname, struct PartyMenuBox *menuBox) +static void DisplayPartyPokemonGender(u8 gender, u16 species, u8 *nickname, struct PartyMenuBox *menuBox) { u8 palNum = GetWindowAttribute(menuBox->windowId, WINDOW_PALETTE_NUM) * 16; @@ -2400,7 +2402,7 @@ void DisplayPartyPokemonGender(u8 gender, u16 species, u8 *nickname, struct Part } } -void DisplayPartyPokemonHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +static void DisplayPartyPokemonHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) { if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) { @@ -2411,7 +2413,7 @@ void DisplayPartyPokemonHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBo } } -void DisplayPartyPokemonHP(u16 hp, struct PartyMenuBox *menuBox) +static void DisplayPartyPokemonHP(u16 hp, struct PartyMenuBox *menuBox) { u8 *strOut = ConvertIntToDecimalStringN(gStringVar1, hp, STR_CONV_MODE_RIGHT_ALIGN, 3); @@ -2420,7 +2422,7 @@ void DisplayPartyPokemonHP(u16 hp, struct PartyMenuBox *menuBox) DisplayPartyPokemonBarDetail(menuBox->windowId, gStringVar1, 0, &menuBox->infoRects->dimensions[12]); } -void DisplayPartyPokemonMaxHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) +static void DisplayPartyPokemonMaxHPCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox, u8 c) { if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) { @@ -2431,7 +2433,7 @@ void DisplayPartyPokemonMaxHPCheck(struct Pokemon *mon, struct PartyMenuBox *men } } -void DisplayPartyPokemonMaxHP(u16 maxhp, struct PartyMenuBox *menuBox) +static void DisplayPartyPokemonMaxHP(u16 maxhp, struct PartyMenuBox *menuBox) { ConvertIntToDecimalStringN(gStringVar2, maxhp, STR_CONV_MODE_RIGHT_ALIGN, 3); StringCopy(gStringVar1, gText_Slash); @@ -2439,13 +2441,13 @@ void DisplayPartyPokemonMaxHP(u16 maxhp, struct PartyMenuBox *menuBox) DisplayPartyPokemonBarDetail(menuBox->windowId, gStringVar1, 0, &menuBox->infoRects->dimensions[16]); } -void DisplayPartyPokemonHPBarCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox) +static void DisplayPartyPokemonHPBarCheck(struct Pokemon *mon, struct PartyMenuBox *menuBox) { if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) DisplayPartyPokemonHPBar(GetMonData(mon, MON_DATA_HP), GetMonData(mon, MON_DATA_MAX_HP), menuBox); } -void DisplayPartyPokemonHPBar(u16 hp, u16 maxhp, struct PartyMenuBox *menuBox) +static void DisplayPartyPokemonHPBar(u16 hp, u16 maxhp, struct PartyMenuBox *menuBox) { u8 palNum = GetWindowAttribute(menuBox->windowId, WINDOW_PALETTE_NUM) * 16; u8 hpFraction; @@ -2478,7 +2480,7 @@ void DisplayPartyPokemonHPBar(u16 hp, u16 maxhp, struct PartyMenuBox *menuBox) CopyWindowToVram(menuBox->windowId, 2); } -void DisplayPartyPokemonDescriptionText(u8 stringId, struct PartyMenuBox *menuBox, u8 c) +static void DisplayPartyPokemonDescriptionText(u8 stringId, struct PartyMenuBox *menuBox, u8 c) { if (c != 0) menuBox->infoRects->blitFunc(menuBox->windowId, menuBox->infoRects->descTextLeft >> 3, menuBox->infoRects->descTextTop >> 3, menuBox->infoRects->descTextWidth >> 3, menuBox->infoRects->descTextHeight >> 3, TRUE); @@ -2486,7 +2488,7 @@ void DisplayPartyPokemonDescriptionText(u8 stringId, struct PartyMenuBox *menuBo AddTextPrinterParameterized3(menuBox->windowId, 1, menuBox->infoRects->descTextLeft, menuBox->infoRects->descTextTop, sFontColorTable[0], 0, sDescriptionStringTable[stringId]); } -void PartyMenuRemoveWindow(u8 *ptr) +static void PartyMenuRemoveWindow(u8 *ptr) { if (*ptr != 0xFF) { @@ -2540,7 +2542,7 @@ void DisplayPartyMenuStdMessage(u32 stringId) } } -bool8 ShouldUseChooseMonText(void) +static bool8 ShouldUseChooseMonText(void) { struct Pokemon *party = gPlayerParty; u8 i; @@ -2558,7 +2560,7 @@ bool8 ShouldUseChooseMonText(void) return FALSE; } -u8 DisplaySelectionWindow(u8 windowType) +static u8 DisplaySelectionWindow(u8 windowType) { struct WindowTemplate window; u8 cursorDimension; @@ -2597,39 +2599,39 @@ u8 DisplaySelectionWindow(u8 windowType) return sPartyMenuInternal->windowId[0]; } -void PartyMenuPrintText(const u8 *text) +static void PartyMenuPrintText(const u8 *text) { DrawStdFrameWithCustomTileAndPalette(6, FALSE, 0x4F, 13); gTextFlags.canABSpeedUpPrint = TRUE; AddTextPrinterParameterized2(6, 2, text, GetTextSpeedSetting(), 0, 2, 1, 3); } -void PartyMenuDisplayYesNoMenu(void) +static void PartyMenuDisplayYesNoMenu(void) { CreateYesNoMenu(&sPartyMenuYesNoWindowTemplate, 2, 0, 2, 0x4F, 13, 0); } -u8 CreateLevelUpStatsWindow(void) +static u8 CreateLevelUpStatsWindow(void) { sPartyMenuInternal->windowId[0] = AddWindow(&sLevelUpStatsWindowTemplate); DrawStdFrameWithCustomTileAndPalette(sPartyMenuInternal->windowId[0], FALSE, 0x4F, 13); return sPartyMenuInternal->windowId[0]; } -void RemoveLevelUpStatsWindow(void) +static void RemoveLevelUpStatsWindow(void) { ClearWindowTilemap(sPartyMenuInternal->windowId[0]); PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); } -void sub_8122084(u8 windowId, const u8 *str) +static void sub_8122084(u8 windowId, const u8 *str) { StringExpandPlaceholders(gStringVar4, str); gTextFlags.canABSpeedUpPrint = TRUE; AddTextPrinterParameterized2(windowId, 4, gStringVar4, GetTextSpeedSetting(), 0, 2, 1, 3); } -bool8 sub_81220D4(void) +static bool8 sub_81220D4(void) { u8 windowId = AddWindow(&gUnknown_845A170); @@ -2639,7 +2641,7 @@ bool8 sub_81220D4(void) return windowId; } -void sub_8122110(u8 windowId) +static void sub_8122110(u8 windowId) { ClearWindowTilemap(windowId); ClearDialogWindowAndFrameToTransparent(windowId, FALSE); @@ -2647,7 +2649,7 @@ void sub_8122110(u8 windowId) ScheduleBgCopyTilemapToVram(2); } -void sub_8122138(u8 action) +static void sub_8122138(u8 action) { u8 attr; struct PartyMenuInternal *ptr = sPartyMenuInternal; @@ -2674,7 +2676,7 @@ void sub_8122138(u8 action) } } -void CreatePartyMonIconSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox, u32 slot) +static void CreatePartyMonIconSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox, u32 slot) { bool32 handleDeoxys = TRUE; u16 species2; @@ -2687,7 +2689,7 @@ void CreatePartyMonIconSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox, UpdatePartyMonHPBar(menuBox->monSpriteId, mon); } -void CreatePartyMonIconSpriteParameterized(u16 species, u32 pid, struct PartyMenuBox *menuBox, u8 priority, bool32 handleDeoxys) +static void CreatePartyMonIconSpriteParameterized(u16 species, u32 pid, struct PartyMenuBox *menuBox, u8 priority, bool32 handleDeoxys) { if (species != SPECIES_NONE) { @@ -2696,7 +2698,7 @@ void CreatePartyMonIconSpriteParameterized(u16 species, u32 pid, struct PartyMen } } -void UpdateHPBar(u8 spriteId, u16 hp, u16 maxhp) +static void UpdateHPBar(u8 spriteId, u16 hp, u16 maxhp) { switch (GetHPBarLevel(hp, maxhp)) { @@ -2718,12 +2720,12 @@ void UpdateHPBar(u8 spriteId, u16 hp, u16 maxhp) } } -void UpdatePartyMonHPBar(u8 spriteId, struct Pokemon *mon) +static void UpdatePartyMonHPBar(u8 spriteId, struct Pokemon *mon) { UpdateHPBar(spriteId, GetMonData(mon, MON_DATA_HP), GetMonData(mon, MON_DATA_MAX_HP)); } -void AnimateSelectedPartyIcon(u8 spriteId, u8 animNum) +static void AnimateSelectedPartyIcon(u8 spriteId, u8 animNum) { gSprites[spriteId].data[0] = 0; if (animNum == 0) @@ -2748,7 +2750,7 @@ void AnimateSelectedPartyIcon(u8 spriteId, u8 animNum) } } -void SpriteCB_BouncePartyMonIcon(struct Sprite *sprite) +static void SpriteCB_BouncePartyMonIcon(struct Sprite *sprite) { u8 animCmd = UpdateMonIconFrame(sprite); @@ -2761,12 +2763,12 @@ void SpriteCB_BouncePartyMonIcon(struct Sprite *sprite) } } -void SpriteCB_UpdatePartyMonIcon(struct Sprite *sprite) +static void SpriteCB_UpdatePartyMonIcon(struct Sprite *sprite) { UpdateMonIconFrame(sprite); } -void CreatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) +static void CreatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) { if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) { @@ -2775,7 +2777,7 @@ void CreatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menu } } -void CreatePartyMonHeldItemSpriteParameterized(u16 species, u16 item, struct PartyMenuBox *menuBox) +static void CreatePartyMonHeldItemSpriteParameterized(u16 species, u16 item, struct PartyMenuBox *menuBox) { if (species != SPECIES_NONE) { @@ -2785,12 +2787,12 @@ void CreatePartyMonHeldItemSpriteParameterized(u16 species, u16 item, struct Par } } -void UpdatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) +static void UpdatePartyMonHeldItemSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) { ShowOrHideHeldItemSprite(GetMonData(mon, MON_DATA_HELD_ITEM), menuBox); } -void ShowOrHideHeldItemSprite(u16 item, struct PartyMenuBox *menuBox) +static void ShowOrHideHeldItemSprite(u16 item, struct PartyMenuBox *menuBox) { if (item == ITEM_NONE) { @@ -2838,7 +2840,7 @@ void DrawHeldItemIconsForTrade(u8 *partyCounts, u8 *partySpriteIds, u8 whichPart } } -void CreateHeldItemSpriteForTrade(u8 spriteId, bool8 isMail) +static void CreateHeldItemSpriteForTrade(u8 spriteId, bool8 isMail) { u8 subpriority = gSprites[spriteId].subpriority; u8 newSpriteId = CreateSprite(&sSpriteTemplate_HeldItem, 250, 170, subpriority - 1); @@ -2851,7 +2853,7 @@ void CreateHeldItemSpriteForTrade(u8 spriteId, bool8 isMail) gSprites[newSpriteId].callback(&gSprites[newSpriteId]); } -void SpriteCB_HeldItem(struct Sprite *sprite) +static void SpriteCB_HeldItem(struct Sprite *sprite) { u8 otherSpriteId = sprite->data[7]; @@ -2867,13 +2869,13 @@ void SpriteCB_HeldItem(struct Sprite *sprite) } } -void CreatePartyMonPokeballSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) +static void CreatePartyMonPokeballSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) { if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) menuBox->pokeballSpriteId = CreateSprite(&sSpriteTemplate_MenuPokeball, menuBox->spriteCoords[6], menuBox->spriteCoords[7], 8); } -void CreatePartyMonPokeballSpriteParameterized(u16 species, struct PartyMenuBox *menuBox) +static void CreatePartyMonPokeballSpriteParameterized(u16 species, struct PartyMenuBox *menuBox) { if (species != SPECIES_NONE) { @@ -2883,7 +2885,7 @@ void CreatePartyMonPokeballSpriteParameterized(u16 species, struct PartyMenuBox } // For Cancel when Confirm isnt present -u8 CreatePokeballButtonSprite(u8 x, u8 y) +static u8 CreatePokeballButtonSprite(u8 x, u8 y) { u8 spriteId = CreateSprite(&sSpriteTemplate_MenuPokeball, x, y, 8); @@ -2892,12 +2894,12 @@ u8 CreatePokeballButtonSprite(u8 x, u8 y) } // For Confirm and Cancel when both are present -u8 CreateSmallPokeballButtonSprite(u8 x, u8 y) +static u8 CreateSmallPokeballButtonSprite(u8 x, u8 y) { return CreateSprite(&sSpriteTemplate_MenuPokeballSmall, x, y, 8); } -void PartyMenuStartSpriteAnim(u8 spriteId, u8 animNum) +static void PartyMenuStartSpriteAnim(u8 spriteId, u8 animNum) { StartSpriteAnim(&gSprites[spriteId], animNum); } @@ -2922,14 +2924,14 @@ void SpriteCB_BounceConfirmCancelButton(u8 spriteId, u8 spriteId2, u8 animNum) } } -void LoadPartyMenuPokeballGfx(void) +static void LoadPartyMenuPokeballGfx(void) { LoadCompressedSpriteSheet(&sSpriteSheet_MenuPokeball); LoadCompressedSpriteSheet(&sSpriteSheet_MenuPokeballSmall); LoadCompressedSpritePalette(&sSpritePalette_MenuPokeball); } -void CreatePartyMonStatusSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) +static void CreatePartyMonStatusSprite(struct Pokemon *mon, struct PartyMenuBox *menuBox) { if (GetMonData(mon, MON_DATA_SPECIES) != SPECIES_NONE) { @@ -2938,7 +2940,7 @@ void CreatePartyMonStatusSprite(struct Pokemon *mon, struct PartyMenuBox *menuBo } } -void CreatePartyMonStatusSpriteParameterized(u16 species, u8 status, struct PartyMenuBox *menuBox) +static void CreatePartyMonStatusSpriteParameterized(u16 species, u8 status, struct PartyMenuBox *menuBox) { if (species != SPECIES_NONE) { @@ -2948,12 +2950,12 @@ void CreatePartyMonStatusSpriteParameterized(u16 species, u8 status, struct Part } } -void SetPartyMonAilmentGfx(struct Pokemon *mon, struct PartyMenuBox *menuBox) +static void SetPartyMonAilmentGfx(struct Pokemon *mon, struct PartyMenuBox *menuBox) { UpdatePartyMonAilmentGfx(GetMonAilment(mon), menuBox); } -void UpdatePartyMonAilmentGfx(u8 status, struct PartyMenuBox *menuBox) +static void UpdatePartyMonAilmentGfx(u8 status, struct PartyMenuBox *menuBox) { switch (status) { @@ -2968,13 +2970,13 @@ void UpdatePartyMonAilmentGfx(u8 status, struct PartyMenuBox *menuBox) } } -void LoadPartyMenuAilmentGfx(void) +static void LoadPartyMenuAilmentGfx(void) { LoadCompressedSpriteSheet(&sSpriteSheet_StatusIcons); LoadCompressedSpritePalette(&sSpritePalette_StatusIcons); } -void SetPartyMonSelectionActions(struct Pokemon *mons, u8 slotId, u8 action) +static void SetPartyMonSelectionActions(struct Pokemon *mons, u8 slotId, u8 action) { u8 i; @@ -2990,7 +2992,7 @@ void SetPartyMonSelectionActions(struct Pokemon *mons, u8 slotId, u8 action) } } -void SetPartyMonFieldSelectionActions(struct Pokemon *mons, u8 slotId) +static void SetPartyMonFieldSelectionActions(struct Pokemon *mons, u8 slotId) { u8 i, j; @@ -3017,7 +3019,7 @@ void SetPartyMonFieldSelectionActions(struct Pokemon *mons, u8 slotId) AppendToList(sPartyMenuInternal->actions, &sPartyMenuInternal->numActions, MENU_CANCEL1); } -u8 GetPartyMenuActionsType(struct Pokemon *mon) +static u8 GetPartyMenuActionsType(struct Pokemon *mon) { u32 actionType; @@ -3071,7 +3073,7 @@ u8 GetPartyMenuActionsType(struct Pokemon *mon) return actionType; } -void CreateSelectionWindow(void) +static void CreateSelectionWindow(void) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; @@ -3082,14 +3084,14 @@ void CreateSelectionWindow(void) DisplayPartyMenuStdMessage(PARTY_MSG_DO_WHAT_WITH_MON); } -void Task_TryCreateSelectionWindow(u8 taskId) +static void Task_TryCreateSelectionWindow(u8 taskId) { CreateSelectionWindow(); gTasks[taskId].data[0] = 0xFF; gTasks[taskId].func = Task_HandleSelectionMenuInput; } -void Task_HandleSelectionMenuInput(u8 taskId) +static void Task_HandleSelectionMenuInput(u8 taskId) { if (!gPaletteFade.active && sub_80BF748() != TRUE) { @@ -3120,28 +3122,28 @@ void Task_HandleSelectionMenuInput(u8 taskId) } } -void CursorCB_Summary(u8 taskId) +static void CursorCB_Summary(u8 taskId) { PlaySE(SE_SELECT); sPartyMenuInternal->exitCallback = CB2_ShowPokemonSummaryScreen; Task_ClosePartyMenu(taskId); } -void CB2_ShowPokemonSummaryScreen(void) +static void CB2_ShowPokemonSummaryScreen(void) { if (gPartyMenu.menuType == PARTY_MENU_TYPE_IN_BATTLE) UpdatePartyToBattleOrder(); ShowPokemonSummaryScreen(gPlayerParty, gPartyMenu.slotId, gPlayerPartyCount - 1, CB2_ReturnToPartyMenuFromSummaryScreen, 0); } -void CB2_ReturnToPartyMenuFromSummaryScreen(void) +static void CB2_ReturnToPartyMenuFromSummaryScreen(void) { gPaletteFade.bufferTransferDisabled = TRUE; gPartyMenu.slotId = GetLastViewedMonIndex(); InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_DO_WHAT_WITH_MON, Task_TryCreateSelectionWindow, gPartyMenu.exitCallback); } -void CursorCB_Switch(u8 taskId) +static void CursorCB_Switch(u8 taskId) { PlaySE(SE_SELECT); gPartyMenu.action = PARTY_ACTION_SWITCH; @@ -3166,7 +3168,7 @@ void CursorCB_Switch(u8 taskId) #define tSlot1SlideDir data[10] #define tSlot2SlideDir data[11] -void SwitchSelectedMons(u8 taskId) +static void SwitchSelectedMons(u8 taskId) { s16 *data = gTasks[taskId].data; u8 windowIds[2]; @@ -3214,7 +3216,7 @@ void SwitchSelectedMons(u8 taskId) } // returns FALSE if the slot has slid fully offscreen / back onscreen -bool8 TryMovePartySlot(s16 x, s16 width, u8 *leftMove, u8 *newX, u8 *newWidth) +static bool8 TryMovePartySlot(s16 x, s16 width, u8 *leftMove, u8 *newX, u8 *newWidth) { if ((x + width) < 0) return FALSE; @@ -3238,7 +3240,7 @@ bool8 TryMovePartySlot(s16 x, s16 width, u8 *leftMove, u8 *newX, u8 *newWidth) return TRUE; } -void MoveAndBufferPartySlot(const void *rectSrc, s16 x, s16 y, s16 width, s16 height, s16 dir) +static void MoveAndBufferPartySlot(const void *rectSrc, s16 x, s16 y, s16 width, s16 height, s16 dir) { // The use of the dimension parameters here is a mess u8 leftMove, newX, newWidth; // leftMove is used as a srcX, newX is used as both x and srcHeight, newWidth is used as both width and destY @@ -3251,7 +3253,7 @@ void MoveAndBufferPartySlot(const void *rectSrc, s16 x, s16 y, s16 width, s16 he } } -void MovePartyMenuBoxSprites(struct PartyMenuBox *menuBox, s16 offset) +static void MovePartyMenuBoxSprites(struct PartyMenuBox *menuBox, s16 offset) { gSprites[menuBox->pokeballSpriteId].pos2.x += offset * 8; gSprites[menuBox->itemSpriteId].pos2.x += offset * 8; @@ -3259,7 +3261,7 @@ void MovePartyMenuBoxSprites(struct PartyMenuBox *menuBox, s16 offset) gSprites[menuBox->statusSpriteId].pos2.x += offset * 8; } -void SlidePartyMenuBoxSpritesOneStep(u8 taskId) +static void SlidePartyMenuBoxSpritesOneStep(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -3269,7 +3271,7 @@ void SlidePartyMenuBoxSpritesOneStep(u8 taskId) MovePartyMenuBoxSprites(&sPartyMenuBoxes[gPartyMenu.slotId2], tSlot2SlideDir); } -void SlidePartyMenuBoxOneStep(u8 taskId) +static void SlidePartyMenuBoxOneStep(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -3280,7 +3282,7 @@ void SlidePartyMenuBoxOneStep(u8 taskId) ScheduleBgCopyTilemapToVram(0); } -void Task_SlideSelectedSlotsOffscreen(u8 taskId) +static void Task_SlideSelectedSlotsOffscreen(u8 taskId) { s16 *data = gTasks[taskId].data; u16 slidingSlotPositions[2]; @@ -3309,7 +3311,7 @@ void Task_SlideSelectedSlotsOffscreen(u8 taskId) } } -void Task_SlideSelectedSlotsOnscreen(u8 taskId) +static void Task_SlideSelectedSlotsOnscreen(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -3339,7 +3341,7 @@ void Task_SlideSelectedSlotsOnscreen(u8 taskId) } } -void SwitchMenuBoxSprites(u8 *spriteIdPtr1, u8 *spriteIdPtr2) +static void SwitchMenuBoxSprites(u8 *spriteIdPtr1, u8 *spriteIdPtr2) { u8 spriteIdBuffer = *spriteIdPtr1; u16 xBuffer1, yBuffer1, xBuffer2, yBuffer2; @@ -3360,7 +3362,7 @@ void SwitchMenuBoxSprites(u8 *spriteIdPtr1, u8 *spriteIdPtr2) gSprites[*spriteIdPtr2].pos2.y = yBuffer2; } -void SwitchPartyMon(void) +static void SwitchPartyMon(void) { struct PartyMenuBox *menuBoxes[2]; struct Pokemon *mon1, *mon2; @@ -3381,7 +3383,7 @@ void SwitchPartyMon(void) SwitchMenuBoxSprites(&menuBoxes[0]->statusSpriteId, &menuBoxes[1]->statusSpriteId); } -void sub_812358C(void) +static void sub_812358C(void) { u16 *buffer = Alloc(2 * sizeof(u16)); @@ -3392,7 +3394,7 @@ void sub_812358C(void) } // Finish switching mons or using Softboiled -void FinishTwoMonAction(u8 taskId) +static void FinishTwoMonAction(u8 taskId) { PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); gPartyMenu.action = PARTY_ACTION_CHOOSE_MON; @@ -3416,7 +3418,7 @@ void FinishTwoMonAction(u8 taskId) #undef tSlot1SlideDir #undef tSlot2SlideDir -void CursorCB_Cancel1(u8 taskId) +static void CursorCB_Cancel1(u8 taskId) { PlaySE(SE_SELECT); PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); @@ -3428,7 +3430,7 @@ void CursorCB_Cancel1(u8 taskId) gTasks[taskId].func = Task_HandleChooseMonInput; } -void CursorCB_Item(u8 taskId) +static void CursorCB_Item(u8 taskId) { PlaySE(SE_SELECT); PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); @@ -3440,7 +3442,7 @@ void CursorCB_Item(u8 taskId) gTasks[taskId].func = Task_HandleSelectionMenuInput; } -void CursorCB_Give(u8 taskId) +static void CursorCB_Give(u8 taskId) { PlaySE(SE_SELECT); sPartyMenuInternal->exitCallback = CB2_SelectBagItemToGive; @@ -3481,7 +3483,7 @@ void CB2_GiveHoldItem(void) } } -void Task_GiveHoldItem(u8 taskId) +static void Task_GiveHoldItem(u8 taskId) { u16 item; @@ -3495,7 +3497,7 @@ void Task_GiveHoldItem(u8 taskId) } } -void Task_SwitchHoldItemsPrompt(u8 taskId) +static void Task_SwitchHoldItemsPrompt(u8 taskId) { if (!gPaletteFade.active) { @@ -3504,7 +3506,7 @@ void Task_SwitchHoldItemsPrompt(u8 taskId) } } -void Task_SwitchItemsYesNo(u8 taskId) +static void Task_SwitchItemsYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -3513,7 +3515,7 @@ void Task_SwitchItemsYesNo(u8 taskId) } } -void Task_HandleSwitchItemsYesNoInput(u8 taskId) +static void Task_HandleSwitchItemsYesNoInput(u8 taskId) { switch (Menu_ProcessInputNoWrapClearOnChoose()) { @@ -3551,7 +3553,7 @@ void Task_HandleSwitchItemsYesNoInput(u8 taskId) } } -void Task_WriteMailToGiveMonAfterText(u8 taskId) +static void Task_WriteMailToGiveMonAfterText(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -3560,7 +3562,7 @@ void Task_WriteMailToGiveMonAfterText(u8 taskId) } } -void CB2_WriteMailToGiveMon(void) +static void CB2_WriteMailToGiveMon(void) { u8 mail = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_MAIL); @@ -3569,7 +3571,7 @@ void CB2_WriteMailToGiveMon(void) CB2_ReturnToPartyMenuFromWritingMail); } -void CB2_ReturnToPartyMenuFromWritingMail(void) +static void CB2_ReturnToPartyMenuFromWritingMail(void) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; u16 item = GetMonData(mon, MON_DATA_HELD_ITEM); @@ -3591,7 +3593,7 @@ void CB2_ReturnToPartyMenuFromWritingMail(void) } // Nearly redundant with Task_DisplayGaveMailFromBagMessgae -void Task_DisplayGaveMailFromPartyMessage(u8 taskId) +static void Task_DisplayGaveMailFromPartyMessage(u8 taskId) { if (!gPaletteFade.active) { @@ -3603,7 +3605,7 @@ void Task_DisplayGaveMailFromPartyMessage(u8 taskId) } } -void Task_UpdateHeldItemSprite(u8 taskId) +static void Task_UpdateHeldItemSprite(u8 taskId) { s8 slotId = gPartyMenu.slotId; @@ -3614,7 +3616,7 @@ void Task_UpdateHeldItemSprite(u8 taskId) } } -void CursorCB_TakeItem(u8 taskId) +static void CursorCB_TakeItem(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; u16 item = GetMonData(mon, MON_DATA_HELD_ITEM); @@ -3641,7 +3643,7 @@ void CursorCB_TakeItem(u8 taskId) gTasks[taskId].func = Task_UpdateHeldItemSprite; } -void CursorCB_Mail(u8 taskId) +static void CursorCB_Mail(u8 taskId) { PlaySE(SE_SELECT); PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); @@ -3653,25 +3655,25 @@ void CursorCB_Mail(u8 taskId) gTasks[taskId].func = Task_HandleSelectionMenuInput; } -void CursorCB_Read(u8 taskId) +static void CursorCB_Read(u8 taskId) { PlaySE(SE_SELECT); sPartyMenuInternal->exitCallback = CB2_ReadHeldMail; Task_ClosePartyMenu(taskId); } -void CB2_ReadHeldMail(void) +static void CB2_ReadHeldMail(void) { ReadMail(&gSaveBlock1Ptr->mail[GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_MAIL)], CB2_ReturnToPartyMenuFromReadingMail, 1); } -void CB2_ReturnToPartyMenuFromReadingMail(void) +static void CB2_ReturnToPartyMenuFromReadingMail(void) { gPaletteFade.bufferTransferDisabled = TRUE; InitPartyMenu(gPartyMenu.menuType, KEEP_PARTY_LAYOUT, gPartyMenu.action, TRUE, PARTY_MSG_DO_WHAT_WITH_MON, Task_TryCreateSelectionWindow, gPartyMenu.exitCallback); } -void CursorCB_TakeMail(u8 taskId) +static void CursorCB_TakeMail(u8 taskId) { PlaySE(SE_SELECT); PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[1]); @@ -3680,7 +3682,7 @@ void CursorCB_TakeMail(u8 taskId) gTasks[taskId].func = Task_SendMailToPCYesNo; } -void Task_SendMailToPCYesNo(u8 taskId) +static void Task_SendMailToPCYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -3689,7 +3691,7 @@ void Task_SendMailToPCYesNo(u8 taskId) } } -void Task_HandleSendMailToPCYesNoInput(u8 taskId) +static void Task_HandleSendMailToPCYesNoInput(u8 taskId) { switch (Menu_ProcessInputNoWrapClearOnChoose()) { @@ -3715,7 +3717,7 @@ void Task_HandleSendMailToPCYesNoInput(u8 taskId) } } -void Task_LoseMailMessageYesNo(u8 taskId) +static void Task_LoseMailMessageYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -3724,7 +3726,7 @@ void Task_LoseMailMessageYesNo(u8 taskId) } } -void Task_HandleLoseMailMessageYesNoInput(u8 taskId) +static void Task_HandleLoseMailMessageYesNoInput(u8 taskId) { u16 item; @@ -3754,7 +3756,7 @@ void Task_HandleLoseMailMessageYesNoInput(u8 taskId) } } -void CursorCB_Cancel2(u8 taskId) +static void CursorCB_Cancel2(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; @@ -3768,7 +3770,7 @@ void CursorCB_Cancel2(u8 taskId) gTasks[taskId].func = Task_HandleSelectionMenuInput; } -void CursorCB_SendMon(u8 taskId) +static void CursorCB_SendMon(u8 taskId) { PlaySE(SE_SELECT); PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); @@ -3785,7 +3787,7 @@ void CursorCB_SendMon(u8 taskId) } } -void CursorCB_Enter(u8 taskId) +static void CursorCB_Enter(u8 taskId) { u8 maxBattlers; u8 i; @@ -3822,14 +3824,14 @@ void CursorCB_Enter(u8 taskId) gTasks[taskId].func = Task_ReturnToChooseMonAfterText; } -void MoveCursorToConfirm(void) +static void MoveCursorToConfirm(void) { AnimatePartySlot(gPartyMenu.slotId, 0); gPartyMenu.slotId = PARTY_SIZE; AnimatePartySlot(gPartyMenu.slotId, 1); } -void CursorCB_NoEntry(u8 taskId) +static void CursorCB_NoEntry(u8 taskId) { u8 i; @@ -3865,7 +3867,7 @@ void CursorCB_NoEntry(u8 taskId) gTasks[taskId].func = Task_HandleChooseMonInput; } -void CursorCB_Store(u8 taskId) +static void CursorCB_Store(u8 taskId) { PlaySE(SE_SELECT); gSpecialVar_0x8004 = gPartyMenu.slotId; @@ -3873,7 +3875,7 @@ void CursorCB_Store(u8 taskId) } // Register mon for the Trading Board in Union Room -void CursorCB_Register(u8 taskId) +static void CursorCB_Register(u8 taskId) { u16 species2 = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES2); u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); @@ -3900,7 +3902,7 @@ void CursorCB_Register(u8 taskId) gTasks[taskId].func = Task_ReturnToChooseMonAfterText; } -void CursorCB_Trade1(u8 taskId) +static void CursorCB_Trade1(u8 taskId) { u16 species2 = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES2); u16 species = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); @@ -3926,11 +3928,11 @@ void CursorCB_Trade1(u8 taskId) // Spin Trade (based on the translation of the Japanese trade prompt) // Not implemented, and normally unreachable because PARTY_MENU_TYPE_SPIN_TRADE is never used -void CursorCB_Trade2(u8 taskId) +static void CursorCB_Trade2(u8 taskId) { } -void CursorCB_FieldMove(u8 taskId) +static void CursorCB_FieldMove(u8 taskId) { u8 fieldMove = sPartyMenuInternal->actions[Menu_GetCursorPos()] - MENU_FIELD_MOVES; const struct MapHeader *mapHeader; @@ -4009,13 +4011,13 @@ void CursorCB_FieldMove(u8 taskId) } } -void DisplayFieldMoveExitAreaMessage(u8 taskId) +static void DisplayFieldMoveExitAreaMessage(u8 taskId) { DisplayPartyMenuMessage(gStringVar4, TRUE); gTasks[taskId].func = Task_FieldMoveExitAreaYesNo; } -void Task_FieldMoveExitAreaYesNo(u8 taskId) +static void Task_FieldMoveExitAreaYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -4024,7 +4026,7 @@ void Task_FieldMoveExitAreaYesNo(u8 taskId) } } -void Task_HandleFieldMoveExitAreaYesNoInput(u8 taskId) +static void Task_HandleFieldMoveExitAreaYesNoInput(u8 taskId) { switch (Menu_ProcessInputNoWrapClearOnChoose()) { @@ -4051,7 +4053,7 @@ bool8 FieldCallback_PrepareFadeInFromMenu(void) return TRUE; } -void Task_FieldMoveWaitForFade(u8 taskId) +static void Task_FieldMoveWaitForFade(u8 taskId) { if (IsWeatherNotFadingIn() == TRUE) { @@ -4061,18 +4063,18 @@ void Task_FieldMoveWaitForFade(u8 taskId) } } -u16 GetFieldMoveMonSpecies(void) +static u16 GetFieldMoveMonSpecies(void) { return GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_SPECIES); } -void Task_CancelAfterAorBPress(u8 taskId) +static void Task_CancelAfterAorBPress(u8 taskId) { if ((gMain.newKeys & A_BUTTON) || (gMain.newKeys & B_BUTTON)) CursorCB_Cancel1(taskId); } -void DisplayCantUseFlashMessage(void) +static void DisplayCantUseFlashMessage(void) { if (FlagGet(FLAG_SYS_FLASH_ACTIVE) == TRUE) DisplayPartyMenuStdMessage(PARTY_MSG_ALREADY_IN_USE); @@ -4080,13 +4082,13 @@ void DisplayCantUseFlashMessage(void) DisplayPartyMenuStdMessage(PARTY_MSG_CANT_USE_HERE); } -void FieldCallback_Surf(void) +static void FieldCallback_Surf(void) { gFieldEffectArguments[0] = GetCursorSelectionMonId(); FieldEffectStart(FLDEFF_USE_SURF); } -bool8 SetUpFieldMove_Surf(void) +static bool8 SetUpFieldMove_Surf(void) { s16 x, y; @@ -4102,7 +4104,7 @@ bool8 SetUpFieldMove_Surf(void) return FALSE; } -void DisplayCantUseSurfMessage(void) +static void DisplayCantUseSurfMessage(void) { s16 x, y; @@ -4124,7 +4126,7 @@ void DisplayCantUseSurfMessage(void) } } -bool8 SetUpFieldMove_Fly(void) +static bool8 SetUpFieldMove_Fly(void) { if (Overworld_MapTypeAllowsTeleportAndFly(gMapHeader.mapType) == TRUE) return TRUE; @@ -4137,13 +4139,13 @@ void CB2_ReturnToPartyMenuFromFlyMap(void) InitPartyMenu(PARTY_MENU_TYPE_FIELD, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_MON, TRUE, PARTY_MSG_CHOOSE_MON, Task_HandleChooseMonInput, CB2_ReturnToFieldWithOpenMenu); } -void FieldCallback_Waterfall(void) +static void FieldCallback_Waterfall(void) { gFieldEffectArguments[0] = GetCursorSelectionMonId(); FieldEffectStart(FLDEFF_USE_WATERFALL); } -bool8 SetUpFieldMove_Waterfall(void) +static bool8 SetUpFieldMove_Waterfall(void) { s16 x, y; @@ -4157,7 +4159,7 @@ bool8 SetUpFieldMove_Waterfall(void) return FALSE; } -void sub_8124B60(struct Pokemon *mon, u16 item, u16 item2) +static void sub_8124B60(struct Pokemon *mon, u16 item, u16 item2) { u16 *ptr = Alloc(4 * sizeof(u16)); @@ -4178,7 +4180,7 @@ struct FieldMoveWarpParams u8 regionMapSectionId; }; -void sub_8124BB0(struct Pokemon *mon, u8 fieldMove) +static void sub_8124BB0(struct Pokemon *mon, u8 fieldMove) { struct FieldMoveWarpParams *ptr = Alloc(sizeof(*ptr)); @@ -4279,28 +4281,28 @@ void CB2_ShowPartyMenuForItemUse(void) InitPartyMenu(menuType, partyLayout, PARTY_ACTION_USE_ITEM, TRUE, msgId, task, callback); } -void CB2_ReturnToBagMenu(void) +static void CB2_ReturnToBagMenu(void) { GoToBagMenu(11, 3, NULL); } -void CB2_ReturnToTMCaseMenu(void) +static void CB2_ReturnToTMCaseMenu(void) { InitTMCase(5, NULL, 0xFF); } -void CB2_ReturnToBerryPouchMenu(void) +static void CB2_ReturnToBerryPouchMenu(void) { InitBerryPouch(BERRYPOUCH_NA, NULL, 0xFF); } -void sub_8124DC0(u8 taskId) +static void sub_8124DC0(u8 taskId) { sPartyMenuInternal->exitCallback = sub_8124DE0; Task_ClosePartyMenu(taskId); } -void sub_8124DE0(void) +static void sub_8124DE0(void) { if (CheckIfItemIsTMHMOrEvolutionStone(gSpecialVar_ItemId) == 2) // Evolution stone { @@ -4315,7 +4317,7 @@ void sub_8124DE0(void) } } -void sub_8124E48(void) +static void sub_8124E48(void) { if (ItemId_GetPocket(gSpecialVar_ItemId) == POCKET_TM_CASE && sub_811D178() == 1) @@ -4332,7 +4334,7 @@ void sub_8124E48(void) } } -void sub_8124EFC(void) +static void sub_8124EFC(void) { if (sub_811D178() == 1) { @@ -4354,7 +4356,7 @@ void sub_8124EFC(void) } } -void Task_SetSacredAshCB(u8 taskId) +static void Task_SetSacredAshCB(u8 taskId) { if (!gPaletteFade.active) { @@ -4364,7 +4366,7 @@ void Task_SetSacredAshCB(u8 taskId) } } -bool8 IsHPRecoveryItem(u16 item) +static bool8 IsHPRecoveryItem(u16 item) { const u8 *effect; @@ -4378,7 +4380,7 @@ bool8 IsHPRecoveryItem(u16 item) return FALSE; } -void GetMedicineItemEffectMessage(u16 item) +static void GetMedicineItemEffectMessage(u16 item) { switch (GetItemEffectType(item)) { @@ -4443,21 +4445,21 @@ void GetMedicineItemEffectMessage(u16 item) } } -bool8 NotUsingHPEVItemOnShedinja(struct Pokemon *mon, u16 item) +static bool8 NotUsingHPEVItemOnShedinja(struct Pokemon *mon, u16 item) { if (GetItemEffectType(item) == ITEM_EFFECT_HP_EV && GetMonData(mon, MON_DATA_SPECIES) == SPECIES_SHEDINJA) return FALSE; return TRUE; } -bool8 IsItemFlute(u16 item) +static bool8 IsItemFlute(u16 item) { if (item == ITEM_BLUE_FLUTE || item == ITEM_RED_FLUTE || item == ITEM_YELLOW_FLUTE) return TRUE; return FALSE; } -bool8 ExecuteTableBasedItemEffect_(u8 partyMonIndex, u16 item, u8 monMoveIndex) +static bool8 ExecuteTableBasedItemEffect_(u8 partyMonIndex, u16 item, u8 monMoveIndex) { if (gMain.inBattle) return ExecuteTableBasedItemEffect(&gPlayerParty[partyMonIndex], item, GetPartyIdFromBattleSlot(partyMonIndex), monMoveIndex); @@ -4565,7 +4567,7 @@ void ItemUseCB_MedicineStep(u8 taskId, TaskFunc func) } } -void Task_DisplayHPRestoredMessage(u8 taskId) +static void Task_DisplayHPRestoredMessage(u8 taskId) { GetMonNickname(&gPlayerParty[gPartyMenu.slotId], gStringVar1); StringExpandPlaceholders(gStringVar4, gText_PkmnHPRestoredByVar2); @@ -4575,7 +4577,7 @@ void Task_DisplayHPRestoredMessage(u8 taskId) gTasks[taskId].func = Task_ClosePartyMenuAfterText; } -void Task_ClosePartyMenuAfterText(u8 taskId) +static void Task_ClosePartyMenuAfterText(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -4585,7 +4587,7 @@ void Task_ClosePartyMenuAfterText(u8 taskId) } } -void ShowMoveSelectWindow(u8 slot) +static void ShowMoveSelectWindow(u8 slot) { u8 i; u8 moveCount = 0; @@ -4610,7 +4612,7 @@ void ShowMoveSelectWindow(u8 slot) ScheduleBgCopyTilemapToVram(2); } -void Task_HandleWhichMoveInput(u8 taskId) +static void Task_HandleWhichMoveInput(u8 taskId) { s8 input = Menu_ProcessInput(); @@ -4655,7 +4657,7 @@ void ItemUseCB_PPRecovery(u8 taskId, UNUSED TaskFunc func) } } -void SetSelectedMoveForPPItem(u8 taskId) +static void SetSelectedMoveForPPItem(u8 taskId) { PartyMenuRemoveWindow(&sPartyMenuInternal->windowId[0]); gPartyMenu.data1 = Menu_GetCursorPos(); @@ -4665,7 +4667,7 @@ void SetSelectedMoveForPPItem(u8 taskId) sub_812580C(taskId); } -void ReturnToUseOnWhichMon(u8 taskId) +static void ReturnToUseOnWhichMon(u8 taskId) { gTasks[taskId].func = Task_HandleChooseMonInput; sPartyMenuInternal->exitCallback = NULL; @@ -4673,7 +4675,7 @@ void ReturnToUseOnWhichMon(u8 taskId) DisplayPartyMenuStdMessage(PARTY_MSG_USE_ON_WHICH_MON); } -void sub_812580C(u8 taskId) +static void sub_812580C(u8 taskId) { bool8 noEffect = PokemonItemUseNoEffect(&gPlayerParty[gPartyMenu.slotId], gSpecialVar_ItemId, @@ -4694,7 +4696,7 @@ void sub_812580C(u8 taskId) } } -void sub_8125898(u8 taskId, UNUSED TaskFunc func) +static void sub_8125898(u8 taskId, UNUSED TaskFunc func) { u16 move; struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; @@ -4712,7 +4714,7 @@ void sub_8125898(u8 taskId, UNUSED TaskFunc func) gTasks[taskId].func = Task_ClosePartyMenuAfterText; } -void TryUsePPItem(u8 taskId) +static void TryUsePPItem(u8 taskId) { u16 move = MOVE_NONE; s16 *moveSlot = &gPartyMenu.data1; @@ -4781,14 +4783,14 @@ bool8 MonKnowsMove(struct Pokemon *mon, u16 move) return FALSE; } -void DisplayLearnMoveMessage(const u8 *str) +static void DisplayLearnMoveMessage(const u8 *str) { StringExpandPlaceholders(gStringVar4, str); DisplayPartyMenuMessage(gStringVar4, TRUE); ScheduleBgCopyTilemapToVram(2); } -void DisplayLearnMoveMessageAndClose(u8 taskId, const u8 *str) +static void DisplayLearnMoveMessageAndClose(u8 taskId, const u8 *str) { DisplayLearnMoveMessage(str); gTasks[taskId].func = Task_ClosePartyMenuAfterText; @@ -4830,12 +4832,12 @@ void ItemUseCB_TMHM(u8 taskId, UNUSED TaskFunc func) } } -void ItemUseCB_LearnedMove(u8 taskId, UNUSED TaskFunc func) +static void ItemUseCB_LearnedMove(u8 taskId, UNUSED TaskFunc func) { Task_LearnedMove(taskId); } -void Task_LearnedMove(u8 taskId) +static void Task_LearnedMove(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; s16 *move = &gPartyMenu.data1; @@ -4855,7 +4857,7 @@ void Task_LearnedMove(u8 taskId) gTasks[taskId].func = Task_DoLearnedMoveFanfareAfterText; } -void Task_DoLearnedMoveFanfareAfterText(u8 taskId) +static void Task_DoLearnedMoveFanfareAfterText(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -4864,7 +4866,7 @@ void Task_DoLearnedMoveFanfareAfterText(u8 taskId) } } -void Task_LearnNextMoveOrClosePartyMenu(u8 taskId) +static void Task_LearnNextMoveOrClosePartyMenu(u8 taskId) { if (IsFanfareTaskInactive() && ((gMain.newKeys & A_BUTTON) || (gMain.newKeys & B_BUTTON))) { @@ -4879,7 +4881,7 @@ void Task_LearnNextMoveOrClosePartyMenu(u8 taskId) } } -void Task_ReplaceMoveYesNo(u8 taskId) +static void Task_ReplaceMoveYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -4888,7 +4890,7 @@ void Task_ReplaceMoveYesNo(u8 taskId) } } -void Task_HandleReplaceMoveYesNoInput(u8 taskId) +static void Task_HandleReplaceMoveYesNoInput(u8 taskId) { switch (Menu_ProcessInputNoWrapClearOnChoose()) { @@ -4905,7 +4907,7 @@ void Task_HandleReplaceMoveYesNoInput(u8 taskId) } } -void Task_ShowSummaryScreenToForgetMove(u8 taskId) +static void Task_ShowSummaryScreenToForgetMove(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -4914,12 +4916,12 @@ void Task_ShowSummaryScreenToForgetMove(u8 taskId) } } -void CB2_ShowSummaryScreenToForgetMove(void) +static void CB2_ShowSummaryScreenToForgetMove(void) { ShowSelectMovePokemonSummaryScreen(gPlayerParty, gPartyMenu.slotId, gPlayerPartyCount - 1, CB2_ReturnToPartyMenuWhileLearningMove, gPartyMenu.data1); } -void CB2_ReturnToPartyMenuWhileLearningMove(void) +static void CB2_ReturnToPartyMenuWhileLearningMove(void) { u8 moveIdx = GetMoveSlotToReplace(); u16 move; @@ -4938,7 +4940,7 @@ void CB2_ReturnToPartyMenuWhileLearningMove(void) } } -void Task_ReturnToPartyMenuWhileLearningMove(u8 taskId) +static void Task_ReturnToPartyMenuWhileLearningMove(u8 taskId) { if (!gPaletteFade.active) { @@ -4949,12 +4951,12 @@ void Task_ReturnToPartyMenuWhileLearningMove(u8 taskId) } } -void sub_8125F4C(u8 taskId, UNUSED TaskFunc func) +static void sub_8125F4C(u8 taskId, UNUSED TaskFunc func) { sub_8125F5C(taskId); } -void sub_8125F5C(u8 taskId) +static void sub_8125F5C(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; u8 moveIdx = GetMoveSlotToReplace(); @@ -4968,7 +4970,7 @@ void sub_8125F5C(u8 taskId) Task_LearnedMove(taskId); } -void DisplayPartyMenuForgotMoveMessage(u8 taskId) +static void DisplayPartyMenuForgotMoveMessage(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; u16 move = GetMonData(mon, MON_DATA_MOVE1 + GetMoveSlotToReplace()); @@ -4979,7 +4981,7 @@ void DisplayPartyMenuForgotMoveMessage(u8 taskId) gTasks[taskId].func = Task_PartyMenuReplaceMove; } -void Task_PartyMenuReplaceMove(u8 taskId) +static void Task_PartyMenuReplaceMove(u8 taskId) { struct Pokemon *mon; u16 move; @@ -4994,7 +4996,7 @@ void Task_PartyMenuReplaceMove(u8 taskId) } } -void StopLearningMovePrompt(u8 taskId) +static void StopLearningMovePrompt(u8 taskId) { StringCopy(gStringVar2, gMoveNames[gPartyMenu.data1]); StringExpandPlaceholders(gStringVar4, gText_StopLearningMove2); @@ -5003,7 +5005,7 @@ void StopLearningMovePrompt(u8 taskId) gTasks[taskId].func = Task_StopLearningMoveYesNo; } -void Task_StopLearningMoveYesNo(u8 taskId) +static void Task_StopLearningMoveYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -5012,7 +5014,7 @@ void Task_StopLearningMoveYesNo(u8 taskId) } } -void Task_HandleStopLearningMoveYesNoInput(u8 taskId) +static void Task_HandleStopLearningMoveYesNoInput(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; @@ -5046,7 +5048,7 @@ void Task_HandleStopLearningMoveYesNoInput(u8 taskId) } } -void Task_TryLearningNextMoveAfterText(u8 taskId) +static void Task_TryLearningNextMoveAfterText(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) Task_TryLearningNextMove(taskId); @@ -5077,7 +5079,7 @@ void ItemUseCB_RareCandy(u8 taskId, TaskFunc func) } } -void ItemUseCB_RareCandyStep(u8 taskId, UNUSED TaskFunc func) +static void ItemUseCB_RareCandyStep(u8 taskId, UNUSED TaskFunc func) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; struct PartyMenuInternal *ptr = sPartyMenuInternal; @@ -5101,7 +5103,7 @@ void ItemUseCB_RareCandyStep(u8 taskId, UNUSED TaskFunc func) gTasks[taskId].func = Task_DisplayLevelUpStatsPg1; } -void UpdateMonDisplayInfoAfterRareCandy(u8 slot, struct Pokemon *mon) +static void UpdateMonDisplayInfoAfterRareCandy(u8 slot, struct Pokemon *mon) { SetPartyMonAilmentGfx(mon, &sPartyMenuBoxes[slot]); if (gSprites[sPartyMenuBoxes[slot].statusSpriteId].invisible) @@ -5114,7 +5116,7 @@ void UpdateMonDisplayInfoAfterRareCandy(u8 slot, struct Pokemon *mon) ScheduleBgCopyTilemapToVram(0); } -void Task_DisplayLevelUpStatsPg1(u8 taskId) +static void Task_DisplayLevelUpStatsPg1(u8 taskId) { if (WaitFanfare(FALSE) && IsPartyMenuTextPrinterActive() != TRUE && (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON))) { @@ -5124,7 +5126,7 @@ void Task_DisplayLevelUpStatsPg1(u8 taskId) } } -void Task_DisplayLevelUpStatsPg2(u8 taskId) +static void Task_DisplayLevelUpStatsPg2(u8 taskId) { if (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON)) { @@ -5134,7 +5136,7 @@ void Task_DisplayLevelUpStatsPg2(u8 taskId) } } -void DisplayLevelUpStatsPg1(u8 taskId) +static void DisplayLevelUpStatsPg1(u8 taskId) { s16 *arrayPtr = sPartyMenuInternal->data; @@ -5144,7 +5146,7 @@ void DisplayLevelUpStatsPg1(u8 taskId) ScheduleBgCopyTilemapToVram(2); } -void DisplayLevelUpStatsPg2(u8 taskId) +static void DisplayLevelUpStatsPg2(u8 taskId) { s16 *arrayPtr = sPartyMenuInternal->data; @@ -5153,7 +5155,7 @@ void DisplayLevelUpStatsPg2(u8 taskId) ScheduleBgCopyTilemapToVram(2); } -void Task_TryLearnNewMoves(u8 taskId) +static void Task_TryLearnNewMoves(u8 taskId) { u16 learnMove; @@ -5180,7 +5182,7 @@ void Task_TryLearnNewMoves(u8 taskId) } } -void Task_TryLearningNextMove(u8 taskId) +static void Task_TryLearningNextMove(u8 taskId) { u16 result = MonTryLearningNewMove(&gPlayerParty[gPartyMenu.slotId], FALSE); @@ -5200,7 +5202,7 @@ void Task_TryLearningNextMove(u8 taskId) } } -void PartyMenuTryEvolution(u8 taskId) +static void PartyMenuTryEvolution(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; u16 targetSpecies = GetEvolutionTargetSpecies(mon, 0, 0); @@ -5218,7 +5220,7 @@ void PartyMenuTryEvolution(u8 taskId) } } -void DisplayMonNeedsToReplaceMove(u8 taskId) +static void DisplayMonNeedsToReplaceMove(u8 taskId) { GetMonNickname(&gPlayerParty[gPartyMenu.slotId], gStringVar1); StringCopy(gStringVar2, gMoveNames[gMoveToLearn]); @@ -5229,7 +5231,7 @@ void DisplayMonNeedsToReplaceMove(u8 taskId) gTasks[taskId].func = Task_ReplaceMoveYesNo; } -void DisplayMonLearnedMove(u8 taskId, u16 move) +static void DisplayMonLearnedMove(u8 taskId, u16 move) { GetMonNickname(&gPlayerParty[gPartyMenu.slotId], gStringVar1); StringCopy(gStringVar2, gMoveNames[move]); @@ -5252,7 +5254,7 @@ void ItemUseCB_SacredAsh(u8 taskId, UNUSED TaskFunc func) UseSacredAsh(taskId); } -void UseSacredAsh(u8 taskId) +static void UseSacredAsh(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; u16 hp; @@ -5282,7 +5284,7 @@ void UseSacredAsh(u8 taskId) sPartyMenuInternal->tHadEffect = TRUE; } -void Task_SacredAshLoop(u8 taskId) +static void Task_SacredAshLoop(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -5316,7 +5318,7 @@ void Task_SacredAshLoop(u8 taskId) } } -void Task_SacredAshDisplayHPRestored(u8 taskId) +static void Task_SacredAshDisplayHPRestored(u8 taskId) { GetMonNickname(&gPlayerParty[gPartyMenu.slotId], gStringVar1); StringExpandPlaceholders(gStringVar4, gText_PkmnHPRestoredByVar2); @@ -5348,7 +5350,7 @@ void ItemUseCB_EvolutionStone(u8 taskId, TaskFunc func) } } -void sub_8126BD4(void) +static void sub_8126BD4(void) { gCB2_AfterEvolution = gPartyMenu.exitCallback; ExecuteTableBasedItemEffect_(gPartyMenu.slotId, gSpecialVar_ItemId, 0); @@ -5356,7 +5358,7 @@ void sub_8126BD4(void) RemoveBagItem(gSpecialVar_ItemId, 1); } -bool8 sub_8126C24(void) +static bool8 sub_8126C24(void) { if (!IsNationalPokedexEnabled() && GetEvolutionTargetSpecies(&gPlayerParty[gPartyMenu.slotId], 2, gSpecialVar_ItemId) > KANTO_DEX_COUNT) @@ -5429,7 +5431,7 @@ u8 GetItemEffectType(u16 item) return ITEM_EFFECT_NONE; } -void TryTutorSelectedMon(u8 taskId) +static void TryTutorSelectedMon(u8 taskId) { struct Pokemon *mon; s16 *move; @@ -5490,7 +5492,7 @@ void CB2_ChooseMonToGiveItem(void) gPartyMenu.bagItem = gSpecialVar_ItemId; } -void TryGiveItemOrMailToSelectedMon(u8 taskId) +static void TryGiveItemOrMailToSelectedMon(u8 taskId) { sPartyMenuItemId = GetMonData(&gPlayerParty[gPartyMenu.slotId], MON_DATA_HELD_ITEM); if (sPartyMenuItemId == ITEM_NONE) @@ -5508,7 +5510,7 @@ void TryGiveItemOrMailToSelectedMon(u8 taskId) } } -void GiveItemOrMailToSelectedMon(u8 taskId) +static void GiveItemOrMailToSelectedMon(u8 taskId) { if (ItemIsMail(gPartyMenu.bagItem)) { @@ -5522,7 +5524,7 @@ void GiveItemOrMailToSelectedMon(u8 taskId) } } -void GiveItemToSelectedMon(u8 taskId) +static void GiveItemToSelectedMon(u8 taskId) { u16 item; @@ -5536,7 +5538,7 @@ void GiveItemToSelectedMon(u8 taskId) } } -void Task_UpdateHeldItemSpriteAndClosePartyMenu(u8 taskId) +static void Task_UpdateHeldItemSpriteAndClosePartyMenu(u8 taskId) { s8 slot = gPartyMenu.slotId; @@ -5547,7 +5549,7 @@ void Task_UpdateHeldItemSpriteAndClosePartyMenu(u8 taskId) } } -void CB2_WriteMailToGiveMonFromBag(void) +static void CB2_WriteMailToGiveMonFromBag(void) { u8 mail; @@ -5556,7 +5558,7 @@ void CB2_WriteMailToGiveMonFromBag(void) DoEasyChatScreen(EASY_CHAT_TYPE_MAIL, gSaveBlock1Ptr->mail[mail].words, CB2_ReturnToPartyOrBagMenuFromWritingMail); } -void CB2_ReturnToPartyOrBagMenuFromWritingMail(void) +static void CB2_ReturnToPartyOrBagMenuFromWritingMail(void) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; u16 item = GetMonData(mon, MON_DATA_HELD_ITEM); @@ -5577,7 +5579,7 @@ void CB2_ReturnToPartyOrBagMenuFromWritingMail(void) } } -void Task_DisplayGaveMailFromBagMessage(u8 taskId) +static void Task_DisplayGaveMailFromBagMessage(u8 taskId) { if (!gPaletteFade.active) { @@ -5589,7 +5591,7 @@ void Task_DisplayGaveMailFromBagMessage(u8 taskId) } } -void Task_SwitchItemsFromBagYesNo(u8 taskId) +static void Task_SwitchItemsFromBagYesNo(u8 taskId) { if (IsPartyMenuTextPrinterActive() != TRUE) { @@ -5598,7 +5600,7 @@ void Task_SwitchItemsFromBagYesNo(u8 taskId) } } -void Task_HandleSwitchItemsFromBagYesNoInput(u8 taskId) +static void Task_HandleSwitchItemsFromBagYesNoInput(u8 taskId) { u16 item; @@ -5635,14 +5637,14 @@ void Task_HandleSwitchItemsFromBagYesNoInput(u8 taskId) } } -void DisplayItemMustBeRemovedFirstMessage(u8 taskId) +static void DisplayItemMustBeRemovedFirstMessage(u8 taskId) { DisplayPartyMenuMessage(gText_RemoveMailBeforeItem, TRUE); ScheduleBgCopyTilemapToVram(2); gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; } -void RemoveItemToGiveFromBag(u16 item) +static void RemoveItemToGiveFromBag(u16 item) { if (gPartyMenu.action == PARTY_ACTION_GIVE_PC_ITEM) // Unused, never occurs RemovePCItem(item, 1); @@ -5652,7 +5654,7 @@ void RemoveItemToGiveFromBag(u16 item) // Returns FALSE if there was no space to return the item // but there always should be, and the return is ignored in all uses -bool8 ReturnGiveItemToBagOrPC(u16 item) +static bool8 ReturnGiveItemToBagOrPC(u16 item) { if (gPartyMenu.action == PARTY_ACTION_GIVE_ITEM) return AddBagItem(item, 1); @@ -5665,7 +5667,7 @@ void ChooseMonToGiveMailFromMailbox(void) InitPartyMenu(PARTY_MENU_TYPE_FIELD, PARTY_LAYOUT_SINGLE, PARTY_ACTION_GIVE_MAILBOX_MAIL, FALSE, PARTY_MSG_GIVE_TO_WHICH_MON, Task_HandleChooseMonInput, Mailbox_ReturnToMailListAfterDeposit); } -void TryGiveMailToSelectedMon(u8 taskId) +static void TryGiveMailToSelectedMon(u8 taskId) { struct Pokemon *mon = &gPlayerParty[gPartyMenu.slotId]; struct MailStruct *mail; @@ -5686,11 +5688,11 @@ void TryGiveMailToSelectedMon(u8 taskId) gTasks[taskId].func = Task_UpdateHeldItemSpriteAndClosePartyMenu; } -void InitChooseHalfPartyForBattle(u8 maxBattlers) +void InitChooseHalfPartyForBattle(u8 a1) { ClearSelectedPartyOrder(); InitPartyMenu(PARTY_MENU_TYPE_CHOOSE_HALF, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_MON, FALSE, PARTY_MSG_CHOOSE_MON, Task_HandleChooseMonInput, gMain.savedCallback); - gPartyMenu.unk_8_6 = maxBattlers; + gPartyMenu.unk_8_6 = a1; gPartyMenu.task = Task_ValidateChosenHalfParty; } @@ -5699,7 +5701,7 @@ void ClearSelectedPartyOrder(void) memset(gSelectedOrderFromParty, 0, sizeof(gSelectedOrderFromParty)); } -u8 GetPartySlotEntryStatus(s8 slot) +static u8 GetPartySlotEntryStatus(s8 slot) { if (GetBattleEntryEligibility(&gPlayerParty[slot]) == FALSE) return 2; @@ -5709,7 +5711,7 @@ u8 GetPartySlotEntryStatus(s8 slot) } #ifdef NONMATCHING -bool8 GetBattleEntryEligibility(struct Pokemon *mon) +static bool8 GetBattleEntryEligibility(struct Pokemon *mon) { u16 species; u16 i = 0; @@ -5744,7 +5746,7 @@ bool8 GetBattleEntryEligibility(struct Pokemon *mon) } #else NAKED -bool8 GetBattleEntryEligibility(struct Pokemon *mon) +static bool8 GetBattleEntryEligibility(struct Pokemon *mon) { asm_unified("push {r4,r5,lr}\n\ adds r4, r0, 0\n\ @@ -5832,7 +5834,7 @@ bool8 GetBattleEntryEligibility(struct Pokemon *mon) } #endif -u8 CheckBattleEntriesAndGetMessage(void) +static u8 CheckBattleEntriesAndGetMessage(void) { u8 i, j; struct Pokemon *party = gPlayerParty; @@ -5864,7 +5866,7 @@ u8 CheckBattleEntriesAndGetMessage(void) return 0xFF; } -bool8 HasPartySlotAlreadyBeenSelected(u8 slot) +static bool8 HasPartySlotAlreadyBeenSelected(u8 slot) { u8 i; @@ -5874,7 +5876,7 @@ bool8 HasPartySlotAlreadyBeenSelected(u8 slot) return FALSE; } -void Task_ValidateChosenHalfParty(u8 taskId) +static void Task_ValidateChosenHalfParty(u8 taskId) { u8 msgId = CheckBattleEntriesAndGetMessage(); @@ -5900,7 +5902,7 @@ void Task_ValidateChosenHalfParty(u8 taskId) } } -void Task_ContinueChoosingHalfParty(u8 taskId) +static void Task_ContinueChoosingHalfParty(u8 taskId) { if (JOY_NEW(A_BUTTON) || JOY_NEW(B_BUTTON)) { @@ -5951,7 +5953,7 @@ void ChooseMonForWirelessMinigame(void) InitPartyMenu(PARTY_MENU_TYPE_MINIGAME, PARTY_LAYOUT_SINGLE, PARTY_ACTION_MINIGAME, FALSE, PARTY_MSG_CHOOSE_MON_OR_CANCEL, Task_HandleChooseMonInput, CB2_ReturnToFieldContinueScriptPlayMapMusic); } -u8 GetPartyLayoutFromBattleType(void) +static u8 GetPartyLayoutFromBattleType(void) { if (IsDoubleBattle() == FALSE) return PARTY_LAYOUT_SINGLE; @@ -6034,7 +6036,7 @@ void sub_81279E0(void) UpdatePartyToBattleOrder(); } -u8 GetPartyMenuActionsTypeInBattle(struct Pokemon *mon) +static u8 GetPartyMenuActionsTypeInBattle(struct Pokemon *mon) { if (GetMonData(&gPlayerParty[1], MON_DATA_SPECIES) == SPECIES_NONE || GetMonData(mon, MON_DATA_IS_EGG)) return ACTIONS_SUMMARY_ONLY; @@ -6044,7 +6046,7 @@ u8 GetPartyMenuActionsTypeInBattle(struct Pokemon *mon) return ACTIONS_SHIFT; } -bool8 TrySwitchInPokemon(void) +static bool8 TrySwitchInPokemon(void) { u8 slot = GetCursorSelectionMonId(); u8 newSlot; @@ -6109,7 +6111,7 @@ void BufferBattlePartyCurrentOrder(void) BufferBattlePartyOrder(gBattlePartyCurrentOrder, GetPlayerFlankId()); } -void BufferBattlePartyOrder(u8 *partyBattleOrder, u8 flankId) +static void BufferBattlePartyOrder(u8 *partyBattleOrder, u8 flankId) { u8 partyIds[PARTY_SIZE]; s32 i, j; @@ -6169,7 +6171,7 @@ void BufferBattlePartyCurrentOrderBySide(u8 battlerId, u8 flankId) } // when GetBattlerSide(battlerId) == B_SIDE_PLAYER, this function is identical the one above -void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battlerId) +static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battlerId) { u8 partyIndexes[PARTY_SIZE]; s32 i, j; @@ -6247,7 +6249,7 @@ void SwitchPartyOrderLinkMulti(u8 battlerId, u8 slot, u8 slot2) for (i = j = 0; i < 3; ++j, ++i) { partyIds[j] = partyBattleOrder[i] >> 4; - j++; + ++j; partyIds[j] = partyBattleOrder[i] & 0xF; } partyIdBuffer = partyIds[slot2]; @@ -6270,7 +6272,7 @@ void SwitchPartyOrderLinkMulti(u8 battlerId, u8 slot, u8 slot2) } } -u8 GetPartyIdFromBattleSlot(u8 slot) +static u8 GetPartyIdFromBattleSlot(u8 slot) { u8 modResult = slot & 1; u8 retVal; @@ -6283,7 +6285,7 @@ u8 GetPartyIdFromBattleSlot(u8 slot) return retVal; } -void SetPartyIdAtBattleSlot(u8 slot, u8 setVal) +static void SetPartyIdAtBattleSlot(u8 slot, u8 setVal) { bool32 modResult = slot & 1; @@ -6322,7 +6324,7 @@ u8 GetPartyIdFromBattlePartyId(u8 battlePartyId) return 0; } -void UpdatePartyToBattleOrder(void) +static void UpdatePartyToBattleOrder(void) { struct Pokemon *partyBuffer = Alloc(sizeof(gPlayerParty)); u8 i; @@ -6333,7 +6335,7 @@ void UpdatePartyToBattleOrder(void) Free(partyBuffer); } -void UpdatePartyToFieldOrder(void) +static void UpdatePartyToFieldOrder(void) { struct Pokemon *partyBuffer = Alloc(sizeof(gPlayerParty)); u8 i; @@ -6345,7 +6347,7 @@ void UpdatePartyToFieldOrder(void) } // not used -void SwitchAliveMonIntoLeadSlot(void) +static void SwitchAliveMonIntoLeadSlot(void) { u8 i; struct Pokemon *mon; @@ -6364,7 +6366,7 @@ void SwitchAliveMonIntoLeadSlot(void) } } -void CB2_SetUpExitToBattleScreen(void) +static void CB2_SetUpExitToBattleScreen(void) { CB2_SetUpReshowBattleScreenAfterMenu(); SetMainCallback2(SetCB2ToReshowScreenAfterMenu); @@ -6377,7 +6379,7 @@ void ShowPartyMenuToShowcaseMultiBattleParty(void) #define tXPos data[0] -void Task_InitMultiPartnerPartySlideIn(u8 taskId) +static void Task_InitMultiPartnerPartySlideIn(u8 taskId) { // The first slide step also sets the sprites offscreen gTasks[taskId].tXPos = 256; @@ -6386,7 +6388,7 @@ void Task_InitMultiPartnerPartySlideIn(u8 taskId) gTasks[taskId].func = Task_MultiPartnerPartySlideIn; } -void Task_MultiPartnerPartySlideIn(u8 taskId) +static void Task_MultiPartnerPartySlideIn(u8 taskId) { s16 *data = gTasks[taskId].data; u8 i; @@ -6408,7 +6410,7 @@ void Task_MultiPartnerPartySlideIn(u8 taskId) } } -void Task_WaitAfterMultiPartnerPartySlideIn(u8 taskId) +static void Task_WaitAfterMultiPartnerPartySlideIn(u8 taskId) { s16 *data = gTasks[taskId].data; @@ -6417,13 +6419,13 @@ void Task_WaitAfterMultiPartnerPartySlideIn(u8 taskId) Task_ClosePartyMenu(taskId); } -void MoveMultiPartyMenuBoxSprite(u8 spriteId, s16 x) +static void MoveMultiPartyMenuBoxSprite(u8 spriteId, s16 x) { if (x >= 0) gSprites[spriteId].pos2.x = x; } -void SlideMultiPartyMenuBoxSpritesOneStep(u8 taskId) +static void SlideMultiPartyMenuBoxSpritesOneStep(u8 taskId) { s16 *data = gTasks[taskId].data; u8 i; @@ -6455,14 +6457,14 @@ void ChoosePartyMonByMenuType(u8 menuType) InitPartyMenu(menuType, PARTY_LAYOUT_SINGLE, PARTY_ACTION_CHOOSE_AND_CLOSE, FALSE, PARTY_MSG_CHOOSE_MON, Task_HandleChooseMonInput, CB2_ReturnToField); } -bool8 CB2_FadeFromPartyMenu(void) +static bool8 CB2_FadeFromPartyMenu(void) { sub_807DC00(); CreateTask(Task_PartyMenuWaitForFade, 10); return TRUE; } -void Task_PartyMenuWaitForFade(u8 taskId) +static void Task_PartyMenuWaitForFade(u8 taskId) { if (IsWeatherNotFadingIn()) { -- cgit v1.2.3 From 251b0ee0c41b5c6509b908be2a9c5f8bc526c088 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Sun, 24 Nov 2019 09:28:43 +0800 Subject: resolve change requests --- src/data/pokemon/tutor_learnsets.h | 4032 ++++++++++++++++++------------------ src/list_menu.c | 126 +- src/party_menu.c | 24 +- 3 files changed, 2091 insertions(+), 2091 deletions(-) (limited to 'src') diff --git a/src/data/pokemon/tutor_learnsets.h b/src/data/pokemon/tutor_learnsets.h index afd3814a5..5396c1ecc 100644 --- a/src/data/pokemon/tutor_learnsets.h +++ b/src/data/pokemon/tutor_learnsets.h @@ -24,2790 +24,2790 @@ static const u16 sTutorLearnsets[] = [SPECIES_NONE] = 0, [SPECIES_BULBASAUR] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_IVYSAUR] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VENUSAUR] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CHARMANDER] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CHARMELEON] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CHARIZARD] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SQUIRTLE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WARTORTLE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BLASTOISE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CATERPIE] = 0, [SPECIES_METAPOD] = 0, [SPECIES_BUTTERFREE] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WEEDLE] = 0, [SPECIES_KAKUNA] = 0, [SPECIES_BEEDRILL] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PIDGEY] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PIDGEOTTO] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PIDGEOT] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RATTATA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RATICATE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SPEAROW] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FEAROW] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_EKANS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ARBOK] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PIKACHU] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RAICHU] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SANDSHREW] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SANDSLASH] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NIDORAN_F] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NIDORINA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NIDOQUEEN] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NIDORAN_M] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NIDORINO] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NIDOKING] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CLEFAIRY] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SOFT_BOILED) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CLEFABLE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SOFT_BOILED) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VULPIX] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NINETALES] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_JIGGLYPUFF] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WIGGLYTUFF] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ZUBAT] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GOLBAT] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ODDISH] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GLOOM] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VILEPLUME] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PARAS] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PARASECT] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VENONAT] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VENOMOTH] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DIGLETT] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DUGTRIO] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MEOWTH] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PERSIAN] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PSYDUCK] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GOLDUCK] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MANKEY] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PRIMEAPE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GROWLITHE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ARCANINE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_POLIWAG] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_POLIWHIRL] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_POLIWRATH] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ABRA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KADABRA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ALAKAZAM] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MACHOP] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MACHOKE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MACHAMP] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BELLSPROUT] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WEEPINBELL] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VICTREEBEL] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TENTACOOL] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TENTACRUEL] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GEODUDE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GRAVELER] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GOLEM] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PONYTA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RAPIDASH] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SLOWPOKE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SLOWBRO] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAGNEMITE] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAGNETON] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FARFETCHD] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DODUO] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DODRIO] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SEEL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DEWGONG] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GRIMER] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MUK] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SHELLDER] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CLOYSTER] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GASTLY] = TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HAUNTER] = TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GENGAR] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ONIX] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DROWZEE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HYPNO] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KRABBY] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KINGLER] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VOLTORB] = TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ELECTRODE] = TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_EXEGGCUTE] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_EXEGGUTOR] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CUBONE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAROWAK] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HITMONLEE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HITMONCHAN] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LICKITUNG] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KOFFING] = TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WEEZING] = TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RHYHORN] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RHYDON] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CHANSEY] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SOFT_BOILED) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TANGELA] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KANGASKHAN] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HORSEA] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SEADRA] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GOLDEEN] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SEAKING] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_STARYU] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_STARMIE] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MR_MIME] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SCYTHER] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_JYNX] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ELECTABUZZ] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAGMAR] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PINSIR] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TAUROS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAGIKARP] = 0, [SPECIES_GYARADOS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LAPRAS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DITTO] = 0, [SPECIES_EEVEE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VAPOREON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_JOLTEON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FLAREON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PORYGON] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_OMANYTE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_OMASTAR] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KABUTO] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KABUTOPS] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_AERODACTYL] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SNORLAX] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ARTICUNO] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ZAPDOS] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MOLTRES] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DRATINI] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DRAGONAIR] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DRAGONITE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MEWTWO] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MEW] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SOFT_BOILED) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CHIKORITA] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BAYLEEF] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MEGANIUM] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CYNDAQUIL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_QUILAVA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TYPHLOSION] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TOTODILE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CROCONAW] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FERALIGATR] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SENTRET] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FURRET] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HOOTHOOT] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NOCTOWL] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LEDYBA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LEDIAN] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SPINARAK] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ARIADOS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CROBAT] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CHINCHOU] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LANTURN] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PICHU] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CLEFFA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SOFT_BOILED) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_IGGLYBUFF] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TOGEPI] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SOFT_BOILED) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TOGETIC] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SOFT_BOILED) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NATU] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_XATU] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAREEP] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FLAAFFY] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_AMPHAROS] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BELLOSSOM] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MARILL] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_AZUMARILL] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SUDOWOODO] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_POLITOED] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HOPPIP] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SKIPLOOM] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_JUMPLUFF] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_AIPOM] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SUNKERN] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SUNFLORA] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_YANMA] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WOOPER] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_QUAGSIRE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ESPEON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_UMBREON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MURKROW] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SLOWKING] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MISDREAVUS] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_UNOWN] = 0, [SPECIES_WOBBUFFET] = 0, [SPECIES_GIRAFARIG] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PINECO] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FORRETRESS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DUNSPARCE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GLIGAR] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_STEELIX] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SNUBBULL] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GRANBULL] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_QWILFISH] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SCIZOR] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SHUCKLE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HERACROSS] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SNEASEL] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TEDDIURSA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_URSARING] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SLUGMA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAGCARGO] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SWINUB] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PILOSWINE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CORSOLA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_REMORAID] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_OCTILLERY] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DELIBIRD] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MANTINE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SKARMORY] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HOUNDOUR] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HOUNDOOM] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KINGDRA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PHANPY] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DONPHAN] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PORYGON2] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_STANTLER] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SMEARGLE] = 0, [SPECIES_TYROGUE] = TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HITMONTOP] = TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SMOOCHUM] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ELEKID] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAGBY] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MILTANK] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BLISSEY] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SOFT_BOILED) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SOFT_BOILED) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RAIKOU] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ENTEI] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SUICUNE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LARVITAR] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PUPITAR] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TYRANITAR] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LUGIA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HO_OH] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CELEBI] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TREECKO] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GROVYLE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SCEPTILE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TORCHIC] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_COMBUSKEN] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BLAZIKEN] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MUDKIP] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MARSHTOMP] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SWAMPERT] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_POOCHYENA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MIGHTYENA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ZIGZAGOON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LINOONE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WURMPLE] = 0, [SPECIES_SILCOON] = 0, [SPECIES_BEAUTIFLY] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CASCOON] = 0, [SPECIES_DUSTOX] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LOTAD] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LOMBRE] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LUDICOLO] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SEEDOT] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NUZLEAF] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SHIFTRY] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NINCADA] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NINJASK] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SHEDINJA] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TAILLOW] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SWELLOW] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SHROOMISH] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BRELOOM] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SPINDA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WINGULL] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PELIPPER] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SURSKIT] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MASQUERAIN] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WAILMER] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WAILORD] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SKITTY] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DELCATTY] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KECLEON] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BALTOY] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CLAYDOL] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NOSEPASS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TORKOAL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SABLEYE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BARBOACH] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WHISCASH] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LUVDISC] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CORPHISH] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CRAWDAUNT] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FEEBAS] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MILOTIC] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CARVANHA] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SHARPEDO] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TRAPINCH] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VIBRAVA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_FLYGON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAKUHITA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HARIYAMA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ELECTRIKE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MANECTRIC] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_NUMEL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CAMERUPT] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SPHEAL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SEALEO] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WALREIN] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CACNEA] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CACTURNE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SNORUNT] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GLALIE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LUNATONE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SOLROCK] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_AZURILL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SPOINK] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GRUMPIG] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_PLUSLE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MINUN] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MAWILE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MEDITITE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_MEDICHAM] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SWABLU] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ALTARIA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WYNAUT] = 0, [SPECIES_DUSKULL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DUSCLOPS] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ROSELIA] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SLAKOTH] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VIGOROTH] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SLAKING] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GULPIN] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SWALOT] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_TROPIUS] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_WHISMUR] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LOUDRED] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_EXPLOUD] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CLAMPERL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_HUNTAIL] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GOREBYSS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ABSOL] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SHUPPET] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BANETTE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SEVIPER] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ZANGOOSE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RELICANTH] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ARON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LAIRON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_AGGRON] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CASTFORM] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_VOLBEAT] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ILLUMISE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LILEEP] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CRADILY] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ANORITH] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_ARMALDO] = TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RALTS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KIRLIA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GARDEVOIR] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BAGON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SHELGON] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_SALAMENCE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_BELDUM] = 0, [SPECIES_METANG] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_METAGROSS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_REGIROCK] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_REGICE] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_REGISTEEL] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_EXPLOSION) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_EXPLOSION) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_KYOGRE] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_GROUDON] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_SWORDS_DANCE) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_SWORDS_DANCE) + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_RAYQUAZA] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LATIAS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_LATIOS] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_JIRACHI] = TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_METRONOME) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_METRONOME) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_DEOXYS] = TUTOR(MOVE_MEGA_PUNCH) - | TUTOR(MOVE_MEGA_KICK) - | TUTOR(MOVE_BODY_SLAM) - | TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_COUNTER) - | TUTOR(MOVE_SEISMIC_TOSS) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_THUNDER_WAVE) - | TUTOR(MOVE_ROCK_SLIDE) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MEGA_KICK) + | TUTOR(MOVE_BODY_SLAM) + | TUTOR(MOVE_DOUBLE_EDGE) + | TUTOR(MOVE_COUNTER) + | TUTOR(MOVE_SEISMIC_TOSS) + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_THUNDER_WAVE) + | TUTOR(MOVE_ROCK_SLIDE) + | TUTOR(MOVE_SUBSTITUTE), [SPECIES_CHIMECHO] = TUTOR(MOVE_DOUBLE_EDGE) - | TUTOR(MOVE_MIMIC) - | TUTOR(MOVE_DREAM_EATER) - | TUTOR(MOVE_SUBSTITUTE), + | TUTOR(MOVE_MIMIC) + | TUTOR(MOVE_DREAM_EATER) + | TUTOR(MOVE_SUBSTITUTE), }; diff --git a/src/list_menu.c b/src/list_menu.c index d25eb3faf..484da31ad 100644 --- a/src/list_menu.c +++ b/src/list_menu.c @@ -70,7 +70,7 @@ static EWRAM_DATA struct MysteryGiftLinkMenuStruct sMysteryGiftLinkMenu = {0}; struct ListMenuOverride gListMenuOverride; struct ListMenuTemplate gMultiuseListMenuTemplate; -static u8 ListMenuInitInternal(struct ListMenuTemplate *listMenuTemplate, u16 scrollOffset, u16 selectedRow); +static u8 ListMenuInitInternal(struct ListMenuTemplate *listMenuTemplate, u16 cursorPos, u16 itemsAbove); static bool8 ListMenuChangeSelection(struct ListMenu *list, bool8 updateCursorAndCallCallback, u8 count, bool8 movingDown); static void ListMenuPrintEntries(struct ListMenu *list, u16 startIndex, u16 yOffset, u16 count); static void ListMenuDrawCursor(struct ListMenu *list); @@ -172,18 +172,18 @@ s32 DoMysteryGiftListMenu(const struct WindowTemplate *windowTemplate, const str return LIST_NOTHING_CHOSEN; } -u8 ListMenuInit(struct ListMenuTemplate *listMenuTemplate, u16 scrollOffset, u16 selectedRow) +u8 ListMenuInit(struct ListMenuTemplate *listMenuTemplate, u16 cursorPos, u16 itemsAbove) { - u8 taskId = ListMenuInitInternal(listMenuTemplate, scrollOffset, selectedRow); + u8 taskId = ListMenuInitInternal(listMenuTemplate, cursorPos, itemsAbove); PutWindowTilemap(listMenuTemplate->windowId); CopyWindowToVram(listMenuTemplate->windowId, 2); return taskId; } -u8 ListMenuInitInRect(struct ListMenuTemplate *listMenuTemplate, struct ListMenuWindowRect *rect, u16 scrollOffset, u16 selectedRow) +u8 ListMenuInitInRect(struct ListMenuTemplate *listMenuTemplate, struct ListMenuWindowRect *rect, u16 cursorPos, u16 itemsAbove) { s32 i; - u8 taskId = ListMenuInitInternal(listMenuTemplate, scrollOffset, selectedRow); + u8 taskId = ListMenuInitInternal(listMenuTemplate, cursorPos, itemsAbove); for (i = 0; rect[i].palNum != 0xFF; i++) PutWindowRectTilemapOverridePalette(listMenuTemplate->windowId, rect[i].x, rect[i].y, rect[i].width, rect[i].height, rect[i].palNum); @@ -197,7 +197,7 @@ s32 ListMenu_ProcessInput(u8 listTaskId) if (JOY_NEW(A_BUTTON)) { - return list->template.items[list->scrollOffset + list->selectedRow].index; + return list->template.items[list->cursorPos + list->itemsAbove].index; } else if (JOY_NEW(B_BUTTON)) { @@ -249,14 +249,14 @@ s32 ListMenu_ProcessInput(u8 listTaskId) } } -void DestroyListMenuTask(u8 listTaskId, u16 *scrollOffset, u16 *selectedRow) +void DestroyListMenuTask(u8 listTaskId, u16 *cursorPos, u16 *itemsAbove) { struct ListMenu *list = (struct ListMenu *)gTasks[listTaskId].data; - if (scrollOffset != NULL) - *scrollOffset = list->scrollOffset; - if (selectedRow != NULL) - *selectedRow = list->selectedRow; + if (cursorPos != NULL) + *cursorPos = list->cursorPos; + if (itemsAbove != NULL) + *itemsAbove = list->itemsAbove; if (list->taskId != TASK_NONE) ListMenuRemoveCursorObject(list->taskId, list->template.cursorKind - 2); @@ -269,7 +269,7 @@ void RedrawListMenu(u8 listTaskId) struct ListMenu *list = (struct ListMenu *)gTasks[listTaskId].data; FillWindowPixelBuffer(list->template.windowId, PIXEL_FILL(list->template.fillValue)); - ListMenuPrintEntries(list, list->scrollOffset, 0, list->template.maxShowed); + ListMenuPrintEntries(list, list->cursorPos, 0, list->template.maxShowed); ListMenuDrawCursor(list); CopyWindowToVram(list->template.windowId, 2); } @@ -291,13 +291,13 @@ static void ChangeListMenuCoords(u8 listTaskId, u8 x, u8 y) SetWindowAttribute(list->template.windowId, WINDOW_TILEMAP_TOP, y); } -static s32 ListMenuTestInput(struct ListMenuTemplate *template, u32 scrollOffset, u32 selectedRow, u16 keys, u16 *newScrollOffset, u16 *newSelectedRow) +static s32 ListMenuTestInput(struct ListMenuTemplate *template, u32 cursorPos, u32 itemsAbove, u16 keys, u16 *newCursorPos, u16 *newItemsAbove) { struct ListMenu list; list.template = *template; - list.scrollOffset = scrollOffset; - list.selectedRow = selectedRow; + list.cursorPos = cursorPos; + list.itemsAbove = itemsAbove; list.unk_1C = 0; list.unk_1D = 0; if (keys == DPAD_UP) @@ -305,10 +305,10 @@ static s32 ListMenuTestInput(struct ListMenuTemplate *template, u32 scrollOffset if (keys == DPAD_DOWN) ListMenuChangeSelection(&list, FALSE, 1, TRUE); - if (newScrollOffset != NULL) - *newScrollOffset = list.scrollOffset; - if (newSelectedRow != NULL) - *newSelectedRow = list.selectedRow; + if (newCursorPos != NULL) + *newCursorPos = list.cursorPos; + if (newItemsAbove != NULL) + *newItemsAbove = list.itemsAbove; return LIST_NOTHING_CHOSEN; } @@ -317,17 +317,17 @@ static void ListMenuGetCurrentItemArrayId(u8 listTaskId, u16 *arrayId) struct ListMenu *list = (struct ListMenu *)gTasks[listTaskId].data; if (arrayId != NULL) - *arrayId = list->scrollOffset + list->selectedRow; + *arrayId = list->cursorPos + list->itemsAbove; } -void ListMenuGetScrollAndRow(u8 listTaskId, u16 *scrollOffset, u16 *selectedRow) +void ListMenuGetScrollAndRow(u8 listTaskId, u16 *cursorPos, u16 *itemsAbove) { struct ListMenu *list = (struct ListMenu *)gTasks[listTaskId].data; - if (scrollOffset != NULL) - *scrollOffset = list->scrollOffset; - if (selectedRow != NULL) - *selectedRow = list->selectedRow; + if (cursorPos != NULL) + *cursorPos = list->cursorPos; + if (itemsAbove != NULL) + *itemsAbove = list->itemsAbove; } u16 ListMenuGetYCoordForPrintingArrowCursor(u8 listTaskId) @@ -335,17 +335,17 @@ u16 ListMenuGetYCoordForPrintingArrowCursor(u8 listTaskId) struct ListMenu *list = (struct ListMenu *)gTasks[listTaskId].data; u8 yMultiplier = GetFontAttribute(list->template.fontId, FONTATTR_MAX_LETTER_HEIGHT) + list->template.itemVerticalPadding; - return list->selectedRow * yMultiplier + list->template.upText_Y; + return list->itemsAbove * yMultiplier + list->template.upText_Y; } -static u8 ListMenuInitInternal(struct ListMenuTemplate *listMenuTemplate, u16 scrollOffset, u16 selectedRow) +static u8 ListMenuInitInternal(struct ListMenuTemplate *listMenuTemplate, u16 cursorPos, u16 itemsAbove) { u8 listTaskId = CreateTask(ListMenuDummyTask, 0); struct ListMenu *list = (struct ListMenu *)gTasks[listTaskId].data; list->template = *listMenuTemplate; - list->scrollOffset = scrollOffset; - list->selectedRow = selectedRow; + list->cursorPos = cursorPos; + list->itemsAbove = itemsAbove; list->unk_1C = 0; list->unk_1D = 0; list->taskId = TASK_NONE; @@ -359,7 +359,7 @@ static u8 ListMenuInitInternal(struct ListMenuTemplate *listMenuTemplate, u16 sc if (list->template.totalItems < list->template.maxShowed) list->template.maxShowed = list->template.totalItems; FillWindowPixelBuffer(list->template.windowId, PIXEL_FILL(list->template.fillValue)); - ListMenuPrintEntries(list, list->scrollOffset, 0, list->template.maxShowed); + ListMenuPrintEntries(list, list->cursorPos, 0, list->template.maxShowed); ListMenuDrawCursor(list); ListMenuCallSelectionChangedCallback(list, TRUE); @@ -410,7 +410,7 @@ static void ListMenuDrawCursor(struct ListMenu *list) { u8 yMultiplier = GetFontAttribute(list->template.fontId, FONTATTR_MAX_LETTER_HEIGHT) + list->template.itemVerticalPadding; u8 x = list->template.cursor_X; - u8 y = list->selectedRow * yMultiplier + list->template.upText_Y; + u8 y = list->itemsAbove * yMultiplier + list->template.upText_Y; switch (list->template.cursorKind) { @@ -446,7 +446,7 @@ static u8 ListMenuAddCursorObject(struct ListMenu *list, u32 cursorKind) return ListMenuAddCursorObjectInternal(&cursor, cursorKind); } -static void ListMenuErasePrintedCursor(struct ListMenu *list, u16 selectedRow) +static void ListMenuErasePrintedCursor(struct ListMenu *list, u16 itemsAbove) { u8 cursorKind = list->template.cursorKind; if (cursorKind == 0) @@ -457,7 +457,7 @@ static void ListMenuErasePrintedCursor(struct ListMenu *list, u16 selectedRow) FillWindowPixelRect(list->template.windowId, PIXEL_FILL(list->template.fillValue), list->template.cursor_X, - selectedRow * yMultiplier + list->template.upText_Y, + itemsAbove * yMultiplier + list->template.upText_Y, width, height); } @@ -465,8 +465,8 @@ static void ListMenuErasePrintedCursor(struct ListMenu *list, u16 selectedRow) static u8 ListMenuUpdateSelectedRowIndexAndScrollOffset(struct ListMenu *list, bool8 movingDown) { - u16 selectedRow = list->selectedRow; - u16 scrollOffset = list->scrollOffset; + u16 itemsAbove = list->itemsAbove; + u16 cursorPos = list->cursorPos; u16 newRow; u32 newScroll; @@ -477,14 +477,14 @@ static u8 ListMenuUpdateSelectedRowIndexAndScrollOffset(struct ListMenu *list, b else newRow = list->template.maxShowed - ((list->template.maxShowed / 2) + (list->template.maxShowed % 2)) - 1; - if (scrollOffset == 0) + if (cursorPos == 0) { - while (selectedRow != 0) + while (itemsAbove != 0) { - selectedRow--; - if (list->template.items[scrollOffset + selectedRow].index != LIST_HEADER) + itemsAbove--; + if (list->template.items[cursorPos + itemsAbove].index != LIST_HEADER) { - list->selectedRow = selectedRow; + list->itemsAbove = itemsAbove; return 1; } } @@ -492,16 +492,16 @@ static u8 ListMenuUpdateSelectedRowIndexAndScrollOffset(struct ListMenu *list, b } else { - while (selectedRow > newRow) + while (itemsAbove > newRow) { - selectedRow--; - if (list->template.items[scrollOffset + selectedRow].index != LIST_HEADER) + itemsAbove--; + if (list->template.items[cursorPos + itemsAbove].index != LIST_HEADER) { - list->selectedRow = selectedRow; + list->itemsAbove = itemsAbove; return 1; } } - newScroll = scrollOffset - 1; + newScroll = cursorPos - 1; } } else @@ -511,14 +511,14 @@ static u8 ListMenuUpdateSelectedRowIndexAndScrollOffset(struct ListMenu *list, b else newRow = ((list->template.maxShowed / 2) + (list->template.maxShowed % 2)); - if (scrollOffset == list->template.totalItems - list->template.maxShowed) + if (cursorPos == list->template.totalItems - list->template.maxShowed) { - while (selectedRow < list->template.maxShowed - 1) + while (itemsAbove < list->template.maxShowed - 1) { - selectedRow++; - if (list->template.items[scrollOffset + selectedRow].index != LIST_HEADER) + itemsAbove++; + if (list->template.items[cursorPos + itemsAbove].index != LIST_HEADER) { - list->selectedRow = selectedRow; + list->itemsAbove = itemsAbove; return 1; } } @@ -526,20 +526,20 @@ static u8 ListMenuUpdateSelectedRowIndexAndScrollOffset(struct ListMenu *list, b } else { - while (selectedRow < newRow) + while (itemsAbove < newRow) { - selectedRow++; - if (list->template.items[scrollOffset + selectedRow].index != LIST_HEADER) + itemsAbove++; + if (list->template.items[cursorPos + itemsAbove].index != LIST_HEADER) { - list->selectedRow = selectedRow; + list->itemsAbove = itemsAbove; return 1; } } - newScroll = scrollOffset + 1; + newScroll = cursorPos + 1; } } - list->selectedRow = newRow; - list->scrollOffset = newScroll; + list->itemsAbove = newRow; + list->cursorPos = newScroll; return 2; } @@ -548,7 +548,7 @@ static void ListMenuScroll(struct ListMenu *list, u8 count, bool8 movingDown) if (count >= list->template.maxShowed) { FillWindowPixelBuffer(list->template.windowId, PIXEL_FILL(list->template.fillValue)); - ListMenuPrintEntries(list, list->scrollOffset, 0, list->template.maxShowed); + ListMenuPrintEntries(list, list->cursorPos, 0, list->template.maxShowed); } else { @@ -559,7 +559,7 @@ static void ListMenuScroll(struct ListMenu *list, u8 count, bool8 movingDown) u16 y, width, height; ScrollWindow(list->template.windowId, 1, count * yMultiplier, PIXEL_FILL(list->template.fillValue)); - ListMenuPrintEntries(list, list->scrollOffset, 0, count); + ListMenuPrintEntries(list, list->cursorPos, 0, count); y = (list->template.maxShowed * yMultiplier) + list->template.upText_Y; width = GetWindowAttribute(list->template.windowId, WINDOW_WIDTH) * 8; @@ -573,7 +573,7 @@ static void ListMenuScroll(struct ListMenu *list, u8 count, bool8 movingDown) u16 width; ScrollWindow(list->template.windowId, 0, count * yMultiplier, PIXEL_FILL(list->template.fillValue)); - ListMenuPrintEntries(list, list->scrollOffset + (list->template.maxShowed - count), list->template.maxShowed - count, count); + ListMenuPrintEntries(list, list->cursorPos + (list->template.maxShowed - count), list->template.maxShowed - count, count); width = GetWindowAttribute(list->template.windowId, WINDOW_WIDTH) * 8; FillWindowPixelRect(list->template.windowId, @@ -588,7 +588,7 @@ static bool8 ListMenuChangeSelection(struct ListMenu *list, bool8 updateCursorAn u16 oldSelectedRow; u8 selectionChange, i, cursorCount; - oldSelectedRow = list->selectedRow; + oldSelectedRow = list->itemsAbove; cursorCount = 0; selectionChange = 0; for (i = 0; i < count; i++) @@ -602,7 +602,7 @@ static bool8 ListMenuChangeSelection(struct ListMenu *list, bool8 updateCursorAn break; cursorCount++; } - while (list->template.items[list->scrollOffset + list->selectedRow].index == LIST_HEADER); + while (list->template.items[list->cursorPos + list->itemsAbove].index == LIST_HEADER); } if (updateCursorAndCallCallback) @@ -634,7 +634,7 @@ static bool8 ListMenuChangeSelection(struct ListMenu *list, bool8 updateCursorAn static void ListMenuCallSelectionChangedCallback(struct ListMenu *list, u8 onInit) { if (list->template.moveCursorFunc != NULL) - list->template.moveCursorFunc(list->template.items[list->scrollOffset + list->selectedRow].index, onInit, list); + list->template.moveCursorFunc(list->template.items[list->cursorPos + list->itemsAbove].index, onInit, list); } void ListMenuOverrideSetColors(u8 cursorPal, u8 fillValue, u8 cursorShadowPal) diff --git a/src/party_menu.c b/src/party_menu.c index 6f543ca9c..e981bccf3 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -1159,13 +1159,13 @@ static void HandleChooseMonSelection(u8 taskId, s8 *slotPtr) } else { - switch (gPartyMenu.action - 3) + switch (gPartyMenu.action) { - case PARTY_ACTION_SOFTBOILED - 3: + case PARTY_ACTION_SOFTBOILED: if (IsSelectedMonNotEgg((u8 *)slotPtr)) Task_TryUseSoftboiledOnPartyMon(taskId); break; - case PARTY_ACTION_USE_ITEM - 3: + case PARTY_ACTION_USE_ITEM: if (IsSelectedMonNotEgg((u8 *)slotPtr)) { if (gPartyMenu.menuType == PARTY_MENU_TYPE_IN_BATTLE) @@ -1173,46 +1173,46 @@ static void HandleChooseMonSelection(u8 taskId, s8 *slotPtr) gItemUseCB(taskId, Task_ClosePartyMenuAfterText); } break; - case PARTY_ACTION_MOVE_TUTOR - 3: + case PARTY_ACTION_MOVE_TUTOR: if (IsSelectedMonNotEgg((u8 *)slotPtr)) { PlaySE(SE_SELECT); TryTutorSelectedMon(taskId); } break; - case PARTY_ACTION_GIVE_MAILBOX_MAIL - 3: + case PARTY_ACTION_GIVE_MAILBOX_MAIL: if (IsSelectedMonNotEgg((u8 *)slotPtr)) { PlaySE(SE_SELECT); TryGiveMailToSelectedMon(taskId); } break; - case PARTY_ACTION_GIVE_ITEM - 3: - case PARTY_ACTION_GIVE_PC_ITEM - 3: + case PARTY_ACTION_GIVE_ITEM: + case PARTY_ACTION_GIVE_PC_ITEM: if (IsSelectedMonNotEgg((u8 *)slotPtr)) { PlaySE(SE_SELECT); TryGiveItemOrMailToSelectedMon(taskId); } break; - case PARTY_ACTION_SWITCH - 3: + case PARTY_ACTION_SWITCH: PlaySE(SE_SELECT); SwitchSelectedMons(taskId); break; - case PARTY_ACTION_CHOOSE_AND_CLOSE - 3: + case PARTY_ACTION_CHOOSE_AND_CLOSE: PlaySE(SE_SELECT); gSpecialVar_0x8004 = *slotPtr; if (gPartyMenu.menuType == PARTY_MENU_TYPE_MOVE_RELEARNER) gSpecialVar_0x8005 = GetNumberOfRelearnableMoves(&gPlayerParty[*slotPtr]); Task_ClosePartyMenu(taskId); break; - case PARTY_ACTION_MINIGAME - 3: + case PARTY_ACTION_MINIGAME: if (IsSelectedMonNotEgg((u8 *)slotPtr)) TryEnterMonForMinigame(taskId, (u8)*slotPtr); break; default: - case PARTY_ACTION_ABILITY_PREVENTS - 3: - case PARTY_ACTION_SWITCHING - 3: + case PARTY_ACTION_ABILITY_PREVENTS: + case PARTY_ACTION_SWITCHING: PlaySE(SE_SELECT); Task_TryCreateSelectionWindow(taskId); break; -- cgit v1.2.3 From f80767b40db959d021682fbab18eec17008521e4 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Sun, 24 Nov 2019 14:36:15 +0800 Subject: GetBattleEntryEligibility --- src/party_menu.c | 124 +++++++------------------------------------------------ 1 file changed, 15 insertions(+), 109 deletions(-) (limited to 'src') diff --git a/src/party_menu.c b/src/party_menu.c index e981bccf3..399794b2d 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -5710,7 +5710,6 @@ static u8 GetPartySlotEntryStatus(s8 slot) return 0; } -#ifdef NONMATCHING static bool8 GetBattleEntryEligibility(struct Pokemon *mon) { u16 species; @@ -5721,118 +5720,25 @@ static bool8 GetBattleEntryEligibility(struct Pokemon *mon) switch (gPartyMenu.unk_8_6) { default: - if (GetMonData(mon, MON_DATA_LEVEL) <= 30) - return TRUE; - return FALSE; + if (GetMonData(mon, MON_DATA_LEVEL) > 30) + return FALSE; + break; case 0: - if (GetMonData(mon, MON_DATA_HP) != 0) - return TRUE; - return FALSE; + if (GetMonData(mon, MON_DATA_HP) == 0) + return FALSE; + break; case 1: - if (gSaveBlock2Ptr->battleTower.battleTowerLevelType != 0 // level 100 - || GetMonData(mon, MON_DATA_LEVEL) <= 50) - { - species = GetMonData(mon, MON_DATA_SPECIES); - // Although i is always 0, the compiler still computes the offset of - // gBattleTowerBannedSpecies[i] by shifting i. - // It's also in emerald, but for whatever reason it's generated. - for (; gBattleTowerBannedSpecies[i] != 0xFFFF; ++i) - if (gBattleTowerBannedSpecies[i] == species) - return FALSE; - return TRUE; - } - return FALSE; + if (gSaveBlock2Ptr->battleTower.battleTowerLevelType == 0 // level 50 + && GetMonData(mon, MON_DATA_LEVEL) > 50) + return FALSE; + species = GetMonData(mon, MON_DATA_SPECIES); + for (; gBattleTowerBannedSpecies[i] != 0xFFFF; ++i) + if (gBattleTowerBannedSpecies[i] == species) + return FALSE; + break; } + return TRUE; } -#else -NAKED -static bool8 GetBattleEntryEligibility(struct Pokemon *mon) -{ - asm_unified("push {r4,r5,lr}\n\ - adds r4, r0, 0\n\ - movs r5, 0\n\ - movs r1, 0x2D\n\ - bl GetMonData\n\ - cmp r0, 0\n\ - bne _0812757A\n\ - ldr r0, _08127580 @ =gPartyMenu\n\ - ldrb r0, [r0, 0x8]\n\ - lsrs r1, r0, 6\n\ - cmp r1, 0\n\ - beq _08127584\n\ - cmp r1, 0x1\n\ - beq _08127592\n\ - adds r0, r4, 0\n\ - movs r1, 0x38\n\ - bl GetMonData\n\ - cmp r0, 0x1E\n\ - bls _081275E0\n\ - _0812757A:\n\ - movs r0, 0\n\ - b _081275E2\n\ - .align 2, 0\n\ - _08127580: .4byte gPartyMenu\n\ - _08127584:\n\ - adds r0, r4, 0\n\ - movs r1, 0x39\n\ - bl GetMonData\n\ - cmp r0, 0\n\ - bne _081275E0\n\ - b _0812757A\n\ - _08127592:\n\ - ldr r0, _081275E8 @ =gSaveBlock2Ptr\n\ - ldr r0, [r0]\n\ - ldr r2, _081275EC @ =0x0000055c\n\ - adds r0, r2\n\ - ldrb r0, [r0]\n\ - ands r1, r0\n\ - cmp r1, 0\n\ - bne _081275AE\n\ - adds r0, r4, 0\n\ - movs r1, 0x38\n\ - bl GetMonData\n\ - cmp r0, 0x32\n\ - bhi _0812757A\n\ - _081275AE:\n\ - adds r0, r4, 0\n\ - movs r1, 0xB\n\ - bl GetMonData\n\ - lsls r0, 16\n\ - lsrs r4, r0, 16\n\ - ldr r3, _081275F0 @ =gBattleTowerBannedSpecies\n\ - lsls r1, r5, 1\n\ - adds r0, r1, r3\n\ - ldrh r0, [r0]\n\ - ldr r2, _081275F4 @ =0x0000ffff\n\ - cmp r0, r2\n\ - beq _081275E0\n\ - _081275C8:\n\ - adds r0, r1, r3\n\ - ldrh r0, [r0]\n\ - cmp r0, r4\n\ - beq _0812757A\n\ - adds r0, r5, 0x1\n\ - lsls r0, 16\n\ - lsrs r5, r0, 16\n\ - lsls r1, r5, 1\n\ - adds r0, r1, r3\n\ - ldrh r0, [r0]\n\ - cmp r0, r2\n\ - bne _081275C8\n\ - _081275E0:\n\ - movs r0, 0x1\n\ - _081275E2:\n\ - pop {r4,r5}\n\ - pop {r1}\n\ - bx r1\n\ - .align 2, 0\n\ - _081275E8: .4byte gSaveBlock2Ptr\n\ - _081275EC: .4byte 0x0000055c\n\ - _081275F0: .4byte gBattleTowerBannedSpecies\n\ - _081275F4: .4byte 0x0000ffff\n\ - "); -} -#endif static u8 CheckBattleEntriesAndGetMessage(void) { -- cgit v1.2.3 From 0b547dff4db52a6101d3841450178d4ef3aff724 Mon Sep 17 00:00:00 2001 From: Evan Date: Sat, 30 Nov 2019 11:36:22 -0500 Subject: start decompilation --- src/battle_anim.c | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 src/battle_anim.c (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c new file mode 100644 index 000000000..64f01beb1 --- /dev/null +++ b/src/battle_anim.c @@ -0,0 +1,136 @@ +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "battle_controllers.h" +#include "battle_interface.h" + +// Defines +#define ANIM_SPRITE_INDEX_COUNT 8 + +// RAM +EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; +EWRAM_DATA static const u8 *sBattleAnimScriptRetAddr = NULL; +EWRAM_DATA void (*gAnimScriptCallback)(void) = NULL; +EWRAM_DATA static s8 gAnimFramesToWait = 0; +EWRAM_DATA bool8 gAnimScriptActive = FALSE; +EWRAM_DATA u8 gAnimVisualTaskCount = 0; +EWRAM_DATA u8 gAnimSoundTaskCount = 0; +EWRAM_DATA struct DisableStruct *gAnimDisableStructPtr = NULL; +EWRAM_DATA s32 gAnimMoveDmg = 0; +EWRAM_DATA u16 gAnimMovePower = 0; +EWRAM_DATA static u16 sAnimSpriteIndexArray[ANIM_SPRITE_INDEX_COUNT] = {0}; +EWRAM_DATA u8 gAnimFriendship = 0; +EWRAM_DATA u16 gWeatherMoveAnim = 0; +EWRAM_DATA s16 gBattleAnimArgs[ANIM_ARGS_COUNT] = {0}; +EWRAM_DATA static u16 sSoundAnimFramesToWait = 0; +EWRAM_DATA static u8 sMonAnimTaskIdArray[2] = {0}; +EWRAM_DATA u8 gAnimMoveTurn = 0; +EWRAM_DATA static u8 sAnimBackgroundFadeState = 0; +EWRAM_DATA static u16 sAnimMoveIndex = 0; // Set but unused. +EWRAM_DATA u8 gBattleAnimAttacker = 0; +EWRAM_DATA u8 gBattleAnimTarget = 0; +EWRAM_DATA u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT] = {0}; +EWRAM_DATA u8 gUnknown_2037F24 = 0; + +// Data + +// Function Declarations + + +void ClearBattleAnimationVars(void) +{ + s32 i; + + gAnimFramesToWait = 0; + gAnimScriptActive = FALSE; + gAnimVisualTaskCount = 0; + gAnimSoundTaskCount = 0; + gAnimDisableStructPtr = NULL; + gAnimMoveDmg = 0; + gAnimMovePower = 0; + gAnimFriendship = 0; + + // Clear index array. + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + sAnimSpriteIndexArray[i] |= 0xFFFF; + + // Clear anim args. + for (i = 0; i < ANIM_ARGS_COUNT; i++) + gBattleAnimArgs[i] = 0; + + sMonAnimTaskIdArray[0] = 0xFF; + sMonAnimTaskIdArray[1] = (s8)0xFF; + gAnimMoveTurn = 0; + sAnimBackgroundFadeState = 0; + sAnimMoveIndex = 0; + gBattleAnimAttacker = 0; + gBattleAnimTarget = 0; + gUnknown_2037F24 = 0; +} + +void DoMoveAnim(u16 move) +{ + gBattleAnimAttacker = gBattlerAttacker; + gBattleAnimTarget = gBattlerTarget; + LaunchBattleAnimation(gBattleAnims_Moves, move, TRUE); +} + +void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMoveAnim) +{ + s32 i; + + if (!IsContest()) + { + sub_80A8278(); + UpdateOamPriorityInAllHealthboxes(0); + for (i = 0; i < MAX_BATTLERS_COUNT; i++) + { + if (GetBattlerSide(i) != B_SIDE_PLAYER) + gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + else + gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + } + } + else + { + for (i = 0; i < 4; i++) + gAnimBattlerSpecies[i] = gContestResources->field_18->species; + } + + if (!isMoveAnim) + sAnimMoveIndex = 0; + else + sAnimMoveIndex = tableId; + + for (i = 0; i < ANIM_ARGS_COUNT; i++) + gBattleAnimArgs[i] = 0; + + sMonAnimTaskIdArray[0] = 0xFF; + sMonAnimTaskIdArray[1] = 0xFF; + sBattleAnimScriptPtr = animsTable[tableId]; + gAnimScriptActive = TRUE; + gAnimFramesToWait = 0; + gAnimScriptCallback = RunAnimScriptCommand; + + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + sAnimSpriteIndexArray[i] = 0xFFFF; + + if (isMoveAnim) + { + for (i = 0; gMovesWithQuietBGM[i] != 0xFFFF; i++) + { + if (tableId == gMovesWithQuietBGM[i]) + { + m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 128); + break; + } + } + } + + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + gBattle_WIN1H = 0; + gBattle_WIN1V = 0; +} + + -- cgit v1.2.3 From 4f67dc41a4a4fd0ad3c8b80a142150bc64f554cd Mon Sep 17 00:00:00 2001 From: Evan Date: Sat, 30 Nov 2019 15:09:08 -0500 Subject: port all to c --- src/battle_anim.c | 1599 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1579 insertions(+), 20 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index 64f01beb1..a92cf98de 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -3,6 +3,20 @@ #include "battle_anim.h" #include "battle_controllers.h" #include "battle_interface.h" +#include "bg.h" +#include "contest.h" +#include "decompress.h" +#include "dma3.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "main.h" +#include "m4a.h" +#include "palette.h" +#include "pokemon.h" +#include "sound.h" +#include "sprite.h" +#include "task.h" +#include "constants/battle_anim.h" // Defines #define ANIM_SPRITE_INDEX_COUNT 8 @@ -32,11 +46,114 @@ EWRAM_DATA u8 gBattleAnimTarget = 0; EWRAM_DATA u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA u8 gUnknown_2037F24 = 0; -// Data - // Function Declarations +static void AddSpriteIndex(u16 index); +static void ClearSpriteIndex(u16 index); +static void WaitAnimFrameCount(void); +static void RunAnimScriptCommand(void); +static void ScriptCmd_loadspritegfx(void); +static void ScriptCmd_unloadspritegfx(void); +static void ScriptCmd_createsprite(void); +static void ScriptCmd_createvisualtask(void); +static void ScriptCmd_delay(void); +static void ScriptCmd_waitforvisualfinish(void); +static void ScriptCmd_hang1(void); +static void ScriptCmd_hang2(void); +static void ScriptCmd_end(void); +static void ScriptCmd_playse(void); +static void ScriptCmd_monbg(void); +static void ScriptCmd_clearmonbg(void); +static void ScriptCmd_setalpha(void); +static void ScriptCmd_blendoff(void); +static void ScriptCmd_call(void); +static void ScriptCmd_return(void); +static void ScriptCmd_setarg(void); +static void ScriptCmd_choosetwoturnanim(void); +static void ScriptCmd_jumpifmoveturn(void); +static void ScriptCmd_goto(void); +static void ScriptCmd_fadetobg(void); +static void ScriptCmd_restorebg(void); +static void ScriptCmd_waitbgfadeout(void); +static void ScriptCmd_waitbgfadein(void); +static void ScriptCmd_changebg(void); +static void ScriptCmd_playsewithpan(void); +static void ScriptCmd_setpan(void); +static void ScriptCmd_panse_1B(void); +static void ScriptCmd_loopsewithpan(void); +static void ScriptCmd_waitplaysewithpan(void); +static void ScriptCmd_setbldcnt(void); +static void ScriptCmd_createsoundtask(void); +static void ScriptCmd_waitsound(void); +static void ScriptCmd_jumpargeq(void); +static void ScriptCmd_monbg_22(void); +static void ScriptCmd_clearmonbg_23(void); +static void ScriptCmd_jumpifcontest(void); +static void ScriptCmd_fadetobgfromset(void); +static void ScriptCmd_panse_26(void); +static void ScriptCmd_panse_27(void); +static void ScriptCmd_monbgprio_28(void); +static void ScriptCmd_monbgprio_29(void); +static void ScriptCmd_monbgprio_2A(void); +static void ScriptCmd_invisible(void); +static void ScriptCmd_visible(void); +static void ScriptCmd_doublebattle_2D(void); +static void ScriptCmd_doublebattle_2E(void); +static void ScriptCmd_stopsound(void); +// Data +static void (* const sScriptCmdTable[])(void) = //83ADF5C +{ + ScriptCmd_loadspritegfx, + ScriptCmd_unloadspritegfx, + ScriptCmd_createsprite, + ScriptCmd_createvisualtask, + ScriptCmd_delay, + ScriptCmd_waitforvisualfinish, + ScriptCmd_hang1, + ScriptCmd_hang2, + ScriptCmd_end, + ScriptCmd_playse, + ScriptCmd_monbg, + ScriptCmd_clearmonbg, + ScriptCmd_setalpha, + ScriptCmd_blendoff, + ScriptCmd_call, + ScriptCmd_return, + ScriptCmd_setarg, + ScriptCmd_choosetwoturnanim, + ScriptCmd_jumpifmoveturn, + ScriptCmd_goto, + ScriptCmd_fadetobg, + ScriptCmd_restorebg, + ScriptCmd_waitbgfadeout, + ScriptCmd_waitbgfadein, + ScriptCmd_changebg, + ScriptCmd_playsewithpan, + ScriptCmd_setpan, + ScriptCmd_panse_1B, + ScriptCmd_loopsewithpan, + ScriptCmd_waitplaysewithpan, + ScriptCmd_setbldcnt, + ScriptCmd_createsoundtask, + ScriptCmd_waitsound, + ScriptCmd_jumpargeq, + ScriptCmd_monbg_22, + ScriptCmd_clearmonbg_23, + ScriptCmd_jumpifcontest, + ScriptCmd_fadetobgfromset, + ScriptCmd_panse_26, + ScriptCmd_panse_27, + ScriptCmd_monbgprio_28, + ScriptCmd_monbgprio_29, + ScriptCmd_monbgprio_2A, + ScriptCmd_invisible, + ScriptCmd_visible, + ScriptCmd_doublebattle_2D, + ScriptCmd_doublebattle_2E, + ScriptCmd_stopsound +}; +// Functions void ClearBattleAnimationVars(void) { s32 i; @@ -79,23 +196,15 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo { s32 i; - if (!IsContest()) - { - sub_80A8278(); - UpdateOamPriorityInAllHealthboxes(0); - for (i = 0; i < MAX_BATTLERS_COUNT; i++) - { - if (GetBattlerSide(i) != B_SIDE_PLAYER) - gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); - else - gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); - } - } - else - { - for (i = 0; i < 4; i++) - gAnimBattlerSpecies[i] = gContestResources->field_18->species; - } + sub_80767F0(); + UpdateOamPriorityInAllHealthboxes(0); + for (i = 0; i < MAX_BATTLERS_COUNT; i++) + { + if (GetBattlerSide(i) != B_SIDE_PLAYER) + gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + else + gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + } if (!isMoveAnim) sAnimMoveIndex = 0; @@ -106,7 +215,7 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo gBattleAnimArgs[i] = 0; sMonAnimTaskIdArray[0] = 0xFF; - sMonAnimTaskIdArray[1] = 0xFF; + sMonAnimTaskIdArray[1] = (s8)-1; sBattleAnimScriptPtr = animsTable[tableId]; gAnimScriptActive = TRUE; gAnimFramesToWait = 0; @@ -133,4 +242,1454 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo gBattle_WIN1V = 0; } +void DestroyAnimSprite(struct Sprite *sprite) +{ + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); + gAnimVisualTaskCount--; +} + +void DestroyAnimVisualTask(u8 taskId) +{ + DestroyTask(taskId); + gAnimVisualTaskCount--; +} + +void DestroyAnimSoundTask(u8 taskId) +{ + DestroyTask(taskId); + gAnimSoundTaskCount--; +} + +static void AddSpriteIndex(u16 index) +{ + s32 i; + + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + { + if (sAnimSpriteIndexArray[i] == 0xFFFF) + { + sAnimSpriteIndexArray[i] = index; + return; + } + } +} + +static void ClearSpriteIndex(u16 index) +{ + s32 i; + + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + { + if (sAnimSpriteIndexArray[i] == index) + { + sAnimSpriteIndexArray[i] = 0xFFFF; + return; + } + } +} + +static void WaitAnimFrameCount(void) +{ + if (gAnimFramesToWait <= 0) + { + gAnimScriptCallback = RunAnimScriptCommand; + gAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait--; + } +} + +static void RunAnimScriptCommand(void) +{ + do + { + sScriptCmdTable[sBattleAnimScriptPtr[0]](); + } while (gAnimFramesToWait == 0 && gAnimScriptActive); +} + +static void ScriptCmd_loadspritegfx(void) +{ + u16 index; + + sBattleAnimScriptPtr++; + index = T1_READ_16(sBattleAnimScriptPtr); + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(index)]); + sBattleAnimScriptPtr += 2; + AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); + gAnimFramesToWait = 1; + gAnimScriptCallback = WaitAnimFrameCount; +} + +static void ScriptCmd_unloadspritegfx(void) +{ + u16 index; + + sBattleAnimScriptPtr++; + index = T1_READ_16(sBattleAnimScriptPtr); + FreeSpriteTilesByTag(gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)].tag); + FreeSpritePaletteByTag(gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)].tag); + sBattleAnimScriptPtr += 2; + ClearSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); +} + +static void ScriptCmd_createsprite(void) +{ + s32 i; + const struct SpriteTemplate *template; + u8 argVar; + u8 argsCount; + s16 subpriority; + + sBattleAnimScriptPtr++; + template = (const struct SpriteTemplate *)(T2_READ_32(sBattleAnimScriptPtr)); + sBattleAnimScriptPtr += 4; + + argVar = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + + argsCount = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + for (i = 0; i < argsCount; i++) + { + gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 2; + } + + if (argVar & 0x80) + { + argVar ^= 0x80; + if (argVar >= 0x40) + argVar -= 0x40; + else + argVar *= -1; + + subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + (s8)(argVar); + } + else + { + if (argVar >= 0x40) + argVar -= 0x40; + else + argVar *= -1; + + subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) + (s8)(argVar); + } + + if (subpriority < 3) + subpriority = 3; + + CreateSpriteAndAnimate( + template, + GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2), + GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET), + subpriority); + gAnimVisualTaskCount++; +} + +static void ScriptCmd_createvisualtask(void) +{ + TaskFunc taskFunc; + u8 taskPriority; + u8 taskId; + u8 numArgs; + s32 i; + + sBattleAnimScriptPtr++; + + taskFunc = (TaskFunc)T2_READ_32(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 4; + + taskPriority = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + + numArgs = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + + for (i = 0; i < numArgs; i++) + { + gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 2; + } + + taskId = CreateTask(taskFunc, taskPriority); + taskFunc(taskId); + gAnimVisualTaskCount++; +} + +static void ScriptCmd_delay(void) +{ + sBattleAnimScriptPtr++; + gAnimFramesToWait = sBattleAnimScriptPtr[0]; + if (gAnimFramesToWait == 0) + gAnimFramesToWait = -1; + sBattleAnimScriptPtr++; + gAnimScriptCallback = WaitAnimFrameCount; +} + +// Wait for visual tasks to finish. +static void ScriptCmd_waitforvisualfinish(void) +{ + if (gAnimVisualTaskCount == 0) + { + sBattleAnimScriptPtr++; + gAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait = 1; + } +} + +static void ScriptCmd_end(void) +{ + s32 i; + bool32 continuousAnim = FALSE; + + // Keep waiting as long as there are animations to be done. + if (gAnimVisualTaskCount != 0 || gAnimSoundTaskCount != 0 + || sMonAnimTaskIdArray[0] != 0xFF || sMonAnimTaskIdArray[1] != 0xFF) + { + sSoundAnimFramesToWait = 0; + gAnimFramesToWait = 1; + return; + } + + // Finish the sound effects. + if (IsSEPlaying()) + { + if (++sSoundAnimFramesToWait <= 90) // Wait 90 frames, then halt the sound effect. + { + gAnimFramesToWait = 1; + return; + } + else + { + m4aMPlayStop(&gMPlayInfo_SE1); + m4aMPlayStop(&gMPlayInfo_SE2); + } + } + + // The SE has halted, so set the SE Frame Counter to 0 and continue. + sSoundAnimFramesToWait = 0; + + for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) + { + if (sAnimSpriteIndexArray[i] != 0xFFFF) + { + FreeSpriteTilesByTag(gBattleAnimPicTable[sAnimSpriteIndexArray[i]].tag); + FreeSpritePaletteByTag(gBattleAnimPicTable[sAnimSpriteIndexArray[i]].tag); + sAnimSpriteIndexArray[i] = 0xFFFF; // set terminator. + } + } + + if (!continuousAnim) // May have been used for debug? + { + m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256); + if (!IsContest()) + { + sub_80A8278(); + UpdateOamPriorityInAllHealthboxes(1); + } + gAnimScriptActive = FALSE; + } +} + +static void ScriptCmd_playse(void) +{ + sBattleAnimScriptPtr++; + PlaySE(T1_READ_16(sBattleAnimScriptPtr)); + sBattleAnimScriptPtr += 2; +} + +#define t1_MONBG_BATTLER 0 +#define t1_MON_IN_BG2 1 +#define t1_CREATE_ANOTHER_TASK 2 +#define t1_IS_SECONDMON_BG 3 + +#define t2_BATTLER_SPRITE_ID 0 +#define t2_MON_IN_BG2 5 +#define t2_MONBG_BATTLER 6 + +static void ScriptCmd_monbg(void) +{ + bool8 toBG_2; + u8 taskId; + u8 battlerId; + u8 animBattler; + + sBattleAnimScriptPtr++; + + animBattler = sBattleAnimScriptPtr[0]; + if (animBattler & ANIM_TARGET) + battlerId = gBattleAnimTarget; + else + battlerId = gBattleAnimAttacker; + + if (IsBattlerSpriteVisible(battlerId)) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + + MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); + gAnimVisualTaskCount++; + gTasks[taskId].data[t1_MONBG_BATTLER] = battlerId; + gTasks[taskId].data[t1_MON_IN_BG2] = toBG_2; + gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE; + gTasks[taskId].data[t1_IS_SECONDMON_BG] = 0; + + } + + battlerId ^= BIT_FLANK; + if (IsBattlerSpriteVisible(battlerId)) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + + MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); + gAnimVisualTaskCount++; + gTasks[taskId].data[0] = battlerId; + gTasks[taskId].data[1] = toBG_2; + gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE; + gTasks[taskId].data[t1_IS_SECONDMON_BG] = 1; + } + + sBattleAnimScriptPtr++; + gAnimFramesToWait = 1; + gAnimScriptCallback = WaitAnimFrameCount; +} + +bool8 IsBattlerSpriteVisible(u8 battlerId) +{ + if (!IsBattlerSpritePresent(battlerId)) + return FALSE; + + if (!gBattleSpritesDataPtr->battlerData[battlerId].invisible || !gSprites[gBattlerSpriteIds[battlerId]].invisible) + return TRUE; + + return FALSE; +} + +void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) +{ + struct BattleAnimBgData animBg; + u8 battlerSpriteId; + + if (!toBG_2) + { + u8 battlerPosition; + + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(16)), 0x2000, 1); + RequestDma3Fill(0xFF, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 0); + sub_80752A0(&animBg); + CpuFill16(0, animBg.bgTiles, 0x1000); + CpuFill16(0xFF, animBg.bgTilemap, 0x800); + + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 2); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 1); + SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0); + + battlerSpriteId = gBattlerSpriteIds[battlerId]; + + SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); + SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); + + LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], animBg.paletteId * 16, 0x20); + CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + animBg.paletteId * 32), 0x20); + + battlerPosition = GetBattlerPosition(battlerId); + + sub_80BCEF4(1, 0, 0, battlerPosition, animBg.paletteId, animBg.bgTiles, animBg.bgTilemap, animBg.tilesOffset); + } + else + { + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(12)), 0x2000, 1); + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 1); + sub_80752C8(&animBg, 2); + CpuFill16(0, animBg.bgTiles + 0x1000, 0x1000); + CpuFill16(0, animBg.bgTilemap + 0x400, 0x800); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); + SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1); + SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0); + + battlerSpriteId = gBattlerSpriteIds[battlerId]; + + gBattle_BG2_X = -(gSprites[battlerSpriteId].pos1.x + gSprites[battlerSpriteId].pos2.x) + 0x20; + gBattle_BG2_Y = -(gSprites[battlerSpriteId].pos1.y + gSprites[battlerSpriteId].pos2.y) + 0x20; + + SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X); + SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y); + + LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], 0x90, 0x20); + CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + 0x120), 0x20); + + sub_80BCEF4(2, 0, 0, GetBattlerPosition(battlerId), animBg.paletteId, animBg.bgTiles + 0x1000, animBg.bgTilemap + 0x400, animBg.tilesOffset); + } +} + +void sub_80730C0(u16 a, u16 *b, u32 c, u8 d) +{ + s32 i, j; + s32 var; + + if (d == 0) + var = 32; + else + var = 64; + a <<= 12; + for (i = 0; i < var; i++) + { + for (j = 0; j < 32; j++) + b[j + i * 32] = ((b[j + i * 32] & 0xFFF) | a) + c; + } +} + +void sub_8073128(bool8 to_BG2) +{ + struct BattleAnimBgData animBg; + sub_80752A0(&animBg); + + if (!to_BG2)) + { + sub_8075358(1); + gBattle_BG1_X = NULL; + gBattle_BG1_Y = NULL; + } + else + { + sub_8075358(2); + gBattle_BG2_X = NULL; + gBattle_BG2_Y = NULL; + } +} + +static void task_pA_ma0A_obj_to_bg_pal(u8 taskId) +{ + u8 spriteId, palIndex; + s16 x, y; + struct BattleAnimBgData animBg; + + spriteId = gTasks[taskId].data[0]; + palIndex = gTasks[taskId].data[6]; + sub_80752A0(&animBg); + x = gTasks[taskId].data[1] - (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x); + y = gTasks[taskId].data[2] - (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y); + + if (gTasks[taskId].data[5] == 0) + { + u16 *src; + u16 *dst; + + gBattle_BG1_X = x + gTasks[taskId].data[3]; + gBattle_BG1_Y = y + gTasks[taskId].data[4]; + src = gPlttBufferFaded + 0x100 + palIndex * 16; + dst = gPlttBufferFaded + 0x100 + animBg.paletteId * 16 - 256; + CpuCopy32(src, dst, 0x20); + } + else + { + u16 *src; + u16 *dst; + + gBattle_BG2_X = x + gTasks[taskId].data[3]; + gBattle_BG2_Y = y + gTasks[taskId].data[4]; + src = gPlttBufferFaded + 0x100 + palIndex * 16; + dst = gPlttBufferFaded + 0x100 - 112; + CpuCopy32(src, dst, 0x20); + } +} + +static void ScriptCmd_clearmonbg(void) +{ + u8 animBattlerId; + u8 battlerId; + u8 taskId; + + sBattleAnimScriptPtr++; + animBattlerId = sBattleAnimScriptPtr[0]; + + if (animBattlerId == ANIM_ATTACKER) + animBattlerId = ANIM_ATK_PARTNER; + else if (animBattlerId == ANIM_TARGET) + animBattlerId = ANIM_DEF_PARTNER; + + if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + battlerId = gBattleAnimAttacker; + else + battlerId = gBattleAnimTarget; + + if (sMonAnimTaskIdArray[0] != 0xFF) + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; + if (animBattlerId > 1 && sMonAnimTaskIdArray[1] != 0xFF) + gSprites[gBattlerSpriteIds[battlerId ^ BIT_FLANK]].invisible = FALSE; + else + animBattlerId = 0; + + taskId = CreateTask(sub_807331C, 5); + gTasks[taskId].data[0] = animBattlerId; + gTasks[taskId].data[2] = battlerId; + + sBattleAnimScriptPtr++; +} + +static void sub_807331C(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] != 1) + { + u8 to_BG2; + u8 position = GetBattlerPosition(gTasks[taskId].data[2]); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + to_BG2 = FALSE; + else + to_BG2 = TRUE; + + if (sMonAnimTaskIdArray[0] != 0xFF) + { + sub_8073128(to_BG2); + DestroyTask(sMonAnimTaskIdArray[0]); + sMonAnimTaskIdArray[0] = 0xFF; + } + if (gTasks[taskId].data[0] > 1) + { + sub_8073128(to_BG2 ^ 1); + DestroyTask(sMonAnimTaskIdArray[1]); + sMonAnimTaskIdArray[1] = 0xFF; + } + DestroyTask(taskId); + } +} + +static void ScriptCmd_monbg_22(void) +{ + bool8 toBG_2; + u8 battlerId; + u8 animBattlerId; + + sBattleAnimScriptPtr++; + + animBattlerId = sBattleAnimScriptPtr[0]; + + if (animBattlerId == ANIM_ATTACKER) + animBattlerId = ANIM_ATK_PARTNER; + else if (animBattlerId == ANIM_TARGET) + animBattlerId = ANIM_DEF_PARTNER; + + if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + battlerId = gBattleAnimAttacker; + else + battlerId = gBattleAnimTarget; + + if (IsBattlerSpriteVisible(battlerId)) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + + MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + } + + battlerId ^= BIT_FLANK; + if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId)) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + + MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + } + + sBattleAnimScriptPtr++; +} + +static void ScriptCmd_clearmonbg_23(void) +{ + u8 animBattlerId; + u8 battlerId; + u8 taskId; + + sBattleAnimScriptPtr++; + animBattlerId = sBattleAnimScriptPtr[0]; + + if (animBattlerId == ANIM_ATTACKER) + animBattlerId = ANIM_ATK_PARTNER; + else if (animBattlerId == ANIM_TARGET) + animBattlerId = ANIM_DEF_PARTNER; + + if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + battlerId = gBattleAnimAttacker; + else + battlerId = gBattleAnimTarget; + + if (IsBattlerSpriteVisible(battlerId)) + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; + if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) + gSprites[gBattlerSpriteIds[battlerId ^ BIT_FLANK]].invisible = FALSE; + else + animBattlerId = 0; + + taskId = CreateTask(sub_8073558, 5); + gTasks[taskId].data[0] = animBattlerId; + gTasks[taskId].data[2] = battlerId; + + sBattleAnimScriptPtr++; +} + +static void sub_8073558(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] != 1) + { + bool8 toBG_2; + u8 battlerId = gTasks[taskId].data[2]; + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = FALSE; + else + toBG_2 = TRUE; + if (IsBattlerSpriteVisible(battlerId)) + sub_8073128(toBG_2); + if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) + sub_8073128(toBG_2 ^ 1); + + DestroyTask(taskId); + } +} + +#undef t1_MONBG_BATTLER +#undef t1_MON_IN_BG2 +#undef t1_CREATE_ANOTHER_TASK +#undef t1_IS_SECONDMON_BG + +#undef t2_BATTLER_SPRITE_ID +#undef t2_MON_IN_BG2 +#undef t2_MONBG_BATTLER + +static void ScriptCmd_setalpha(void) +{ + u16 half1, half2; + + sBattleAnimScriptPtr++; + half1 = *(sBattleAnimScriptPtr++); + half2 = *(sBattleAnimScriptPtr++) << 8; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, half1 | half2); +} + +static void ScriptCmd_setbldcnt(void) +{ + u16 half1, half2; + + sBattleAnimScriptPtr++; + half1 = *(sBattleAnimScriptPtr++); + half2 = *(sBattleAnimScriptPtr++) << 8; + SetGpuReg(REG_OFFSET_BLDCNT, half1 | half2); +} + +static void ScriptCmd_blendoff(void) +{ + sBattleAnimScriptPtr++; + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); +} + +static void ScriptCmd_call(void) +{ + sBattleAnimScriptPtr++; + sBattleAnimScriptRetAddr = sBattleAnimScriptPtr + 4; + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); +} + +static void ScriptCmd_return(void) +{ + sBattleAnimScriptPtr = sBattleAnimScriptRetAddr; +} + +static void ScriptCmd_setarg(void) +{ + const u8 *addr = sBattleAnimScriptPtr; + u16 value; + u8 argId; + + sBattleAnimScriptPtr++; + argId = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + value = T1_READ_16(sBattleAnimScriptPtr); + sBattleAnimScriptPtr = addr + 4; + gBattleAnimArgs[argId] = value; +} + +static void ScriptCmd_choosetwoturnanim(void) +{ + sBattleAnimScriptPtr++; + if (gAnimMoveTurn & 1) + sBattleAnimScriptPtr += 4; + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); +} + +static void ScriptCmd_jumpifmoveturn(void) +{ + u8 toCheck; + sBattleAnimScriptPtr++; + toCheck = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + + if (toCheck == gAnimMoveTurn) + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); + else + sBattleAnimScriptPtr += 4; +} + +static void ScriptCmd_goto(void) +{ + sBattleAnimScriptPtr++; + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); +} + +//unused +bool8 IsContest(void) +{ + if (!gMain.inBattle) + return TRUE; + else + return FALSE; +} + +#define tBackgroundId data[0] +#define tState data[10] + +static void ScriptCmd_fadetobg(void) +{ + u8 backgroundId; + u8 taskId; + + sBattleAnimScriptPtr++; + backgroundId = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + taskId = CreateTask(Task_FadeToBg, 5); + gTasks[taskId].tBackgroundId = backgroundId; + sAnimBackgroundFadeState = 1; +} + +static void ScriptCmd_fadetobgfromset(void) +{ + u8 bg1, bg2, bg3; + u8 taskId; + + sBattleAnimScriptPtr++; + bg1 = sBattleAnimScriptPtr[0]; + bg2 = sBattleAnimScriptPtr[1]; + bg3 = sBattleAnimScriptPtr[2]; + sBattleAnimScriptPtr += 3; + taskId = CreateTask(Task_FadeToBg, 5); + + if (IsContest()) + gTasks[taskId].tBackgroundId = bg3; + else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + gTasks[taskId].tBackgroundId = bg2; + else + gTasks[taskId].tBackgroundId = bg1; + + sAnimBackgroundFadeState = 1; +} + +static void Task_FadeToBg(u8 taskId) +{ + if (gTasks[taskId].tState == 0) + { + BeginHardwarePaletteFade(0xE8, 0, 0, 16, 0); + gTasks[taskId].tState++; + return; + } + if (gPaletteFade.active) + return; + if (gTasks[taskId].tState == 1) + { + gTasks[taskId].tState++; + sAnimBackgroundFadeState = 2; + } + else if (gTasks[taskId].tState == 2) + { + s16 bgId = gTasks[taskId].tBackgroundId; + + if (bgId == -1) + LoadDefaultBg(); + else + LoadMoveBg(bgId); + + BeginHardwarePaletteFade(0xE8, 0, 16, 0, 1); + gTasks[taskId].tState++; + return; + } + if (gPaletteFade.active) + return; + if (gTasks[taskId].tState == 3) + { + DestroyTask(taskId); + sAnimBackgroundFadeState = 0; + } +} + +static void LoadMoveBg(u16 bgId) +{ + if (IsContest()) + { + const u32 *tilemap = gBattleAnimBackgroundTable[bgId].tilemap; + void *dmaSrc; + void *dmaDest; + + LZDecompressWram(tilemap, gDecompressionBuffer); + sub_80730C0(sub_80A6D94(), (void*)(gDecompressionBuffer), 0x100, 0); + dmaSrc = gDecompressionBuffer; + dmaDest = (void *)(BG_SCREEN_ADDR(26)); + DmaCopy32(3, dmaSrc, dmaDest, 0x800); + LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_SCREEN_ADDR(4))); + LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, sub_80A6D94() * 16, 32); + } + else + { + LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26))); + LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2))); + LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32); + } +} + +static void LoadDefaultBg(void) +{ + if (IsContest()) + LoadContestBgAfterMoveAnim(); + else + DrawMainBattleBackground(); +} + +static void ScriptCmd_restorebg(void) +{ + u8 taskId; + + sBattleAnimScriptPtr++; + taskId = CreateTask(Task_FadeToBg, 5); + gTasks[taskId].tBackgroundId = -1; + sAnimBackgroundFadeState = 1; +} + +#undef tBackgroundId +#undef tState + +static void ScriptCmd_waitbgfadeout(void) +{ + if (sAnimBackgroundFadeState == 2) + { + sBattleAnimScriptPtr++; + gAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait = 1; + } +} + +static void ScriptCmd_waitbgfadein(void) +{ + if (sAnimBackgroundFadeState == 0) + { + sBattleAnimScriptPtr++; + gAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait = 1; + } +} + +static void ScriptCmd_changebg(void) +{ + sBattleAnimScriptPtr++; + LoadMoveBg(sBattleAnimScriptPtr[0]); + sBattleAnimScriptPtr++; +} + +s8 BattleAnimAdjustPanning(s8 pan) +{ + if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + pan = SOUND_PAN_TARGET; + else + pan = SOUND_PAN_ATTACKER; + } + else if (IsContest()) + { + if (gBattleAnimAttacker != gBattleAnimTarget || gBattleAnimAttacker != 2 || pan != SOUND_PAN_TARGET) + pan *= -1; + } + else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + if (pan == SOUND_PAN_TARGET) + pan = SOUND_PAN_ATTACKER; + else if (pan != SOUND_PAN_ATTACKER) + pan *= -1; + } + } + else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) + { + if (pan == SOUND_PAN_ATTACKER) + pan = SOUND_PAN_TARGET; + } + else + { + pan *= -1; + } + + if (pan > SOUND_PAN_TARGET) + pan = SOUND_PAN_TARGET; + else if (pan < SOUND_PAN_ATTACKER) + pan = SOUND_PAN_ATTACKER; + + return pan; +} + +s8 BattleAnimAdjustPanning2(s8 pan) +{ + if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + pan = SOUND_PAN_TARGET; + else + pan = SOUND_PAN_ATTACKER; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER || IsContest()) + pan = -pan; + } + return pan; +} + +s16 KeepPanInRange(s16 panArg, int oldPan) +{ + s16 pan = panArg; + + if (pan > SOUND_PAN_TARGET) + pan = SOUND_PAN_TARGET; + else if (pan < SOUND_PAN_ATTACKER) + pan = SOUND_PAN_ATTACKER; + + return pan; +} + +s16 CalculatePanIncrement(s16 sourcePan, s16 targetPan, s16 incrementPan) +{ + s16 ret; + + if (sourcePan < targetPan) + ret = ((incrementPan < 0) ? -incrementPan : incrementPan); + else if (sourcePan > targetPan) + ret = -((incrementPan < 0) ? -incrementPan : incrementPan); + else + ret = 0; + + return ret; +} + +static void ScriptCmd_playsewithpan(void) +{ + u16 songId; + s8 pan; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + pan = sBattleAnimScriptPtr[2]; + PlaySE12WithPanning(songId, BattleAnimAdjustPanning(pan)); + sBattleAnimScriptPtr += 3; +} + +static void ScriptCmd_setpan(void) +{ + s8 pan; + + sBattleAnimScriptPtr++; + pan = sBattleAnimScriptPtr[0]; + SE12PanpotControl(BattleAnimAdjustPanning(pan)); + sBattleAnimScriptPtr++; +} + +#define tInitialPan data[0] +#define tTargetPan data[1] +#define tIncrementPan data[2] +#define tFramesToWait data[3] +#define tCurrentPan data[4] +#define tFrameCounter data[8] + +static void ScriptCmd_panse_1B(void) +{ + u16 songNum; + s8 currentPanArg, incrementPan, incrementPanArg, currentPan, targetPan; + u8 framesToWait; + u8 taskId; + + sBattleAnimScriptPtr++; + songNum = T1_READ_16(sBattleAnimScriptPtr); + currentPanArg = sBattleAnimScriptPtr[2]; + incrementPan = sBattleAnimScriptPtr[3]; + incrementPanArg = sBattleAnimScriptPtr[4]; + framesToWait = sBattleAnimScriptPtr[5]; + + currentPan = BattleAnimAdjustPanning(currentPanArg); + targetPan = BattleAnimAdjustPanning(incrementPan); + incrementPan = CalculatePanIncrement(currentPan, targetPan, incrementPanArg); + taskId = CreateTask(Task_PanFromInitialToTarget, 1); + gTasks[taskId].tInitialPan = currentPan; + gTasks[taskId].tTargetPan = targetPan; + gTasks[taskId].tIncrementPan = incrementPan; + gTasks[taskId].tFramesToWait = framesToWait; + gTasks[taskId].tCurrentPan = currentPan; + + PlaySE12WithPanning(songNum, currentPan); + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 6; +} + +void Task_PanFromInitialToTarget(u8 taskId) +{ + bool32 destroyTask = FALSE; + if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait) + { + s16 pan; + s16 initialPanning, targetPanning, currentPan, incrementPan; + + gTasks[taskId].tFrameCounter = 0; + initialPanning = gTasks[taskId].tInitialPan; + targetPanning = gTasks[taskId].tTargetPan; + currentPan = gTasks[taskId].tCurrentPan; + incrementPan = gTasks[taskId].tIncrementPan; + pan = currentPan + incrementPan; + gTasks[taskId].tCurrentPan = pan; + + if (incrementPan == 0) // If we're not incrementing, just cancel the task immediately. + { + destroyTask = TRUE; + } + else if (initialPanning < targetPanning) // Panning increasing. + { + if (pan >= targetPanning) // Target reached. + destroyTask = TRUE; + } + else // Panning decreasing. + { + if (pan <= targetPanning) // Target reached. + destroyTask = TRUE; + } + + if (destroyTask) + { + pan = targetPanning; + DestroyTask(taskId); + gAnimSoundTaskCount--; + } + + SE12PanpotControl(pan); + } +} + +static void ScriptCmd_panse_26(void) +{ + u16 songId; + s8 currentPan, targetPan, incrementPan; + u8 framesToWait; + u8 taskId; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + currentPan = sBattleAnimScriptPtr[2]; + targetPan = sBattleAnimScriptPtr[3]; + incrementPan = sBattleAnimScriptPtr[4]; + framesToWait = sBattleAnimScriptPtr[5]; + + taskId = CreateTask(Task_PanFromInitialToTarget, 1); + gTasks[taskId].tInitialPan = currentPan; + gTasks[taskId].tTargetPan = targetPan; + gTasks[taskId].tIncrementPan = incrementPan; + gTasks[taskId].tFramesToWait = framesToWait; + gTasks[taskId].tCurrentPan = currentPan; + + PlaySE12WithPanning(songId, currentPan); + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 6; +} + +static void ScriptCmd_panse_27(void) +{ + u16 songId; + s8 targetPanArg, incrementPanArg, currentPanArg, currentPan, targetPan, incrementPan; + u8 framesToWait; + u8 taskId; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + currentPanArg = sBattleAnimScriptPtr[2]; + targetPanArg = sBattleAnimScriptPtr[3]; + incrementPanArg = sBattleAnimScriptPtr[4]; + framesToWait = sBattleAnimScriptPtr[5]; + + currentPan = BattleAnimAdjustPanning2(currentPanArg); + targetPan = BattleAnimAdjustPanning2(targetPanArg); + incrementPan = BattleAnimAdjustPanning2(incrementPanArg); + + taskId = CreateTask(Task_PanFromInitialToTarget, 1); + gTasks[taskId].tInitialPan = currentPan; + gTasks[taskId].tTargetPan = targetPan; + gTasks[taskId].tIncrementPan = incrementPan; + gTasks[taskId].tFramesToWait = framesToWait; + gTasks[taskId].tCurrentPan = currentPan; + + PlaySE12WithPanning(songId, currentPan); + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 6; +} + +#undef tInitialPan +#undef tTargetPan +#undef tIncrementPan +#undef tFramesToWait +#undef tCurrentPan +#undef tFrameCounter + +#define tSongId data[0] +#define tPanning data[1] +#define tFramesToWait data[2] +#define tNumberOfPlays data[3] +#define tFrameCounter data[8] + +static void ScriptCmd_loopsewithpan(void) +{ + u16 songId; + s8 panningArg, panning; + u8 framesToWait, numberOfPlays; + u8 taskId; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + panningArg = sBattleAnimScriptPtr[2]; + framesToWait = sBattleAnimScriptPtr[3]; + numberOfPlays = sBattleAnimScriptPtr[4]; + panning = BattleAnimAdjustPanning(panningArg); + + taskId = CreateTask(Task_LoopAndPlaySE, 1); + gTasks[taskId].tSongId = songId; + gTasks[taskId].tPanning = panning; + gTasks[taskId].tFramesToWait = framesToWait; + gTasks[taskId].tNumberOfPlays = numberOfPlays; + gTasks[taskId].tFrameCounter = framesToWait; + gTasks[taskId].func(taskId); + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 5; +} + +static void Task_LoopAndPlaySE(u8 taskId) +{ + if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait) + { + u16 songId; + s8 panning; + u8 numberOfPlays; + + gTasks[taskId].tFrameCounter = 0; + songId = gTasks[taskId].tSongId; + panning = gTasks[taskId].tPanning; + numberOfPlays = --gTasks[taskId].tNumberOfPlays; + PlaySE12WithPanning(songId, panning); + if (numberOfPlays == 0) + { + DestroyTask(taskId); + gAnimSoundTaskCount--; + } + } +} + +#undef tSongId +#undef tPanning +#undef tFramesToWait +#undef tNumberOfPlays +#undef tFrameCounter + +#define tSongId data[0] +#define tPanning data[1] +#define tFramesToWait data[2] + +static void ScriptCmd_waitplaysewithpan(void) +{ + u16 songId; + s8 panningArg, panning; + u8 framesToWait; + u8 taskId; + + sBattleAnimScriptPtr++; + songId = T1_READ_16(sBattleAnimScriptPtr); + panningArg = sBattleAnimScriptPtr[2]; + framesToWait = sBattleAnimScriptPtr[3]; + panning = BattleAnimAdjustPanning(panningArg); + + taskId = CreateTask(Task_WaitAndPlaySE, 1); + gTasks[taskId].tSongId = songId; + gTasks[taskId].tPanning = panning; + gTasks[taskId].tFramesToWait = framesToWait; + + gAnimSoundTaskCount++; + sBattleAnimScriptPtr += 4; +} + +static void Task_WaitAndPlaySE(u8 taskId) +{ + if (gTasks[taskId].tFramesToWait-- <= 0) + { + PlaySE12WithPanning(gTasks[taskId].tSongId, gTasks[taskId].tPanning); + DestroyTask(taskId); + gAnimSoundTaskCount--; + } +} + +#undef tSongId +#undef tPanning +#undef tFramesToWait + +static void ScriptCmd_createsoundtask(void) +{ + TaskFunc func; + u8 numArgs, taskId; + s32 i; + + sBattleAnimScriptPtr++; + func = (TaskFunc)T2_READ_32(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 4; + numArgs = sBattleAnimScriptPtr[0]; + sBattleAnimScriptPtr++; + for (i = 0; i < numArgs; i++) + { + gBattleAnimArgs[i] = T1_READ_16(sBattleAnimScriptPtr); + sBattleAnimScriptPtr += 2; + } + taskId = CreateTask(func, 1); + func(taskId); + gAnimSoundTaskCount++; +} + +static void ScriptCmd_waitsound(void) +{ + if (gAnimSoundTaskCount != 0) + { + sSoundAnimFramesToWait = 0; + gAnimFramesToWait = 1; + } + else if (IsSEPlaying()) + { + if (++sSoundAnimFramesToWait > 90) + { + m4aMPlayStop(&gMPlayInfo_SE1); + m4aMPlayStop(&gMPlayInfo_SE2); + sSoundAnimFramesToWait = 0; + } + else + { + gAnimFramesToWait = 1; + } + } + else + { + sSoundAnimFramesToWait = 0; + sBattleAnimScriptPtr++; + gAnimFramesToWait = 0; + } +} + +static void ScriptCmd_jumpargeq(void) +{ + u8 argId; + s16 valueToCheck; + + sBattleAnimScriptPtr++; + argId = sBattleAnimScriptPtr[0]; + valueToCheck = T1_READ_16(sBattleAnimScriptPtr + 1); + + if (valueToCheck == gBattleAnimArgs[argId]) + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr + 3); + else + sBattleAnimScriptPtr += 7; +} + +static void ScriptCmd_jumpifcontest(void) +{ + sBattleAnimScriptPtr++; + if (IsContest()) + sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); + else + sBattleAnimScriptPtr += 4; +} + +static void ScriptCmd_monbgprio_28(void) +{ + u8 wantedBattler; + u8 battlerId; + u8 battlerPosition; + + wantedBattler = sBattleAnimScriptPtr[1]; + sBattleAnimScriptPtr += 2; + + if (wantedBattler != ANIM_ATTACKER) + battlerId = gBattleAnimTarget; + else + battlerId = gBattleAnimAttacker; + + battlerPosition = GetBattlerPosition(battlerId); + if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT)) + { + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); + } +} + +static void ScriptCmd_monbgprio_29(void) +{ + sBattleAnimScriptPtr++; + if (!IsContest()) + { + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); + } +} + +static void ScriptCmd_monbgprio_2A(void) +{ + u8 wantedBattler; + u8 battlerPosition; + u8 battlerId; + + wantedBattler = sBattleAnimScriptPtr[1]; + sBattleAnimScriptPtr += 2; + if (GetBattlerSide(gBattleAnimAttacker) != GetBattlerSide(gBattleAnimTarget)) + { + if (wantedBattler != ANIM_ATTACKER) + battlerId = gBattleAnimTarget; + else + battlerId = gBattleAnimAttacker; + + battlerPosition = GetBattlerPosition(battlerId); + if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT)) + { + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); + } + } +} + +static void ScriptCmd_invisible(void) +{ + u8 spriteId; + + spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]); + if (spriteId != 0xFF) + gSprites[spriteId].invisible = TRUE; + + sBattleAnimScriptPtr += 2; +} + +static void ScriptCmd_visible(void) +{ + u8 spriteId; + + spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]); + if (spriteId != 0xFF) + gSprites[spriteId].invisible = FALSE; + + sBattleAnimScriptPtr += 2; +} + +static void ScriptCmd_doublebattle_2D(void) +{ + u8 wantedBattler; + u8 r4; + u8 spriteId; + + wantedBattler = sBattleAnimScriptPtr[1]; + sBattleAnimScriptPtr += 2; + if (!IsContest() && IsDoubleBattle() + && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) + { + if (wantedBattler == ANIM_ATTACKER) + { + r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + } + else + { + r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); + spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + } + if (spriteId != 0xFF) + { + gSprites[spriteId].invisible = FALSE; + if (r4 == 2) + gSprites[spriteId].oam.priority = 3; + + if (r4 == 1) + sub_8073128(FALSE); + else + sub_8073128(TRUE); + } + } +} + +static void ScriptCmd_doublebattle_2E(void) +{ + u8 wantedBattler; + u8 r4; + u8 spriteId; + + wantedBattler = sBattleAnimScriptPtr[1]; + sBattleAnimScriptPtr += 2; + if (!IsContest() && IsDoubleBattle() + && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) + { + if (wantedBattler == ANIM_ATTACKER) + { + r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + } + else + { + r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); + spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + } + + if (spriteId != 0xFF && r4 == 2) + gSprites[spriteId].oam.priority = 2; + } +} + +static void ScriptCmd_stopsound(void) +{ + m4aMPlayStop(&gMPlayInfo_SE1); + m4aMPlayStop(&gMPlayInfo_SE2); + sBattleAnimScriptPtr++; +} -- cgit v1.2.3 From 45ff887858828bf06dbab9e0a5e94610955f2358 Mon Sep 17 00:00:00 2001 From: Evan Date: Sun, 1 Dec 2019 11:49:27 -0500 Subject: anim particle gfx graphics names --- src/battle_anim.c | 625 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 622 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index a92cf98de..fc22231bc 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -4,7 +4,6 @@ #include "battle_controllers.h" #include "battle_interface.h" #include "bg.h" -#include "contest.h" #include "decompress.h" #include "dma3.h" #include "gpu_regs.h" @@ -21,6 +20,9 @@ // Defines #define ANIM_SPRITE_INDEX_COUNT 8 +extern const u16 gMovesWithQuietBGM[]; +extern const u8 *const gBattleAnims_Moves[]; + // RAM EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; EWRAM_DATA static const u8 *sBattleAnimScriptRetAddr = NULL; @@ -40,7 +42,7 @@ EWRAM_DATA static u16 sSoundAnimFramesToWait = 0; EWRAM_DATA static u8 sMonAnimTaskIdArray[2] = {0}; EWRAM_DATA u8 gAnimMoveTurn = 0; EWRAM_DATA static u8 sAnimBackgroundFadeState = 0; -EWRAM_DATA static u16 sAnimMoveIndex = 0; // Set but unused. +EWRAM_DATA static u16 sAnimMoveIndex = 0; EWRAM_DATA u8 gBattleAnimAttacker = 0; EWRAM_DATA u8 gBattleAnimTarget = 0; EWRAM_DATA u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT] = {0}; @@ -101,7 +103,624 @@ static void ScriptCmd_doublebattle_2E(void); static void ScriptCmd_stopsound(void); // Data -static void (* const sScriptCmdTable[])(void) = //83ADF5C +const struct CompressedSpriteSheet gBattleAnimPicTable[] = // 83ACC08 +{ + {gBattleAnimSpriteGfx_Bone, 0x0200, ANIM_TAG_BONE}, + {gBattleAnimSpriteGfx_Spark, 0x0300, ANIM_TAG_SPARK}, + {gBattleAnimSpriteGfx_Pencil, 0x0200, ANIM_TAG_PENCIL}, + {gBattleAnimSpriteGfx_AirWave, 0x0100, ANIM_TAG_AIR_WAVE}, + {gBattleAnimSpriteGfx_Orb, 0x0200, ANIM_TAG_ORB}, + {gBattleAnimSpriteGfx_Sword, 0x0400, ANIM_TAG_SWORD}, + {gBattleAnimSpriteGfx_Seed, 0x0180, ANIM_TAG_SEED}, + {gBattleAnimSpriteGfx_Explosion6, 0x0800, ANIM_TAG_EXPLOSION_6}, + {gBattleAnimSpriteGfx_PinkOrb, 0x0020, ANIM_TAG_PINK_ORB}, + {gBattleAnimSpriteGfx_Gust, 0x0400, ANIM_TAG_GUST}, + {gBattleAnimSpriteGfx_IceCube, 0x1200, ANIM_TAG_ICE_CUBE}, + {gBattleAnimSpriteGfx_Spark2, 0x0180, ANIM_TAG_SPARK_2}, + {gBattleAnimSpriteGfx_Orange, 0x0080, ANIM_TAG_ORANGE}, + {gBattleAnimSpriteGfx_YellowBall, 0x0080, ANIM_TAG_YELLOW_BALL}, + {gBattleAnimSpriteGfx_LockOn, 0x0280, ANIM_TAG_LOCK_ON}, + {gBattleAnimSpriteGfx_TiedBag, 0x0080, ANIM_TAG_TIED_BAG}, + {gBattleAnimSpriteGfx_BlackSmoke, 0x0100, ANIM_TAG_BLACK_SMOKE}, + {gBattleAnimSpriteGfx_BlackBall, 0x0020, ANIM_TAG_BLACK_BALL}, + {gBattleAnimSpriteGfx_Conversion, 0x0080, ANIM_TAG_CONVERSION}, + {gBattleAnimSpriteGfx_Glass, 0x0400, ANIM_TAG_GLASS}, + {gBattleAnimSpriteGfx_HornHit, 0x0200, ANIM_TAG_HORN_HIT}, + {gBattleAnimSpriteGfx_Hit, 0x0A00, ANIM_TAG_HIT}, + {gBattleAnimSpriteGfx_Hit, 0x0A00, ANIM_TAG_HIT_2}, + {gBattleAnimSpriteGfx_BlueShards, 0x0380, ANIM_TAG_BLUE_SHARDS}, + {gBattleAnimSpriteGfx_ClosingEye, 0x0300, ANIM_TAG_CLOSING_EYE}, + {gBattleAnimSpriteGfx_WavingHand, 0x0A00, ANIM_TAG_WAVING_HAND}, + {gBattleAnimSpriteGfx_HitDuplicate, 0x0A00, ANIM_TAG_HIT_DUPLICATE}, + {gBattleAnimSpriteGfx_Leer, 0x0A00, ANIM_TAG_LEER}, + {gBattleAnimSpriteGfx_BlueBurst, 0x0A00, ANIM_TAG_BLUE_BURST}, + {gBattleAnimSpriteGfx_SmallEmber, 0x0A00, ANIM_TAG_SMALL_EMBER}, + {gBattleAnimSpriteGfx_GraySmoke, 0x0A00, ANIM_TAG_GRAY_SMOKE}, + {gBattleAnimSpriteGfx_BlueStar, 0x0E00, ANIM_TAG_BLUE_STAR}, + {gBattleAnimSpriteGfx_BubbleBurst, 0x0380, ANIM_TAG_BUBBLE_BURST}, + {gBattleAnimSpriteGfx_Fire, 0x1000, ANIM_TAG_FIRE}, + {gBattleAnimSpriteGfx_SpinningFire, 0x0800, ANIM_TAG_SPINNING_FIRE}, + {gBattleAnimSpriteGfx_FirePlume, 0x0A00, ANIM_TAG_FIRE_PLUME}, + {gBattleAnimSpriteGfx_Lightning2, 0x0800, ANIM_TAG_LIGHTNING_2}, + {gBattleAnimSpriteGfx_Lightning, 0x0A00, ANIM_TAG_LIGHTNING}, + {gBattleAnimSpriteGfx_ClawSlash2, 0x0A00, ANIM_TAG_CLAW_SLASH_2}, + {gBattleAnimSpriteGfx_ClawSlash, 0x0A00, ANIM_TAG_CLAW_SLASH}, + {gBattleAnimSpriteGfx_Scratch3, 0x0A00, ANIM_TAG_SCRATCH_3}, + {gBattleAnimSpriteGfx_Scratch2, 0x0A00, ANIM_TAG_SCRATCH_2}, + {gBattleAnimSpriteGfx_BubbleBurst2, 0x0A00, ANIM_TAG_BUBBLE_BURST_2}, + {gBattleAnimSpriteGfx_IceChunk, 0x0A00, ANIM_TAG_ICE_CHUNK}, + {gBattleAnimSpriteGfx_Glass2, 0x0A00, ANIM_TAG_GLASS_2}, + {gBattleAnimSpriteGfx_PinkHeart2, 0x0A00, ANIM_TAG_PINK_HEART_2}, + {gBattleAnimSpriteGfx_SapDrip, 0x1000, ANIM_TAG_SAP_DRIP}, + {gBattleAnimSpriteGfx_SapDrip, 0x1000, ANIM_TAG_SAP_DRIP_2}, + {gBattleAnimSpriteGfx_Sparkle1, 0x1000, ANIM_TAG_SPARKLE_1}, + {gBattleAnimSpriteGfx_Sparkle1, 0x1000, ANIM_TAG_SPARKLE_2}, + {gBattleAnimSpriteGfx_HumanoidFoot, 0x0200, ANIM_TAG_HUMANOID_FOOT}, + {gBattleAnimSpriteGfx_MonsterFoot, 0x0200, ANIM_TAG_MONSTER_FOOT}, + {gBattleAnimSpriteGfx_HumanoidHand, 0x0200, ANIM_TAG_HUMANOID_HAND}, + {gBattleAnimSpriteGfx_NoiseLine, 0x0800, ANIM_TAG_NOISE_LINE}, + {gBattleAnimSpriteGfx_YellowUnk, 0x0080, ANIM_TAG_YELLOW_UNK}, + {gBattleAnimSpriteGfx_RedFist, 0x0200, ANIM_TAG_RED_FIST}, + {gBattleAnimSpriteGfx_SlamHit, 0x1000, ANIM_TAG_SLAM_HIT}, + {gBattleAnimSpriteGfx_Ring, 0x0180, ANIM_TAG_RING}, + {gBattleAnimSpriteGfx_Rocks, 0x0C00, ANIM_TAG_ROCKS}, + {gBattleAnimSpriteGfx_Z, 0x0100, ANIM_TAG_Z}, + {gBattleAnimSpriteGfx_YellowUnk2, 0x0040, ANIM_TAG_YELLOW_UNK_2}, + {gBattleAnimSpriteGfx_AirSlash, 0x0180, ANIM_TAG_AIR_SLASH}, + {gBattleAnimSpriteGfx_SpinningGreenOrbs, 0x0800, ANIM_TAG_SPINNING_GREEN_ORBS}, + {gBattleAnimSpriteGfx_Leaf, 0x0480, ANIM_TAG_LEAF}, + {gBattleAnimSpriteGfx_Finger, 0x0200, ANIM_TAG_FINGER}, + {gBattleAnimSpriteGfx_PoisonPowder, 0x0200, ANIM_TAG_POISON_POWDER}, + {gBattleAnimSpriteGfx_BrownTriangle, 0x0100, ANIM_TAG_BROWN_TRIANGLE}, + {gBattleAnimSpriteGfx_PoisonPowder, 0x0200, ANIM_TAG_SLEEP_POWDER}, + {gBattleAnimSpriteGfx_PoisonPowder, 0x0200, ANIM_TAG_STUN_SPORE}, + {gBattleAnimSpriteGfx_PoisonPowder, 0x0200, ANIM_TAG_POWDER}, + {gBattleAnimSpriteGfx_Sparkle3, 0x0200, ANIM_TAG_SPARKLE_3}, + {gBattleAnimSpriteGfx_Sparkle4, 0x0A00, ANIM_TAG_SPARKLE_4}, + {gBattleAnimSpriteGfx_MusicNotes, 0x0300, ANIM_TAG_MUSIC_NOTES}, + {gBattleAnimSpriteGfx_Duck, 0x0180, ANIM_TAG_DUCK}, + {gBattleAnimSpriteGfx_MudSand, 0x00A0, ANIM_TAG_MUD_SAND}, + {gBattleAnimSpriteGfx_Alert, 0x0700, ANIM_TAG_ALERT}, + {gBattleAnimSpriteGfx_BlueFlames, 0x0400, ANIM_TAG_BLUE_FLAMES}, + {gBattleAnimSpriteGfx_BlueFlames2, 0x0200, ANIM_TAG_BLUE_FLAMES_2}, + {gBattleAnimSpriteGfx_Shock4, 0x0300, ANIM_TAG_SHOCK_4}, + {gBattleAnimSpriteGfx_Shock, 0x0C00, ANIM_TAG_SHOCK}, + {gBattleAnimSpriteGfx_Bell2, 0x0A00, ANIM_TAG_BELL_2}, + {gBattleAnimSpriteGfx_PinkGlove, 0x0080, ANIM_TAG_PINK_GLOVE}, + {gBattleAnimSpriteGfx_BlueLines, 0x0040, ANIM_TAG_BLUE_LINES}, + {gBattleAnimSpriteGfx_Impact3, 0x0E00, ANIM_TAG_IMPACT_3}, + {gBattleAnimSpriteGfx_Impact2, 0x0E00, ANIM_TAG_IMPACT_2}, + {gBattleAnimSpriteGfx_Reticle, 0x0280, ANIM_TAG_RETICLE}, + {gBattleAnimSpriteGfx_Breath, 0x0200, ANIM_TAG_BREATH}, + {gBattleAnimSpriteGfx_Anger, 0x0080, ANIM_TAG_ANGER}, + {gBattleAnimSpriteGfx_Snowball, 0x00C0, ANIM_TAG_SNOWBALL}, + {gBattleAnimSpriteGfx_Vine, 0x0A00, ANIM_TAG_VINE}, + {gBattleAnimSpriteGfx_Sword2, 0x0200, ANIM_TAG_SWORD_2}, + {gBattleAnimSpriteGfx_Clapping, 0x0180, ANIM_TAG_CLAPPING}, + {gBattleAnimSpriteGfx_RedTube, 0x0080, ANIM_TAG_RED_TUBE}, + {gBattleAnimSpriteGfx_Amnesia, 0x1000, ANIM_TAG_AMNESIA}, + {gBattleAnimSpriteGfx_String2, 0x0A00, ANIM_TAG_STRING_2}, + {gBattleAnimSpriteGfx_Pencil2, 0x0180, ANIM_TAG_PENCIL_2}, + {gBattleAnimSpriteGfx_Petal, 0x0380, ANIM_TAG_PETAL}, + {gBattleAnimSpriteGfx_BentSpoon, 0x0C00, ANIM_TAG_BENT_SPOON}, + {gBattleAnimSpriteGfx_Web, 0x0200, ANIM_TAG_WEB}, + {gBattleAnimSpriteGfx_MilkBottle, 0x0200, ANIM_TAG_MILK_BOTTLE}, + {gBattleAnimSpriteGfx_Coin, 0x0200, ANIM_TAG_COIN}, + {gBattleAnimSpriteGfx_CrackedEgg, 0x0200, ANIM_TAG_CRACKED_EGG}, + {gBattleAnimSpriteGfx_HatchedEgg, 0x0400, ANIM_TAG_HATCHED_EGG}, + {gBattleAnimSpriteGfx_FreshEgg, 0x0080, ANIM_TAG_FRESH_EGG}, + {gBattleAnimSpriteGfx_Fangs, 0x0400, ANIM_TAG_FANGS}, + {gBattleAnimSpriteGfx_Explosion2, 0x0c00, ANIM_TAG_EXPLOSION_2}, + {gBattleAnimSpriteGfx_Explosion3, 0x0200, ANIM_TAG_EXPLOSION_3}, + {gBattleAnimSpriteGfx_WaterDroplet, 0x1000, ANIM_TAG_WATER_DROPLET}, + {gBattleAnimSpriteGfx_WaterDroplet2, 0x0a00, ANIM_TAG_WATER_DROPLET_2}, + {gBattleAnimSpriteGfx_Seed2, 0x0020, ANIM_TAG_SEED_2}, + {gBattleAnimSpriteGfx_Sprout, 0x0e00, ANIM_TAG_SPROUT}, + {gBattleAnimSpriteGfx_RedWand, 0x0080, ANIM_TAG_RED_WAND}, + {gBattleAnimSpriteGfx_PurpleGreenUnk, 0x0a00, ANIM_TAG_PURPLE_GREEN_UNK}, + {gBattleAnimSpriteGfx_WaterColumn, 0x0400, ANIM_TAG_WATER_COLUMN}, + {gBattleAnimSpriteGfx_MudUnk, 0x0200, ANIM_TAG_MUD_UNK}, + {gBattleAnimSpriteGfx_RainDrops, 0x0700, ANIM_TAG_RAIN_DROPS}, + {gBattleAnimSpriteGfx_FurySwipes, 0x0800, ANIM_TAG_FURY_SWIPES}, + {gBattleAnimSpriteGfx_Vine2, 0x0a00, ANIM_TAG_VINE_2}, + {gBattleAnimSpriteGfx_Teeth, 0x0600, ANIM_TAG_TEETH}, + {gBattleAnimSpriteGfx_Bone2, 0x0800, ANIM_TAG_BONE_2}, + {gBattleAnimSpriteGfx_WhiteBag, 0x0200, ANIM_TAG_WHITE_BAG}, + {gBattleAnimSpriteGfx_Unknown, 0x0040, ANIM_TAG_UNKNOWN}, + {gBattleAnimSpriteGfx_PurpleCoral, 0x0180, ANIM_TAG_PURPLE_CORAL}, + {gBattleAnimSpriteGfx_PurpleDroplet, 0x0600, ANIM_TAG_PURPLE_DROPLET}, + {gBattleAnimSpriteGfx_Shock2, 0x0600, ANIM_TAG_SHOCK_2}, + {gBattleAnimSpriteGfx_ClosingEye2, 0x0200, ANIM_TAG_CLOSING_EYE_2}, + {gBattleAnimSpriteGfx_MetalBall, 0x0080, ANIM_TAG_METAL_BALL}, + {gBattleAnimSpriteGfx_MonsterDoll, 0x0200, ANIM_TAG_MONSTER_DOLL}, + {gBattleAnimSpriteGfx_Whirlwind, 0x0800, ANIM_TAG_WHIRLWIND}, + {gBattleAnimSpriteGfx_Whirlwind2, 0x0080, ANIM_TAG_WHIRLWIND_2}, + {gBattleAnimSpriteGfx_Explosion4, 0x0a00, ANIM_TAG_EXPLOSION_4}, + {gBattleAnimSpriteGfx_Explosion5, 0x0280, ANIM_TAG_EXPLOSION_5}, + {gBattleAnimSpriteGfx_Tongue, 0x0280, ANIM_TAG_TONGUE}, + {gBattleAnimSpriteGfx_Smoke, 0x0100, ANIM_TAG_SMOKE}, + {gBattleAnimSpriteGfx_Smoke2, 0x0200, ANIM_TAG_SMOKE_2}, + {gBattleAnimSpriteGfx_Impact, 0x0200, ANIM_TAG_IMPACT}, + {gBattleAnimSpriteGfx_CircleImpact, 0x0020, ANIM_TAG_CIRCLE_IMPACT}, + {gBattleAnimSpriteGfx_Scratch, 0x0a00, ANIM_TAG_SCRATCH}, + {gBattleAnimSpriteGfx_Cut, 0x0800, ANIM_TAG_CUT}, + {gBattleAnimSpriteGfx_SharpTeeth, 0x0800, ANIM_TAG_SHARP_TEETH}, + {gBattleAnimSpriteGfx_RainbowRings, 0x00c0, ANIM_TAG_RAINBOW_RINGS}, + {gBattleAnimSpriteGfx_IceCrystals, 0x01c0, ANIM_TAG_ICE_CRYSTALS}, + {gBattleAnimSpriteGfx_IceSpikes, 0x0100, ANIM_TAG_ICE_SPIKES}, + {gBattleAnimSpriteGfx_HandsAndFeet, 0x0800, ANIM_TAG_HANDS_AND_FEET}, + {gBattleAnimSpriteGfx_MistCloud, 0x0200, ANIM_TAG_MIST_CLOUD}, + {gBattleAnimSpriteGfx_Clamp, 0x0800, ANIM_TAG_CLAMP}, + {gBattleAnimSpriteGfx_Bubble, 0x0180, ANIM_TAG_BUBBLE}, + {gBattleAnimSpriteGfx_Orbs, 0x0180, ANIM_TAG_ORBS}, + {gBattleAnimSpriteGfx_WaterImpact, 0x0200, ANIM_TAG_WATER_IMPACT}, + {gBattleAnimSpriteGfx_WaterOrb, 0x0200, ANIM_TAG_WATER_ORB}, + {gBattleAnimSpriteGfx_PoisonBubble, 0x0180, ANIM_TAG_POISON_BUBBLE}, + {gBattleAnimSpriteGfx_ToxicBubble, 0x0400, ANIM_TAG_TOXIC_BUBBLE}, + {gBattleAnimSpriteGfx_Spikes, 0x0080, ANIM_TAG_SPIKES}, + {gBattleAnimSpriteGfx_HornHit2, 0x0100, ANIM_TAG_HORN_HIT_2}, + {gBattleAnimSpriteGfx_AirWave2, 0x0100, ANIM_TAG_AIR_WAVE_2}, + {gBattleAnimSpriteGfx_SmallBubbles, 0x0140, ANIM_TAG_SMALL_BUBBLES}, + {gBattleAnimSpriteGfx_RoundShadow, 0x0800, ANIM_TAG_ROUND_SHADOW}, + {gBattleAnimSpriteGfx_Sunlight, 0x0200, ANIM_TAG_SUNLIGHT}, + {gBattleAnimSpriteGfx_Spore, 0x0100, ANIM_TAG_SPORE}, + {gBattleAnimSpriteGfx_Flower, 0x00a0, ANIM_TAG_FLOWER}, + {gBattleAnimSpriteGfx_RazorLeaf, 0x0100, ANIM_TAG_RAZOR_LEAF}, + {gBattleAnimSpriteGfx_Needle, 0x0080, ANIM_TAG_NEEDLE}, + {gBattleAnimSpriteGfx_WhirlwindLines, 0x0300, ANIM_TAG_WHIRLWIND_LINES}, + {gBattleAnimSpriteGfx_GoldRing, 0x0100, ANIM_TAG_GOLD_RING}, + {gBattleAnimSpriteGfx_GoldRing, 0x0100, ANIM_TAG_PURPLE_RING}, + {gBattleAnimSpriteGfx_GoldRing, 0x0100, ANIM_TAG_BLUE_RING}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_GREEN_LIGHT_WALL}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_BLUE_LIGHT_WALL}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_RED_LIGHT_WALL}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_GRAY_LIGHT_WALL}, + {gBattleAnimSpriteGfx_GreenLightWall, 0x0800, ANIM_TAG_ORANGE_LIGHT_WALL}, + {gBattleAnimSpriteGfx_BlackBall2, 0x0080, ANIM_TAG_BLACK_BALL_2}, + {gBattleAnimSpriteGfx_MistCloud, 0x0200, ANIM_TAG_PURPLE_GAS_CLOUD}, + {gBattleAnimSpriteGfx_SparkH, 0x0200, ANIM_TAG_SPARK_H}, + {gBattleAnimSpriteGfx_YellowStar, 0x0200, ANIM_TAG_YELLOW_STAR}, + {gBattleAnimSpriteGfx_LargeFreshEgg, 0x0080, ANIM_TAG_LARGE_FRESH_EGG}, + {gBattleAnimSpriteGfx_ShadowBall, 0x0200, ANIM_TAG_SHADOW_BALL}, + {gBattleAnimSpriteGfx_Lick, 0x0500, ANIM_TAG_LICK}, + {gBattleAnimSpriteGfx_VoidLines, 0x0800, ANIM_TAG_VOID_LINES}, + {gBattleAnimSpriteGfx_String, 0x0400, ANIM_TAG_STRING}, + {gBattleAnimSpriteGfx_WebThread, 0x0020, ANIM_TAG_WEB_THREAD}, + {gBattleAnimSpriteGfx_SpiderWeb, 0x0800, ANIM_TAG_SPIDER_WEB}, + {gBattleAnimSpriteGfx_Lightbulb, 0x0100, ANIM_TAG_LIGHTBULB}, + {gBattleAnimSpriteGfx_Slash, 0x0800, ANIM_TAG_SLASH}, + {gBattleAnimSpriteGfx_FocusEnergy, 0x0400, ANIM_TAG_FOCUS_ENERGY}, + {gBattleAnimSpriteGfx_SphereToCube, 0x0a00, ANIM_TAG_SPHERE_TO_CUBE}, + {gBattleAnimSpriteGfx_Tendrils, 0x1000, ANIM_TAG_TENDRILS}, + {gBattleAnimSpriteGfx_Eye, 0x0800, ANIM_TAG_EYE}, + {gBattleAnimSpriteGfx_WhiteShadow, 0x0400, ANIM_TAG_WHITE_SHADOW}, + {gBattleAnimSpriteGfx_TealAlert, 0x0200, ANIM_TAG_TEAL_ALERT}, + {gBattleAnimSpriteGfx_OpeningEye, 0x0800, ANIM_TAG_OPENING_EYE}, + {gBattleAnimSpriteGfx_RoundWhiteHalo, 0x0800, ANIM_TAG_ROUND_WHITE_HALO}, + {gBattleAnimSpriteGfx_FangAttack, 0x0800, ANIM_TAG_FANG_ATTACK}, + {gBattleAnimSpriteGfx_PurpleHandOutline, 0x0200, ANIM_TAG_PURPLE_HAND_OUTLINE}, + {gBattleAnimSpriteGfx_Moon, 0x0800, ANIM_TAG_MOON}, + {gBattleAnimSpriteGfx_GreenSparkle, 0x0200, ANIM_TAG_GREEN_SPARKLE}, + {gBattleAnimSpriteGfx_Spiral, 0x0800, ANIM_TAG_SPIRAL}, + {gBattleAnimSpriteGfx_SnoreZ, 0x0200, ANIM_TAG_SNORE_Z}, + {gBattleAnimSpriteGfx_Explosion, 0x0800, ANIM_TAG_EXPLOSION}, + {gBattleAnimSpriteGfx_Nail, 0x0400, ANIM_TAG_NAIL}, + {gBattleAnimSpriteGfx_GhostlySpirit, 0x0200, ANIM_TAG_GHOSTLY_SPIRIT}, + {gBattleAnimSpriteGfx_WarmRock, 0x0a80, ANIM_TAG_WARM_ROCK}, + {gBattleAnimSpriteGfx_BreakingEgg, 0x0600, ANIM_TAG_BREAKING_EGG}, + {gBattleAnimSpriteGfx_ThinRing, 0x0800, ANIM_TAG_THIN_RING}, + {gBattleAnimSpriteGfx_PunchImpact, 0x0200, ANIM_TAG_PUNCH_IMPACT}, + {gBattleAnimSpriteGfx_Bell, 0x0600, ANIM_TAG_BELL}, + {gBattleAnimSpriteGfx_MusicNotes2, 0x0800, ANIM_TAG_MUSIC_NOTES_2}, + {gBattleAnimSpriteGfx_SpeedDust, 0x0180, ANIM_TAG_SPEED_DUST}, + {gBattleAnimSpriteGfx_TornMetal, 0x0800, ANIM_TAG_TORN_METAL}, + {gBattleAnimSpriteGfx_ThoughtBubble, 0x0800, ANIM_TAG_THOUGHT_BUBBLE}, + {gBattleAnimSpriteGfx_MagentaHeart, 0x0080, ANIM_TAG_MAGENTA_HEART}, + {gBattleAnimSpriteGfx_ElectricOrbs, 0x0080, ANIM_TAG_ELECTRIC_ORBS}, + {gBattleAnimSpriteGfx_CircleOfLight, 0x0800, ANIM_TAG_CIRCLE_OF_LIGHT}, + {gBattleAnimSpriteGfx_Electricity, 0x0800, ANIM_TAG_ELECTRICITY}, + {gBattleAnimSpriteGfx_Finger2, 0x0600, ANIM_TAG_FINGER_2}, + {gBattleAnimSpriteGfx_MovementWaves, 0x0600, ANIM_TAG_MOVEMENT_WAVES}, + {gBattleAnimSpriteGfx_MagentaHeart, 0x0080, ANIM_TAG_RED_HEART}, + {gBattleAnimSpriteGfx_RedOrb, 0x0080, ANIM_TAG_RED_ORB}, + {gBattleAnimSpriteGfx_EyeSparkle, 0x0180, ANIM_TAG_EYE_SPARKLE}, + {gBattleAnimSpriteGfx_MagentaHeart, 0x0080, ANIM_TAG_PINK_HEART}, + {gBattleAnimSpriteGfx_Angel, 0x0200, ANIM_TAG_ANGEL}, + {gBattleAnimSpriteGfx_Devil, 0x0400, ANIM_TAG_DEVIL}, + {gBattleAnimSpriteGfx_Swipe, 0x0a00, ANIM_TAG_SWIPE}, + {gBattleAnimSpriteGfx_Roots, 0x0800, ANIM_TAG_ROOTS}, + {gBattleAnimSpriteGfx_ItemBag, 0x0200, ANIM_TAG_ITEM_BAG}, + {gBattleAnimSpriteGfx_JaggedMusicNote, 0x0400, ANIM_TAG_JAGGED_MUSIC_NOTE}, + {gBattleAnimSpriteGfx_Pokeball, 0x0080, ANIM_TAG_POKEBALL}, + {gBattleAnimSpriteGfx_Spotlight, 0x0800, ANIM_TAG_SPOTLIGHT}, + {gBattleAnimSpriteGfx_LetterZ, 0x0200, ANIM_TAG_LETTER_Z}, + {gBattleAnimSpriteGfx_RapidSpin, 0x0300, ANIM_TAG_RAPID_SPIN}, + {gBattleAnimSpriteGfx_TriForceTriangle, 0x0800, ANIM_TAG_TRI_FORCE_TRIANGLE}, + {gBattleAnimSpriteGfx_WispOrb, 0x0380, ANIM_TAG_WISP_ORB}, + {gBattleAnimSpriteGfx_WispFire, 0x0800, ANIM_TAG_WISP_FIRE}, + {gBattleAnimSpriteGfx_GoldStars, 0x00c0, ANIM_TAG_GOLD_STARS}, + {gBattleAnimSpriteGfx_EclipsingOrb, 0x0800, ANIM_TAG_ECLIPSING_ORB}, + {gBattleAnimSpriteGfx_GrayOrb, 0x0060, ANIM_TAG_GRAY_ORB}, + {gBattleAnimSpriteGfx_GrayOrb, 0x0060, ANIM_TAG_BLUE_ORB}, + {gBattleAnimSpriteGfx_GrayOrb, 0x0060, ANIM_TAG_RED_ORB_2}, + {gBattleAnimSpriteGfx_PinkPetal, 0x0080, ANIM_TAG_PINK_PETAL}, + {gBattleAnimSpriteGfx_PainSplit, 0x0180, ANIM_TAG_PAIN_SPLIT}, + {gBattleAnimSpriteGfx_Confetti, 0x0180, ANIM_TAG_CONFETTI}, + {gBattleAnimSpriteGfx_GreenStar, 0x0200, ANIM_TAG_GREEN_STAR}, + {gBattleAnimSpriteGfx_PinkCloud, 0x0200, ANIM_TAG_PINK_CLOUD}, + {gBattleAnimSpriteGfx_SweatDrop, 0x0020, ANIM_TAG_SWEAT_DROP}, + {gBattleAnimSpriteGfx_GuardRing, 0x0400, ANIM_TAG_GUARD_RING}, + {gBattleAnimSpriteGfx_PurpleScratch, 0x0600, ANIM_TAG_PURPLE_SCRATCH}, + {gBattleAnimSpriteGfx_PurpleSwipe, 0x1000, ANIM_TAG_PURPLE_SWIPE}, + {gBattleAnimSpriteGfx_TagHand, 0x0400, ANIM_TAG_TAG_HAND}, + {gBattleAnimSpriteGfx_SmallRedEye, 0x0020, ANIM_TAG_SMALL_RED_EYE}, + {gBattleAnimSpriteGfx_HollowOrb, 0x0080, ANIM_TAG_HOLLOW_ORB}, + {gBattleAnimSpriteGfx_XSign, 0x0800, ANIM_TAG_X_SIGN}, + {gBattleAnimSpriteGfx_BluegreenOrb, 0x0080, ANIM_TAG_BLUEGREEN_ORB}, + {gBattleAnimSpriteGfx_PawPrint, 0x0200, ANIM_TAG_PAW_PRINT}, + {gBattleAnimSpriteGfx_PurpleFlame, 0x0400, ANIM_TAG_PURPLE_FLAME}, + {gBattleAnimSpriteGfx_RedBall, 0x0200, ANIM_TAG_RED_BALL}, + {gBattleAnimSpriteGfx_SmellingsaltEffect, 0x0200, ANIM_TAG_SMELLINGSALT_EFFECT}, + {gBattleAnimSpriteGfx_Meteor, 0x0800, ANIM_TAG_METEOR}, + {gBattleAnimSpriteGfx_FlatRock, 0x0280, ANIM_TAG_FLAT_ROCK}, + {gBattleAnimSpriteGfx_MagnifyingGlass, 0x0200, ANIM_TAG_MAGNIFYING_GLASS}, + {gBattleAnimSpriteGfx_WaterOrb, 0x0200, ANIM_TAG_BROWN_ORB}, + {gBattleAnimSpriteGfx_MetalSoundWaves, 0x0400, ANIM_TAG_METAL_SOUND_WAVES}, + {gBattleAnimSpriteGfx_FlyingDirt, 0x0200, ANIM_TAG_FLYING_DIRT}, + {gBattleAnimSpriteGfx_IcicleSpear, 0x0200, ANIM_TAG_ICICLE_SPEAR}, + {gBattleAnimSpriteGfx_Hail, 0x0080, ANIM_TAG_HAIL}, + {gBattleAnimSpriteGfx_GlowyRedOrb, 0x0020, ANIM_TAG_GLOWY_RED_ORB}, + {gBattleAnimSpriteGfx_GlowyRedOrb, 0x0020, ANIM_TAG_GLOWY_GREEN_ORB}, + {gBattleAnimSpriteGfx_GreenSpike, 0x0080, ANIM_TAG_GREEN_SPIKE}, + {gBattleAnimSpriteGfx_CircleOfLight, 0x0800, ANIM_TAG_WHITE_CIRCLE_OF_LIGHT}, + {gBattleAnimSpriteGfx_GlowyRedOrb, 0x0020, ANIM_TAG_GLOWY_BLUE_ORB}, + {gBattleAnimSpriteGfx_Pokeblock, 0x0080, ANIM_TAG_POKEBLOCK}, + {gBattleAnimSpriteGfx_WhiteFeather, 0x0400, ANIM_TAG_WHITE_FEATHER}, + {gBattleAnimSpriteGfx_Sparkle6, 0x0080, ANIM_TAG_SPARKLE_6}, + {gBattleAnimSpriteGfx_Splash, 0x0800, ANIM_TAG_SPLASH}, + {gBattleAnimSpriteGfx_SweatBead, 0x0020, ANIM_TAG_SWEAT_BEAD}, + {gBattleAnimSpriteGfx_Gem1, 0x0800, ANIM_TAG_GEM_1}, + {gBattleAnimSpriteGfx_Gem2, 0x0800, ANIM_TAG_GEM_2}, + {gBattleAnimSpriteGfx_Gem3, 0x0800, ANIM_TAG_GEM_3}, + {gBattleAnimSpriteGfx_SlamHit2, 0x1000, ANIM_TAG_SLAM_HIT_2}, + {gBattleAnimSpriteGfx_Recycle, 0x0800, ANIM_TAG_RECYCLE}, + {gBattleAnimSpriteGfx_RedParticles, 0x00a0, ANIM_TAG_RED_PARTICLES}, + {gBattleAnimSpriteGfx_Protect, 0x0800, ANIM_TAG_PROTECT}, + {gBattleAnimSpriteGfx_DirtMound, 0x0200, ANIM_TAG_DIRT_MOUND}, + {gBattleAnimSpriteGfx_Shock3, 0x0600, ANIM_TAG_SHOCK_3}, + {gBattleAnimSpriteGfx_WeatherBall, 0x0200, ANIM_TAG_WEATHER_BALL}, + {gBattleAnimSpriteGfx_Bird, 0x0800, ANIM_TAG_BIRD}, + {gBattleAnimSpriteGfx_CrossImpact, 0x0200, ANIM_TAG_CROSS_IMPACT}, + {gBattleAnimSpriteGfx_Slash, 0x0800, ANIM_TAG_SLASH_2}, + {gBattleAnimSpriteGfx_SlamHit, 0x1000, ANIM_TAG_WHIP_HIT}, + {gBattleAnimSpriteGfx_GoldRing, 0x0100, ANIM_TAG_BLUE_RING_2}, +}; + +const struct CompressedSpritePalette gBattleAnimPaletteTable[] = +{ + {gBattleAnimSpritePal_Bone, ANIM_TAG_BONE}, + {gBattleAnimSpritePal_Spark, ANIM_TAG_SPARK}, + {gBattleAnimSpritePal_Pencil, ANIM_TAG_PENCIL}, + {gBattleAnimSpritePal_AirWave, ANIM_TAG_AIR_WAVE}, + {gBattleAnimSpritePal_Orb, ANIM_TAG_ORB}, + {gBattleAnimSpritePal_Sword, ANIM_TAG_SWORD}, + {gBattleAnimSpritePal_Seed, ANIM_TAG_SEED}, + {gBattleAnimSpritePal_Explosion6, ANIM_TAG_EXPLOSION_6}, + {gBattleAnimSpritePal_PinkOrb, ANIM_TAG_PINK_ORB}, + {gBattleAnimSpritePal_Gust, ANIM_TAG_GUST}, + {gBattleAnimSpritePal_IceCube, ANIM_TAG_ICE_CUBE}, + {gBattleAnimSpritePal_Spark2, ANIM_TAG_SPARK_2}, + {gBattleAnimSpritePal_Orange, ANIM_TAG_ORANGE}, + {gBattleAnimSpritePal_YellowBall, ANIM_TAG_YELLOW_BALL}, + {gBattleAnimSpritePal_LockOn, ANIM_TAG_LOCK_ON}, + {gBattleAnimSpritePal_TiedBag, ANIM_TAG_TIED_BAG}, + {gBattleAnimSpritePal_BlackSmoke, ANIM_TAG_BLACK_SMOKE}, + {gBattleAnimSpritePal_BlackSmoke, ANIM_TAG_BLACK_BALL}, + {gBattleAnimSpritePal_Conversion, ANIM_TAG_CONVERSION}, + {gBattleAnimSpritePal_Glass, ANIM_TAG_GLASS}, + {gBattleAnimSpritePal_HornHit, ANIM_TAG_HORN_HIT}, + {gBattleAnimSpritePal_Hit, ANIM_TAG_HIT}, + {gBattleAnimSpritePal_Hit2, ANIM_TAG_HIT_2}, + {gBattleAnimSpritePal_BlueShards, ANIM_TAG_BLUE_SHARDS}, + {gBattleAnimSpritePal_ClosingEye, ANIM_TAG_CLOSING_EYE}, + {gBattleAnimSpritePal_WavingHand, ANIM_TAG_WAVING_HAND}, + {gBattleAnimSpritePal_HitDuplicate, ANIM_TAG_HIT_DUPLICATE}, + {gBattleAnimSpritePal_Leer, ANIM_TAG_LEER}, + {gBattleAnimSpritePal_BlueBurst, ANIM_TAG_BLUE_BURST}, + {gBattleAnimSpritePal_SmallEmber, ANIM_TAG_SMALL_EMBER}, + {gBattleAnimSpritePal_GraySmoke, ANIM_TAG_GRAY_SMOKE}, + {gBattleAnimSpritePal_BlueStar, ANIM_TAG_BLUE_STAR}, + {gBattleAnimSpritePal_BubbleBurst, ANIM_TAG_BUBBLE_BURST}, + {gBattleAnimSpritePal_Fire, ANIM_TAG_FIRE}, + {gBattleAnimSpritePal_Fire, ANIM_TAG_SPINNING_FIRE}, + {gBattleAnimSpritePal_Fire, ANIM_TAG_FIRE_PLUME}, + {gBattleAnimSpritePal_Lightning2, ANIM_TAG_LIGHTNING_2}, + {gBattleAnimSpritePal_Lightning2, ANIM_TAG_LIGHTNING}, + {gBattleAnimSpritePal_ClawSlash2, ANIM_TAG_CLAW_SLASH_2}, + {gBattleAnimSpritePal_ClawSlash, ANIM_TAG_CLAW_SLASH}, + {gBattleAnimSpritePal_ClawSlash2, ANIM_TAG_SCRATCH_3}, + {gBattleAnimSpritePal_ClawSlash2, ANIM_TAG_SCRATCH_2}, + {gBattleAnimSpritePal_BubbleBurst2, ANIM_TAG_BUBBLE_BURST_2}, + {gBattleAnimSpritePal_IceChunk, ANIM_TAG_ICE_CHUNK}, + {gBattleAnimSpritePal_Glass2, ANIM_TAG_GLASS_2}, + {gBattleAnimSpritePal_PinkHeart2, ANIM_TAG_PINK_HEART_2}, + {gBattleAnimSpritePal_SapDrip, ANIM_TAG_SAP_DRIP}, + {gBattleAnimSpritePal_SapDrip2, ANIM_TAG_SAP_DRIP}, + {gBattleAnimSpritePal_Sparkle1, ANIM_TAG_SPARKLE_1}, + {gBattleAnimSpritePal_Sparkle2, ANIM_TAG_SPARKLE_2}, + {gBattleAnimSpritePal_HumanoidFoot, ANIM_TAG_HUMANOID_FOOT}, + {gBattleAnimSpritePal_HumanoidFoot, ANIM_TAG_MONSTER_FOOT}, + {gBattleAnimSpritePal_HumanoidFoot, ANIM_TAG_HUMANOID_HAND}, + {gBattleAnimSpritePal_HitDuplicate, ANIM_TAG_NOISE_LINE}, + {gBattleAnimSpritePal_YellowUnk, ANIM_TAG_YELLOW_UNK}, + {gBattleAnimSpritePal_HumanoidFoot, ANIM_TAG_RED_FIST}, + {gBattleAnimSpritePal_SlamHit, ANIM_TAG_SLAM_HIT}, + {gBattleAnimSpritePal_Ring, ANIM_TAG_RING}, + {gBattleAnimSpritePal_Rocks, ANIM_TAG_ROCKS}, + {gBattleAnimSpritePal_Z, ANIM_TAG_Z}, + {gBattleAnimSpritePal_YellowUnk2, ANIM_TAG_YELLOW_UNK_2}, + {gBattleAnimSpritePal_AirSlash, ANIM_TAG_AIR_SLASH}, + {gBattleAnimSpritePal_SpinningGreenOrbs, ANIM_TAG_SPINNING_GREEN_ORBS}, + {gBattleAnimSpritePal_Leaf, ANIM_TAG_LEAF}, + {gBattleAnimSpritePal_Finger, ANIM_TAG_FINGER}, + {gBattleAnimSpritePal_PoisonPowder, ANIM_TAG_POISON_POWDER}, + {gBattleAnimSpritePal_BrownTriangle, ANIM_TAG_BROWN_TRIANGLE}, + {gBattleAnimSpritePal_SleepPowder, ANIM_TAG_SLEEP_POWDER}, + {gBattleAnimSpritePal_StunSpore, ANIM_TAG_STUN_SPORE}, + {gBattleAnimSpritePal_PoisonPowder, ANIM_TAG_POWDER}, + {gBattleAnimSpritePal_Sparkle3, ANIM_TAG_SPARKLE_3}, + {gBattleAnimSpritePal_Sparkle3, ANIM_TAG_SPARKLE_4}, + {gBattleAnimSpritePal_MusicNotes, ANIM_TAG_MUSIC_NOTES}, + {gBattleAnimSpritePal_Duck, ANIM_TAG_DUCK}, + {gBattleAnimSpritePal_MudSand, ANIM_TAG_MUD_SAND}, + {gBattleAnimSpritePal_Alert, ANIM_TAG_ALERT}, + {gBattleAnimSpritePal_BlueFlames, ANIM_TAG_BLUE_FLAMES}, + {gBattleAnimSpritePal_BlueFlames, ANIM_TAG_BLUE_FLAMES_2}, + {gBattleAnimSpritePal_Shock4, ANIM_TAG_SHOCK_4}, + {gBattleAnimSpritePal_Shock4, ANIM_TAG_SHOCK}, + {gBattleAnimSpritePal_Bell2, ANIM_TAG_BELL_2}, + {gBattleAnimSpritePal_PinkGlove, ANIM_TAG_PINK_GLOVE}, + {gBattleAnimSpritePal_BlueLines, ANIM_TAG_BLUE_LINES}, + {gBattleAnimSpritePal_Impact3, ANIM_TAG_IMPACT_3}, + {gBattleAnimSpritePal_Impact2, ANIM_TAG_IMPACT_2}, + {gBattleAnimSpritePal_Reticle, ANIM_TAG_RETICLE}, + {gBattleAnimSpritePal_Breath, ANIM_TAG_BREATH}, + {gBattleAnimSpritePal_Anger, ANIM_TAG_ANGER}, + {gBattleAnimSpritePal_Snowball, ANIM_TAG_SNOWBALL}, + {gBattleAnimSpritePal_Vine, ANIM_TAG_VINE}, + {gBattleAnimSpritePal_Sword2, ANIM_TAG_SWORD_2}, + {gBattleAnimSpritePal_Clapping, ANIM_TAG_CLAPPING}, + {gBattleAnimSpritePal_RedTube, ANIM_TAG_RED_TUBE}, + {gBattleAnimSpritePal_Amnesia, ANIM_TAG_AMNESIA}, + {gBattleAnimSpritePal_String2, ANIM_TAG_STRING_2}, + {gBattleAnimSpritePal_Pencil2, ANIM_TAG_PENCIL_2}, + {gBattleAnimSpritePal_Petal, ANIM_TAG_PETAL}, + {gBattleAnimSpritePal_BentSpoon, ANIM_TAG_BENT_SPOON}, + {gBattleAnimSpritePal_String2, ANIM_TAG_WEB}, + {gBattleAnimSpritePal_MilkBottle, ANIM_TAG_MILK_BOTTLE}, + {gBattleAnimSpritePal_Coin, ANIM_TAG_COIN}, + {gBattleAnimSpritePal_CrackedEgg, ANIM_TAG_CRACKED_EGG}, + {gBattleAnimSpritePal_CrackedEgg, ANIM_TAG_HATCHED_EGG}, + {gBattleAnimSpritePal_FreshEgg, ANIM_TAG_FRESH_EGG}, + {gBattleAnimSpritePal_Fangs, ANIM_TAG_FANGS}, + {gBattleAnimSpritePal_Explosion2, ANIM_TAG_EXPLOSION_2}, + {gBattleAnimSpritePal_Explosion2, ANIM_TAG_EXPLOSION_3}, + {gBattleAnimSpritePal_WaterDroplet, ANIM_TAG_WATER_DROPLET}, + {gBattleAnimSpritePal_WaterDroplet, ANIM_TAG_WATER_DROPLET_2}, + {gBattleAnimSpritePal_Seed2, ANIM_TAG_SEED_2}, + {gBattleAnimSpritePal_Seed2, ANIM_TAG_SPROUT}, + {gBattleAnimSpritePal_RedWand, ANIM_TAG_RED_WAND}, + {gBattleAnimSpritePal_PurpleGreenUnk, ANIM_TAG_PURPLE_GREEN_UNK}, + {gBattleAnimSpritePal_WaterColumn, ANIM_TAG_WATER_COLUMN}, + {gBattleAnimSpritePal_MudUnk, ANIM_TAG_MUD_UNK}, + {gBattleAnimSpritePal_RainDrops, ANIM_TAG_RAIN_DROPS}, + {gBattleAnimSpritePal_FurySwipes, ANIM_TAG_FURY_SWIPES}, + {gBattleAnimSpritePal_Vine2, ANIM_TAG_VINE_2}, + {gBattleAnimSpritePal_Teeth, ANIM_TAG_TEETH}, + {gBattleAnimSpritePal_Bone2, ANIM_TAG_BONE_2}, + {gBattleAnimSpritePal_WhiteBag, ANIM_TAG_WHITE_BAG}, + {gBattleAnimSpritePal_Unknown, ANIM_TAG_UNKNOWN}, + {gBattleAnimSpritePal_PurpleCoral, ANIM_TAG_PURPLE_CORAL}, + {gBattleAnimSpritePal_PurpleCoral, ANIM_TAG_PURPLE_DROPLET}, + {gBattleAnimSpritePal_Shock2, ANIM_TAG_SHOCK_2}, + {gBattleAnimSpritePal_ClosingEye2, ANIM_TAG_CLOSING_EYE_2}, + {gBattleAnimSpritePal_MetalBall, ANIM_TAG_METAL_BALL}, + {gBattleAnimSpritePal_MonsterDoll, ANIM_TAG_MONSTER_DOLL}, + {gBattleAnimSpritePal_Whirlwind, ANIM_TAG_WHIRLWIND}, + {gBattleAnimSpritePal_Whirlwind, ANIM_TAG_WHIRLWIND_2}, + {gBattleAnimSpritePal_Explosion4, ANIM_TAG_EXPLOSION_4}, + {gBattleAnimSpritePal_Explosion4, ANIM_TAG_EXPLOSION_5}, + {gBattleAnimSpritePal_Tongue, ANIM_TAG_TONGUE}, + {gBattleAnimSpritePal_Smoke, ANIM_TAG_SMOKE}, + {gBattleAnimSpritePal_Smoke, ANIM_TAG_SMOKE_2}, + {gBattleAnimSpritePal_Impact, ANIM_TAG_IMPACT}, + {gBattleAnimSpritePal_CircleImpact, ANIM_TAG_CIRCLE_IMPACT}, + {gBattleAnimSpritePal_Impact, ANIM_TAG_SCRATCH}, + {gBattleAnimSpritePal_Impact, ANIM_TAG_CUT}, + {gBattleAnimSpritePal_SharpTeeth, ANIM_TAG_SHARP_TEETH}, + {gBattleAnimSpritePal_RainbowRings, ANIM_TAG_RAINBOW_RINGS}, + {gBattleAnimSpritePal_IceCrystals, ANIM_TAG_ICE_CRYSTALS}, + {gBattleAnimSpritePal_IceCrystals, ANIM_TAG_ICE_SPIKES}, + {gBattleAnimSpritePal_HandsAndFeet, ANIM_TAG_HANDS_AND_FEET}, + {gBattleAnimSpritePal_MistCloud, ANIM_TAG_MIST_CLOUD}, + {gBattleAnimSpritePal_SharpTeeth, ANIM_TAG_CLAMP}, + {gBattleAnimSpritePal_RainDrops, ANIM_TAG_BUBBLE}, + {gBattleAnimSpritePal_Orbs, ANIM_TAG_ORBS}, + {gBattleAnimSpritePal_WaterImpact, ANIM_TAG_WATER_IMPACT}, + {gBattleAnimSpritePal_WaterImpact, ANIM_TAG_WATER_ORB}, + {gBattleAnimSpritePal_PoisonBubble, ANIM_TAG_POISON_BUBBLE}, + {gBattleAnimSpritePal_PoisonBubble, ANIM_TAG_TOXIC_BUBBLE}, + {gBattleAnimSpritePal_Spikes, ANIM_TAG_SPIKES}, + {gBattleAnimSpritePal_HornHit2, ANIM_TAG_HORN_HIT_2}, + {gBattleAnimSpritePal_AirWave2, ANIM_TAG_AIR_WAVE_2}, + {gBattleAnimSpritePal_SmallBubbles, ANIM_TAG_SMALL_BUBBLES}, + {gBattleAnimSpritePal_RoundShadow, ANIM_TAG_ROUND_SHADOW}, + {gBattleAnimSpritePal_Sunlight, ANIM_TAG_SUNLIGHT}, + {gBattleAnimSpritePal_Spore, ANIM_TAG_SPORE}, + {gBattleAnimSpritePal_Flower, ANIM_TAG_FLOWER}, + {gBattleAnimSpritePal_RazorLeaf, ANIM_TAG_RAZOR_LEAF}, + {gBattleAnimSpritePal_Needle, ANIM_TAG_NEEDLE}, + {gBattleAnimSpritePal_WhirlwindLines, ANIM_TAG_WHIRLWIND_LINES}, + {gBattleAnimSpritePal_GoldRing, ANIM_TAG_GOLD_RING}, + {gBattleAnimSpritePal_PurpleRing, ANIM_TAG_PURPLE_RING}, + {gBattleAnimSpritePal_BlueRing, ANIM_TAG_BLUE_RING}, + {gBattleAnimSpritePal_GreenLightWall, ANIM_TAG_GREEN_LIGHT_WALL}, + {gBattleAnimSpritePal_BlueLightWall, ANIM_TAG_BLUE_LIGHT_WALL}, + {gBattleAnimSpritePal_RedLightWall, ANIM_TAG_RED_LIGHT_WALL}, + {gBattleAnimSpritePal_GrayLightWall, ANIM_TAG_GRAY_LIGHT_WALL}, + {gBattleAnimSpritePal_OrangeLightWall, ANIM_TAG_ORANGE_LIGHT_WALL}, + {gBattleAnimSpritePal_BlackBall2, ANIM_TAG_BLACK_BALL_2}, + {gBattleAnimSpritePal_PurpleGasCloud, ANIM_TAG_PURPLE_GAS_CLOUD}, + {gBattleAnimSpritePal_Spark, ANIM_TAG_SPARK_H}, + {gBattleAnimSpritePal_YellowStar, ANIM_TAG_YELLOW_STAR}, + {gBattleAnimSpritePal_LargeFreshEgg, ANIM_TAG_LARGE_FRESH_EGG}, + {gBattleAnimSpritePal_ShadowBall, ANIM_TAG_SHADOW_BALL}, + {gBattleAnimSpritePal_Lick, ANIM_TAG_LICK}, + {gBattleAnimSpritePal_VoidLines, ANIM_TAG_VOID_LINES}, + {gBattleAnimSpritePal_String, ANIM_TAG_STRING}, + {gBattleAnimSpritePal_String, ANIM_TAG_WEB_THREAD}, + {gBattleAnimSpritePal_String, ANIM_TAG_SPIDER_WEB}, + {gBattleAnimSpritePal_Lightbulb, ANIM_TAG_LIGHTBULB}, + {gBattleAnimSpritePal_Slash, ANIM_TAG_SLASH}, + {gBattleAnimSpritePal_FocusEnergy, ANIM_TAG_FOCUS_ENERGY}, + {gBattleAnimSpritePal_SphereToCube, ANIM_TAG_SPHERE_TO_CUBE}, + {gBattleAnimSpritePal_Tendrils, ANIM_TAG_TENDRILS}, + {gBattleAnimSpritePal_Eye, ANIM_TAG_EYE}, + {gBattleAnimSpritePal_WhiteShadow, ANIM_TAG_WHITE_SHADOW}, + {gBattleAnimSpritePal_TealAlert, ANIM_TAG_TEAL_ALERT}, + {gBattleAnimSpritePal_OpeningEye, ANIM_TAG_OPENING_EYE}, + {gBattleAnimSpritePal_RoundWhiteHalo, ANIM_TAG_ROUND_WHITE_HALO}, + {gBattleAnimSpritePal_FangAttack, ANIM_TAG_FANG_ATTACK}, + {gBattleAnimSpritePal_PurpleHandOutline, ANIM_TAG_PURPLE_HAND_OUTLINE}, + {gBattleAnimSpritePal_Moon, ANIM_TAG_MOON}, + {gBattleAnimSpritePal_GreenSparkle, ANIM_TAG_GREEN_SPARKLE}, + {gBattleAnimSpritePal_Spiral, ANIM_TAG_SPIRAL}, + {gBattleAnimSpritePal_SnoreZ, ANIM_TAG_SNORE_Z}, + {gBattleAnimSpritePal_Explosion, ANIM_TAG_EXPLOSION}, + {gBattleAnimSpritePal_Nail, ANIM_TAG_NAIL}, + {gBattleAnimSpritePal_GhostlySpirit, ANIM_TAG_GHOSTLY_SPIRIT}, + {gBattleAnimSpritePal_WarmRock, ANIM_TAG_WARM_ROCK}, + {gBattleAnimSpritePal_BreakingEgg, ANIM_TAG_BREAKING_EGG}, + {gBattleAnimSpritePal_ThinRing, ANIM_TAG_THIN_RING}, + {gBattleAnimSpritePal_PunchImpact, ANIM_TAG_PUNCH_IMPACT}, + {gBattleAnimSpritePal_Bell, ANIM_TAG_BELL}, + {gBattleAnimSpritePal_MusicNotes2, ANIM_TAG_MUSIC_NOTES_2}, + {gBattleAnimSpritePal_SpeedDust, ANIM_TAG_SPEED_DUST}, + {gBattleAnimSpritePal_BlueLightWall, ANIM_TAG_TORN_METAL}, + {gBattleAnimSpritePal_ThoughtBubble, ANIM_TAG_THOUGHT_BUBBLE}, + {gBattleAnimSpritePal_MagentaHeart, ANIM_TAG_MAGENTA_HEART}, + {gBattleAnimSpritePal_ElectricOrbs, ANIM_TAG_ELECTRIC_ORBS}, + {gBattleAnimSpritePal_ElectricOrbs, ANIM_TAG_CIRCLE_OF_LIGHT}, + {gBattleAnimSpritePal_ElectricOrbs, ANIM_TAG_ELECTRICITY}, + {gBattleAnimSpritePal_Finger, ANIM_TAG_FINGER_2}, + {gBattleAnimSpritePal_MovementWaves, ANIM_TAG_MOVEMENT_WAVES}, + {gBattleAnimSpritePal_RedHeart, ANIM_TAG_RED_HEART}, + {gBattleAnimSpritePal_RedOrb, ANIM_TAG_RED_ORB}, + {gBattleAnimSpritePal_EyeSparkle, ANIM_TAG_EYE_SPARKLE}, + {gBattleAnimSpritePal_PinkHeart, ANIM_TAG_PINK_HEART}, + {gBattleAnimSpritePal_Angel, ANIM_TAG_ANGEL}, + {gBattleAnimSpritePal_Devil, ANIM_TAG_DEVIL}, + {gBattleAnimSpritePal_Swipe, ANIM_TAG_SWIPE}, + {gBattleAnimSpritePal_Roots, ANIM_TAG_ROOTS}, + {gBattleAnimSpritePal_ItemBag, ANIM_TAG_ITEM_BAG}, + {gBattleAnimSpritePal_JaggedMusicNote, ANIM_TAG_JAGGED_MUSIC_NOTE}, + {gBattleAnimSpritePal_Pokeball, ANIM_TAG_POKEBALL}, + {gBattleAnimSpritePal_Pokeball, ANIM_TAG_SPOTLIGHT}, + {gBattleAnimSpritePal_LetterZ, ANIM_TAG_LETTER_Z}, + {gBattleAnimSpritePal_RapidSpin, ANIM_TAG_RAPID_SPIN}, + {gBattleAnimSpritePal_TriForceTriangle, ANIM_TAG_TRI_FORCE_TRIANGLE}, + {gBattleAnimSpritePal_WispOrb, ANIM_TAG_WISP_ORB}, + {gBattleAnimSpritePal_WispOrb, ANIM_TAG_WISP_FIRE}, + {gBattleAnimSpritePal_GoldStars, ANIM_TAG_GOLD_STARS}, + {gBattleAnimSpritePal_EclipsingOrb, ANIM_TAG_ECLIPSING_ORB}, + {gBattleAnimSpritePal_GrayOrb, ANIM_TAG_GRAY_ORB}, + {gBattleAnimSpritePal_BlueOrb, ANIM_TAG_BLUE_ORB}, + {gBattleAnimSpritePal_RedOrb2, ANIM_TAG_RED_ORB_2}, + {gBattleAnimSpritePal_PinkPetal, ANIM_TAG_PINK_PETAL}, + {gBattleAnimSpritePal_PainSplit, ANIM_TAG_PAIN_SPLIT}, + {gBattleAnimSpritePal_Confetti, ANIM_TAG_CONFETTI}, + {gBattleAnimSpritePal_GreenStar, ANIM_TAG_GREEN_STAR}, + {gBattleAnimSpritePal_PinkCloud, ANIM_TAG_PINK_CLOUD}, + {gBattleAnimSpritePal_SweatDrop, ANIM_TAG_SWEAT_DROP}, + {gBattleAnimSpritePal_GuardRing, ANIM_TAG_GUARD_RING}, + {gBattleAnimSpritePal_PurpleScratch, ANIM_TAG_PURPLE_SCRATCH}, + {gBattleAnimSpritePal_PurpleScratch, ANIM_TAG_PURPLE_SWIPE}, + {gBattleAnimSpritePal_Finger, ANIM_TAG_TAG_HAND}, + {gBattleAnimSpritePal_SmallRedEye, ANIM_TAG_SMALL_RED_EYE}, + {gBattleAnimSpritePal_HollowOrb, ANIM_TAG_HOLLOW_ORB}, + {gBattleAnimSpritePal_HollowOrb, ANIM_TAG_X_SIGN}, + {gBattleAnimSpritePal_BluegreenOrb, ANIM_TAG_BLUEGREEN_ORB}, + {gBattleAnimSpritePal_PawPrint, ANIM_TAG_PAW_PRINT}, + {gBattleAnimSpritePal_PurpleFlame, ANIM_TAG_PURPLE_FLAME}, + {gBattleAnimSpritePal_RedBall, ANIM_TAG_RED_BALL}, + {gBattleAnimSpritePal_SmellingsaltEffect, ANIM_TAG_SMELLINGSALT_EFFECT}, + {gBattleAnimSpritePal_Meteor, ANIM_TAG_METEOR}, + {gBattleAnimSpritePal_FlatRock, ANIM_TAG_FLAT_ROCK}, + {gBattleAnimSpritePal_MagnifyingGlass, ANIM_TAG_MAGNIFYING_GLASS}, + {gBattleAnimSpritePal_BrownOrb, ANIM_TAG_BROWN_ORB}, + {gBattleAnimSpritePal_MetalSoundWaves, ANIM_TAG_METAL_SOUND_WAVES}, + {gBattleAnimSpritePal_FlyingDirt, ANIM_TAG_FLYING_DIRT}, + {gBattleAnimSpritePal_IcicleSpear, ANIM_TAG_ICICLE_SPEAR}, + {gBattleAnimSpritePal_Hail, ANIM_TAG_HAIL}, + {gBattleAnimSpritePal_GlowyRedOrb, ANIM_TAG_GLOWY_RED_ORB}, + {gBattleAnimSpritePal_GlowyGreenOrb, ANIM_TAG_GLOWY_GREEN_ORB}, + {gBattleAnimSpritePal_GreenSpike, ANIM_TAG_GREEN_SPIKE}, + {gBattleAnimSpritePal_WhiteCircleOfLight, ANIM_TAG_WHITE_CIRCLE_OF_LIGHT}, + {gBattleAnimSpritePal_GlowyBlueOrb, ANIM_TAG_GLOWY_BLUE_ORB}, + {gBattleAnimSpritePal_Pokeblock, ANIM_TAG_POKEBLOCK}, + {gBattleAnimSpritePal_WhiteFeather, ANIM_TAG_WHITE_FEATHER}, + {gBattleAnimSpritePal_Sparkle6, ANIM_TAG_SPARKLE_6}, + {gBattleAnimSpritePal_Splash, ANIM_TAG_SPLASH}, + {gBattleAnimSpritePal_Splash, ANIM_TAG_SWEAT_BEAD}, + {gBattleAnimSpritePal_Gem1, ANIM_TAG_GEM_1}, + {gBattleAnimSpritePal_Gem1, ANIM_TAG_GEM_2}, + {gBattleAnimSpritePal_Gem1, ANIM_TAG_GEM_3}, + {gBattleAnimSpritePal_SlamHit2, ANIM_TAG_SLAM_HIT_2}, + {gBattleAnimSpritePal_Recycle, ANIM_TAG_RECYCLE}, + {gBattleAnimSpritePal_RedParticles, ANIM_TAG_RED_PARTICLES}, + {gBattleAnimSpritePal_Protect, ANIM_TAG_PROTECT}, + {gBattleAnimSpritePal_DirtMound, ANIM_TAG_DIRT_MOUND}, + {gBattleAnimSpritePal_Shock3, ANIM_TAG_SHOCK_3}, + {gBattleAnimSpritePal_WeatherBall, ANIM_TAG_WEATHER_BALL}, + {gBattleAnimSpritePal_Bird, ANIM_TAG_BIRD}, + {gBattleAnimSpritePal_CrossImpact, ANIM_TAG_CROSS_IMPACT}, + {gBattleAnimSpritePal_Slash2, ANIM_TAG_SLASH_2}, + {gBattleAnimSpritePal_WhipHit, ANIM_TAG_WHIP_HIT}, + {gBattleAnimSpritePal_BlueRing2, ANIM_TAG_BLUE_RING_2}, +}; + +const struct BattleAnimBackground gBattleAnimBackgroundTable[] = // 83ADE18 +{ + [BG_DARK_] = {gBattleAnimBgImage_Dark, gBattleAnimBgPalette_Dark, gBattleAnimBgTilemap_Dark}, + [BG_DARK] = {gBattleAnimBgImage_Dark, gBattleAnimBgPalette_Dark, gBattleAnimBgTilemap_Dark}, + [BG_GHOST] = {gBattleAnimBgImage_Ghost, gBattleAnimBgPalette_Ghost, gBattleAnimBgTilemap_Ghost}, + [BG_PSYCHIC] = {gBattleAnimBgImage_Psychic, gBattleAnimBgPalette_Psychic, gBattleAnimBgTilemap_Psychic}, + [BG_IMPACT_OPPONENT] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Impact, gBattleAnimBgTilemap_ImpactOpponent}, + [BG_IMPACT_PLAYER] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Impact, gBattleAnimBgTilemap_ImpactPlayer}, + [BG_IMPACT_CONTESTS] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Impact, gBattleAnimBgTilemap_ImpactContests}, + [BG_DRILL] = {gBattleAnimBgImage_Drill, gBattleAnimBgPalette_Drill, gBattleAnimBgTilemap_Drill}, + [BG_DRILL_CONTESTS] = {gBattleAnimBgImage_Drill, gBattleAnimBgPalette_Drill, gBattleAnimBgTilemap_DrillContests}, + [BG_HIGHSPEED_OPPONENT] = {gBattleAnimBgImage_Highspeed, gBattleAnimBgPalette_Highspeed, gBattleAnimBgTilemap_HighspeedOpponent}, + [BG_HIGHSPEED_PLAYER] = {gBattleAnimBgImage_Highspeed, gBattleAnimBgPalette_Highspeed, gBattleAnimBgTilemap_HighspeedPlayer}, + [BG_THUNDER] = {gBattleAnimBgImage_Thunder, gBattleAnimBgPalette_Thunder, gBattleAnimBgTilemap_Thunder}, + [BG_GUILLOTINE_OPPONENT] = {gBattleAnimBgImage_Guillotine, gBattleAnimBgPalette_Guillotine, gBattleAnimBgTilemap_GuillotineOpponent}, + [BG_GUILLOTINE_PLAYER] = {gBattleAnimBgImage_Guillotine, gBattleAnimBgPalette_Guillotine, gBattleAnimBgTilemap_GuillotinePlayer}, + [BG_GUILLOTINE_CONTESTS] = {gBattleAnimBgImage_Guillotine, gBattleAnimBgPalette_Guillotine, gBattleAnimBgTilemap_GuillotineContests}, + [BG_ICE] = {gBattleAnimBgImage_Ice, gBattleAnimBgPalette_Ice, gBattleAnimBgTilemap_Ice}, + [BG_COSMIC] = {gBattleAnimBgImage_Cosmic, gBattleAnimBgPalette_Cosmic, gBattleAnimBgTilemap_Cosmic}, + [BG_IN_AIR] = {gBattleAnimBgImage_InAir, gBattleAnimBgPalette_InAir, gBattleAnimBgTilemap_InAir}, + [BG_SKY] = {gBattleAnimBgImage_Drill, gBattleAnimBgPalette_Sky, gBattleAnimBgTilemap_Drill}, + [BG_SKY_CONTESTS] = {gBattleAnimBgImage_Drill, gBattleAnimBgPalette_Sky, gBattleAnimBgTilemap_DrillContests}, + [BG_AURORA] = {gBattleAnimBgImage_Aurora, gBattleAnimBgPalette_Aurora, gBattleAnimBgTilemap_Aurora}, + [BG_FISSURE] = {gBattleAnimBgImage_Fissure, gBattleAnimBgPalette_Fissure, gBattleAnimBgTilemap_Fissure}, + [BG_BUG_OPPONENT] = {gBattleAnimBgImage_Highspeed, gBattleAnimBgPalette_Bug, gBattleAnimBgTilemap_HighspeedOpponent}, + [BG_BUG_PLAYER] = {gBattleAnimBgImage_Highspeed, gBattleAnimBgPalette_Bug, gBattleAnimBgTilemap_HighspeedPlayer}, + [BG_SOLARBEAM_OPPONENT] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Solarbeam, gBattleAnimBgTilemap_ImpactOpponent}, + [BG_SOLARBEAM_PLAYER] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Solarbeam, gBattleAnimBgTilemap_ImpactPlayer}, + [BG_SOLARBEAM_CONTESTS] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Solarbeam, gBattleAnimBgTilemap_ImpactContests}, +}; + +static void (* const sScriptCmdTable[])(void) = // 83ADF5C { ScriptCmd_loadspritegfx, ScriptCmd_unloadspritegfx, -- cgit v1.2.3 From 9bc5170673883795cc4397aa010a1dd08cad9d85 Mon Sep 17 00:00:00 2001 From: Evan Date: Sun, 1 Dec 2019 13:00:24 -0500 Subject: resolve data/battle_anim.s --- src/battle_anim.c | 1009 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1009 insertions(+) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index fc22231bc..be78558ca 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -103,6 +103,1015 @@ static void ScriptCmd_doublebattle_2E(void); static void ScriptCmd_stopsound(void); // Data +const struct OamData gOamData_AffineOff_ObjNormal_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + + +const struct OamData gOamData_AffineOff_ObjNormal_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjNormal_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineOff_ObjBlend_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x8), + .x = 0, + .size = SPRITE_SIZE(16x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x32), + .x = 0, + .size = SPRITE_SIZE(64x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x32), + .x = 0, + .size = SPRITE_SIZE(8x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x32), + .x = 0, + .size = SPRITE_SIZE(16x32), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_DOUBLE, + .objMode = ST_OAM_OBJ_BLEND, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x64), + .x = 0, + .size = SPRITE_SIZE(32x64), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + const struct CompressedSpriteSheet gBattleAnimPicTable[] = // 83ACC08 { {gBattleAnimSpriteGfx_Bone, 0x0200, ANIM_TAG_BONE}, -- cgit v1.2.3 From 2f3ad837110bf47aeb1b3cf4f34531878d55e720 Mon Sep 17 00:00:00 2001 From: Evan Date: Sun, 1 Dec 2019 20:23:36 -0500 Subject: start anim objtemplates --- src/battle_anim.c | 298 ++- src/battle_anim_effects_1.c | 5617 +++++++++++++++++++++++++++++++++++++++++++ src/battle_anim_mons.c | 4 +- src/bug.c | 18 +- src/dark.c | 10 +- src/dragon.c | 12 +- src/electric.c | 36 +- src/fighting.c | 40 +- src/fire.c | 38 +- src/flying.c | 32 +- src/ghost.c | 18 +- src/ground.c | 14 +- src/ice.c | 38 +- src/mevent_8145654.c | 4 +- src/normal.c | 20 +- src/oak_speech.c | 20 +- src/poison.c | 14 +- src/psychic.c | 32 +- src/rock.c | 28 +- src/text.c | 4 +- 20 files changed, 5948 insertions(+), 349 deletions(-) create mode 100644 src/battle_anim_effects_1.c (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index be78558ca..de5f08f38 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -3,6 +3,7 @@ #include "battle_anim.h" #include "battle_controllers.h" #include "battle_interface.h" +#include "battle_bg.h" #include "bg.h" #include "decompress.h" #include "dma3.h" @@ -22,6 +23,8 @@ extern const u16 gMovesWithQuietBGM[]; extern const u8 *const gBattleAnims_Moves[]; +extern const struct CompressedSpriteSheet gUnknown_8399388[]; +extern const struct CompressedSpritePalette gUnknown_8399C90[]; // RAM EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; @@ -53,6 +56,16 @@ static void AddSpriteIndex(u16 index); static void ClearSpriteIndex(u16 index); static void WaitAnimFrameCount(void); static void RunAnimScriptCommand(void); +static void sub_8073558(u8 taskId); +static void Task_FadeToBg(u8 taskId); +static void Task_PanFromInitialToTarget(u8 taskId); +static void task_pA_ma0A_obj_to_bg_pal(u8 taskId); +static void LoadMoveBg(u16 bgId); +static void LoadDefaultBg(void); +static void Task_LoopAndPlaySE(u8 taskId); +static void Task_WaitAndPlaySE(u8 taskId); +static void sub_807331C(u8 taskId); + static void ScriptCmd_loadspritegfx(void); static void ScriptCmd_unloadspritegfx(void); static void ScriptCmd_createsprite(void); @@ -103,7 +116,7 @@ static void ScriptCmd_doublebattle_2E(void); static void ScriptCmd_stopsound(void); // Data -const struct OamData gOamData_AffineOff_ObjNormal_8x8 = +const struct OamData gOamData_AffineOff_ObjNormal_8x8 = //gOamData_83AC9C8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -118,7 +131,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x8 = }; -const struct OamData gOamData_AffineOff_ObjNormal_16x16 = +const struct OamData gOamData_AffineOff_ObjNormal_16x16 = //gOamData_83AC9D0 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -132,7 +145,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x32 = +const struct OamData gOamData_AffineOff_ObjNormal_32x32 = //gOamData_83AC9D8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -146,7 +159,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_64x64 = +const struct OamData gOamData_AffineOff_ObjNormal_64x64 = //gOamData_83AC9E0 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -160,7 +173,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_16x8 = +const struct OamData gOamData_AffineOff_ObjNormal_16x8 = //gOamData_83AC9E8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -174,7 +187,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x8 = +const struct OamData gOamData_AffineOff_ObjNormal_32x8 = //gOamData_83AC9F0 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -188,7 +201,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x16 = +const struct OamData gOamData_AffineOff_ObjNormal_32x16 = //gOamData_83AC9F8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -202,7 +215,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_64x32 = +const struct OamData gOamData_AffineOff_ObjNormal_64x32 = //gOamData_83ACA00 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -216,7 +229,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_8x16 = +const struct OamData gOamData_AffineOff_ObjNormal_8x16 = //gOamData_83ACA08 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -230,7 +243,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_8x32 = +const struct OamData gOamData_AffineOff_ObjNormal_8x32 = //gOamData_83ACA10 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -244,7 +257,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_16x32 = +const struct OamData gOamData_AffineOff_ObjNormal_16x32 = //gOamData_83ACA18 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -258,7 +271,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x64 = +const struct OamData gOamData_AffineOff_ObjNormal_32x64 = //gOamData_83ACA20 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -272,7 +285,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = +const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = //gOamData_83ACA28 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -286,7 +299,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = +const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = //gOamData_83ACA30 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -300,7 +313,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = +const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = //gOamData_83ACA38 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -314,7 +327,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = +const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = //gOamData_83ACA40 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -328,7 +341,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = +const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = //gOamData_83ACA48 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -342,7 +355,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = +const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = //gOamData_83ACA50 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -356,7 +369,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = +const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = //gOamData_83ACA58 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -370,7 +383,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = +const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = //gOamData_83ACA60 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -384,7 +397,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = +const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = //gOamData_83ACA68 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -398,7 +411,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = +const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = //gOamData_83ACA70 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -412,7 +425,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = +const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = //gOamData_83ACA78 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -426,7 +439,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = +const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = //gOamData_83ACA80 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -440,7 +453,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = +const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = //gOamData_83ACA88 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -454,7 +467,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = +const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = //gOamData_83ACA90 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -468,7 +481,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = +const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = //gOamData_83ACA98 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -482,7 +495,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = +const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = //gOamData_83ACAA0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -496,7 +509,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = +const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = //gOamData_83ACAA8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -510,7 +523,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = +const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = //gOamData_83ACAB0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -524,7 +537,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = +const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = //gOamData_83ACAB8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -538,7 +551,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = +const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = //gOamData_83ACAC0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -552,7 +565,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = +const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = //gOamData_83ACAC8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -566,7 +579,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = +const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = //gOamData_83ACAD0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -580,7 +593,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = +const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = //gOamData_83ACAD8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -594,7 +607,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = +const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = //gOamData_83ACAE0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -608,7 +621,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x8 = +const struct OamData gOamData_AffineOff_ObjBlend_8x8 = //gOamData_83ACAE8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -622,7 +635,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x16 = +const struct OamData gOamData_AffineOff_ObjBlend_16x16 = //gOamData_83ACAF0 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -636,7 +649,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x32 = +const struct OamData gOamData_AffineOff_ObjBlend_32x32 = //gOamData_83ACAF8 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -650,7 +663,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_64x64 = +const struct OamData gOamData_AffineOff_ObjBlend_64x64 = //gOamData_83ACB00 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -664,7 +677,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x8 = +const struct OamData gOamData_AffineOff_ObjBlend_16x8 = //gOamData_83ACB08 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -678,7 +691,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x8 = +const struct OamData gOamData_AffineOff_ObjBlend_32x8 = //gOamData_83ACB10 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -692,7 +705,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x16 = +const struct OamData gOamData_AffineOff_ObjBlend_32x16 = //gOamData_83ACB18 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -706,7 +719,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_64x32 = +const struct OamData gOamData_AffineOff_ObjBlend_64x32 = //gOamData_83ACB20 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -720,7 +733,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x16 = +const struct OamData gOamData_AffineOff_ObjBlend_8x16 = //gOamData_83ACB28 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -734,7 +747,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x32 = +const struct OamData gOamData_AffineOff_ObjBlend_8x32 = //gOamData_83ACB30 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -748,7 +761,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x32 = +const struct OamData gOamData_AffineOff_ObjBlend_16x32 = //gOamData_83ACB38 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -762,7 +775,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x64 = +const struct OamData gOamData_AffineOff_ObjBlend_32x64 = //gOamData_83ACB40 { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -776,7 +789,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = +const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = //gOamData_83ACB48 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -790,7 +803,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = +const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = //gOamData_83ACB50 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -804,7 +817,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = +const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = //gOamData_83ACB58 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -818,7 +831,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = +const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = //gOamData_83ACB60 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -832,7 +845,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = +const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = //gOamData_83ACB68 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -846,7 +859,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = +const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = //gOamData_83ACB70 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -860,7 +873,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = +const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = //gOamData_83ACB78 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -874,7 +887,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = +const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = //gOamData_83ACB80 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -888,7 +901,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = +const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = //gOamData_83ACB88 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -902,7 +915,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = +const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = //gOamData_83ACB90 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -916,7 +929,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = +const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = //gOamData_83ACB98 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -930,7 +943,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = +const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = //gOamData_83ACBA0 { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -944,7 +957,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = +const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = //gOamData_83ACBA8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -958,7 +971,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = +const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = //gOamData_83ACBB0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -972,7 +985,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = +const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = //gOamData_83ACBB8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -986,7 +999,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = +const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = //gOamData_83ACBC0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1000,7 +1013,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = +const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = //gOamData_83ACBC8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1014,7 +1027,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = +const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = //gOamData_83ACBD0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1028,7 +1041,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = +const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = //gOamData_83ACBD8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1042,7 +1055,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = +const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = //gOamData_83ACBE0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1056,7 +1069,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = +const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = //gOamData_83ACBE8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1070,7 +1083,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = +const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = //gOamData_83ACBF0 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1084,7 +1097,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = +const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = //gOamData_83ACBF8 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1098,7 +1111,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = +const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = //gOamData_83ACC00 { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1944,8 +1957,8 @@ static void ScriptCmd_loadspritegfx(void) sBattleAnimScriptPtr++; index = T1_READ_16(sBattleAnimScriptPtr); - LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)]); - LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(index)]); + LoadCompressedSpriteSheetUsingHeap(&gUnknown_8399388[GET_TRUE_SPRITE_INDEX(index)]); + LoadCompressedSpritePaletteUsingHeap(&gUnknown_8399C90[GET_TRUE_SPRITE_INDEX(index)]); sBattleAnimScriptPtr += 2; AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); gAnimFramesToWait = 1; @@ -2072,6 +2085,13 @@ static void ScriptCmd_waitforvisualfinish(void) } } +static void ScriptCmd_hang1(void) +{ +} +static void ScriptCmd_hang2(void) +{ +} + static void ScriptCmd_end(void) { s32 i; @@ -2117,11 +2137,8 @@ static void ScriptCmd_end(void) if (!continuousAnim) // May have been used for debug? { m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256); - if (!IsContest()) - { - sub_80A8278(); - UpdateOamPriorityInAllHealthboxes(1); - } + sub_80767F0(); + UpdateOamPriorityInAllHealthboxes(1); gAnimScriptActive = FALSE; } } @@ -2160,12 +2177,11 @@ static void ScriptCmd_monbg(void) if (IsBattlerSpriteVisible(battlerId)) { u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) // || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; - else - toBG_2 = TRUE; - MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + MoveBattlerSpriteToBG(battlerId, toBG_2); taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); gAnimVisualTaskCount++; gTasks[taskId].data[t1_MONBG_BATTLER] = battlerId; @@ -2179,12 +2195,11 @@ static void ScriptCmd_monbg(void) if (IsBattlerSpriteVisible(battlerId)) { u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) // || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; - else - toBG_2 = TRUE; - MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + MoveBattlerSpriteToBG(battlerId, toBG_2); taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); gAnimVisualTaskCount++; gTasks[taskId].data[0] = battlerId; @@ -2266,7 +2281,7 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) } } -void sub_80730C0(u16 a, u16 *b, u32 c, u8 d) +void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) { s32 i, j; s32 var; @@ -2275,6 +2290,7 @@ void sub_80730C0(u16 a, u16 *b, u32 c, u8 d) var = 32; else var = 64; + a <<= 12; for (i = 0; i < var; i++) { @@ -2288,17 +2304,17 @@ void sub_8073128(bool8 to_BG2) struct BattleAnimBgData animBg; sub_80752A0(&animBg); - if (!to_BG2)) + if (!to_BG2) { sub_8075358(1); - gBattle_BG1_X = NULL; - gBattle_BG1_Y = NULL; + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; } else { sub_8075358(2); - gBattle_BG2_X = NULL; - gBattle_BG2_Y = NULL; + gBattle_BG2_X = 0; + gBattle_BG2_Y = 0; } } @@ -2378,10 +2394,9 @@ static void sub_807331C(u8 taskId) { u8 to_BG2; u8 position = GetBattlerPosition(gTasks[taskId].data[2]); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + to_BG2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) to_BG2 = FALSE; - else - to_BG2 = TRUE; if (sMonAnimTaskIdArray[0] != 0xFF) { @@ -2422,24 +2437,22 @@ static void ScriptCmd_monbg_22(void) if (IsBattlerSpriteVisible(battlerId)) { u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; - else - toBG_2 = TRUE; - MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + MoveBattlerSpriteToBG(battlerId, toBG_2); } battlerId ^= BIT_FLANK; if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId)) { u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) + toBG_2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; - else - toBG_2 = TRUE; - MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE); + MoveBattlerSpriteToBG(battlerId, toBG_2); } sBattleAnimScriptPtr++; @@ -2480,19 +2493,21 @@ static void ScriptCmd_clearmonbg_23(void) static void sub_8073558(u8 taskId) { - gTasks[taskId].data[1]++; + bool8 to_BG2; + + gTasks[taskId].data[1]++; if (gTasks[taskId].data[1] != 1) { bool8 toBG_2; u8 battlerId = gTasks[taskId].data[2]; u8 position = GetBattlerPosition(battlerId); - if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) - toBG_2 = FALSE; - else - toBG_2 = TRUE; + to_BG2 = TRUE; + if (position < B_POSITION_OPPONENT_LEFT) + to_BG2 = FALSE; if (IsBattlerSpriteVisible(battlerId)) sub_8073128(toBG_2); + if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) sub_8073128(toBG_2 ^ 1); @@ -2627,9 +2642,7 @@ static void ScriptCmd_fadetobgfromset(void) sBattleAnimScriptPtr += 3; taskId = CreateTask(Task_FadeToBg, 5); - if (IsContest()) - gTasks[taskId].tBackgroundId = bg3; - else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) gTasks[taskId].tBackgroundId = bg2; else gTasks[taskId].tBackgroundId = bg1; @@ -2676,34 +2689,14 @@ static void Task_FadeToBg(u8 taskId) static void LoadMoveBg(u16 bgId) { - if (IsContest()) - { - const u32 *tilemap = gBattleAnimBackgroundTable[bgId].tilemap; - void *dmaSrc; - void *dmaDest; - - LZDecompressWram(tilemap, gDecompressionBuffer); - sub_80730C0(sub_80A6D94(), (void*)(gDecompressionBuffer), 0x100, 0); - dmaSrc = gDecompressionBuffer; - dmaDest = (void *)(BG_SCREEN_ADDR(26)); - DmaCopy32(3, dmaSrc, dmaDest, 0x800); - LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_SCREEN_ADDR(4))); - LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, sub_80A6D94() * 16, 32); - } - else - { - LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26))); - LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2))); - LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32); - } + LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26))); + LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2))); + LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32); } static void LoadDefaultBg(void) { - if (IsContest()) - LoadContestBgAfterMoveAnim(); - else - DrawMainBattleBackground(); + DrawMainBattleBackground(); } static void ScriptCmd_restorebg(void) @@ -2754,18 +2747,13 @@ static void ScriptCmd_changebg(void) s8 BattleAnimAdjustPanning(s8 pan) { - if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) + if (gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) { if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) pan = SOUND_PAN_TARGET; else pan = SOUND_PAN_ATTACKER; } - else if (IsContest()) - { - if (gBattleAnimAttacker != gBattleAnimTarget || gBattleAnimAttacker != 2 || pan != SOUND_PAN_TARGET) - pan *= -1; - } else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) { if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) @@ -2796,7 +2784,7 @@ s8 BattleAnimAdjustPanning(s8 pan) s8 BattleAnimAdjustPanning2(s8 pan) { - if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) + if (gBattleSpritesDataPtr->healthBoxesData[gBattleAnimAttacker].statusAnimActive) { if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) pan = SOUND_PAN_TARGET; @@ -2805,7 +2793,7 @@ s8 BattleAnimAdjustPanning2(s8 pan) } else { - if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER || IsContest()) + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) pan = -pan; } return pan; @@ -2896,7 +2884,7 @@ static void ScriptCmd_panse_1B(void) sBattleAnimScriptPtr += 6; } -void Task_PanFromInitialToTarget(u8 taskId) +static void Task_PanFromInitialToTarget(u8 taskId) { bool32 destroyTask = FALSE; if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait) @@ -3169,10 +3157,7 @@ static void ScriptCmd_jumpargeq(void) static void ScriptCmd_jumpifcontest(void) { sBattleAnimScriptPtr++; - if (IsContest()) - sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); - else - sBattleAnimScriptPtr += 4; + sBattleAnimScriptPtr += 5; } static void ScriptCmd_monbgprio_28(void) @@ -3190,7 +3175,7 @@ static void ScriptCmd_monbgprio_28(void) battlerId = gBattleAnimAttacker; battlerPosition = GetBattlerPosition(battlerId); - if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT)) + if (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT) { SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); @@ -3200,11 +3185,8 @@ static void ScriptCmd_monbgprio_28(void) static void ScriptCmd_monbgprio_29(void) { sBattleAnimScriptPtr++; - if (!IsContest()) - { - SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); - SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); - } + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); } static void ScriptCmd_monbgprio_2A(void) @@ -3223,7 +3205,7 @@ static void ScriptCmd_monbgprio_2A(void) battlerId = gBattleAnimAttacker; battlerPosition = GetBattlerPosition(battlerId); - if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT)) + if (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT) { SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); @@ -3261,7 +3243,7 @@ static void ScriptCmd_doublebattle_2D(void) wantedBattler = sBattleAnimScriptPtr[1]; sBattleAnimScriptPtr += 2; - if (!IsContest() && IsDoubleBattle() + if (IsDoubleBattle() && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) { if (wantedBattler == ANIM_ATTACKER) @@ -3296,7 +3278,7 @@ static void ScriptCmd_doublebattle_2E(void) wantedBattler = sBattleAnimScriptPtr[1]; sBattleAnimScriptPtr += 2; - if (!IsContest() && IsDoubleBattle() + if (IsDoubleBattle() && GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) { if (wantedBattler == ANIM_ATTACKER) diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c new file mode 100644 index 000000000..a02125d6d --- /dev/null +++ b/src/battle_anim_effects_1.c @@ -0,0 +1,5617 @@ +#include "global.h" +#include "malloc.h" +#include "battle_anim.h" +#include "battle_interface.h" +#include "decompress.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "main.h" +#include "math_util.h" +#include "palette.h" +#include "random.h" +#include "scanline_effect.h" +#include "sound.h" +#include "trig.h" +#include "util.h" +#include "constants/rgb.h" +#include "constants/songs.h" + +EWRAM_DATA s16 gUnknown_0203A0F8[4] = {0}; + +void AnimMovePowderParticle(struct Sprite *); +void AnimPowerAbsorptionOrb(struct Sprite *); +void AnimSolarbeamBigOrb(struct Sprite *); +void AnimSolarbeamSmallOrb(struct Sprite *); +void AnimAbsorptionOrb(struct Sprite *); +void AnimHyperBeamOrb(struct Sprite *); +void AnimSporeParticle(struct Sprite *); +void AnimPetalDanceBigFlower(struct Sprite *); +void AnimPetalDanceSmallFlower(struct Sprite *); +void AnimRazorLeafParticle(struct Sprite *); +void AnimLeechSeed(struct Sprite *); +void AnimTranslateLinearSingleSineWave(struct Sprite *); +void AnimMoveTwisterParticle(struct Sprite *); +void AnimConstrictBinding(struct Sprite *); +void AnimMimicOrb(struct Sprite *); +void AnimIngrainRoot(struct Sprite *); +void AnimFrenzyPlantRoot(struct Sprite *); +void AnimIngrainOrb(struct Sprite *); +void AnimPresent(struct Sprite *); +void AnimKnockOffItem(struct Sprite *); +void AnimPresentHealParticle(struct Sprite *); +void AnimItemSteal(struct Sprite *); +void AnimTrickBag(struct Sprite *); +void AnimFlyingParticle(struct Sprite *); +void AnimNeedleArmSpike(struct Sprite *); +void sub_80A43F8(struct Sprite *); +void AnimWhipHit(struct Sprite *); +void sub_80A4494(struct Sprite *); +void AnimCuttingSlice(struct Sprite *); +void AnimAirCutterSlice(struct Sprite *); +void sub_80A481C(struct Sprite *); +void AnimProtect(struct Sprite *); +void AnimMilkBottle(struct Sprite *); +void AnimGrantingStars(struct Sprite *); +void AnimSparkingStars(struct Sprite *); +void sub_80A4E40(struct Sprite *); +void AnimSleepLetterZ(struct Sprite *); +void AnimLockOnTarget(struct Sprite *); +void AnimLockOnMoveTarget(struct Sprite *); +void AnimBowMon(struct Sprite *); +void sub_80A5590(struct Sprite *); +void AnimSlashSlice(struct Sprite *); +void AnimFalseSwipeSlice(struct Sprite *); +void AnimFalseSwipePositionedSlice(struct Sprite *); +void AnimEndureEnergy(struct Sprite *); +void AnimSharpenSphere(struct Sprite *); +void AnimConversion(struct Sprite *); +void AnimConversion2(struct Sprite *); +void AnimMoon(struct Sprite *); +void AnimMoonlightSparkle(struct Sprite *); +void AnimHornHit(struct Sprite *); +void AnimSuperFang(struct Sprite *); +void AnimWavyMusicNotes(struct Sprite *); +void AnimFlyingMusicNotes(struct Sprite *); +void AnimBellyDrumHand(struct Sprite *); +void AnimSlowFlyingMusicNotes(struct Sprite *); +void AnimThoughtBubble(struct Sprite *); +void AnimMetronomeFinger(struct Sprite *); +void AnimFollowMeFinger(struct Sprite *); +void AnimTauntFinger(struct Sprite *); +static void AnimMovePowderParticleStep(struct Sprite *); +static void AnimSolarbeamSmallOrbStep(struct Sprite *); +static void AnimAbsorptionOrbStep(struct Sprite *); +static void AnimHyperBeamOrbStep(struct Sprite *); +static void AnimLeechSeedStep(struct Sprite *); +static void AnimLeechSeedSprouts(struct Sprite *); +static void AnimSporeParticleStep(struct Sprite *); +static void AnimPetalDanceBigFlowerStep(struct Sprite *); +static void AnimPetalDanceSmallFlowerStep(struct Sprite *); +static void AnimRazorLeafParticleStep1(struct Sprite *); +static void AnimRazorLeafParticleStep2(struct Sprite *); +static void AnimTranslateLinearSingleSineWaveStep(struct Sprite *); +static void AnimMoveTwisterParticleStep(struct Sprite *); +static void AnimConstrictBindingStep1(struct Sprite *); +static void AnimConstrictBindingStep2(struct Sprite *); +static void AnimTask_DuplicateAndShrinkToPosStep1(u8); +static void AnimTask_DuplicateAndShrinkToPosStep2(u8); +static void AnimItemStealStep3(struct Sprite *); +static void AnimRootFlickerOut(struct Sprite *); +static void AnimTrickBagStep1(struct Sprite *); +static void AnimTrickBagStep2(struct Sprite *); +static void AnimTrickBagStep3(struct Sprite *); +static void AnimTask_LeafBladeStep(u8); +static s16 LeafBladeGetPosFactor(struct Sprite *); +static void AnimTask_LeafBladeStep2(struct Task *, u8); +static void AnimTask_LeafBladeStep2_Callback(struct Sprite *); +static void AnimFlyingParticleStep(struct Sprite *); +static void AnimNeedleArmSpikeStep(struct Sprite *); +static void AnimSliceStep(struct Sprite *); +static void sub_80A4880(struct Sprite *); +static void AnimProtectStep(struct Sprite *); +static void AnimMilkBottleStep1(struct Sprite *); +static void AnimMilkBottleStep2(struct Sprite *, int, int); +static void sub_80A4EA0(struct Sprite *); +static void AnimSleepLetterZStep(struct Sprite *); +static void AnimLockOnTargetStep1(struct Sprite *); +static void AnimLockOnTargetStep2(struct Sprite *); +static void AnimLockOnTargetStep3(struct Sprite *); +static void AnimLockOnTargetStep4(struct Sprite *); +static void AnimLockOnTargetStep5(struct Sprite *); +static void AnimLockOnTargetStep6(struct Sprite *); +static void AnimBowMonStep1(struct Sprite *); +static void AnimBowMonStep1_Callback(struct Sprite *); +static void AnimBowMonStep2(struct Sprite *); +static void AnimBowMonStep3(struct Sprite *); +static void AnimBowMonStep4(struct Sprite *); +static void AnimBowMonStep3_Callback(struct Sprite *); +static void sub_80A55A0(struct Sprite *); +static void AnimTask_SkullBashPositionSet(u8); +static void AnimTask_SkullBashPositionReset(u8); +static void AnimFalseSwipeSliceStep1(struct Sprite *); +static void AnimFalseSwipeSliceStep2(struct Sprite *); +static void AnimFalseSwipeSliceStep3(struct Sprite *); +static void AnimEndureEnergyStep(struct Sprite *); +static void AnimSharpenSphereStep(struct Sprite *); +static void AnimConversion2Step(struct Sprite *); +static void AnimMoonStep(struct Sprite *); +static void AnimMoonlightSparkleStep(struct Sprite *); +static void AnimHornHitStep(struct Sprite *); +static void AnimTask_DoubleTeamStep(u8); +static void AnimTask_DoubleTeamCallback(struct Sprite *); +static void AnimWavyMusicNotesGetNextPos(s16, s16, s16 *, s16 *, s8); +static void AnimWavyMusicNotesStep(struct Sprite *); +static void AnimFlyingMusicNotesStep(struct Sprite *); +static void AnimSlowFlyingMusicNotesStep(struct Sprite *); +static void AnimThoughtBubbleStep(struct Sprite *); +static void AnimMetronomeFingerStep(struct Sprite *); +static void AnimFollowMeFingerStep1(struct Sprite *); +static void AnimFollowMeFingerStep2(struct Sprite *); +static void AnimTauntFingerStep1(struct Sprite *); +static void AnimTauntFingerStep2(struct Sprite *); + +const union AnimCmd gPowderParticlesAnimCmds[] = //gUnknown_83E2968 +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(2, 5), + ANIMCMD_FRAME(4, 5), + ANIMCMD_FRAME(6, 5), + ANIMCMD_FRAME(8, 5), + ANIMCMD_FRAME(10, 5), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(14, 5), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gPowderParticlesAnimTable[] = //gUnknown_83E298C +{ + gPowderParticlesAnimCmds, +}; + +const struct SpriteTemplate gSleepPowderParticleSpriteTemplate = //gUnknown_83E2990 +{ + .tileTag = ANIM_TAG_SLEEP_POWDER, + .paletteTag = ANIM_TAG_SLEEP_POWDER, + .oam = &gOamData_AffineOff_ObjNormal_8x16, + .anims = gPowderParticlesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMovePowderParticle, +}; + +const struct SpriteTemplate gStunSporeParticleSpriteTemplate = //gUnknown_83E29A8 +{ + .tileTag = ANIM_TAG_STUN_SPORE, + .paletteTag = ANIM_TAG_STUN_SPORE, + .oam = &gOamData_AffineOff_ObjNormal_8x16, + .anims = gPowderParticlesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMovePowderParticle, +}; + +const struct SpriteTemplate gPoisonPowderParticleSpriteTemplate = //gUnknown_83E29C0 +{ + .tileTag = ANIM_TAG_POISON_POWDER, + .paletteTag = ANIM_TAG_POISON_POWDER, + .oam = &gOamData_AffineOff_ObjNormal_8x16, + .anims = gPowderParticlesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMovePowderParticle, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds1[] = //gUnknown_83E29D8 +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds2[] = +{ + ANIMCMD_FRAME(1, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds3[] = +{ + ANIMCMD_FRAME(2, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds4[] = +{ + ANIMCMD_FRAME(3, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds5[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds6[] = +{ + ANIMCMD_FRAME(5, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamBigOrbAnimCmds7[] = +{ + ANIMCMD_FRAME(6, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSolarbeamSmallOrbAnimCms[] = +{ + ANIMCMD_FRAME(7, 1), + ANIMCMD_END, +}; + +const union AnimCmd gPowerAbsorptionOrbAnimCmds[] = +{ + ANIMCMD_FRAME(8, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = //gUnknown_83E2A20 +{ + gSolarbeamBigOrbAnimCmds1, + gSolarbeamBigOrbAnimCmds2, + gSolarbeamBigOrbAnimCmds3, + gSolarbeamBigOrbAnimCmds4, + gSolarbeamBigOrbAnimCmds5, + gSolarbeamBigOrbAnimCmds6, + gSolarbeamBigOrbAnimCmds7, +}; + +const union AnimCmd *const gSolarbeamSmallOrbAnimTable[] = //gUnknown_83E2A3C +{ + gSolarbeamSmallOrbAnimCms, +}; + +const union AnimCmd *const gPowerAbsorptionOrbAnimTable[] = //gUnknown_83E2A40 +{ + gPowerAbsorptionOrbAnimCmds, +}; + +const union AffineAnimCmd gPowerAbsorptionOrbAffineAnimCmds[] = //gUnknown_83E2A44 +{ + AFFINEANIMCMD_FRAME(-5, -5, 0, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gPowerAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2A54 +{ + gPowerAbsorptionOrbAffineAnimCmds, +}; + +const struct SpriteTemplate gPowerAbsorptionOrbSpriteTemplate = //gUnknown_83E2A58 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineNormal_ObjBlend_16x16, + .anims = gPowerAbsorptionOrbAnimTable, + .images = NULL, + .affineAnims = gPowerAbsorptionOrbAffineAnimTable, + .callback = AnimPowerAbsorptionOrb, +}; + +const struct SpriteTemplate gSolarbeamBigOrbSpriteTemplate = //gUnknown_83E2A70 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gSolarbeamBigOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSolarbeamBigOrb, +}; + +const struct SpriteTemplate gSolarbeamSmallOrbSpriteTemplate = //gUnknown_83E2A88 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gSolarbeamSmallOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSolarbeamSmallOrb, +}; + +const union AffineAnimCmd gStockpileAbsorptionOrbAffineCmds[] = //gUnknown_83E2AA0 +{ + AFFINEANIMCMD_FRAME(320, 320, 0, 0), + AFFINEANIMCMD_FRAME(-14, -14, 0, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gStockpileAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2AB8 +{ + gStockpileAbsorptionOrbAffineCmds, +}; + +const struct SpriteTemplate gStockpileAbsorptionOrbSpriteTemplate = //gUnknown_83E2ABC +{ + .tileTag = ANIM_TAG_GRAY_ORB, + .paletteTag = ANIM_TAG_GRAY_ORB, + .oam = &gOamData_AffineDouble_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gStockpileAbsorptionOrbAffineAnimTable, + .callback = AnimPowerAbsorptionOrb, +}; + +const union AffineAnimCmd gAbsorptionOrbAffineAnimCmds[] = //gUnknown_83E2AD4 +{ + AFFINEANIMCMD_FRAME(-5, -5, 0, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2AE4 +{ + gAbsorptionOrbAffineAnimCmds, +}; + +const struct SpriteTemplate gAbsorptionOrbSpriteTemplate = //gUnknown_83E2AE8 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineNormal_ObjBlend_16x16, + .anims = gPowerAbsorptionOrbAnimTable, + .images = NULL, + .affineAnims = gAbsorptionOrbAffineAnimTable, + .callback = AnimAbsorptionOrb, +}; + +const struct SpriteTemplate gHyperBeamOrbSpriteTemplate = //gUnknown_83E2B00 +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gSolarbeamBigOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimHyperBeamOrb, +}; + +const union AnimCmd gLeechSeedAnimCmds1[] = //gUnknown_83E2B18 +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeechSeedAnimCmds2[] = //gUnknown_83E2B20 +{ + ANIMCMD_FRAME(4, 7), + ANIMCMD_FRAME(8, 7), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gLeechSeedAnimTable[] = //gUnknown_83E2B2C +{ + gLeechSeedAnimCmds1, + gLeechSeedAnimCmds2, +}; + +const struct SpriteTemplate gLeechSeedSpriteTemplate = //gUnknown_83E2B34 +{ + .tileTag = ANIM_TAG_SEED, + .paletteTag = ANIM_TAG_SEED, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gLeechSeedAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimLeechSeed, +}; + +const union AnimCmd gSporeParticleAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gSporeParticleAnimCmds2[] = +{ + ANIMCMD_FRAME(4, 7), + ANIMCMD_END, +}; + +const union AnimCmd *const gSporeParticleAnimTable[] = +{ + gSporeParticleAnimCmds1, + gSporeParticleAnimCmds2, +}; + +const struct SpriteTemplate gSporeParticleSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPORE, + .paletteTag = ANIM_TAG_SPORE, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gSporeParticleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSporeParticle, +}; + +const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = +{ + gPetalDanceBigFlowerAnimCmds, +}; + +const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = +{ + gPetalDanceSmallFlowerAnimCmds, +}; + +const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FLOWER, + .paletteTag = ANIM_TAG_FLOWER, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gPetalDanceBigFlowerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPetalDanceBigFlower, +}; + +const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FLOWER, + .paletteTag = ANIM_TAG_FLOWER, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gPetalDanceSmallFlowerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPetalDanceSmallFlower, +}; + +const union AnimCmd gRazorLeafParticleAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(4, 5), + ANIMCMD_FRAME(8, 5), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(20, 5), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(8, 5), + ANIMCMD_FRAME(4, 5), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gRazorLeafParticleAnimCmds2[] = +{ + ANIMCMD_FRAME(24, 5), + ANIMCMD_FRAME(28, 5), + ANIMCMD_FRAME(32, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gRazorLeafParticleAnimTable[] = +{ + gRazorLeafParticleAnimCmds1, + gRazorLeafParticleAnimCmds2, +}; + +const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = +{ + .tileTag = ANIM_TAG_LEAF, + .paletteTag = ANIM_TAG_LEAF, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gRazorLeafParticleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRazorLeafParticle, +}; + +const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = +{ + .tileTag = ANIM_TAG_LEAF, + .paletteTag = ANIM_TAG_LEAF, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gRazorLeafParticleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMoveTwisterParticle, +}; + +const union AnimCmd gRazorLeafCutterAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(0, 3, .hFlip = TRUE), + ANIMCMD_FRAME(0, 3, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(0, 3, .vFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gRazorLeafCutterAnimTable[] = +{ + gRazorLeafCutterAnimCmds, +}; + +const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = +{ + .tileTag = ANIM_TAG_RAZOR_LEAF, + .paletteTag = ANIM_TAG_RAZOR_LEAF, + .oam = &gOamData_AffineOff_ObjNormal_32x16, + .anims = gRazorLeafCutterAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimTranslateLinearSingleSineWave, +}; + +const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(0, 0, 0, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = { + gSwiftStarAffineAnimCmds, +}; + +const struct SpriteTemplate gSwiftStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_YELLOW_STAR, + .paletteTag = ANIM_TAG_YELLOW_STAR, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSwiftStarAffineAnimTable, + .callback = AnimTranslateLinearSingleSineWave, +}; + +const union AnimCmd gConstrictBindingAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(64, 4), + ANIMCMD_FRAME(96, 4), + ANIMCMD_END, +}; + +const union AnimCmd gConstrictBindingAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_FRAME(64, 4, .hFlip = TRUE), + ANIMCMD_FRAME(96, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gConstrictBindingAnimTable[] = +{ + gConstrictBindingAnimCmds1, + gConstrictBindingAnimCmds2, +}; + +const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = { + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-11, 0, 0, 6), + AFFINEANIMCMD_FRAME(11, 0, 0, 6), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = { + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(11, 0, 0, 6), + AFFINEANIMCMD_FRAME(-11, 0, 0, 6), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = { + gConstrictBindingAffineAnimCmds1, + gConstrictBindingAffineAnimCmds2, +}; + +const struct SpriteTemplate gConstrictBindingSpriteTemplate = +{ + .tileTag = ANIM_TAG_TENDRILS, + .paletteTag = ANIM_TAG_TENDRILS, + .oam = &gOamData_AffineNormal_ObjNormal_64x32, + .anims = gConstrictBindingAnimTable, + .images = NULL, + .affineAnims = gConstrictBindingAffineAnimTable, + .callback = AnimConstrictBinding, +}; + +const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = { + AFFINEANIMCMD_FRAME(0, 0, 0, 0), + AFFINEANIMCMD_FRAME(48, 48, 0, 14), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = { + AFFINEANIMCMD_FRAME(-16, -16, 0, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = { + gMimicOrbAffineAnimCmds1, + gMimicOrbAffineAnimCmds2, +}; + +const struct SpriteTemplate gMimicOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gPowerAbsorptionOrbAnimTable, + .images = NULL, + .affineAnims = gMimicOrbAffineAnimTable, + .callback = AnimMimicOrb, +}; + +const union AnimCmd gIngrainRootAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 7), + ANIMCMD_FRAME(16, 7), + ANIMCMD_FRAME(32, 7), + ANIMCMD_FRAME(48, 7), + ANIMCMD_END, +}; + +const union AnimCmd gIngrainRootAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 7, .hFlip = TRUE), + ANIMCMD_FRAME(16, 7, .hFlip = TRUE), + ANIMCMD_FRAME(32, 7, .hFlip = TRUE), + ANIMCMD_FRAME(48, 7, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gIngrainRootAnimCmds3[] = +{ + ANIMCMD_FRAME(0, 7), + ANIMCMD_FRAME(16, 7), + ANIMCMD_FRAME(32, 7), + ANIMCMD_END, +}; + +const union AnimCmd gIngrainRootAnimCmds4[] = +{ + ANIMCMD_FRAME(0, 7, .hFlip = TRUE), + ANIMCMD_FRAME(16, 7, .hFlip = TRUE), + ANIMCMD_FRAME(32, 7, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gIngrainRootAnimTable[] = +{ + gIngrainRootAnimCmds1, + gIngrainRootAnimCmds2, + gIngrainRootAnimCmds3, + gIngrainRootAnimCmds4, +}; + +const struct SpriteTemplate gIngrainRootSpriteTemplate = +{ + .tileTag = ANIM_TAG_ROOTS, + .paletteTag = ANIM_TAG_ROOTS, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gIngrainRootAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimIngrainRoot, +}; + +const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = +{ + .tileTag = ANIM_TAG_ROOTS, + .paletteTag = ANIM_TAG_ROOTS, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gIngrainRootAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFrenzyPlantRoot, +}; + +const union AnimCmd gIngrainOrbAnimCmds[] = +{ + ANIMCMD_FRAME(3, 3), + ANIMCMD_FRAME(0, 5), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gIngrainOrbAnimTable[] = +{ + gIngrainOrbAnimCmds, +}; + +const struct SpriteTemplate gIngrainOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_ORBS, + .paletteTag = ANIM_TAG_ORBS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gIngrainOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimIngrainOrb, +}; + +const union AnimCmd gFallingBagAnimCmds[] = +{ + ANIMCMD_FRAME(0, 30), + ANIMCMD_END, +}; + +const union AnimCmd *const gFallingBagAnimTable[] = +{ + gFallingBagAnimCmds, +}; + +const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = { + AFFINEANIMCMD_FRAME(0, 0, -4, 10), + AFFINEANIMCMD_FRAME(0, 0, 4, 20), + AFFINEANIMCMD_FRAME(0, 0, -4, 10), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = { + AFFINEANIMCMD_FRAME(0, 0, -1, 2), + AFFINEANIMCMD_FRAME(0, 0, 1, 4), + AFFINEANIMCMD_FRAME(0, 0, -1, 4), + AFFINEANIMCMD_FRAME(0, 0, 1, 4), + AFFINEANIMCMD_FRAME(0, 0, -1, 4), + AFFINEANIMCMD_FRAME(0, 0, 1, 2), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = { + gFallingBagAffineAnimCmds1, + gFallingBagAffineAnimCmds2, +}; + +const struct SpriteTemplate gPresentSpriteTemplate = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gFallingBagAnimTable, + .images = NULL, + .affineAnims = gFallingBagAffineAnimTable, + .callback = AnimPresent, +}; + +const struct SpriteTemplate gKnockOffItemSpriteTemplate = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gFallingBagAnimTable, + .images = NULL, + .affineAnims = gFallingBagAffineAnimTable, + .callback = AnimKnockOffItem, +}; + +const union AnimCmd gPresentHealParticleAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(12, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gPresentHealParticleAnimTable[] = +{ + gPresentHealParticleAnimCmds, +}; + +const struct SpriteTemplate gPresentHealParticleSpriteTemplate = +{ + .tileTag = ANIM_TAG_GREEN_SPARKLE, + .paletteTag = ANIM_TAG_GREEN_SPARKLE, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gPresentHealParticleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPresentHealParticle, +}; + +const struct SpriteTemplate gItemStealSpriteTemplate = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gFallingBagAnimTable, + .images = NULL, + .affineAnims = gFallingBagAffineAnimTable, + .callback = AnimItemSteal, +}; + +const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = { + AFFINEANIMCMD_FRAME(0, 0, 0, 3), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = { + AFFINEANIMCMD_FRAME(0, -10, 0, 3), + AFFINEANIMCMD_FRAME(0, -6, 0, 3), + AFFINEANIMCMD_FRAME(0, -2, 0, 3), + AFFINEANIMCMD_FRAME(0, 0, 0, 3), + AFFINEANIMCMD_FRAME(0, 2, 0, 3), + AFFINEANIMCMD_FRAME(0, 6, 0, 3), + AFFINEANIMCMD_FRAME(0, 10, 0, 3), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = { + gTrickBagAffineAnimCmds1, + gTrickBagAffineAnimCmds2, + gFallingBagAffineAnimCmds1, + gFallingBagAffineAnimCmds2, +}; + +const struct SpriteTemplate gTrickBagSpriteTemplate = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gFallingBagAnimTable, + .images = NULL, + .affineAnims = gTrickBagAffineAnimTable, + .callback = AnimTrickBag, +}; + +const s8 gTrickBagCoordinates[][3] = +{ + {5, 24, 1}, + {0, 4, 0}, + {8, 16, -1}, + {0, 2, 0}, + {8, 16, 1}, + {0, 2, 0}, + {8, 16, 1}, + {0, 2, 0}, + {8, 16, 1}, + {0, 16, 0}, + {0, 0, 127}, +}; + +const union AnimCmd gLeafBladeAnimCmds1[] = +{ + ANIMCMD_FRAME(28, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds2[] = +{ + ANIMCMD_FRAME(32, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds3[] = +{ + ANIMCMD_FRAME(20, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds4[] = +{ + ANIMCMD_FRAME(28, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds5[] = +{ + ANIMCMD_FRAME(16, 1), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds6[] = +{ + ANIMCMD_FRAME(16, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gLeafBladeAnimCmds7[] = +{ + ANIMCMD_FRAME(28, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gLeafBladeAnimTable[] = +{ + gLeafBladeAnimCmds1, + gLeafBladeAnimCmds2, + gLeafBladeAnimCmds3, + gLeafBladeAnimCmds4, + gLeafBladeAnimCmds5, + gLeafBladeAnimCmds6, + gLeafBladeAnimCmds7, +}; + +const struct SpriteTemplate gLeafBladeSpriteTemplate = +{ + .tileTag = ANIM_TAG_LEAF, + .paletteTag = ANIM_TAG_LEAF, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gLeafBladeAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(256, 256, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, 4, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = { + gAromatherapyBigFlowerAffineAnimCmds, +}; + +const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FLOWER, + .paletteTag = ANIM_TAG_FLOWER, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gPetalDanceSmallFlowerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FLOWER, + .paletteTag = ANIM_TAG_FLOWER, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gPetalDanceBigFlowerAnimTable, + .images = NULL, + .affineAnims = gAromatherapyBigFlowerAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(256, 256, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, -10, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(192, 192, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, -12, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = { + AFFINEANIMCMD_FRAME(143, 143, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, -15, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = { + gSilverWindBigSparkAffineAnimCmds, +}; + +const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = { + gSilverWindMediumSparkAffineAnimCmds, +}; + +const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = { + gSilverWindSmallSparkAffineAnimCmds, +}; + +const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_6, + .paletteTag = ANIM_TAG_SPARKLE_6, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSilverWindBigSparkAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_6, + .paletteTag = ANIM_TAG_SPARKLE_6, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSilverWindMediumSparkAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_6, + .paletteTag = ANIM_TAG_SPARKLE_6, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSilverWindSmallSparkAffineAnimTable, + .callback = AnimFlyingParticle, +}; + +const u16 gMagicalLeafBlendColors[] = +{ + RGB(31, 0, 0), + RGB(31, 19, 0), + RGB(31, 31, 0), + RGB(0, 31, 0), + RGB(5, 14, 31), + RGB(22, 10, 31), + RGB(22, 21, 31), +}; + +const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = +{ + .tileTag = ANIM_TAG_GREEN_SPIKE, + .paletteTag = ANIM_TAG_GREEN_SPIKE, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimNeedleArmSpike, +}; + +const union AnimCmd gWhipAnimCmds1[] = +{ + ANIMCMD_FRAME(64, 3), + ANIMCMD_FRAME(80, 3), + ANIMCMD_FRAME(96, 3), + ANIMCMD_FRAME(112, 6), + ANIMCMD_END, +}; + +const union AnimCmd gWhipAnimCmds2[] = +{ + ANIMCMD_FRAME(64, 3, .hFlip = TRUE), + ANIMCMD_FRAME(80, 3, .hFlip = TRUE), + ANIMCMD_FRAME(96, 3, .hFlip = TRUE), + ANIMCMD_FRAME(112, 6, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gWhipAnimTable[] = +{ + gWhipAnimCmds1, + gWhipAnimCmds2, +}; + +const struct SpriteTemplate gSlamHitSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLAM_HIT, + .paletteTag = ANIM_TAG_SLAM_HIT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gWhipAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWhipHit, +}; + +const struct SpriteTemplate gVineWhipSpriteTemplate = +{ + .tileTag = ANIM_TAG_WHIP_HIT, + .paletteTag = ANIM_TAG_WHIP_HIT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gWhipAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWhipHit, +}; + +const union AnimCmd gUnknown_08592900[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_FRAME(64, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_08592918[] = +{ + gUnknown_08592900, +}; + +// Unused +const struct SpriteTemplate gUnknown_0859291C = +{ + .tileTag = ANIM_TAG_HIT, + .paletteTag = ANIM_TAG_HIT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gUnknown_08592918, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A43F8, +}; + +// Unused +const struct SpriteTemplate gUnknown_08592934 = +{ + .tileTag = ANIM_TAG_HIT_2, + .paletteTag = ANIM_TAG_HIT_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gUnknown_08592918, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A43F8, +}; + +const union AffineAnimCmd gUnknown_0859294C[] = { + AFFINEANIMCMD_FRAME(256, 256, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859295C[] = { + AFFINEANIMCMD_FRAME(256, 256, 32, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859296C[] = { + AFFINEANIMCMD_FRAME(256, 256, 64, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859297C[] = { + AFFINEANIMCMD_FRAME(256, 256, 96, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859298C[] = { + AFFINEANIMCMD_FRAME(256, 256, -128, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_0859299C[] = { + AFFINEANIMCMD_FRAME(256, 256, -96, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_085929AC[] = { + AFFINEANIMCMD_FRAME(256, 256, -64, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gUnknown_085929BC[] = { + AFFINEANIMCMD_FRAME(256, 256, -32, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gUnknown_085929CC[] = { + gUnknown_0859294C, + gUnknown_0859295C, + gUnknown_0859296C, + gUnknown_0859297C, + gUnknown_0859298C, + gUnknown_0859299C, + gUnknown_085929AC, + gUnknown_085929BC, +}; + +// Unused +const struct SpriteTemplate gUnknown_085929EC = +{ + .tileTag = ANIM_TAG_HANDS_AND_FEET, + .paletteTag = ANIM_TAG_HANDS_AND_FEET, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gUnknown_085929CC, + .callback = sub_80A4494, +}; + +const union AnimCmd gCuttingSliceAnimCmds[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(32, 5), + ANIMCMD_FRAME(48, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gCuttingSliceAnimTable[] = +{ + gCuttingSliceAnimCmds, +}; + +const struct SpriteTemplate gCuttingSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_CUT, + .paletteTag = ANIM_TAG_CUT, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gCuttingSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimCuttingSlice, +}; + +const struct SpriteTemplate gAirCutterSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_CUT, + .paletteTag = ANIM_TAG_CUT, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gCuttingSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimAirCutterSlice, +}; + +const union AnimCmd gUnknown_08592A4C[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A54[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A5C[] = +{ + ANIMCMD_FRAME(8, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A64[] = +{ + ANIMCMD_FRAME(12, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A6C[] = +{ + ANIMCMD_FRAME(16, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A74[] = +{ + ANIMCMD_FRAME(20, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A7C[] = +{ + ANIMCMD_FRAME(0, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A84[] = +{ + ANIMCMD_FRAME(4, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A8C[] = +{ + ANIMCMD_FRAME(8, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592A94[] = +{ + ANIMCMD_FRAME(12, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_08592A9C[] = +{ + gUnknown_08592A4C, + gUnknown_08592A54, + gUnknown_08592A5C, + gUnknown_08592A64, + gUnknown_08592A6C, + gUnknown_08592A74, + gUnknown_08592A7C, + gUnknown_08592A84, + gUnknown_08592A8C, + gUnknown_08592A94, +}; + +// Unused +const struct SpriteTemplate gUnknown_08592AC4 = +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gUnknown_08592A9C, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A481C, +}; + +const struct SpriteTemplate gUnknown_08592ADC = +{ + .tileTag = ANIM_TAG_PROTECT, + .paletteTag = ANIM_TAG_PROTECT, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimProtect, +}; + +const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), + AFFINEANIMCMD_FRAME(0x0, 0x0, -2, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), + AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] = +{ + gMilkBottleAffineAnimCmds1, + gMilkBottleAffineAnimCmds2, +}; + +const struct SpriteTemplate gMilkBottleSpriteTemplate = +{ + .tileTag = ANIM_TAG_MILK_BOTTLE, + .paletteTag = ANIM_TAG_MILK_BOTTLE, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gMilkBottleAffineAnimTable, + .callback = AnimMilkBottle, +}; + +const union AnimCmd gGrantingStarsAnimCmds[] = +{ + ANIMCMD_FRAME(0, 7), + ANIMCMD_FRAME(16, 7), + ANIMCMD_FRAME(32, 7), + ANIMCMD_FRAME(48, 7), + ANIMCMD_FRAME(64, 7), + ANIMCMD_FRAME(80, 7), + ANIMCMD_FRAME(96, 7), + ANIMCMD_FRAME(112, 7), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gGrantingStarsAnimTable[] = +{ + gGrantingStarsAnimCmds, +}; + +const struct SpriteTemplate gGrantingStarsSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_2, + .paletteTag = ANIM_TAG_SPARKLE_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gGrantingStarsAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimGrantingStars, +}; + +const struct SpriteTemplate gSparklingStarsSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPARKLE_2, + .paletteTag = ANIM_TAG_SPARKLE_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gGrantingStarsAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSparkingStars, +}; + +const union AnimCmd gUnknown_08592BAC[] = +{ + ANIMCMD_FRAME(0, 10), + ANIMCMD_FRAME(4, 10), + ANIMCMD_FRAME(8, 10), + ANIMCMD_FRAME(12, 10), + ANIMCMD_FRAME(16, 26), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(20, 5), + ANIMCMD_FRAME(24, 15), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08592BD0[] = +{ + ANIMCMD_FRAME(0, 10, .hFlip = TRUE), + ANIMCMD_FRAME(4, 10, .hFlip = TRUE), + ANIMCMD_FRAME(8, 10, .hFlip = TRUE), + ANIMCMD_FRAME(12, 10, .hFlip = TRUE), + ANIMCMD_FRAME(16, 26, .hFlip = TRUE), + ANIMCMD_FRAME(16, 5, .hFlip = TRUE), + ANIMCMD_FRAME(20, 5, .hFlip = TRUE), + ANIMCMD_FRAME(24, 15, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_08592BF4[] = +{ + gUnknown_08592BAC, + gUnknown_08592BD0, +}; + +// Unused +const struct SpriteTemplate gUnknown_08592BFC = +{ + .tileTag = ANIM_TAG_BUBBLE_BURST, + .paletteTag = ANIM_TAG_BUBBLE_BURST, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gUnknown_08592BF4, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A4E40, +}; + +const union AnimCmd gSleepLetterZAnimCmds[] = +{ + ANIMCMD_FRAME(0, 40), + ANIMCMD_END, +}; + +const union AnimCmd *const gSleepLetterZAnimTable[] = +{ + gSleepLetterZAnimCmds, +}; + +const union AffineAnimCmd gSleepLetterZAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x14, 0x14, -30, 0), + AFFINEANIMCMD_FRAME(0x8, 0x8, 1, 24), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSleepLetterZAffineAnimCmds1_2[] = +{ + AFFINEANIMCMD_LOOP(0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), + AFFINEANIMCMD_LOOP(10), +}; + +const union AffineAnimCmd gSleepLetterZAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x14, 0x14, 30, 0), + AFFINEANIMCMD_FRAME(0x8, 0x8, -1, 24), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSleepLetterZAffineAnimCmds2_2[] = +{ + AFFINEANIMCMD_LOOP(0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 24), + AFFINEANIMCMD_LOOP(10), +}; + +const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] = +{ + gSleepLetterZAffineAnimCmds1, + gSleepLetterZAffineAnimCmds2, +}; + +const struct SpriteTemplate gSleepLetterZSpriteTemplate = +{ + .tileTag = ANIM_TAG_LETTER_Z, + .paletteTag = ANIM_TAG_LETTER_Z, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gSleepLetterZAnimTable, + .images = NULL, + .affineAnims = gSleepLetterZAffineAnimTable, + .callback = AnimSleepLetterZ, +}; + +const struct SpriteTemplate gLockOnTargetSpriteTemplate = +{ + .tileTag = ANIM_TAG_LOCK_ON, + .paletteTag = ANIM_TAG_LOCK_ON, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimLockOnTarget, +}; + +const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = +{ + .tileTag = ANIM_TAG_LOCK_ON, + .paletteTag = ANIM_TAG_LOCK_ON, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimLockOnMoveTarget, +}; + +const s8 gInclineMonCoordTable[][2] = +{ + { 64, 64}, + { 0, -64}, + {-64, 64}, + { 32, -32}, +}; + +const struct SpriteTemplate gBowMonSpriteTemplate = +{ + .tileTag = 0, + .paletteTag = 0, + .oam = &gDummyOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBowMon, +}; + +// Unused +const struct SpriteTemplate gUnknown_08592CF0 = +{ + .tileTag = 0, + .paletteTag = 0, + .oam = &gDummyOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A5590, +}; + +const union AnimCmd gSlashSliceAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_END, +}; + +const union AnimCmd gSlashSliceAnimCmds2[] = +{ + ANIMCMD_FRAME(48, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gSlashSliceAnimTable[] = +{ + gSlashSliceAnimCmds1, + gSlashSliceAnimCmds2, +}; + +const struct SpriteTemplate gSlashSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLASH, + .paletteTag = ANIM_TAG_SLASH, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSlashSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSlashSlice, +}; + +const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLASH_2, + .paletteTag = ANIM_TAG_SLASH_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSlashSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFalseSwipeSlice, +}; + +const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLASH_2, + .paletteTag = ANIM_TAG_SLASH_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSlashSliceAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFalseSwipePositionedSlice, +}; + +const union AnimCmd gEndureEnergyAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(8, 12), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(24, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gEndureEnergyAnimTable[] = +{ + gEndureEnergyAnimCmds, +}; + +const struct SpriteTemplate gEndureEnergySpriteTemplate = +{ + .tileTag = ANIM_TAG_FOCUS_ENERGY, + .paletteTag = ANIM_TAG_FOCUS_ENERGY, + .oam = &gOamData_AffineOff_ObjNormal_16x32, + .anims = gEndureEnergyAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimEndureEnergy, +}; + +const union AnimCmd gSharpenSphereAnimCmds[] = +{ + ANIMCMD_FRAME(0, 18), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 18), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(32, 18), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(32, 6), + ANIMCMD_FRAME(48, 18), + ANIMCMD_FRAME(32, 6), + ANIMCMD_FRAME(48, 6), + ANIMCMD_FRAME(64, 18), + ANIMCMD_FRAME(48, 6), + ANIMCMD_FRAME(64, 54), + ANIMCMD_END, +}; + +const union AnimCmd *const gSharpenSphereAnimTable[] = +{ + gSharpenSphereAnimCmds, +}; + +const struct SpriteTemplate gSharpenSphereSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPHERE_TO_CUBE, + .paletteTag = ANIM_TAG_SPHERE_TO_CUBE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSharpenSphereAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSharpenSphere, +}; + +const struct SpriteTemplate gOctazookaBallSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLACK_BALL, + .paletteTag = ANIM_TAG_BLACK_BALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = TranslateAnimSpriteToTargetMonLocation, +}; + +const union AnimCmd gOctazookaAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(64, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gOctazookaAnimTable[] = +{ + gOctazookaAnimCmds, +}; + +const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = +{ + .tileTag = ANIM_TAG_GRAY_SMOKE, + .paletteTag = ANIM_TAG_GRAY_SMOKE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gOctazookaAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const union AnimCmd gConversionAnimCmds[] = +{ + ANIMCMD_FRAME(3, 5), + ANIMCMD_FRAME(2, 5), + ANIMCMD_FRAME(1, 5), + ANIMCMD_FRAME(0, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gConversionAnimTable[] = +{ + gConversionAnimCmds, +}; + +const union AffineAnimCmd gConversionAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gConversionAffineAnimTable[] = +{ + gConversionAffineAnimCmds, +}; + +const struct SpriteTemplate gConversionSpriteTemplate = +{ + .tileTag = ANIM_TAG_CONVERSION, + .paletteTag = ANIM_TAG_CONVERSION, + .oam = &gOamData_AffineDouble_ObjBlend_8x8, + .anims = gConversionAnimTable, + .images = NULL, + .affineAnims = gConversionAffineAnimTable, + .callback = AnimConversion, +}; + +const union AnimCmd gConversion2AnimCmds[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(1, 5), + ANIMCMD_FRAME(2, 5), + ANIMCMD_FRAME(3, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gConversion2AnimTable[] = +{ + gConversion2AnimCmds, +}; + +const struct SpriteTemplate gConversion2SpriteTemplate = +{ + .tileTag = ANIM_TAG_CONVERSION, + .paletteTag = ANIM_TAG_CONVERSION, + .oam = &gOamData_AffineDouble_ObjBlend_8x8, + .anims = gConversion2AnimTable, + .images = NULL, + .affineAnims = gConversionAffineAnimTable, + .callback = AnimConversion2, +}; + +const struct SpriteTemplate gMoonSpriteTemplate = +{ + .tileTag = ANIM_TAG_MOON, + .paletteTag = ANIM_TAG_MOON, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMoon, +}; + +const union AnimCmd gMoonlightSparkleAnimCmds[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(4, 8), + ANIMCMD_FRAME(8, 8), + ANIMCMD_FRAME(12, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gMoonlightSparkleAnimTable[] = +{ + gMoonlightSparkleAnimCmds, +}; + +const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = +{ + .tileTag = ANIM_TAG_GREEN_SPARKLE, + .paletteTag = ANIM_TAG_GREEN_SPARKLE, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gMoonlightSparkleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMoonlightSparkle, +}; + +const union AnimCmd gHealingBlueStarAnimCmds[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(32, 2), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(64, 5), + ANIMCMD_FRAME(80, 3), + ANIMCMD_FRAME(96, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_END, +}; + +const union AnimCmd *const gHealingBlueStarAnimTable[] = +{ + gHealingBlueStarAnimCmds, +}; + +const struct SpriteTemplate gHealingBlueStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLUE_STAR, + .paletteTag = ANIM_TAG_BLUE_STAR, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gHealingBlueStarAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const struct SpriteTemplate gHornHitSpriteTemplate = +{ + .tileTag = ANIM_TAG_HORN_HIT, + .paletteTag = ANIM_TAG_HORN_HIT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimHornHit, +}; + +const union AnimCmd gSuperFangAnimCmds[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(32, 2), + ANIMCMD_FRAME(48, 2), + ANIMCMD_END, +}; + +const union AnimCmd *const gSuperFangAnimTable[] = +{ + gSuperFangAnimCmds, +}; + +const struct SpriteTemplate gSuperFangSpriteTemplate = +{ + .tileTag = ANIM_TAG_FANG_ATTACK, + .paletteTag = ANIM_TAG_FANG_ATTACK, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSuperFangAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSuperFang, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds2[] = +{ + ANIMCMD_FRAME(4, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds3[] = +{ + ANIMCMD_FRAME(8, 41), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds4[] = +{ + ANIMCMD_FRAME(12, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds5[] = +{ + ANIMCMD_FRAME(16, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds6[] = +{ + ANIMCMD_FRAME(20, 10), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds7[] = +{ + ANIMCMD_FRAME(0, 10, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gWavyMusicNotesAnimCmds8[] = +{ + ANIMCMD_FRAME(4, 10, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gMusicNotesAnimTable[] = +{ + gWavyMusicNotesAnimCmds1, + gWavyMusicNotesAnimCmds2, + gWavyMusicNotesAnimCmds3, + gWavyMusicNotesAnimCmds4, + gWavyMusicNotesAnimCmds5, + gWavyMusicNotesAnimCmds6, + gWavyMusicNotesAnimCmds7, + gWavyMusicNotesAnimCmds8, +}; + +const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0xC, 0xC, 0, 16), + AFFINEANIMCMD_FRAME(0xFFF4, 0xFFF4, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = +{ + gWavyMusicNotesAffineAnimCmds, +}; + +const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gMusicNotesAffineAnimTable, + .callback = AnimWavyMusicNotes, +}; + +const u16 gParticlesColorBlendTable[][6] = +{ + {ANIM_TAG_MUSIC_NOTES, RGB(31, 31, 31), RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, + {ANIM_TAG_BENT_SPOON, RGB(31, 31, 31), RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, + {ANIM_TAG_SPHERE_TO_CUBE, RGB(31, 31, 31), RGB(31, 31, 24), RGB(31, 31, 17), RGB(31, 31, 10), RGB(31, 31, 3)}, + {ANIM_TAG_LARGE_FRESH_EGG, RGB(31, 31, 31), RGB(26, 28, 31), RGB(21, 26, 31), RGB(16, 24, 31), RGB(12, 22, 31)}, +}; + +const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gMusicNotesAffineAnimTable, + .callback = AnimFlyingMusicNotes, +}; + +const struct SpriteTemplate gBellyDrumHandSpriteTemplate = +{ + .tileTag = ANIM_TAG_PURPLE_HAND_OUTLINE, + .paletteTag = ANIM_TAG_PURPLE_HAND_OUTLINE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBellyDrumHand, +}; + +const union AffineAnimCmd gSlowFlyingMusicNotesAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0xA0, 0xA0, 0, 0), + AFFINEANIMCMD_FRAME(0x4, 0x4, 0, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gSlowFlyingMusicNotesAffineAnimTable[] = +{ + gSlowFlyingMusicNotesAffineAnimCmds, +}; + +const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gSlowFlyingMusicNotesAffineAnimTable, + .callback = AnimSlowFlyingMusicNotes, +}; + +const union AnimCmd gMetronomeThroughtBubbleAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 2, .hFlip = TRUE), + ANIMCMD_FRAME(16, 2, .hFlip = TRUE), + ANIMCMD_FRAME(32, 2, .hFlip = TRUE), + ANIMCMD_FRAME(48, 2, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gMetronomeThroughtBubbleAnimCmds3[] = +{ + ANIMCMD_FRAME(48, 2, .hFlip = TRUE), + ANIMCMD_FRAME(32, 2, .hFlip = TRUE), + ANIMCMD_FRAME(16, 2, .hFlip = TRUE), + ANIMCMD_FRAME(0, 2, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gMetronomeThroughtBubbleAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(32, 2), + ANIMCMD_FRAME(48, 2), + ANIMCMD_END, +}; + +const union AnimCmd gMetronomeThroughtBubbleAnimCmds4[] = +{ + ANIMCMD_FRAME(48, 2), + ANIMCMD_FRAME(32, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_END, +}; + +const union AnimCmd *const gMetronomeThroughtBubbleAnimTable[] = +{ + gMetronomeThroughtBubbleAnimCmds1, + gMetronomeThroughtBubbleAnimCmds2, + gMetronomeThroughtBubbleAnimCmds3, + gMetronomeThroughtBubbleAnimCmds4, +}; + +const struct SpriteTemplate gThoughtBubbleSpriteTemplate = +{ + .tileTag = ANIM_TAG_THOUGHT_BUBBLE, + .paletteTag = ANIM_TAG_THOUGHT_BUBBLE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gMetronomeThroughtBubbleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimThoughtBubble, +}; + +const union AffineAnimCmd gMetronomeFingerAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), + AFFINEANIMCMD_FRAME(0x1E, 0x1E, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 11), + AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 11), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_FRAME(0xFFE2, 0xFFE2, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2_2[] = +{ + AFFINEANIMCMD_FRAME(16, 16, 0, 0), + AFFINEANIMCMD_FRAME(30, 30, 0, 8), + AFFINEANIMCMD_FRAME(0, 0, 0, 16), + AFFINEANIMCMD_LOOP(0), + AFFINEANIMCMD_FRAME(0, 0, 4, 11), + AFFINEANIMCMD_FRAME(0, 0, -4, 11), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_FRAME(-30, -30, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gMetronomeFingerAffineAnimTable[] = +{ + gMetronomeFingerAffineAnimCmds1, + gMetronomeFingerAffineAnimCmds2, +}; + +const struct SpriteTemplate gMetronomeFingerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FINGER, + .paletteTag = ANIM_TAG_FINGER, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gMetronomeFingerAffineAnimTable, + .callback = AnimMetronomeFinger, +}; + +const struct SpriteTemplate gFollowMeFingerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FINGER, + .paletteTag = ANIM_TAG_FINGER, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gMetronomeFingerAffineAnimTable, + .callback = AnimFollowMeFinger, +}; + +const union AnimCmd gTauntFingerAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gTauntFingerAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gTauntFingerAnimCmds3[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_END, +}; + +const union AnimCmd gTauntFingerAnimCmds4[] = +{ + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(16, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_FRAME(16, 4, .hFlip = TRUE), + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(16, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gTauntFingerAnimTable[] = +{ + gTauntFingerAnimCmds1, + gTauntFingerAnimCmds2, + gTauntFingerAnimCmds3, + gTauntFingerAnimCmds4, +}; + +const struct SpriteTemplate gTauntFingerSpriteTemplate = +{ + .tileTag = ANIM_TAG_FINGER_2, + .paletteTag = ANIM_TAG_FINGER_2, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gTauntFingerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimTauntFinger, +}; + +// Animates the falling particles that horizontally wave back and forth. +// Used by Sleep Powder, Stun Spore, and Poison Powder. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: total duration in frames +// arg 3: vertical movement speed (sub-pixel value) +// arg 4: wave amplitude +// arg 5: wave speed +void AnimMovePowderParticle(struct Sprite* sprite) +{ + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + + if (GetBattlerSide(gBattleAnimAttacker)) + { + sprite->data[3] = -gBattleAnimArgs[4]; + } + else + { + sprite->data[3] = gBattleAnimArgs[4]; + } + + sprite->data[4] = gBattleAnimArgs[5]; + sprite->callback = AnimMovePowderParticleStep; +} + +static void AnimMovePowderParticleStep(struct Sprite* sprite) +{ + if (sprite->data[0] > 0) + { + sprite->data[0]--; + sprite->pos2.y = sprite->data[2] >> 8; + sprite->data[2] += sprite->data[1]; + sprite->pos2.x = Sin(sprite->data[5], sprite->data[3]); + sprite->data[5] = (sprite->data[5] + sprite->data[4]) & 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +// Moves an energy orb towards the center of the mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: duration +void AnimPowerAbsorptionOrb(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); +} + +// Moves an orb in a straight line towards the target mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: duration +// arg 3: sprite anim number +void AnimSolarbeamBigOrb(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + StartSpriteAnim(sprite, gBattleAnimArgs[3]); + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Moves a small orb in a wavy pattern towards the target mon. +// The small orb "circles" the big orbs in AnimSolarbeamBigOrb. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: duration +// arg 3: initial wave offset +void AnimSolarbeamSmallOrb(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + InitAnimLinearTranslation(sprite); + sprite->data[5] = gBattleAnimArgs[3]; + sprite->callback = AnimSolarbeamSmallOrbStep; + sprite->callback(sprite); +} + +static void AnimSolarbeamSmallOrbStep(struct Sprite* sprite) +{ + if (AnimTranslateLinear(sprite)) + { + DestroySprite(sprite); + } + else + { + if (sprite->data[5] > 0x7F) + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + 1; + else + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + 6; + + sprite->pos2.x += Sin(sprite->data[5], 5); + sprite->pos2.y += Cos(sprite->data[5], 14); + sprite->data[5] = (sprite->data[5] + 15) & 0xFF; + } +} + +// Creates 15 small secondary orbs used in the solarbeam anim effect. +// There is a 7-frame delay between each of them. +// No args. +void AnimTask_CreateSmallSolarbeamOrbs(u8 taskId) +{ + if (--gTasks[taskId].data[0] == -1) + { + gTasks[taskId].data[1]++; + gTasks[taskId].data[0] = 6; + gBattleAnimArgs[0] = 15; + gBattleAnimArgs[1] = 0; + gBattleAnimArgs[2] = 80; + gBattleAnimArgs[3] = 0; + CreateSpriteAndAnimate(&gSolarbeamSmallOrbSpriteTemplate, 0, 0, GetBattlerSpriteSubpriority(gBattleAnimTarget) + 1); + } + + if (gTasks[taskId].data[1] == 15) + DestroyAnimVisualTask(taskId); +} + +// Moves an orb from the target mon to the attacking mon in an arc-like fashion. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: wave amplitude +// arg 3: wave period (lower means faster wave) +void AnimAbsorptionOrb(struct Sprite* sprite) +{ + InitSpritePosToAnimTarget(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[3]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->data[5] = gBattleAnimArgs[2]; + InitAnimArcTranslation(sprite); + sprite->callback = AnimAbsorptionOrbStep; +} + +static void AnimAbsorptionOrbStep(struct Sprite* sprite) +{ + if (TranslateAnimHorizontalArc(sprite)) + DestroyAnimSprite(sprite); +} + +// Moves an orb in a wave-like fashion towards the target mon. The wave's +// properties and the sprite anim are randomly determined. +void AnimHyperBeamOrb(struct Sprite* sprite) +{ + u16 speed; + u16 animNum = Random2(); + + StartSpriteAnim(sprite, animNum % 8); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x -= 20; + else + sprite->pos1.x += 20; + + speed = Random2(); + sprite->data[0] = (speed & 31) + 64; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + InitAnimFastLinearTranslationWithSpeed(sprite); + sprite->data[5] = Random2() & 0xFF; + sprite->data[6] = sprite->subpriority; + sprite->callback = AnimHyperBeamOrbStep; + sprite->callback(sprite); +} + +static void AnimHyperBeamOrbStep(struct Sprite* sprite) +{ + if (AnimFastTranslateLinear(sprite)) + { + DestroyAnimSprite(sprite); + } + else + { + sprite->pos2.y += Cos(sprite->data[5], 12); + if (sprite->data[5] < 0x7F) + sprite->subpriority = sprite->data[6]; + else + sprite->subpriority = sprite->data[6] + 1; + + sprite->data[5] += 24; + sprite->data[5] &= 0xFF; + } +} + +// seed (sprouts a sapling from a seed.) +// Used by Leech Seed. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: target x pixel offset +// arg 3: target y pixel offset +// arg 4: duration +// arg 5: wave amplitude +void AnimLeechSeed(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + gBattleAnimArgs[3]; + sprite->data[5] = gBattleAnimArgs[5]; + InitAnimArcTranslation(sprite); + sprite->callback = AnimLeechSeedStep; +} + +static void AnimLeechSeedStep(struct Sprite* sprite) +{ + if (TranslateAnimHorizontalArc(sprite)) + { + sprite->invisible = 1; + sprite->data[0] = 10; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLeechSeedSprouts); + } +} + +static void AnimLeechSeedSprouts(struct Sprite* sprite) +{ + sprite->invisible = 0; + StartSpriteAnim(sprite, 1); + sprite->data[0] = 60; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Moves a spore particle in a halo around the target mon. +// The sprite's priority is updated to give the effect of going +// behind the mon's sprite. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: initial wave offset +// arg 3: duration +// arg 4: blend (0 = off, 1 = on) +void AnimSporeParticle(struct Sprite* sprite) +{ + InitSpritePosToAnimTarget(sprite, TRUE); + StartSpriteAnim(sprite, gBattleAnimArgs[4]); + if (gBattleAnimArgs[4] == 1) + sprite->oam.objMode = ST_OAM_OBJ_BLEND; + + sprite->data[0] = gBattleAnimArgs[3]; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->callback = AnimSporeParticleStep; + sprite->callback(sprite); +} + +static void AnimSporeParticleStep(struct Sprite* sprite) +{ + sprite->pos2.x = Sin(sprite->data[1], 32); + sprite->pos2.y = Cos(sprite->data[1], -3) + ((sprite->data[2] += 24) >> 8); + if ((u16)(sprite->data[1] - 0x40) < 0x80) + { + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget); + } + else + { + u8 priority = GetBattlerSpriteBGPriority(gBattleAnimTarget) + 1; + if (priority > 3) + priority = 3; + + sprite->oam.priority = priority; + } + + sprite->data[1] += 2; + sprite->data[1] &= 0xFF; + if (--sprite->data[0] == -1) + DestroyAnimSprite(sprite); +} + +// In a double battle, Updates the mon sprite background priorities to allow +// the circling effect controlled by AnimSporeParticle. +// No args. +void AnimTask_SporeDoubleBattle(u8 taskId) +{ + if (IsContest() || !IsDoubleBattle()) + { + DestroyAnimVisualTask(taskId); + } + else + { + if (GetBattlerSpriteBGPriorityRank(gBattleAnimTarget) == 1) + SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 3); + else + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + + DestroyAnimVisualTask(taskId); + } +} + +// Rotates a big flower around the attacking mon, and slowly floats +// downward. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: target y pixel offset +// arg 3: duration +void AnimPetalDanceBigFlower(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + sprite->data[0] = gBattleAnimArgs[3]; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; + InitAnimLinearTranslation(sprite); + sprite->data[5] = 0x40; + sprite->callback = AnimPetalDanceBigFlowerStep; + sprite->callback(sprite); +} + +static void AnimPetalDanceBigFlowerStep(struct Sprite* sprite) +{ + if (!AnimTranslateLinear(sprite)) + { + sprite->pos2.x += Sin(sprite->data[5], 32); + sprite->pos2.y += Cos(sprite->data[5], -5); + if ((u16)(sprite->data[5] - 0x40) < 0x80) + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) - 1; + else + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) + 1; + + sprite->data[5] = (sprite->data[5] + 5) & 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +// Slowly floats a small flower downard, while swaying from right to left. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: target y pixel offset +// arg 3: duration +void AnimPetalDanceSmallFlower(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[3]; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + InitAnimLinearTranslation(sprite); + sprite->data[5] = 0x40; + sprite->callback = AnimPetalDanceSmallFlowerStep; + sprite->callback(sprite); +} + +static void AnimPetalDanceSmallFlowerStep(struct Sprite* sprite) +{ + if (!AnimTranslateLinear(sprite)) + { + sprite->pos2.x += Sin(sprite->data[5], 8); + if ((u16)(sprite->data[5] - 59) < 5 || (u16)(sprite->data[5] - 187) < 5) + sprite->oam.matrixNum ^= ST_OAM_HFLIP; + + sprite->data[5] += 5; + sprite->data[5] &= 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +// Shoots a leaf upward, then floats it downward while swaying back and forth. +// arg 0: upward x delta per frame +// arg 1: upward y delta per frame +// arg 2: upward duration +void AnimRazorLeafParticle(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[2] = gBattleAnimArgs[2]; + sprite->callback = AnimRazorLeafParticleStep1; +} + +static void AnimRazorLeafParticleStep1(struct Sprite* sprite) +{ + if (!sprite->data[2]) + { + if (sprite->data[1] & 1) + { + sprite->data[0] = 0x80; + sprite->data[1] = 0; + sprite->data[2] = 0; + } + else + { + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2] = 0; + } + sprite->callback = AnimRazorLeafParticleStep2; + } + else + { + sprite->data[2]--; + sprite->pos1.x += sprite->data[0]; + sprite->pos1.y += sprite->data[1]; + } +} + +static void AnimRazorLeafParticleStep2(struct Sprite* sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker)) + sprite->pos2.x = -Sin(sprite->data[0], 25); + else + sprite->pos2.x = Sin(sprite->data[0], 25); + + sprite->data[0] += 2; + sprite->data[0] &= 0xFF; + sprite->data[1]++; + if (!(sprite->data[1] & 1)) + sprite->pos2.y++; + + if (sprite->data[1] > 80) + DestroyAnimSprite(sprite); +} + +// Animates a sprite that moves linearly from one location to another, with a +// single-cycle sine wave added to the y position along the way. +// Used by Razor Leaf and Magical Leaf. +// arg 0: initial x offset +// arg 1: initial y offset +// arg 2: target x offset +// arg 3: target y offset +// arg 4: translation duration +// arg 5: wave amplitude +// arg 6: target between double battle opponents (boolean) +void AnimTranslateLinearSingleSineWave(struct Sprite* sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + if (!gBattleAnimArgs[6]) + { + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[3]; + } + else + { + SetAverageBattlerPositions(gBattleAnimTarget, TRUE, &sprite->data[2], &sprite->data[4]); + sprite->data[2] += gBattleAnimArgs[2]; + sprite->data[4] += gBattleAnimArgs[3]; + } + + sprite->data[5] = gBattleAnimArgs[5]; + InitAnimArcTranslation(sprite); + if (GetBattlerSide(gBattleAnimAttacker) == GetBattlerSide(gBattleAnimTarget)) + sprite->data[0] = 1; + else + sprite->data[0] = 0; + + sprite->callback = AnimTranslateLinearSingleSineWaveStep; +} + +static void AnimTranslateLinearSingleSineWaveStep(struct Sprite* sprite) +{ + bool8 destroy = FALSE; + s16 a = sprite->data[0]; + s16 b = sprite->data[7]; + s16 r0; + + sprite->data[0] = 1; + TranslateAnimHorizontalArc(sprite); + r0 = sprite->data[7]; + sprite->data[0] = a; + if (b > 200 && r0 < 56 && sprite->oam.affineParam == 0) + sprite->oam.affineParam++; + + if (sprite->oam.affineParam && sprite->data[0]) + { + sprite->invisible ^= 1; + sprite->oam.affineParam++; + if (sprite->oam.affineParam == 30) + destroy = TRUE; + } + + if (sprite->pos1.x + sprite->pos2.x > 256 + || sprite->pos1.x + sprite->pos2.x < -16 + || sprite->pos1.y + sprite->pos2.y > 160 + || sprite->pos1.y + sprite->pos2.y < -16) + destroy = TRUE; + + if (destroy) + DestroyAnimSprite(sprite); +} + +// Animates particles in the Twister move animation. +// arg 0: duration +// arg 1: total y delta (the particles rise upward) +// arg 2: wave period (higher means faster wave) +// arg 3: wave amplitude +// arg 4: speedup frame (particles move faster at the end of the animation) +void AnimMoveTwisterParticle(struct Sprite* sprite) +{ + if (IsDoubleBattle() == TRUE) + SetAverageBattlerPositions(gBattleAnimTarget, 1, &sprite->pos1.x, &sprite->pos1.y); + + sprite->pos1.y += 32; + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[2] = gBattleAnimArgs[2]; + sprite->data[3] = gBattleAnimArgs[3]; + sprite->data[4] = gBattleAnimArgs[4]; + sprite->callback = AnimMoveTwisterParticleStep; +} + +static void AnimMoveTwisterParticleStep(struct Sprite* sprite) +{ + if (sprite->data[1] == 0xFF) + { + sprite->pos1.y -= 2; + } + else if (sprite->data[1] > 0) + { + sprite->pos1.y -= 2; + sprite->data[1] -= 2; + } + + sprite->data[5] += sprite->data[2]; + if (sprite->data[0] < sprite->data[4]) + sprite->data[5] += sprite->data[2]; + + sprite->data[5] &= 0xFF; + sprite->pos2.x = Cos(sprite->data[5], sprite->data[3]); + sprite->pos2.y = Sin(sprite->data[5], 5); + if (sprite->data[5] < 0x80) + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget) - 1; + else + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget) + 1; + + if (--sprite->data[0] == 0) + DestroyAnimSprite(sprite); +} + +// Squeezes a constricting "rope" several times via affine animations. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: affine anim num +// arg 3: num squeezes +void AnimConstrictBinding(struct Sprite* sprite) +{ + InitSpritePosToAnimTarget(sprite, FALSE); + sprite->affineAnimPaused = 1; + StartSpriteAffineAnim(sprite, gBattleAnimArgs[2]); + sprite->data[6] = gBattleAnimArgs[2]; + sprite->data[7] = gBattleAnimArgs[3]; + sprite->callback = AnimConstrictBindingStep1; +} + +static void AnimConstrictBindingStep1(struct Sprite* sprite) +{ + u8 spriteId; + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + { + sprite->affineAnimPaused = 0; + spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + sprite->data[0] = 0x100; + sprite->callback = AnimConstrictBindingStep2; + } +} + +static void AnimConstrictBindingStep2(struct Sprite* sprite) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (!sprite->data[2]) + sprite->data[0] += 11; + else + sprite->data[0] -= 11; + + if (++sprite->data[1] == 6) + { + sprite->data[1] = 0; + sprite->data[2] ^= 1; + } + + if (sprite->affineAnimEnded) + { + if (--sprite->data[7] > 0) + StartSpriteAffineAnim(sprite, sprite->data[6]); + else + DestroyAnimSprite(sprite); + } +} + +void sub_80FF458(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (gSprites[spriteId].invisible) + { + DestroyAnimVisualTask(taskId); + } + else + { + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_BLEND); + gTasks[taskId].data[14] = gSprites[spriteId].oam.priority; + gSprites[spriteId].oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget); + spriteId = GetAnimBattlerSpriteId(ANIM_DEF_PARTNER); + gTasks[taskId].data[15] = gSprites[spriteId].oam.priority; + gSprites[spriteId].oam.priority = GetBattlerSpriteBGPriority(BATTLE_PARTNER(gBattleAnimTarget)); + gTasks[taskId].data[0] = gBattleAnimArgs[0]; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + gTasks[taskId].data[11] = 0x100; + gTasks[taskId].func = AnimTask_DuplicateAndShrinkToPosStep1; + } +} + +static void AnimTask_DuplicateAndShrinkToPosStep1(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + gTasks[taskId].data[10] += gTasks[taskId].data[0]; + gSprites[spriteId].pos2.x = gTasks[taskId].data[10] >> 8; + if (GetBattlerSide(gBattleAnimTarget) != B_SIDE_PLAYER) + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos2.x; + + gTasks[taskId].data[11] += 16; + SetSpriteRotScale(spriteId, gTasks[taskId].data[11], gTasks[taskId].data[11], 0); + SetBattlerSpriteYOffsetFromYScale(spriteId); + if (--gTasks[taskId].data[1] == 0) + { + gTasks[taskId].data[0] = 0; + gTasks[taskId].func = AnimTask_DuplicateAndShrinkToPosStep2; + } +} + +static void AnimTask_DuplicateAndShrinkToPosStep2(u8 taskId) +{ + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + { + if (gTasks[taskId].data[0] == 0) + { + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + ResetSpriteRotScale(spriteId); + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + gSprites[spriteId].oam.priority = gTasks[taskId].data[14]; + spriteId = GetAnimBattlerSpriteId(ANIM_DEF_PARTNER); + gSprites[spriteId].oam.priority = gTasks[taskId].data[15]; + gTasks[taskId].data[0]++; + return; + } + } + else + { + if (gTasks[taskId].data[0] == 0) + return; + } + + gTasks[taskId].data[0]++; + if (gTasks[taskId].data[0] == 3) + DestroyAnimVisualTask(taskId); +} + +// Moves an orb from the target mon to the attacking mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +void AnimMimicOrb(struct Sprite* sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + gBattleAnimArgs[0] *= -1; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + gBattleAnimArgs[1]; + sprite->invisible = 1; + sprite->data[0]++; + break; + case 1: + sprite->invisible = 0; + if (sprite->affineAnimEnded) + { + ChangeSpriteAffineAnim(sprite, 1); + sprite->data[0] = 25; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->callback = InitAndRunAnimFastLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + break; + } + } +} + +// Animates a root that flickers away after some time. +// arg 0: x pixel offset +// arg 1: y pixel offset +// arg 2: sprite subpriority offset +// arg 3: sprite anim num +// arg 4: duration +void AnimIngrainRoot(struct Sprite* sprite) +{ + if (!sprite->data[0]) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); + sprite->pos2.x = gBattleAnimArgs[0]; + sprite->pos2.y = gBattleAnimArgs[1]; + sprite->subpriority = gBattleAnimArgs[2] + 30; + StartSpriteAnim(sprite, gBattleAnimArgs[3]); + sprite->data[2] = gBattleAnimArgs[4]; + sprite->data[0]++; + if (sprite->pos1.y + sprite->pos2.y > 120) + sprite->pos1.y += sprite->pos2.y + sprite->pos1.y - 120; + } + sprite->callback = AnimRootFlickerOut; +} + +// Places a root on the path to the target mon that flickers away after some time. +// arg 0: percent along the path to the target mon +// arg 1: x pixel offset +// arg 2: y pixel offset +// arg 3: sprite subpriority offset +// arg 4: sprite anum num +// arg 5: duration +void AnimFrenzyPlantRoot(struct Sprite *sprite) +{ + s16 attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + s16 attackerY = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + s16 targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + s16 targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + + targetX -= attackerX; + targetY -= attackerY; + sprite->pos1.x = attackerX + targetX * gBattleAnimArgs[0] / 100; + sprite->pos1.y = attackerY + targetY * gBattleAnimArgs[0] / 100; + sprite->pos2.x = gBattleAnimArgs[1]; + sprite->pos2.y = gBattleAnimArgs[2]; + sprite->subpriority = gBattleAnimArgs[3] + 30; + StartSpriteAnim(sprite, gBattleAnimArgs[4]); + sprite->data[2] = gBattleAnimArgs[5]; + sprite->callback = AnimRootFlickerOut; + gUnknown_0203A0F8[0] = sprite->pos1.x; + gUnknown_0203A0F8[1] = sprite->pos1.y; + gUnknown_0203A0F8[2] = targetX; + gUnknown_0203A0F8[3] = targetY; +} + +static void AnimRootFlickerOut(struct Sprite* sprite) +{ + if (++sprite->data[0] > (sprite->data[2] - 10)) + sprite->invisible = sprite->data[0] % 2; + + if (sprite->data[0] > sprite->data[2]) + DestroyAnimSprite(sprite); +} + +// Moves an orb in a fast wavy path. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: horizontal velocity +// arg 3: wave amplitude +// arg 4: duration +void AnimIngrainOrb(struct Sprite* sprite) +{ + if (!sprite->data[0]) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[3]; + sprite->data[3] = gBattleAnimArgs[4]; + } + + sprite->data[0]++; + sprite->pos2.x = sprite->data[1] * sprite->data[0]; + sprite->pos2.y = Sin((sprite->data[0] * 20) & 0xFF, sprite->data[2]); + if (sprite->data[0] > sprite->data[3]) + DestroyAnimSprite(sprite); +} + +static void sub_80FF9B8(struct Sprite* sprite, s16 c) +{ + int a = (sprite->pos1.x << 8) | sprite->pos1.y; + int b = (sprite->data[6] << 8) | sprite->data[7]; + c <<= 8; + sprite->data[5] = a; + sprite->data[6] = b; + sprite->data[7] = c; +} + +bool8 moveAlongLinearPath(struct Sprite* sprite) +{ + u16 xStartPos = (u8)(sprite->data[5] >> 8); + u16 yStartPos = (u8)sprite->data[5]; + s32 xEndPos = (u8)(sprite->data[6] >> 8); + s32 yEndPos = (u8)sprite->data[6]; + s16 totalTime = sprite->data[7] >> 8; + s16 currentTime = sprite->data[7] & 0xFF; + s16 yEndPos_2; + s16 r0; + s32 var1; + s32 vaxEndPos; + + if (xEndPos == 0) + xEndPos = -32; + else if (xEndPos == 255) + xEndPos = 272; + + yEndPos_2 = yEndPos - yStartPos; + r0 = xEndPos - xStartPos; + var1 = r0 * currentTime / totalTime; + vaxEndPos = yEndPos_2 * currentTime / totalTime; + sprite->pos1.x = var1 + xStartPos; + sprite->pos1.y = vaxEndPos + yStartPos; + if (++currentTime == totalTime) + return TRUE; + + sprite->data[7] = (totalTime << 8) | currentTime; + return FALSE; +} + +void AnimItemStealStep2(struct Sprite* sprite) +{ + if (sprite->data[0] == 10) + StartSpriteAffineAnim(sprite, 1); + + sprite->data[0]++; + if (sprite->data[0] > 50) + DestroyAnimSprite(sprite); +} + +static void AnimItemStealStep1(struct Sprite* sprite) +{ + sprite->data[0] += sprite->data[3] * 128 / sprite->data[4]; + if (sprite->data[0] >= 128) + { + sprite->data[1]++; + sprite->data[0] = 0; + } + + sprite->pos2.y = Sin(sprite->data[0] + 128, 30 - sprite->data[1] * 8); + if (moveAlongLinearPath(sprite)) + { + sprite->pos2.y = 0; + sprite->data[0] = 0; + sprite->callback = AnimItemStealStep2; + } +} + +void AnimPresent(struct Sprite* sprite) +{ + s16 targetX; + s16 targetY; + InitSpritePosToAnimAttacker(sprite, FALSE); + targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); + if (BATTLE_PARTNER(gBattleAnimAttacker) == gBattleAnimTarget) + { + sprite->data[6] = targetX; + sprite->data[7] = targetY + 10; + sub_80FF9B8(sprite, 60); + sprite->data[3] = 1; + } + else + { + sprite->data[6] = targetX; + sprite->data[7] = targetY + 10; + sub_80FF9B8(sprite, 60); + sprite->data[3] = 3; + } + + sprite->data[4] = 60; + sprite->callback = AnimItemStealStep1; +} + +static void sub_80FFB90(struct Sprite* sprite) +{ + int zero; + sprite->data[0] += ((sprite->data[3] * 128) / sprite->data[4]); + zero = 0; + if (sprite->data[0] > 0x7F) + { + sprite->data[1]++; + sprite->data[0] = zero; + } + + sprite->pos2.y = Sin(sprite->data[0] + 0x80, 30 - sprite->data[1] * 8); + if (moveAlongLinearPath(sprite)) + { + sprite->pos2.y = zero; + sprite->data[0] = zero; + DestroyAnimSprite(sprite); + } +} + +void AnimKnockOffItem(struct Sprite* sprite) +{ + s16 targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + sprite->data[6] = 0; + sprite->data[7] = targetY + 10; + sub_80FF9B8(sprite, 40); + sprite->data[3] = 3; + sprite->data[4] = 60; + sprite->callback = AnimItemStealStep1; + } + else + { + sprite->data[6] = 255; + sprite->data[7] = targetY + 10; + if (IsContest()) + sprite->data[6] = 0; + + sub_80FF9B8(sprite, 40); + sprite->data[3] = 3; + sprite->data[4] = 60; + sprite->callback = sub_80FFB90; + } +} + +// Animates a heal particle upward. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: vertical velocity +// arg 3: unused +void AnimPresentHealParticle(struct Sprite* sprite) +{ + if (!sprite->data[0]) + { + InitSpritePosToAnimTarget(sprite, FALSE); + sprite->data[1] = gBattleAnimArgs[2]; + } + + sprite->data[0]++; + sprite->pos2.y = sprite->data[1] * sprite->data[0]; + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimItemSteal(struct Sprite* sprite) +{ + s16 attackerX; + s16 attackerY; + InitSpritePosToAnimTarget(sprite, FALSE); + attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + attackerY = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); + if (BATTLE_PARTNER(gBattleAnimTarget) == gBattleAnimAttacker) + { + sprite->data[6] = attackerX; + sprite->data[7] = attackerY + 10; + sub_80FF9B8(sprite, 60); + sprite->data[3] = 1; + } + else + { + sprite->data[6] = attackerX; + sprite->data[7] = attackerY + 10; + sub_80FF9B8(sprite, 60); + sprite->data[3] = 3; + } + + sprite->data[4] = 60; + sprite->callback = AnimItemStealStep3; +} + +static void AnimItemStealStep3(struct Sprite* sprite) +{ + int zero; + sprite->data[0] += ((sprite->data[3] * 128) / sprite->data[4]); + zero = 0; + if (sprite->data[0] > 127) + { + sprite->data[1]++; + sprite->data[0] = zero; + } + + sprite->pos2.y = Sin(sprite->data[0] + 0x80, 30 - sprite->data[1] * 8); + if (sprite->pos2.y == 0) + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(63)); + + if (moveAlongLinearPath(sprite)) + { + sprite->pos2.y = 0; + sprite->data[0] = 0; + sprite->callback = AnimItemStealStep2; + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + } +} + +// Moves a bag in a circular motion. +// arg 0: y position +// arg 1: initial wave offset +void AnimTrickBag(struct Sprite* sprite) +{ + int a; + int b; + + if (!sprite->data[0]) + { + if (!IsContest()) + { + sprite->data[1] = gBattleAnimArgs[1]; + sprite->pos1.x = 120; + } + else + { + a = gBattleAnimArgs[1] - 32; + if (a < 0) + b = gBattleAnimArgs[1] + 0xDF; + else + b = a; + + sprite->data[1] = a - ((b >> 8) << 8); + sprite->pos1.x = 70; + } + + sprite->pos1.y = gBattleAnimArgs[0]; + sprite->data[2] = gBattleAnimArgs[0]; + sprite->data[4] = 20; + sprite->pos2.x = Cos(sprite->data[1], 60); + sprite->pos2.y = Sin(sprite->data[1], 20); + sprite->callback = AnimTrickBagStep1; + if (sprite->data[1] > 0 && sprite->data[1] < 192) + sprite->subpriority = 31; + else + sprite->subpriority = 29; + } +} + +static void AnimTrickBagStep1(struct Sprite* sprite) +{ + switch (sprite->data[3]) + { + case 0: + if (sprite->data[2] > 78) + { + sprite->data[3] = 1; + StartSpriteAffineAnim(sprite, 1); + break; + } + else + { + sprite->data[2] += sprite->data[4] / 10; + sprite->data[4] += 3; + sprite->pos1.y = sprite->data[2]; + break; + } + break; + case 1: + if (sprite->data[3] && sprite->affineAnimEnded) + { + sprite->data[0] = 0; + sprite->data[2] = 0; + sprite->callback = AnimTrickBagStep2; + } + break; + } +} + +static void AnimTrickBagStep2(struct Sprite* sprite) +{ + if (sprite->data[2] == gTrickBagCoordinates[sprite->data[0]][1]) + { + if (gTrickBagCoordinates[sprite->data[0]][2] == 127) + { + sprite->data[0] = 0; + sprite->callback = AnimTrickBagStep3; + } + + sprite->data[2] = 0; + sprite->data[0]++; + } + else + { + sprite->data[2]++; + sprite->data[1] = (gTrickBagCoordinates[sprite->data[0]][0] * gTrickBagCoordinates[sprite->data[0]][2] + sprite->data[1]) & 0xFF; + if (!IsContest()) + { + if ((u16)(sprite->data[1] - 1) < 191) + sprite->subpriority = 31; + else + sprite->subpriority = 29; + } + + sprite->pos2.x = Cos(sprite->data[1], 60); + sprite->pos2.y = Sin(sprite->data[1], 20); + } +} + +static void AnimTrickBagStep3(struct Sprite* sprite) +{ + if (sprite->data[0] > 20) + DestroyAnimSprite(sprite); + + sprite->invisible = sprite->data[0] % 2; + sprite->data[0]++; +} + +void AnimTask_LeafBlade(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[4] = GetBattlerSpriteSubpriority(gBattleAnimTarget) - 1; + task->data[6] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + task->data[7] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + task->data[10] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_WIDTH); + task->data[11] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT); + task->data[5] = (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) ? 1 : -1; + task->data[9] = 56 - (task->data[5] * 64); + task->data[8] = task->data[7] - task->data[9] + task->data[6]; + task->data[2] = CreateSprite(&gLeafBladeSpriteTemplate, task->data[8], task->data[9], task->data[4]); + if (task->data[2] == MAX_SPRITES) + DestroyAnimVisualTask(taskId); + + gSprites[task->data[2]].data[0] = 10; + gSprites[task->data[2]].data[1] = task->data[8]; + gSprites[task->data[2]].data[2] = task->data[6] - (task->data[10] / 2 + 10) * task->data[5]; + gSprites[task->data[2]].data[3] = task->data[9]; + gSprites[task->data[2]].data[4] = task->data[7] + (task->data[11] / 2 + 10) * task->data[5]; + gSprites[task->data[2]].data[5] = LeafBladeGetPosFactor(&gSprites[task->data[2]]); + InitAnimArcTranslation(&gSprites[task->data[2]]); + task->func = AnimTask_LeafBladeStep; +} + +static void AnimTask_LeafBladeStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + struct Sprite* sprite = &gSprites[task->data[2]]; + int a = task->data[0]; + switch (a) + { + case 4: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 5; + task->data[0] = 0xFF; + } + break; + case 8: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 9; + task->data[0] = 0xFF; + } + break; + case 0: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 1; + task->data[0] = 0xFF; + } + break; + case 1: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[4] += 2; + task->data[3] = a; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 2: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 3; + task->data[0] = 0xFF; + } + break; + case 3: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6] - ((task->data[10] / 2) + 10) * task->data[5]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7] - ((task->data[11] / 2) + 10) * task->data[5]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[3] = 2; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 5: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6] + ((task->data[10] / 2) + 10) * task->data[5]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7] + ((task->data[11] / 2) + 10) * task->data[5]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[4] -= 2; + task->data[3] = 3; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 6: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 7; + task->data[0] = 0xFF; + } + break; + case 7: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[4] += 2; + task->data[3] = 4; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 9: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[6] - ((task->data[10] / 2) + 10) * task->data[5]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[7] + ((task->data[11] / 2) + 10) * task->data[5]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[3] = 5; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + case 10: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + task->data[15] = 11; + task->data[0] = 0xFF; + } + break; + case 11: + { + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 10; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = task->data[8]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = task->data[9]; + sprite->data[5] = LeafBladeGetPosFactor(sprite); + task->data[4] -= 2; + task->data[3] = 6; + sprite->subpriority = task->data[4]; + StartSpriteAnim(sprite, task->data[3]); + InitAnimArcTranslation(sprite); + task->data[0]++; + break; + } + case 12: + AnimTask_LeafBladeStep2(task, taskId); + if (TranslateAnimHorizontalArc(sprite)) + { + DestroySprite(sprite); + task->data[0]++; + } + break; + case 13: + if (task->data[12] == 0) + DestroyAnimVisualTask(taskId); + break; + case 0xFF: + if (++task->data[1] > 5) + { + task->data[1] = 0; + task->data[0] = task->data[15]; + } + break; + } +} + +static s16 LeafBladeGetPosFactor(struct Sprite* sprite) +{ + s16 var = 8; + if (sprite->data[4] < sprite->pos1.y) + var = -var; + + return var; +} + +static void AnimTask_LeafBladeStep2(struct Task* task, u8 taskId) +{ + task->data[14]++; + if (task->data[14] > 0) + { + u8 spriteId; + s16 spriteX; + s16 spriteY; + task->data[14] = 0; + spriteX = gSprites[task->data[2]].pos1.x + gSprites[task->data[2]].pos2.x; + spriteY = gSprites[task->data[2]].pos1.y + gSprites[task->data[2]].pos2.y; + spriteId = CreateSprite(&gLeafBladeSpriteTemplate, spriteX, spriteY, task->data[4]); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].data[6] = taskId; + gSprites[spriteId].data[7] = 12; + gTasks[taskId].data[12]++; + gSprites[spriteId].data[0] = task->data[13] & 1; + gTasks[taskId].data[13]++; + StartSpriteAnim(&gSprites[spriteId], task->data[3]); + gSprites[spriteId].subpriority = task->data[4]; + gSprites[spriteId].callback = AnimTask_LeafBladeStep2_Callback; + } + } +} + +static void AnimTask_LeafBladeStep2_Callback(struct Sprite* sprite) +{ + sprite->data[0]++; + if (sprite->data[0] > 1) + { + sprite->data[0] = 0; + sprite->invisible ^= 1; + sprite->data[1]++; + if (sprite->data[1] > 8) + { + gTasks[sprite->data[6]].data[sprite->data[7]]--; + DestroySprite(sprite); + } + } +} + +void AnimFlyingParticle(struct Sprite* sprite) +{ + u8 battler; + if (!gBattleAnimArgs[6]) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + if (GetBattlerSide(battler) != B_SIDE_PLAYER) + { + sprite->data[4] = 0; + sprite->data[2] = gBattleAnimArgs[3]; + sprite->pos1.x = 0xFFF0; + } + else + { + sprite->data[4] = 1; + sprite->data[2] = -gBattleAnimArgs[3]; + sprite->pos1.x = 0x100; + } + + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[3] = gBattleAnimArgs[4]; + switch (gBattleAnimArgs[5]) + { + case 0: + sprite->pos1.y = gBattleAnimArgs[0]; + sprite->oam.priority = GetBattlerSpriteBGPriority(battler); + break; + case 1: + sprite->pos1.y = gBattleAnimArgs[0]; + sprite->oam.priority = GetBattlerSpriteBGPriority(battler) + 1; + break; + case 2: + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[0]; + sprite->oam.priority = GetBattlerSpriteBGPriority(battler); + break; + case 3: + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[0]; + GetAnimBattlerSpriteId(ANIM_TARGET); + sprite->oam.priority = GetBattlerSpriteBGPriority(battler) + 1; + break; + } + + sprite->callback = AnimFlyingParticleStep; +} + +static void AnimFlyingParticleStep(struct Sprite* sprite) +{ + int a = sprite->data[7]; + sprite->data[7]++; + sprite->pos2.y = (sprite->data[1] * gSineTable[sprite->data[0]]) >> 8; + sprite->pos2.x = sprite->data[2] * a; + sprite->data[0] = (sprite->data[3] * a) & 0xFF; + if (!sprite->data[4]) + { + if (sprite->pos2.x + sprite->pos1.x <= 0xF7) + return; + } + else + { + if (sprite->pos2.x + sprite->pos1.x > -16) + return; + } + + DestroySpriteAndMatrix(sprite); +} + +void sub_80A41C4(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[0]) + { + case 0: + task->data[8] = IndexOfSpritePaletteTag(ANIM_TAG_LEAF) * 16 + 256; + task->data[12] = IndexOfSpritePaletteTag(ANIM_TAG_RAZOR_LEAF) * 16 + 256; + task->data[0]++; + break; + case 1: + if (++task->data[9] >= 0) + { + task->data[9] = 0; + BlendPalette(task->data[8], 16, task->data[10], gMagicalLeafBlendColors[task->data[11]]); + BlendPalette(task->data[12], 16, task->data[10], gMagicalLeafBlendColors[task->data[11]]); + if (++task->data[10] == 17) + { + task->data[10] = 0; + if (++task->data[11] == 7) + task->data[11] = 0; + } + } + break; + } + + if (gBattleAnimArgs[7] == -1) + DestroyAnimVisualTask(taskId); +} + +void AnimNeedleArmSpike(struct Sprite* sprite) +{ + u8 a; + u8 b; + u16 c; + u16 x; + u16 y; + + if (gBattleAnimArgs[4] == 0) + { + DestroyAnimSprite(sprite); + } + else + { + if (gBattleAnimArgs[0] == 0) + { + a = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + b = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + } + else + { + a = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + b = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + } + + sprite->data[0] = gBattleAnimArgs[4]; + if (gBattleAnimArgs[1] == 0) + { + sprite->pos1.x = gBattleAnimArgs[2] + a; + sprite->pos1.y = gBattleAnimArgs[3] + b; + sprite->data[5] = a; + sprite->data[6] = b; + } + else + { + sprite->pos1.x = a; + sprite->pos1.y = b; + sprite->data[5] = gBattleAnimArgs[2] + a; + sprite->data[6] = gBattleAnimArgs[3] + b; + } + + x = sprite->pos1.x; + sprite->data[1] = x * 16; + y = sprite->pos1.y; + sprite->data[2] = y * 16; + sprite->data[3] = (sprite->data[5] - sprite->pos1.x) * 16 / gBattleAnimArgs[4]; + sprite->data[4] = (sprite->data[6] - sprite->pos1.y) * 16 / gBattleAnimArgs[4]; + c = ArcTan2Neg(sprite->data[5] - x, sprite->data[6] - y); + if (IsContest()) + c -= 0x8000; + + TrySetSpriteRotScale(sprite, 0, 0x100, 0x100, c); + sprite->callback = AnimNeedleArmSpikeStep; + } +} + +static void AnimNeedleArmSpikeStep(struct Sprite* sprite) +{ + if (sprite->data[0]) + { + sprite->data[1] += sprite->data[3]; + sprite->data[2] += sprite->data[4]; + sprite->pos1.x = sprite->data[1] >> 4 ; + sprite->pos1.y = sprite->data[2] >> 4 ; + sprite->data[0]--; + } + else + { + DestroySpriteAndMatrix(sprite); + } +} + +static void sub_80A43DC(struct Sprite* sprite) +{ + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void sub_80A43F8(struct Sprite* sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + else + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + + sprite->callback = RunStoredCallbackWhenAnimEnds; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimWhipHit(struct Sprite* sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + StartSpriteAnim(sprite, 1); + + sprite->callback = sub_80A43DC; + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; +} + +void sub_80A4494(struct Sprite* sprite) +{ + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[3] = gBattleAnimArgs[4]; + sprite->data[5] = gBattleAnimArgs[5]; + StartSpriteAffineAnim(sprite, gBattleAnimArgs[6]); + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); + sprite->callback = TranslateSpriteLinearAndFlicker; +} + +// Moves the sprite in a diagonally slashing motion across the target mon. +// Used by moves such as MOVE_CUT and MOVE_AERIAL_ACE. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: slice direction; 0 = right-to-left, 1 = left-to-right +void AnimCuttingSlice(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + sprite->pos1.y += 8; + + sprite->callback = AnimSliceStep; + if (gBattleAnimArgs[2] == 0) + { + sprite->pos1.x += gBattleAnimArgs[0]; + } + else + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->hFlip = 1; + } + + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[1] -= 0x400; + sprite->data[2] += 0x400; + sprite->data[5] = gBattleAnimArgs[2]; + if (sprite->data[5] == 1) + sprite->data[1] = -sprite->data[1]; +} + +void AnimAirCutterSlice(struct Sprite* sprite) +{ + u8 a; + u8 b; + switch (gBattleAnimArgs[3]) + { + case 1: + a = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 0); + b = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 1); + break; + case 2: + a = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + b = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget))) + { + a = (GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 0) + a) / 2; + b = (GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 1) + b) / 2; + } + break; + case 0: + default: + a = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + b = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + break; + } + + sprite->pos1.x = a; + sprite->pos1.y = b; + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + sprite->pos1.y += 8; + + sprite->callback = AnimSliceStep; + if (gBattleAnimArgs[2] == 0) + { + sprite->pos1.x += gBattleAnimArgs[0]; + } + else + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->hFlip = 1; + } + + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[1] -= 0x400; + sprite->data[2] += 0x400; + sprite->data[5] = gBattleAnimArgs[2]; + if (sprite->data[5] == 1) + sprite->data[1] = -sprite->data[1]; +} + +static void AnimSliceStep(struct Sprite* sprite) +{ + sprite->data[3] += sprite->data[1]; + sprite->data[4] += sprite->data[2]; + if (sprite->data[5] == 0) + sprite->data[1] += 0x18; + else + sprite->data[1] -= 0x18; + + sprite->data[2] -= 0x18; + sprite->pos2.x = sprite->data[3] >> 8; + sprite->pos2.y = sprite->data[4] >> 8; + sprite->data[0]++; + if (sprite->data[0] == 20) + { + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->data[0] = 3; + sprite->callback = WaitAnimForDuration; + } +} + +void sub_80A4738(struct Sprite* sprite) +{ + if (sprite->data[2] > 1) + { + if (sprite->data[3] & 1) + { + sprite->invisible = 0; + gSprites[sprite->data[0]].invisible = 0; + gSprites[sprite->data[1]].invisible = 0; + } + else + { + sprite->invisible = 1; + gSprites[sprite->data[0]].invisible = 1; + gSprites[sprite->data[1]].invisible = 1; + } + + sprite->data[2] = 0; + sprite->data[3]++; + } + else + { + sprite->data[2]++; + } + + if (sprite->data[3] == 10) + { + DestroySprite(&gSprites[sprite->data[0]]); + DestroySprite(&gSprites[sprite->data[1]]); + DestroyAnimSprite(sprite); + } +} + +void sub_80A481C(struct Sprite* sprite) +{ + sprite->data[0] = gBattleAnimArgs[2]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x -= gBattleAnimArgs[0]; + else + sprite->pos1.x += gBattleAnimArgs[0]; + + StartSpriteAnim(sprite, gBattleAnimArgs[5]); + sprite->data[1] = -gBattleAnimArgs[3]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[3] = gBattleAnimArgs[4]; + sprite->callback = sub_80A4880; + sprite->callback(sprite); +} + +static void sub_80A4880(struct Sprite* sprite) +{ + sprite->pos2.x = Cos(sprite->data[0], 100); + sprite->pos2.y = Sin(sprite->data[0], 20); + if (sprite->data[0] < 128) + sprite->subpriority = 0; + else + sprite->subpriority = 14; + + sprite->data[0] = (sprite->data[0] + sprite->data[1]) & 0xFF; + sprite->data[5] += 0x82; + sprite->pos2.y += sprite->data[5] >> 8; + sprite->data[2]++; + if (sprite->data[2] == sprite->data[3]) + DestroyAnimSprite(sprite); +} + +void AnimProtect(struct Sprite* sprite) +{ + if (IsContest()) + gBattleAnimArgs[1] += 8; + + sprite->pos1.x = GetBattlerSpriteCoord2(gBattleAnimAttacker, 0) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord2(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER || IsContest()) + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker) + 1; + else + sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = (IndexOfSpritePaletteTag(ANIM_TAG_PROTECT) << 4) + 0x100; + sprite->data[7] = 16; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[7], sprite->data[7])); + sprite->callback = AnimProtectStep; +} + +static void AnimProtectStep(struct Sprite *sprite) +{ + int a; + int i; + sprite->data[5] += 96; + sprite->pos2.x = -(sprite->data[5] >> 8); + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + a = gPlttBufferFaded[sprite->data[2] + 1]; + i = 0; + do + { + gPlttBufferFaded[sprite->data[2] + ++i] = gPlttBufferFaded[sprite->data[2] + i + 1]; + } while (i < 6); + + gPlttBufferFaded[sprite->data[2] + 7] = a; + } + + if (sprite->data[7] > 6 && sprite->data[0] >0 && ++sprite->data[6] > 1) + { + sprite->data[6] = 0; + sprite->data[7] -= 1; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[7], sprite->data[7])); + } + + if (sprite->data[0] > 0) + { + sprite->data[0] -= 1; + } + else if (++sprite->data[6] > 1) + { + sprite->data[6] = 0; + sprite->data[7]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[7], sprite->data[7])); + if (sprite->data[7] == 16) + { + sprite->invisible = 1; + sprite->callback = DestroyAnimSpriteAndDisableBlend; + } + } +} + +void AnimMilkBottle(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + 0xFFE8; + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = 0; + sprite->data[6] = 0; + sprite->data[7] = 16; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + sprite->callback = AnimMilkBottleStep1; +} + +static void AnimMilkBottleStep1(struct Sprite* sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (++sprite->data[2] > 0) + { + sprite->data[2] = 0; + if (((++sprite->data[1]) & 1) != 0) + { + if (sprite->data[6] <= 15) + sprite->data[6]++; + } + else if (sprite->data[7] > 0) + sprite->data[7]--; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + if (sprite->data[6] == 16 && sprite->data[7] == 0) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + } + break; + case 1: + if (++sprite->data[1] > 8) + { + sprite->data[1] = 0; + StartSpriteAffineAnim(sprite, 1); + sprite->data[0]++; + } + break; + case 2: + AnimMilkBottleStep2(sprite, 16, 4); + if (++sprite->data[1] > 2) + { + sprite->data[1] = 0; + sprite->pos1.y++; + } + + if (++sprite->data[2] <= 29) + break; + + if (sprite->data[2] & 1) + { + if (sprite->data[6] > 0) + sprite->data[6]--; + } + else if (sprite->data[7] <= 15) + { + sprite->data[7]++; + } + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + if (sprite->data[6] == 0 && sprite->data[7] == 16) + { + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 3: + sprite->invisible = 1; + sprite->data[0]++; + break; + case 4: + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 0)); + DestroyAnimSprite(sprite); + break; + } +} + +static void AnimMilkBottleStep2(struct Sprite* sprite, int unk1, int unk2) +{ + if (sprite->data[3] <= 11) + sprite->data[4] += 2; + + if ((u16)(sprite->data[3] - 0x12) <= 0x17) + sprite->data[4] -= 2; + + if ((sprite->data[3]) > 0x2F) + sprite->data[4] += 2; + + sprite->pos2.x = sprite->data[4] / 9; + sprite->pos2.y = sprite->data[4] / 14; + if (sprite->pos2.y < 0) + sprite->pos2.y *= -1; + + sprite->data[3]++; + if (sprite->data[3] > 0x3B) + sprite->data[3] = 0; +} + +void AnimGrantingStars(struct Sprite* sprite) +{ + if (!gBattleAnimArgs[2]) + SetSpriteCoordsToAnimAttackerCoords(sprite); + + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[5]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[2] = gBattleAnimArgs[4]; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = TranslateSpriteLinearFixedPoint; +} + +void AnimSparkingStars(struct Sprite* sprite) +{ + u8 battler; + if (!gBattleAnimArgs[2]) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + if (IsDoubleBattle() && IsBattlerSpriteVisible(BATTLE_PARTNER(battler))) + { + SetAverageBattlerPositions(battler, gBattleAnimArgs[6], &sprite->pos1.x, &sprite->pos1.y); + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; + } + else + { + if (!gBattleAnimArgs[6]) + { + sprite->pos1.x = GetBattlerSpriteCoord(battler, 0); + sprite->pos1.y = GetBattlerSpriteCoord(battler, 1) + gBattleAnimArgs[1]; + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(battler, 2); + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[1]; + } + + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + } + + sprite->data[0] = gBattleAnimArgs[5]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[2] = gBattleAnimArgs[4]; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = TranslateSpriteLinearFixedPoint; +} + +void sub_80A4E40(struct Sprite* sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + else + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + StartSpriteAnim(sprite, 1); + } + + sprite->callback = sub_80A4EA0; +} + +static void sub_80A4EA0(struct Sprite* sprite) +{ + if (++sprite->data[0] > 30) + { + sprite->pos2.y = (30 - sprite->data[0]) / 3; + sprite->pos2.x = Sin(sprite->data[1] * 4, 3); + sprite->data[1]++; + } + + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimSleepLetterZ(struct Sprite* sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[3] = 1; + } + else + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[3] = 0xFFFF; + StartSpriteAffineAnim(sprite, 1); + } + + sprite->callback = AnimSleepLetterZStep; +} + +static void AnimSleepLetterZStep(struct Sprite* sprite) +{ + sprite->pos2.y = -(sprite->data[0] / 0x28); + sprite->pos2.x = sprite->data[4] / 10; + sprite->data[4] += sprite->data[3] * 2; + sprite->data[0] += sprite->data[1]; + if (++sprite->data[1] > 60) + DestroySpriteAndMatrix(sprite); +} + +void AnimLockOnTarget(struct Sprite* sprite) +{ + sprite->pos1.x -= 32; + sprite->pos1.y -= 32; + sprite->data[0] = 20; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep1); +} + +static void AnimLockOnTargetStep1(struct Sprite* sprite) +{ + switch (sprite->data[5] & 1) + { + case 0: + sprite->data[0] = 1; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep1); + break; + case 1: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[0] = 8; + sprite->data[2] = sprite->pos1.x + gInclineMonCoordTable[sprite->data[5] >> 8][0]; + sprite->data[4] = sprite->pos1.y + gInclineMonCoordTable[sprite->data[5] >> 8][1]; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep2); + sprite->data[5] += 0x100; + PlaySE12WithPanning(SE_W199, BattleAnimAdjustPanning(63)); + break; + } + + sprite->data[5] ^= 1; +} + +static void AnimLockOnTargetStep2(struct Sprite* sprite) +{ + if ((sprite->data[5] >> 8) == 4) + { + sprite->data[0] = 10; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep3); + } + else + { + sprite->callback = AnimLockOnTargetStep1; + } +} + +static void AnimLockOnTargetStep3(struct Sprite* sprite) +{ + s16 a; + s16 b; + if (sprite->oam.affineParam == 0) + { + sprite->data[0] = 3; + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep4); + } + else + { + switch (sprite->oam.affineParam) + { + case 1: + a = -8; + b = -8; + break; + case 2: + a = -8; + b = 8; + break; + case 3: + a = 8; + b = -8; + break; + default: + a = 8; + b = 8; + break; + } + + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[0] = 6; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + a; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + b; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep5); + } +} + +static void AnimLockOnTargetStep4(struct Sprite* sprite) +{ + if (sprite->data[2] == 0) + { + if ((sprite->data[1] += 3) > 16) + sprite->data[1] = 16; + } + else if ((sprite->data[1] -= 3) < 0) + { + sprite->data[1] = 0; + } + + BlendPalettes(sub_80A75AC(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB(31, 31, 31)); + if (sprite->data[1] == 16) + { + int pal; + sprite->data[2]++; + pal = sprite->oam.paletteNum; + LoadPalette(&gPlttBufferUnfaded[0x108 + pal * 16], pal * 16 | 0x101, 4); + PlaySE12WithPanning(SE_W043, BattleAnimAdjustPanning(63)); + } + else if (sprite->data[1] == 0) + { + sprite->callback = AnimLockOnTargetStep5; + } +} + +static void AnimLockOnTargetStep5(struct Sprite* sprite) +{ + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + { + sprite->data[1] = 0; + sprite->data[0] = 0; + sprite->callback = AnimLockOnTargetStep6; + } +} + +static void AnimLockOnTargetStep6(struct Sprite* sprite) +{ + if (sprite->data[0] % 3 == 0) + { + sprite->data[1]++; + sprite->invisible ^= 1; + } + + sprite->data[0]++; + if (sprite->data[1] == 8) + DestroyAnimSprite(sprite); +} + +void AnimLockOnMoveTarget(struct Sprite* sprite) +{ + sprite->oam.affineParam = gBattleAnimArgs[0]; + if ((s16)sprite->oam.affineParam == 1) + { + sprite->pos1.x -= 0x18; + sprite->pos1.y -= 0x18; + } + else if ((s16)sprite->oam.affineParam == 2) + { + sprite->pos1.x -= 0x18; + sprite->pos1.y += 0x18; + sprite->oam.matrixNum = ST_OAM_VFLIP; + } + else if ((s16)sprite->oam.affineParam == 3) + { + sprite->pos1.x += 0x18; + sprite->pos1.y -= 0x18; + sprite->oam.matrixNum = ST_OAM_HFLIP; + } + else + { + sprite->pos1.x += 0x18; + sprite->pos1.y += 0x18; + sprite->oam.matrixNum = ST_OAM_HFLIP | ST_OAM_VFLIP; + } + + sprite->oam.tileNum = (sprite->oam.tileNum + 16); + sprite->callback = AnimLockOnTarget; + sprite->callback(sprite); +} + +void AnimBowMon(struct Sprite* sprite) +{ + sprite->invisible = 1; + sprite->data[0] = 0; + switch (gBattleAnimArgs[0]) + { + case 0: + sprite->callback = AnimBowMonStep1; + break; + case 1: + sprite->callback = AnimBowMonStep2; + break; + case 2: + sprite->callback = AnimBowMonStep3; + break; + default: + sprite->callback = AnimBowMonStep4; + break; + } +} + +static void AnimBowMonStep1(struct Sprite* sprite) +{ + sprite->data[0] = 6; + sprite->data[1] = (GetBattlerSide(gBattleAnimAttacker)) ? 2 : -2; + sprite->data[2] = 0; + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + StoreSpriteCallbackInData6(sprite, AnimBowMonStep1_Callback); + sprite->callback = TranslateMonSpriteLinear; +} + +static void AnimBowMonStep1_Callback(struct Sprite* sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + PrepareBattlerSpriteForRotScale(sprite->data[3], ST_OAM_OBJ_NORMAL); + sprite->data[4] = (sprite->data[6] = GetBattlerSide(gBattleAnimAttacker)) ? 0x300 : 0xFFFFFD00; + sprite->data[5] = 0; + } + + sprite->data[5] += sprite->data[4]; + SetSpriteRotScale(sprite->data[3], 0x100, 0x100, sprite->data[5]); + SetBattlerSpriteYOffsetFromRotation(sprite->data[3]); + if (++sprite->data[0] > 3) + { + sprite->data[0] = 0; + sprite->callback = AnimBowMonStep4; + } +} + +static void AnimBowMonStep2(struct Sprite* sprite) +{ + sprite->data[0] = 4; + sprite->data[1] = (GetBattlerSide(gBattleAnimAttacker)) ? -3 : 3; + sprite->data[2] = 0; + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + StoreSpriteCallbackInData6(sprite, AnimBowMonStep4); + sprite->callback = TranslateMonSpriteLinear; +} + +static void AnimBowMonStep3(struct Sprite* sprite) +{ + if (++sprite->data[0] > 8) + { + sprite->data[0] = 0; + sprite->callback = AnimBowMonStep3_Callback; + } +} + +static void AnimBowMonStep3_Callback(struct Sprite* sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + sprite->data[6] = GetBattlerSide(gBattleAnimAttacker); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->data[4] = 0xFC00; + sprite->data[5] = 0xC00; + } + else + { + sprite->data[4] = 0x400; + sprite->data[5] = 0xF400; + } + } + + sprite->data[5] += sprite->data[4]; + SetSpriteRotScale(sprite->data[3], 0x100, 0x100, sprite->data[5]); + SetBattlerSpriteYOffsetFromRotation(sprite->data[3]); + if (++sprite->data[0] > 2) + { + ResetSpriteRotScale(sprite->data[3]); + sprite->callback = AnimBowMonStep4; + } +} + +static void AnimBowMonStep4(struct Sprite* sprite) +{ + DestroyAnimSprite(sprite); +} + +void sub_80A5590(struct Sprite *sprite) +{ + sprite->data[0] = 0; + sprite->callback = sub_80A55A0; +} + +static void sub_80A55A0(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->data[1] = 0; + sprite->data[2] = gBattlerSpriteIds[gBattleAnimAttacker]; + sprite->data[3] = GetBattlerSide(gBattleAnimAttacker); + sprite->data[4] = (sprite->data[3] != B_SIDE_PLAYER) ? 0x200 : -0x200; + sprite->data[5] = 0; + PrepareBattlerSpriteForRotScale(sprite->data[2], ST_OAM_OBJ_NORMAL); + sprite->data[0]++; + // fall through + case 1: + sprite->data[5] += sprite->data[4]; + SetSpriteRotScale(sprite->data[2], 0x100, 0x100, sprite->data[5]); + SetBattlerSpriteYOffsetFromRotation(sprite->data[2]); + if (++sprite->data[1] > 3) + { + sprite->data[1] = 0; + sprite->data[4] *= -1; + sprite->data[0]++; + } + break; + case 2: + sprite->data[5] += sprite->data[4]; + SetSpriteRotScale(sprite->data[2], 0x100, 0x100, sprite->data[5]); + SetBattlerSpriteYOffsetFromRotation(sprite->data[2]); + if (++sprite->data[1] > 3) + { + ResetSpriteRotScale(sprite->data[2]); + DestroyAnimSprite(sprite); + } + break; + } +} + +void AnimTask_SkullBashPosition(u8 taskId) +{ + u8 a; + + gTasks[taskId].data[0] = gBattlerSpriteIds[gBattleAnimAttacker]; + a = GetBattlerSide(gBattleAnimAttacker); + gTasks[taskId].data[1] = a; + gTasks[taskId].data[2] = 0; + switch (gBattleAnimArgs[0]) + { + default: + DestroyAnimVisualTask(taskId); + break; + case 0: + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[3] = 8; + gTasks[taskId].data[4] = 0; + gTasks[taskId].data[5] = 3; + if (a == 0) + gTasks[taskId].data[5] *= -1; + + gTasks[taskId].func = AnimTask_SkullBashPositionSet; + break; + case 1: + gTasks[taskId].data[3] = 8; + gTasks[taskId].data[4] = 0x600; + gTasks[taskId].data[5] = 0xC0; + if (a == 0) + { + gTasks[taskId].data[4] = -gTasks[taskId].data[4]; + gTasks[taskId].data[5] = -gTasks[taskId].data[5]; + } + + gTasks[taskId].func = AnimTask_SkullBashPositionReset; + break; + } +} + +static void AnimTask_SkullBashPositionSet(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + switch (task->data[2]) + { + case 0: + if (task->data[3]) + { + task->data[4] += task->data[5]; + gSprites[task->data[0]].pos2.x = task->data[4]; + task->data[3]--; + } + else + { + task->data[3] = 8; + task->data[4] = 0; + task->data[5] = (task->data[1] == 0) ? -0xC0 : 0xC0; + PrepareBattlerSpriteForRotScale(task->data[0], ST_OAM_OBJ_NORMAL); + task->data[2]++; + } + break; + case 1: + if (task->data[3]) + { + task->data[4] += task->data[5]; + SetSpriteRotScale(task->data[0], 0x100, 0x100, task->data[4]); + SetBattlerSpriteYOffsetFromRotation(task->data[0]); + task->data[3]--; + } + else + { + task->data[3] = 8; + task->data[4] = gSprites[task->data[0]].pos2.x; + task->data[5] = (task->data[1] == 0) ? 0x2 : -0x2; + task->data[6] = 1; + task->data[2]++; + } + break; + case 2: + if (task->data[3]) + { + if (task->data[6]) + { + task->data[6]--; + } + else + { + if (task->data[3] & 1) + gSprites[task->data[0]].pos2.x = task->data[4] + task->data[5]; + else + gSprites[task->data[0]].pos2.x = task->data[4] - task->data[5]; + + task->data[6] = 1; + task->data[3]--; + } + } + else + { + gSprites[task->data[0]].pos2.x = task->data[4]; + task->data[3] = 12; + task->data[2]++; + } + break; + case 3: + if (task->data[3]) + { + task->data[3]--; + } + else + { + task->data[3] = 3; + task->data[4] = gSprites[task->data[0]].pos2.x; + task->data[5] = (task->data[1] == 0) ? 8 : -8; + task->data[2]++; + } + break; + case 4: + if (task->data[3]) + { + task->data[4] += task->data[5]; + gSprites[task->data[0]].pos2.x = task->data[4]; + task->data[3]--; + } + else + { + DestroyAnimVisualTask(taskId); + } + break; + } +} + +static void AnimTask_SkullBashPositionReset(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (task->data[3]) + { + task->data[4] -= task->data[5]; + SetSpriteRotScale(task->data[0], 0x100, 0x100, task->data[4]); + SetBattlerSpriteYOffsetFromRotation(task->data[0]); + task->data[3]--; + } + else + { + ResetSpriteRotScale(task->data[0]); + DestroyAnimVisualTask(taskId); + } +} + +void AnimSlashSlice(struct Sprite* sprite) +{ + if (gBattleAnimArgs[0] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[2]; + } + + sprite->data[0] = 0; + sprite->data[1] = 0; + StoreSpriteCallbackInData6(sprite, AnimFalseSwipeSliceStep3); + sprite->callback = RunStoredCallbackWhenAnimEnds; +} + +void AnimFalseSwipeSlice(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 0xFFD0; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + StoreSpriteCallbackInData6(sprite, AnimFalseSwipeSliceStep1); + sprite->callback = RunStoredCallbackWhenAnimEnds; +} + +void AnimFalseSwipePositionedSlice(struct Sprite* sprite) +{ + sprite->pos1.x = sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 0xFFD0 + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + StartSpriteAnim(sprite, 1); + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->callback = AnimFalseSwipeSliceStep3; +} + +static void AnimFalseSwipeSliceStep1(struct Sprite* sprite) +{ + if (++sprite->data[0] > 8) + { + sprite->data[0] = 12; + sprite->data[1] = 8; + sprite->data[2] = 0; + StoreSpriteCallbackInData6(sprite, AnimFalseSwipeSliceStep2); + sprite->callback = TranslateSpriteLinear; + } +} + +static void AnimFalseSwipeSliceStep2(struct Sprite* sprite) +{ + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->callback = AnimFalseSwipeSliceStep3; +} + +static void AnimFalseSwipeSliceStep3(struct Sprite* sprite) +{ + if (++sprite->data[0] > 1) + { + sprite->data[0] = 0; + sprite->invisible = !sprite->invisible; + if (++sprite->data[1] > 8) + DestroyAnimSprite(sprite); + } +} + +void AnimEndureEnergy(struct Sprite* sprite) +{ + if (gBattleAnimArgs[0] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[2]; + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1) + gBattleAnimArgs[2]; + } + + sprite->data[0] = 0; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->callback = AnimEndureEnergyStep; +} + +static void AnimEndureEnergyStep(struct Sprite* sprite) +{ + if (++sprite->data[0] > sprite->data[1]) + { + sprite->data[0] = 0; + sprite->pos1.y--; + } + + sprite->pos1.y -= sprite->data[0]; + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimSharpenSphere(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) - 12; + sprite->data[0] = 0; + sprite->data[1] = 2; + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = 0; + sprite->data[5] = BattleAnimAdjustPanning(-64); + sprite->callback = AnimSharpenSphereStep; +} + +static void AnimSharpenSphereStep(struct Sprite* sprite) +{ + if (++sprite->data[0] >= sprite->data[1]) + { + sprite->invisible = !sprite->invisible; + if (!sprite->invisible) + { + sprite->data[4]++; + if (!(sprite->data[4] & 1)) + PlaySE12WithPanning(SE_W207B, sprite->data[5]); + } + + sprite->data[0] = 0; + if (++sprite->data[2] > 1) + { + sprite->data[2] = 0; + sprite->data[1]++; + } + } + + if (sprite->animEnded && sprite->data[1] > 16 && sprite->invisible) + DestroyAnimSprite(sprite); +} + +void AnimConversion(struct Sprite* sprite) +{ + if (sprite->data[0] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + if (IsContest()) + sprite->pos1.y += 10; + + sprite->data[0]++; + } + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + DestroyAnimSprite(sprite); +} + +void AnimTask_ConversionAlphaBlend(u8 taskId) +{ + if (gTasks[taskId].data[2] == 1) + { + gBattleAnimArgs[7] = 0xFFFF; + gTasks[taskId].data[2]++; + } + else if (gTasks[taskId].data[2] == 2) + { + DestroyAnimVisualTask(taskId); + } + else + { + if (++gTasks[taskId].data[0] == 4) + { + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - gTasks[taskId].data[1], gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 16) + gTasks[taskId].data[2]++; + } + } +} + +void AnimConversion2(struct Sprite* sprite) +{ + InitSpritePosToAnimTarget(sprite, FALSE); + sprite->animPaused = 1; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->callback = AnimConversion2Step; +} + +static void AnimConversion2Step(struct Sprite* sprite) +{ + if (sprite->data[0]) + { + sprite->data[0]--; + } + else + { + sprite->animPaused = 0; + sprite->data[0] = 30; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + } +} + +void AnimTask_Conversion2AlphaBlend(u8 taskId) +{ + if (++gTasks[taskId].data[0] == 4) + { + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 16) + DestroyAnimVisualTask(taskId); + } +} + +void sub_80A5E34(u8 taskId) +{ + u8 i; + for (i = 0; i < gBattlersCount; i++) + { + if (gBattleAnimArgs[0] == 1 && GetBattlerSide(i) == B_SIDE_PLAYER) + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[i]); + + if (gBattleAnimArgs[1] == 1 && GetBattlerSide(i) == B_SIDE_OPPONENT) + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[i]); + } + + DestroyAnimVisualTask(taskId); +} + +void sub_80A5EA8(u8 taskId) +{ + u8 i; + for (i = 0; i < gBattlersCount; i++) + SetHealthboxSpriteVisible(gHealthboxSpriteIds[i]); + + DestroyAnimVisualTask(taskId); +} + +void AnimMoon(struct Sprite* sprite) +{ + if (IsContest()) + { + sprite->pos1.x = 48; + sprite->pos1.y = 40; + } + else + { + sprite->pos1.x = gBattleAnimArgs[0]; + sprite->pos1.y = gBattleAnimArgs[1]; + } + + sprite->oam.shape = 0; + sprite->oam.size = 3; + sprite->data[0] = 0; + sprite->callback = AnimMoonStep; +} + +static void AnimMoonStep(struct Sprite* sprite) +{ + if (sprite->data[0]) + DestroyAnimSprite(sprite); +} + +void AnimMoonlightSparkle(struct Sprite* sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[0]; + sprite->pos1.y = gBattleAnimArgs[1]; + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = 1; + sprite->callback = AnimMoonlightSparkleStep; +} + +static void AnimMoonlightSparkleStep(struct Sprite* sprite) +{ + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + if (sprite->data[2] < 120) + { + sprite->pos1.y++; + sprite->data[2]++; + } + } + + if (sprite->data[0]) + DestroyAnimSprite(sprite); +} + +void AnimTask_FadeScreenBlueStep(u8); + + +void AnimTask_FadeScreenBlue(u8 taskId) +{ + int a = sub_80A75AC(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; + int b; + int c; + int d; + + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[3] = a; + gTasks[taskId].data[4] = 0; + gTasks[taskId].data[5] = 0; + gTasks[taskId].data[6] = 0; + gTasks[taskId].data[7] = 13; + gTasks[taskId].data[8] = 14; + gTasks[taskId].data[9] = 15; + b = sub_80A76C4(1, 1, 1, 1); + c = a | b; + StorePointerInVars(&gTasks[taskId].data[14], &gTasks[taskId].data[15], (void*)c); + b = b | (0x10000 << IndexOfSpritePaletteTag(ANIM_TAG_MOON)); + d = IndexOfSpritePaletteTag(ANIM_TAG_GREEN_SPARKLE); + BeginNormalPaletteFade((0x10000 << d) | b, 0, 0, 16, RGB(27, 29, 31)); + gTasks[taskId].func = AnimTask_FadeScreenBlueStep; + gTasks[taskId].func(taskId); +} + +void AnimTask_FadeScreenBlueStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[0]) + { + case 0: + if (++task->data[1] > 0) + { + u16 color; + u16 bitmask; + u16 r3; + u16 i; + u16 j; + task->data[1] = 0; + if (++task->data[2] <= 15) + { + u16 red; + u16 green; + u16 blue; + task->data[4] += task->data[7]; + task->data[5] += task->data[8]; + task->data[6] += task->data[9]; + red = task->data[4] >> 3; + green = task->data[5] >> 3; + blue = task->data[6] >> 3; + color = RGB(red, green, blue); + } + else + { + color = RGB(27, 29, 31); + task->data[0]++; + } + + bitmask = 1; + r3 = 0; + for (i = 0; i <= 15; i++) + { + if (task->data[3] & bitmask) + { + for (j = 1; j <= 15; j++) + { + gPlttBufferFaded[r3 + j] = color; + } + } + + bitmask <<= 1; + r3 += 16; + } + } + break; + case 1: + if (!gPaletteFade.active) + { + u8 spriteId; + for (spriteId = 0; spriteId < MAX_SPRITES; spriteId++) + { + if (gSprites[spriteId].template == &gMoonSpriteTemplate || gSprites[spriteId].template == &gMoonlightSparkleSpriteTemplate) + gSprites[spriteId].data[0] = 1; + } + + task->data[1] = 0; + task->data[0]++; + } + break; + case 2: + if (++task->data[1] > 30) + { + BeginNormalPaletteFade((u32)LoadPointerFromVars(task->data[14], task->data[15]), 0, 16, 0, RGB(27, 29, 31)); + task->data[0]++; + } + break; + case 3: + if (!gPaletteFade.active) + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimHornHit(struct Sprite* sprite) +{ + if (gBattleAnimArgs[2] < 2) + gBattleAnimArgs[2] = 2; + + if (gBattleAnimArgs[2] > 0x7F) + gBattleAnimArgs[2] = 0x7F; + + sprite->data[0] = 0; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[1]; + sprite->data[6] = sprite->pos1.x; + sprite->data[7] = sprite->pos1.y; + if (IsContest()) + { + sprite->oam.matrixNum = ST_OAM_HFLIP; + sprite->pos1.x += 40; + sprite->pos1.y += 20; + sprite->data[2] = sprite->pos1.x << 7; + sprite->data[3] = -0x1400 / sprite->data[1]; + sprite->data[4] = sprite->pos1.y << 7; + sprite->data[5] = -0xA00 / sprite->data[1]; + } + else if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x -= 40; + sprite->pos1.y += 20; + sprite->data[2] = sprite->pos1.x << 7; + sprite->data[3] = 0x1400 / sprite->data[1]; + sprite->data[4] = sprite->pos1.y << 7; + sprite->data[5] = -0xA00 / sprite->data[1]; + } + else + { + sprite->pos1.x += 40; + sprite->pos1.y -= 20; + sprite->data[2] = sprite->pos1.x << 7; + sprite->data[3] = -0x1400 / sprite->data[1]; + sprite->data[4] = sprite->pos1.y << 7; + sprite->data[5] = 0xA00 / sprite->data[1]; + sprite->oam.matrixNum = (ST_OAM_HFLIP | ST_OAM_VFLIP); + } + + sprite->callback = AnimHornHitStep; +} + +static void AnimHornHitStep(struct Sprite* sprite) +{ + sprite->data[2] += sprite->data[3]; + sprite->data[4] += sprite->data[5]; + sprite->pos1.x = sprite->data[2] >> 7; + sprite->pos1.y = sprite->data[4] >> 7; + if (--sprite->data[1] == 1) + { + sprite->pos1.x = sprite->data[6]; + sprite->pos1.y = sprite->data[7]; + } + + if (sprite->data[1] == 0) + DestroyAnimSprite(sprite); +} + +void AnimTask_DoubleTeam(u8 taskId) +{ + u16 i; + int obj; + u16 r3; + u16 r4; + struct Task* task = &gTasks[taskId]; + task->data[0] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[1] = AllocSpritePalette(ANIM_TAG_BENT_SPOON); + r3 = (task->data[1] * 16) + 0x100; + r4 = (gSprites[task->data[0]].oam.paletteNum + 16) << 4; + for (i = 1; i < 16; i++) + gPlttBufferUnfaded[r3 + i] = gPlttBufferUnfaded[r4 + i]; + + BlendPalette(r3, 16, 11, RGB(0, 0, 0)); + task->data[3] = 0; + i = 0; + while (i < 2 && (obj = CloneBattlerSpriteWithBlend(0)) >= 0) + { + gSprites[obj].oam.paletteNum = task->data[1]; + gSprites[obj].data[0] = 0; + gSprites[obj].data[1] = i << 7; + gSprites[obj].data[2] = taskId; + gSprites[obj].callback = AnimTask_DoubleTeamCallback; + task->data[3]++; + i++; + } + + task->func = AnimTask_DoubleTeamStep; + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG1_ON); + else + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG2_ON); +} + +static void AnimTask_DoubleTeamStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (!task->data[3]) + { + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG1_ON); + else + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG2_ON); + + FreeSpritePaletteByTag(ANIM_TAG_BENT_SPOON); + DestroyAnimVisualTask(taskId); + } +} + +static void AnimTask_DoubleTeamCallback(struct Sprite* sprite) +{ + if (++sprite->data[3] > 1) + { + sprite->data[3] = 0; + sprite->data[0]++; + } + + if (sprite->data[0] > 64) + { + gTasks[sprite->data[2]].data[3]--; + obj_delete_but_dont_free_vram(sprite); + } + else + { + sprite->data[4] = gSineTable[sprite->data[0]] / 6; + sprite->data[5] = gSineTable[sprite->data[0]] / 13; + sprite->data[1] = (sprite->data[1] + sprite->data[5]) & 0xFF; + sprite->pos2.x = Sin(sprite->data[1], sprite->data[4]); + } +} + +void AnimSuperFang(struct Sprite* sprite) +{ + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = RunStoredCallbackWhenAnimEnds; +} + +void AnimTask_MusicNotesRainbowBlend(u8 taskId) +{ + u16 i; + u16 j; + u16 index; + + index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[0][0]); + if (index != 0xFF) + { + index = (index << 4) + 0x100; + for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable[0]); i++) + gPlttBufferFaded[index + i] = gParticlesColorBlendTable[0][i]; + } + + for (j = 1; j < ARRAY_COUNT(gParticlesColorBlendTable); j++) + { + index = AllocSpritePalette(gParticlesColorBlendTable[j][0]); + if (index != 0xFF) + { + index = (index << 4) + 0x100; + for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable[0]); i++) + gPlttBufferFaded[index + i] = gParticlesColorBlendTable[j][i]; + } + } + DestroyAnimVisualTask(taskId); +} + +// clears the rainbow effect for musical notes. +void AnimTask_MusicNotesClearRainbowBlend(u8 taskId) +{ + u16 i; + for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable); i++) + FreeSpritePaletteByTag(gParticlesColorBlendTable[i][0]); + + DestroyAnimVisualTask(taskId); +} + +void AnimWavyMusicNotes(struct Sprite* sprite) +{ + u8 index; + u8 a; + u8 b; + SetSpriteCoordsToAnimAttackerCoords(sprite); + StartSpriteAnim(sprite, gBattleAnimArgs[0]); + if ((index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[gBattleAnimArgs[1]][0])) != 0xFF) + sprite->oam.paletteNum = index; + + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[2] = 0; + sprite->data[3] = gBattleAnimArgs[2]; + if (IsContest()) + { + a = 48; + b = 40; + } + else + { + a = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + b = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + } + + sprite->data[4] = sprite->pos1.x << 4; + sprite->data[5] = sprite->pos1.y << 4; + AnimWavyMusicNotesGetNextPos(a - sprite->pos1.x, b - sprite->pos1.y, &sprite->data[6], &sprite->data[7], 40); + sprite->callback = AnimWavyMusicNotesStep; +} + +static void AnimWavyMusicNotesGetNextPos(s16 a, s16 b, s16* c, s16* d, s8 e) +{ + int f; + int g; + if (a < 0) + e = -e; + + f = a << 8; + g = f / e; + if (g == 0) + g = 1; + + *c = f / g; + *d = (b << 8) / g; +} + +static void AnimWavyMusicNotesStep(struct Sprite* sprite) +{ + s16 y, yDelta; + u8 index; + + sprite->data[0]++; + yDelta = sprite->data[0] * 5 - ((sprite->data[0] * 5 / 256) << 8); + sprite->data[4] += sprite->data[6]; + sprite->data[5] += sprite->data[7]; + sprite->pos1.x = sprite->data[4] >> 4; + sprite->pos1.y = sprite->data[5] >> 4; + sprite->pos2.y = Sin(yDelta, 15); + + y = sprite->pos1.y; + if (sprite->pos1.x < -16 || sprite->pos1.x > 256 || y < -16 || y > 128) + { + DestroySpriteAndMatrix(sprite); + } + else + { + if (sprite->data[3] && ++sprite->data[2] > sprite->data[3]) + { + sprite->data[2] = 0; + if (++sprite->data[1] > 3) + sprite->data[1] = 0; + + index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[sprite->data[1]][0]); + if (index != 0xFF) + sprite->oam.paletteNum = index; + } + } +} + +void AnimFlyingMusicNotes(struct Sprite* sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + gBattleAnimArgs[1] *= -1; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + StartSpriteAnim(sprite, gBattleAnimArgs[0]); + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = sprite->pos1.x << 4; + sprite->data[5] = sprite->pos1.y << 4; + sprite->data[6] = (gBattleAnimArgs[1] << 4) / 5; + sprite->data[7] = (gBattleAnimArgs[2] << 7) / 5; + sprite->callback = AnimFlyingMusicNotesStep; +} + +static void AnimFlyingMusicNotesStep(struct Sprite* sprite) +{ + sprite->data[4] += sprite->data[6]; + sprite->data[5] += sprite->data[7]; + sprite->pos1.x = sprite->data[4] >> 4; + sprite->pos1.y = sprite->data[5] >> 4; + if (sprite->data[0] > 5 && sprite->data[3] == 0) + { + sprite->data[2] = (sprite->data[2] + 16) & 0xFF; + sprite->pos2.x = Cos(sprite->data[2], 18); + sprite->pos2.y = Sin(sprite->data[2], 18); + if (sprite->data[2] == 0) + sprite->data[3] = 1; + } + + if (++sprite->data[0] == 48) + DestroySpriteAndMatrix(sprite); +} + +void AnimBellyDrumHand(struct Sprite* sprite) +{ + s16 a; + if (gBattleAnimArgs[0] == 1) + { + sprite->oam.matrixNum = ST_OAM_HFLIP; + a = 16; + } + else + { + a = -16; + } + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + a; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + 8; + sprite->data[0] = 8; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimSlowFlyingMusicNotes(struct Sprite* sprite) +{ + s16 xDiff; + u8 index; + SetSpriteCoordsToAnimAttackerCoords(sprite); + sprite->pos1.y += 8; + StartSpriteAnim(sprite, gBattleAnimArgs[1]); + index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[gBattleAnimArgs[2]][0]); + if (index != 0xFF) + sprite->oam.paletteNum = index; + + xDiff = (gBattleAnimArgs[0] == 0) ? -32 : 32; + sprite->data[0] = 40; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = xDiff + sprite->data[1]; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = sprite->data[3] - 40; + InitAnimLinearTranslation(sprite); + sprite->data[5] = gBattleAnimArgs[3]; + sprite->callback = AnimSlowFlyingMusicNotesStep; +} + +static void AnimSlowFlyingMusicNotesStep(struct Sprite* sprite) +{ + if (AnimTranslateLinear(sprite) == 0) + { + s16 xDiff; + xDiff = Sin(sprite->data[5], 8); + if (sprite->pos2.x < 0) + xDiff = -xDiff; + + sprite->pos2.x += xDiff; + sprite->pos2.y += Sin(sprite->data[5], 4); + sprite->data[5] = (sprite->data[5] + 8) & 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +void SetSpriteNextToMonHead(u8 battler, struct Sprite* sprite) +{ + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_RIGHT) + 8; + else + sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_LEFT) - 8; + + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) - (s16)GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_HEIGHT) / 4; +} + +void AnimThoughtBubble(struct Sprite* sprite) +{ + u8 a; + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + SetSpriteNextToMonHead(battler, sprite); + a = (GetBattlerSide(battler) == B_SIDE_PLAYER) ? 0 : 1; + sprite->data[0] = gBattleAnimArgs[1]; + sprite->data[1] = a + 2; + StartSpriteAnim(sprite, a); + StoreSpriteCallbackInData6(sprite, AnimThoughtBubbleStep); + sprite->callback = RunStoredCallbackWhenAnimEnds; +} + +static void AnimThoughtBubbleStep(struct Sprite* sprite) +{ + if (--sprite->data[0] == 0) + { + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + StartSpriteAnim(sprite, sprite->data[1]); + sprite->callback = RunStoredCallbackWhenAnimEnds; + } +} + +void AnimMetronomeFinger(struct Sprite* sprite) +{ + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + SetSpriteNextToMonHead(battler, sprite); + sprite->data[0] = 0; + StoreSpriteCallbackInData6(sprite, AnimMetronomeFingerStep); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; +} + +static void AnimMetronomeFingerStep(struct Sprite* sprite) +{ + if (++sprite->data[0] > 16) + { + StartSpriteAffineAnim(sprite, 1); + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; + } +} + +void AnimFollowMeFinger(struct Sprite* sprite) +{ + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + sprite->pos1.x = GetBattlerSpriteCoord(battler, 0); + sprite->pos1.y = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_TOP); + if (sprite->pos1.y <= 9) + sprite->pos1.y = 10; + + sprite->data[0] = 1; + sprite->data[1] = 0; + sprite->data[2] = sprite->subpriority; + sprite->data[3] = sprite->subpriority + 4; + sprite->data[4] = 0; + StoreSpriteCallbackInData6(sprite, AnimFollowMeFingerStep1); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; +} + +static void AnimFollowMeFingerStep1(struct Sprite* sprite) +{ + if (++sprite->data[4] > 12) + sprite->callback = AnimFollowMeFingerStep2; +} + +static void AnimFollowMeFingerStep2(struct Sprite* sprite) +{ + s16 x1, x2; + + sprite->data[1] += 4; + if (sprite->data[1] > 254) + { + if (--sprite->data[0] == 0) + { + sprite->pos2.x = 0; + sprite->callback = AnimMetronomeFingerStep; + return; + } + else + { + sprite->data[1] &= 0xFF; + } + } + + if (sprite->data[1] > 0x4F) + sprite->subpriority = sprite->data[3]; + + if (sprite->data[1] > 0x9F) + sprite->subpriority = sprite->data[2]; + + x1 = gSineTable[sprite->data[1]]; + x2 = x1 >> 3; + sprite->pos2.x = (x1 >> 3) + (x2 >> 1); +} + +void AnimTauntFinger(struct Sprite* sprite) +{ + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + SetSpriteNextToMonHead(battler, sprite); + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + { + StartSpriteAnim(sprite, 0); + sprite->data[0] = 2; + } + else + { + StartSpriteAnim(sprite, 1); + sprite->data[0] = 3; + } + + sprite->callback = AnimTauntFingerStep1; +} + +static void AnimTauntFingerStep1(struct Sprite* sprite) +{ + if (++sprite->data[1] > 10) + { + sprite->data[1] = 0; + StartSpriteAnim(sprite, sprite->data[0]); + StoreSpriteCallbackInData6(sprite, AnimTauntFingerStep2); + sprite->callback = RunStoredCallbackWhenAnimEnds; + } +} + +static void AnimTauntFingerStep2(struct Sprite* sprite) +{ + if (++sprite->data[1] > 5) + DestroyAnimSprite(sprite); +} + diff --git a/src/battle_anim_mons.c b/src/battle_anim_mons.c index a3bd26898..bdba7ae3b 100644 --- a/src/battle_anim_mons.c +++ b/src/battle_anim_mons.c @@ -88,7 +88,7 @@ static const struct SpriteTemplate gUnknown_83AE054[] = { .tileTag = 0xD755, .paletteTag = 0xD755, - .oam = &gOamData_83ACA40, + .oam = &gOamData_AffineNormal_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -97,7 +97,7 @@ static const struct SpriteTemplate gUnknown_83AE054[] = { .tileTag = 0xD756, .paletteTag = 0xD756, - .oam = &gOamData_83ACA40, + .oam = &gOamData_AffineNormal_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/bug.c b/src/bug.c index b9f1795ab..e3bcb68ab 100644 --- a/src/bug.c +++ b/src/bug.c @@ -46,7 +46,7 @@ const struct SpriteTemplate gUnknown_83E7224 = { .tileTag = ANIM_TAG_HORN_HIT_2, .paletteTag = ANIM_TAG_HORN_HIT_2, - .oam = &gOamData_83ACAB8, + .oam = &gOamData_AffineDouble_ObjNormal_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7218, @@ -82,7 +82,7 @@ const struct SpriteTemplate gUnknown_83E7278 = { .tileTag = ANIM_TAG_NEEDLE, .paletteTag = ANIM_TAG_NEEDLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E726C, @@ -93,7 +93,7 @@ const struct SpriteTemplate gWebThreadSpriteTemplate = { .tileTag = ANIM_TAG_WEB_THREAD, .paletteTag = ANIM_TAG_WEB_THREAD, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -104,7 +104,7 @@ const struct SpriteTemplate gUnknown_83E72A8 = { .tileTag = ANIM_TAG_STRING, .paletteTag = ANIM_TAG_STRING, - .oam = &gOamData_83ACA00, + .oam = &gOamData_AffineOff_ObjNormal_64x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -127,7 +127,7 @@ const struct SpriteTemplate gSpiderWebSpriteTemplate = { .tileTag = ANIM_TAG_SPIDER_WEB, .paletteTag = ANIM_TAG_SPIDER_WEB, - .oam = &gOamData_83ACBC0, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E72D8, @@ -138,7 +138,7 @@ const struct SpriteTemplate gLinearStingerSpriteTemplate = { .tileTag = ANIM_TAG_NEEDLE, .paletteTag = ANIM_TAG_NEEDLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -149,7 +149,7 @@ const struct SpriteTemplate gPinMissileSpriteTemplate = { .tileTag = ANIM_TAG_NEEDLE, .paletteTag = ANIM_TAG_NEEDLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -160,7 +160,7 @@ const struct SpriteTemplate gIcicleSpearSpriteTemplate = { .tileTag = ANIM_TAG_ICICLE_SPEAR, .paletteTag = ANIM_TAG_ICICLE_SPEAR, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -187,7 +187,7 @@ const struct SpriteTemplate gUnknown_83E7378 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7374, diff --git a/src/dark.c b/src/dark.c index 368f5cbd5..e13227316 100644 --- a/src/dark.c +++ b/src/dark.c @@ -27,7 +27,7 @@ const struct SpriteTemplate gUnknown_83E7878 = { .tileTag = ANIM_TAG_TIED_BAG, .paletteTag = ANIM_TAG_TIED_BAG, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -98,7 +98,7 @@ const struct SpriteTemplate gUnknown_83E7930 = { .tileTag = ANIM_TAG_SHARP_TEETH, .paletteTag = ANIM_TAG_SHARP_TEETH, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7910, @@ -109,7 +109,7 @@ const struct SpriteTemplate gUnknown_83E7948 = { .tileTag = ANIM_TAG_CLAMP, .paletteTag = ANIM_TAG_CLAMP, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7910, @@ -140,7 +140,7 @@ const struct SpriteTemplate gUnknown_83E7998 = { .tileTag = ANIM_TAG_SMALL_BUBBLES, .paletteTag = ANIM_TAG_SMALL_BUBBLES, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7990, @@ -177,7 +177,7 @@ const struct SpriteTemplate gUnknown_83E79E8 = { .tileTag = ANIM_TAG_CLAW_SLASH, .paletteTag = ANIM_TAG_CLAW_SLASH, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E79E0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/dragon.c b/src/dragon.c index 34f97ba74..d18cf25df 100644 --- a/src/dragon.c +++ b/src/dragon.c @@ -35,7 +35,7 @@ const struct SpriteTemplate gUnknown_83E772C = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E7728, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -88,7 +88,7 @@ const struct SpriteTemplate gUnknown_83E77A4 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E7764, .images = NULL, .affineAnims = gUnknown_83E779C, @@ -114,7 +114,7 @@ const struct SpriteTemplate gUnknown_83E77D8 = { .tileTag = ANIM_TAG_FIRE_PLUME, .paletteTag = ANIM_TAG_FIRE_PLUME, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E77D4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -157,7 +157,7 @@ const struct SpriteTemplate gUnknown_83E7830 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E7800, .images = NULL, .affineAnims = gUnknown_83E7828, @@ -168,7 +168,7 @@ const struct SpriteTemplate gUnknown_83E7848 = { .tileTag = ANIM_TAG_HOLLOW_ORB, .paletteTag = ANIM_TAG_HOLLOW_ORB, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -179,7 +179,7 @@ const struct SpriteTemplate gUnknown_83E7860 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E7728, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/electric.c b/src/electric.c index 025eac48b..908ce60a4 100644 --- a/src/electric.c +++ b/src/electric.c @@ -53,7 +53,7 @@ const struct SpriteTemplate gUnknown_83E5F38 = { .tileTag = ANIM_TAG_LIGHTNING, .paletteTag = ANIM_TAG_LIGHTNING, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5F34, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -77,7 +77,7 @@ const struct SpriteTemplate gUnknown_83E5F74 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E5F70, @@ -104,7 +104,7 @@ const struct SpriteTemplate gUnknown_83E5FAC = { .tileTag = ANIM_TAG_SHOCK, .paletteTag = ANIM_TAG_SHOCK, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5FA8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -115,7 +115,7 @@ const struct SpriteTemplate gUnknown_83E5FC4 = { .tileTag = ANIM_TAG_SPARK_2, .paletteTag = ANIM_TAG_SPARK_2, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -126,7 +126,7 @@ const struct SpriteTemplate gUnknown_83E5FDC = { .tileTag = ANIM_TAG_BLACK_BALL_2, .paletteTag = ANIM_TAG_BLACK_BALL_2, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -148,7 +148,7 @@ const struct SpriteTemplate gUnknown_83E6008 = { .tileTag = ANIM_TAG_SPARK_2, .paletteTag = ANIM_TAG_SPARK_2, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6004, @@ -185,7 +185,7 @@ const struct SpriteTemplate gUnknown_83E6058 = { .tileTag = ANIM_TAG_SHOCK_3, .paletteTag = ANIM_TAG_SHOCK_3, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E6030, .images = NULL, .affineAnims = gUnknown_83E6054, @@ -196,7 +196,7 @@ const struct SpriteTemplate gUnknown_83E6070 = { .tileTag = ANIM_TAG_SPARK_2, .paletteTag = ANIM_TAG_SPARK_2, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6004, @@ -207,7 +207,7 @@ const struct SpriteTemplate gElectricitySpriteTemplate = { .tileTag = ANIM_TAG_SPARK_2, .paletteTag = ANIM_TAG_SPARK_2, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -218,7 +218,7 @@ static const struct SpriteTemplate gUnknown_83E60A0 = { .tileTag = ANIM_TAG_SPARK, .paletteTag = ANIM_TAG_SPARK, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -229,7 +229,7 @@ const struct SpriteTemplate gUnknown_83E60B8 = { .tileTag = ANIM_TAG_SPARK_H, .paletteTag = ANIM_TAG_SPARK_H, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -284,7 +284,7 @@ static const struct SpriteTemplate gUnknown_83E6120 = { .tileTag = ANIM_TAG_ELECTRIC_ORBS, .paletteTag = ANIM_TAG_ELECTRIC_ORBS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gUnknown_83E6118, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -332,7 +332,7 @@ const struct SpriteTemplate gUnknown_83E61D4 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E61C8, @@ -357,7 +357,7 @@ const struct SpriteTemplate gUnknown_83E6204 = { .tileTag = ANIM_TAG_ELECTRICITY, .paletteTag = ANIM_TAG_ELECTRICITY, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E6200, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -368,7 +368,7 @@ const struct SpriteTemplate gUnknown_83E621C = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E61C8, @@ -422,7 +422,7 @@ static const struct SpriteTemplate gUnknown_83E6278 = { .tileTag = ANIM_TAG_SPARK, .paletteTag = ANIM_TAG_SPARK, - .oam = &gOamData_83ACAC8, + .oam = &gOamData_AffineDouble_ObjNormal_8x16, .anims = gUnknown_83E6254, .images = NULL, .affineAnims = gUnknown_83E6274, @@ -433,7 +433,7 @@ const struct SpriteTemplate gUnknown_83E6290 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E61C8, @@ -444,7 +444,7 @@ static const struct SpriteTemplate gUnknown_83E62A8 = { .tileTag = ANIM_TAG_SPARK, .paletteTag = ANIM_TAG_SPARK, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/fighting.c b/src/fighting.c index 496f752ef..7b826594d 100644 --- a/src/fighting.c +++ b/src/fighting.c @@ -39,7 +39,7 @@ const struct SpriteTemplate gUnknown_83E668C = { .tileTag = ANIM_TAG_HUMANOID_FOOT, .paletteTag = ANIM_TAG_HUMANOID_FOOT, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -97,7 +97,7 @@ const struct SpriteTemplate gUnknown_83E66E0 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -108,7 +108,7 @@ const struct SpriteTemplate gUnknown_83E66F8 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -119,7 +119,7 @@ const struct SpriteTemplate gFistFootSpriteTemplate = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -130,7 +130,7 @@ const struct SpriteTemplate gUnknown_83E6728 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -141,7 +141,7 @@ const struct SpriteTemplate gUnknown_83E6740 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66D8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -152,7 +152,7 @@ const struct SpriteTemplate gUnknown_83E6758 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66D0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -175,7 +175,7 @@ const struct SpriteTemplate gUnknown_83E678C = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gUnknown_83E6788, @@ -198,7 +198,7 @@ const struct SpriteTemplate gMegaPunchKickSpriteTemplate = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gUnknown_83E67BC, @@ -209,7 +209,7 @@ const struct SpriteTemplate gUnknown_83E67D8 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66D0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -220,7 +220,7 @@ const struct SpriteTemplate gUnknown_83E67F0 = { .tileTag = ANIM_TAG_DUCK, .paletteTag = ANIM_TAG_DUCK, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -231,7 +231,7 @@ const struct SpriteTemplate gUnknown_83E6808 = { .tileTag = ANIM_TAG_BLUE_LIGHT_WALL, .paletteTag = ANIM_TAG_BLUE_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -242,7 +242,7 @@ const struct SpriteTemplate gUnknown_83E6820 = { .tileTag = ANIM_TAG_TORN_METAL, .paletteTag = ANIM_TAG_TORN_METAL, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -267,7 +267,7 @@ const struct SpriteTemplate gUnknown_83E6864 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACBC0, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6860, @@ -278,7 +278,7 @@ const struct SpriteTemplate gUnknown_83E687C = { .tileTag = ANIM_TAG_FLAT_ROCK, .paletteTag = ANIM_TAG_FLAT_ROCK, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -289,7 +289,7 @@ const struct SpriteTemplate gUnknown_83E6894 = { .tileTag = ANIM_TAG_METEOR, .paletteTag = ANIM_TAG_METEOR, - .oam = &gOamData_83AC9E0, + .oam = &gOamData_AffineOff_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -300,7 +300,7 @@ const struct SpriteTemplate gUnknown_83E68AC = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -342,7 +342,7 @@ const struct SpriteTemplate gUnknown_83E6900 = { .tileTag = ANIM_TAG_PURPLE_SCRATCH, .paletteTag = ANIM_TAG_PURPLE_SCRATCH, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E68F4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -381,7 +381,7 @@ const struct SpriteTemplate gUnknown_83E6948 = { .tileTag = ANIM_TAG_PURPLE_SWIPE, .paletteTag = ANIM_TAG_PURPLE_SWIPE, - .oam = &gOamData_83AC9E0, + .oam = &gOamData_AffineOff_ObjNormal_64x64, .anims = gUnknown_83E693C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -404,7 +404,7 @@ const struct SpriteTemplate gUnknown_83E697C = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E66CC, .images = NULL, .affineAnims = gUnknown_83E6978, diff --git a/src/fire.c b/src/fire.c index 014413f5b..a5a2ee5f6 100644 --- a/src/fire.c +++ b/src/fire.c @@ -64,7 +64,7 @@ const struct SpriteTemplate gUnknown_83E5BE0 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5BD8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -75,7 +75,7 @@ const struct SpriteTemplate gUnknown_83E5BF8 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5BD8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -131,7 +131,7 @@ const struct SpriteTemplate gUnknown_83E5C70 = { .tileTag = ANIM_TAG_FIRE, .paletteTag = ANIM_TAG_FIRE, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E5C34, .images = NULL, .affineAnims = gUnknown_83E5C6C, @@ -142,7 +142,7 @@ const struct SpriteTemplate gUnknown_83E5C88 = { .tileTag = ANIM_TAG_FIRE, .paletteTag = ANIM_TAG_FIRE, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5C34, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -153,7 +153,7 @@ const struct SpriteTemplate gUnknown_83E5CA0 = { .tileTag = ANIM_TAG_FIRE_PLUME, .paletteTag = ANIM_TAG_FIRE_PLUME, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5C50, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -164,7 +164,7 @@ const struct SpriteTemplate gUnknown_83E5CB8 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5C50, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -188,7 +188,7 @@ const struct SpriteTemplate gUnknown_83E5CE4 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5CE0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -211,7 +211,7 @@ const struct SpriteTemplate gUnknown_83E5D18 = { .tileTag = ANIM_TAG_SUNLIGHT, .paletteTag = ANIM_TAG_SUNLIGHT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E5D14, @@ -237,7 +237,7 @@ const struct SpriteTemplate gEmberSpriteTemplate = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -248,7 +248,7 @@ const struct SpriteTemplate gEmberFlareSpriteTemplate = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -259,7 +259,7 @@ const struct SpriteTemplate gUnknown_83E5D7C = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -270,7 +270,7 @@ const struct SpriteTemplate gUnknown_83E5D94 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -311,7 +311,7 @@ const struct SpriteTemplate gUnknown_83E5DE4 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5DB8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -322,7 +322,7 @@ const struct SpriteTemplate gUnknown_83E5DFC = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -333,7 +333,7 @@ const struct SpriteTemplate gUnknown_83E5E14 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -344,7 +344,7 @@ static const struct SpriteTemplate gUnknown_83E5E2C = { .tileTag = ANIM_TAG_WARM_ROCK, .paletteTag = ANIM_TAG_WARM_ROCK, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -366,7 +366,7 @@ const struct SpriteTemplate gUnknown_83E5E60 = { .tileTag = ANIM_TAG_WARM_ROCK, .paletteTag = ANIM_TAG_WARM_ROCK, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -412,7 +412,7 @@ const struct SpriteTemplate gUnknown_83E5EB4 = { .tileTag = ANIM_TAG_WISP_ORB, .paletteTag = ANIM_TAG_WISP_ORB, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E5EA4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -437,7 +437,7 @@ const struct SpriteTemplate gUnknown_83E5EE4 = { .tileTag = ANIM_TAG_WISP_FIRE, .paletteTag = ANIM_TAG_WISP_FIRE, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5EE0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/flying.c b/src/flying.c index 59378c2f1..6d4a1eb56 100644 --- a/src/flying.c +++ b/src/flying.c @@ -39,7 +39,7 @@ const struct SpriteTemplate gUnknown_83E6AE8 = { .tileTag = ANIM_TAG_GUST, .paletteTag = ANIM_TAG_GUST, - .oam = &gOamData_83ACA20, + .oam = &gOamData_AffineOff_ObjNormal_32x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -62,7 +62,7 @@ const struct SpriteTemplate gUnknown_83E6B1C = { .tileTag = ANIM_TAG_GUST, .paletteTag = ANIM_TAG_GUST, - .oam = &gOamData_83ACA80, + .oam = &gOamData_AffineNormal_ObjNormal_32x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6B18, @@ -87,7 +87,7 @@ const struct SpriteTemplate gUnknown_83E6B4C = { .tileTag = ANIM_TAG_AIR_WAVE_2, .paletteTag = ANIM_TAG_AIR_WAVE_2, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gUnknown_83E6B48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -130,7 +130,7 @@ const struct SpriteTemplate gUnknown_83E6BB8 = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6B8C, @@ -141,7 +141,7 @@ const struct SpriteTemplate gUnknown_83E6BD0 = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACA40, + .oam = &gOamData_AffineNormal_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6BB0, @@ -170,7 +170,7 @@ const struct SpriteTemplate gUnknown_83E6C00 = { .tileTag = ANIM_TAG_WHITE_FEATHER, .paletteTag = ANIM_TAG_WHITE_FEATHER, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E6BF8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -184,7 +184,7 @@ const struct SpriteTemplate gUnknown_83E6C38 = { .tileTag = ANIM_TAG_SMALL_BUBBLES, .paletteTag = ANIM_TAG_SMALL_BUBBLES, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -195,7 +195,7 @@ const struct SpriteTemplate gUnknown_83E6C50 = { .tileTag = ANIM_TAG_WHITE_FEATHER, .paletteTag = ANIM_TAG_WHITE_FEATHER, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E6BF8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -221,7 +221,7 @@ const struct SpriteTemplate gUnknown_83E6C84 = { .tileTag = ANIM_TAG_WHIRLWIND_LINES, .paletteTag = ANIM_TAG_WHIRLWIND_LINES, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gUnknown_83E6C80, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -247,7 +247,7 @@ const struct SpriteTemplate gUnknown_83E6CD0 = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6CCC, @@ -269,7 +269,7 @@ const struct SpriteTemplate gUnknown_83E6CFC = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6CF8, @@ -294,7 +294,7 @@ const struct SpriteTemplate gUnknown_83E6D40 = { .tileTag = ANIM_TAG_ROUND_SHADOW, .paletteTag = ANIM_TAG_ROUND_SHADOW, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6D3C, @@ -320,7 +320,7 @@ const struct SpriteTemplate gUnknown_83E6D7C = { .tileTag = ANIM_TAG_SPLASH, .paletteTag = ANIM_TAG_SPLASH, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -331,7 +331,7 @@ const struct SpriteTemplate gUnknown_83E6D94 = { .tileTag = ANIM_TAG_SWEAT_BEAD, .paletteTag = ANIM_TAG_SWEAT_BEAD, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -342,7 +342,7 @@ const struct SpriteTemplate gUnknown_83E6DAC = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -353,7 +353,7 @@ const struct SpriteTemplate gUnknown_83E6DB4 = { .tileTag = ANIM_TAG_BIRD, .paletteTag = ANIM_TAG_BIRD, - .oam = &gOamData_83ACAA0, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/ghost.c b/src/ghost.c index 30430309e..643cc3b0d 100644 --- a/src/ghost.c +++ b/src/ghost.c @@ -63,7 +63,7 @@ const struct SpriteTemplate gUnknown_83E75C4 = { .tileTag = ANIM_TAG_YELLOW_BALL, .paletteTag = ANIM_TAG_YELLOW_BALL, - .oam = &gOamData_83ACA90, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E75C0, @@ -74,7 +74,7 @@ const struct SpriteTemplate gUnknown_83E75DC = { .tileTag = ANIM_TAG_YELLOW_BALL, .paletteTag = ANIM_TAG_YELLOW_BALL, - .oam = &gOamData_83ACAF0, + .oam = &gOamData_AffineOff_ObjBlend_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -96,7 +96,7 @@ const struct SpriteTemplate gShadowBallSpriteTemplate = { .tileTag = ANIM_TAG_SHADOW_BALL, .paletteTag = ANIM_TAG_SHADOW_BALL, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7604, @@ -122,7 +122,7 @@ const struct SpriteTemplate gUnknown_83E763C = { .tileTag = ANIM_TAG_LICK, .paletteTag = ANIM_TAG_LICK, - .oam = &gOamData_83ACA18, + .oam = &gOamData_AffineOff_ObjNormal_16x32, .anims = gUnknown_83E7638, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -146,7 +146,7 @@ const struct SpriteTemplate gUnknown_83E7668 = { .tileTag = ANIM_TAG_WHITE_SHADOW, .paletteTag = ANIM_TAG_WHITE_SHADOW, - .oam = &gOamData_83ACB20, + .oam = &gOamData_AffineOff_ObjBlend_64x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -157,7 +157,7 @@ const struct SpriteTemplate gUnknown_83E7680 = { .tileTag = ANIM_TAG_NAIL, .paletteTag = ANIM_TAG_NAIL, - .oam = &gOamData_83ACB18, + .oam = &gOamData_AffineOff_ObjBlend_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -168,7 +168,7 @@ const struct SpriteTemplate gUnknown_83E7698 = { .tileTag = ANIM_TAG_GHOSTLY_SPIRIT, .paletteTag = ANIM_TAG_GHOSTLY_SPIRIT, - .oam = &gOamData_83ACAF8, + .oam = &gOamData_AffineOff_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -179,7 +179,7 @@ const struct SpriteTemplate gUnknown_83E76B0 = { .tileTag = ANIM_TAG_DEVIL, .paletteTag = ANIM_TAG_DEVIL, - .oam = &gOamData_83ACAF8, + .oam = &gOamData_AffineOff_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -204,7 +204,7 @@ const struct SpriteTemplate gUnknown_83E76E0 = { .tileTag = ANIM_TAG_PURPLE_FLAME, .paletteTag = ANIM_TAG_PURPLE_FLAME, - .oam = &gOamData_83ACB38, + .oam = &gOamData_AffineOff_ObjBlend_16x32, .anims = gUnknown_83E76DC, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/ground.c b/src/ground.c index 7ab6b6e95..423671112 100644 --- a/src/ground.c +++ b/src/ground.c @@ -52,7 +52,7 @@ const struct SpriteTemplate gUnknown_83E7A28 = { .tileTag = ANIM_TAG_BONE, .paletteTag = ANIM_TAG_BONE, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7A20, @@ -63,7 +63,7 @@ const struct SpriteTemplate gUnknown_83E7A40 = { .tileTag = ANIM_TAG_BONE, .paletteTag = ANIM_TAG_BONE, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7A24, @@ -74,7 +74,7 @@ const struct SpriteTemplate gUnknown_83E7A58 = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -96,7 +96,7 @@ const struct SpriteTemplate gUnknown_83E7A7C = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E7A78, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -107,7 +107,7 @@ const struct SpriteTemplate gUnknown_83E7A94 = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -118,7 +118,7 @@ const struct SpriteTemplate gUnknown_83E7AAC = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -129,7 +129,7 @@ const struct SpriteTemplate gUnknown_83E7AC4 = { .tileTag = ANIM_TAG_DIRT_MOUND, .paletteTag = ANIM_TAG_DIRT_MOUND, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/ice.c b/src/ice.c index 79966e597..4ed6e0ece 100644 --- a/src/ice.c +++ b/src/ice.c @@ -66,7 +66,7 @@ static const struct SpriteTemplate gUnknown_83E62D0 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -155,7 +155,7 @@ const struct SpriteTemplate gUnknown_83E6348 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACBE8, + .oam = &gOamData_AffineDouble_ObjBlend_8x16, .anims = gUnknown_83E6320, .images = NULL, .affineAnims = gUnknown_83E6344, @@ -166,7 +166,7 @@ const struct SpriteTemplate gUnknown_83E6360 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACAE8, + .oam = &gOamData_AffineOff_ObjBlend_8x8, .anims = gUnknown_83E6324, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -188,7 +188,7 @@ const struct SpriteTemplate gUnknown_83E638C = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACB88, + .oam = &gOamData_AffineNormal_ObjBlend_8x16, .anims = gUnknown_83E6320, .images = NULL, .affineAnims = gUnknown_83E6388, @@ -199,7 +199,7 @@ const struct SpriteTemplate gUnknown_83E63A4 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACAE8, + .oam = &gOamData_AffineOff_ObjBlend_8x8, .anims = gUnknown_83E6324, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -223,7 +223,7 @@ const struct SpriteTemplate gUnknown_83E63E0 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACB88, + .oam = &gOamData_AffineNormal_ObjBlend_8x16, .anims = gUnknown_83E6320, .images = NULL, .affineAnims = gUnknown_83E63DC, @@ -234,7 +234,7 @@ const struct SpriteTemplate gUnknown_83E63F8 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83ACB48, + .oam = &gOamData_AffineNormal_ObjBlend_8x8, .anims = gUnknown_83E6324, .images = NULL, .affineAnims = gUnknown_83E63DC, @@ -245,7 +245,7 @@ const struct SpriteTemplate gUnknown_83E6410 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gUnknown_83E6328, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -256,7 +256,7 @@ const struct SpriteTemplate gUnknown_83E6428 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E632C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -267,7 +267,7 @@ const struct SpriteTemplate gUnknown_83E6440 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gUnknown_83E6328, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -295,7 +295,7 @@ const struct SpriteTemplate gUnknown_83E647C = { .tileTag = ANIM_TAG_ICE_SPIKES, .paletteTag = ANIM_TAG_ICE_SPIKES, - .oam = &gOamData_83ACB28, + .oam = &gOamData_AffineOff_ObjBlend_8x16, .anims = gUnknown_83E6478, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -318,7 +318,7 @@ const struct SpriteTemplate gUnknown_83E64A4 = { .tileTag = ANIM_TAG_MIST_CLOUD, .paletteTag = ANIM_TAG_MIST_CLOUD, - .oam = &gOamData_83ACB18, + .oam = &gOamData_AffineOff_ObjBlend_32x16, .anims = gUnknown_83E64A0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -329,7 +329,7 @@ const struct SpriteTemplate gUnknown_83E64BC = { .tileTag = ANIM_TAG_PURPLE_GAS_CLOUD, .paletteTag = ANIM_TAG_PURPLE_GAS_CLOUD, - .oam = &gOamData_83ACB18, + .oam = &gOamData_AffineOff_ObjBlend_32x16, .anims = gUnknown_83E64A0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -345,7 +345,7 @@ const struct SpriteTemplate gUnknown_83E64E8 = { .tileTag = ANIM_TAG_SMALL_BUBBLES, .paletteTag = ANIM_TAG_SMALL_BUBBLES, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -361,7 +361,7 @@ const struct SpriteTemplate gUnknown_83E6514 = { .tileTag = ANIM_TAG_PURPLE_GAS_CLOUD, .paletteTag = ANIM_TAG_PURPLE_GAS_CLOUD, - .oam = &gOamData_83ACB18, + .oam = &gOamData_AffineOff_ObjBlend_32x16, .anims = gUnknown_83E64A0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -422,7 +422,7 @@ static const struct SpriteTemplate gUnknown_83E65A4 = { .tileTag = ANIM_TAG_HAIL, .paletteTag = ANIM_TAG_HAIL, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6594, @@ -433,7 +433,7 @@ const struct SpriteTemplate gUnknown_83E65BC = { .tileTag = ANIM_TAG_HAIL, .paletteTag = ANIM_TAG_HAIL, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E65A0, @@ -504,7 +504,7 @@ const struct SpriteTemplate gUnknown_83E665C = { .tileTag = ANIM_TAG_ICE_CHUNK, .paletteTag = ANIM_TAG_ICE_CHUNK, - .oam = &gOamData_83ACA98, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gUnknown_83E65F0, .images = NULL, .affineAnims = gUnknown_83E6648, @@ -515,7 +515,7 @@ const struct SpriteTemplate gUnknown_83E6674 = { .tileTag = ANIM_TAG_ICE_CRYSTALS, .paletteTag = ANIM_TAG_ICE_CRYSTALS, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gUnknown_83E6324, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, diff --git a/src/mevent_8145654.c b/src/mevent_8145654.c index 44a40c6ec..a35e9e9f8 100644 --- a/src/mevent_8145654.c +++ b/src/mevent_8145654.c @@ -59,7 +59,7 @@ void sub_8145D18(u8 whichWindow); void sub_8146060(void); void sub_81461D8(void); -extern const struct OamData gOamData_83AC9F8; +extern const struct OamData gOamData_AffineOff_ObjNormal_32x16; const u8 gUnknown_8467068[][3] = { {0, 2, 3}, @@ -114,7 +114,7 @@ const struct SpritePalette gUnknown_8467F60[] = { {gUnknown_8467ED4, 0x8000} }; const struct SpriteTemplate gUnknown_8467FA0 = { - 0x8000, 0x8000, &gOamData_83AC9F8, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy + 0x8000, 0x8000, &gOamData_AffineOff_ObjNormal_32x16, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }; const struct UnkStruct_8467FB8 gUnknown_8467FB8[8] = { {1, 0, 0, 0, gUnknown_846718C, gUnknown_8467288, gUnknown_846708C}, diff --git a/src/normal.c b/src/normal.c index 4d86b55a6..4e045340f 100644 --- a/src/normal.c +++ b/src/normal.c @@ -63,7 +63,7 @@ const struct SpriteTemplate gConfusionDuckSpriteTemplate = { .tileTag = ANIM_TAG_DUCK, .paletteTag = ANIM_TAG_DUCK, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E7B04, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -111,7 +111,7 @@ const struct SpriteTemplate gUnknown_83E7B70 = { .tileTag = ANIM_TAG_SPARKLE_4, .paletteTag = ANIM_TAG_SPARKLE_4, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E7B6C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -168,7 +168,7 @@ const struct SpriteTemplate gBasicHitSplatSpriteTemplate = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -179,7 +179,7 @@ const struct SpriteTemplate gUnknown_83E7C20 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -190,7 +190,7 @@ const struct SpriteTemplate gUnknown_83E7C38 = { .tileTag = ANIM_TAG_WATER_IMPACT, .paletteTag = ANIM_TAG_WATER_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -201,7 +201,7 @@ const struct SpriteTemplate gUnknown_83E7C50 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -212,7 +212,7 @@ const struct SpriteTemplate gUnknown_83E7C68 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -223,7 +223,7 @@ const struct SpriteTemplate gUnknown_83E7C80 = { .tileTag = ANIM_TAG_CROSS_IMPACT, .paletteTag = ANIM_TAG_CROSS_IMPACT, - .oam = &gOamData_83ACAF8, + .oam = &gOamData_AffineOff_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -234,7 +234,7 @@ const struct SpriteTemplate gUnknown_83E7C98 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, @@ -245,7 +245,7 @@ const struct SpriteTemplate gUnknown_83E7CB0 = { .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, - .oam = &gOamData_83ACB58, + .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7BF8, diff --git a/src/oak_speech.c b/src/oak_speech.c index 3f946e13f..79f8b18c7 100644 --- a/src/oak_speech.c +++ b/src/oak_speech.c @@ -328,12 +328,12 @@ static const union AnimCmd *const sGrassPlatformAnims3[] = { sGrassPlatformAnim3 }; -extern const struct OamData gOamData_83ACAF8; +extern const struct OamData gOamData_AffineOff_ObjBlend_32x32; static const struct SpriteTemplate sOakSpeech_GrassPlatformSpriteTemplates[3] = { - { 0x1000, 0x1000, &gOamData_83ACAF8, sGrassPlatformAnims1, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, - { 0x1000, 0x1000, &gOamData_83ACAF8, sGrassPlatformAnims2, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, - { 0x1000, 0x1000, &gOamData_83ACAF8, sGrassPlatformAnims3, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1000, 0x1000, &gOamData_AffineOff_ObjBlend_32x32, sGrassPlatformAnims1, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1000, 0x1000, &gOamData_AffineOff_ObjBlend_32x32, sGrassPlatformAnims2, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1000, 0x1000, &gOamData_AffineOff_ObjBlend_32x32, sGrassPlatformAnims3, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, }; static const union AnimCmd sPikaAnim1[] = { @@ -389,14 +389,14 @@ static const union AnimCmd *const sPikaAnims3[] = { sPikaAnim3 }; -extern const struct OamData gOamData_83AC9D8; -extern const struct OamData gOamData_83AC9F8; -extern const struct OamData gOamData_83AC9E8; +extern const struct OamData gOamData_AffineOff_ObjNormal_32x32; +extern const struct OamData gOamData_AffineOff_ObjNormal_32x16; +extern const struct OamData gOamData_AffineOff_ObjNormal_16x8; static const struct SpriteTemplate sOakSpeech_PikaSpriteTemplates[3] = { - { 0x1001, 0x1001, &gOamData_83AC9D8, sPikaAnims1, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, - { 0x1002, 0x1001, &gOamData_83AC9F8, sPikaAnims2, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, - { 0x1003, 0x1001, &gOamData_83AC9E8, sPikaAnims3, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy } + { 0x1001, 0x1001, &gOamData_AffineOff_ObjNormal_32x32, sPikaAnims1, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1002, 0x1001, &gOamData_AffineOff_ObjNormal_32x16, sPikaAnims2, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy }, + { 0x1003, 0x1001, &gOamData_AffineOff_ObjNormal_16x8, sPikaAnims3, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy } }; static const u8 *const sHelpDocsPtrs[] = { diff --git a/src/poison.c b/src/poison.c index 7a0788c29..af7f8ee86 100644 --- a/src/poison.c +++ b/src/poison.c @@ -30,7 +30,7 @@ const struct SpriteTemplate gUnknown_83E69AC = { .tileTag = ANIM_TAG_TOXIC_BUBBLE, .paletteTag = ANIM_TAG_TOXIC_BUBBLE, - .oam = &gOamData_83ACA18, + .oam = &gOamData_AffineOff_ObjNormal_16x32, .anims = gUnknown_83E69A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -98,7 +98,7 @@ const struct SpriteTemplate gUnknown_83E6A20 = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA90, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gUnknown_83E69DC, .images = NULL, .affineAnims = gUnknown_83E6A18, @@ -109,7 +109,7 @@ const struct SpriteTemplate gUnknown_83E6A38 = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA90, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gUnknown_83E69DC, .images = NULL, .affineAnims = gUnknown_83E6A18, @@ -120,7 +120,7 @@ const struct SpriteTemplate gUnknown_83E6A50 = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gUnknown_83E69E4, .images = NULL, .affineAnims = gUnknown_83E6A1C, @@ -143,7 +143,7 @@ const struct SpriteTemplate gUnknown_83E6A84 = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA90, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gUnknown_83E69E0, .images = NULL, .affineAnims = gUnknown_83E6A80, @@ -166,7 +166,7 @@ const struct SpriteTemplate gPoisonBubbleSpriteTemplate = { .tileTag = ANIM_TAG_POISON_BUBBLE, .paletteTag = ANIM_TAG_POISON_BUBBLE, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gUnknown_83E69DC, .images = NULL, .affineAnims = gUnknown_83E6AB4, @@ -177,7 +177,7 @@ const struct SpriteTemplate gWaterBubbleSpriteTemplate = { .tileTag = ANIM_TAG_SMALL_BUBBLES, .paletteTag = ANIM_TAG_SMALL_BUBBLES, - .oam = &gOamData_83ACB50, + .oam = &gOamData_AffineNormal_ObjBlend_16x16, .anims = gUnknown_83E5A78, .images = NULL, .affineAnims = gUnknown_83E6AB4, diff --git a/src/psychic.c b/src/psychic.c index bbb6c3ed5..722ea014f 100644 --- a/src/psychic.c +++ b/src/psychic.c @@ -43,7 +43,7 @@ const struct SpriteTemplate gUnknown_83E6DF8 = { .tileTag = ANIM_TAG_SPIRAL, .paletteTag = ANIM_TAG_SPIRAL, - .oam = &gOamData_83ACB60, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E6DF4, @@ -54,7 +54,7 @@ const struct SpriteTemplate gUnknown_83E6E10 = { .tileTag = ANIM_TAG_GREEN_LIGHT_WALL, .paletteTag = ANIM_TAG_GREEN_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -65,7 +65,7 @@ const struct SpriteTemplate gUnknown_83E6E28 = { .tileTag = ANIM_TAG_BLUE_LIGHT_WALL, .paletteTag = ANIM_TAG_BLUE_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -76,7 +76,7 @@ const struct SpriteTemplate gUnknown_83E6E40 = { .tileTag = ANIM_TAG_RED_LIGHT_WALL, .paletteTag = ANIM_TAG_RED_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -87,7 +87,7 @@ const struct SpriteTemplate gUnknown_83E6E58 = { .tileTag = ANIM_TAG_GRAY_LIGHT_WALL, .paletteTag = ANIM_TAG_GRAY_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -98,7 +98,7 @@ const struct SpriteTemplate gUnknown_83E6E70 = { .tileTag = ANIM_TAG_ORANGE_LIGHT_WALL, .paletteTag = ANIM_TAG_ORANGE_LIGHT_WALL, - .oam = &gOamData_83ACB00, + .oam = &gOamData_AffineOff_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -124,7 +124,7 @@ const struct SpriteTemplate gUnknown_83E6EA4 = { .tileTag = ANIM_TAG_SPARKLE_4, .paletteTag = ANIM_TAG_SPARKLE_4, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E6EA0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -149,7 +149,7 @@ const struct SpriteTemplate gUnknown_83E6ED4 = { .tileTag = ANIM_TAG_SPARKLE_3, .paletteTag = ANIM_TAG_SPARKLE_3, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gUnknown_83E6ED0, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -160,7 +160,7 @@ const struct SpriteTemplate gUnknown_83E6EEC = { .tileTag = ANIM_TAG_GOLD_RING, .paletteTag = ANIM_TAG_GOLD_RING, - .oam = &gOamData_83ACA18, + .oam = &gOamData_AffineOff_ObjNormal_16x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -217,7 +217,7 @@ const struct SpriteTemplate gUnknown_83E6F8C = { .tileTag = ANIM_TAG_BENT_SPOON, .paletteTag = ANIM_TAG_BENT_SPOON, - .oam = &gOamData_83ACA18, + .oam = &gOamData_AffineOff_ObjNormal_16x32, .anims = gUnknown_83E6F84, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -259,7 +259,7 @@ const struct SpriteTemplate gUnknown_83E6FF4 = { .tileTag = ANIM_TAG_AMNESIA, .paletteTag = ANIM_TAG_AMNESIA, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E6FC4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -285,7 +285,7 @@ static const struct SpriteTemplate gUnknown_83E7044 = { .tileTag = ANIM_TAG_HOLLOW_ORB, .paletteTag = ANIM_TAG_HOLLOW_ORB, - .oam = &gOamData_83ACAF0, + .oam = &gOamData_AffineOff_ObjBlend_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -296,7 +296,7 @@ const struct SpriteTemplate gUnknown_83E705C = { .tileTag = 0x280A, .paletteTag = 0x280A, - .oam = &gOamData_83AC9E0, + .oam = &gOamData_AffineOff_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -349,7 +349,7 @@ static const struct SpriteTemplate gUnknown_83E7114 = { .tileTag = ANIM_TAG_BLUEGREEN_ORB, .paletteTag = ANIM_TAG_BLUEGREEN_ORB, - .oam = &gOamData_83ACA30, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7104, @@ -372,7 +372,7 @@ const struct SpriteTemplate gUnknown_83E7148 = { .tileTag = ANIM_TAG_WHITE_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_WHITE_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACBC0, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E7144, @@ -410,7 +410,7 @@ const struct SpriteTemplate gUnknown_83E71D0 = { .tileTag = ANIM_TAG_CIRCLE_OF_LIGHT, .paletteTag = ANIM_TAG_CIRCLE_OF_LIGHT, - .oam = &gOamData_83ACBC0, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gUnknown_83E71C8, diff --git a/src/rock.c b/src/rock.c index c4b668941..b0809fade 100644 --- a/src/rock.c +++ b/src/rock.c @@ -55,7 +55,7 @@ const struct SpriteTemplate gUnknown_83E73B4 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E73A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -66,7 +66,7 @@ const struct SpriteTemplate gUnknown_83E73CC = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E73A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -77,7 +77,7 @@ const struct SpriteTemplate gUnknown_83E73E4 = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -101,7 +101,7 @@ const struct SpriteTemplate gUnknown_83E7420 = { .tileTag = ANIM_TAG_WATER_ORB, .paletteTag = ANIM_TAG_WATER_ORB, - .oam = &gOamData_83ACB50, + .oam = &gOamData_AffineNormal_ObjBlend_16x16, .anims = gUnknown_83E5958, .images = NULL, .affineAnims = gUnknown_83E741C, @@ -112,7 +112,7 @@ const struct SpriteTemplate gUnknown_83E7438 = { .tileTag = ANIM_TAG_SMALL_EMBER, .paletteTag = ANIM_TAG_SMALL_EMBER, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E5D48, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -123,7 +123,7 @@ const struct SpriteTemplate gUnknown_83E7450 = { .tileTag = ANIM_TAG_FLYING_DIRT, .paletteTag = ANIM_TAG_FLYING_DIRT, - .oam = &gOamData_83AC9F8, + .oam = &gOamData_AffineOff_ObjNormal_32x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -213,7 +213,7 @@ const struct SpriteTemplate gUnknown_83E74C0 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E74A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -224,7 +224,7 @@ const struct SpriteTemplate gUnknown_83E74D8 = { .tileTag = ANIM_TAG_MUD_SAND, .paletteTag = ANIM_TAG_MUD_SAND, - .oam = &gOamData_83AC9C8, + .oam = &gOamData_AffineOff_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -235,7 +235,7 @@ const struct SpriteTemplate gUnknown_83E74F0 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -246,7 +246,7 @@ const struct SpriteTemplate gUnknown_83E7508 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E74A8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, @@ -275,7 +275,7 @@ const struct SpriteTemplate gUnknown_83E7548 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E74A8, .images = NULL, .affineAnims = gUnknown_83E7540, @@ -286,7 +286,7 @@ const struct SpriteTemplate gUnknown_83E7560 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E74A8, .images = NULL, .affineAnims = gUnknown_83E7540, @@ -297,7 +297,7 @@ const struct SpriteTemplate gUnknown_83E7578 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83AC9D8, + .oam = &gOamData_AffineOff_ObjNormal_32x32, .anims = gUnknown_83E74B8, .images = NULL, .affineAnims = gUnknown_83E7540, @@ -308,7 +308,7 @@ const struct SpriteTemplate gUnknown_83E7590 = { .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, - .oam = &gOamData_83ACA38, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gUnknown_83E74B0, .images = NULL, .affineAnims = gUnknown_83E7540, diff --git a/src/text.c b/src/text.c index b61713ee2..93a35a07d 100644 --- a/src/text.c +++ b/src/text.c @@ -15,7 +15,7 @@ #include "constants/songs.h" extern u8 gGlyphInfo[0x90]; -extern const struct OamData gOamData_83AC9D0; +extern const struct OamData gOamData_AffineOff_ObjNormal_16x16; static void DecompressGlyphFont3(u16 glyphId, bool32 isJapanese); static void DecompressGlyphFont4(u16 glyphId, bool32 isJapanese); @@ -59,7 +59,7 @@ const struct SpriteTemplate gUnknown_81EA6B4 = { .tileTag = 0x8000, .paletteTag = 0x8000, - .oam = &gOamData_83AC9D0, + .oam = &gOamData_AffineOff_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, -- cgit v1.2.3 From aa8d5fb55768ab1b4e7cd423bd097756a65adb3e Mon Sep 17 00:00:00 2001 From: Evan Date: Mon, 2 Dec 2019 12:32:56 -0700 Subject: b_anim_eff_3 --- src/battle_anim_effects_1.c | 463 ++-- src/battle_anim_effects_2.c | 3818 ++++++++++++++++++++++++++++++ src/battle_anim_effects_3.c | 5495 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 9560 insertions(+), 216 deletions(-) create mode 100644 src/battle_anim_effects_2.c create mode 100644 src/battle_anim_effects_3.c (limited to 'src') diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index a02125d6d..9d820b628 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -16,8 +16,10 @@ #include "constants/rgb.h" #include "constants/songs.h" -EWRAM_DATA s16 gUnknown_0203A0F8[4] = {0}; +// RAM +EWRAM_DATA s16 gUnknown_203999C[4] = {0}; +// Function Declarations void AnimMovePowderParticle(struct Sprite *); void AnimPowerAbsorptionOrb(struct Sprite *); void AnimSolarbeamBigOrb(struct Sprite *); @@ -150,6 +152,8 @@ static void AnimFollowMeFingerStep2(struct Sprite *); static void AnimTauntFingerStep1(struct Sprite *); static void AnimTauntFingerStep2(struct Sprite *); +static const u8 gUnknown_83E2964[] = {0x02, 0x04, 0x01, 0x03}; + const union AnimCmd gPowderParticlesAnimCmds[] = //gUnknown_83E2968 { ANIMCMD_FRAME(0, 5), @@ -406,25 +410,25 @@ const struct SpriteTemplate gLeechSeedSpriteTemplate = //gUnknown_83E2B34 .callback = AnimLeechSeed, }; -const union AnimCmd gSporeParticleAnimCmds1[] = +const union AnimCmd gSporeParticleAnimCmds1[] = //gUnknown_83E2B4C { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gSporeParticleAnimCmds2[] = +const union AnimCmd gSporeParticleAnimCmds2[] = //gUnknown_83E2B54 { ANIMCMD_FRAME(4, 7), ANIMCMD_END, }; -const union AnimCmd *const gSporeParticleAnimTable[] = +const union AnimCmd *const gSporeParticleAnimTable[] = //gUnknown_83E2B5C { gSporeParticleAnimCmds1, gSporeParticleAnimCmds2, }; -const struct SpriteTemplate gSporeParticleSpriteTemplate = +const struct SpriteTemplate gSporeParticleSpriteTemplate = //gUnknown_83E2B64 { .tileTag = ANIM_TAG_SPORE, .paletteTag = ANIM_TAG_SPORE, @@ -435,29 +439,29 @@ const struct SpriteTemplate gSporeParticleSpriteTemplate = .callback = AnimSporeParticle, }; -const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = +const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = //gUnknown_83E2B7C { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = +const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = //gUnknown_83E2B84 { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = +const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = //gUnknown_83E2B8C { gPetalDanceBigFlowerAnimCmds, }; -const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = +const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = //gUnknown_83E2B90 { gPetalDanceSmallFlowerAnimCmds, }; -const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = +const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = //gUnknown_83E2B94 { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -468,7 +472,7 @@ const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = .callback = AnimPetalDanceBigFlower, }; -const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = +const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = //gUnknown_83E2BAC { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -479,7 +483,7 @@ const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = .callback = AnimPetalDanceSmallFlower, }; -const union AnimCmd gRazorLeafParticleAnimCmds1[] = +const union AnimCmd gRazorLeafParticleAnimCmds1[] = //gUnknown_83E2BC4 { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 5), @@ -494,7 +498,7 @@ const union AnimCmd gRazorLeafParticleAnimCmds1[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gRazorLeafParticleAnimCmds2[] = +const union AnimCmd gRazorLeafParticleAnimCmds2[] = //gUnknown_83E2BF0 { ANIMCMD_FRAME(24, 5), ANIMCMD_FRAME(28, 5), @@ -502,13 +506,13 @@ const union AnimCmd gRazorLeafParticleAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gRazorLeafParticleAnimTable[] = +const union AnimCmd *const gRazorLeafParticleAnimTable[] = //gUnknown_83E2C00 { gRazorLeafParticleAnimCmds1, gRazorLeafParticleAnimCmds2, }; -const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = +const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = //gUnknown_83E2C08 { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -519,7 +523,7 @@ const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = .callback = AnimRazorLeafParticle, }; -const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = +const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = //gUnknown_83E2C20 { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -530,7 +534,7 @@ const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = .callback = AnimMoveTwisterParticle, }; -const union AnimCmd gRazorLeafCutterAnimCmds[] = +const union AnimCmd gRazorLeafCutterAnimCmds[] = //gUnknown_83E2C38 { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(0, 3, .hFlip = TRUE), @@ -539,12 +543,12 @@ const union AnimCmd gRazorLeafCutterAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRazorLeafCutterAnimTable[] = +const union AnimCmd *const gRazorLeafCutterAnimTable[] = //gUnknown_83E2C4C { gRazorLeafCutterAnimCmds, }; -const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = +const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = //gUnknown_83E2C50 { .tileTag = ANIM_TAG_RAZOR_LEAF, .paletteTag = ANIM_TAG_RAZOR_LEAF, @@ -555,16 +559,18 @@ const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = .callback = AnimTranslateLinearSingleSineWave, }; -const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = { +const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = //gUnknown_83E2C68 +{ AFFINEANIMCMD_FRAME(0, 0, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = { +const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = //gUnknown_83E2C78 +{ gSwiftStarAffineAnimCmds, }; -const struct SpriteTemplate gSwiftStarSpriteTemplate = +const struct SpriteTemplate gSwiftStarSpriteTemplate = //gUnknown_83E2C7C { .tileTag = ANIM_TAG_YELLOW_STAR, .paletteTag = ANIM_TAG_YELLOW_STAR, @@ -575,7 +581,7 @@ const struct SpriteTemplate gSwiftStarSpriteTemplate = .callback = AnimTranslateLinearSingleSineWave, }; -const union AnimCmd gConstrictBindingAnimCmds1[] = +const union AnimCmd gConstrictBindingAnimCmds1[] = //gUnknown_83E2C94 { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(32, 4), @@ -584,7 +590,7 @@ const union AnimCmd gConstrictBindingAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gConstrictBindingAnimCmds2[] = +const union AnimCmd gConstrictBindingAnimCmds2[] = //gUnknown_83E2CA8 { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(32, 4, .hFlip = TRUE), @@ -593,32 +599,35 @@ const union AnimCmd gConstrictBindingAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gConstrictBindingAnimTable[] = +const union AnimCmd *const gConstrictBindingAnimTable[] = //gUnknown_83E2CBC { gConstrictBindingAnimCmds1, gConstrictBindingAnimCmds2, }; -const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = { +const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = //gUnknown_83E2CC4 +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(-11, 0, 0, 6), AFFINEANIMCMD_FRAME(11, 0, 0, 6), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = { +const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = //gUnknown_83E2CE4 +{ AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(11, 0, 0, 6), AFFINEANIMCMD_FRAME(-11, 0, 0, 6), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = { +const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = //gUnknown_83E2D04 +{ gConstrictBindingAffineAnimCmds1, gConstrictBindingAffineAnimCmds2, }; -const struct SpriteTemplate gConstrictBindingSpriteTemplate = +const struct SpriteTemplate gConstrictBindingSpriteTemplate = //gUnknown_83E2D0C { .tileTag = ANIM_TAG_TENDRILS, .paletteTag = ANIM_TAG_TENDRILS, @@ -629,23 +638,26 @@ const struct SpriteTemplate gConstrictBindingSpriteTemplate = .callback = AnimConstrictBinding, }; -const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = { +const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = //gUnknown_83E2D24 +{ AFFINEANIMCMD_FRAME(0, 0, 0, 0), AFFINEANIMCMD_FRAME(48, 48, 0, 14), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = { +const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = //gUnknown_83E2D3C +{ AFFINEANIMCMD_FRAME(-16, -16, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = { +const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = //gUnknown_83E2D4C +{ gMimicOrbAffineAnimCmds1, gMimicOrbAffineAnimCmds2, }; -const struct SpriteTemplate gMimicOrbSpriteTemplate = +const struct SpriteTemplate gMimicOrbSpriteTemplate = //gUnknown_83E2D54 { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -656,7 +668,7 @@ const struct SpriteTemplate gMimicOrbSpriteTemplate = .callback = AnimMimicOrb, }; -const union AnimCmd gIngrainRootAnimCmds1[] = +const union AnimCmd gIngrainRootAnimCmds1[] = //gUnknown_83E2D6C { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -665,7 +677,7 @@ const union AnimCmd gIngrainRootAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds2[] = +const union AnimCmd gIngrainRootAnimCmds2[] = //gUnknown_83E2D80 { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -674,7 +686,7 @@ const union AnimCmd gIngrainRootAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds3[] = +const union AnimCmd gIngrainRootAnimCmds3[] = //gUnknown_83E2D94 { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -682,7 +694,7 @@ const union AnimCmd gIngrainRootAnimCmds3[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds4[] = +const union AnimCmd gIngrainRootAnimCmds4[] = //gUnknown_83E2DA4 { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -690,7 +702,7 @@ const union AnimCmd gIngrainRootAnimCmds4[] = ANIMCMD_END, }; -const union AnimCmd *const gIngrainRootAnimTable[] = +const union AnimCmd *const gIngrainRootAnimTable[] = //gUnknown_83E2DB4 { gIngrainRootAnimCmds1, gIngrainRootAnimCmds2, @@ -698,7 +710,7 @@ const union AnimCmd *const gIngrainRootAnimTable[] = gIngrainRootAnimCmds4, }; -const struct SpriteTemplate gIngrainRootSpriteTemplate = +const struct SpriteTemplate gIngrainRootSpriteTemplate = //gUnknown_83E2DC4 { .tileTag = ANIM_TAG_ROOTS, .paletteTag = ANIM_TAG_ROOTS, @@ -709,7 +721,7 @@ const struct SpriteTemplate gIngrainRootSpriteTemplate = .callback = AnimIngrainRoot, }; -const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = +const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = //gUnknown_83E2DDC { .tileTag = ANIM_TAG_ROOTS, .paletteTag = ANIM_TAG_ROOTS, @@ -720,19 +732,19 @@ const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = .callback = AnimFrenzyPlantRoot, }; -const union AnimCmd gIngrainOrbAnimCmds[] = +const union AnimCmd gIngrainOrbAnimCmds[] = //gUnknown_83E2DF4 { ANIMCMD_FRAME(3, 3), ANIMCMD_FRAME(0, 5), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gIngrainOrbAnimTable[] = +const union AnimCmd *const gIngrainOrbAnimTable[] = //gUnknown_83E2E00 { gIngrainOrbAnimCmds, }; -const struct SpriteTemplate gIngrainOrbSpriteTemplate = +const struct SpriteTemplate gIngrainOrbSpriteTemplate = //gUnknown_83E2E04 { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -743,25 +755,27 @@ const struct SpriteTemplate gIngrainOrbSpriteTemplate = .callback = AnimIngrainOrb, }; -const union AnimCmd gFallingBagAnimCmds[] = +const union AnimCmd gFallingBagAnimCmds[] = //gUnknown_83E2E1C { ANIMCMD_FRAME(0, 30), ANIMCMD_END, }; -const union AnimCmd *const gFallingBagAnimTable[] = +const union AnimCmd *const gFallingBagAnimTable[] = //gUnknown_83E2E24 { gFallingBagAnimCmds, }; -const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = { +const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = //gUnknown_83E2E28 +{ AFFINEANIMCMD_FRAME(0, 0, -4, 10), AFFINEANIMCMD_FRAME(0, 0, 4, 20), AFFINEANIMCMD_FRAME(0, 0, -4, 10), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = { +const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = //gUnknown_83E2E48 +{ AFFINEANIMCMD_FRAME(0, 0, -1, 2), AFFINEANIMCMD_FRAME(0, 0, 1, 4), AFFINEANIMCMD_FRAME(0, 0, -1, 4), @@ -771,12 +785,13 @@ const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = { AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = { +const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = //gUnknown_83E2E80 +{ gFallingBagAffineAnimCmds1, gFallingBagAffineAnimCmds2, }; -const struct SpriteTemplate gPresentSpriteTemplate = +const struct SpriteTemplate gPresentSpriteTemplate = //gUnknown_83E2E88 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -787,7 +802,7 @@ const struct SpriteTemplate gPresentSpriteTemplate = .callback = AnimPresent, }; -const struct SpriteTemplate gKnockOffItemSpriteTemplate = +const struct SpriteTemplate gKnockOffItemSpriteTemplate = //gUnknown_83E2EA0 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -798,7 +813,7 @@ const struct SpriteTemplate gKnockOffItemSpriteTemplate = .callback = AnimKnockOffItem, }; -const union AnimCmd gPresentHealParticleAnimCmds[] = +const union AnimCmd gPresentHealParticleAnimCmds[] = //gUnknown_83E2EB8 { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 4), @@ -807,12 +822,12 @@ const union AnimCmd gPresentHealParticleAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gPresentHealParticleAnimTable[] = +const union AnimCmd *const gPresentHealParticleAnimTable[] = //gUnknown_83E2ECC { gPresentHealParticleAnimCmds, }; -const struct SpriteTemplate gPresentHealParticleSpriteTemplate = +const struct SpriteTemplate gPresentHealParticleSpriteTemplate = //gUnknown_83E2ED0 { .tileTag = ANIM_TAG_GREEN_SPARKLE, .paletteTag = ANIM_TAG_GREEN_SPARKLE, @@ -823,7 +838,7 @@ const struct SpriteTemplate gPresentHealParticleSpriteTemplate = .callback = AnimPresentHealParticle, }; -const struct SpriteTemplate gItemStealSpriteTemplate = +const struct SpriteTemplate gItemStealSpriteTemplate = //gUnknown_83E2EE8 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -834,12 +849,14 @@ const struct SpriteTemplate gItemStealSpriteTemplate = .callback = AnimItemSteal, }; -const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = { +const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = //gUnknown_83E2F00 +{ AFFINEANIMCMD_FRAME(0, 0, 0, 3), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = { +const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = //gUnknown_83E2F10 +{ AFFINEANIMCMD_FRAME(0, -10, 0, 3), AFFINEANIMCMD_FRAME(0, -6, 0, 3), AFFINEANIMCMD_FRAME(0, -2, 0, 3), @@ -850,14 +867,15 @@ const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = { AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = { +const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = //gUnknown_83E2F50 +{ gTrickBagAffineAnimCmds1, gTrickBagAffineAnimCmds2, gFallingBagAffineAnimCmds1, gFallingBagAffineAnimCmds2, }; -const struct SpriteTemplate gTrickBagSpriteTemplate = +const struct SpriteTemplate gTrickBagSpriteTemplate = //gUnknown_83E2F60 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -868,7 +886,7 @@ const struct SpriteTemplate gTrickBagSpriteTemplate = .callback = AnimTrickBag, }; -const s8 gTrickBagCoordinates[][3] = +const s8 gTrickBagCoordinates[][3] = //gUnknown_83E2F78 { {5, 24, 1}, {0, 4, 0}, @@ -883,49 +901,49 @@ const s8 gTrickBagCoordinates[][3] = {0, 0, 127}, }; -const union AnimCmd gLeafBladeAnimCmds1[] = +const union AnimCmd gLeafBladeAnimCmds1[] = //gUnknown_83E2F9C { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds2[] = +const union AnimCmd gLeafBladeAnimCmds2[] = //gUnknown_83E2FA4 { ANIMCMD_FRAME(32, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds3[] = +const union AnimCmd gLeafBladeAnimCmds3[] = //gUnknown_83E2FAC { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds4[] = +const union AnimCmd gLeafBladeAnimCmds4[] = //gUnknown_83E2FB4 { ANIMCMD_FRAME(28, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds5[] = +const union AnimCmd gLeafBladeAnimCmds5[] = //gUnknown_83E2FBC { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds6[] = +const union AnimCmd gLeafBladeAnimCmds6[] = //gUnknown_83E2FC4 { ANIMCMD_FRAME(16, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds7[] = +const union AnimCmd gLeafBladeAnimCmds7[] = //gUnknown_83E2FCC { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -const union AnimCmd *const gLeafBladeAnimTable[] = +const union AnimCmd *const gLeafBladeAnimTable[] = //gUnknown_83E2FD4 { gLeafBladeAnimCmds1, gLeafBladeAnimCmds2, @@ -936,7 +954,7 @@ const union AnimCmd *const gLeafBladeAnimTable[] = gLeafBladeAnimCmds7, }; -const struct SpriteTemplate gLeafBladeSpriteTemplate = +const struct SpriteTemplate gLeafBladeSpriteTemplate = //gUnknown_83E2FF0 { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -947,17 +965,19 @@ const struct SpriteTemplate gLeafBladeSpriteTemplate = .callback = SpriteCallbackDummy, }; -const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = { +const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = //gUnknown_83E3008 +{ AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = { +const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = //gUnknown_83E3020 +{ gAromatherapyBigFlowerAffineAnimCmds, }; -const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = +const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = //gUnknown_83E3024 { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -968,7 +988,7 @@ const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = +const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = //gUnknown_83E303C { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -979,37 +999,43 @@ const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = .callback = AnimFlyingParticle, }; -const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = { +const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = //gUnknown_83E3054 +{ AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -10, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = { +const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = //gUnknown_83E306C +{ AFFINEANIMCMD_FRAME(192, 192, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -12, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = { +const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = //gUnknown_83E3084 +{ AFFINEANIMCMD_FRAME(143, 143, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -15, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = { +const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = //gUnknown_83E309C +{ gSilverWindBigSparkAffineAnimCmds, }; -const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = { +const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = //gUnknown_83E30A0 +{ gSilverWindMediumSparkAffineAnimCmds, }; -const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = { +const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = //gUnknown_83E30A4 +{ gSilverWindSmallSparkAffineAnimCmds, }; -const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = +const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = //gUnknown_83E30A8 { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1020,7 +1046,7 @@ const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = +const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = //gUnknown_83E30C0 { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1031,7 +1057,7 @@ const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = +const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = //gUnknown_83E30D8 { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1042,7 +1068,7 @@ const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = .callback = AnimFlyingParticle, }; -const u16 gMagicalLeafBlendColors[] = +const u16 gMagicalLeafBlendColors[] = //gUnknown_83E30F0 { RGB(31, 0, 0), RGB(31, 19, 0), @@ -1053,7 +1079,7 @@ const u16 gMagicalLeafBlendColors[] = RGB(22, 21, 31), }; -const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = +const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = //gUnknown_83E3100 { .tileTag = ANIM_TAG_GREEN_SPIKE, .paletteTag = ANIM_TAG_GREEN_SPIKE, @@ -1064,7 +1090,7 @@ const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = .callback = AnimNeedleArmSpike, }; -const union AnimCmd gWhipAnimCmds1[] = +const union AnimCmd gWhipAnimCmds1[] = //gUnknown_83E3118 { ANIMCMD_FRAME(64, 3), ANIMCMD_FRAME(80, 3), @@ -1073,7 +1099,7 @@ const union AnimCmd gWhipAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gWhipAnimCmds2[] = +const union AnimCmd gWhipAnimCmds2[] = //gUnknown_83E312C { ANIMCMD_FRAME(64, 3, .hFlip = TRUE), ANIMCMD_FRAME(80, 3, .hFlip = TRUE), @@ -1082,13 +1108,13 @@ const union AnimCmd gWhipAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gWhipAnimTable[] = +const union AnimCmd *const gWhipAnimTable[] = //gUnknown_83E3140 { gWhipAnimCmds1, gWhipAnimCmds2, }; -const struct SpriteTemplate gSlamHitSpriteTemplate = +const struct SpriteTemplate gSlamHitSpriteTemplate = //gUnknown_83E3148 { .tileTag = ANIM_TAG_SLAM_HIT, .paletteTag = ANIM_TAG_SLAM_HIT, @@ -1099,7 +1125,7 @@ const struct SpriteTemplate gSlamHitSpriteTemplate = .callback = AnimWhipHit, }; -const struct SpriteTemplate gVineWhipSpriteTemplate = +const struct SpriteTemplate gVineWhipSpriteTemplate = //gUnknown_83E3160 { .tileTag = ANIM_TAG_WHIP_HIT, .paletteTag = ANIM_TAG_WHIP_HIT, @@ -1110,7 +1136,7 @@ const struct SpriteTemplate gVineWhipSpriteTemplate = .callback = AnimWhipHit, }; -const union AnimCmd gUnknown_08592900[] = +const union AnimCmd gUnknown_83E3178[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1120,99 +1146,105 @@ const union AnimCmd gUnknown_08592900[] = ANIMCMD_END, }; -const union AnimCmd *const gUnknown_08592918[] = +const union AnimCmd *const gUnknown_83E3190[] = { - gUnknown_08592900, + gUnknown_83E3178, }; -// Unused -const struct SpriteTemplate gUnknown_0859291C = +const struct SpriteTemplate gUnknown_83E3194 = // Unused { .tileTag = ANIM_TAG_HIT, .paletteTag = ANIM_TAG_HIT, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gUnknown_08592918, + .anims = gUnknown_83E3190, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A43F8, }; -// Unused -const struct SpriteTemplate gUnknown_08592934 = +const struct SpriteTemplate gUnknown_83E31AC = // Unused { .tileTag = ANIM_TAG_HIT_2, .paletteTag = ANIM_TAG_HIT_2, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gUnknown_08592918, + .anims = gUnknown_83E3190, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A43F8, }; -const union AffineAnimCmd gUnknown_0859294C[] = { +const union AffineAnimCmd gUnknown_83E31C4[] = +{ AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859295C[] = { +const union AffineAnimCmd gUnknown_83E31D4[] = +{ AFFINEANIMCMD_FRAME(256, 256, 32, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859296C[] = { +const union AffineAnimCmd gUnknown_83E31E4[] = +{ AFFINEANIMCMD_FRAME(256, 256, 64, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859297C[] = { +const union AffineAnimCmd gUnknown_83E31F4[] = +{ AFFINEANIMCMD_FRAME(256, 256, 96, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859298C[] = { +const union AffineAnimCmd gUnknown_83E3204[] = +{ AFFINEANIMCMD_FRAME(256, 256, -128, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_0859299C[] = { +const union AffineAnimCmd gUnknown_83E3214[] = +{ AFFINEANIMCMD_FRAME(256, 256, -96, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_085929AC[] = { +const union AffineAnimCmd gUnknown_83E3224[] = +{ AFFINEANIMCMD_FRAME(256, 256, -64, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_085929BC[] = { +const union AffineAnimCmd gUnknown_83E3234[] = +{ AFFINEANIMCMD_FRAME(256, 256, -32, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gUnknown_085929CC[] = { - gUnknown_0859294C, - gUnknown_0859295C, - gUnknown_0859296C, - gUnknown_0859297C, - gUnknown_0859298C, - gUnknown_0859299C, - gUnknown_085929AC, - gUnknown_085929BC, +const union AffineAnimCmd *const gUnknown_83E3244[] = +{ + gUnknown_83E31C4, + gUnknown_83E31D4, + gUnknown_83E31E4, + gUnknown_83E31F4, + gUnknown_83E3204, + gUnknown_83E3214, + gUnknown_83E3224, + gUnknown_83E3234, }; -// Unused -const struct SpriteTemplate gUnknown_085929EC = +const struct SpriteTemplate gUnknown_83E3264 = // Unused { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gUnknown_085929CC, + .affineAnims = gUnknown_83E3244, .callback = sub_80A4494, }; -const union AnimCmd gCuttingSliceAnimCmds[] = +const union AnimCmd gCuttingSliceAnimCmds[] = //gUnknown_83E327C { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(16, 5), @@ -1221,12 +1253,12 @@ const union AnimCmd gCuttingSliceAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gCuttingSliceAnimTable[] = +const union AnimCmd *const gCuttingSliceAnimTable[] = //gUnknown_83E3290 { gCuttingSliceAnimCmds, }; -const struct SpriteTemplate gCuttingSliceSpriteTemplate = +const struct SpriteTemplate gCuttingSliceSpriteTemplate = //gUnknown_83E3294 { .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, @@ -1237,7 +1269,7 @@ const struct SpriteTemplate gCuttingSliceSpriteTemplate = .callback = AnimCuttingSlice, }; -const struct SpriteTemplate gAirCutterSliceSpriteTemplate = +const struct SpriteTemplate gAirCutterSliceSpriteTemplate = //gUnknown_83E32AC { .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, @@ -1248,93 +1280,92 @@ const struct SpriteTemplate gAirCutterSliceSpriteTemplate = .callback = AnimAirCutterSlice, }; -const union AnimCmd gUnknown_08592A4C[] = +const union AnimCmd gUnknown_83E32C4[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A54[] = +const union AnimCmd gUnknown_83E32CC[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A5C[] = +const union AnimCmd gUnknown_83E32D4[] = { ANIMCMD_FRAME(8, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A64[] = +const union AnimCmd gUnknown_83E32DC[] = { ANIMCMD_FRAME(12, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A6C[] = +const union AnimCmd gUnknown_83E32E4[] = { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A74[] = +const union AnimCmd gUnknown_83E32EC[] = { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A7C[] = +const union AnimCmd gUnknown_83E32F4[] = { ANIMCMD_FRAME(0, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A84[] = +const union AnimCmd gUnknown_83E32FC[] = { ANIMCMD_FRAME(4, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A8C[] = +const union AnimCmd gUnknown_83E3304[] = { ANIMCMD_FRAME(8, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_08592A94[] = +const union AnimCmd gUnknown_83E330C[] = { ANIMCMD_FRAME(12, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd *const gUnknown_08592A9C[] = +const union AnimCmd *const gUnknown_83E3314[] = { - gUnknown_08592A4C, - gUnknown_08592A54, - gUnknown_08592A5C, - gUnknown_08592A64, - gUnknown_08592A6C, - gUnknown_08592A74, - gUnknown_08592A7C, - gUnknown_08592A84, - gUnknown_08592A8C, - gUnknown_08592A94, + gUnknown_83E32C4, + gUnknown_83E32CC, + gUnknown_83E32D4, + gUnknown_83E32DC, + gUnknown_83E32E4, + gUnknown_83E32EC, + gUnknown_83E32F4, + gUnknown_83E32FC, + gUnknown_83E3304, + gUnknown_83E330C, }; -// Unused -const struct SpriteTemplate gUnknown_08592AC4 = +const struct SpriteTemplate gUnknown_83E333C = // Unused { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gUnknown_08592A9C, + .anims = gUnknown_83E3314, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A481C, }; -const struct SpriteTemplate gUnknown_08592ADC = +const struct SpriteTemplate gProtectWallSpriteTemplate = //gUnknown_83E3354 { .tileTag = ANIM_TAG_PROTECT, .paletteTag = ANIM_TAG_PROTECT, @@ -1345,13 +1376,13 @@ const struct SpriteTemplate gUnknown_08592ADC = .callback = AnimProtect, }; -const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = +const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = //gUnknown_83E336C { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = +const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] =//gUnknown_83E337C { AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), @@ -1361,13 +1392,13 @@ const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] = +const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] =//gUnknown_83E33AC { gMilkBottleAffineAnimCmds1, gMilkBottleAffineAnimCmds2, }; -const struct SpriteTemplate gMilkBottleSpriteTemplate = +const struct SpriteTemplate gMilkBottleSpriteTemplate =//gUnknown_83E33B4 { .tileTag = ANIM_TAG_MILK_BOTTLE, .paletteTag = ANIM_TAG_MILK_BOTTLE, @@ -1378,7 +1409,7 @@ const struct SpriteTemplate gMilkBottleSpriteTemplate = .callback = AnimMilkBottle, }; -const union AnimCmd gGrantingStarsAnimCmds[] = +const union AnimCmd gGrantingStarsAnimCmds[] =//gUnknown_83E33CC { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -1391,12 +1422,12 @@ const union AnimCmd gGrantingStarsAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gGrantingStarsAnimTable[] = +const union AnimCmd *const gGrantingStarsAnimTable[] =//gUnknown_83E33F0 { gGrantingStarsAnimCmds, }; -const struct SpriteTemplate gGrantingStarsSpriteTemplate = +const struct SpriteTemplate gGrantingStarsSpriteTemplate = //gUnknown_83E33F4 { .tileTag = ANIM_TAG_SPARKLE_2, .paletteTag = ANIM_TAG_SPARKLE_2, @@ -1407,7 +1438,7 @@ const struct SpriteTemplate gGrantingStarsSpriteTemplate = .callback = AnimGrantingStars, }; -const struct SpriteTemplate gSparklingStarsSpriteTemplate = +const struct SpriteTemplate gSparklingStarsSpriteTemplate = //gUnknown_83E340C { .tileTag = ANIM_TAG_SPARKLE_2, .paletteTag = ANIM_TAG_SPARKLE_2, @@ -1418,7 +1449,7 @@ const struct SpriteTemplate gSparklingStarsSpriteTemplate = .callback = AnimSparkingStars, }; -const union AnimCmd gUnknown_08592BAC[] = +const union AnimCmd gUnknown_83E3424[] = { ANIMCMD_FRAME(0, 10), ANIMCMD_FRAME(4, 10), @@ -1431,7 +1462,7 @@ const union AnimCmd gUnknown_08592BAC[] = ANIMCMD_END, }; -const union AnimCmd gUnknown_08592BD0[] = +const union AnimCmd gUnknown_83E3448[] = { ANIMCMD_FRAME(0, 10, .hFlip = TRUE), ANIMCMD_FRAME(4, 10, .hFlip = TRUE), @@ -1444,31 +1475,30 @@ const union AnimCmd gUnknown_08592BD0[] = ANIMCMD_END, }; -const union AnimCmd *const gUnknown_08592BF4[] = +const union AnimCmd *const gUnknown_83E346C[] = { - gUnknown_08592BAC, - gUnknown_08592BD0, + gUnknown_83E3424, + gUnknown_83E3448, }; -// Unused -const struct SpriteTemplate gUnknown_08592BFC = +const struct SpriteTemplate gUnknown_83E3474 = // Unused { .tileTag = ANIM_TAG_BUBBLE_BURST, .paletteTag = ANIM_TAG_BUBBLE_BURST, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gUnknown_08592BF4, + .anims = gUnknown_83E346C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A4E40, }; -const union AnimCmd gSleepLetterZAnimCmds[] = +const union AnimCmd gSleepLetterZAnimCmds[] =//gUnknown_83E348C { ANIMCMD_FRAME(0, 40), ANIMCMD_END, }; -const union AnimCmd *const gSleepLetterZAnimTable[] = +const union AnimCmd *const gSleepLetterZAnimTable[] =//gUnknown_83E3494 { gSleepLetterZAnimCmds, }; @@ -1501,13 +1531,13 @@ const union AffineAnimCmd gSleepLetterZAffineAnimCmds2_2[] = AFFINEANIMCMD_LOOP(10), }; -const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] = +const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] =//gUnknown_83E34F8 { gSleepLetterZAffineAnimCmds1, gSleepLetterZAffineAnimCmds2, }; -const struct SpriteTemplate gSleepLetterZSpriteTemplate = +const struct SpriteTemplate gSleepLetterZSpriteTemplate = //gUnknown_83E3500 { .tileTag = ANIM_TAG_LETTER_Z, .paletteTag = ANIM_TAG_LETTER_Z, @@ -1518,7 +1548,7 @@ const struct SpriteTemplate gSleepLetterZSpriteTemplate = .callback = AnimSleepLetterZ, }; -const struct SpriteTemplate gLockOnTargetSpriteTemplate = +const struct SpriteTemplate gLockOnTargetSpriteTemplate = //gUnknown_83E3518 { .tileTag = ANIM_TAG_LOCK_ON, .paletteTag = ANIM_TAG_LOCK_ON, @@ -1529,7 +1559,7 @@ const struct SpriteTemplate gLockOnTargetSpriteTemplate = .callback = AnimLockOnTarget, }; -const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = +const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = //gUnknown_83E3530 { .tileTag = ANIM_TAG_LOCK_ON, .paletteTag = ANIM_TAG_LOCK_ON, @@ -1548,7 +1578,7 @@ const s8 gInclineMonCoordTable[][2] = { 32, -32}, }; -const struct SpriteTemplate gBowMonSpriteTemplate = +const struct SpriteTemplate gBowMonSpriteTemplate = //gUnknown_83E3550 { .tileTag = 0, .paletteTag = 0, @@ -1559,8 +1589,7 @@ const struct SpriteTemplate gBowMonSpriteTemplate = .callback = AnimBowMon, }; -// Unused -const struct SpriteTemplate gUnknown_08592CF0 = +const struct SpriteTemplate gUnknown_83E3568 = // Unused { .tileTag = 0, .paletteTag = 0, @@ -1571,7 +1600,7 @@ const struct SpriteTemplate gUnknown_08592CF0 = .callback = sub_80A5590, }; -const union AnimCmd gSlashSliceAnimCmds1[] = +const union AnimCmd gSlashSliceAnimCmds1[] = //gUnknown_83E3580 { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1592,7 +1621,7 @@ const union AnimCmd *const gSlashSliceAnimTable[] = gSlashSliceAnimCmds2, }; -const struct SpriteTemplate gSlashSliceSpriteTemplate = +const struct SpriteTemplate gSlashSliceSpriteTemplate = //gUnknown_83E35A4 { .tileTag = ANIM_TAG_SLASH, .paletteTag = ANIM_TAG_SLASH, @@ -1603,7 +1632,7 @@ const struct SpriteTemplate gSlashSliceSpriteTemplate = .callback = AnimSlashSlice, }; -const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = +const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = //gUnknown_83E35BC { .tileTag = ANIM_TAG_SLASH_2, .paletteTag = ANIM_TAG_SLASH_2, @@ -1614,7 +1643,7 @@ const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = .callback = AnimFalseSwipeSlice, }; -const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = +const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = //gUnknown_83E35D4 { .tileTag = ANIM_TAG_SLASH_2, .paletteTag = ANIM_TAG_SLASH_2, @@ -1639,7 +1668,7 @@ const union AnimCmd *const gEndureEnergyAnimTable[] = gEndureEnergyAnimCmds, }; -const struct SpriteTemplate gEndureEnergySpriteTemplate = +const struct SpriteTemplate gEndureEnergySpriteTemplate = //gUnknown_83E3604 { .tileTag = ANIM_TAG_FOCUS_ENERGY, .paletteTag = ANIM_TAG_FOCUS_ENERGY, @@ -1674,7 +1703,7 @@ const union AnimCmd *const gSharpenSphereAnimTable[] = gSharpenSphereAnimCmds, }; -const struct SpriteTemplate gSharpenSphereSpriteTemplate = +const struct SpriteTemplate gSharpenSphereSpriteTemplate = //gUnknown_83E365C { .tileTag = ANIM_TAG_SPHERE_TO_CUBE, .paletteTag = ANIM_TAG_SPHERE_TO_CUBE, @@ -1685,7 +1714,7 @@ const struct SpriteTemplate gSharpenSphereSpriteTemplate = .callback = AnimSharpenSphere, }; -const struct SpriteTemplate gOctazookaBallSpriteTemplate = +const struct SpriteTemplate gOctazookaBallSpriteTemplate = //gUnknown_83E3674 { .tileTag = ANIM_TAG_BLACK_BALL, .paletteTag = ANIM_TAG_BLACK_BALL, @@ -1711,7 +1740,7 @@ const union AnimCmd *const gOctazookaAnimTable[] = gOctazookaAnimCmds, }; -const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = +const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = //gUnknown_83E36A8 { .tileTag = ANIM_TAG_GRAY_SMOKE, .paletteTag = ANIM_TAG_GRAY_SMOKE, @@ -1747,7 +1776,7 @@ const union AffineAnimCmd *const gConversionAffineAnimTable[] = gConversionAffineAnimCmds, }; -const struct SpriteTemplate gConversionSpriteTemplate = +const struct SpriteTemplate gConversionSpriteTemplate = //gUnknown_83E36EC { .tileTag = ANIM_TAG_CONVERSION, .paletteTag = ANIM_TAG_CONVERSION, @@ -1772,7 +1801,7 @@ const union AnimCmd *const gConversion2AnimTable[] = gConversion2AnimCmds, }; -const struct SpriteTemplate gConversion2SpriteTemplate = +const struct SpriteTemplate gConversion2SpriteTemplate = //gUnknown_83E371C { .tileTag = ANIM_TAG_CONVERSION, .paletteTag = ANIM_TAG_CONVERSION, @@ -1783,7 +1812,7 @@ const struct SpriteTemplate gConversion2SpriteTemplate = .callback = AnimConversion2, }; -const struct SpriteTemplate gMoonSpriteTemplate = +const struct SpriteTemplate gMoonSpriteTemplate = //gUnknown_83E3734 { .tileTag = ANIM_TAG_MOON, .paletteTag = ANIM_TAG_MOON, @@ -1808,7 +1837,7 @@ const union AnimCmd *const gMoonlightSparkleAnimTable[] = gMoonlightSparkleAnimCmds, }; -const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = +const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = //gUnknown_83E3764 { .tileTag = ANIM_TAG_GREEN_SPARKLE, .paletteTag = ANIM_TAG_GREEN_SPARKLE, @@ -1837,7 +1866,7 @@ const union AnimCmd *const gHealingBlueStarAnimTable[] = gHealingBlueStarAnimCmds, }; -const struct SpriteTemplate gHealingBlueStarSpriteTemplate = +const struct SpriteTemplate gHealingBlueStarSpriteTemplate = //gUnknown_83E37A4 { .tileTag = ANIM_TAG_BLUE_STAR, .paletteTag = ANIM_TAG_BLUE_STAR, @@ -1848,7 +1877,7 @@ const struct SpriteTemplate gHealingBlueStarSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gHornHitSpriteTemplate = +const struct SpriteTemplate gHornHitSpriteTemplate = //gUnknown_83E37BC { .tileTag = ANIM_TAG_HORN_HIT, .paletteTag = ANIM_TAG_HORN_HIT, @@ -1873,7 +1902,7 @@ const union AnimCmd *const gSuperFangAnimTable[] = gSuperFangAnimCmds, }; -const struct SpriteTemplate gSuperFangSpriteTemplate = +const struct SpriteTemplate gSuperFangSpriteTemplate = //gUnknown_83E37EC { .tileTag = ANIM_TAG_FANG_ATTACK, .paletteTag = ANIM_TAG_FANG_ATTACK, @@ -1932,7 +1961,7 @@ const union AnimCmd gWavyMusicNotesAnimCmds8[] = ANIMCMD_END, }; -const union AnimCmd *const gMusicNotesAnimTable[] = +const union AnimCmd *const gMusicNotesAnimTable[] = //gUnknown_83E3844 { gWavyMusicNotesAnimCmds1, gWavyMusicNotesAnimCmds2, @@ -1944,19 +1973,19 @@ const union AnimCmd *const gMusicNotesAnimTable[] = gWavyMusicNotesAnimCmds8, }; -const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = +const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = //gUnknown_83E3864 { AFFINEANIMCMD_FRAME(0xC, 0xC, 0, 16), AFFINEANIMCMD_FRAME(0xFFF4, 0xFFF4, 0, 16), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = +const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = //gUnknown_83E387C { gWavyMusicNotesAffineAnimCmds, }; -const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = +const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = //gUnknown_83E3880 { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -1967,7 +1996,7 @@ const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = .callback = AnimWavyMusicNotes, }; -const u16 gParticlesColorBlendTable[][6] = +const u16 gParticlesColorBlendTable[][6] = //gUnknown_83E3898 { {ANIM_TAG_MUSIC_NOTES, RGB(31, 31, 31), RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, {ANIM_TAG_BENT_SPOON, RGB(31, 31, 31), RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, @@ -1975,7 +2004,7 @@ const u16 gParticlesColorBlendTable[][6] = {ANIM_TAG_LARGE_FRESH_EGG, RGB(31, 31, 31), RGB(26, 28, 31), RGB(21, 26, 31), RGB(16, 24, 31), RGB(12, 22, 31)}, }; -const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = +const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = //gUnknown_83E38C8 { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -1986,7 +2015,7 @@ const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = .callback = AnimFlyingMusicNotes, }; -const struct SpriteTemplate gBellyDrumHandSpriteTemplate = +const struct SpriteTemplate gBellyDrumHandSpriteTemplate = // gUnknown_83E38E0 { .tileTag = ANIM_TAG_PURPLE_HAND_OUTLINE, .paletteTag = ANIM_TAG_PURPLE_HAND_OUTLINE, @@ -2009,7 +2038,7 @@ const union AffineAnimCmd *const gSlowFlyingMusicNotesAffineAnimTable[] = gSlowFlyingMusicNotesAffineAnimCmds, }; -const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = +const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = //gUnknown_83E3914 { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -2064,7 +2093,7 @@ const union AnimCmd *const gMetronomeThroughtBubbleAnimTable[] = gMetronomeThroughtBubbleAnimCmds4, }; -const struct SpriteTemplate gThoughtBubbleSpriteTemplate = +const struct SpriteTemplate gThoughtBubbleSpriteTemplate = //gUnknown_83E398C { .tileTag = ANIM_TAG_THOUGHT_BUBBLE, .paletteTag = ANIM_TAG_THOUGHT_BUBBLE, @@ -2110,7 +2139,7 @@ const union AffineAnimCmd *const gMetronomeFingerAffineAnimTable[] = gMetronomeFingerAffineAnimCmds2, }; -const struct SpriteTemplate gMetronomeFingerSpriteTemplate = +const struct SpriteTemplate gMetronomeFingerSpriteTemplate = //gUnknown_83E3A34 { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -2121,7 +2150,7 @@ const struct SpriteTemplate gMetronomeFingerSpriteTemplate = .callback = AnimMetronomeFinger, }; -const struct SpriteTemplate gFollowMeFingerSpriteTemplate = +const struct SpriteTemplate gFollowMeFingerSpriteTemplate = //gUnknown_83E3A4C { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -2176,7 +2205,7 @@ const union AnimCmd *const gTauntFingerAnimTable[] = gTauntFingerAnimCmds4, }; -const struct SpriteTemplate gTauntFingerSpriteTemplate = +const struct SpriteTemplate gTauntFingerSpriteTemplate = //gUnknown_83E3AC4 { .tileTag = ANIM_TAG_FINGER_2, .paletteTag = ANIM_TAG_FINGER_2, @@ -2797,7 +2826,8 @@ static void AnimConstrictBindingStep2(struct Sprite* sprite) } } -void sub_80FF458(u8 taskId) +// Unused +void sub_80A2F0C(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); if (gSprites[spriteId].invisible) @@ -2927,6 +2957,7 @@ void AnimIngrainRoot(struct Sprite* sprite) // arg 3: sprite subpriority offset // arg 4: sprite anum num // arg 5: duration +//sub_80A31EC void AnimFrenzyPlantRoot(struct Sprite *sprite) { s16 attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); @@ -2944,10 +2975,10 @@ void AnimFrenzyPlantRoot(struct Sprite *sprite) StartSpriteAnim(sprite, gBattleAnimArgs[4]); sprite->data[2] = gBattleAnimArgs[5]; sprite->callback = AnimRootFlickerOut; - gUnknown_0203A0F8[0] = sprite->pos1.x; - gUnknown_0203A0F8[1] = sprite->pos1.y; - gUnknown_0203A0F8[2] = targetX; - gUnknown_0203A0F8[3] = targetY; + gUnknown_203999C[0] = sprite->pos1.x; + gUnknown_203999C[1] = sprite->pos1.y; + gUnknown_203999C[2] = targetX; + gUnknown_203999C[3] = targetY; } static void AnimRootFlickerOut(struct Sprite* sprite) @@ -2983,7 +3014,7 @@ void AnimIngrainOrb(struct Sprite* sprite) DestroyAnimSprite(sprite); } -static void sub_80FF9B8(struct Sprite* sprite, s16 c) +static void sub_80A33B8(struct Sprite* sprite, s16 c) { int a = (sprite->pos1.x << 8) | sprite->pos1.y; int b = (sprite->data[6] << 8) | sprite->data[7]; @@ -2993,7 +3024,7 @@ static void sub_80FF9B8(struct Sprite* sprite, s16 c) sprite->data[7] = c; } -bool8 moveAlongLinearPath(struct Sprite* sprite) +bool8 MoveAlongLinearPath(struct Sprite* sprite) { u16 xStartPos = (u8)(sprite->data[5] >> 8); u16 yStartPos = (u8)sprite->data[5]; @@ -3044,7 +3075,7 @@ static void AnimItemStealStep1(struct Sprite* sprite) } sprite->pos2.y = Sin(sprite->data[0] + 128, 30 - sprite->data[1] * 8); - if (moveAlongLinearPath(sprite)) + if (MoveAlongLinearPath(sprite)) { sprite->pos2.y = 0; sprite->data[0] = 0; @@ -3063,14 +3094,14 @@ void AnimPresent(struct Sprite* sprite) { sprite->data[6] = targetX; sprite->data[7] = targetY + 10; - sub_80FF9B8(sprite, 60); + sub_80A33B8(sprite, 60); sprite->data[3] = 1; } else { sprite->data[6] = targetX; sprite->data[7] = targetY + 10; - sub_80FF9B8(sprite, 60); + sub_80A33B8(sprite, 60); sprite->data[3] = 3; } @@ -3078,7 +3109,7 @@ void AnimPresent(struct Sprite* sprite) sprite->callback = AnimItemStealStep1; } -static void sub_80FFB90(struct Sprite* sprite) +static void sub_80A3590(struct Sprite* sprite) { int zero; sprite->data[0] += ((sprite->data[3] * 128) / sprite->data[4]); @@ -3090,7 +3121,7 @@ static void sub_80FFB90(struct Sprite* sprite) } sprite->pos2.y = Sin(sprite->data[0] + 0x80, 30 - sprite->data[1] * 8); - if (moveAlongLinearPath(sprite)) + if (MoveAlongLinearPath(sprite)) { sprite->pos2.y = zero; sprite->data[0] = zero; @@ -3105,7 +3136,7 @@ void AnimKnockOffItem(struct Sprite* sprite) { sprite->data[6] = 0; sprite->data[7] = targetY + 10; - sub_80FF9B8(sprite, 40); + sub_80A33B8(sprite, 40); sprite->data[3] = 3; sprite->data[4] = 60; sprite->callback = AnimItemStealStep1; @@ -3117,10 +3148,10 @@ void AnimKnockOffItem(struct Sprite* sprite) if (IsContest()) sprite->data[6] = 0; - sub_80FF9B8(sprite, 40); + sub_80A33B8(sprite, 40); sprite->data[3] = 3; sprite->data[4] = 60; - sprite->callback = sub_80FFB90; + sprite->callback = sub_80A3590; } } @@ -3154,14 +3185,14 @@ void AnimItemSteal(struct Sprite* sprite) { sprite->data[6] = attackerX; sprite->data[7] = attackerY + 10; - sub_80FF9B8(sprite, 60); + sub_80A33B8(sprite, 60); sprite->data[3] = 1; } else { sprite->data[6] = attackerX; sprite->data[7] = attackerY + 10; - sub_80FF9B8(sprite, 60); + sub_80A33B8(sprite, 60); sprite->data[3] = 3; } @@ -3184,7 +3215,7 @@ static void AnimItemStealStep3(struct Sprite* sprite) if (sprite->pos2.y == 0) PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(63)); - if (moveAlongLinearPath(sprite)) + if (MoveAlongLinearPath(sprite)) { sprite->pos2.y = 0; sprite->data[0] = 0; diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c new file mode 100644 index 000000000..32ed2fba9 --- /dev/null +++ b/src/battle_anim_effects_2.c @@ -0,0 +1,3818 @@ +#include "global.h" +#include "malloc.h" +#include "battle_anim.h" +#include "battle_interface.h" +#include "decompress.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "main.h" +#include "math_util.h" +#include "palette.h" +#include "random.h" +#include "scanline_effect.h" +#include "sound.h" +#include "trig.h" +#include "util.h" +#include "constants/rgb.h" +#include "constants/songs.h" + +void sub_80A6E48(struct Sprite *); +void sub_80A6E98(struct Sprite *); +void sub_80A6F8C(struct Sprite *); +void sub_80A7020(struct Sprite *); +void Anim_KinesisZapEnergy(struct Sprite *); +void Anim_SwordsDanceBlade(struct Sprite *); +void AnimSonicBoomProjectile(struct Sprite *); +void AnimAirWaveProjectile(struct Sprite *); +void sub_80A79E8(struct Sprite *); +void AnimCoinThrow(struct Sprite *); +void AnimFallingCoin(struct Sprite *); +void AnimBulletSeed(struct Sprite *); +void AnimRazorWindTornado(struct Sprite *); +void AnimViceGripPincer(struct Sprite *); +void AnimGuillotinePincer(struct Sprite *); +void AnimBreathPuff(struct Sprite *); +void AnimAngerMark(struct Sprite *); +void AnimPencil(struct Sprite *); +void AnimBlendThinRing(struct Sprite *); +void AnimHyperVoiceRing(struct Sprite *); +void AnimUproarRing(struct Sprite *); +void AnimSoftBoiledEgg(struct Sprite *); +void AnimSpeedDust(struct Sprite *); +void AnimHealBellMusicNote(struct Sprite *); +void AnimMagentaHeart(struct Sprite *); +void AnimRedHeartProjectile(struct Sprite *); +void AnimParticuleBurst(struct Sprite *); +void AnimRedHeartRising(struct Sprite *); +void AnimOrbitFast(struct Sprite *); +void AnimOrbitScatter(struct Sprite *); +void AnimSpitUpOrb(struct Sprite *); +void AnimEyeSparkle(struct Sprite *); +void AnimAngel(struct Sprite *); +void AnimPinkHeart(struct Sprite *); +void AnimDevil(struct Sprite *); +void AnimFurySwipes(struct Sprite *); +void AnimMovmentWaves(struct Sprite *); +void AnimJaggedMusicNote(struct Sprite *); +void AnimPerishSongMusicNote2(struct Sprite *); +void AnimPerishSongMusicNote(struct Sprite *); +void AnimGuardRing(struct Sprite *); +static void sub_80A6ED8(struct Sprite *); +static void sub_80A7058(struct Sprite *); +static void sub_80A7080(struct Sprite *); +static void AnimTask_WithdrawStep(u8); +static void AnimSwordsDanceBladeStep(struct Sprite *); +static void sub_80A7A18(struct Sprite *); +static void AnimFallingCoin_Step(struct Sprite *); +static void AnimBulletSeed_Step1(struct Sprite *); +static void AnimBulletSeed_Step2(struct Sprite *); +static void AnimViceGripPincerStep(struct Sprite *); +static void AnimGuillotinePincerStep1(struct Sprite *); +static void AnimGuillotinePincerStep2(struct Sprite *); +static void AnimGuillotinePincerStep3(struct Sprite *); +static void AnimTask_GrowAndGreyscaleStep(u8); +static void AnimTask_MinimizeStep1(u8); +static void CreateMinimizeSprite(struct Task *, u8); +static void ClonedMinizeSprite_Step(struct Sprite *); +static void AnimTask_SplashStep(u8); +static void AnimTask_GrowAndShrinkStep(u8); +static void ThrashMoveMonStep(u8); +static void ThrashMoveMon(u8); +static void AnimTask_SketchDrawMon(u8); +static void AnimPencil_Step(struct Sprite *); +static void AnimSoftBoiledEgg_Step1(struct Sprite *); +static void AnimSoftBoiledEgg_Step2(struct Sprite *); +static void AnimSoftBoiledEgg_Step3(struct Sprite *); +static void AnimSoftBoiledEgg_Step3_Callback1(struct Sprite *); +static void AnimSoftBoiledEgg_Step3_Callback2(struct Sprite *); +static void AnimSoftBoiledEgg_Step4(struct Sprite *); +static void AnimSoftBoiledEgg_Step4_Callback(struct Sprite *); +static void StretchAttacker_Step(u8); +static void ExtremeSpeedImpact_Step(u8); +static void ExtremeSpeedMonReappear_Step(u8); +static void SpeedDust_Step1(u8); +static void FakeOutStep1(u8); +static void FakeOutStep2(u8); +static void AnimRedHeartProjectile_Step(struct Sprite *); +static void AnimRedHeartRising_Step(struct Sprite *); +static void HeartsBackground_Step(u8); +static void ScaryFace_Step(u8); +static void AnimOrbitFastStep(struct Sprite *); +static void AnimOrbitScatterStep(struct Sprite *); +static void AnimMovmentWaves_Step(struct Sprite *); +static void UproarDistortion_Step(u8); +static void AnimJaggedMusicNote_Step(struct Sprite *); +static void AnimPerishSongMusicNote_Step1(struct Sprite *); +static void AnimPerishSongMusicNote_Step2(struct Sprite *); + +// Data +const struct SpriteTemplate gUnknown_83E3ADC = // Unused +{ + .tileTag = ANIM_TAG_FINGER, + .paletteTag = ANIM_TAG_FINGER, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A6E48, +}; + +const union AnimCmd gUnknown_83E3AF4[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83E3AFC[] = +{ + gUnknown_83E3AF4, +}; + +const struct SpriteTemplate gUnknown_83E3B00 = // Unused +{ + .tileTag = ANIM_TAG_MUSIC_NOTES, + .paletteTag = ANIM_TAG_MUSIC_NOTES, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A6E98, +}; + +const struct SpriteTemplate gUnknown_83E3B18 = // Unused +{ + .tileTag = 0, + .paletteTag = 0, + .oam = &gDummyOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A6F8C, +}; + +extern const union AffineAnimCmd *const gUnknown_83E7910[]; +const struct SpriteTemplate gUnknown_83E3B30 = // Unused +{ + .tileTag = ANIM_TAG_CLAMP, + .paletteTag = ANIM_TAG_CLAMP, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gUnknown_83E7910, + .callback = sub_80A7020, +}; + +const union AnimCmd gUnknown_83E3B48[] = +{ + ANIMCMD_FRAME(0, 9), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83E3B5C[] = +{ + gUnknown_83E3B48, +}; + +const union AffineAnimCmd gUnknown_83E3B60[] = +{ + AFFINEANIMCMD_FRAME(0x50, 0x50, 0, 0), + AFFINEANIMCMD_FRAME(0x9, 0x9, 0, 18), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gUnknown_83E3B78[] = +{ + gUnknown_83E3B60, +}; + +const struct SpriteTemplate gUnknown_83E3B7C = // Unused +{ + .tileTag = ANIM_TAG_EXPLOSION_6, + .paletteTag = ANIM_TAG_EXPLOSION_6, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gUnknown_83E3B5C, + .images = NULL, + .affineAnims = gUnknown_83E3B78, + .callback = AnimSpriteOnMonPos, +}; + +const union AnimCmd gKinesisZapEnergyAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3, .hFlip = TRUE), + ANIMCMD_FRAME(8, 3, .hFlip = TRUE), + ANIMCMD_FRAME(16, 3, .hFlip = TRUE), + ANIMCMD_FRAME(24, 3, .hFlip = TRUE), + ANIMCMD_FRAME(32, 3, .hFlip = TRUE), + ANIMCMD_FRAME(40, 3, .hFlip = TRUE), + ANIMCMD_FRAME(48, 3, .hFlip = TRUE), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd *const gKinesisZapEnergyAnimTable[] = +{ + gKinesisZapEnergyAnimCmds, +}; + +const struct SpriteTemplate gKinesisZapEnergySpriteTemplate = //gUnknown_83E3BBC +{ + .tileTag = ANIM_TAG_ALERT, + .paletteTag = ANIM_TAG_ALERT, + .oam = &gOamData_AffineOff_ObjNormal_32x16, + .anims = gKinesisZapEnergyAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = Anim_KinesisZapEnergy, +}; + +const union AffineAnimCmd gSwordsDanceBladeAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x14, 0x0, 0, 12), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gSwordsDanceBladeAffineAnimTable[] = +{ + gSwordsDanceBladeAffineAnimCmds, +}; + +const struct SpriteTemplate gSwordsDanceBladeSpriteTemplate = //gUnknown_83E3BF8 +{ + .tileTag = ANIM_TAG_SWORD, + .paletteTag = ANIM_TAG_SWORD, + .oam = &gOamData_AffineNormal_ObjBlend_32x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSwordsDanceBladeAffineAnimTable, + .callback = Anim_SwordsDanceBlade, +}; + +const struct SpriteTemplate gSonicBoomSpriteTemplate = //gUnknown_83E3C10 +{ + .tileTag = ANIM_TAG_AIR_WAVE, + .paletteTag = ANIM_TAG_AIR_WAVE, + .oam = &gOamData_AffineDouble_ObjBlend_32x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSonicBoomProjectile, +}; + +const struct SpriteTemplate gAirWaveProjectileSpriteTemplate = //gUnknown_83E3C28 +{ + .tileTag = ANIM_TAG_AIR_WAVE, + .paletteTag = ANIM_TAG_AIR_WAVE, + .oam = &gOamData_AffineOff_ObjBlend_32x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimAirWaveProjectile, +}; + +const union AffineAnimCmd gGrowingRingAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 0), + AFFINEANIMCMD_FRAME(0x7, 0x7, 0, -56), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x5, 0x5, 0, 10), + AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = +{ + gGrowingRingAffineAnimCmds, +}; + +const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = +{ + gWaterPulseRingAffineAnimCmds, +}; + +const struct SpriteTemplate gSupersonicWaveSpriteTemplate = //gUnknown_83E3CA0 +{ + .tileTag = ANIM_TAG_GOLD_RING, + .paletteTag = ANIM_TAG_GOLD_RING, + .oam = &gOamData_AffineDouble_ObjNormal_16x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gGrowingRingAffineAnimTable, + .callback = TranslateAnimSpriteToTargetMonLocation, +}; + +const struct SpriteTemplate gScreechWaveSpriteTemplate = //gUnknown_83E3CB8 +{ + .tileTag = ANIM_TAG_PURPLE_RING, + .paletteTag = ANIM_TAG_PURPLE_RING, + .oam = &gOamData_AffineDouble_ObjNormal_16x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gGrowingRingAffineAnimTable, + .callback = TranslateAnimSpriteToTargetMonLocation, +}; + +const struct SpriteTemplate gMetalSoundSpriteTemplate = //gUnknown_83E3CD0 +{ + .tileTag = ANIM_TAG_METAL_SOUND_WAVES, + .paletteTag = ANIM_TAG_METAL_SOUND_WAVES, + .oam = &gOamData_AffineDouble_ObjNormal_32x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gGrowingRingAffineAnimTable, + .callback = TranslateAnimSpriteToTargetMonLocation, +}; + +const struct SpriteTemplate gWaterPulseRingSpriteTemplate = //gUnknown_83E3CE8 +{ + .tileTag = ANIM_TAG_BLUE_RING_2, + .paletteTag = ANIM_TAG_BLUE_RING_2, + .oam = &gOamData_AffineDouble_ObjNormal_16x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gWaterPulseRingAffineAnimTable, + .callback = AnimWaterPulseRing, +}; + +const struct SpriteTemplate gEggThrowSpriteTemplate = //gUnknown_83E3D00 +{ + .tileTag = ANIM_TAG_LARGE_FRESH_EGG, + .paletteTag = ANIM_TAG_LARGE_FRESH_EGG, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimThrowProjectile, +}; + +const struct SpriteTemplate gUnknown_83E3D18 = +{ + .tileTag = ANIM_TAG_VOID_LINES, + .paletteTag = ANIM_TAG_VOID_LINES, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A79E8, +}; + +const union AnimCmd gCoinAnimCmds[] = +{ + ANIMCMD_FRAME(8, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gCoinAnimTable[] = +{ + gCoinAnimCmds, +}; + +const union AffineAnimCmd gFallingCoinAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 10, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gFallingCoinAffineAnimTable[] = +{ + gFallingCoinAffineAnimCmds, +}; + +const struct SpriteTemplate gCoinThrowSpriteTemplate = //gUnknown_83E3D50 +{ + .tileTag = ANIM_TAG_COIN, + .paletteTag = ANIM_TAG_COIN, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gCoinAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimCoinThrow, +}; + +const struct SpriteTemplate gFallingCoinSpriteTemplate = //gUnknown_83E3D68 +{ + .tileTag = ANIM_TAG_COIN, + .paletteTag = ANIM_TAG_COIN, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gCoinAnimTable, + .images = NULL, + .affineAnims = gFallingCoinAffineAnimTable, + .callback = AnimFallingCoin, +}; + +const union AffineAnimCmd gBulletSeedAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 20, 1), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gBulletSeedAffineAnimTable[] = +{ + gBulletSeedAffineAnimCmds, +}; + +const struct SpriteTemplate gBulletSeedSpriteTemplate = //gUnknown_83E3D94 +{ + .tileTag = ANIM_TAG_SEED, + .paletteTag = ANIM_TAG_SEED, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gBulletSeedAffineAnimTable, + .callback = AnimBulletSeed, +}; + +const union AffineAnimCmd gRazorWindTornadoAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x4, 0x0, 0, 40), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gRazorWindTornadoAffineAnimTable[] = +{ + gRazorWindTornadoAffineAnimCmds, +}; + +const struct SpriteTemplate gRazorWindTornadoSpriteTemplate = //gUnknown_83E3DC8 +{ + .tileTag = ANIM_TAG_GUST, + .paletteTag = ANIM_TAG_GUST, + .oam = &gOamData_AffineNormal_ObjNormal_32x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gRazorWindTornadoAffineAnimTable, + .callback = AnimRazorWindTornado, +}; + +const union AnimCmd gViceGripAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 20), + ANIMCMD_END, +}; + +const union AnimCmd gViceGripAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 3, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(16, 3, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(32, 20, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gViceGripAnimTable[] = +{ + gViceGripAnimCmds1, + gViceGripAnimCmds2, +}; + +const struct SpriteTemplate gViceGripSpriteTemplate = //gUnknown_83E3E08 +{ + .tileTag = ANIM_TAG_CUT, + .paletteTag = ANIM_TAG_CUT, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gViceGripAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimViceGripPincer, +}; + +const union AnimCmd gGuillotineAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_FRAME(32, 1), + ANIMCMD_END, +}; + +const union AnimCmd gGuillotineAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 2, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(16, 2, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(32, 1, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gGuillotineAnimTable[] = +{ + gGuillotineAnimCmds1, + gGuillotineAnimCmds2, +}; + +const struct SpriteTemplate gGuillotineSpriteTemplate = //gUnknown_83E3E48 +{ + .tileTag = ANIM_TAG_CUT, + .paletteTag = ANIM_TAG_CUT, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gGuillotineAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimGuillotinePincer, +}; + +const union AffineAnimCmd gSplashEffectAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-6, 4, 0, 8), + AFFINEANIMCMD_FRAME(10, -10, 0, 8), + AFFINEANIMCMD_FRAME(-4, 6, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gGrowAndShrinkAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-4, -5, 0, 12), + AFFINEANIMCMD_FRAME(0, 0, 0, 24), + AFFINEANIMCMD_FRAME(4, 5, 0, 12), + AFFINEANIMCMD_END, +}; + +const union AnimCmd gBreathPuffAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(4, 40, .hFlip = TRUE), + ANIMCMD_FRAME(8, 4, .hFlip = TRUE), + ANIMCMD_FRAME(12, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gBreathPuffAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(4, 40), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(12, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gBreathPuffAnimTable[] = +{ + gBreathPuffAnimCmds1, + gBreathPuffAnimCmds2, +}; + +const struct SpriteTemplate gBreathPuffSpriteTemplate = //gUnknown_83E3ED0 +{ + .tileTag = ANIM_TAG_BREATH, + .paletteTag = ANIM_TAG_BREATH, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gBreathPuffAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBreathPuff, +}; + +const union AffineAnimCmd gAngerMarkAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0xB, 0xB, 0, 8), + AFFINEANIMCMD_FRAME(0xFFF5, 0xFFF5, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gAngerMarkAffineAnimTable[] = +{ + gAngerMarkAffineAnimCmds, +}; + +const struct SpriteTemplate gAngerMarkSpriteTemplate = //gUnknown_83E3F04 +{ + .tileTag = ANIM_TAG_ANGER, + .paletteTag = ANIM_TAG_ANGER, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gAngerMarkAffineAnimTable, + .callback = AnimAngerMark, +}; + +const union AffineAnimCmd gThrashMoveMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-10, 9, 0, 7), + AFFINEANIMCMD_FRAME(20, -20, 0, 7), + AFFINEANIMCMD_FRAME(-20, 20, 0, 7), + AFFINEANIMCMD_FRAME(10, -9, 0, 7), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gPencilSpriteTemplate = //gUnknown_83E3F4C +{ + .tileTag = ANIM_TAG_PENCIL, + .paletteTag = ANIM_TAG_PENCIL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPencil, +}; + +const struct SpriteTemplate gSnoreZSpriteTemplate = //gUnknown_83E3F64 +{ + .tileTag = ANIM_TAG_SNORE_Z, + .paletteTag = ANIM_TAG_SNORE_Z, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSnoreZ, +}; + +const union AnimCmd gExplosionAnimCmds[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(16, 5), + ANIMCMD_FRAME(32, 5), + ANIMCMD_FRAME(48, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gExplosionAnimTable[] = +{ + gExplosionAnimCmds, +}; + +const struct SpriteTemplate gExplosionSpriteTemplate = //gUnknown_83E3F94 +{ + .tileTag = ANIM_TAG_EXPLOSION, + .paletteTag = ANIM_TAG_EXPLOSION, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gExplosionAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 2), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 4), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 2), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = +{ + AFFINEANIMCMD_FRAME(0xFFF8, 0x4, 0, 8), + AFFINEANIMCMD_LOOP(0), + AFFINEANIMCMD_FRAME(0x10, 0xFFF8, 0, 8), + AFFINEANIMCMD_FRAME(0xFFF0, 0x8, 0, 8), + AFFINEANIMCMD_LOOP(1), + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 15), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gSoftBoiledEggAffineAnimTable[] = +{ + gSoftBoiledEggAffineAnimCmds1, + gSoftBoiledEggAffineAnimCmds2, + gSoftBoiledEggAffineAnimCmds3, +}; + +const struct SpriteTemplate gSoftBoiledEggSpriteTemplate = //gUnknown_83E4028 +{ + .tileTag = ANIM_TAG_BREAKING_EGG, + .paletteTag = ANIM_TAG_BREAKING_EGG, + .oam = &gOamData_AffineDouble_ObjBlend_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSoftBoiledEggAffineAnimTable, + .callback = AnimSoftBoiledEgg, +}; + +const union AffineAnimCmd gThinRingExpandingAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 30), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd gThinRingExpandingAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), + AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 15), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd gHyperVoiceRingAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), + AFFINEANIMCMD_FRAME(0xB, 0xB, 0, 45), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd *const gThinRingExpandingAffineAnimTable[] = +{ + gThinRingExpandingAffineAnimCmds1, + gThinRingExpandingAffineAnimCmds2, +}; + +const union AffineAnimCmd *const gHyperVoiceRingAffineAnimTable[] = +{ + gHyperVoiceRingAffineAnimCmds, +}; + +const struct SpriteTemplate gThinRingExpandingSpriteTemplate = //gUnknown_83E4094 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gThinRingExpandingAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const union AffineAnimCmd gThinRingShrinkingAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), + AFFINEANIMCMD_FRAME(0xFFF0, 0xFFF0, 0, 30), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd *const gThinRingShrinkingAffineAnimTable[] = +{ + gThinRingShrinkingAffineAnimCmds, +}; + +const struct SpriteTemplate gThinRingShrinkingSpriteTemplate = //gUnknown_83E40C8 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gThinRingShrinkingAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const struct SpriteTemplate gBlendThinRingExpandingSpriteTemplate = //gUnknown_83E40E0 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gThinRingExpandingAffineAnimTable, + .callback = AnimBlendThinRing, +}; + +const struct SpriteTemplate gHyperVoiceRingSpriteTemplate = //gUnknown_83E40F8 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gHyperVoiceRingAffineAnimTable, + .callback = AnimHyperVoiceRing, +}; + +const struct SpriteTemplate gUproarRingSpriteTemplate = //gUnknown_83E4110 +{ + .tileTag = ANIM_TAG_THIN_RING, + .paletteTag = ANIM_TAG_THIN_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gThinRingExpandingAffineAnimTable, + .callback = AnimUproarRing, +}; + +const union AffineAnimCmd gStretchAttackerAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(96, -13, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AnimCmd gSpeedDustAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(4, 3), + ANIMCMD_FRAME(8, 3), + ANIMCMD_FRAME(4, 3), + ANIMCMD_FRAME(0, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gSpeedDustAnimTable[] = +{ + gSpeedDustAnimCmds, +}; + +const struct SpriteTemplate gSpeedDustSpriteTemplate = //gUnknown_83E4154 +{ + .tileTag = ANIM_TAG_SPEED_DUST, + .paletteTag = ANIM_TAG_SPEED_DUST, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gSpeedDustAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpeedDust, +}; + +const s8 gSpeedDustPosTable[][2] = +{ + {30, 28}, + {-20, 24}, + {16, 26}, + {-10, 28}, +}; + +const union AnimCmd gBellAnimCmds[] = +{ + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(32, 15), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 6, .hFlip = TRUE), + ANIMCMD_FRAME(32, 15, .hFlip = TRUE), + ANIMCMD_FRAME(16, 6, .hFlip = TRUE), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(32, 15), + ANIMCMD_FRAME(16, 6), + ANIMCMD_FRAME(0, 6), + ANIMCMD_END, +}; + +const union AnimCmd *const gBellAnimTable[] = +{ + gBellAnimCmds, +}; + +const struct SpriteTemplate gBellSpriteTemplate = //gUnknown_83E41B0 +{ + .tileTag = ANIM_TAG_BELL, + .paletteTag = ANIM_TAG_BELL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gBellAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const u16 gMusicNotePaletteTagsTable[] = +{ + ANIM_TAG_MUSIC_NOTES_2, + ANIM_SPRITES_START - 1, + ANIM_SPRITES_START - 2, +}; + +const struct SpriteTemplate gHealBellMusicNoteSpriteTemplate = //gUnknown_83E41D0 +{ + .tileTag = ANIM_TAG_MUSIC_NOTES_2, + .paletteTag = ANIM_TAG_MUSIC_NOTES_2, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimHealBellMusicNote, +}; + +const struct SpriteTemplate gMagentaHeartSpriteTemplate = //gUnknown_83E41E8 +{ + .tileTag = ANIM_TAG_MAGENTA_HEART, + .paletteTag = ANIM_TAG_MAGENTA_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMagentaHeart, +}; + +const union AffineAnimCmd gUnknown_83E4200[] = +{ + AFFINEANIMCMD_FRAME(0x000A, 0xFFF3, 0x00, 0x0A), + AFFINEANIMCMD_FRAME(0xFFF6, 0x000D, 0x00, 0x0A), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gRedHeartProjectileSpriteTemplate = //gUnknown_83E4218 +{ + .tileTag = ANIM_TAG_RED_HEART, + .paletteTag = ANIM_TAG_RED_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRedHeartProjectile, +}; + +const struct SpriteTemplate gRedHeartBurstSpriteTemplate = //gUnknown_83E4230 +{ + .tileTag = ANIM_TAG_RED_HEART, + .paletteTag = ANIM_TAG_RED_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimParticuleBurst, +}; + +const struct SpriteTemplate gRedHeartRisingSpriteTemplate = //gUnknown_83E4248 +{ + .tileTag = ANIM_TAG_RED_HEART, + .paletteTag = ANIM_TAG_RED_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRedHeartRising, +}; + +const union AffineAnimCmd gHiddenPowerOrbAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), + AFFINEANIMCMD_FRAME(0x8, 0x8, 0, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gHiddenPowerOrbAffineAnimTable[] = +{ + gHiddenPowerOrbAffineAnimCmds, +}; + +const struct SpriteTemplate gHiddenPowerOrbSpriteTemplate = //gUnknown_83E427C +{ + .tileTag = ANIM_TAG_RED_ORB, + .paletteTag = ANIM_TAG_RED_ORB, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gHiddenPowerOrbAffineAnimTable, + .callback = AnimOrbitFast, +}; + +const struct SpriteTemplate gHiddenPowerOrbScatterSpriteTemplate = //gUnknown_83E4294 +{ + .tileTag = ANIM_TAG_RED_ORB, + .paletteTag = ANIM_TAG_RED_ORB, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gHiddenPowerOrbAffineAnimTable, + .callback = AnimOrbitScatter, +}; + +const union AffineAnimCmd gSpitUpOrbAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), + AFFINEANIMCMD_FRAME(0x8, 0x8, 0, 1), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gSpitUpOrbAffineAnimTable[] = +{ + gSpitUpOrbAffineAnimCmds, +}; + +const struct SpriteTemplate gSpitUpOrbSpriteTemplate = //gUnknown_83E42C8 +{ + .tileTag = ANIM_TAG_RED_ORB_2, + .paletteTag = ANIM_TAG_RED_ORB_2, + .oam = &gOamData_AffineDouble_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSpitUpOrbAffineAnimTable, + .callback = AnimSpitUpOrb, +}; + +const union AnimCmd gEyeSparkleAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gEyeSparkleAnimTable[] = +{ + gEyeSparkleAnimCmds, +}; + +const struct SpriteTemplate gEyeSparkleSpriteTemplate = //gUnknown_83E42FC +{ + .tileTag = ANIM_TAG_EYE_SPARKLE, + .paletteTag = ANIM_TAG_EYE_SPARKLE, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gEyeSparkleAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimEyeSparkle, +}; + +const union AnimCmd gAngelSpriteAnimCmds[] = +{ + ANIMCMD_FRAME(0, 24), + ANIMCMD_END, +}; + +const union AnimCmd *const gAngelSpriteAnimTable[] = +{ + gAngelSpriteAnimCmds, +}; + +const struct SpriteTemplate gAngelSpriteTemplate = //gUnknown_83E4320 +{ + .tileTag = ANIM_TAG_ANGEL, + .paletteTag = ANIM_TAG_ANGEL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gAngelSpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimAngel, +}; + +const struct SpriteTemplate gPinkHeartSpriteTemplate = //gUnknown_83E4338 +{ + .tileTag = ANIM_TAG_PINK_HEART, + .paletteTag = ANIM_TAG_PINK_HEART, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPinkHeart, +}; + +const union AnimCmd gDevilAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gDevilAnimCmds2[] = +{ + ANIMCMD_FRAME(16, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gDevilAnimTable[] = +{ + gDevilAnimCmds1, + gDevilAnimCmds2, +}; + +const struct SpriteTemplate gDevilSpriteTemplate = //gUnknown_83E4368 +{ + .tileTag = ANIM_TAG_DEVIL, + .paletteTag = ANIM_TAG_DEVIL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDevilAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimDevil, +}; + +const union AnimCmd gUnknown_08593B08[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_08593B1C[] = +{ + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(16, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_FRAME(48, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gFurySwipesAnimTable[] = +{ + gUnknown_08593B08, + gUnknown_08593B1C, +}; + +const struct SpriteTemplate gFurySwipesSpriteTemplate = //gUnknown_83E43B0 +{ + .tileTag = ANIM_TAG_SWIPE, + .paletteTag = ANIM_TAG_SWIPE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gFurySwipesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFurySwipes, +}; + +const union AnimCmd gMovementWavesAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(16, 8), + ANIMCMD_FRAME(32, 8), + ANIMCMD_FRAME(16, 8), + ANIMCMD_END, +}; + +const union AnimCmd gMovementWavesAnimCmds2[] = +{ + ANIMCMD_FRAME(16, 8, .hFlip = TRUE), + ANIMCMD_FRAME(32, 8, .hFlip = TRUE), + ANIMCMD_FRAME(16, 8, .hFlip = TRUE), + ANIMCMD_FRAME(0, 8, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gMovementWavesAnimTable[] = +{ + gMovementWavesAnimCmds1, + gMovementWavesAnimCmds2, +}; + +const struct SpriteTemplate gMovementWavesSpriteTemplate = //gUnknown_83E43F8 +{ + .tileTag = ANIM_TAG_MOVEMENT_WAVES, + .paletteTag = ANIM_TAG_MOVEMENT_WAVES, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gMovementWavesAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMovmentWaves, +}; + +const union AffineAnimCmd gUnknown_08593B98[] = +{ + AFFINEANIMCMD_FRAME(-12, 8, 0, 4), + AFFINEANIMCMD_FRAME(20, -20, 0, 4), + AFFINEANIMCMD_FRAME(-8, 12, 0, 4), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gJaggedMusicNoteSpriteTemplate = //gUnknown_83E4430 +{ + .tileTag = ANIM_TAG_JAGGED_MUSIC_NOTE, + .paletteTag = ANIM_TAG_JAGGED_MUSIC_NOTE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimJaggedMusicNote, +}; + +const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 5), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 16), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds3[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 16), + AFFINEANIMCMD_END_ALT(1), +}; + +const union AffineAnimCmd *const gPerishSongMusicNoteAffineAnimTable[] = +{ + gPerishSongMusicNoteAffineAnimCmds1, + gPerishSongMusicNoteAffineAnimCmds2, + gPerishSongMusicNoteAffineAnimCmds3, +}; + +extern const union AnimCmd *const gMusicNotesAnimTable[]; +const struct SpriteTemplate gPerishSongMusicNoteSpriteTemplate = //gUnknown_83E4484 +{ + .tileTag = ANIM_TAG_MUSIC_NOTES_2, + .paletteTag = ANIM_TAG_MUSIC_NOTES_2, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gPerishSongMusicNoteAffineAnimTable, + .callback = AnimPerishSongMusicNote, +}; + +const struct SpriteTemplate gPerishSongMusicNote2SpriteTemplate = //gUnknown_83E449C +{ + .tileTag = ANIM_TAG_MUSIC_NOTES_2, + .paletteTag = ANIM_TAG_MUSIC_NOTES_2, + .oam = &gOamData_AffineNormal_ObjNormal_16x16, + .anims = gMusicNotesAnimTable, + .images = NULL, + .affineAnims = gPerishSongMusicNoteAffineAnimTable, + .callback = AnimPerishSongMusicNote2, +}; + +const union AffineAnimCmd gGuardRingAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gGuardRingAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x200, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gGuardRingAffineAnimTable[] = +{ + gGuardRingAffineAnimCmds1, + gGuardRingAffineAnimCmds2, +}; + +const struct SpriteTemplate gGuardRingSpriteTemplate = //gUnknown_83E44DC +{ + .tileTag = ANIM_TAG_GUARD_RING, + .paletteTag = ANIM_TAG_GUARD_RING, + .oam = &gOamData_AffineDouble_ObjBlend_64x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gGuardRingAffineAnimTable, + .callback = AnimGuardRing, +}; + +// Functions +void sub_80A6E48(struct Sprite *sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[4]; + sprite->data[3] = gBattleAnimArgs[5]; + sprite->data[4] = gBattleAnimArgs[3]; + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); + sprite->callback = TranslateSpriteInEllipseOverDuration; + sprite->callback(sprite); +} + +void sub_80A6E98(struct Sprite *sprite) +{ + u8 battler; + if (gBattleAnimArgs[0] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + SetSpriteNextToMonHead(battler, sprite); + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->callback = sub_80A6ED8; +} + +static void sub_80A6ED8(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->pos2.y -= 3; + if (++sprite->data[1] == 6) + sprite->data[0]++; + break; + case 1: + sprite->pos2.y += 3; + if (--sprite->data[1] == 0) + sprite->data[0]++; + break; + case 2: + if (++sprite->data[1] == 64) + DestroyAnimSprite(sprite); + break; + } +} + +static void sub_80A6F3C(struct Sprite *sprite) +{ + s16 temp; + gSprites[sprite->data[2]].pos2.x += sprite->data[1]; + temp = sprite->data[1]; + sprite->data[1] = -temp; + if (sprite->data[0] == 0) + { + gSprites[sprite->data[2]].pos2.x = 0; + DestroySpriteAndMatrix(sprite); + } + + sprite->data[0]--; +} + +void sub_80A6F8C(struct Sprite *sprite) +{ + u8 spriteId; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + spriteId = gBattlerSpriteIds[gBattleAnimTarget]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x -= gBattleAnimArgs[0]; + else + sprite->pos1.x += gBattleAnimArgs[0]; + + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[2] = spriteId; + sprite->callback = sub_80A6F3C; + sprite->invisible = 1; +} + +void sub_80A7020(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[5] = gBattleAnimArgs[4]; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, sub_80A7058); +} + +static void sub_80A7058(struct Sprite *sprite) +{ + sprite->data[0] = sprite->data[1]; + sprite->data[2] = sprite->pos1.x; + sprite->data[4] = sprite->pos1.y + 15; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, sub_80A7080); +} + +static void sub_80A7080(struct Sprite *sprite) +{ + if (sprite->data[5] == 0) + DestroyAnimSprite(sprite); + else + sprite->data[5]--; +} + +// Rotates the attacking mon sprite downwards and then back upwards to its original position. +// No args. +void AnimTask_Withdraw(u8 taskId) +{ + PrepareBattlerSpriteForRotScale(gBattlerSpriteIds[gBattleAnimAttacker], ST_OAM_OBJ_NORMAL); + gTasks[taskId].func = AnimTask_WithdrawStep; +} + +static void AnimTask_WithdrawStep(u8 taskId) +{ + u8 spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + s16 rotation; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + rotation = -gTasks[taskId].data[0]; + else + rotation = gTasks[taskId].data[0]; + + SetSpriteRotScale(spriteId, 0x100, 0x100, rotation); + if (gTasks[taskId].data[1] == 0) + { + gTasks[taskId].data[0] += 0xB0; + // this y position update gets overwritten by SetBattlerSpriteYOffsetFromRotation() + gSprites[spriteId].pos2.y++; + } + else if (gTasks[taskId].data[1] == 1) + { + if (++gTasks[taskId].data[3] == 30) + gTasks[taskId].data[1] = 2; + + return; + } + else + { + gTasks[taskId].data[0] -= 0xB0; + // this y position update gets overwritten by SetBattlerSpriteYOffsetFromRotation() + gSprites[spriteId].pos2.y--; + } + + SetBattlerSpriteYOffsetFromRotation(spriteId); + if (gTasks[taskId].data[0] == 0xF20 || gTasks[taskId].data[0] == 0) + { + if (gTasks[taskId].data[1] == 2) + { + ResetSpriteRotScale(spriteId); + DestroyAnimVisualTask(taskId); + } + else + { + gTasks[taskId].data[1]++; + } + } +} + +// Animates a "zap of energy" used in KINESIS. +// arg 0: x pixel offset +// arg 1: y pixel offset +// arg 2: vertical flip +void Anim_KinesisZapEnergy(struct Sprite *sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x -= gBattleAnimArgs[0]; + else + sprite->pos1.x += gBattleAnimArgs[0]; + + sprite->pos1.y += gBattleAnimArgs[1]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->hFlip = 1; + if (gBattleAnimArgs[2]) + sprite->vFlip = 1; + } + else + { + if (gBattleAnimArgs[2]) + sprite->vFlip = 1; + } + + sprite->callback = RunStoredCallbackWhenAnimEnds; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Animates a sword that rises into the air after a brief pause. +// arg 0: x pixel offset +// arg 1: y pixel offset +void Anim_SwordsDanceBlade(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; + StoreSpriteCallbackInData6(sprite, AnimSwordsDanceBladeStep); +} + +static void AnimSwordsDanceBladeStep(struct Sprite *sprite) +{ + sprite->data[0] = 6; + sprite->data[2] = sprite->pos1.x; + sprite->data[4] = sprite->pos1.y - 32; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Moves a projectile towards the target mon. The sprite is rotated to be pointing +// in the same direction it's moving. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: target x pixel offset +// arg 3: target y pixel offset +// arg 4: duration +void AnimSonicBoomProjectile(struct Sprite *sprite) +{ + s16 targetXPos; + s16 targetYPos; + u16 rotation; + + if (IsContest()) + { + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + } + else if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + gBattleAnimArgs[3] = -gBattleAnimArgs[3]; + } + + InitSpritePosToAnimAttacker(sprite, TRUE); + targetXPos = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[2]; + targetYPos = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[3]; + rotation = ArcTan2Neg(targetXPos - sprite->pos1.x, targetYPos - sprite->pos1.y); + rotation += 0xF000; + if (IsContest()) + rotation -= 0x6000; + + TrySetSpriteRotScale(sprite, FALSE, 0x100, 0x100, rotation); + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = targetXPos; + sprite->data[4] = targetYPos; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +static void AnimAirWaveProjectile_Step2(struct Sprite *sprite) +{ + if (sprite->data[0]-- <= 0) + { + gTasks[sprite->data[7]].data[1]--; + DestroySprite(sprite); + } +} + +static void AnimAirWaveProjectile_Step1(struct Sprite *sprite) +{ + struct Task* task = &gTasks[sprite->data[7]]; + if (sprite->data[0] > task->data[5]) + { + sprite->data[5] += sprite->data[3]; + sprite->data[6] += sprite->data[4]; + } + else + { + sprite->data[5] -= sprite->data[3]; + sprite->data[6] -= sprite->data[4]; + } + + sprite->data[1] += sprite->data[5]; + sprite->data[2] += sprite->data[6]; + if (1 & task->data[7]) + sprite->pos2.x = ((u16)sprite->data[1] >> 8) * -1; + else + sprite->pos2.x = (u16)sprite->data[1] >> 8; + + if (1 & task->data[8]) + sprite->pos2.y = ((u16)sprite->data[2] / 256u) * -1; + else + sprite->pos2.y = (u16)sprite->data[2] / 256u; + + if (sprite->data[0]-- <= 0) + { + sprite->data[0] = 30; + sprite->callback = AnimAirWaveProjectile_Step2; + } +} + +void AnimAirWaveProjectile(struct Sprite *sprite) +{ + s16 a; + s16 b; + s16 c; + + struct Task* task = &gTasks[sprite->data[7]]; + sprite->data[1] += (-2 & task->data[7]); + sprite->data[2] += (-2 & task->data[8]); + if (1 & task->data[7]) + sprite->pos2.x = ((u16)sprite->data[1] >> 8) * -1; + else + sprite->pos2.x = (u16)sprite->data[1] >> 8; + + if (1 & task->data[8]) + sprite->pos2.y = ((u16)sprite->data[2] / 256u) * -1; + else + sprite->pos2.y = (u16)sprite->data[2] / 256u; + + if (sprite->data[0]-- <= 0) + { + sprite->data[0] = 8; + task->data[5] = 4; + a = sub_80D8B90(0x1000); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + if (task->data[11] >= sprite->pos1.x) + b = (task->data[11] - sprite->pos1.x) << 8; + else + b = (sprite->pos1.x - task->data[11]) << 8; + + if (task->data[12] >= sprite->pos1.y) + c = (task->data[12] - sprite->pos1.y) << 8; + else + c = (sprite->pos1.y - task->data[12]) << 8; + + sprite->data[2] = 0; + sprite->data[1] = 0; + sprite->data[6] = 0; + sprite->data[5] = 0; + sprite->data[3] = sub_80D8AA0(sub_80D8AA0(b, a), sub_80D8B90(0x1C0)); + sprite->data[4] = sub_80D8AA0(sub_80D8AA0(c, a), sub_80D8B90(0x1C0)); + sprite->callback = AnimAirWaveProjectile_Step1; + } +} + +static void AirCutterProjectileStep2(u8 taskId) +{ + if (gTasks[taskId].data[1] == 0) + DestroyAnimVisualTask(taskId); +} + +static void AirCutterProjectileStep1(u8 taskId) +{ + if (gTasks[taskId].data[0]-- <= 0) + { + u8 spriteId; + struct Sprite *sprite; + spriteId = CreateSprite(&gAirWaveProjectileSpriteTemplate, gTasks[taskId].data[9], gTasks[taskId].data[10], gTasks[taskId].data[2] - gTasks[taskId].data[1]); + sprite = &gSprites[spriteId]; + switch (gTasks[taskId].data[4]) + { + case 1: + sprite->oam.matrixNum |= (ST_OAM_HFLIP | ST_OAM_VFLIP); + break; + case 2: + sprite->oam.matrixNum = ST_OAM_HFLIP; + break; + } + + sprite->data[0] = gTasks[taskId].data[5] - gTasks[taskId].data[6]; + sprite->data[7] = taskId; + gTasks[taskId].data[gTasks[taskId].data[1] + 13] = spriteId; + gTasks[taskId].data[0] = gTasks[taskId].data[3]; + gTasks[taskId].data[1]++; + PlaySE12WithPanning(SE_W059B, BattleAnimAdjustPanning(-63)); + if (gTasks[taskId].data[1] > 2) + gTasks[taskId].func = AirCutterProjectileStep2; + } +} + +void AnimTask_AirCutterProjectile(u8 taskId) +{ + s16 attackerY = 0; + s16 attackerX = 0; + s16 targetX = 0; + s16 targetY = 0; + s16 xDiff, yDiff; + + if (IsContest()) + { + gTasks[taskId].data[4] = 2; + gBattleAnimArgs[0] = -gBattleAnimArgs[0]; + if (gBattleAnimArgs[2] & 1) + gBattleAnimArgs[2] &= ~1; + else + gBattleAnimArgs[2] |= 1; + } + else + { + if ((gBattlerPositions[gBattleAnimTarget] & BIT_SIDE) == B_SIDE_PLAYER) + { + gTasks[taskId].data[4] = 1; + gBattleAnimArgs[0] = -gBattleAnimArgs[0]; + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + if (gBattleAnimArgs[2] & 1) + gBattleAnimArgs[2] &= ~1; + else + gBattleAnimArgs[2] |= 1; + } + } + + attackerX = gTasks[taskId].data[9] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + attackerY = gTasks[taskId].data[10] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + && IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget))) + { + SetAverageBattlerPositions(gBattleAnimTarget, 0, &targetX, &targetY); + } + else + { + targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); + } + + targetX = gTasks[taskId].data[11] = targetX + gBattleAnimArgs[0]; + targetY = gTasks[taskId].data[12] = targetY + gBattleAnimArgs[1]; + if (targetX >= attackerX) + xDiff = targetX - attackerX; + else + xDiff = attackerX - targetX; + + gTasks[taskId].data[5] = sub_80D8AA0(xDiff, sub_80D8B90(gBattleAnimArgs[2] & ~1)); + gTasks[taskId].data[6] = sub_80D8AA0(gTasks[taskId].data[5], 0x80); + gTasks[taskId].data[7] = gBattleAnimArgs[2]; + if (targetY >= attackerY) + { + yDiff = targetY - attackerY; + gTasks[taskId].data[8] = sub_80D8AA0(yDiff, sub_80D8B90(gTasks[taskId].data[5])) & ~1; + } + else + { + yDiff = attackerY - targetY; + gTasks[taskId].data[8] = sub_80D8AA0(yDiff, sub_80D8B90(gTasks[taskId].data[5])) | 1; + } + + gTasks[taskId].data[3] = gBattleAnimArgs[3]; + if (gBattleAnimArgs[4] & 0x80) + { + gBattleAnimArgs[4] ^= 0x80; + if (gBattleAnimArgs[4] >= 64) + { + u16 var = GetBattlerSpriteSubpriority(gBattleAnimTarget) + (gBattleAnimArgs[4] - 64); + gTasks[taskId].data[2] = var; + } + else + { + u16 var = GetBattlerSpriteSubpriority(gBattleAnimTarget) - gBattleAnimArgs[4]; + gTasks[taskId].data[2] = var; + } + } + else + { + if (gBattleAnimArgs[4] >= 64) + { + u16 var = GetBattlerSpriteSubpriority(gBattleAnimTarget) + (gBattleAnimArgs[4] - 64); + gTasks[taskId].data[2] = var; + } + else + { + u16 var = GetBattlerSpriteSubpriority(gBattleAnimTarget) - gBattleAnimArgs[4]; + gTasks[taskId].data[2] = var; + } + } + + if (gTasks[taskId].data[2] < 3) + gTasks[taskId].data[2] = 3; + + gTasks[taskId].func = AirCutterProjectileStep1; +} + +void sub_80A79E8(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + sprite->data[0] = 0x100 + (IndexOfSpritePaletteTag(gUnknown_83E3D18.paletteTag) << 4); + sprite->callback = sub_80A7A18; +} + +static void sub_80A7A18(struct Sprite *sprite) +{ + u16 id, val; + int i; + + if (++sprite->data[1] == 2) + { + sprite->data[1] = 0; + id = sprite->data[0]; + val = gPlttBufferFaded[8 + id]; + for (i = 8; i < 16; i++) + gPlttBufferFaded[i + id] = gPlttBufferFaded[i + id + 1]; + + gPlttBufferFaded[id + 15] = val; + + if (++sprite->data[2] == 24) + DestroyAnimSprite(sprite); + } +} + +void AnimCoinThrow(struct Sprite *sprite) +{ + s16 r6; + s16 r7; + u16 var; + + InitSpritePosToAnimAttacker(sprite, TRUE); + r6 = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + r7 = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[3]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + r6 += gBattleAnimArgs[2]; + var = ArcTan2Neg(r6 - sprite->pos1.x, r7 - sprite->pos1.y); + var += 0xC000; + TrySetSpriteRotScale(sprite, FALSE, 0x100, 0x100, var); + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = r6; + sprite->data[4] = r7; + sprite->callback = sub_80756A4; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimFallingCoin(struct Sprite *sprite) +{ + sprite->data[2] = -16; + sprite->pos1.y += 8; + sprite->callback = AnimFallingCoin_Step; +} + +static void AnimFallingCoin_Step(struct Sprite *sprite) +{ + sprite->data[0] += 0x80; + sprite->pos2.x = sprite->data[0] >> 8; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + sprite->pos2.x = -sprite->pos2.x; + + sprite->pos2.y = Sin(sprite->data[1], sprite->data[2]); + sprite->data[1] += 5; + if (sprite->data[1] > 126) + { + sprite->data[1] = 0; + sprite->data[2] /= 2; + if (++sprite->data[3] == 2) + DestroyAnimSprite(sprite); + } +} + +void AnimBulletSeed(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = 20; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + sprite->callback = StartAnimLinearTranslation; + sprite->affineAnimPaused = 1; + StoreSpriteCallbackInData6(sprite, AnimBulletSeed_Step1); +} + +static void AnimBulletSeed_Step1(struct Sprite *sprite) +{ + int i; + u16 rand; + s16* ptr; + PlaySE12WithPanning(SE_W030, BattleAnimAdjustPanning(63)); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + ptr = &sprite->data[7]; + for (i = 0; i < 8; i++) + ptr[i - 7] = 0; + + rand = Random2(); + sprite->data[6] = 0xFFF4 - (rand & 7); + rand = Random2(); + sprite->data[7] = (rand % 0xA0) + 0xA0; + sprite->callback = AnimBulletSeed_Step2; + sprite->affineAnimPaused = 0; +} + +static void AnimBulletSeed_Step2(struct Sprite *sprite) +{ + sprite->data[0] += sprite->data[7]; + sprite->pos2.x = sprite->data[0] >> 8; + if (sprite->data[7] & 1) + sprite->pos2.x = -sprite->pos2.x; + + sprite->pos2.y = Sin(sprite->data[1], sprite->data[6]); + sprite->data[1] += 8; + if (sprite->data[1] > 126) + { + sprite->data[1] = 0; + sprite->data[2] /= 2; + if (++sprite->data[3] == 1) + DestroyAnimSprite(sprite); + } +} + +// Moves a tornado in a circlular motion. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: wave amplitude +// arg 3: unused +// arg 4: initial wave offset +// arg 5: wave period (higher means faster wave) +// arg 6: duration +void AnimRazorWindTornado(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + sprite->pos1.y += 16; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[1] = gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[5]; + sprite->data[3] = gBattleAnimArgs[6]; + sprite->data[4] = gBattleAnimArgs[3]; + sprite->callback = TranslateSpriteInCircleOverDuration; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback(sprite); +} + +// Animates a single pincer line that extends towards the center of the target mon. +// arg 0: invert +void AnimViceGripPincer(struct Sprite *sprite) +{ + s16 startXOffset = 32; + s16 startYOffset = -32; + s16 endXOffset = 16; + s16 endYOffset = -16; + if (gBattleAnimArgs[0]) + { + startXOffset = -32; + startYOffset = 32; + endXOffset = -16; + endYOffset = 16; + StartSpriteAnim(sprite, 1); + } + + sprite->pos1.x += startXOffset; + sprite->pos1.y += startYOffset; + sprite->data[0] = 6; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + endXOffset; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + endYOffset; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, AnimViceGripPincerStep); +} + +static void AnimViceGripPincerStep(struct Sprite *sprite) +{ + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +// Animates a single pincer line that extends towards the center of the target mon, and then back out. +// arg 0: animation id +void AnimGuillotinePincer(struct Sprite *sprite) +{ + s16 startXOffset = 32; + s16 startYOffset = -32; + s16 endXOffset = 16; + s16 endYOffset = -16; + if (gBattleAnimArgs[0]) + { + startXOffset = -32; + startYOffset = 32; + endXOffset = -16; + endYOffset = 16; + StartSpriteAnim(sprite, gBattleAnimArgs[0]); + } + + sprite->pos1.x += startXOffset; + sprite->pos1.y += startYOffset; + sprite->data[0] = 6; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + endXOffset; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + endYOffset; + InitAnimLinearTranslation(sprite); + sprite->data[5] = gBattleAnimArgs[0]; + sprite->data[6] = sprite->data[0]; + sprite->callback = AnimGuillotinePincerStep1; +} + +static void AnimGuillotinePincerStep1(struct Sprite *sprite) +{ + if (AnimTranslateLinear(sprite) && sprite->animEnded) + { + SeekSpriteAnim(sprite, 0); + sprite->animPaused = 1; + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 2; + sprite->pos2.y = -2; + sprite->data[0] = sprite->data[6]; + sprite->data[1] ^= 1; + sprite->data[2] ^= 1; + sprite->data[4] = 0; + sprite->data[3] = 0; + sprite->callback = AnimGuillotinePincerStep2; + } +} + +static void AnimGuillotinePincerStep2(struct Sprite *sprite) +{ + if (sprite->data[3]) + { + sprite->pos2.x = -sprite->pos2.x; + sprite->pos2.y = -sprite->pos2.y; + } + + sprite->data[3] ^= 1; + if (++sprite->data[4] == 51) + { + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[4] = 0; + sprite->data[3] = 0; + sprite->animPaused = 0; + StartSpriteAnim(sprite, sprite->data[5] ^ 1); + sprite->callback = AnimGuillotinePincerStep3; + } +} + +static void AnimGuillotinePincerStep3(struct Sprite *sprite) +{ + if (AnimTranslateLinear(sprite)) + DestroyAnimSprite(sprite); +} + +// Scales up the target mon sprite, and sets the palette to greyscale. +// Used in MOVE_DISABLE. +// No args. +void AnimTask_GrowAndGreyscale(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_BLEND); + SetSpriteRotScale(spriteId, 0xD0, 0xD0, 0); + SetGreyscaleOrOriginalPalette(gSprites[spriteId].oam.paletteNum + 16, FALSE); + gTasks[taskId].data[0] = 80; + gTasks[taskId].func = AnimTask_GrowAndGreyscaleStep; +} + +static void AnimTask_GrowAndGreyscaleStep(u8 taskId) +{ + if (--gTasks[taskId].data[0] == -1) + { + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + ResetSpriteRotScale(spriteId); + SetGreyscaleOrOriginalPalette(gSprites[spriteId].oam.paletteNum + 16, TRUE); + DestroyAnimVisualTask(taskId); + } +} + +// Shrinks and grows the attacking mon several times. Also creates transparent versions of the +// mon's sprite while it is shrinking. +// No args. +void AnimTask_Minimize(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 0x100; + task->data[5] = 0; + task->data[6] = 0; + task->data[7] = GetBattlerSpriteSubpriority(gBattleAnimAttacker); + task->func = AnimTask_MinimizeStep1; +} + +static void AnimTask_MinimizeStep1(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[1]) + { + case 0: + if (task->data[2] == 0 || task->data[2] == 3 || task->data[2] == 6) + CreateMinimizeSprite(task, taskId); + task->data[2]++; + task->data[4] += 0x28; + SetSpriteRotScale(task->data[0], task->data[4], task->data[4], 0); + SetBattlerSpriteYOffsetFromYScale(task->data[0]); + if (task->data[2] == 32) + { + task->data[5]++; + task->data[1]++; + } + break; + case 1: + if (task->data[6] == 0) + { + if (task->data[5] == 3) + { + task->data[2] = 0; + task->data[1] = 3; + } + else + { + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 0x100; + SetSpriteRotScale(task->data[0], task->data[4], task->data[4], 0); + SetBattlerSpriteYOffsetFromYScale(task->data[0]); + task->data[1] = 2; + } + } + break; + case 2: + task->data[1] = 0; + break; + case 3: + if (++task->data[2] > 32) + { + task->data[2] = 0; + task->data[1]++; + } + break; + case 4: + task->data[2] += 2; + task->data[4] -= 0x50; + SetSpriteRotScale(task->data[0], task->data[4], task->data[4], 0); + SetBattlerSpriteYOffsetFromYScale(task->data[0]); + if (task->data[2] == 32) + { + task->data[2] = 0; + task->data[1]++; + } + break; + case 5: + ResetSpriteRotScale(task->data[0]); + gSprites[task->data[15]].pos2.y = 0; + DestroyAnimVisualTask(taskId); + break; + } +} + +static void CreateMinimizeSprite(struct Task* task, u8 taskId) +{ + u16 matrixNum; + s16 spriteId = CloneBattlerSpriteWithBlend(ANIM_ATTACKER); + if (spriteId >= 0) + { + if ((matrixNum = AllocOamMatrix()) == 0xFF) + { + obj_delete_but_dont_free_vram(&gSprites[spriteId]); + } + else + { + gSprites[spriteId].oam.objMode = ST_OAM_OBJ_BLEND; + gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_DOUBLE; + gSprites[spriteId].affineAnimPaused = TRUE; + gSprites[spriteId].oam.matrixNum = matrixNum; + gSprites[spriteId].subpriority = task->data[7] - task->data[3]; + task->data[3]++; + task->data[6]++; + gSprites[spriteId].data[0] = 16; + gSprites[spriteId].data[1] = taskId; + gSprites[spriteId].data[2] = 6; + gSprites[spriteId].callback = ClonedMinizeSprite_Step; + SetSpriteRotScale(spriteId, task->data[4], task->data[4], 0); + gSprites[spriteId].oam.affineMode = 1; + CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode); + } + } +} + +static void ClonedMinizeSprite_Step(struct Sprite *sprite) +{ + if (--sprite->data[0] == 0) + { + gTasks[sprite->data[1]].data[sprite->data[2]]--; + FreeOamMatrix(sprite->oam.matrixNum); + obj_delete_but_dont_free_vram(sprite); + } +} + +// Task to facilitate expanding and hopping effect seen in Splash. +// arg 0: anim battler +// arg 1: num hops +void AnimTask_Splash(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (gBattleAnimArgs[1] == 0) + { + DestroyAnimVisualTask(taskId); + } + else + { + u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->data[0] = spriteId; + task->data[1] = 0; + task->data[2] = gBattleAnimArgs[1]; + task->data[3] = 0; + task->data[4] = 0; + PrepareAffineAnimInTaskData(task, spriteId, gSplashEffectAffineAnimCmds); + task->func = AnimTask_SplashStep; + } +} + +static void AnimTask_SplashStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[1]) + { + case 0: + RunAffineAnimFromTaskData(task); + task->data[4] += 3; + gSprites[task->data[0]].pos2.y += task->data[4]; + if (++task->data[3] > 7) + { + task->data[3] = 0; + task->data[1]++; + } + break; + case 1: + RunAffineAnimFromTaskData(task); + gSprites[task->data[0]].pos2.y += task->data[4]; + if (++task->data[3] > 7) + { + task->data[3] = 0; + task->data[1]++; + } + break; + case 2: + if (task->data[4] != 0) + { + gSprites[task->data[0]].pos2.y -= 2; + task->data[4] -= 2; + } + else + task->data[1]++; + break; + case 3: + if (!RunAffineAnimFromTaskData(task)) + { + if (--task->data[2] == 0) + { + gSprites[task->data[0]].pos2.y = 0; + DestroyAnimVisualTask(taskId); + } + else + { + PrepareAffineAnimInTaskData(task, task->data[0], gSplashEffectAffineAnimCmds); + task->data[1] = 0; + } + } + break; + } +} + +// Grows, pauses, then shrinks the attacking mon. +// Used by MOVE_SWAGGER and MOVE_BULK_UP +// No args. +void AnimTask_GrowAndShrink(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + PrepareAffineAnimInTaskData(task, spriteId, gGrowAndShrinkAffineAnimCmds); + task->func = AnimTask_GrowAndShrinkStep; +} + +static void AnimTask_GrowAndShrinkStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) + DestroyAnimVisualTask(taskId); +} + +// Animates a little puff of the mon's breath. +// Used by MOVE_SWAGGER and MOVE_BULK_UP +// No args. +void AnimBreathPuff(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + StartSpriteAnim(sprite, 0); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + 32; + sprite->data[1] = 64; + } + else + { + StartSpriteAnim(sprite, 1); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) - 32; + sprite->data[1] = -64; + } + + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->data[0] = 52; + sprite->data[2] = 0; + sprite->data[3] = 0; + sprite->data[4] = 0; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = TranslateSpriteLinearFixedPoint; +} + +// Animates an "angry" mark above a mon's head. +// arg 0: target mon (0 = attacker, 1 = target) +// arg 1: x pixel offset +// arg 2: y pixel offset +void AnimAngerMark(struct Sprite *sprite) +{ + u8 battler; + if (!gBattleAnimArgs[0]) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + gBattleAnimArgs[1] *= -1; + + sprite->pos1.x = GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; + if (sprite->pos1.y < 8) + sprite->pos1.y = 8; + + StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix); + sprite->callback = RunStoredCallbackWhenAffineAnimEnds; +} + +// left/right movements +void AnimTask_ThrashMoveMonHorizontal(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; + task->data[1] = 0; + PrepareAffineAnimInTaskData(task, spriteId, gThrashMoveMonAffineAnimCmds); + task->func = ThrashMoveMonStep; +} + +static void ThrashMoveMonStep(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) + DestroyAnimVisualTask(taskId); +} + +// up/down movements +void AnimTask_ThrashMoveMonVertical(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + task->data[0] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[1] = 0; + task->data[2] = 4; + task->data[3] = 7; + task->data[4] = 3; + task->data[5] = gSprites[task->data[0]].pos1.x; + task->data[6] = gSprites[task->data[0]].pos1.y; + task->data[7] = 0; + task->data[8] = 0; + task->data[9] = 2; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + task->data[2] *= -1; + + task->func = ThrashMoveMon; +} + +static void ThrashMoveMon(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (++task->data[7] > 2) + { + task->data[7] = 0; + task->data[8]++; + if (task->data[8] & 1) + gSprites[task->data[0]].pos1.y += task->data[9]; + else + gSprites[task->data[0]].pos1.y -= task->data[9]; + } + switch (task->data[1]) + { + case 0: + gSprites[task->data[0]].pos1.x += task->data[2]; + if (--task->data[3] == 0) + { + task->data[3] = 14; + task->data[1] = 1; + } + break; + case 1: + gSprites[task->data[0]].pos1.x -= task->data[2]; + if (--task->data[3] == 0) + { + task->data[3] = 7; + task->data[1] = 2; + } + break; + case 2: + gSprites[task->data[0]].pos1.x += task->data[2]; + if (--task->data[3] == 0) + { + if (--task->data[4] != 0) + { + task->data[3] = 7; + task->data[1] = 0; + } + else + { + if ((task->data[8] & 1) != 0) + gSprites[task->data[0]].pos1.y -= task->data[9]; + + DestroyAnimVisualTask(taskId); + } + } + break; + } +} + +void sub_80A8874(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + struct ScanlineEffectParams params; + + s16 i; + task->data[0] = GetBattlerYCoordWithElevation(gBattleAnimTarget) + 32; + task->data[1] = 4; + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 0; + task->data[5] = 0; + task->data[15] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT); + + if (GetBattlerSpriteBGPriorityRank(gBattleAnimTarget) == 1) + { + task->data[6] = gBattle_BG1_X; + params.dmaDest = (u16 *)REG_ADDR_BG1HOFS; + } + else + { + task->data[6] = gBattle_BG2_X; + params.dmaDest = (u16 *)REG_ADDR_BG2HOFS; + } + + for (i = task->data[0] - 0x40; i <= task->data[0]; i++) + { + if (i >= 0) + { + gScanlineEffectRegBuffers[0][i] = task->data[6] + 0xF0; + gScanlineEffectRegBuffers[1][i] = task->data[6] + 0xF0; + } + } + + params.dmaControl = SCANLINE_EFFECT_DMACNT_16BIT; + params.initState = 1; + params.unused9 = 0; + ScanlineEffect_SetParams(params); + task->func = AnimTask_SketchDrawMon; +} + +static void AnimTask_SketchDrawMon(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + + switch (task->data[4]) + { + case 0: + if (++task->data[5] > 20) + task->data[4]++; + break; + case 1: + if (++task->data[1] > 3) + { + task->data[1] = 0; + task->data[2] = task->data[3] & 3; + task->data[5] = task->data[0] - task->data[3]; + switch (task->data[2]) + { + case 0: + break; + case 1: + task->data[5] -= 2; + break; + case 2: + task->data[5] += 1; + break; + case 3: + task->data[5] += 1; + break; + } + + if (task->data[5] >= 0) + { + gScanlineEffectRegBuffers[0][task->data[5]] = task->data[6]; + gScanlineEffectRegBuffers[1][task->data[5]] = task->data[6]; + } + + if (++task->data[3] >= task->data[15]) + { + gScanlineEffect.state = 3; + DestroyAnimVisualTask(taskId); + } + } + break; + } +} + +void AnimPencil(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) - 16; + sprite->pos1.y = GetBattlerYCoordWithElevation(gBattleAnimTarget) + 16; + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[3] = 16; + sprite->data[4] = 0; + sprite->data[5] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT) + 2; + sprite->data[6] = BattleAnimAdjustPanning(63); + sprite->callback = AnimPencil_Step; +} + +static void AnimPencil_Step(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (++sprite->data[2] > 1) + { + sprite->data[2] = 0; + sprite->invisible = !sprite->invisible; + } + if (++sprite->data[1] > 16) + { + sprite->invisible = 0; + sprite->data[0]++; + } + break; + case 1: + if (++sprite->data[1] > 3 && sprite->data[2] < sprite->data[5]) + { + sprite->data[1] = 0; + sprite->pos1.y -= 1; + sprite->data[2]++; + if (sprite->data[2] % 10 == 0) + PlaySE12WithPanning(SE_W166, sprite->data[6]); + } + sprite->data[4] += sprite->data[3]; + if (sprite->data[4] > 31) + { + sprite->data[4] = 0x40 - sprite->data[4]; + sprite->data[3] *= -1; + } + else if (sprite->data[4] <= -32) + { + sprite->data[4] = -0x40 - sprite->data[4]; + sprite->data[3] *= -1; + } + sprite->pos2.x = sprite->data[4]; + if (sprite->data[5] == sprite->data[2]) + { + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 2: + if (++sprite->data[2] > 1) + { + sprite->data[2] = 0; + sprite->invisible = !sprite->invisible; + } + if (++sprite->data[1] > 16) + { + sprite->invisible = 0; + DestroyAnimSprite(sprite); + } + break; + } +} + +void AnimBlendThinRing(struct Sprite *sprite) +{ + u8 battler = 0; + u16 sp0 = 0; + u16 sp1 = 0; + u8 r4; + + if (gBattleAnimArgs[2] == 0) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + r4 = gBattleAnimArgs[3] ^ 1; + if (IsDoubleBattle() && IsBattlerSpriteVisible(BATTLE_PARTNER(battler))) + { + SetAverageBattlerPositions(battler, r4, &sp0, &sp1); + if (r4 == 0) + r4 = GetBattlerSpriteCoord(battler, 0); + else + r4 = GetBattlerSpriteCoord(battler, 2); + + if (GetBattlerSide(battler) != B_SIDE_PLAYER) + gBattleAnimArgs[0] -= (sp0 - r4) - gBattleAnimArgs[0]; // This is weird. + else + gBattleAnimArgs[0] = sp0 - r4; + } + + sprite->callback = AnimSpriteOnMonPos; + sprite->callback(sprite); +} + +void sub_80A8C84(struct Sprite *sprite) +{ + if (AnimTranslateLinear(sprite)) + { + FreeSpriteOamMatrix(sprite); + DestroyAnimSprite(sprite); + } +} + +void AnimHyperVoiceRing(struct Sprite *sprite) +{ + u16 r9 = 0; + u16 r6 = 0; + s16 sp0 = 0; + s16 sp1 = 0; + u8 sp4; + u8 battler1; + u8 battler2; + u8 r10; + + if (gBattleAnimArgs[5] == 0) + { + battler1 = gBattleAnimAttacker; + battler2 = gBattleAnimTarget; + } + else + { + battler1 = gBattleAnimTarget; + battler2 = gBattleAnimAttacker; + } + + if (!gBattleAnimArgs[6]) + { + r10 = 0; + sp4 = 1; + } + else + { + r10 = 2; + sp4 = 3; + } + + if (GetBattlerSide(battler1) != B_SIDE_PLAYER) + { + r9 = GetBattlerSpriteCoord(battler1, r10) + gBattleAnimArgs[0]; + if (IsBattlerSpriteVisible(BATTLE_PARTNER(battler2))) + sprite->subpriority = gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler2)]].subpriority - 1; + else + sprite->subpriority = gSprites[gBattlerSpriteIds[battler2]].subpriority - 1; + } + else + { + r9 = GetBattlerSpriteCoord(battler1, r10) - gBattleAnimArgs[0]; + if (!IsContest() && IsBattlerSpriteVisible(BATTLE_PARTNER(battler1))) + { + if (gSprites[gBattlerSpriteIds[battler1]].pos1.x < gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler1)]].pos1.x) + sprite->subpriority = gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler1)]].subpriority + 1; + else + sprite->subpriority = gSprites[gBattlerSpriteIds[battler1]].subpriority - 1; + } + else + { + sprite->subpriority = gSprites[gBattlerSpriteIds[battler1]].subpriority - 1; + } + + } + + r6 = GetBattlerSpriteCoord(battler1, sp4) + gBattleAnimArgs[1]; + if (!IsContest() && IsBattlerSpriteVisible(BATTLE_PARTNER(battler2))) + { + SetAverageBattlerPositions(battler2, gBattleAnimArgs[6], &sp0, &sp1); + } + else + { + sp0 = GetBattlerSpriteCoord(battler2, r10); + sp1 = GetBattlerSpriteCoord(battler2, sp4); + } + + if (GetBattlerSide(battler2)) + sp0 += gBattleAnimArgs[3]; + else + sp0 -= gBattleAnimArgs[3]; + + sp1 += gBattleAnimArgs[4]; + sprite->pos1.x = sprite->data[1] = r9; + sprite->pos1.y = sprite->data[3] = r6; + sprite->data[2] = sp0; + sprite->data[4] = sp1; + sprite->data[0] = gBattleAnimArgs[0]; + InitAnimLinearTranslation(sprite); + sprite->callback = sub_80A8C84; + sprite->callback(sprite); +} + +void AnimUproarRing(struct Sprite *sprite) +{ + u8 index = IndexOfSpritePaletteTag(ANIM_TAG_THIN_RING); + if (index != 0xFF) + { + BlendPalette(((index << 20) + 0x1010000) >> 16, 15, gBattleAnimArgs[5], gBattleAnimArgs[4]); + } + + StartSpriteAffineAnim(sprite, 1); + sprite->callback = AnimSpriteOnMonPos; + sprite->callback(sprite); +} + +void AnimSoftBoiledEgg(struct Sprite *sprite) +{ + s16 r1; + InitSpritePosToAnimAttacker(sprite, FALSE); + r1 = GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER ? -160 : 160; + sprite->data[0] = 0x380; + sprite->data[1] = r1; + sprite->data[7] = gBattleAnimArgs[2]; + sprite->callback = AnimSoftBoiledEgg_Step1; +} + +static void AnimSoftBoiledEgg_Step1(struct Sprite *sprite) +{ + s16 add; + sprite->pos2.y -= (sprite->data[0] >> 8); + sprite->pos2.x = sprite->data[1] >> 8; + sprite->data[0] -= 32; + add = GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER ? -160 : 160; + sprite->data[1] += add; + if (sprite->pos2.y > 0) + { + sprite->pos1.y += sprite->pos2.y; + sprite->pos1.x += sprite->pos2.x; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[0] = 0; + StartSpriteAffineAnim(sprite, 1); + sprite->callback = AnimSoftBoiledEgg_Step2; + } +} + +static void AnimSoftBoiledEgg_Step2(struct Sprite *sprite) +{ + if (sprite->data[0]++ > 19) + { + StartSpriteAffineAnim(sprite, 2); + sprite->callback = AnimSoftBoiledEgg_Step3; + } +} + +static void AnimSoftBoiledEgg_Step3(struct Sprite *sprite) +{ + if (sprite->affineAnimEnded) + { + StartSpriteAffineAnim(sprite, 1); + sprite->data[0] = 0; + if (sprite->data[7] == 0) + { + sprite->oam.tileNum += 16; + sprite->callback = AnimSoftBoiledEgg_Step3_Callback1; + } + else + { + sprite->oam.tileNum += 32; + sprite->callback = AnimSoftBoiledEgg_Step4; + } + } +} + +static void AnimSoftBoiledEgg_Step3_Callback1(struct Sprite *sprite) +{ + sprite->pos2.y -= 2; + if (++sprite->data[0] == 9) + { + sprite->data[0] = 16; + sprite->data[1] = 0; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND((u16)sprite->data[0], 0)); + sprite->callback = AnimSoftBoiledEgg_Step3_Callback2; + } +} + +static void AnimSoftBoiledEgg_Step3_Callback2(struct Sprite *sprite) +{ + if (sprite->data[1]++ % 3 == 0) + { + sprite->data[0]--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 16 - sprite->data[0])); + if (sprite->data[0] == 0) + sprite->callback = AnimSoftBoiledEgg_Step4; + } +} + +static void AnimSoftBoiledEgg_Step4(struct Sprite *sprite) +{ + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + { + sprite->invisible = 1; + if (sprite->data[7] == 0) + sprite->callback = AnimSoftBoiledEgg_Step4_Callback; + else + sprite->callback = DestroyAnimSprite; + } +} + +static void AnimSoftBoiledEgg_Step4_Callback(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimSprite(sprite); +} + +void AnimTask_StretchAttacker(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; + PrepareAffineAnimInTaskData(task, spriteId, gStretchAttackerAffineAnimCmds); + task->func = StretchAttacker_Step; +} + +static void StretchAttacker_Step(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) + { + gSprites[task->data[0]].pos2.y = 0; + gSprites[task->data[0]].invisible = 1; + DestroyAnimVisualTask(taskId); + } +} + +void AnimTask_ExtremeSpeedImpact(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[12] = 3; + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + task->data[13] = 0xFFFF; + task->data[14] = 8; + } + else + { + task->data[13] = 1; + task->data[14] = -8; + } + + task->data[15] = GetAnimBattlerSpriteId(ANIM_TARGET); + task->func = ExtremeSpeedImpact_Step; +} + +static void ExtremeSpeedImpact_Step(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + gSprites[task->data[15]].pos2.x += task->data[14]; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[0]++; + break; + case 1: + if (++task->data[1] > 1) + { + task->data[1] = 0; + task->data[2]++; + if (task->data[2] & 1) + gSprites[task->data[15]].pos2.x += 6; + else + gSprites[task->data[15]].pos2.x -= 6; + + if (++task->data[3] > 4) + { + if (task->data[2] & 1) + gSprites[task->data[15]].pos2.x -= 6; + + task->data[0]++; + } + } + break; + case 2: + if (--task->data[12] != 0) + task->data[0] = 0; + else + task->data[0]++; + break; + case 3: + gSprites[task->data[15]].pos2.x += task->data[13]; + if (gSprites[task->data[15]].pos2.x == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimTask_ExtremeSpeedMonReappear(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 1; + task->data[13] = 14; + task->data[14] = 2; + task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->func = ExtremeSpeedMonReappear_Step; +} + +static void ExtremeSpeedMonReappear_Step(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + if (task->data[0] == 0 && ++task->data[1] > task->data[4]) + { + task->data[1] = 0; + if (++task->data[2] & 1) + gSprites[task->data[15]].invisible = 0; + else + gSprites[task->data[15]].invisible = 1; + + if (++task->data[3] >= task->data[13]) + { + if (++task->data[4] < task->data[14]) + { + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + } + else + { + gSprites[task->data[15]].invisible = 0; + DestroyAnimVisualTask(taskId); + } + } + } +} + +void AnimTask_SpeedDust(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + task->data[0] = 0; + task->data[1] = 4; + task->data[2] = 0; + task->data[3] = 0; + task->data[4] = 0; + task->data[5] = 0; + task->data[6] = 0; + task->data[7] = 0; + task->data[8] = 0; + task->data[13] = 0; + task->data[14] = GetBattlerSpriteCoord(gBattleAnimAttacker, ANIM_ATTACKER); + task->data[15] = GetBattlerSpriteCoord(gBattleAnimAttacker, ANIM_TARGET); + task->func = SpeedDust_Step1; +} + +static void SpeedDust_Step1(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + switch (task->data[8]) + { + case 0: + if (++task->data[4] > 1) + { + task->data[4] = 0; + task->data[5] = (task->data[5] + 1) & 1; + if (++task->data[6] > 20) + { + if (task->data[7] == 0) + { + task->data[6] = 0; + task->data[8] = 1; + } + else + task->data[8] = 2; + } + } + break; + case 1: + task->data[5] = 0; + if (++task->data[4] > 20) + { + task->data[7] = 1; + task->data[8] = 0; + } + break; + case 2: + task->data[5] = 1; + break; + } + + switch (task->data[0]) + { + case 0: + if (++task->data[1] > 4) + { + u8 spriteId; + task->data[1] = 0; + spriteId = CreateSprite(&gSpeedDustSpriteTemplate, task->data[14], task->data[15], 0); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].data[0] = taskId; + gSprites[spriteId].data[1] = 13; + gSprites[spriteId].pos2.x = gSpeedDustPosTable[task->data[2]][0]; + gSprites[spriteId].pos2.y = gSpeedDustPosTable[task->data[2]][1]; + task->data[13]++; + if (++task->data[2] > 3) + { + task->data[2] = 0; + if (++task->data[3] > 5) + task->data[0]++; + } + } + } + break; + case 1: + if (task->data[13] == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimSpeedDust(struct Sprite *sprite) +{ + sprite->invisible = gTasks[sprite->data[0]].data[5]; + if (sprite->animEnded) + { + gTasks[sprite->data[0]].data[sprite->data[1]]--; + DestroySprite(sprite); + } +} + +void sub_80A96B4(u8 taskId) +{ + int i; + u8 paletteNums[3]; + + paletteNums[0] = IndexOfSpritePaletteTag(ANIM_TAG_MUSIC_NOTES_2); + for (i = 1; i < 3; i++) + paletteNums[i] = AllocSpritePalette(ANIM_SPRITES_START - i); + + gMonSpritesGfxPtr->field_17C = AllocZeroed(0x2000); + LZDecompressWram(gBattleAnimSpritePal_MusicNotes2, gMonSpritesGfxPtr->field_17C); + for (i = 0; i < 3; i++) + LoadPalette(&gMonSpritesGfxPtr->field_17C[i * 32], (u16)((paletteNums[i] << 4) + 0x100), 32); + + FREE_AND_SET_NULL(gMonSpritesGfxPtr->field_17C); + DestroyAnimVisualTask(taskId); +} + +void sub_80A9760(u8 taskId) +{ + int i; + for (i = 0; i < 3; i++) + FreeSpritePaletteByTag(gMusicNotePaletteTagsTable[i]); + + DestroyAnimVisualTask(taskId); +} + +static void SetMusicNotePalette(struct Sprite *sprite, u8 a, u8 b) +{ + u8 tile; + tile = (b & 1); + tile = ((-tile | tile) >> 31) & 32; + sprite->oam.tileNum += tile + (a << 2); + sprite->oam.paletteNum = IndexOfSpritePaletteTag(gMusicNotePaletteTagsTable[b >> 1]); +} + +void AnimHealBellMusicNote(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, FALSE); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[3]; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + SetMusicNotePalette(sprite, gBattleAnimArgs[5], gBattleAnimArgs[6]); +} + +void AnimMagentaHeart(struct Sprite *sprite) +{ + if (++sprite->data[0] == 1) + InitSpritePosToAnimAttacker(sprite, FALSE); + + sprite->pos2.x = Sin(sprite->data[1], 8); + sprite->pos2.y = sprite->data[2] >> 8; + sprite->data[1] = (sprite->data[1] + 7) & 0xFF; + sprite->data[2] -= 0x80; + if (sprite->data[0] == 60) + DestroyAnimSprite(sprite); +} + +void AnimTask_FakeOut(u8 taskId) +{ + u16 win0h = IsContest() ? 0x98 : 0xF0; + u16 win0v = 0; + + gBattle_WIN0H = win0h; + gBattle_WIN0V = 0xA0; + SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); + SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); + SetGpuReg(REG_OFFSET_WININ, 0x3F1F); + SetGpuReg(REG_OFFSET_WINOUT, 0x3F3F); + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_DARKEN); + SetGpuReg(REG_OFFSET_BLDY, 0x10); + gTasks[taskId].data[0] = win0v; + gTasks[taskId].data[1] = win0h; + gTasks[taskId].func = FakeOutStep1; +} + +static void FakeOutStep1(u8 taskId) +{ + gTasks[taskId].data[0] += 13; + gTasks[taskId].data[1] -= 13; + if (gTasks[taskId].data[0] >= gTasks[taskId].data[1]) + { + gBattle_WIN0H = 0; + gTasks[taskId].func = FakeOutStep2; + } + else + { + gBattle_WIN0H = gTasks[taskId].data[1] | (gTasks[taskId].data[0] << 8); + } +} + +static void FakeOutStep2(u8 taskId) +{ + if (++gTasks[taskId].data[10] == 5) + { + gTasks[taskId].data[11] = 0x88; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_LIGHTEN); + BlendPalettes(sub_80A75AC(1, 0, 0, 0, 0, 0, 0), 16, RGB(31, 31, 31)); + } + else if (gTasks[taskId].data[10] > 4) + { + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDY, 0); + DestroyAnimVisualTask(taskId); + } +} + +void sub_80A9A20(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (++gTasks[taskId].data[0] == 1) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(1), gUnknown_83E4200); + gSprites[spriteId].pos2.x = 4; + } + else + { + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos2.x; + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + { + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + DestroyAnimVisualTask(taskId); + } + } +} + +void sub_80A9AB0(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + if (++gTasks[taskId].data[0] == 1) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(0), gUnknown_83E4200); + gSprites[spriteId].pos2.x = 4; + } + else + { + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos2.x; + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + { + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + DestroyAnimVisualTask(taskId); + } + } +} + +void AnimRedHeartProjectile(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[0] = 95; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + InitAnimLinearTranslation(sprite); + sprite->callback = AnimRedHeartProjectile_Step; +} + +static void AnimRedHeartProjectile_Step(struct Sprite *sprite) +{ + if (!AnimTranslateLinear(sprite)) + { + sprite->pos2.y += Sin(sprite->data[5], 14); + sprite->data[5] = (sprite->data[5] + 4) & 0xFF; + } + else + { + DestroyAnimSprite(sprite); + } +} + +void AnimParticuleBurst(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[1] = gBattleAnimArgs[0]; + sprite->data[2] = gBattleAnimArgs[1]; + sprite->data[0]++; + } + else + { + sprite->data[4] += sprite->data[1]; + sprite->pos2.x = sprite->data[4] >> 8; + sprite->pos2.y = Sin(sprite->data[3], sprite->data[2]); + sprite->data[3] = (sprite->data[3] + 3) & 0xFF; + if (sprite->data[3] > 100) + sprite->invisible = sprite->data[3] % 2; + + if (sprite->data[3] > 120) + DestroyAnimSprite(sprite); + } +} + +void AnimRedHeartRising(struct Sprite *sprite) +{ + sprite->pos1.x = gBattleAnimArgs[0]; + sprite->pos1.y = 160; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimRedHeartRising_Step); +} + +static void AnimRedHeartRising_Step(struct Sprite *sprite) +{ + s16 y; + sprite->data[2] += sprite->data[1]; + sprite->pos2.y = -((u16)sprite->data[2] >> 8); + sprite->pos2.x = Sin(sprite->data[3], 4); + sprite->data[3] = (sprite->data[3] + 3) & 0xFF; + y = sprite->pos1.y + sprite->pos2.y; + if (y <= 72) + { + sprite->invisible = sprite->data[3] % 2; + if (y <= 64) + DestroyAnimSprite(sprite); + } +} + +void AnimTask_HeartsBackground(u8 taskId) +{ + struct BattleAnimBgData animBg; + + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 3); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; + SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); + SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); + sub_80752A0(&animBg); + AnimLoadCompressedBgGfx(animBg.bgId, &gUnknown_08C232E0, animBg.tilesOffset); + sub_80A6D60(&animBg, &gUnknown_08C23D78, 0); + LoadCompressedPalette(&gUnknown_08C23D50, animBg.paletteId * 16, 32); + gTasks[taskId].func = HeartsBackground_Step; +} + +static void HeartsBackground_Step(u8 taskId) +{ + struct BattleAnimBgData animBg; + + switch (gTasks[taskId].data[12]) + { + case 0: + if (++gTasks[taskId].data[10] == 4) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[11]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[11], 16 - gTasks[taskId].data[11])); + if (gTasks[taskId].data[11] == 16) + { + gTasks[taskId].data[12]++; + gTasks[taskId].data[11] = 0; + } + } + break; + case 1: + if (++gTasks[taskId].data[11] == 141) + { + gTasks[taskId].data[11] = 16; + gTasks[taskId].data[12]++; + } + break; + case 2: + if (++gTasks[taskId].data[10] == 4) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[11]--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[11], 16 - gTasks[taskId].data[11])); + if (gTasks[taskId].data[11] == 0) + { + gTasks[taskId].data[12]++; + gTasks[taskId].data[11] = 0; + } + } + break; + case 3: + sub_80752A0(&animBg); + sub_8075358(animBg.bgId); + gTasks[taskId].data[12]++; + break; + case 4: + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimTask_ScaryFace(u8 taskId) +{ + struct BattleAnimBgData animBg; + + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; + SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); + SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); + sub_80752A0(&animBg); + if (IsContest()) + sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFaceContest, 0); + else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) + sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFacePlayer, 0); + else + sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFaceOpponent, 0); + + AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C249F8, animBg.tilesOffset); + LoadCompressedPalette(gUnknown_08C249D0, animBg.paletteId * 16, 32); + gTasks[taskId].func = ScaryFace_Step; +} + +static void ScaryFace_Step(u8 taskId) +{ + struct BattleAnimBgData animBg; + + switch (gTasks[taskId].data[12]) + { + case 0: + if (++gTasks[taskId].data[10] == 2) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[11]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[11], 16 - gTasks[taskId].data[11])); + if (gTasks[taskId].data[11] == 14) + { + gTasks[taskId].data[12]++; + gTasks[taskId].data[11] = 0; + } + } + break; + case 1: + if (++gTasks[taskId].data[11] == 21) + { + gTasks[taskId].data[11] = 14; + gTasks[taskId].data[12]++; + } + break; + case 2: + if (++gTasks[taskId].data[10] == 2) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[11]--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[11], 16 - gTasks[taskId].data[11])); + if (gTasks[taskId].data[11] == 0) + { + gTasks[taskId].data[12]++; + gTasks[taskId].data[11] = 0; + } + } + break; + case 3: + sub_80752A0(&animBg); + sub_8075358(1); + sub_8075358(2); + gTasks[taskId].data[12]++; + // fall through + case 4: + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + DestroyAnimVisualTask(taskId); + break; + } +} + +// Orbits a sphere in an ellipse around the mon. +// Used by MOVE_HIDDEN_POWER +// arg 0: duration +// arg 1: initial wave offset +void AnimOrbitFast(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->affineAnimPaused = 1; + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[7] = GetBattlerSpriteSubpriority(gBattleAnimAttacker); + sprite->callback = AnimOrbitFastStep; + sprite->callback(sprite); +} + +static void AnimOrbitFastStep(struct Sprite *sprite) +{ + if (sprite->data[1] >= 64 && sprite->data[1] <= 191) + sprite->subpriority = sprite->data[7] + 1; + else + sprite->subpriority = sprite->data[7] - 1; + + sprite->pos2.x = Sin(sprite->data[1], sprite->data[2] >> 8); + sprite->pos2.y = Cos(sprite->data[1], sprite->data[3] >> 8); + sprite->data[1] = (sprite->data[1] + 9) & 0xFF; + switch (sprite->data[5]) + { + case 1: + sprite->data[2] -= 0x400; + sprite->data[3] -= 0x100; + if (++sprite->data[4] == sprite->data[0]) + { + sprite->data[5] = 2; + return; + } + break; + case 0: + sprite->data[2] += 0x400; + sprite->data[3] += 0x100; + if (++sprite->data[4] == sprite->data[0]) + { + sprite->data[4] = 0; + sprite->data[5] = 1; + } + break; + } + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + DestroyAnimSprite(sprite); +} + +// Moves orbs away from the mon, based on where they are in their orbit. +// Used in MOVE_HIDDEN_POWER. +// arg 0: initial wave offset +void AnimOrbitScatter(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->data[0] = Sin(gBattleAnimArgs[0], 10); + sprite->data[1] = Cos(gBattleAnimArgs[0], 7); + sprite->callback = AnimOrbitScatterStep; +} + +static void AnimOrbitScatterStep(struct Sprite *sprite) +{ + sprite->pos2.x += sprite->data[0]; + sprite->pos2.y += sprite->data[1]; + if (sprite->pos1.x + sprite->pos2.x + 16 > 272u || sprite->pos1.y + sprite->pos2.y > 160 || sprite->pos1.y + sprite->pos2.y < -16) + DestroyAnimSprite(sprite); +} + +static void AnimSpitUpOrb_Step(struct Sprite *sprite) +{ + sprite->pos2.x += sprite->data[0]; + sprite->pos2.y += sprite->data[1]; + if (sprite->data[3]++ >= sprite->data[2]) + DestroyAnimSprite(sprite); +} + +void AnimSpitUpOrb(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->data[0] = Sin(gBattleAnimArgs[0], 10); + sprite->data[1] = Cos(gBattleAnimArgs[0], 7); + sprite->data[2] = gBattleAnimArgs[1]; + sprite->callback = AnimSpitUpOrb_Step; +} + +static void sub_80AA3D4(struct Sprite *sprite) +{ + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimEyeSparkle(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->callback = sub_80AA3D4; +} + +void AnimAngel(struct Sprite *sprite) +{ + s16 var0; + if (!sprite->data[0]) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + + sprite->data[0]++; + var0 = (sprite->data[0] * 10) & 0xFF; + sprite->pos2.x = Sin(var0, 80) >> 8; + if (sprite->data[0] < 80) + sprite->pos2.y = (sprite->data[0] / 2) + (Cos(var0, 80) >> 8); + + if (sprite->data[0] > 90) + { + sprite->data[2]++; + sprite->pos2.x -= sprite->data[2] / 2; + } + + if (sprite->data[0] > 100) + DestroyAnimSprite(sprite); +} + +static void sub_80AA49C(struct Sprite *sprite) +{ + sprite->data[5]++; + sprite->pos2.x = Sin(sprite->data[3], 5); + sprite->pos2.y = sprite->data[5] / 2; + sprite->data[3] = (sprite->data[3] + 3) & 0xFF; + if (sprite->data[5] > 20) + sprite->invisible = sprite->data[5] % 2; + + if (sprite->data[5] > 30) + DestroyAnimSprite(sprite); +} + +void AnimPinkHeart(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[1] = gBattleAnimArgs[0]; + sprite->data[2] = gBattleAnimArgs[1]; + sprite->data[0]++; + } + else + { + sprite->data[4] += sprite->data[1]; + sprite->pos2.x = sprite->data[4] >> 8; + sprite->pos2.y = Sin(sprite->data[3], sprite->data[2]); + sprite->data[3] = (sprite->data[3] + 3) & 0xFF; + if (sprite->data[3] > 70) + { + sprite->callback = sub_80AA49C; + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[3] = Random2() % 180; + } + } +} + +void AnimDevil(struct Sprite *sprite) +{ + if (sprite->data[3] == 0) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + StartSpriteAnim(sprite, 0); + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) - 1; + sprite->data[2] = 1; + } + sprite->data[0] += sprite->data[2]; + sprite->data[1] = (sprite->data[0] * 4) % 256; + if (sprite->data[1] < 0) + sprite->data[1] = 0; + sprite->pos2.x = Cos(sprite->data[1], 30 - sprite->data[0] / 4); + sprite->pos2.y = Sin(sprite->data[1], 10 - sprite->data[0] / 8); + if (sprite->data[1] > 128 && sprite->data[2] > 0) + sprite->data[2] = -1; + if (sprite->data[1] == 0 && sprite->data[2] < 0) + sprite->data[2] = 1; + sprite->data[3]++; + if (sprite->data[3] < 10 || sprite->data[3] > 80) + sprite->invisible = sprite->data[0] % 2; + else + sprite->invisible = FALSE; + if (sprite->data[3] > 90) + DestroyAnimSprite(sprite); +} + +void AnimFurySwipes(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + StartSpriteAnim(sprite, gBattleAnimArgs[2]); + sprite->data[0]++; + } + else if (sprite->animEnded) + { + DestroyAnimSprite(sprite); + } +} + +void AnimMovmentWaves(struct Sprite *sprite) +{ + if (!gBattleAnimArgs[2]) + { + DestroyAnimSprite(sprite); + } + else + { + if (!gBattleAnimArgs[0]) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + } + + if (!gBattleAnimArgs[1]) + sprite->pos1.x += 32; + else + sprite->pos1.x -= 32; + + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[1]; + StartSpriteAnim(sprite, sprite->data[1]); + sprite->callback = AnimMovmentWaves_Step; + } +} + +static void AnimMovmentWaves_Step(struct Sprite *sprite) +{ + if (sprite->animEnded) + { + if (--sprite->data[0]) + StartSpriteAnim(sprite, sprite->data[1]); + else + DestroyAnimSprite(sprite); + } +} + +void AnimTask_UproarDistortion(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + + PrepareAffineAnimInTaskData(&gTasks[taskId], spriteId, gUnknown_08593B98); + gTasks[taskId].func = UproarDistortion_Step; +} + +static void UproarDistortion_Step(u8 taskId) +{ + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); +} + +void AnimJaggedMusicNote(struct Sprite *sprite) +{ + int var1; + u8 battler = !gBattleAnimArgs[0] ? gBattleAnimAttacker : gBattleAnimTarget; + + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + gBattleAnimArgs[1] *= -1; + + sprite->pos1.x = GetBattlerSpriteCoord(battler, 2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[2]; + sprite->data[0] = 0; + sprite->data[1] = (u16)sprite->pos1.x << 3; + sprite->data[2] = (u16)sprite->pos1.y << 3; + + var1 = gBattleAnimArgs[1] << 3; + if (var1 < 0) + var1 += 7; + sprite->data[3] = var1 >> 3; + + var1 = gBattleAnimArgs[2] << 3; + if (var1 < 0) + var1 += 7; + sprite->data[4] = var1 >> 3; + + sprite->oam.tileNum += gBattleAnimArgs[3] * 16; + sprite->callback = AnimJaggedMusicNote_Step; +} + +static void AnimJaggedMusicNote_Step(struct Sprite *sprite) +{ + sprite->data[1] += sprite->data[3]; + sprite->data[2] += sprite->data[4]; + sprite->pos1.x = sprite->data[1] >> 3; + sprite->pos1.y = sprite->data[2] >> 3; + if (++sprite->data[0] > 16) + DestroyAnimSprite(sprite); +} + +void AnimPerishSongMusicNote2(struct Sprite *sprite) +{ + if (!sprite->data[0]) + { + sprite->data[1] = 120 - gBattleAnimArgs[0]; + sprite->invisible = 1; + } + + if (++sprite->data[0] == sprite->data[1]) + SetGreyscaleOrOriginalPalette(sprite->oam.paletteNum + 16, 0); + + if (sprite->data[0] == sprite->data[1] + 80) + DestroyAnimSprite(sprite); +} + +void AnimPerishSongMusicNote(struct Sprite *sprite) +{ + int index; + int var2; + + if (!sprite->data[0]) + { + sprite->pos1.x = 120; + sprite->pos1.y = (gBattleAnimArgs[0] + (((u16)gBattleAnimArgs[0]) >> 31)) / 2 - 15; + + StartSpriteAnim(sprite, gBattleAnimArgs[1]); + + sprite->data[5] = 120; + sprite->data[3] = gBattleAnimArgs[2]; + } + + sprite->data[0]++; + + sprite->data[1] = (sprite->data[0] + ((u16)sprite->data[0] >> 31)) / 2; + index = ((sprite->data[0] * 3) + (u16)sprite->data[3]); + var2 = 0xFF; + sprite->data[6] = (sprite->data[6] + 10) & 0xFF; + + index &= var2; + sprite->pos2.x = Cos(index, 100); + + sprite->pos2.y = sprite->data[1] + Sin(index, 10) + Cos(sprite->data[6], 4); + + if (sprite->data[0] > sprite->data[5]) + { + sprite->callback = AnimPerishSongMusicNote_Step1; + + sprite->data[0] = 0; + SetSpritePrimaryCoordsFromSecondaryCoords(sprite); + sprite->data[2] = 5; + sprite->data[4] = 0; + sprite->data[3] = 0; + + StartSpriteAffineAnim(sprite, 1); + } +} + +static void AnimPerishSongMusicNote_Step1(struct Sprite *sprite) +{ + if (++sprite->data[0] > 10) + { + sprite->data[0] = 0; + sprite->callback = AnimPerishSongMusicNote_Step2; + } +} + +static void AnimPerishSongMusicNote_Step2(struct Sprite *sprite) +{ + sprite->data[3] += sprite->data[2]; + sprite->pos2.y = sprite->data[3]; + + sprite->data[2]++; + + if (sprite->data[3] > 48 && sprite->data[2] > 0) + { + sprite->data[2] = sprite->data[4] - 5; + sprite->data[4]++; + } + + if (sprite->data[4] > 3) + { + int var1 = sprite->data[2]; + sprite->invisible = var1 - (((s32)(var1 + ((u32)var1 >> 31)) >> 1) << 1); + DestroyAnimSprite(sprite); + } + + if (sprite->data[4] == 4) + { + DestroyAnimSprite(sprite); + } +} + +void AnimGuardRing(struct Sprite *sprite) +{ + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) && IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker))) + { + SetAverageBattlerPositions(gBattleAnimAttacker, 0, &sprite->pos1.x, &sprite->pos1.y); + sprite->pos1.y += 40; + + StartSpriteAffineAnim(sprite, 1); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + 40; + } + + sprite->data[0] = 13; + sprite->data[2] = sprite->pos1.x; + sprite->data[4] = sprite->pos1.y - 72; + + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimTask_IsFuryCutterHitRight(u8 taskId) +{ + gBattleAnimArgs[7] = gAnimDisableStructPtr->furyCutterCounter & 1; + DestroyAnimVisualTask(taskId); +} + +void AnimTask_GetFuryCutterHitCount(u8 taskId) +{ + gBattleAnimArgs[7] = gAnimDisableStructPtr->furyCutterCounter; + DestroyAnimVisualTask(taskId); +} diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c new file mode 100644 index 000000000..89f66139f --- /dev/null +++ b/src/battle_anim_effects_3.c @@ -0,0 +1,5495 @@ +#include "global.h" +#include "malloc.h" +#include "battle.h" +#include "battle_anim.h" +#include "bg.h" +#include "contest.h" +#include "data.h" +#include "decompress.h" +#include "dma3.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "palette.h" +#include "pokemon_icon.h" +#include "random.h" +#include "scanline_effect.h" +#include "sound.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" +#include "util.h" +#include "constants/battle_anim.h" +#include "constants/rgb.h" +#include "constants/songs.h" +#include "constants/species.h" +#include "constants/weather.h" + +extern const struct SpriteTemplate gThoughtBubbleSpriteTemplate; + +void AnimBlackSmoke(struct Sprite *); +void AnimWhiteHalo(struct Sprite *); +void AnimTealAlert(struct Sprite *); +void AnimMeanLookEye(struct Sprite *); +void AnimSpikes(struct Sprite *); +void AnimLeer(struct Sprite *); +void AnimLetterZ(struct Sprite *); +void AnimFang(struct Sprite *); +void AnimSpotlight(struct Sprite *); +void AnimClappingHand(struct Sprite *); +void AnimClappingHand2(struct Sprite *); +void AnimRapidSpin(struct Sprite *); +void AnimTriAttackTriangle(struct Sprite *); +void AnimBatonPassPokeball(struct Sprite *); +void AnimWishStar(struct Sprite *); +void AnimMiniTwinklingStar(struct Sprite *); +void AnimSwallowBlueOrb(struct Sprite *); +void AnimGreenStar(struct Sprite *); +void AnimWeakFrustrationAngerMark(struct Sprite *); +void AnimSweetScentPetal(struct Sprite *); +void AnimPainSplitProjectile(struct Sprite *); +void AnimFlatterConfetti(struct Sprite *); +void AnimFlatterSpotlight(struct Sprite *); +void AnimReversalOrb(struct Sprite *); +void AnimYawnCloud(struct Sprite *); +void AnimSmokeBallEscapeCloud(struct Sprite *); +void AnimFacadeSweatDrop(struct Sprite *); +void AnimRoarNoiseLine(struct Sprite *); +void AnimGlareEyeDot(struct Sprite *); +void AnimAssistPawprint(struct Sprite *); +void AnimSmellingSaltsHand(struct Sprite *); +void AnimSmellingSaltExclamation(struct Sprite *); +void AnimHelpingHandClap(struct Sprite *); +void AnimForesightMagnifyingGlass(struct Sprite *); +void AnimMeteorMashStar(struct Sprite *); +void AnimBlockX(struct Sprite *); +void sub_80E3E84(struct Sprite *); +void AnimParticuleBurst(struct Sprite *); +void AnimKnockOffStrike(struct Sprite *); +void AnimRecycle(struct Sprite *); +static void AnimBlackSmokeStep(struct Sprite *); +static void AnimWhiteHalo_Step1(struct Sprite *); +static void AnimWhiteHalo_Step2(struct Sprite *); +static void AnimMeanLookEye_Step1(struct Sprite *); +static void AnimMeanLookEye_Step2(struct Sprite *); +static void AnimMeanLookEye_Step3(struct Sprite *); +static void AnimMeanLookEye_Step4(struct Sprite *); +static void SetPsychicBackground_Step(u8); +static void FadeScreenToWhite_Step(u8); +static void AnimSpikes_Step1(struct Sprite *); +static void AnimSpikes_Step2(struct Sprite *); +static void AnimSpotlight_Step1(struct Sprite *); +static void AnimSpotlight_Step2(struct Sprite *); +static void AnimClappingHand_Step(struct Sprite *); +static void AnimRapidSpin_Step(struct Sprite *); +static void RapinSpinMonElevation_Step(u8); +static void TormentAttacker_Step(u8); +static void TormentAttacker_Callback(struct Sprite *); +static void AnimWishStar_Step(struct Sprite *); +static void AnimMiniTwinklingStar_Step(struct Sprite *); +static void AnimGreenStar_Step1(struct Sprite *); +static void AnimGreenStar_Step2(struct Sprite *); +static void AnimGreenStar_Callback(struct Sprite *); +static void AnimTask_RockMonBackAndForthStep(u8); +static void AnimSweetScentPetalStep(struct Sprite *); +static void AnimTask_FlailMovementStep(u8); +static void AnimFlatterConfettiStep(struct Sprite *); +static void AnimFlatterSpotlightStep(struct Sprite *); +static void AnimReversalOrbStep(struct Sprite *); +static void AnimTask_RolePlaySilhouetteStep1(u8); +static void AnimTask_RolePlaySilhouetteStep2(u8); +static void AnimTask_AcidArmorStep(u8); +static void AnimTask_DeepInhaleStep(u8); +static void AnimYawnCloudStep(struct Sprite *); +static void AnimTask_SquishAndSweatDropletsStep(u8); +static void CreateSweatDroplets(u8, bool8); +static void AnimTask_FacadeColorBlendStep(u8); +static void AnimRoarNoiseLineStep(struct Sprite *); +static void AnimTask_GlareEyeDotsStep(u8); +static void GetGlareEyeDotCoords(s16, s16, s16, s16, u8, u8, s16 *, s16 *); +static void AnimTask_BarrageBallStep(u8); +static void AnimSmellingSaltsHand_Step(struct Sprite *); +static void AnimTask_SmellingSaltsSquishStep(u8); +static void AnimSmellingSaltExclamationStep(struct Sprite *); +static void AnimHelpingHandClapStep(struct Sprite *); +static void AnimTask_HelpingHandAttackerMovementStep(u8); +static void AnimForesightMagnifyingGlassStep(struct Sprite *); +static void AnimTask_MonToSubstituteDoll(u8); +static void AnimBlockXStep(struct Sprite *); +static void AnimTask_OdorSleuthMovementWaitFinish(u8); +static void MoveOdorSleuthClone(struct Sprite *); +static void AnimTask_TeeterDanceMovementStep(u8); +static void AnimRecycleStep(struct Sprite *); +static void AnimTask_SlackOffSquishStep(u8); +const union AnimCmd gScratchAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_FRAME(64, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gScratchAnimTable[] = +{ + gScratchAnimCmds, +}; + +const struct SpriteTemplate gScratchSpriteTemplate = +{ + .tileTag = ANIM_TAG_SCRATCH, + .paletteTag = ANIM_TAG_SCRATCH, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gScratchAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const struct SpriteTemplate gBlackSmokeSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLACK_SMOKE, + .paletteTag = ANIM_TAG_BLACK_SMOKE, + .oam = &gOamData_AffineOff_ObjNormal_32x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBlackSmoke, +}; + +const struct SpriteTemplate gBlackBallSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLACK_BALL, + .paletteTag = ANIM_TAG_BLACK_BALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimThrowProjectile, +}; + +const union AnimCmd gOpeningEyeAnimCmds[] = +{ + ANIMCMD_FRAME(0, 40), + ANIMCMD_FRAME(16, 8), + ANIMCMD_FRAME(32, 40), + ANIMCMD_END, +}; + +const union AnimCmd *const gOpeningEyeAnimTable[] = +{ + gOpeningEyeAnimCmds, +}; + +const struct SpriteTemplate gOpeningEyeSpriteTemplate = +{ + .tileTag = ANIM_TAG_OPENING_EYE, + .paletteTag = ANIM_TAG_OPENING_EYE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gOpeningEyeAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const struct SpriteTemplate gWhiteHaloSpriteTemplate = +{ + .tileTag = ANIM_TAG_ROUND_WHITE_HALO, + .paletteTag = ANIM_TAG_ROUND_WHITE_HALO, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWhiteHalo, +}; + +const struct SpriteTemplate gTealAlertSpriteTemplate = +{ + .tileTag = ANIM_TAG_TEAL_ALERT, + .paletteTag = ANIM_TAG_TEAL_ALERT, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimTealAlert, +}; + +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x180, 0x180, 0, 0), + AFFINEANIMCMD_FRAME(-0x20, 0x18, 0, 5), + AFFINEANIMCMD_FRAME(0x18, -0x20, 0, 5), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x30, 0x30, 0, 0), + AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 6), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = +{ + gMeanLookEyeAffineAnimCmds1, + gMeanLookEyeAffineAnimCmds2, +}; + +const struct SpriteTemplate gMeanLookEyeSpriteTemplate = +{ + .tileTag = ANIM_TAG_EYE, + .paletteTag = ANIM_TAG_EYE, + .oam = &gOamData_AffineDouble_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gMeanLookEyeAffineAnimTable, + .callback = AnimMeanLookEye, +}; + +const struct SpriteTemplate gSpikesSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPIKES, + .paletteTag = ANIM_TAG_SPIKES, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpikes, +}; + +const union AnimCmd gLeerAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(64, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gLeerAnimTable[] = +{ + gLeerAnimCmds, +}; + +const struct SpriteTemplate gLeerSpriteTemplate = +{ + .tileTag = ANIM_TAG_LEER, + .paletteTag = ANIM_TAG_LEER, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gLeerAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimLeer, +}; + +const union AnimCmd gLetterZAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_END, +}; + +const union AnimCmd *const gLetterZAnimTable[] = +{ + gLetterZAnimCmds, +}; + +const union AffineAnimCmd gLetterZAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-7, -7, -3, 16), + AFFINEANIMCMD_FRAME(7, 7, 3, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gLetterZAffineAnimTable[] = +{ + gLetterZAffineAnimCmds, +}; + +const struct SpriteTemplate gLetterZSpriteTemplate = +{ + .tileTag = ANIM_TAG_LETTER_Z, + .paletteTag = ANIM_TAG_LETTER_Z, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gLetterZAnimTable, + .images = NULL, + .affineAnims = gLetterZAffineAnimTable, + .callback = AnimLetterZ, +}; + +const union AnimCmd gFangAnimCmds[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(16, 16), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(48, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gFangAnimTable[] = +{ + gFangAnimCmds, +}; + +const union AffineAnimCmd gFangAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), + AFFINEANIMCMD_FRAME(-0x20, -0x20, 0, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gFangAffineAnimTable[] = +{ + gFangAffineAnimCmds, +}; + +const struct SpriteTemplate gFangSpriteTemplate = +{ + .tileTag = ANIM_TAG_FANG_ATTACK, + .paletteTag = ANIM_TAG_FANG_ATTACK, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, + .anims = gFangAnimTable, + .images = NULL, + .affineAnims = gFangAffineAnimTable, + .callback = AnimFang, +}; + +const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x180, 0, 0), + AFFINEANIMCMD_FRAME(0x10, 0x0, 0, 20), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x140, 0x180, 0, 0), + AFFINEANIMCMD_FRAME(-0x10, 0x0, 0, 19), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = +{ + gSpotlightAffineAnimCmds1, + gSpotlightAffineAnimCmds2, +}; + +const struct SpriteTemplate gSpotlightSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPOTLIGHT, + .paletteTag = ANIM_TAG_SPOTLIGHT, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSpotlightAffineAnimTable, + .callback = AnimSpotlight, +}; + +const struct SpriteTemplate gClappingHandSpriteTemplate = +{ + .tileTag = ANIM_TAG_TAG_HAND, + .paletteTag = ANIM_TAG_TAG_HAND, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimClappingHand, +}; + +const struct SpriteTemplate gClappingHand2SpriteTemplate = +{ + .tileTag = ANIM_TAG_TAG_HAND, + .paletteTag = ANIM_TAG_TAG_HAND, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimClappingHand2, +}; + +const union AnimCmd gRapidSpinAnimCmds[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(8, 2), + ANIMCMD_FRAME(16, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gRapidSpinAnimTable[] = +{ + gRapidSpinAnimCmds, +}; + +const struct SpriteTemplate gRapidSpinSpriteTemplate = +{ + .tileTag = ANIM_TAG_RAPID_SPIN, + .paletteTag = ANIM_TAG_RAPID_SPIN, + .oam = &gOamData_AffineOff_ObjNormal_32x16, + .anims = gRapidSpinAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRapidSpin, +}; + +const union AffineAnimCmd gUnknown_085CE2A0[] = +{ + AFFINEANIMCMD_FRAME(-12, 8, 0, 4), + AFFINEANIMCMD_FRAME(20, -20, 0, 4), + AFFINEANIMCMD_FRAME(-8, 12, 0, 4), + AFFINEANIMCMD_END, +}; + +const union AnimCmd gTriAttackTriangleAnimCmds[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_END, +}; + +const union AnimCmd *const gTriAttackTriangleAnimTable[] = +{ + gTriAttackTriangleAnimCmds, +}; + +const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 0, 5, 40), + AFFINEANIMCMD_FRAME(0, 0, 10, 10), + AFFINEANIMCMD_FRAME(0, 0, 15, 10), + AFFINEANIMCMD_FRAME(0, 0, 20, 40), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = +{ + gTriAttackTriangleAffineAnimCmds, +}; + +const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = +{ + .tileTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, + .paletteTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, + .anims = gTriAttackTriangleAnimTable, + .images = NULL, + .affineAnims = gTriAttackTriangleAffineAnimTable, + .callback = AnimTriAttackTriangle, +}; + +const union AnimCmd gEclipsingOrbAnimCmds[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(32, 3, .hFlip = TRUE), + ANIMCMD_FRAME(16, 3, .hFlip = TRUE), + ANIMCMD_FRAME(0, 3, .hFlip = TRUE), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd *const gEclipsingOrbAnimTable[] = +{ + gEclipsingOrbAnimCmds, +}; + +const struct SpriteTemplate gEclipsingOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_ECLIPSING_ORB, + .paletteTag = ANIM_TAG_ECLIPSING_ORB, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gEclipsingOrbAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSpriteOnMonPos, +}; + +const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-12, 20, 0, 8), + AFFINEANIMCMD_FRAME(12, -20, 0, 8), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = +{ + .tileTag = ANIM_TAG_POKEBALL, + .paletteTag = ANIM_TAG_POKEBALL, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBatonPassPokeball, +}; + +const struct SpriteTemplate gWishStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_GOLD_STARS, + .paletteTag = ANIM_TAG_GOLD_STARS, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWishStar, +}; + +const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_GOLD_STARS, + .paletteTag = ANIM_TAG_GOLD_STARS, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMiniTwinklingStar, +}; + +const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(8, -8, 0, 12), + AFFINEANIMCMD_FRAME(-16, 16, 0, 12), + AFFINEANIMCMD_FRAME(8, -8, 0, 12), + AFFINEANIMCMD_LOOP(1), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 6, 0, 20), + AFFINEANIMCMD_FRAME(0, 0, 0, 20), + AFFINEANIMCMD_FRAME(0, -18, 0, 6), + AFFINEANIMCMD_FRAME(-18, -18, 0, 3), + AFFINEANIMCMD_FRAME(0, 0, 0, 15), + AFFINEANIMCMD_FRAME(4, 4, 0, 13), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLUE_ORB, + .paletteTag = ANIM_TAG_BLUE_ORB, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSwallowBlueOrb, +}; + +const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 6, 0, 20), + AFFINEANIMCMD_FRAME(0, 0, 0, 20), + AFFINEANIMCMD_FRAME(7, -30, 0, 6), + AFFINEANIMCMD_FRAME(0, 0, 0, 20), + AFFINEANIMCMD_FRAME(-2, 3, 0, 20), + AFFINEANIMCMD_END, +}; + +const s8 gMorningSunLightBeamCoordsTable[] = +{ + 0xE8, + 0x18, + 0xFC, + 0x00, +}; + +const union AnimCmd gGreenStarAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(4, 6), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gGreenStarAnimCmds2[] = +{ + ANIMCMD_FRAME(8, 6), + ANIMCMD_END, +}; + +const union AnimCmd gGreenStarAnimCmds3[] = +{ + ANIMCMD_FRAME(12, 6), + ANIMCMD_END, +}; + +const union AnimCmd *const gGreenStarAnimTable[] = +{ + gGreenStarAnimCmds1, + gGreenStarAnimCmds2, + gGreenStarAnimCmds3, +}; + +const struct SpriteTemplate gGreenStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_GREEN_STAR, + .paletteTag = ANIM_TAG_GREEN_STAR, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gGreenStarAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimGreenStar, +}; + +const s8 gDoomDesireLightBeamCoordTable[] = +{ + 0x78, + 0x50, + 0x28, + 0x00, +}; + +const u8 gDoomDesireLightBeamDelayTable[] = +{ + 0, + 0, + 0, + 0, + 50, +}; + +const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, -15, 0, 7), + AFFINEANIMCMD_FRAME(0, 15, 0, 7), + AFFINEANIMCMD_LOOP(2), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = +{ + .tileTag = ANIM_TAG_ANGER, + .paletteTag = ANIM_TAG_ANGER, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimWeakFrustrationAngerMark, +}; + +const union AnimCmd gSweetScentPetalAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(3, 8), + ANIMCMD_FRAME(3, 8, .vFlip = TRUE), + ANIMCMD_FRAME(2, 8, .vFlip = TRUE), + ANIMCMD_FRAME(0, 8, .vFlip = TRUE), + ANIMCMD_FRAME(1, 8, .vFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gSweetScentPetalAnimCmds2[] = +{ + ANIMCMD_FRAME(0, 8, .hFlip = TRUE), + ANIMCMD_FRAME(1, 8, .hFlip = TRUE), + ANIMCMD_FRAME(2, 8, .hFlip = TRUE), + ANIMCMD_FRAME(3, 8, .hFlip = TRUE), + ANIMCMD_FRAME(3, 8, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(2, 8, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(0, 8, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_FRAME(1, 8, .vFlip = TRUE, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gSweetScentPetalAnimCmds3[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_END, +}; + +const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = +{ + gSweetScentPetalAnimCmds1, + gSweetScentPetalAnimCmds2, + gSweetScentPetalAnimCmds3, +}; + +const struct SpriteTemplate gSweetScentPetalSpriteTemplate = +{ + .tileTag = ANIM_TAG_PINK_PETAL, + .paletteTag = ANIM_TAG_PINK_PETAL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gSweetScentPetalAnimCmdTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSweetScentPetal, +}; + +const u16 gUnknown_085CE55C[] = INCBIN_U16("graphics/unknown/unknown_85CE55C.gbapal"); + +const union AnimCmd gPainSplitAnimCmds[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_FRAME(4, 9), + ANIMCMD_FRAME(8, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gPainSplitAnimCmdTable[] = +{ + gPainSplitAnimCmds, +}; + +const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = +{ + .tileTag = ANIM_TAG_PAIN_SPLIT, + .paletteTag = ANIM_TAG_PAIN_SPLIT, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gPainSplitAnimCmdTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimPainSplitProjectile, +}; + +const struct SpriteTemplate gFlatterConfettiSpriteTemplate = +{ + .tileTag = ANIM_TAG_CONFETTI, + .paletteTag = ANIM_TAG_CONFETTI, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFlatterConfetti, +}; + +const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = +{ + .tileTag = ANIM_TAG_SPOTLIGHT, + .paletteTag = ANIM_TAG_SPOTLIGHT, + .oam = &gOamData_AffineDouble_ObjNormal_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSpotlightAffineAnimTable, + .callback = AnimFlatterSpotlight, +}; + +const struct SpriteTemplate gReversalOrbSpriteTemplate = +{ + .tileTag = ANIM_TAG_BLUE_ORB, + .paletteTag = ANIM_TAG_BLUE_ORB, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimReversalOrb, +}; + +const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(16, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, -3, 0, 16), + AFFINEANIMCMD_FRAME(4, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 24), + AFFINEANIMCMD_FRAME(-5, 3, 0, 16), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), + AFFINEANIMCMD_FRAME(-8, -8, 0, 8), + AFFINEANIMCMD_FRAME(8, 8, 0, 8), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), + AFFINEANIMCMD_FRAME(8, 8, 0, 8), + AFFINEANIMCMD_FRAME(-8, -8, 0, 8), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(8, 8, 0, 8), + AFFINEANIMCMD_FRAME(-8, -8, 0, 8), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = +{ + gYawnCloudAffineAnimCmds1, + gYawnCloudAffineAnimCmds2, + gYawnCloudAffineAnimCmds3, +}; + +const struct SpriteTemplate gYawnCloudSpriteTemplate = +{ + .tileTag = ANIM_TAG_PINK_CLOUD, + .paletteTag = ANIM_TAG_PINK_CLOUD, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gYawnCloudAffineAnimTable, + .callback = AnimYawnCloud, +}; + +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), + AFFINEANIMCMD_FRAME(-4, -6, 0, 16), + AFFINEANIMCMD_FRAME(4, 6, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), + AFFINEANIMCMD_FRAME(4, 6, 0, 16), + AFFINEANIMCMD_FRAME(-4, -6, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(4, 6, 0, 16), + AFFINEANIMCMD_FRAME(-4, -6, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(8, 10, 0, 30), + AFFINEANIMCMD_FRAME(-8, -10, 0, 16), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = +{ + gSmokeBallEscapeCloudAffineAnimCmds1, + gSmokeBallEscapeCloudAffineAnimCmds2, + gSmokeBallEscapeCloudAffineAnimCmds3, + gSmokeBallEscapeCloudAffineAnimCmds4, +}; + +const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = +{ + .tileTag = ANIM_TAG_PINK_CLOUD, + .paletteTag = ANIM_TAG_PINK_CLOUD, + .oam = &gOamData_AffineDouble_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gSmokeBallEscapeCloudAffineAnimTable, + .callback = AnimSmokeBallEscapeCloud, +}; + +const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(-16, 16, 0, 6), + AFFINEANIMCMD_FRAME(16, -16, 0, 12), + AFFINEANIMCMD_FRAME(-16, 16, 0, 6), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = +{ + .tileTag = ANIM_TAG_SWEAT_DROP, + .paletteTag = ANIM_TAG_SWEAT_DROP, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimFacadeSweatDrop, +}; + +const u16 gFacadeBlendColors[] = { + RGB(28, 25, 1), + RGB(28, 21, 5), + RGB(27, 18, 8), + RGB(27, 14, 11), + RGB(26, 10, 15), + RGB(26, 7, 18), + RGB(25, 3, 21), + RGB(25, 0, 25), + RGB(25, 0, 23), + RGB(25, 0, 20), + RGB(25, 0, 16), + RGB(25, 0, 13), + RGB(26, 0, 10), + RGB(26, 0, 6), + RGB(26, 0, 3), + RGB(27, 0, 0), + RGB(27, 1, 0), + RGB(27, 5, 0), + RGB(27, 9, 0), + RGB(27, 12, 0), + RGB(28, 16, 0), + RGB(28, 19, 0), + RGB(28, 23, 0), + RGB(29, 27, 0), +}; + +const union AnimCmd gRoarNoiseLineAnimCmds1[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gRoarNoiseLineAnimCmds2[] = +{ + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gRoarNoiseLineAnimTable[] = +{ + gRoarNoiseLineAnimCmds1, + gRoarNoiseLineAnimCmds2, +}; + +const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = +{ + .tileTag = ANIM_TAG_NOISE_LINE, + .paletteTag = ANIM_TAG_NOISE_LINE, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gRoarNoiseLineAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimRoarNoiseLine, +}; + +const struct SpriteTemplate gGlareEyeDotSpriteTemplate = +{ + .tileTag = ANIM_TAG_SMALL_RED_EYE, + .paletteTag = ANIM_TAG_SMALL_RED_EYE, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimGlareEyeDot, +}; + +const struct SpriteTemplate gAssistPawprintSpriteTemplate = +{ + .tileTag = ANIM_TAG_PAW_PRINT, + .paletteTag = ANIM_TAG_PAW_PRINT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimAssistPawprint, +}; + +const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0, 0, -4, 24), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), + AFFINEANIMCMD_FRAME(0, 0, 4, 24), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = +{ + gBarrageBallAffineAnimCmds1, + gBarrageBallAffineAnimCmds2, +}; + +const struct SpriteTemplate gBarrageBallSpriteTemplate = +{ + .tileTag = ANIM_TAG_RED_BALL, + .paletteTag = ANIM_TAG_RED_BALL, + .oam = &gOamData_AffineNormal_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gBarrageBallAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = +{ + .tileTag = ANIM_TAG_TAG_HAND, + .paletteTag = ANIM_TAG_TAG_HAND, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSmellingSaltsHand, +}; + +const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, -16, 0, 6), + AFFINEANIMCMD_FRAME(0, 16, 0, 6), + AFFINEANIMCMD_END, +}; + +const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = +{ + .tileTag = ANIM_TAG_SMELLINGSALT_EFFECT, + .paletteTag = ANIM_TAG_SMELLINGSALT_EFFECT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimSmellingSaltExclamation, +}; + +const struct SpriteTemplate gHelpingHandClapSpriteTemplate = +{ + .tileTag = ANIM_TAG_TAG_HAND, + .paletteTag = ANIM_TAG_TAG_HAND, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimHelpingHandClap, +}; + +const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = +{ + .tileTag = ANIM_TAG_MAGNIFYING_GLASS, + .paletteTag = ANIM_TAG_MAGNIFYING_GLASS, + .oam = &gOamData_AffineOff_ObjBlend_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimForesightMagnifyingGlass, +}; + +const struct SpriteTemplate gMeteorMashStarSpriteTemplate = +{ + .tileTag = ANIM_TAG_GOLD_STARS, + .paletteTag = ANIM_TAG_GOLD_STARS, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimMeteorMashStar, +}; + +const struct SpriteTemplate gUnknown_085CE8F4 = +{ + .tileTag = ANIM_TAG_GOLD_STARS, + .paletteTag = ANIM_TAG_GOLD_STARS, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimParticuleBurst, +}; + +const struct SpriteTemplate gBlockXSpriteTemplate = +{ + .tileTag = ANIM_TAG_X_SIGN, + .paletteTag = ANIM_TAG_X_SIGN, + .oam = &gOamData_AffineOff_ObjNormal_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = AnimBlockX, +}; + +const struct SpriteTemplate gUnknown_085CE924 = +{ + .tileTag = ANIM_TAG_ITEM_BAG, + .paletteTag = ANIM_TAG_ITEM_BAG, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_815FE80, +}; + +const union AnimCmd gKnockOffStrikeAnimCmds[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(64, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gKnockOffStrikeAnimTable[] = +{ + gKnockOffStrikeAnimCmds, +}; + +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, -4, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = +{ + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, 4, 8), + AFFINEANIMCMD_END, +}; + +const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = +{ + gKnockOffStrikeAffineanimCmds1, + gKnockOffStrikeAffineanimCmds2, +}; + +const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = +{ + .tileTag = ANIM_TAG_SLAM_HIT_2, + .paletteTag = ANIM_TAG_SLAM_HIT_2, + .oam = &gOamData_AffineNormal_ObjNormal_64x64, + .anims = gKnockOffStrikeAnimTable, + .images = NULL, + .affineAnims = gKnockOffStrikeAffineAnimTable, + .callback = AnimKnockOffStrike, +}; + +const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 0, -4, 64), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = +{ + gRecycleSpriteAffineAnimCmds, +}; + +const struct SpriteTemplate gRecycleSpriteTemplate = +{ + .tileTag = ANIM_TAG_RECYCLE, + .paletteTag = ANIM_TAG_RECYCLE, + .oam = &gOamData_AffineNormal_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gRecycleSpriteAffineAnimTable, + .callback = AnimRecycle, +}; + +const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = +{ + AFFINEANIMCMD_FRAME(0, 16, 0, 4), + AFFINEANIMCMD_FRAME(-2, 0, 0, 8), + AFFINEANIMCMD_FRAME(0, 4, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 24), + AFFINEANIMCMD_FRAME(1, -5, 0, 16), + AFFINEANIMCMD_END, +}; + +// Functions +void AnimBlackSmoke(struct Sprite *sprite) +{ + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + + if (!gBattleAnimArgs[3]) + sprite->data[0] = gBattleAnimArgs[2]; + else + sprite->data[0] = -gBattleAnimArgs[2]; + + sprite->data[1] = gBattleAnimArgs[4]; + sprite->callback = AnimBlackSmokeStep; +} + +static void AnimBlackSmokeStep(struct Sprite *sprite) +{ + if (sprite->data[1] > 0) + { + sprite->pos2.x = sprite->data[2] >> 8; + sprite->data[2] += sprite->data[0]; + sprite->invisible ^= 1; + sprite->data[1]--; + } + else + { + DestroyAnimSprite(sprite); + } +} + +void AnimTask_SmokescreenImpact(u8 taskId) +{ + SmokescreenImpact( + GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 8, + GetBattlerSpriteCoord(gBattleAnimTarget, 3) + 8, + 0); + DestroyAnimVisualTask(taskId); +} + +void AnimWhiteHalo(struct Sprite *sprite) +{ + sprite->data[0] = 90; + sprite->callback = WaitAnimForDuration; + sprite->data[1] = 7; + StoreSpriteCallbackInData6(sprite, AnimWhiteHalo_Step1); + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[1], 16 - sprite->data[1])); +} + +static void AnimWhiteHalo_Step1(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[1], 16 - sprite->data[1])); + if (--sprite->data[1] < 0) + { + sprite->invisible = 1; + sprite->callback = AnimWhiteHalo_Step2; + } +} + +static void AnimWhiteHalo_Step2(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimSprite(sprite); +} + +void AnimTealAlert(struct Sprite *sprite) +{ + u16 rotation; + u8 x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + u8 y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + + InitSpritePosToAnimTarget(sprite, TRUE); + + rotation = ArcTan2Neg(sprite->pos1.x - x, sprite->pos1.y - y); + rotation += 0x6000; + if (IsContest()) + rotation += 0x4000; + + TrySetSpriteRotScale(sprite, FALSE, 0x100, 0x100, rotation); + + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = x; + sprite->data[4] = y; + sprite->callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimMeanLookEye(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + sprite->data[0] = 4; + sprite->callback = AnimMeanLookEye_Step1; +} + +static void AnimMeanLookEye_Step1(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 16 - sprite->data[0])); + + if (sprite->data[1]) + sprite->data[0]--; + else + sprite->data[0]++; + + if (sprite->data[0] == 15 || sprite->data[0] == 4) + sprite->data[1] ^= 1; + + if (sprite->data[2]++ > 70) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + StartSpriteAffineAnim(sprite, 1); + sprite->data[2] = 0; + sprite->invisible = 1; + sprite->affineAnimPaused = 1; + sprite->callback = AnimMeanLookEye_Step2; + } +} + +static void AnimMeanLookEye_Step2(struct Sprite *sprite) +{ + if (sprite->data[2]++ > 9) + { + sprite->invisible = 0; + sprite->affineAnimPaused = 0; + if (sprite->affineAnimEnded) + sprite->callback = AnimMeanLookEye_Step3; + } +} + +static void AnimMeanLookEye_Step3(struct Sprite *sprite) +{ + switch (sprite->data[3]) + { + case 0: + case 1: + sprite->pos2.x = 1; + sprite->pos2.y = 0; + break; + case 2: + case 3: + sprite->pos2.x = -1; + sprite->pos2.y = 0; + break; + case 4: + case 5: + sprite->pos2.x = 0; + sprite->pos2.y = 1; + break; + case 6: + default: + sprite->pos2.x = 0; + sprite->pos2.y = -1; + break; + } + + if (++sprite->data[3] > 7) + sprite->data[3] = 0; + + if (sprite->data[4]++ > 15) + { + sprite->data[0] = 16; + sprite->data[1] = 0; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 0)); + sprite->callback = AnimMeanLookEye_Step4; + } +} + +static void AnimMeanLookEye_Step4(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 16 - sprite->data[0])); + + if (sprite->data[1]++ > 1) + { + sprite->data[0]--; + sprite->data[1] = 0; + } + + if (sprite->data[0] == 0) + sprite->invisible = 1; + + if (sprite->data[0] < 0) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimSprite(sprite); + } +} + +void AnimTask_SetPsychicBackground(u8 taskId) +{ + gTasks[taskId].func = SetPsychicBackground_Step; + gAnimVisualTaskCount--; +} + +static void SetPsychicBackground_Step(u8 taskId) +{ + int i; + u16 lastColor; + u8 paletteIndex = GetBattleBgPaletteNum(); + + if (++gTasks[taskId].data[5] == 4) + { + lastColor = gPlttBufferFaded[paletteIndex * 16 + 11]; + for (i = 10; i > 0; i--) + gPlttBufferFaded[paletteIndex * 16 + i + 1] = gPlttBufferFaded[paletteIndex * 16 + i]; + + gPlttBufferFaded[paletteIndex * 16 + 1] = lastColor; + gTasks[taskId].data[5] = 0; + } + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + DestroyTask(taskId); +} + +void AnimTask_FadeScreenToWhite(u8 taskId) +{ + gTasks[taskId].func = FadeScreenToWhite_Step; + gAnimVisualTaskCount--; +} + +static void FadeScreenToWhite_Step(u8 taskId) +{ + int i; + u16 lastColor; + u8 paletteIndex = GetBattleBgPaletteNum(); + + if (++gTasks[taskId].data[5] == 4) + { + lastColor = gPlttBufferFaded[paletteIndex * 16 + 11]; + for (i = 10; i > 0; i--) + gPlttBufferFaded[paletteIndex * 16 + i + 1] = gPlttBufferFaded[paletteIndex * 16 + i]; + gPlttBufferFaded[paletteIndex * 16 + 1] = lastColor; + + lastColor = gPlttBufferUnfaded[paletteIndex * 16 + 11]; + for (i = 10; i > 0; i--) + gPlttBufferUnfaded[paletteIndex * 16 + i + 1] = gPlttBufferUnfaded[paletteIndex * 16 + i]; + gPlttBufferUnfaded[paletteIndex * 16 + 1] = lastColor; + + gTasks[taskId].data[5] = 0; + } + + if ((u16)gBattleAnimArgs[7] == 0xFFFF) + DestroyTask(taskId); +} + +void AnimSpikes(struct Sprite *sprite) +{ + u16 x; + u16 y; + + InitSpritePosToAnimAttacker(sprite, TRUE); + SetAverageBattlerPositions(gBattleAnimTarget, FALSE, &x, &y); + + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = x + gBattleAnimArgs[2]; + sprite->data[4] = y + gBattleAnimArgs[3]; + sprite->data[5] = -50; + + InitAnimArcTranslation(sprite); + sprite->callback = AnimSpikes_Step1; +} + +static void AnimSpikes_Step1(struct Sprite *sprite) +{ + if (TranslateAnimHorizontalArc(sprite)) + { + sprite->data[0] = 30; + sprite->data[1] = 0; + sprite->callback = WaitAnimForDuration; + StoreSpriteCallbackInData6(sprite, AnimSpikes_Step2); + } +} + +static void AnimSpikes_Step2(struct Sprite *sprite) +{ + if (sprite->data[1] & 1) + sprite->invisible ^= 1; + + if (++sprite->data[1] == 16) + DestroyAnimSprite(sprite); +} + +void AnimLeer(struct Sprite *sprite) +{ + SetSpriteCoordsToAnimAttackerCoords(sprite); + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->callback = RunStoredCallbackWhenAnimEnds; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void AnimLetterZ(struct Sprite *sprite) +{ + int var0; + if (sprite->data[0] == 0) + { + SetSpriteCoordsToAnimAttackerCoords(sprite); + SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); + if (!IsContest()) + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->data[1] = gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[3]; + } + else + { + sprite->data[1] = -1 * gBattleAnimArgs[2]; + sprite->data[2] = -1 * gBattleAnimArgs[3]; + } + } + else + { + sprite->data[1] = -1 * gBattleAnimArgs[2]; + sprite->data[2] = gBattleAnimArgs[3]; + } + } + + sprite->data[0]++; + var0 = (sprite->data[0] * 20) & 0xFF; + sprite->data[3] += sprite->data[1]; + sprite->data[4] += sprite->data[2]; + sprite->pos2.x = sprite->data[3] / 2; + sprite->pos2.y = Sin(var0 & 0xFF, 5) + (sprite->data[4] / 2); + + if ((u16)(sprite->pos1.x + sprite->pos2.x) > 240) + DestroyAnimSprite(sprite); +} + +void AnimFang(struct Sprite *sprite) +{ + if (sprite->animEnded) + DestroyAnimSprite(sprite); +} + +void AnimTask_IsTargetPlayerSide(u8 taskId) +{ + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) + gBattleAnimArgs[7] = 0; + else + gBattleAnimArgs[7] = 1; + + DestroyAnimVisualTask(taskId); +} + +void AnimTask_IsHealingMove(u8 taskId) +{ + if (gAnimMoveDmg > 0) + gBattleAnimArgs[7] = 0; + else + gBattleAnimArgs[7] = 1; + + DestroyAnimVisualTask(taskId); +} + +void AnimSpotlight(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJWIN_ON); + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); + SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); + + InitSpritePosToAnimTarget(sprite, FALSE); + + sprite->oam.objMode = ST_OAM_OBJ_WINDOW; + sprite->invisible = 1; + sprite->callback = AnimSpotlight_Step1; +} + +static void AnimSpotlight_Step1(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->invisible = 0; + if (sprite->affineAnimEnded) + sprite->data[0]++; + break; + case 1: + case 3: + sprite->data[1] += 117; + sprite->pos2.x = sprite->data[1] >> 8; + if (++sprite->data[2] == 21) + { + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 2: + sprite->data[1] -= 117; + sprite->pos2.x = sprite->data[1] >> 8; + if (++sprite->data[2] == 41) + { + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 4: + ChangeSpriteAffineAnim(sprite, 1); + sprite->data[0]++; + break; + case 5: + if (sprite->affineAnimEnded) + { + sprite->invisible = 1; + sprite->callback = AnimSpotlight_Step2; + } + break; + } +} + +static void AnimSpotlight_Step2(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + SetGpuReg(REG_OFFSET_DISPCNT, GetGpuReg(REG_OFFSET_DISPCNT) ^ DISPCNT_OBJWIN_ON); + DestroyAnimSprite(sprite); +} + +void AnimClappingHand(struct Sprite *sprite) +{ + if (gBattleAnimArgs[3] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + } + + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->oam.tileNum += 16; + + if (gBattleAnimArgs[2] == 0) + { + sprite->oam.matrixNum = ST_OAM_HFLIP; + sprite->pos2.x = -12; + sprite->data[1] = 2; + } + else + { + sprite->pos2.x = 12; + sprite->data[1] = -2; + } + + sprite->data[0] = gBattleAnimArgs[4]; + + if (sprite->data[3] != 255) + sprite->data[3] = gBattleAnimArgs[2]; + + sprite->callback = AnimClappingHand_Step; +} + +static void AnimClappingHand_Step(struct Sprite *sprite) +{ + if (sprite->data[2] == 0) + { + sprite->pos2.x += sprite->data[1]; + if (sprite->pos2.x == 0) + { + sprite->data[2]++; + if (sprite->data[3] == 0) + { + PlaySE1WithPanning(SE_W227, BattleAnimAdjustPanning(-64)); + } + } + } + else + { + sprite->pos2.x -= sprite->data[1]; + if (abs(sprite->pos2.x) == 12) + { + sprite->data[0]--; + sprite->data[2]--; + } + + } + + if (sprite->data[0] == 0) + DestroyAnimSprite(sprite); +} + +void AnimClappingHand2(struct Sprite *sprite) +{ + sprite->oam.objMode = ST_OAM_OBJ_WINDOW; + sprite->data[3] = 255; + AnimClappingHand(sprite); +} + +void AnimTask_CreateSpotlight(u8 taskId) +{ + if (IsContest()) + { + SetGpuReg(REG_OFFSET_WININ, 0x1F3F); + gBattle_WIN1H = 0x98F0; + gBattle_WIN1V = 0x00A0; + SetGpuReg(REG_OFFSET_WIN1H, gBattle_WIN0H); + SetGpuReg(REG_OFFSET_WIN1V, gBattle_WIN0V); + } + else + { + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ); + gBattle_WIN1H = 0x00F0; + gBattle_WIN1V = 0x78A0; + SetGpuReg(REG_OFFSET_WIN1H, 0x00F0); + SetGpuReg(REG_OFFSET_WIN1V, gBattle_WIN1V); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON); + } + + DestroyAnimVisualTask(taskId); +} + +void AnimTask_RemoveSpotlight(u8 taskId) +{ + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); + gBattle_WIN1H = 0; + gBattle_WIN1V = 0; + if (!IsContest()) + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON); + + DestroyAnimVisualTask(taskId); +} + +void AnimRapidSpin(struct Sprite *sprite) +{ + if (gBattleAnimArgs[0] == 0) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + } + + sprite->pos2.y = gBattleAnimArgs[2]; + + sprite->data[0] = (sprite->pos2.y > gBattleAnimArgs[3]); + sprite->data[1] = 0; + sprite->data[2] = gBattleAnimArgs[4]; + sprite->data[3] = gBattleAnimArgs[5]; + sprite->data[4] = gBattleAnimArgs[3]; + sprite->callback = AnimRapidSpin_Step; +} + +static void AnimRapidSpin_Step(struct Sprite *sprite) +{ + sprite->data[1] = (sprite->data[1] + sprite->data[2]) & 0xFF; + sprite->pos2.x = gSineTable[sprite->data[1]] >> 4; + sprite->pos2.y += sprite->data[3]; + + if (sprite->data[0]) + { + if (sprite->pos2.y < sprite->data[4]) + DestroyAnimSprite(sprite); + } + else + { + if (sprite->pos2.y > sprite->data[4]) + DestroyAnimSprite(sprite); + } +} + +void AnimTask_RapinSpinMonElevation(u8 taskId) +{ + s16 var0; + u8 toBG2; + s16 var2; + int var3; + int var4; + s16 i; + struct ScanlineEffectParams scanlineParams; + struct Task *task = &gTasks[taskId]; + + if (!gBattleAnimArgs[0]) + { + var0 = GetBattlerYCoordWithElevation(gBattleAnimAttacker); + toBG2 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); + } + else + { + var0 = GetBattlerYCoordWithElevation(gBattleAnimTarget); + toBG2 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); + } + + task->data[0] = var0 + 36; + task->data[1] = task->data[0]; + task->data[2] = var0 - 33; + if (task->data[2] < 0) + task->data[2] = 0; + + task->data[3] = task->data[0]; + task->data[4] = 8; + task->data[5] = gBattleAnimArgs[1]; + task->data[6] = 0; + task->data[7] = 0; + + if (toBG2 == 1) + { + var3 = gBattle_BG1_X; + task->data[8] = var3; + var4 = var3 + 240; + } + else + { + var3 = gBattle_BG2_X; + task->data[8] = var3; + var4 = var3 + 240; + } + + task->data[9] = var4; + task->data[10] = gBattleAnimArgs[2]; + + if (!gBattleAnimArgs[2]) + { + task->data[11] = var4; + var2 = task->data[8]; + } + else + { + task->data[11] = var3; + var2 = task->data[9]; + } + + task->data[15] = 0; + + i = task->data[2]; + while (i <= task->data[3]) + { + gScanlineEffectRegBuffers[0][i] = var2; + gScanlineEffectRegBuffers[1][i] = var2; + i++; + } + + if (toBG2 == 1) + scanlineParams.dmaDest = ®_BG1HOFS; + else + scanlineParams.dmaDest = ®_BG2HOFS; + + scanlineParams.dmaControl = SCANLINE_EFFECT_DMACNT_16BIT; + scanlineParams.initState = 1; + scanlineParams.unused9 = 0; + ScanlineEffect_SetParams(scanlineParams); + + task->func = RapinSpinMonElevation_Step; +} + +static void RapinSpinMonElevation_Step(u8 taskId) +{ + s16 i; + struct Task *task = &gTasks[taskId]; + + task->data[0] -= task->data[5]; + if (task->data[0] < task->data[2]) + task->data[0] = task->data[2]; + + if (task->data[4] == 0) + { + task->data[1] -= task->data[5]; + if (task->data[1] < task->data[2]) + { + task->data[1] = task->data[2]; + task->data[15] = 1; + } + } + else + { + task->data[4]--; + } + + if (++task->data[6] > 1) + { + task->data[6] = 0; + task->data[7] = task->data[7] == 0 ? 1 : 0; + + if (task->data[7]) + task->data[12] = task->data[8]; + else + task->data[12] = task->data[9]; + } + + i = task->data[0]; + while (i < task->data[1]) + { + gScanlineEffectRegBuffers[0][i] = task->data[12]; + gScanlineEffectRegBuffers[1][i] = task->data[12]; + i++; + } + + i = task->data[1]; + while (i <= task->data[3]) + { + gScanlineEffectRegBuffers[0][i] = task->data[11]; + gScanlineEffectRegBuffers[1][i] = task->data[11]; + i++; + } + + if (task->data[15]) + { + if (task->data[10]) + gScanlineEffect.state = 3; + + DestroyAnimVisualTask(taskId); + } +} + +void AnimTask_TormentAttacker(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + task->data[3] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + task->data[4] = 32; + task->data[5] = -20; + task->data[6] = 0; + task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->func = TormentAttacker_Step; +} + +static void TormentAttacker_Step(u8 taskId) +{ + int var0, var1; + s16 x, y; + u16 i, j; + u8 spriteId; + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + var0 = task->data[2]; + if (task->data[1] & 1) + { + var1 = task->data[4]; + x = var0 - var1; + } + else + { + var1 = task->data[4]; + x = var0 + var1; + } + + y = task->data[3] + task->data[5]; + spriteId = CreateSprite(&gThoughtBubbleSpriteTemplate, x, y, 6 - task->data[1]); + PlaySE12WithPanning(SE_W118, BattleAnimAdjustPanning(-64)); + + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].hFlip = task->data[1] & 1; + gSprites[spriteId].callback = SpriteCallbackDummy; + } + + if (task->data[1] & 1) + { + task->data[4] -= 6; + task->data[5] -= 6; + } + + PrepareAffineAnimInTaskData(task, task->data[15], gUnknown_085CE2A0); + task->data[1]++; + task->data[0] = 1; + break; + case 1: + if (!RunAffineAnimFromTaskData(task)) + { + if (task->data[1] == 6) + { + task->data[6] = 8; + task->data[0] = 3; + } + else + { + if (task->data[1] <= 2) + task->data[6] = 10; + else + task->data[6] = 0; + + task->data[0] = 2; + } + } + break; + case 2: + if (task->data[6] != 0) + task->data[6]--; + else + task->data[0] = 0; + break; + case 3: + if (task->data[6] != 0) + task->data[6]--; + else + task->data[0] = 4; + break; + case 4: + for (i = 0, j = 0; i < MAX_SPRITES; i++) + { + if (gSprites[i].template == &gThoughtBubbleSpriteTemplate) + { + gSprites[i].data[0] = taskId; + gSprites[i].data[1] = 6; + StartSpriteAnim(&gSprites[i], 2); + gSprites[i].callback = TormentAttacker_Callback; + + if (++j == 6) + break; + } + } + + task->data[6] = j; + task->data[0] = 5; + break; + case 5: + if (task->data[6] == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +static void TormentAttacker_Callback(struct Sprite *sprite) +{ + if (sprite->animEnded) + { + gTasks[sprite->data[0]].data[sprite->data[1]]--; + DestroySprite(sprite); + } +} + +void AnimTriAttackTriangle(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + InitSpritePosToAnimAttacker(sprite, FALSE); + + if (++sprite->data[0] < 40) + { + u16 var = sprite->data[0]; + if ((var & 1) == 0) + sprite->invisible = 1; + else + sprite->invisible = 0; + } + + if (sprite->data[0] > 30) + sprite->invisible = 0; + + if (sprite->data[0] == 61) + { + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->data[0] = 20; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->callback = StartAnimLinearTranslation; + } +} + +void AnimTask_DefenseCurlDeformMon(u8 taskId) +{ + switch (gTasks[taskId].data[0]) + { + case 0: + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE350); + gTasks[taskId].data[0]++; + break; + case 1: + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimBatonPassPokeball(struct Sprite *sprite) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + + switch (sprite->data[0]) + { + case 0: + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + sprite->data[1] = 256; + sprite->data[2] = 256; + sprite->data[0]++; + break; + case 1: + sprite->data[1] += 96; + sprite->data[2] -= 26; + SetSpriteRotScale(spriteId, sprite->data[1], sprite->data[2], 0); + + if (++sprite->data[3] == 5) + sprite->data[0]++; + // fall through + case 2: + sprite->data[1] += 96; + sprite->data[2] += 48; + SetSpriteRotScale(spriteId, sprite->data[1], sprite->data[2], 0); + + if (++sprite->data[3] == 9) + { + sprite->data[3] = 0; + gSprites[spriteId].invisible = 1; + ResetSpriteRotScale(spriteId); + sprite->data[0]++; + } + break; + case 3: + sprite->pos2.y -= 6; + if (sprite->pos1.y + sprite->pos2.y < -32) + DestroyAnimSprite(sprite); + break; + } +} + +void AnimWishStar(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos1.x = -16; + else + sprite->pos1.x = 256; + + sprite->pos1.y = 0; + sprite->callback = AnimWishStar_Step; +} + +static void AnimWishStar_Step(struct Sprite *sprite) +{ + u32 newX; + + sprite->data[0] += 72; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos2.x = sprite->data[0] >> 4; + else + sprite->pos2.x = -(sprite->data[0] >> 4); + + sprite->data[1] += 16; + sprite->pos2.y += sprite->data[1] >> 8; + + if (++sprite->data[2] % 3 == 0) + { + CreateSpriteAndAnimate( + &gMiniTwinklingStarSpriteTemplate, + sprite->pos1.x + sprite->pos2.x, + sprite->pos1.y + sprite->pos2.y, + sprite->subpriority + 1); + } + + newX = sprite->pos1.x + sprite->pos2.x + 32; + if (newX > 304) + DestroyAnimSprite(sprite); +} + +void AnimMiniTwinklingStar(struct Sprite *sprite) +{ + u8 rand; + s8 y; + + rand = Random2() & 3; + if (rand == 0) + sprite->oam.tileNum += 4; + else + sprite->oam.tileNum += 5; + + y = Random2() & 7; + if (y > 3) + y = -y; + + sprite->pos2.y = y; + sprite->callback = AnimMiniTwinklingStar_Step; +} + +static void AnimMiniTwinklingStar_Step(struct Sprite *sprite) +{ + if (++sprite->data[0] < 30) + { + if (++sprite->data[1] == 2) + { + sprite->invisible ^= 1; + sprite->data[1] = 0; + } + } + else + { + if (sprite->data[1] == 2) + sprite->invisible = 0; + + if (sprite->data[1] == 3) + { + sprite->invisible = 1; + sprite->data[1] = -1; + } + + sprite->data[1]++; + } + + if (sprite->data[0] > 60) + DestroySprite(sprite); +} + +void AnimTask_StockpileDeformMon(u8 taskId) +{ + if (!gTasks[taskId].data[0]) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE3B8); + gTasks[taskId].data[0]++; + } + else + { + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + } +} + +void AnimTask_SpitUpDeformMon(u8 taskId) +{ + if (!gTasks[taskId].data[0]) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE3E0); + gTasks[taskId].data[0]++; + } + else + { + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + } +} + +void AnimSwallowBlueOrb(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + InitSpritePosToAnimAttacker(sprite, FALSE); + sprite->data[1] = 0x900; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->data[0]++; + break; + case 1: + sprite->pos2.y -= sprite->data[1] >> 8; + sprite->data[1] -= 96; + if (sprite->pos1.y + sprite->pos2.y > sprite->data[2]) + DestroyAnimSprite(sprite); + break; + } +} + +void AnimTask_SwallowDeformMon(u8 taskId) +{ + if (!gTasks[taskId].data[0]) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE430); + gTasks[taskId].data[0]++; + } + else + { + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + } +} + +void AnimTask_TransformMon(u8 taskId) +{ + int i, j; + u8 position; + struct BattleAnimBgData animBg; + u8 *dest; + u8 *src; + u16 *bgTilemap; + u16 stretch; + + switch (gTasks[taskId].data[0]) + { + case 0: + SetGpuReg(REG_OFFSET_MOSAIC, 0); + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) + SetAnimBgAttribute(1, BG_ANIM_MOSAIC, 1); + else + SetAnimBgAttribute(2, BG_ANIM_MOSAIC, 1); + + gTasks[taskId].data[10] = gBattleAnimArgs[0]; + gTasks[taskId].data[0]++; + break; + case 1: + if (gTasks[taskId].data[2]++ > 1) + { + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[1]++; + stretch = gTasks[taskId].data[1]; + SetGpuReg(REG_OFFSET_MOSAIC, (stretch << 4) | stretch); + if (stretch == 15) + gTasks[taskId].data[0]++; + } + break; + case 2: + HandleSpeciesGfxDataChange(gBattleAnimAttacker, gBattleAnimTarget, gTasks[taskId].data[10]); + sub_80A6BFC(&animBg, gBattleAnimAttacker); + + if (IsContest()) + position = 0; + else + position = GetBattlerPosition(gBattleAnimAttacker); + + src = gMonSpritesGfxPtr->sprites[position] + (gBattleMonForms[gBattleAnimAttacker] << 11); + dest = animBg.bgTiles; + CpuCopy32(src, dest, 0x800); + LoadBgTiles(1, animBg.bgTiles, 0x800, animBg.tilesOffset); + if (IsContest()) + { + if (IsSpeciesNotUnown(gContestResources->field_18->species) != IsSpeciesNotUnown(gContestResources->field_18->unk2)) + { + bgTilemap = (u16 *)animBg.bgTilemap; + for (i = 0; i < 8; i++) + { + for (j = 0; j < 4; j++) + { + u16 temp = bgTilemap[j + i * 0x20]; + bgTilemap[j + i * 0x20] = bgTilemap[(7 - j) + i * 0x20]; + bgTilemap[(7 - j) + i * 0x20] = temp; + } + } + + for (i = 0; i < 8; i++) + { + for (j = 0; j < 8; j++) + { + bgTilemap[j + i * 0x20] ^= 0x400; + } + } + } + + if (IsSpeciesNotUnown(gContestResources->field_18->unk2)) + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].affineAnims = gUnknown_082FF6C0; + else + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].affineAnims = gUnknown_082FF694; + + StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimAttacker]], 0); + } + + gTasks[taskId].data[0]++; + break; + case 3: + if (gTasks[taskId].data[2]++ > 1) + { + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[1]--; + stretch = gTasks[taskId].data[1]; + SetGpuReg(REG_OFFSET_MOSAIC, (stretch << 4) | stretch); + + if (stretch == 0) + gTasks[taskId].data[0]++; + } + break; + case 4: + SetGpuReg(REG_OFFSET_MOSAIC, 0); + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) + SetAnimBgAttribute(1, BG_ANIM_MOSAIC, 0); + else + SetAnimBgAttribute(2, BG_ANIM_MOSAIC, 0); + + if (!IsContest()) + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + { + if (gTasks[taskId].data[10] == 0) + SetBattlerShadowSpriteCallback(gBattleAnimAttacker, gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies); + } + } + + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimTask_IsMonInvisible(u8 taskId) +{ + gBattleAnimArgs[7] = gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].invisible; + DestroyAnimVisualTask(taskId); +} + +void AnimTask_CastformGfxChange(u8 taskId) +{ + HandleSpeciesGfxDataChange(gBattleAnimAttacker, gBattleAnimTarget, TRUE); + DestroyAnimVisualTask(taskId); +} + +void AnimTask_MorningSunLightBeam(u8 taskId) +{ + struct BattleAnimBgData animBg; + + switch (gTasks[taskId].data[0]) + { + case 0: + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND | BLDCNT_TGT1_BG1); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + sub_80752A0 + sub_807543C + sub_80753B4 //AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); + LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); + if (IsContest()) + { + sub_80730C0(animBg.paletteId, [sp+4 ???], 0, 0); + gBattle_BG1_X = -56; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattle_BG1_X = -135; + else + gBattle_BG1_X = -10; + } + + gBattle_BG1_Y = 0; + + /* + sub_80752A0(&animBg); + sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); + + if (IsContest()) + { + gBattle_BG1_X = -56; + gBattle_BG1_Y = 0; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattle_BG1_X = -135; + else + gBattle_BG1_X = -10; + + gBattle_BG1_Y = 0; + } + */ + + + + + gTasks[taskId].data[10] = gBattle_BG1_X; + gTasks[taskId].data[11] = gBattle_BG1_Y; + + gTasks[taskId].data[0]++; + PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(-64)); + break; + case 1: + if (gTasks[taskId].data[4]++ > 0) + { + gTasks[taskId].data[4] = 0; + if (++gTasks[taskId].data[1] > 12) + gTasks[taskId].data[1] = 12; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + + if (gTasks[taskId].data[1] == 12) + gTasks[taskId].data[0]++; + } + break; + case 2: + if (--gTasks[taskId].data[1] < 0) + gTasks[taskId].data[1] = 0; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + + if (!gTasks[taskId].data[1]) + { + gBattle_BG1_X = gUnknown_085CE460[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; + if (++gTasks[taskId].data[2] == 4) + gTasks[taskId].data[0] = 4; + else + gTasks[taskId].data[0] = 3; + } + break; + case 3: + if (++gTasks[taskId].data[3] == 4) + { + gTasks[taskId].data[3] = 0; + gTasks[taskId].data[0] = 1; + PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(-64)); + } + break; + case 4: + sub_80752A0(&animBg); + sub_8075358(animBg.bgId); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimGreenStar(struct Sprite *sprite) +{ + s16 xOffset; + u8 spriteId1; + u8 spriteId2; + + xOffset = Random2(); + xOffset &= 0x3F; + if (xOffset > 31) + xOffset = 32 - xOffset; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + xOffset; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + 32; + sprite->data[1] = gBattleAnimArgs[0]; + sprite->data[2] = gBattleAnimArgs[1]; + + spriteId1 = CreateSprite(&gUnknown_085CE48C, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); + spriteId2 = CreateSprite(&gUnknown_085CE48C, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); + StartSpriteAnim(&gSprites[spriteId1], 1); + StartSpriteAnim(&gSprites[spriteId2], 2); + + gSprites[spriteId1].data[1] = gBattleAnimArgs[0]; + gSprites[spriteId1].data[2] = gBattleAnimArgs[1]; + gSprites[spriteId2].data[1] = gBattleAnimArgs[0]; + gSprites[spriteId2].data[2] = gBattleAnimArgs[1]; + gSprites[spriteId1].data[7] = -1; + gSprites[spriteId2].data[7] = -1; + gSprites[spriteId1].invisible = 1; + gSprites[spriteId2].invisible = 1; + gSprites[spriteId1].callback = AnimGreenStar_Callback; + gSprites[spriteId2].callback = AnimGreenStar_Callback; + + sprite->data[6] = spriteId1; + sprite->data[7] = spriteId2; + sprite->callback = AnimGreenStar_Step1; +} + +static void AnimGreenStar_Step1(struct Sprite *sprite) +{ + s16 delta = sprite->data[3] + sprite->data[2]; + sprite->pos2.y -= delta >> 8; + sprite->data[3] += sprite->data[2]; + sprite->data[3] &= 0xFF; + if (sprite->data[4] == 0 && sprite->pos2.y < -8) + { + gSprites[sprite->data[6]].invisible = 0; + sprite->data[4]++; + } + + if (sprite->data[4] == 1 && sprite->pos2.y < -16) + { + gSprites[sprite->data[7]].invisible = 0; + sprite->data[4]++; + } + + if (--sprite->data[1] == -1) + { + sprite->invisible = 1; + sprite->callback = AnimGreenStar_Step2; + } +} + +static void AnimGreenStar_Step2(struct Sprite *sprite) +{ + if (gSprites[sprite->data[6]].callback == SpriteCallbackDummy + && gSprites[sprite->data[7]].callback == SpriteCallbackDummy) + { + DestroySprite(&gSprites[sprite->data[6]]); + DestroySprite(&gSprites[sprite->data[7]]); + DestroyAnimSprite(sprite); + } +} + +static void AnimGreenStar_Callback(struct Sprite *sprite) +{ + if (!sprite->invisible) + { + s16 delta = sprite->data[3] + sprite->data[2]; + sprite->pos2.y -= delta >> 8; + sprite->data[3] += sprite->data[2]; + sprite->data[3] &= 0xFF; + if (--sprite->data[1] == -1) + { + sprite->invisible = 1; + sprite->callback = SpriteCallbackDummy; + } + } +} + +void AnimTask_DoomDesireLightBeam(u8 taskId) +{ + struct BattleAnimBgData animBg; + + switch (gTasks[taskId].data[0]) + { + case 0: + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND | BLDCNT_TGT1_BG1); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(3, 13)); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + /* + sub_80752A0(&animBg); + sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); + */ + + sub_80752A0 + sub_807543C + sub_80753B4 + LoadCompressedPalette + //... + + if (IsContest()) + { + gBattle_BG1_X = -56; + gBattle_BG1_Y = 0; + } + else + { + u8 position = GetBattlerPosition(gBattleAnimTarget); + if (IsDoubleBattle() == TRUE) + { + if (position == B_POSITION_OPPONENT_LEFT) + gBattle_BG1_X = -155; + if (position == B_POSITION_OPPONENT_RIGHT) + gBattle_BG1_X = -115; + if (position == B_POSITION_PLAYER_LEFT) + gBattle_BG1_X = 14; + if (position == B_POSITION_PLAYER_RIGHT) + gBattle_BG1_X = -20; + } + else + { + if (position == B_POSITION_OPPONENT_LEFT) + gBattle_BG1_X = -135; + if (position == B_POSITION_PLAYER_LEFT) + gBattle_BG1_X = -10; + } + + gBattle_BG1_Y = 0; + } + + AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); + LoadCompressedPalette(gUnknown_08C2A6D4, animBg.paletteId * 16, 32); + gTasks[taskId].data[10] = gBattle_BG1_X; + gTasks[taskId].data[11] = gBattle_BG1_Y; + gTasks[taskId].data[0]++; + break; + case 1: + gTasks[taskId].data[3] = 0; + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) + gBattle_BG1_X = gTasks[taskId].data[10] + gUnknown_085CE4A4[gTasks[taskId].data[2]]; + else + gBattle_BG1_X = gTasks[taskId].data[10] - gUnknown_085CE4A4[gTasks[taskId].data[2]]; + + if (++gTasks[taskId].data[2] == 5) + gTasks[taskId].data[0] = 5; + else + gTasks[taskId].data[0]++; + break; + case 2: + if (--gTasks[taskId].data[1] <= 4) + gTasks[taskId].data[1] = 5; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(3, gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 5) + gTasks[taskId].data[0]++; + break; + case 3: + if (++gTasks[taskId].data[3] > gUnknown_085CE4A8[gTasks[taskId].data[2]]) + gTasks[taskId].data[0]++; + break; + case 4: + if (++gTasks[taskId].data[1] > 13) + gTasks[taskId].data[1] = 13; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(3, gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 13) + gTasks[taskId].data[0] = 1; + break; + case 5: + sub_80752A0(&animBg); + sub_8075358(animBg.bgId); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); + gBattle_BG1_X = 0; + gBattle_BG1_Y = 0; + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimVisualTask(taskId); + break; + } +} + +// Briefly vertically grows and shrinks the attacking mon's sprite. +// No args. +void AnimTask_StrongFrustrationGrowAndShrink(u8 taskId) +{ + if (gTasks[taskId].data[0] == 0) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gStrongFrustrationAffineAnimCmds); + gTasks[taskId].data[0]++; + } + else + { + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); + } +} + +// Animates an anger mark near the mon's head. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +void AnimWeakFrustrationAngerMark(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + InitSpritePosToAnimAttacker(sprite, 0); + sprite->data[0]++; + } + else if (sprite->data[0]++ > 20) + { + sprite->data[1] += 160; + sprite->data[2] += 128; + + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->pos2.x = -(sprite->data[1] >> 8); + else + sprite->pos2.x = sprite->data[1] >> 8; + + sprite->pos2.y += sprite->data[2] >> 8; + if (sprite->pos2.y > 64) + DestroyAnimSprite(sprite); + } +} + +// Rocks the mon back and forth. This is done on a pivot so it is done via rotation. +// arg 0: which battler +// arg 1: number of rocks +// arg 2: rotation speed increase +void AnimTask_RockMonBackAndForth(u8 taskId) +{ + u8 side; + struct Task *task = &gTasks[taskId]; + + if (!gBattleAnimArgs[1]) + { + DestroyAnimVisualTask(taskId); + return; + } + + if (gBattleAnimArgs[2] < 0) + gBattleAnimArgs[2] = 0; + if (gBattleAnimArgs[2] > 2) + gBattleAnimArgs[2] = 2; + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 8 - (2 * gBattleAnimArgs[2]); + task->data[4] = 0x100 + (gBattleAnimArgs[2] * 128); + task->data[5] = gBattleAnimArgs[2] + 2; + task->data[6] = gBattleAnimArgs[1] - 1; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + side = GetBattlerSide(gBattleAnimAttacker); + else + side = GetBattlerSide(gBattleAnimTarget); + + if (side == B_SIDE_OPPONENT) + { + task->data[4] *= -1; + task->data[5] *= -1; + } + + PrepareBattlerSpriteForRotScale(task->data[15], ST_OAM_OBJ_NORMAL); + task->func = AnimTask_RockMonBackAndForthStep; +} + +static void AnimTask_RockMonBackAndForthStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + gSprites[task->data[15]].pos2.x += task->data[5]; + task->data[2] -= task->data[4]; + SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); + SetBattlerSpriteYOffsetFromRotation(task->data[15]); + if (++task->data[1] >= task->data[3]) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 1: + gSprites[task->data[15]].pos2.x -= task->data[5]; + task->data[2] += task->data[4]; + SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); + SetBattlerSpriteYOffsetFromRotation(task->data[15]); + if (++task->data[1] >= task->data[3] * 2) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 2: + gSprites[task->data[15]].pos2.x += task->data[5]; + task->data[2] -= task->data[4]; + SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); + SetBattlerSpriteYOffsetFromRotation(task->data[15]); + if (++task->data[1] >= task->data[3]) + { + if (task->data[6]) + { + task->data[6]--; + task->data[1] = 0; + task->data[0] = 0; + } + else + { + task->data[0]++; + } + } + break; + case 3: + ResetSpriteRotScale(task->data[15]); + DestroyAnimVisualTask(taskId); + break; + } +} + +// Floats a petal across the screen towards the target mon's side. +// arg 0: initial y pixel offset +// arg 1: sprite anim num +// arg 2: unused +void AnimSweetScentPetal(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x = 0; + sprite->pos1.y = gBattleAnimArgs[0]; + } + else + { + sprite->pos1.x = 240; + sprite->pos1.y = gBattleAnimArgs[0] - 30; + } + + sprite->data[2] = gBattleAnimArgs[2]; + StartSpriteAnim(sprite, gBattleAnimArgs[1]); + sprite->callback = AnimSweetScentPetalStep; +} + +static void AnimSweetScentPetalStep(struct Sprite *sprite) +{ + sprite->data[0] += 3; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + sprite->pos1.x += 5; + sprite->pos1.y -= 1; + + if (sprite->pos1.x > 240) + DestroyAnimSprite(sprite); + + sprite->pos2.y = Sin(sprite->data[0] & 0xFF, 16); + } + else + { + sprite->pos1.x -= 5; + sprite->pos1.y += 1; + + if (sprite->pos1.x < 0) + DestroyAnimSprite(sprite); + + sprite->pos2.y = Cos(sprite->data[0] & 0xFF, 16); + } +} + +// Moves the mon sprite in a flailing back-and-forth motion. +// arg 0: which battler +void AnimTask_FlailMovement(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + task->data[12] = 0x20; + task->data[13] = 0x40; + task->data[14] = 0x800; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + + PrepareBattlerSpriteForRotScale(task->data[15], ST_OAM_OBJ_NORMAL); + task->func = AnimTask_FlailMovementStep; +} + +static void AnimTask_FlailMovementStep(u8 taskId) +{ + int temp; + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + task->data[2] += 0x200; + if (task->data[2] >= task->data[14]) + { + s16 diff = task->data[14] - task->data[2]; + s16 div = diff / (task->data[14] * 2); + s16 mod = diff % (task->data[14] * 2); + + if ((div & 1) == 0) + { + task->data[2] = task->data[14] - mod; + task->data[0] = 1; + } + else + { + task->data[2] = mod - task->data[14]; + } + } + break; + case 1: + task->data[2] -= 0x200; + if (task->data[2] <= -task->data[14]) + { + s16 diff = task->data[14] - task->data[2]; + s16 div = diff / (task->data[14] * 2); + s16 mod = diff % (task->data[14] * 2); + + if ((1 & div) == 0) + { + task->data[2] = mod - task->data[14]; + task->data[0] = 0; + } + else + { + task->data[2] = task->data[14] - mod; + } + } + break; + case 2: + ResetSpriteRotScale(task->data[15]); + DestroyAnimVisualTask(taskId); + return; + } + + SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); + SetBattlerSpriteYOffsetFromRotation(task->data[15]); + gSprites[task->data[15]].pos2.x = -(((temp = task->data[2]) >= 0 ? task->data[2] : temp + 63) >> 6); + + if (++task->data[1] > 8) + { + if (task->data[12]) + { + task->data[12]--; + task->data[14] -= task->data[13]; + if (task->data[14] < 16) + task->data[14] = 16; + } + else + { + task->data[0] = 2; + } + } +} + +// Makes a spark-like projectile fall on top of the mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: which battler +void AnimPainSplitProjectile(struct Sprite *sprite) +{ + if (!sprite->data[0]) + { + if (gBattleAnimArgs[2] == ANIM_ATTACKER) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + } + + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[1] = 0x80; + sprite->data[2] = 0x300; + sprite->data[3] = gBattleAnimArgs[1]; + sprite->data[0]++; + } + else + { + sprite->pos2.x = sprite->data[1] >> 8; + sprite->pos2.y += sprite->data[2] >> 8; + if (sprite->data[4] == 0 && sprite->pos2.y > -sprite->data[3]) + { + sprite->data[4] = 1; + sprite->data[2] = (-sprite->data[2] / 3) * 2; + } + + sprite->data[1] += 192; + sprite->data[2] += 128; + if (sprite->animEnded) + DestroyAnimSprite(sprite); + } +} + +// Performs one of several affine transformations on the mon sprite. +// arg 0: which battler +// arg 1: which transformation +void AnimTask_PainSplitMovement(u8 taskId) +{ + u8 spriteId; + + if (gTasks[taskId].data[0] == 0) + { + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + gTasks[taskId].data[11] = gBattleAnimAttacker; + else + gTasks[taskId].data[11] = gBattleAnimTarget; + + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gTasks[taskId].data[10] = spriteId; + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + + switch (gBattleAnimArgs[1]) + { + case 0: + SetSpriteRotScale(spriteId, 0xE0, 0x140, 0); + SetBattlerSpriteYOffsetFromYScale(spriteId); + break; + case 1: + SetSpriteRotScale(spriteId, 0xD0, 0x130, 0xF00); + SetBattlerSpriteYOffsetFromYScale(spriteId); + if (IsContest() || GetBattlerSide(gTasks[taskId].data[11]) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.y += 16; + break; + case 2: + SetSpriteRotScale(spriteId, 0xD0, 0x130, 0xF100); + SetBattlerSpriteYOffsetFromYScale(spriteId); + if (IsContest() || GetBattlerSide(gTasks[taskId].data[11]) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.y += 16; + break; + } + + gSprites[spriteId].pos2.x = 2; + gTasks[taskId].data[0]++; + } + else + { + spriteId = gTasks[taskId].data[10]; + if (++gTasks[taskId].data[2] == 3) + { + gTasks[taskId].data[2] = 0; + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos2.x; + } + + if (++gTasks[taskId].data[1] == 13) + { + ResetSpriteRotScale(spriteId); + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + DestroyAnimVisualTask(taskId); + } + } +} + +// Move a piece of confetti in a slightly-random speed across the screen. +// arg 0: which battler the confetti starts from +void AnimFlatterConfetti(struct Sprite *sprite) +{ + u8 tileOffset; + int rand1; + int rand2; + + tileOffset = Random2() % 12; + sprite->oam.tileNum += tileOffset; + rand1 = Random2() & 0x1FF; + rand2 = Random2() & 0xFF; + + if (rand1 & 1) + sprite->data[0] = 0x5E0 + rand1; + else + sprite->data[0] = 0x5E0 - rand1; + + if (rand2 & 1) + sprite->data[1] = 0x480 + rand2; + else + sprite->data[1] = 0x480 - rand2; + + sprite->data[2] = gBattleAnimArgs[0]; + if (sprite->data[2] == ANIM_ATTACKER) + sprite->pos1.x = -8; + else + sprite->pos1.x = 248; + + sprite->pos1.y = 104; + sprite->callback = AnimFlatterConfettiStep; +} + +static void AnimFlatterConfettiStep(struct Sprite *sprite) +{ + if (sprite->data[2] == 0) + { + sprite->pos2.x += sprite->data[0] >> 8; + sprite->pos2.y -= sprite->data[1] >> 8; + } + else + { + sprite->pos2.x -= sprite->data[0] >> 8; + sprite->pos2.y -= sprite->data[1] >> 8; + } + + sprite->data[0] -= 22; + sprite->data[1] -= 48; + if (sprite->data[0] < 0) + sprite->data[0] = 0; + + if (++sprite->data[3] == 31) + DestroyAnimSprite(sprite); +} + +// Uses a spotlight sprite as a light mask to illuminate the target mon. The spotlight grows and shrinks. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: duration of fully-opened spotlight +void AnimFlatterSpotlight(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJWIN_ON); + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); + SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); + + sprite->data[0] = gBattleAnimArgs[2]; + InitSpritePosToAnimTarget(sprite, FALSE); + sprite->oam.objMode = ST_OAM_OBJ_WINDOW; + sprite->invisible = 1; + sprite->callback = AnimFlatterSpotlightStep; +} + +static void AnimFlatterSpotlightStep(struct Sprite *sprite) +{ + switch (sprite->data[1]) + { + case 0: + sprite->invisible = 0; + if (sprite->affineAnimEnded) + sprite->data[1]++; + break; + case 1: + if (--sprite->data[0] == 0) + { + ChangeSpriteAffineAnim(sprite, 1); + sprite->data[1]++; + } + break; + case 2: + if (sprite->affineAnimEnded) + { + sprite->invisible = 1; + sprite->data[1]++; + } + break; + case 3: + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + SetGpuReg(REG_OFFSET_DISPCNT, GetGpuReg(REG_OFFSET_DISPCNT) ^ DISPCNT_OBJWIN_ON); + DestroyAnimSprite(sprite); + break; + } +} + +// Spins an orb around the attacking mon, while its path radius grows and shrinks. +// arg 0: duration +// arg 1: initial wave offset +void AnimReversalOrb(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->callback = AnimReversalOrbStep; + sprite->callback(sprite); +} + +static void AnimReversalOrbStep(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[1], sprite->data[2] >> 8); + sprite->pos2.y = Cos(sprite->data[1], sprite->data[3] >> 8); + sprite->data[1] = (sprite->data[1] + 9) & 0xFF; + + if ((u16)sprite->data[1] < 64 || sprite->data[1] > 195) + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) - 1; + else + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker) + 1; + + if (!sprite->data[5]) + { + sprite->data[2] += 0x400; + sprite->data[3] += 0x100; + sprite->data[4]++; + if (sprite->data[4] == sprite->data[0]) + { + sprite->data[4] = 0; + sprite->data[5] = 1; + } + } + else if (sprite->data[5] == 1) + { + sprite->data[2] -= 0x400; + sprite->data[3] -= 0x100; + sprite->data[4]++; + if (sprite->data[4] == sprite->data[0]) + DestroyAnimSprite(sprite); + } +} + +// Copies the target mon's sprite, and makes a white silhouette that shrinks away. +void AnimTask_RolePlaySilhouette(u8 taskId) +{ + u8 isBackPic; + u32 personality; + u32 otId; + u16 species; + s16 xOffset; + u32 priority; + u8 spriteId; + s16 coord1, coord2; + + GetAnimBattlerSpriteId(ANIM_ATTACKER); + if (IsContest()) + { + isBackPic = 1; + personality = gContestResources->field_18->unk10; + otId = gContestResources->field_18->unkC; + species = gContestResources->field_18->unk2; + xOffset = 20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + isBackPic = 0; + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } + + xOffset = 20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + else + { + isBackPic = 1; + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } + + xOffset = -20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + } + + coord1 = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + coord2 = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + spriteId = sub_80A8394(species, isBackPic, 0, coord1 + xOffset, coord2, 5, personality, otId, gBattleAnimTarget, 1); + + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].oam.objMode = ST_OAM_OBJ_BLEND; + FillPalette(RGB_WHITE, (gSprites[spriteId].oam.paletteNum << 4) + 0x100, 32); + gSprites[spriteId].oam.priority = priority; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].func = AnimTask_RolePlaySilhouetteStep1; +} + +static void AnimTask_RolePlaySilhouetteStep1(u8 taskId) +{ + if (gTasks[taskId].data[10]++ > 1) + { + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); + if (gTasks[taskId].data[1] == 10) + { + gTasks[taskId].data[10] = 256; + gTasks[taskId].data[11] = 256; + gTasks[taskId].func = AnimTask_RolePlaySilhouetteStep2; + } + } +} + +static void AnimTask_RolePlaySilhouetteStep2(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[0]; + gTasks[taskId].data[10] -= 16; + gTasks[taskId].data[11] += 128; + gSprites[spriteId].oam.affineMode |= ST_OAM_AFFINE_DOUBLE_MASK; + TrySetSpriteRotScale(&gSprites[spriteId], TRUE, gTasks[taskId].data[10], gTasks[taskId].data[11], 0); + if (++gTasks[taskId].data[12] == 9) + { + sub_80A749C(&gSprites[spriteId]); + DestroySpriteAndFreeResources_(&gSprites[spriteId]); + gTasks[taskId].func = DestroyAnimVisualTaskAndDisableBlend; + } +} + +// Performs a wavy transformation on the mon's sprite, and fades out. +// arg 0: which battler +void AnimTask_AcidArmor(u8 taskId) +{ + u8 battler; + u16 bgX, bgY; + s16 y, i; + struct ScanlineEffectParams scanlineParams; + struct Task *task = &gTasks[taskId]; + + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 16; + task->data[4] = 0; + task->data[5] = battler; + task->data[6] = 32; + task->data[7] = 0; + task->data[8] = 24; + + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + task->data[8] *= -1; + + task->data[13] = GetBattlerYCoordWithElevation(battler) - 34; + if (task->data[13] < 0) + task->data[13] = 0; + + task->data[14] = task->data[13] + 66; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + if (GetBattlerSpriteBGPriorityRank(battler) == 1) + { + scanlineParams.dmaDest = ®_BG1HOFS; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND | BLDCNT_TGT1_BG1); + bgX = gBattle_BG1_X; + bgY = gBattle_BG1_Y; + } + else + { + scanlineParams.dmaDest = ®_BG2HOFS; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT2_ALL | BLDCNT_EFFECT_BLEND | BLDCNT_TGT1_BG2); + bgX = gBattle_BG2_X; + bgY = gBattle_BG2_Y; + } + + for (y = 0, i = 0; y < 160; y++, i += 2) + { + gScanlineEffectRegBuffers[0][i] = bgX; + gScanlineEffectRegBuffers[1][i] = bgX; + gScanlineEffectRegBuffers[0][i + 1] = bgY; + gScanlineEffectRegBuffers[1][i + 1] = bgY; + } + + scanlineParams.dmaControl = SCANLINE_EFFECT_DMACNT_32BIT; + scanlineParams.initState = 1; + scanlineParams.unused9 = 0; + ScanlineEffect_SetParams(scanlineParams); + task->func = AnimTask_AcidArmorStep; +} + +static void AnimTask_AcidArmorStep(u8 taskId) +{ + struct Task *task; + s16 var1; + s16 var2; + s16 bgX, bgY; + s16 offset; + s16 var0; + s16 i; + s16 sineIndex; + s16 var3; + + task = &gTasks[taskId]; + if (GetBattlerSpriteBGPriorityRank(task->data[5]) == 1) + { + bgX = gBattle_BG1_X; + bgY = gBattle_BG1_Y; + } + else + { + bgX = gBattle_BG2_X; + bgY = gBattle_BG2_Y; + } + + switch (task->data[0]) + { + case 0: + offset = task->data[14] * 2; + var1 = 0; + var2 = 0; + i = 0; + task->data[1] = (task->data[1] + 2) & 0xFF; + sineIndex = task->data[1]; + task->data[9] = 0x7E0 / task->data[6]; + task->data[10] = -((task->data[7] * 2) / task->data[9]); + task->data[11] = task->data[7]; + var3 = task->data[11] >> 5; + task->data[12] = var3; + var0 = task->data[14]; + while (var0 > task->data[13]) + { + gScanlineEffectRegBuffers[gScanlineEffect.srcBuffer][offset + 1] = (i - var2) + bgY; + gScanlineEffectRegBuffers[gScanlineEffect.srcBuffer][offset] = bgX + var3 + (gSineTable[sineIndex] >> 5); + sineIndex = (sineIndex + 10) & 0xFF; + task->data[11] += task->data[10]; + var3 = task->data[11] >> 5; + task->data[12] = var3; + + i++; + offset -= 2; + var1 += task->data[6]; + var2 = var1 >> 5; + var0--; + } + + var0 *= 2; + while (var0 >= 0) + { + gScanlineEffectRegBuffers[0][var0] = bgX + 240; + gScanlineEffectRegBuffers[1][var0] = bgX + 240; + var0 -= 2; + } + + if (++task->data[6] > 63) + { + task->data[6] = 64; + task->data[2]++; + if (task->data[2] & 1) + task->data[3]--; + else + task->data[4]++; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(task->data[3], task->data[4])); + if (task->data[3] == 0 && task->data[4] == 16) + { + task->data[2] = 0; + task->data[3] = 0; + task->data[0]++; + } + } + else + { + task->data[7] += task->data[8]; + } + break; + case 1: + if (++task->data[2] > 12) + { + gScanlineEffect.state = 3; + task->data[2] = 0; + task->data[0]++; + } + break; + case 2: + task->data[2]++; + if (task->data[2] & 1) + task->data[3]++; + else + task->data[4]--; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(task->data[3], task->data[4])); + if (task->data[3] == 16 && task->data[4] == 0) + { + task->data[2] = 0; + task->data[3] = 0; + task->data[0]++; + } + break; + case 3: + DestroyAnimVisualTask(taskId); + break; + } +} + +// Runs an affine animation that makes it look like the mon is inhaling deeply. +// arg 0: which battler +void AnimTask_DeepInhale(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + task->data[0] = 0; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + PrepareAffineAnimInTaskData(&gTasks[taskId], task->data[15], gDeepInhaleAffineAnimCmds); + task->func = AnimTask_DeepInhaleStep; +} + +static void AnimTask_DeepInhaleStep(u8 taskId) +{ + u16 var0; + + struct Task *task = &gTasks[taskId]; + var0 = task->data[0]; + task->data[0]++; + var0 -= 20; + if (var0 < 23) + { + if (++task->data[1] > 1) + { + task->data[1] = 0; + task->data[2]++; + if (task->data[2] & 1) + gSprites[task->data[15]].pos2.x = 1; + else + gSprites[task->data[15]].pos2.x = -1; + } + } + else + { + gSprites[task->data[15]].pos2.x = 0; + } + + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); +} + +static void InitYawnCloudPosition(struct Sprite *sprite, s16 startX, s16 startY, s16 destX, s16 destY, u16 duration) +{ + sprite->pos1.x = startX; + sprite->pos1.y = startY; + sprite->data[4] = startX << 4; + sprite->data[5] = startY << 4; + sprite->data[6] = ((destX - startX) << 4) / duration; + sprite->data[7] = ((destY - startY) << 4) / duration; +} + +static void UpdateYawnCloudPosition(struct Sprite *sprite) +{ + sprite->data[4] += sprite->data[6]; + sprite->data[5] += sprite->data[7]; + sprite->pos1.x = sprite->data[4] >> 4; + sprite->pos1.y = sprite->data[5] >> 4; +} + +// Drifts a cloud in a wavy path towards the target mon. +// arg 0: which affine anim +void AnimYawnCloud(struct Sprite *sprite) +{ + s16 destX = sprite->pos1.x; + s16 destY = sprite->pos1.y; + + SetSpriteCoordsToAnimAttackerCoords(sprite); + StartSpriteAffineAnim(sprite, gBattleAnimArgs[0]); + InitYawnCloudPosition(sprite, sprite->pos1.x, sprite->pos1.y, destX, destY, 64); + sprite->data[0] = 0; + sprite->callback = AnimYawnCloudStep; +} + +static void AnimYawnCloudStep(struct Sprite *sprite) +{ + int index; + + sprite->data[0]++; + index = (sprite->data[0] * 8) & 0xFF; + UpdateYawnCloudPosition(sprite); + sprite->pos2.y = Sin(index, 8); + if (sprite->data[0] > 58) + { + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + sprite->data[2]++; + sprite->invisible = sprite->data[2] & 1; + if (sprite->data[2] > 3) + DestroySpriteAndMatrix(sprite); + } + } +} + +// Animates a cloud coming from the smoke ball. +// arg 0: ? +// arg 1: initial x pixel offset +// arg 2: initial y pixel offset +// arg 3: ? +void AnimSmokeBallEscapeCloud(struct Sprite *sprite) +{ + sprite->data[0] = gBattleAnimArgs[3]; + StartSpriteAffineAnim(sprite, gBattleAnimArgs[0]); + if (GetBattlerSide(gBattleAnimTarget) != B_SIDE_PLAYER) + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; + sprite->callback = sub_80B1D3C; +} + +static void sub_80E1990(u8 taskId) +{ + u16 var0 = 0; + u16 var1 = 0; + + gTasks[taskId].data[0]--; + if ((gTasks[taskId].data[6] & 0x8000) && (--gTasks[taskId].data[1] == -1)) + { + if (gTasks[taskId].data[9] == 0) + { + gTasks[taskId].data[9] = gTasks[taskId].data[4]; + gTasks[taskId].data[4] = -gTasks[taskId].data[4]; + } + else + { + gTasks[taskId].data[9] = 0; + } + + if (gTasks[taskId].data[10] == 0) + { + gTasks[taskId].data[10] = gTasks[taskId].data[5]; + gTasks[taskId].data[5] = -gTasks[taskId].data[5]; + } + else + { + gTasks[taskId].data[10] = 0; + } + + gTasks[taskId].data[1] = gTasks[taskId].data[13]; + } + + var0 = gTasks[taskId].data[7]; + var1 = gTasks[taskId].data[8]; + if (gTasks[taskId].data[2] & 0x8000) + gSprites[gTasks[taskId].data[15]].pos2.x = gTasks[taskId].data[9] - (var0 >> 8); + else + gSprites[gTasks[taskId].data[15]].pos2.x = gTasks[taskId].data[9] + (var0 >> 8); + + if (gTasks[taskId].data[3] & 0x8000) + gSprites[gTasks[taskId].data[15]].pos2.y = gTasks[taskId].data[10] - (var1 >> 8); + else + gSprites[gTasks[taskId].data[15]].pos2.y = gTasks[taskId].data[10] + (var1 >> 8); + + if (gTasks[taskId].data[0] < 1) + { + DestroyTask(taskId); + gAnimVisualTaskCount--; + } +} + +static void sub_80E1AD8(u8 taskId) +{ + u16 var0 = 0; + u16 var1 = 0; + + gTasks[taskId].data[0]--; + if ((gTasks[taskId].data[6] & 0x8000) && (--gTasks[taskId].data[1] == -1)) + { + if (gTasks[taskId].data[9] == 0) + { + gTasks[taskId].data[9] = gTasks[taskId].data[4]; + gTasks[taskId].data[4] = -gTasks[taskId].data[4]; + } + else + { + gTasks[taskId].data[9] = var0; + } + + if (gTasks[taskId].data[10] == 0) + { + gTasks[taskId].data[10] = gTasks[taskId].data[5]; + gTasks[taskId].data[5] = -gTasks[taskId].data[5]; + } + else + { + gTasks[taskId].data[10] = 0; + } + + gTasks[taskId].data[1] = gTasks[taskId].data[13]; + } + + var0 = (gTasks[taskId].data[2] & 0x7FFF) + gTasks[taskId].data[7]; + var1 = (gTasks[taskId].data[3] & 0x7FFF) + gTasks[taskId].data[8]; + if (gTasks[taskId].data[2] & 0x8000) + gSprites[gTasks[taskId].data[15]].pos2.x = gTasks[taskId].data[9] - (var0 >> 8); + else + gSprites[gTasks[taskId].data[15]].pos2.x = gTasks[taskId].data[9] + (var0 >> 8); + + if (gTasks[taskId].data[3] & 0x8000) + gSprites[gTasks[taskId].data[15]].pos2.y = gTasks[taskId].data[10] - (var1 >> 8); + else + gSprites[gTasks[taskId].data[15]].pos2.y = gTasks[taskId].data[10] + (var1 >> 8); + + gTasks[taskId].data[7] = var0; + gTasks[taskId].data[8] = var1; + if (gTasks[taskId].data[0] < 1) + { + gTasks[taskId].data[0] = 30; + gTasks[taskId].data[13] = 0; + gTasks[taskId].func = sub_80E1990; + } +} + +void sub_80E1C48(u8 taskId) +{ + gTasks[taskId].data[15] = gBattlerSpriteIds[gBattleAnimAttacker]; + gTasks[taskId].data[14] = gBattleAnimArgs[0]; + gTasks[taskId].data[0] = gBattleAnimArgs[0]; + gTasks[taskId].data[13] = gBattleAnimArgs[6]; + if (gBattleAnimArgs[3]) + gTasks[taskId].data[6] = gTasks[taskId].data[6] | -0x8000; + + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + gTasks[taskId].data[2] = gBattleAnimArgs[1]; + gTasks[taskId].data[3] = gBattleAnimArgs[2]; + } + else + { + if (gBattleAnimArgs[1] & 0x8000) + gTasks[taskId].data[2] = gBattleAnimArgs[1] & 0x7FFF; + else + gTasks[taskId].data[2] = gBattleAnimArgs[1] | -0x8000; + + if (gBattleAnimArgs[2] & 0x8000) + gTasks[taskId].data[3] = gBattleAnimArgs[2] & 0x7FFF; + else + gTasks[taskId].data[3] = gBattleAnimArgs[2] | -0x8000; + } + + gTasks[taskId].data[8] = 0; + gTasks[taskId].data[7] = 0; + gTasks[taskId].data[4] = gBattleAnimArgs[4]; + gTasks[taskId].data[5] = gBattleAnimArgs[5]; + gTasks[taskId].func = sub_80E1AD8; +} + +// Squishes the mon vertically and emits sweat droplets a few times. +// arg 0: battler +// arg 1: num squishes +void AnimTask_SquishAndSweatDroplets(u8 taskId) +{ + u8 battler; + struct Task *task = &gTasks[taskId]; + + if (!gBattleAnimArgs[1]) + DestroyAnimVisualTask(taskId); + + task->data[0] = 0; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = gBattleAnimArgs[1]; + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + task->data[4] = GetBattlerSpriteCoord(battler, BATTLER_COORD_X); + task->data[5] = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y); + task->data[6] = GetBattlerSpriteSubpriority(battler); + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + PrepareAffineAnimInTaskData(task, task->data[15], gFacadeSquishAffineAnimCmds); + task->func = AnimTask_SquishAndSweatDropletsStep; +} + +static void AnimTask_SquishAndSweatDropletsStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + task->data[1]++; + if (task->data[1] == 6) + CreateSweatDroplets(taskId, TRUE); + + if (task->data[1] == 18) + CreateSweatDroplets(taskId, FALSE); + + if (!RunAffineAnimFromTaskData(task)) + { + if (--task->data[3] == 0) + { + task->data[0]++; + } + else + { + task->data[1] = 0; + PrepareAffineAnimInTaskData(task, task->data[15], gFacadeSquishAffineAnimCmds); + } + } + break; + case 1: + if (task->data[2] == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +static void CreateSweatDroplets(u8 taskId, bool8 arg1) +{ + u8 i; + s8 xOffset, yOffset; + struct Task *task; + s16 xCoords[4]; + s16 yCoords[2]; + + task = &gTasks[taskId]; + if (!arg1) + { + xOffset = 18; + yOffset = -20; + } + else + { + xOffset = 30; + yOffset = 20; + } + + xCoords[0] = task->data[4] - xOffset; + xCoords[1] = task->data[4] - xOffset - 4; + xCoords[2] = task->data[4] + xOffset; + xCoords[3] = task->data[4] + xOffset + 4; + yCoords[0] = task->data[5] + yOffset; + yCoords[1] = task->data[5] + yOffset + 6; + + for (i = 0; i < 4; i++) + { + u8 spriteId = CreateSprite(&gFacadeSweatDrop, xCoords[i], yCoords[i & 1], task->data[6] - 5); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].data[0] = 0; + gSprites[spriteId].data[1] = i < 2 ? -2 : 2; + gSprites[spriteId].data[2] = -1; + gSprites[spriteId].data[3] = taskId; + gSprites[spriteId].data[4] = 2; + task->data[2]++; + } + } +} + +void AnimFacadeSweatDrop(struct Sprite *sprite) +{ + sprite->pos1.x += sprite->data[1]; + sprite->pos1.y += sprite->data[2]; + if (++sprite->data[0] > 6) + { + gTasks[sprite->data[3]].data[sprite->data[4]]--; + DestroySprite(sprite); + } +} + +// Blends the mon sprite's color with a rotating set of colors. +// arg 0: battler +// arg 1: duration +void AnimTask_FacadeColorBlend(u8 taskId) +{ + u8 spriteId; + + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gTasks[taskId].data[2] = 0x100 + gSprites[spriteId].oam.paletteNum * 16; + gTasks[taskId].func = AnimTask_FacadeColorBlendStep; +} + +static void AnimTask_FacadeColorBlendStep(u8 taskId) +{ + if (gTasks[taskId].data[1]) + { + BlendPalette(gTasks[taskId].data[2], 16, 8, gFacadeBlendColors[gTasks[taskId].data[0]]); + if (++gTasks[taskId].data[0] > 23) + gTasks[taskId].data[0] = 0; + + gTasks[taskId].data[1]--; + } + else + { + BlendPalette(gTasks[taskId].data[2], 16, 0, RGB(0, 0, 0)); + DestroyAnimVisualTask(taskId); + } +} + +void sub_80E2084(u8 taskId) +{ + sub_80BBA20(taskId, + 0, + 0x1A0, + gBattleAnimAttacker, + gBattleAnimArgs[0], + 10, + 2, + 30, + gCureBubblesGfx, + gCureBubblesTilemap, + gCureBubblesPal); +} + +// Moves a noise line from the mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: which direction (0 = upward, 1 = downward, 2 = horizontal) +void AnimRoarNoiseLine(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + gBattleAnimArgs[0] = -gBattleAnimArgs[0]; + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y) + gBattleAnimArgs[1]; + if (gBattleAnimArgs[2] == 0) + { + sprite->data[0] = 0x280; + sprite->data[1] = -0x280; + } + else if (gBattleAnimArgs[2] == 1) + { + sprite->vFlip = 1; + sprite->data[0] = 0x280; + sprite->data[1] = 0x280; + } + else + { + StartSpriteAnim(sprite, 1); + sprite->data[0] = 0x280; + } + + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->data[0] = -sprite->data[0]; + sprite->hFlip = 1; + } + + sprite->callback = AnimRoarNoiseLineStep; +} + +static void AnimRoarNoiseLineStep(struct Sprite *sprite) +{ + sprite->data[6] += sprite->data[0]; + sprite->data[7] += sprite->data[1]; + sprite->pos2.x = sprite->data[6] >> 8; + sprite->pos2.y = sprite->data[7] >> 8; + if (++sprite->data[5] == 14) + DestroyAnimSprite(sprite); +} + +// Makes a series of dots in a trail from the attacker to the target. +// arg 0: unused +void AnimTask_GlareEyeDots(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + if (IsContest()) + { + task->data[5] = 8; + task->data[6] = 3; + task->data[7] = 1; + } + else + { + task->data[5] = 12; + task->data[6] = 3; + task->data[7] = 0; + } + + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; + else + task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) - GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; + + task->data[12] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) - GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; + task->data[13] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + task->data[14] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); + task->func = AnimTask_GlareEyeDotsStep; +} + +static void AnimTask_GlareEyeDotsStep(u8 taskId) +{ + u8 i; + s16 x, y; + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + if (++task->data[1] > 3) + { + task->data[1] = 0; + GetGlareEyeDotCoords( + task->data[11], + task->data[12], + task->data[13], + task->data[14], + task->data[5], + task->data[2], + &x, + &y); + + for (i = 0; i < 2; i++) + { + u8 spriteId = CreateSprite(&gGlareEyeDotSpriteTemplate, x, y, 35); + if (spriteId != MAX_SPRITES) + { + if (task->data[7] == 0) + { + if (i == 0) + gSprites[spriteId].pos2.x = gSprites[spriteId].pos2.y = -task->data[6]; + else + gSprites[spriteId].pos2.x = gSprites[spriteId].pos2.y = task->data[6]; + } + else + { + if (i == 0) + { + gSprites[spriteId].pos2.x = -task->data[6]; + gSprites[spriteId].pos2.y = task->data[6]; + } + else + { + gSprites[spriteId].pos2.x = task->data[6]; + gSprites[spriteId].pos2.y = -task->data[6]; + } + } + + gSprites[spriteId].data[0] = 0; + gSprites[spriteId].data[1] = taskId; + gSprites[spriteId].data[2] = 10; + task->data[10]++; + } + } + + if (task->data[2] == task->data[5]) + task->data[0]++; + + task->data[2]++; + } + break; + case 1: + if (task->data[10] == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +static void GetGlareEyeDotCoords(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, s16 *x, s16 *y) +{ + int x2; + int y2; + + if (arg5 == 0) + { + *x = arg0; + *y = arg1; + return; + } + + if (arg5 >= arg4) + { + *x = arg2; + *y = arg3; + return; + } + + arg4--; + x2 = (arg0 << 8) + arg5 * (((arg2 - arg0) << 8) / arg4); + y2 = (arg1 << 8) + arg5 * (((arg3 - arg1) << 8) / arg4); + *x = x2 >> 8; + *y = y2 >> 8; +} + +void AnimGlareEyeDot(struct Sprite *sprite) +{ + if (++sprite->data[0] > 36) + { + gTasks[sprite->data[1]].data[sprite->data[2]]--; + DestroySprite(sprite); + } +} + +// Moves a pawprint in a straight line. +// arg 0: initial x position +// arg 1: initial y position +// arg 2: destination x position +// arg 3: destination y position +// arg 4: duration +void AnimAssistPawprint(struct Sprite *sprite) +{ + sprite->pos1.x = gBattleAnimArgs[0]; + sprite->pos1.y = gBattleAnimArgs[1]; + sprite->data[2] = gBattleAnimArgs[2]; + sprite->data[4] = gBattleAnimArgs[3]; + sprite->data[0] = gBattleAnimArgs[4]; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = InitAndRunAnimFastLinearTranslation; +} + +// Moves a ball in an arc twoards the target, and rotates the ball while arcing. +// No args. +void AnimTask_BarrageBall(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + task->data[12] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); + task->data[13] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + task->data[14] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT) / 4; + task->data[15] = CreateSprite(&gBarrageBallSpriteTemplate, task->data[11], task->data[12], GetBattlerSpriteSubpriority(gBattleAnimTarget) - 5); + if (task->data[15] != MAX_SPRITES) + { + gSprites[task->data[15]].data[0] = 16; + gSprites[task->data[15]].data[2] = task->data[13]; + gSprites[task->data[15]].data[4] = task->data[14]; + gSprites[task->data[15]].data[5] = -32; + InitAnimArcTranslation(&gSprites[task->data[15]]); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) + StartSpriteAffineAnim(&gSprites[task->data[15]], 1); + + task->func = AnimTask_BarrageBallStep; + } + else + { + DestroyAnimVisualTask(taskId); + } +} + +static void AnimTask_BarrageBallStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + if (++task->data[1] > 1) + { + task->data[1] = 0; + TranslateAnimHorizontalArc(&gSprites[task->data[15]]); + if (++task->data[2] > 7) + task->data[0]++; + } + break; + case 1: + if (TranslateAnimHorizontalArc(&gSprites[task->data[15]])) + { + task->data[1] = 0; + task->data[2] = 0; + task->data[0]++; + } + break; + case 2: + if (++task->data[1] > 1) + { + task->data[1] = 0; + task->data[2]++; + gSprites[task->data[15]].invisible = task->data[2] & 1; + if (task->data[2] == 16) + { + FreeOamMatrix(gSprites[task->data[15]].oam.matrixNum); + DestroySprite(&gSprites[task->data[15]]); + task->data[0]++; + } + } + break; + case 3: + DestroyAnimVisualTask(taskId); + break; + } +} + +// Moves a hand back and forth in a squishing motion. +// arg 0: which battler +// arg 1: horizontal flip +// arg 2: num squishes +void AnimSmellingSaltsHand(struct Sprite *sprite) +{ + u8 battler; + + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + sprite->oam.tileNum += 16; + sprite->data[6] = gBattleAnimArgs[2]; + sprite->data[7] = gBattleAnimArgs[1] == 0 ? -1 : 1; + sprite->pos1.y = GetBattlerSpriteCoord(battler, 3); + if (gBattleAnimArgs[1] == 0) + { + sprite->oam.matrixNum |= ST_OAM_HFLIP; + sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_LEFT) - 8; + } + else + { + sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_RIGHT) + 8; + } + + sprite->callback = AnimSmellingSaltsHand_Step; +} + +static void AnimSmellingSaltsHand_Step(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + sprite->pos2.x += sprite->data[7]; + if (++sprite->data[2] == 12) + sprite->data[0]++; + } + break; + case 1: + if (++sprite->data[1] == 8) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 2: + sprite->pos2.x -= sprite->data[7] * 4; + if (++sprite->data[1] == 6) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 3: + sprite->pos2.x += sprite->data[7] * 3; + if (++sprite->data[1] == 8) + { + if (--sprite->data[6]) + { + sprite->data[1] = 0; + sprite->data[0]--; + } + else + { + DestroyAnimSprite(sprite); + } + } + break; + } +} + +// Squishes the mon horizontally a few times. +// arg 0: which mon +// arg 1: number of squishes +void AnimTask_SmellingSaltsSquish(u8 taskId) +{ + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + { + DestroyAnimVisualTask(taskId); + } + else + { + gTasks[taskId].data[0] = gBattleAnimArgs[1]; + gTasks[taskId].data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], gSmellingSaltsSquishAffineAnimCmds); + gTasks[taskId].func = AnimTask_SmellingSaltsSquishStep; + } +} + +static void AnimTask_SmellingSaltsSquishStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + if (++task->data[1] > 1) + { + task->data[1] = 0; + if (!(task->data[2] & 1)) + gSprites[task->data[15]].pos2.x = 2; + else + gSprites[task->data[15]].pos2.x = -2; + } + + if (!RunAffineAnimFromTaskData(task)) + { + gSprites[task->data[15]].pos2.x = 0; + if (--task->data[0]) + { + PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], gSmellingSaltsSquishAffineAnimCmds); + task->data[1] = 0; + task->data[2] = 0; + } + else + { + DestroyAnimVisualTask(taskId); + } + } +} + +// Blinks an exclamation image over the mon a few times. +// arg 0: which mon +// arg 1: blink delay +// arg 2: number of blinks +void AnimSmellingSaltExclamation(struct Sprite *sprite) +{ + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_TOP); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->pos1.y = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_TOP); + } + + if (sprite->pos1.y < 8) + sprite->pos1.y = 8; + + sprite->data[0] = 0; + sprite->data[1] = gBattleAnimArgs[1]; + sprite->data[2] = 0; + sprite->data[3] = gBattleAnimArgs[2]; + sprite->callback = AnimSmellingSaltExclamationStep; +} + +static void AnimSmellingSaltExclamationStep(struct Sprite *sprite) +{ + if (++sprite->data[0] >= sprite->data[1]) + { + sprite->data[0] = 0; + sprite->data[2] = (sprite->data[2] + 1) & 1; + sprite->invisible = sprite->data[2]; + if (sprite->data[2] && --sprite->data[3] == 0) + DestroyAnimSprite(sprite); + } +} + +// Claps a hand several times. +// arg 0: which hand +// arg 1: +void AnimHelpingHandClap(struct Sprite *sprite) +{ + if (gBattleAnimArgs[0] == 0) + { + sprite->oam.matrixNum |= ST_OAM_HFLIP; + sprite->pos1.x = 100; + sprite->data[7] = 1; + } + else + { + sprite->pos1.x = 140; + sprite->data[7] = -1; + } + + sprite->pos1.y = 56; + sprite->callback = AnimHelpingHandClapStep; +} + +static void AnimHelpingHandClapStep(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->pos1.y -= sprite->data[7] * 2; + if (sprite->data[1] & 1) + sprite->pos1.x -= sprite->data[7] * 2; + + if (++sprite->data[1] == 9) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 1: + if (++sprite->data[1] == 4) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 2: + sprite->data[1]++; + sprite->pos1.y += sprite->data[7] * 3; + sprite->pos2.x = sprite->data[7] * (gSineTable[sprite->data[1] * 10] >> 3); + if (sprite->data[1] == 12) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 3: + if (++sprite->data[1] == 2) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 4: + sprite->data[1]++; + sprite->pos1.y -= sprite->data[7] * 3; + sprite->pos2.x = sprite->data[7] * (gSineTable[sprite->data[1] * 10] >> 3); + if (sprite->data[1] == 12) + sprite->data[0]++; + break; + case 5: + sprite->data[1]++; + sprite->pos1.y += sprite->data[7] * 3; + sprite->pos2.x = sprite->data[7] * (gSineTable[sprite->data[1] * 10] >> 3); + if (sprite->data[1] == 15) + sprite->oam.tileNum += 16; + + if (sprite->data[1] == 18) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 6: + sprite->pos1.x += sprite->data[7] * 6; + if (++sprite->data[1] == 9) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 7: + sprite->pos1.x += sprite->data[7] * 2; + if (++sprite->data[1] == 1) + { + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 8: + sprite->pos1.x -= sprite->data[7] * 3; + if (++sprite->data[1] == 5) + DestroyAnimSprite(sprite); + break; + } +} + +// Repeatedly moves the attacking mon in a horizontal lunging motion. +// No args. +void AnimTask_HelpingHandAttackerMovement(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + if (!IsContest()) + { + if (IsDoubleBattle() == TRUE) + { + int x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + int y = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimAttacker), 0); + if (x > y) + task->data[14] = 1; + else + task->data[14] = -1; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + task->data[14] = -1; + else + task->data[14] = 1; + } + } + else + { + task->data[14] = 1; + } + + task->func = AnimTask_HelpingHandAttackerMovementStep; +} + +static void AnimTask_HelpingHandAttackerMovementStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + if (++task->data[1] == 13) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 1: + gSprites[task->data[15]].pos2.x -= task->data[14] * 3; + if (++task->data[1] == 6) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 2: + gSprites[task->data[15]].pos2.x += task->data[14] * 3; + if (++task->data[1] == 6) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 3: + if (++task->data[1] == 2) + { + task->data[1] = 0; + if (task->data[2] == 0) + { + task->data[2]++; + task->data[0] = 1; + } + else + { + task->data[0]++; + } + } + break; + case 4: + gSprites[task->data[15]].pos2.x += task->data[14]; + if (++task->data[1] == 3) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 5: + if (++task->data[1] == 6) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 6: + gSprites[task->data[15]].pos2.x -= task->data[14] * 4; + if (++task->data[1] == 5) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 7: + gSprites[task->data[15]].pos2.x += task->data[14] * 4; + if (++task->data[1] == 5) + { + task->data[1] = 0; + task->data[0]++; + } + break; + case 8: + gSprites[task->data[15]].pos2.x = 0; + DestroyAnimVisualTask(taskId); + break; + } +} + +// Moves a magnifying glass around in straight lines. +// arg 0: magnifying glass target mon +void AnimForesightMagnifyingGlass(struct Sprite *sprite) +{ + if (gBattleAnimArgs[0] == ANIM_ATTACKER) + { + InitSpritePosToAnimAttacker(sprite, TRUE); + sprite->data[7] = gBattleAnimAttacker; + } + else + { + sprite->data[7] = gBattleAnimTarget; + } + + if (GetBattlerSide(sprite->data[7]) == B_SIDE_OPPONENT) + sprite->oam.matrixNum = ST_OAM_HFLIP; + + sprite->oam.priority = GetBattlerSpriteBGPriority(sprite->data[7]); + sprite->oam.objMode = ST_OAM_OBJ_BLEND; + sprite->callback = AnimForesightMagnifyingGlassStep; +} + +static void AnimForesightMagnifyingGlassStep(struct Sprite *sprite) +{ + u16 x, y; + + switch (sprite->data[5]) + { + case 0: + switch (sprite->data[6]) + { + default: + sprite->data[6] = 0; + case 0: + case 4: + x = GetBattlerSpriteCoordAttr(sprite->data[7], 5) - 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], 3) - 4; + break; + case 1: + x = GetBattlerSpriteCoordAttr(sprite->data[7], 5) - 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], 2) + 4; + break; + case 2: + x = GetBattlerSpriteCoordAttr(sprite->data[7], 4) + 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], 3) - 4; + break; + case 3: + x = GetBattlerSpriteCoordAttr(sprite->data[7], 4) + 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], 2) - 4; + break; + case 5: + x = GetBattlerSpriteCoord(sprite->data[7], 2); + y = GetBattlerSpriteCoord(sprite->data[7], 3); + break; + } + + if (sprite->data[6] == 4) + sprite->data[0] = 24; + else if (sprite->data[6] == 5) + sprite->data[0] = 6; + else + sprite->data[0] = 12; + + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = x; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = y; + InitAnimLinearTranslation(sprite); + sprite->data[5]++; + break; + case 1: + if (AnimTranslateLinear(sprite)) + { + switch (sprite->data[6]) + { + default: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[0] = 0; + sprite->data[5]++; + sprite->data[6]++; + break; + case 4: + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + sprite->data[5] = 0; + sprite->data[6]++; + break; + case 5: + sprite->data[0] = 0; + sprite->data[1] = 16; + sprite->data[2] = 0; + sprite->data[5] = 3; + break; + } + } + break; + case 2: + if (++sprite->data[0] == 4) + sprite->data[5] = 0; + break; + case 3: + if (!(sprite->data[0] & 1)) + sprite->data[1]--; + else + sprite->data[2]++; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[1], sprite->data[2])); + if (++sprite->data[0] == 32) + { + sprite->invisible = 1; + sprite->data[5]++; + } + break; + case 4: + DestroyAnimSprite(sprite); + break; + } +} + +static void AnimMeteorMashStarStep(struct Sprite *sprite) +{ + sprite->pos2.x = ((sprite->data[2] - sprite->data[0]) * sprite->data[5]) / sprite->data[4]; + sprite->pos2.y = ((sprite->data[3] - sprite->data[1]) * sprite->data[5]) / sprite->data[4]; + if (!(sprite->data[5] & 1)) + { + CreateSprite( + &gMiniTwinklingStarSpriteTemplate, + sprite->pos1.x + sprite->pos2.x, + sprite->pos1.y + sprite->pos2.y, 5); + } + + if (sprite->data[5] == sprite->data[4]) + DestroyAnimSprite(sprite); + + sprite->data[5]++; +} + +// Moves a shooting star across the screen that leaves little twinkling stars behind its path. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +// arg 2: destination x pixel offset +// arg 3: destination y pixel offset +// arg 4: duration +void AnimMeteorMashStar(struct Sprite *sprite) +{ + s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); // unused local variable + s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); // unused local variable + + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER || IsContest()) + { + sprite->data[0] = sprite->pos1.x - gBattleAnimArgs[0]; + sprite->data[2] = sprite->pos1.x - gBattleAnimArgs[2]; + } + else + { + sprite->data[0] = sprite->pos1.x + gBattleAnimArgs[0]; + sprite->data[2] = sprite->pos1.x + gBattleAnimArgs[2]; + } + + sprite->data[1] = sprite->pos1.y + gBattleAnimArgs[1]; + sprite->data[3] = sprite->pos1.y + gBattleAnimArgs[3]; + sprite->data[4] = gBattleAnimArgs[4]; + sprite->pos1.x = sprite->data[0]; + sprite->pos1.y = sprite->data[1]; + sprite->callback = AnimMeteorMashStarStep; +} + +void AnimTask_MonToSubstitute(u8 taskId) +{ + int i; + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + + if (gTasks[taskId].data[0] == 0) + { + PrepareBattlerSpriteForRotScale(spriteId, FALSE); + gTasks[taskId].data[1] = 0x100; + gTasks[taskId].data[2] = 0x100; + gTasks[taskId].data[0]++; + } + else if (gTasks[taskId].data[0] == 1) + { + gTasks[taskId].data[1] += 0x60; + gTasks[taskId].data[2] -= 0xD; + SetSpriteRotScale(spriteId, gTasks[taskId].data[1], gTasks[taskId].data[2], 0); + if (++gTasks[taskId].data[3] == 9) + { + gTasks[taskId].data[3] = 0; + ResetSpriteRotScale(spriteId); + gSprites[spriteId].invisible = 1; + gTasks[taskId].data[0]++; + } + } + else + { + LoadBattleMonGfxAndAnimate(gBattleAnimAttacker, 0, spriteId); + for (i = 0; i < 16; i++) + gTasks[taskId].data[i] = 0; + + gTasks[taskId].func = AnimTask_MonToSubstituteDoll; + } +} + +static void AnimTask_MonToSubstituteDoll(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + + switch (gTasks[taskId].data[0]) + { + case 0: + gSprites[spriteId].pos2.y = -200; + gSprites[spriteId].pos2.x = 200; + gSprites[spriteId].invisible = 0; + gTasks[taskId].data[10] = 0; + gTasks[taskId].data[0]++; + break; + case 1: + gTasks[taskId].data[10] += 112; + gSprites[spriteId].pos2.y += gTasks[taskId].data[10] >> 8; + if (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y >= -32) + gSprites[spriteId].pos2.x = 0; + + if (gSprites[spriteId].pos2.y > 0) + gSprites[spriteId].pos2.y = 0; + + if (gSprites[spriteId].pos2.y == 0) + { + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + gTasks[taskId].data[10] -= 0x800; + gTasks[taskId].data[0]++; + } + break; + case 2: + gTasks[taskId].data[10] -= 112; + if (gTasks[taskId].data[10] < 0) + gTasks[taskId].data[10] = 0; + + gSprites[spriteId].pos2.y -= gTasks[taskId].data[10] >> 8; + if (gTasks[taskId].data[10] == 0) + gTasks[taskId].data[0]++; + break; + case 3: + gTasks[taskId].data[10] += 112; + gSprites[spriteId].pos2.y += gTasks[taskId].data[10] >> 8; + if (gSprites[spriteId].pos2.y > 0) + gSprites[spriteId].pos2.y = 0; + + if (gSprites[spriteId].pos2.y == 0) + { + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + DestroyAnimVisualTask(taskId); + } + break; + } +} + +// Moves down an X that flickers and disappears. +// No args. +void AnimBlockX(struct Sprite *sprite) +{ + s16 y; + + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) - 2; + y = -144; + } + else + { + sprite->subpriority = GetBattlerSpriteSubpriority(gBattleAnimTarget) + 2; + y = -96; + } + + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->pos2.y = y; + sprite->callback = AnimBlockXStep; +} + +static void AnimBlockXStep(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->pos2.y += 10; + if (sprite->pos2.y >= 0) + { + PlaySE12WithPanning(SE_W166, BattleAnimAdjustPanning(63)); + sprite->pos2.y = 0; + sprite->data[0]++; + } + break; + case 1: + sprite->data[1] += 4; + sprite->pos2.y = -(gSineTable[sprite->data[1]] >> 3); + if (sprite->data[1] > 0x7F) + { + PlaySE12WithPanning(SE_W166, BattleAnimAdjustPanning(63)); + sprite->data[1] = 0; + sprite->pos2.y = 0; + sprite->data[0]++; + } + break; + case 2: + sprite->data[1] += 6; + sprite->pos2.y = -(gSineTable[sprite->data[1]] >> 4); + if (sprite->data[1] > 0x7F) + { + sprite->data[1] = 0; + sprite->pos2.y = 0; + sprite->data[0]++; + } + break; + case 3: + if (++sprite->data[1] > 8) + { + PlaySE12WithPanning(SE_W043, BattleAnimAdjustPanning(63)); + sprite->data[1] = 0; + sprite->data[0]++; + } + break; + case 4: + if (++sprite->data[1] > 8) + { + sprite->data[1] = 0; + sprite->data[2]++; + sprite->invisible = sprite->data[2] & 1; + if (sprite->data[2] == 7) + DestroyAnimSprite(sprite); + } + break; + } +} + +// Quickly moves two clones of the target mon back and forth. +// No args. +void AnimTask_OdorSleuthMovement(u8 taskId) +{ + s16 spriteId1, spriteId2; + + if (IsContest()) + { + DestroyAnimVisualTask(taskId); + return; + } + + spriteId1 = CloneBattlerSpriteWithBlend(ANIM_TARGET); + if (spriteId1 < 0) + { + DestroyAnimVisualTask(taskId); + return; + } + + spriteId2 = CloneBattlerSpriteWithBlend(ANIM_TARGET); + if (spriteId2 < 0) + { + obj_delete_but_dont_free_vram(&gSprites[spriteId1]); + DestroyAnimVisualTask(taskId); + return; + } + + gSprites[spriteId2].pos2.x += 24; + gSprites[spriteId1].pos2.x -= 24; + gSprites[spriteId2].data[0] = 0; + gSprites[spriteId1].data[0] = 0; + gSprites[spriteId2].data[1] = 0; + gSprites[spriteId1].data[1] = 0; + gSprites[spriteId2].data[2] = 0; + gSprites[spriteId1].data[2] = 0; + gSprites[spriteId2].data[3] = 16; + gSprites[spriteId1].data[3] = -16; + gSprites[spriteId2].data[4] = 0; + gSprites[spriteId1].data[4] = 128; + gSprites[spriteId2].data[5] = 24; + gSprites[spriteId1].data[5] = 24; + gSprites[spriteId2].data[6] = taskId; + gSprites[spriteId1].data[6] = taskId; + gSprites[spriteId2].data[7] = 0; + gSprites[spriteId1].data[7] = 0; + gTasks[taskId].data[0] = 2; + + if (!gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].invisible) + { + gSprites[spriteId2].invisible = 0; + gSprites[spriteId1].invisible = 1; + } + else + { + gSprites[spriteId2].invisible = 1; + gSprites[spriteId1].invisible = 1; + } + + gSprites[spriteId2].oam.objMode = ST_OAM_OBJ_NORMAL; + gSprites[spriteId1].oam.objMode = ST_OAM_OBJ_NORMAL; + gSprites[spriteId2].callback = MoveOdorSleuthClone; + gSprites[spriteId1].callback = MoveOdorSleuthClone; + gTasks[taskId].func = AnimTask_OdorSleuthMovementWaitFinish; +} + +static void AnimTask_OdorSleuthMovementWaitFinish(u8 taskId) +{ + if (gTasks[taskId].data[0] == 0) + DestroyAnimVisualTask(taskId); +} + +static void MoveOdorSleuthClone(struct Sprite *sprite) +{ + int zero = 0; + if (++sprite->data[1] > 1) + { + sprite->data[1] = 0; + if (!gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].invisible) + sprite->invisible ^= 1; + } + + sprite->data[4] = sprite->data[4] + sprite->data[3]; + sprite->data[4] &= 0xFF; + sprite->pos2.x = Cos(sprite->data[4], sprite->data[5]); + switch (sprite->data[0]) + { + case 0: + if (++sprite->data[2] == 60) + { + sprite->data[2] = 0; + sprite->data[0]++; + } + break; + case 1: + if (++sprite->data[2] > 0) + { + sprite->data[2] = 0; + sprite->data[5] -= 2; + if (sprite->data[5] < 0) + { + gTasks[sprite->data[6]].data[sprite->data[7]]--; + obj_delete_but_dont_free_vram(sprite); + } + } + break; + } +} + +void AnimTask_GetReturnPowerLevel(u8 taskId) +{ + gBattleAnimArgs[7] = 0; + if (gAnimFriendship < 60) + gBattleAnimArgs[7] = 0; + if (gAnimFriendship > 60 && gAnimFriendship < 92) + gBattleAnimArgs[7] = 1; + if (gAnimFriendship > 91 && gAnimFriendship < 201) + gBattleAnimArgs[7] = 2; + if (gAnimFriendship > 200) + gBattleAnimArgs[7] = 3; + + DestroyAnimVisualTask(taskId); +} + +// Makes the mon run out of screen, run past the opposing mon, and return to its original position. +// No args. +void AnimTask_SnatchOpposingMonMove(u8 taskId) +{ + u8 spriteId, spriteId2; + int personality; + int otId; + u16 species; + u8 subpriority; + u8 isBackPic; + s16 x; + + switch (gTasks[taskId].data[0]) + { + case 0: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.x += (gTasks[taskId].data[1] >> 8); + else + gSprites[spriteId].pos2.x -= (gTasks[taskId].data[1] >> 8); + + gTasks[taskId].data[1] &= 0xFF; + x = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x; + if ((u16)(x + 32) > 304) + { + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[0]++; + } + break; + case 1: + if (IsContest()) + { + personality = gContestResources->field_18->unk8; + otId = gContestResources->field_18->unkC; + species = gContestResources->field_18->species; + subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker); + isBackPic = 0; + x = -32; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; + isBackPic = 0; + x = 272; + } + else + { + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + isBackPic = 1; + x = -32; + } + } + + spriteId2 = sub_80A8394(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) + BlendPalette((gSprites[spriteId2].oam.paletteNum * 16) | 0x100, 16, 6, RGB_WHITE); + + gTasks[taskId].data[15] = spriteId2; + gTasks[taskId].data[0]++; + break; + case 2: + spriteId2 = gTasks[taskId].data[15]; + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId2].pos2.x -= (gTasks[taskId].data[1] >> 8); + else + gSprites[spriteId2].pos2.x += (gTasks[taskId].data[1] >> 8); + + gTasks[taskId].data[1] &= 0xFF; + x = gSprites[spriteId2].pos1.x + gSprites[spriteId2].pos2.x; + if (gTasks[taskId].data[14] == 0) + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + if (x < GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X)) + { + gTasks[taskId].data[14]++; + gBattleAnimArgs[7] = 0xFFFF; + } + } + else + { + if (x > GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X)) + { + gTasks[taskId].data[14]++; + gBattleAnimArgs[7] = 0xFFFF; + } + } + } + + if ((u16)(x + 32) > 304) + { + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[0]++; + } + break; + case 3: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + spriteId2 = gTasks[taskId].data[15]; + DestroySpriteAndFreeResources_(&gSprites[spriteId2]); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos1.x - 32; + else + gSprites[spriteId].pos2.x = 272 - gSprites[spriteId].pos1.x; + + gTasks[taskId].data[0]++; + break; + case 4: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + gSprites[spriteId].pos2.x += (gTasks[taskId].data[1] >> 8); + if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x >= GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X)) + gSprites[spriteId].pos2.x = 0; + } + else + { + gSprites[spriteId].pos2.x -= (gTasks[taskId].data[1] >> 8); + if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x <= GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X)) + gSprites[spriteId].pos2.x = 0; + } + + gTasks[taskId].data[1] = (u8)gTasks[taskId].data[1]; + if (gSprites[spriteId].pos2.x == 0) + DestroyAnimVisualTask(taskId); + break; + } +} + +void sub_80E3E84(struct Sprite *sprite) +{ + switch (sprite->data[7]) + { + case 0: + if (gBattleAnimArgs[7] == -1) + { + PlaySE12WithPanning(SE_W233, BattleAnimAdjustPanning(63)); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + 16; + sprite->data[0] = -32; + sprite->data[7]++; + sprite->invisible = 0; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT && !IsContest()) + sprite->subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + } + else + { + sprite->invisible = 1; + } + break; + case 1: + sprite->pos2.y = Sin(sprite->data[1], sprite->data[0]); + sprite->data[1] += 5; + if (sprite->data[1] > 0x7F) + { + sprite->data[0] = sprite->data[0] / 2; + sprite->data[3]++; + sprite->data[1] -= 0x7F; + } + + sprite->data[2] += 0x100; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + sprite->pos2.x -= (sprite->data[2] >> 8); + else + sprite->pos2.x += (sprite->data[2] >> 8); + + sprite->data[2] &= 0xFF; + if (sprite->data[3] == 2) + DestroyAnimSprite(sprite); + break; + } +} + +// Quickly moves the mon towards its partner and back. +// No args. +void AnimTask_SnatchPartnerMove(u8 taskId) +{ + s16 attackerX, targetX; + u8 spriteId; + + switch (gTasks[taskId].data[15]) + { + case 0: + attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + gTasks[taskId].data[0] = 6; + if (attackerX > targetX) + gTasks[taskId].data[0] *= -1; + + gTasks[taskId].data[1] = attackerX; + gTasks[taskId].data[2] = targetX; + gTasks[taskId].data[15]++; + break; + case 1: + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + gSprites[spriteId].pos2.x += gTasks[taskId].data[0]; + if (gTasks[taskId].data[0] > 0) + { + if (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x >= gTasks[taskId].data[2]) + gTasks[taskId].data[15]++; + } + else + { + if (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x <= gTasks[taskId].data[2]) + gTasks[taskId].data[15]++; + } + break; + case 2: + gTasks[taskId].data[0] *= -1; + gTasks[taskId].data[15]++; + break; + case 3: + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + gSprites[spriteId].pos2.x += gTasks[taskId].data[0]; + if (gTasks[taskId].data[0] < 0) + { + if (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x <= gTasks[taskId].data[1]) + gTasks[taskId].data[15]++; + } + else + { + if (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x >= gTasks[taskId].data[1]) + gTasks[taskId].data[15]++; + } + break; + case 4: + default: + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + gSprites[spriteId].pos2.x = 0; + DestroyAnimVisualTask(taskId); + break; + } +} + +// Moves the mon's sprite back and forth in an unpredictable swaying motion. +// No args. +void AnimTask_TeeterDanceMovement(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + task->data[3] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[4] = GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER ? 1 : -1; + task->data[6] = gSprites[task->data[3]].pos1.y; + task->data[5] = gSprites[task->data[3]].pos1.x; + task->data[9] = 0; + task->data[11] = 0; + task->data[10] = 1; + task->data[12] = 0; + task->func = AnimTask_TeeterDanceMovementStep; +} + +static void AnimTask_TeeterDanceMovementStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + switch (task->data[0]) + { + case 0: + task->data[11] += 8; + task->data[11] &= 0xFF; + gSprites[task->data[3]].pos2.x = gSineTable[task->data[11]] >> 5; + task->data[9] += 2; + task->data[9] &= 0xFF; + gSprites[task->data[3]].pos1.x = (gSineTable[task->data[9]] >> 3) * task->data[4] + task->data[5]; + if (task->data[9] == 0) + { + gSprites[task->data[3]].pos1.x = task->data[5]; + task->data[0]++; + } + break; + case 1: + task->data[11] += 8; + task->data[11] &= 0xFF; + gSprites[task->data[3]].pos2.x = gSineTable[task->data[11]] >> 5; + if (task->data[11] == 0) + { + gSprites[task->data[3]].pos2.x = 0; + task->data[0]++; + } + break; + case 2: + DestroyAnimVisualTask(taskId); + break; + } +} + +static void AnimKnockOffStrikeStep(struct Sprite *sprite) +{ + // These two cases are identical. + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + sprite->data[1] += sprite->data[0]; + sprite->data[1] &= 0xFF; + } + else + { + sprite->data[1] += sprite->data[0]; + sprite->data[1] &= 0xFF; + } + + sprite->pos2.x = Cos(sprite->data[1], 20); + sprite->pos2.y = Sin(sprite->data[1], 20); + if (sprite->animEnded) + DestroyAnimSprite(sprite); + + sprite->data[2]++; +} + +// Animates a strike that swipes downard at the target mon. +// arg 0: initial x pixel offset +// arg 1: initial y pixel offset +void AnimKnockOffStrike(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + { + sprite->pos1.x -= gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = -11; + sprite->data[1] = 192; + StartSpriteAffineAnim(sprite, 1); + } + else + { + sprite->data[0] = 11; + sprite->data[1] = 192; + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + } + + sprite->callback = AnimKnockOffStrikeStep; +} + +// Gradually fades a rotating recyle arrow sprite in and back out. +// No args. +void AnimRecycle(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_TOP); + if (sprite->pos1.y < 16) + sprite->pos1.y = 16; + + sprite->data[6] = 0; + sprite->data[7] = 16; + sprite->callback = AnimRecycleStep; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); +} + +static void AnimRecycleStep(struct Sprite *sprite) +{ + switch (sprite->data[2]) + { + case 0: + if (++sprite->data[0] > 1) + { + sprite->data[0] = 0; + if (!(sprite->data[1] & 1)) + { + if (sprite->data[6] < 16) + sprite->data[6]++; + } + else + { + if (sprite->data[7] != 0) + sprite->data[7]--; + } + + sprite->data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + if (sprite->data[7] == 0) + sprite->data[2]++; + } + break; + case 1: + if (++sprite->data[0] == 10) + { + sprite->data[0] = 0; + sprite->data[1] = 0; + sprite->data[2]++; + } + break; + case 2: + if (++sprite->data[0] > 1) + { + sprite->data[0] = 0; + if (!(sprite->data[1] & 1)) + { + if (sprite->data[6] != 0) + sprite->data[6]--; + } + else + { + if (sprite->data[7] < 16) + sprite->data[7]++; + } + + sprite->data[1]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[6], sprite->data[7])); + if (sprite->data[7] == 16) + sprite->data[2]++; + } + break; + case 3: + DestroySpriteAndMatrix(sprite); + break; + } +} + +void AnimTask_GetWeather(u8 taskId) +{ + gBattleAnimArgs[7] = ANIM_WEATHER_NONE; + if (gWeatherMoveAnim & WEATHER_SUN_ANY) + gBattleAnimArgs[7] = ANIM_WEATHER_SUN; + else if (gWeatherMoveAnim & WEATHER_RAIN_ANY) + gBattleAnimArgs[7] = ANIM_WEATHER_RAIN; + else if (gWeatherMoveAnim & WEATHER_SANDSTORM_ANY) + gBattleAnimArgs[7] = ANIM_WEATHER_SANDSTORM; + else if (gWeatherMoveAnim & WEATHER_HAIL_ANY) + gBattleAnimArgs[7] = ANIM_WEATHER_HAIL; + + DestroyAnimVisualTask(taskId); +} + +// Squishes the mon sprite vertically, and shakes it back and forth. +// arg 0: which battler +void AnimTask_SlackOffSquish(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + task->data[0] = 0; + task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + PrepareAffineAnimInTaskData(task, task->data[15], gSlackOffSquishAffineAnimCmds); + task->func = AnimTask_SlackOffSquishStep; +} + +static void AnimTask_SlackOffSquishStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + gTasks[taskId].data[0]++; + if (gTasks[taskId].data[0] > 16 && gTasks[taskId].data[0] < 40) + { + if (++task->data[1] > 2) + { + task->data[1] = 0; + task->data[2]++; + if (!(task->data[2] & 1)) + gSprites[task->data[15]].pos2.x = -1; + else + gSprites[task->data[15]].pos2.x = 1; + } + } + else + { + gSprites[task->data[15]].pos2.x = 0; + } + + if (!RunAffineAnimFromTaskData(&gTasks[taskId])) + DestroyAnimVisualTask(taskId); +} -- cgit v1.2.3 From 0cc5446a2a28b6050c8c496416de4b8acdc87929 Mon Sep 17 00:00:00 2001 From: Evan Date: Mon, 2 Dec 2019 15:49:22 -0700 Subject: init battle_anim_special --- src/battle_anim_effects_3.c | 282 +++--- src/battle_anim_special.c | 2296 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2440 insertions(+), 138 deletions(-) create mode 100644 src/battle_anim_special.c (limited to 'src') diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 89f66139f..4fd6ada0b 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -120,7 +120,9 @@ static void MoveOdorSleuthClone(struct Sprite *); static void AnimTask_TeeterDanceMovementStep(u8); static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); -const union AnimCmd gScratchAnimCmds[] = + +// Data +const union AnimCmd gScratchAnimCmds[] = //83FEDE4 { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -130,12 +132,12 @@ const union AnimCmd gScratchAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gScratchAnimTable[] = +const union AnimCmd *const gScratchAnimTable[] = //83FEDFC { gScratchAnimCmds, }; -const struct SpriteTemplate gScratchSpriteTemplate = +const struct SpriteTemplate gScratchSpriteTemplate = //83FEE00 { .tileTag = ANIM_TAG_SCRATCH, .paletteTag = ANIM_TAG_SCRATCH, @@ -146,7 +148,7 @@ const struct SpriteTemplate gScratchSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gBlackSmokeSpriteTemplate = +const struct SpriteTemplate gBlackSmokeSpriteTemplate = //83FEE18 { .tileTag = ANIM_TAG_BLACK_SMOKE, .paletteTag = ANIM_TAG_BLACK_SMOKE, @@ -157,7 +159,7 @@ const struct SpriteTemplate gBlackSmokeSpriteTemplate = .callback = AnimBlackSmoke, }; -const struct SpriteTemplate gBlackBallSpriteTemplate = +const struct SpriteTemplate gBlackBallSpriteTemplate = //83FEE30 { .tileTag = ANIM_TAG_BLACK_BALL, .paletteTag = ANIM_TAG_BLACK_BALL, @@ -168,7 +170,7 @@ const struct SpriteTemplate gBlackBallSpriteTemplate = .callback = AnimThrowProjectile, }; -const union AnimCmd gOpeningEyeAnimCmds[] = +const union AnimCmd gOpeningEyeAnimCmds[] = //83FEE48 { ANIMCMD_FRAME(0, 40), ANIMCMD_FRAME(16, 8), @@ -176,12 +178,12 @@ const union AnimCmd gOpeningEyeAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gOpeningEyeAnimTable[] = +const union AnimCmd *const gOpeningEyeAnimTable[] = //83FEE58 { gOpeningEyeAnimCmds, }; -const struct SpriteTemplate gOpeningEyeSpriteTemplate = +const struct SpriteTemplate gOpeningEyeSpriteTemplate = //83FEE5C { .tileTag = ANIM_TAG_OPENING_EYE, .paletteTag = ANIM_TAG_OPENING_EYE, @@ -192,7 +194,7 @@ const struct SpriteTemplate gOpeningEyeSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gWhiteHaloSpriteTemplate = +const struct SpriteTemplate gWhiteHaloSpriteTemplate = //83FEE74 { .tileTag = ANIM_TAG_ROUND_WHITE_HALO, .paletteTag = ANIM_TAG_ROUND_WHITE_HALO, @@ -203,7 +205,7 @@ const struct SpriteTemplate gWhiteHaloSpriteTemplate = .callback = AnimWhiteHalo, }; -const struct SpriteTemplate gTealAlertSpriteTemplate = +const struct SpriteTemplate gTealAlertSpriteTemplate = //83FEE8C { .tileTag = ANIM_TAG_TEAL_ALERT, .paletteTag = ANIM_TAG_TEAL_ALERT, @@ -214,7 +216,7 @@ const struct SpriteTemplate gTealAlertSpriteTemplate = .callback = AnimTealAlert, }; -const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = //83FEEA4 { AFFINEANIMCMD_FRAME(0x180, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x20, 0x18, 0, 5), @@ -222,20 +224,20 @@ const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = //83FEEC4 { AFFINEANIMCMD_FRAME(0x30, 0x30, 0, 0), AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 6), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = +const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = //83FEEDC { gMeanLookEyeAffineAnimCmds1, gMeanLookEyeAffineAnimCmds2, }; -const struct SpriteTemplate gMeanLookEyeSpriteTemplate = +const struct SpriteTemplate gMeanLookEyeSpriteTemplate = //83FEEE4 { .tileTag = ANIM_TAG_EYE, .paletteTag = ANIM_TAG_EYE, @@ -246,7 +248,7 @@ const struct SpriteTemplate gMeanLookEyeSpriteTemplate = .callback = AnimMeanLookEye, }; -const struct SpriteTemplate gSpikesSpriteTemplate = +const struct SpriteTemplate gSpikesSpriteTemplate = //83FEEFC { .tileTag = ANIM_TAG_SPIKES, .paletteTag = ANIM_TAG_SPIKES, @@ -257,7 +259,7 @@ const struct SpriteTemplate gSpikesSpriteTemplate = .callback = AnimSpikes, }; -const union AnimCmd gLeerAnimCmds[] = +const union AnimCmd gLeerAnimCmds[] = //83FEF14 { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -267,12 +269,12 @@ const union AnimCmd gLeerAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gLeerAnimTable[] = +const union AnimCmd *const gLeerAnimTable[] = //83FEF2C { gLeerAnimCmds, }; -const struct SpriteTemplate gLeerSpriteTemplate = +const struct SpriteTemplate gLeerSpriteTemplate = //83FEF30 { .tileTag = ANIM_TAG_LEER, .paletteTag = ANIM_TAG_LEER, @@ -283,30 +285,30 @@ const struct SpriteTemplate gLeerSpriteTemplate = .callback = AnimLeer, }; -const union AnimCmd gLetterZAnimCmds[] = +const union AnimCmd gLetterZAnimCmds[] = //83FEF48 { ANIMCMD_FRAME(0, 3), ANIMCMD_END, }; -const union AnimCmd *const gLetterZAnimTable[] = +const union AnimCmd *const gLetterZAnimTable[] = //83FEF50 { gLetterZAnimCmds, }; -const union AffineAnimCmd gLetterZAffineAnimCmds[] = +const union AffineAnimCmd gLetterZAffineAnimCmds[] = //83FEF54 { AFFINEANIMCMD_FRAME(-7, -7, -3, 16), AFFINEANIMCMD_FRAME(7, 7, 3, 16), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gLetterZAffineAnimTable[] = +const union AffineAnimCmd *const gLetterZAffineAnimTable[] = //83FEF6C { gLetterZAffineAnimCmds, }; -const struct SpriteTemplate gLetterZSpriteTemplate = +const struct SpriteTemplate gLetterZSpriteTemplate = //83FEF70 { .tileTag = ANIM_TAG_LETTER_Z, .paletteTag = ANIM_TAG_LETTER_Z, @@ -317,7 +319,7 @@ const struct SpriteTemplate gLetterZSpriteTemplate = .callback = AnimLetterZ, }; -const union AnimCmd gFangAnimCmds[] = +const union AnimCmd gFangAnimCmds[] = //83FEF88 { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(16, 16), @@ -326,24 +328,24 @@ const union AnimCmd gFangAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gFangAnimTable[] = +const union AnimCmd *const gFangAnimTable[] = //83FEF9C { gFangAnimCmds, }; -const union AffineAnimCmd gFangAffineAnimCmds[] = +const union AffineAnimCmd gFangAffineAnimCmds[] = //83FEFA0 { AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), AFFINEANIMCMD_FRAME(-0x20, -0x20, 0, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gFangAffineAnimTable[] = +const union AffineAnimCmd *const gFangAffineAnimTable[] = //83FEFB8 { gFangAffineAnimCmds, }; -const struct SpriteTemplate gFangSpriteTemplate = +const struct SpriteTemplate gFangSpriteTemplate = //83FEFBC { .tileTag = ANIM_TAG_FANG_ATTACK, .paletteTag = ANIM_TAG_FANG_ATTACK, @@ -354,27 +356,27 @@ const struct SpriteTemplate gFangSpriteTemplate = .callback = AnimFang, }; -const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = +const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = //83FEFD4 { AFFINEANIMCMD_FRAME(0x0, 0x180, 0, 0), AFFINEANIMCMD_FRAME(0x10, 0x0, 0, 20), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = +const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = //83FEFEC { AFFINEANIMCMD_FRAME(0x140, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x10, 0x0, 0, 19), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = +const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = //83FF004 { gSpotlightAffineAnimCmds1, gSpotlightAffineAnimCmds2, }; -const struct SpriteTemplate gSpotlightSpriteTemplate = +const struct SpriteTemplate gSpotlightSpriteTemplate = //83FF00C { .tileTag = ANIM_TAG_SPOTLIGHT, .paletteTag = ANIM_TAG_SPOTLIGHT, @@ -385,7 +387,7 @@ const struct SpriteTemplate gSpotlightSpriteTemplate = .callback = AnimSpotlight, }; -const struct SpriteTemplate gClappingHandSpriteTemplate = +const struct SpriteTemplate gClappingHandSpriteTemplate = //83FF024 { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -396,7 +398,7 @@ const struct SpriteTemplate gClappingHandSpriteTemplate = .callback = AnimClappingHand, }; -const struct SpriteTemplate gClappingHand2SpriteTemplate = +const struct SpriteTemplate gClappingHand2SpriteTemplate = //83FF03C { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -407,7 +409,7 @@ const struct SpriteTemplate gClappingHand2SpriteTemplate = .callback = AnimClappingHand2, }; -const union AnimCmd gRapidSpinAnimCmds[] = +const union AnimCmd gRapidSpinAnimCmds[] = //83FF054 { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(8, 2), @@ -415,12 +417,12 @@ const union AnimCmd gRapidSpinAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRapidSpinAnimTable[] = +const union AnimCmd *const gRapidSpinAnimTable[] = //83FF064 { gRapidSpinAnimCmds, }; -const struct SpriteTemplate gRapidSpinSpriteTemplate = +const struct SpriteTemplate gRapidSpinSpriteTemplate = //83FF068 { .tileTag = ANIM_TAG_RAPID_SPIN, .paletteTag = ANIM_TAG_RAPID_SPIN, @@ -431,7 +433,7 @@ const struct SpriteTemplate gRapidSpinSpriteTemplate = .callback = AnimRapidSpin, }; -const union AffineAnimCmd gUnknown_085CE2A0[] = +const union AffineAnimCmd gUnknown_83FF080[] = //83FF080 { AFFINEANIMCMD_FRAME(-12, 8, 0, 4), AFFINEANIMCMD_FRAME(20, -20, 0, 4), @@ -439,18 +441,18 @@ const union AffineAnimCmd gUnknown_085CE2A0[] = AFFINEANIMCMD_END, }; -const union AnimCmd gTriAttackTriangleAnimCmds[] = +const union AnimCmd gTriAttackTriangleAnimCmds[] = //83FF0A0 { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -const union AnimCmd *const gTriAttackTriangleAnimTable[] = +const union AnimCmd *const gTriAttackTriangleAnimTable[] = //83FF0A8 { gTriAttackTriangleAnimCmds, }; -const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = +const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = //83FF0AC { AFFINEANIMCMD_FRAME(0, 0, 5, 40), AFFINEANIMCMD_FRAME(0, 0, 10, 10), @@ -459,12 +461,12 @@ const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = +const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = //83FF0D4 { gTriAttackTriangleAffineAnimCmds, }; -const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = +const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = //83FF0D8 { .tileTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, .paletteTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, @@ -475,7 +477,7 @@ const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = .callback = AnimTriAttackTriangle, }; -const union AnimCmd gEclipsingOrbAnimCmds[] = +const union AnimCmd gEclipsingOrbAnimCmds[] = //83FF0F0 { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -488,12 +490,12 @@ const union AnimCmd gEclipsingOrbAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gEclipsingOrbAnimTable[] = +const union AnimCmd *const gEclipsingOrbAnimTable[] = //83FF114 { gEclipsingOrbAnimCmds, }; -const struct SpriteTemplate gEclipsingOrbSpriteTemplate = +const struct SpriteTemplate gEclipsingOrbSpriteTemplate = //83FF118 { .tileTag = ANIM_TAG_ECLIPSING_ORB, .paletteTag = ANIM_TAG_ECLIPSING_ORB, @@ -504,7 +506,7 @@ const struct SpriteTemplate gEclipsingOrbSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = +const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = //83FF130 { AFFINEANIMCMD_FRAME(-12, 20, 0, 8), AFFINEANIMCMD_FRAME(12, -20, 0, 8), @@ -512,7 +514,7 @@ const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = +const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = //83FF150 { .tileTag = ANIM_TAG_POKEBALL, .paletteTag = ANIM_TAG_POKEBALL, @@ -523,7 +525,7 @@ const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = .callback = AnimBatonPassPokeball, }; -const struct SpriteTemplate gWishStarSpriteTemplate = +const struct SpriteTemplate gWishStarSpriteTemplate = //83FF168 { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -534,7 +536,7 @@ const struct SpriteTemplate gWishStarSpriteTemplate = .callback = AnimWishStar, }; -const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = +const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = //83FF180 { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -545,7 +547,7 @@ const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = .callback = AnimMiniTwinklingStar, }; -const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = +const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = //83FF198 { AFFINEANIMCMD_FRAME(8, -8, 0, 12), AFFINEANIMCMD_FRAME(-16, 16, 0, 12), @@ -554,7 +556,7 @@ const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = +const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = //83FF1C0 { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -565,7 +567,7 @@ const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = +const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = //83FF1F8 { .tileTag = ANIM_TAG_BLUE_ORB, .paletteTag = ANIM_TAG_BLUE_ORB, @@ -576,7 +578,7 @@ const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = .callback = AnimSwallowBlueOrb, }; -const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = +const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = //83FF210 { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -586,7 +588,7 @@ const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const s8 gMorningSunLightBeamCoordsTable[] = +const s8 gMorningSunLightBeamCoordsTable[] = //83FF240 { 0xE8, 0x18, @@ -594,33 +596,33 @@ const s8 gMorningSunLightBeamCoordsTable[] = 0x00, }; -const union AnimCmd gGreenStarAnimCmds1[] = +const union AnimCmd gGreenStarAnimCmds1[] = //83FF244 { ANIMCMD_FRAME(0, 6), ANIMCMD_FRAME(4, 6), ANIMCMD_JUMP(0), }; -const union AnimCmd gGreenStarAnimCmds2[] = +const union AnimCmd gGreenStarAnimCmds2[] = //83FF250 { ANIMCMD_FRAME(8, 6), ANIMCMD_END, }; -const union AnimCmd gGreenStarAnimCmds3[] = +const union AnimCmd gGreenStarAnimCmds3[] = //83FF258 { ANIMCMD_FRAME(12, 6), ANIMCMD_END, }; -const union AnimCmd *const gGreenStarAnimTable[] = +const union AnimCmd *const gGreenStarAnimTable[] = //83FF260 { gGreenStarAnimCmds1, gGreenStarAnimCmds2, gGreenStarAnimCmds3, }; -const struct SpriteTemplate gGreenStarSpriteTemplate = +const struct SpriteTemplate gGreenStarSpriteTemplate = //83FF26C { .tileTag = ANIM_TAG_GREEN_STAR, .paletteTag = ANIM_TAG_GREEN_STAR, @@ -631,7 +633,7 @@ const struct SpriteTemplate gGreenStarSpriteTemplate = .callback = AnimGreenStar, }; -const s8 gDoomDesireLightBeamCoordTable[] = +const s8 gDoomDesireLightBeamCoordTable[] = //83FF284 { 0x78, 0x50, @@ -639,7 +641,7 @@ const s8 gDoomDesireLightBeamCoordTable[] = 0x00, }; -const u8 gDoomDesireLightBeamDelayTable[] = +const u8 gDoomDesireLightBeamDelayTable[] = //83FF288 { 0, 0, @@ -648,7 +650,7 @@ const u8 gDoomDesireLightBeamDelayTable[] = 50, }; -const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = +const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = //83FF290 { AFFINEANIMCMD_FRAME(0, -15, 0, 7), AFFINEANIMCMD_FRAME(0, 15, 0, 7), @@ -656,7 +658,7 @@ const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = +const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = //83FF2B0 { .tileTag = ANIM_TAG_ANGER, .paletteTag = ANIM_TAG_ANGER, @@ -667,7 +669,7 @@ const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = .callback = AnimWeakFrustrationAngerMark, }; -const union AnimCmd gSweetScentPetalAnimCmds1[] = +const union AnimCmd gSweetScentPetalAnimCmds1[] = //83FF2C8 { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(1, 8), @@ -680,7 +682,7 @@ const union AnimCmd gSweetScentPetalAnimCmds1[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gSweetScentPetalAnimCmds2[] = +const union AnimCmd gSweetScentPetalAnimCmds2[] = //83FF2EC { ANIMCMD_FRAME(0, 8, .hFlip = TRUE), ANIMCMD_FRAME(1, 8, .hFlip = TRUE), @@ -693,20 +695,20 @@ const union AnimCmd gSweetScentPetalAnimCmds2[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gSweetScentPetalAnimCmds3[] = +const union AnimCmd gSweetScentPetalAnimCmds3[] = //83FF310 { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = +const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = //83FF318 { gSweetScentPetalAnimCmds1, gSweetScentPetalAnimCmds2, gSweetScentPetalAnimCmds3, }; -const struct SpriteTemplate gSweetScentPetalSpriteTemplate = +const struct SpriteTemplate gSweetScentPetalSpriteTemplate = //83FF324 { .tileTag = ANIM_TAG_PINK_PETAL, .paletteTag = ANIM_TAG_PINK_PETAL, @@ -717,9 +719,9 @@ const struct SpriteTemplate gSweetScentPetalSpriteTemplate = .callback = AnimSweetScentPetal, }; -const u16 gUnknown_085CE55C[] = INCBIN_U16("graphics/unknown/unknown_85CE55C.gbapal"); +const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/unknown/unk_83FF33C.gbapal"); //Unused -const union AnimCmd gPainSplitAnimCmds[] = +const union AnimCmd gPainSplitAnimCmds[] = //83FF35C { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 9), @@ -727,12 +729,12 @@ const union AnimCmd gPainSplitAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gPainSplitAnimCmdTable[] = +const union AnimCmd *const gPainSplitAnimCmdTable[] = //83FF36C { gPainSplitAnimCmds, }; -const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = +const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = //83FF370 { .tileTag = ANIM_TAG_PAIN_SPLIT, .paletteTag = ANIM_TAG_PAIN_SPLIT, @@ -743,7 +745,7 @@ const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = .callback = AnimPainSplitProjectile, }; -const struct SpriteTemplate gFlatterConfettiSpriteTemplate = +const struct SpriteTemplate gFlatterConfettiSpriteTemplate = //83FF388 { .tileTag = ANIM_TAG_CONFETTI, .paletteTag = ANIM_TAG_CONFETTI, @@ -754,7 +756,7 @@ const struct SpriteTemplate gFlatterConfettiSpriteTemplate = .callback = AnimFlatterConfetti, }; -const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = +const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = //83FF3A0 { .tileTag = ANIM_TAG_SPOTLIGHT, .paletteTag = ANIM_TAG_SPOTLIGHT, @@ -765,7 +767,7 @@ const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = .callback = AnimFlatterSpotlight, }; -const struct SpriteTemplate gReversalOrbSpriteTemplate = +const struct SpriteTemplate gReversalOrbSpriteTemplate = //83FF3B8 { .tileTag = ANIM_TAG_BLUE_ORB, .paletteTag = ANIM_TAG_BLUE_ORB, @@ -776,7 +778,7 @@ const struct SpriteTemplate gReversalOrbSpriteTemplate = .callback = AnimReversalOrb, }; -const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = +const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = //83FF3D0 { AFFINEANIMCMD_FRAME(16, 0, 0, 4), AFFINEANIMCMD_FRAME(0, -3, 0, 16), @@ -786,7 +788,7 @@ const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = +const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = //83FF400 { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-8, -8, 0, 8), @@ -794,7 +796,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = +const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = //83FF420 { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -802,7 +804,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = +const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = //83FF440 { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -810,14 +812,14 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = +const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = //83FF460 { gYawnCloudAffineAnimCmds1, gYawnCloudAffineAnimCmds2, gYawnCloudAffineAnimCmds3, }; -const struct SpriteTemplate gYawnCloudSpriteTemplate = +const struct SpriteTemplate gYawnCloudSpriteTemplate = //83FF46C { .tileTag = ANIM_TAG_PINK_CLOUD, .paletteTag = ANIM_TAG_PINK_CLOUD, @@ -828,7 +830,7 @@ const struct SpriteTemplate gYawnCloudSpriteTemplate = .callback = AnimYawnCloud, }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = //83FF484 { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-4, -6, 0, 16), @@ -836,7 +838,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = //83FF4A4 { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -844,7 +846,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = //83FF4C4 { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -852,7 +854,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = //83FF4E4 { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 10, 0, 30), @@ -860,7 +862,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = +const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = //83FF504 { gSmokeBallEscapeCloudAffineAnimCmds1, gSmokeBallEscapeCloudAffineAnimCmds2, @@ -868,7 +870,7 @@ const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = gSmokeBallEscapeCloudAffineAnimCmds4, }; -const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = +const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = //83FF514 { .tileTag = ANIM_TAG_PINK_CLOUD, .paletteTag = ANIM_TAG_PINK_CLOUD, @@ -879,7 +881,7 @@ const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = .callback = AnimSmokeBallEscapeCloud, }; -const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = +const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = //83FF52C { AFFINEANIMCMD_FRAME(-16, 16, 0, 6), AFFINEANIMCMD_FRAME(16, -16, 0, 12), @@ -887,7 +889,7 @@ const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = +const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = //83FF54C { .tileTag = ANIM_TAG_SWEAT_DROP, .paletteTag = ANIM_TAG_SWEAT_DROP, @@ -898,7 +900,8 @@ const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = .callback = AnimFacadeSweatDrop, }; -const u16 gFacadeBlendColors[] = { +const u16 gFacadeBlendColors[] = //83FF564 +{ RGB(28, 25, 1), RGB(28, 21, 5), RGB(27, 18, 8), @@ -925,27 +928,27 @@ const u16 gFacadeBlendColors[] = { RGB(29, 27, 0), }; -const union AnimCmd gRoarNoiseLineAnimCmds1[] = +const union AnimCmd gRoarNoiseLineAnimCmds1[] = //83FF594 { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd gRoarNoiseLineAnimCmds2[] = +const union AnimCmd gRoarNoiseLineAnimCmds2[] = //83FF5A0 { ANIMCMD_FRAME(32, 3), ANIMCMD_FRAME(48, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRoarNoiseLineAnimTable[] = +const union AnimCmd *const gRoarNoiseLineAnimTable[] = //83FF5AC { gRoarNoiseLineAnimCmds1, gRoarNoiseLineAnimCmds2, }; -const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = +const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = //83FF5B4 { .tileTag = ANIM_TAG_NOISE_LINE, .paletteTag = ANIM_TAG_NOISE_LINE, @@ -956,7 +959,7 @@ const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = .callback = AnimRoarNoiseLine, }; -const struct SpriteTemplate gGlareEyeDotSpriteTemplate = +const struct SpriteTemplate gGlareEyeDotSpriteTemplate = //83FF5CC { .tileTag = ANIM_TAG_SMALL_RED_EYE, .paletteTag = ANIM_TAG_SMALL_RED_EYE, @@ -967,7 +970,7 @@ const struct SpriteTemplate gGlareEyeDotSpriteTemplate = .callback = AnimGlareEyeDot, }; -const struct SpriteTemplate gAssistPawprintSpriteTemplate = +const struct SpriteTemplate gAssistPawprintSpriteTemplate = //83FF5E4 { .tileTag = ANIM_TAG_PAW_PRINT, .paletteTag = ANIM_TAG_PAW_PRINT, @@ -978,26 +981,26 @@ const struct SpriteTemplate gAssistPawprintSpriteTemplate = .callback = AnimAssistPawprint, }; -const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = +const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = //83FF5FC { AFFINEANIMCMD_FRAME(0, 0, -4, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = +const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = //83FF60C { AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = +const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = //83FF624 { gBarrageBallAffineAnimCmds1, gBarrageBallAffineAnimCmds2, }; -const struct SpriteTemplate gBarrageBallSpriteTemplate = +const struct SpriteTemplate gBarrageBallSpriteTemplate = //83FF62C { .tileTag = ANIM_TAG_RED_BALL, .paletteTag = ANIM_TAG_RED_BALL, @@ -1008,7 +1011,7 @@ const struct SpriteTemplate gBarrageBallSpriteTemplate = .callback = SpriteCallbackDummy, }; -const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = +const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = //83FF644 { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -1019,14 +1022,14 @@ const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = .callback = AnimSmellingSaltsHand, }; -const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = +const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = //83FF65C { AFFINEANIMCMD_FRAME(0, -16, 0, 6), AFFINEANIMCMD_FRAME(0, 16, 0, 6), AFFINEANIMCMD_END, }; -const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = +const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = //83FF674 { .tileTag = ANIM_TAG_SMELLINGSALT_EFFECT, .paletteTag = ANIM_TAG_SMELLINGSALT_EFFECT, @@ -1037,7 +1040,7 @@ const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = .callback = AnimSmellingSaltExclamation, }; -const struct SpriteTemplate gHelpingHandClapSpriteTemplate = +const struct SpriteTemplate gHelpingHandClapSpriteTemplate = //83FF68C { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -1048,7 +1051,7 @@ const struct SpriteTemplate gHelpingHandClapSpriteTemplate = .callback = AnimHelpingHandClap, }; -const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = +const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = //83FF6A4 { .tileTag = ANIM_TAG_MAGNIFYING_GLASS, .paletteTag = ANIM_TAG_MAGNIFYING_GLASS, @@ -1059,7 +1062,7 @@ const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = .callback = AnimForesightMagnifyingGlass, }; -const struct SpriteTemplate gMeteorMashStarSpriteTemplate = +const struct SpriteTemplate gMeteorMashStarSpriteTemplate = //83FF6BC { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -1070,7 +1073,7 @@ const struct SpriteTemplate gMeteorMashStarSpriteTemplate = .callback = AnimMeteorMashStar, }; -const struct SpriteTemplate gUnknown_085CE8F4 = +const struct SpriteTemplate gUnknown_83FF6D4 = //83FF6D4 { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -1081,7 +1084,7 @@ const struct SpriteTemplate gUnknown_085CE8F4 = .callback = AnimParticuleBurst, }; -const struct SpriteTemplate gBlockXSpriteTemplate = +const struct SpriteTemplate gBlockXSpriteTemplate = //83FF6EC { .tileTag = ANIM_TAG_X_SIGN, .paletteTag = ANIM_TAG_X_SIGN, @@ -1092,7 +1095,7 @@ const struct SpriteTemplate gBlockXSpriteTemplate = .callback = AnimBlockX, }; -const struct SpriteTemplate gUnknown_085CE924 = +const struct SpriteTemplate gUnknown_83FF704 = //83FF704 { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -1100,42 +1103,42 @@ const struct SpriteTemplate gUnknown_085CE924 = .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_815FE80, + .callback = sub_80E3E84, }; -const union AnimCmd gKnockOffStrikeAnimCmds[] = +const union AnimCmd gKnockOffStrikeAnimCmds[] = //83FF71C { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(64, 4), ANIMCMD_END, }; -const union AnimCmd *const gKnockOffStrikeAnimTable[] = +const union AnimCmd *const gKnockOffStrikeAnimTable[] = //83FF728 { gKnockOffStrikeAnimCmds, }; -const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = //83FF72C { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -4, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = //83FF744 { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = +const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = //83FF75C { gKnockOffStrikeAffineanimCmds1, gKnockOffStrikeAffineanimCmds2, }; -const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = +const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = //83FF764 { .tileTag = ANIM_TAG_SLAM_HIT_2, .paletteTag = ANIM_TAG_SLAM_HIT_2, @@ -1146,18 +1149,18 @@ const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = .callback = AnimKnockOffStrike, }; -const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = +const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = //83FF77C { AFFINEANIMCMD_FRAME(0, 0, -4, 64), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = +const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = //83FF78C { gRecycleSpriteAffineAnimCmds, }; -const struct SpriteTemplate gRecycleSpriteTemplate = +const struct SpriteTemplate gRecycleSpriteTemplate = //83FF790 { .tileTag = ANIM_TAG_RECYCLE, .paletteTag = ANIM_TAG_RECYCLE, @@ -1168,7 +1171,7 @@ const struct SpriteTemplate gRecycleSpriteTemplate = .callback = AnimRecycle, }; -const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = +const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = //83FF7A8 { AFFINEANIMCMD_FRAME(0, 16, 0, 4), AFFINEANIMCMD_FRAME(-2, 0, 0, 8), @@ -1179,6 +1182,8 @@ const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = }; // Functions + +// 80DE2C0 void AnimBlackSmoke(struct Sprite *sprite) { sprite->pos1.x += gBattleAnimArgs[0]; @@ -1944,7 +1949,7 @@ static void TormentAttacker_Step(u8 taskId) task->data[5] -= 6; } - PrepareAffineAnimInTaskData(task, task->data[15], gUnknown_085CE2A0); + PrepareAffineAnimInTaskData(task, task->data[15], gUnknown_83FF080); task->data[1]++; task->data[0] = 1; break; @@ -2049,7 +2054,7 @@ void AnimTask_DefenseCurlDeformMon(u8 taskId) switch (gTasks[taskId].data[0]) { case 0: - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE350); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), DefenseCurlDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; break; case 1: @@ -2191,7 +2196,7 @@ void AnimTask_StockpileDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE3B8); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gStockpileDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2205,7 +2210,7 @@ void AnimTask_SpitUpDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE3E0); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gSpitUpDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2238,7 +2243,7 @@ void AnimTask_SwallowDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_085CE430); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gSwallowDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2248,6 +2253,7 @@ void AnimTask_SwallowDeformMon(u8 taskId) } } +// case 2 quite different :/ void AnimTask_TransformMon(u8 taskId) { int i, j; @@ -2456,7 +2462,7 @@ void AnimTask_MorningSunLightBeam(u8 taskId) if (!gTasks[taskId].data[1]) { - gBattle_BG1_X = gUnknown_085CE460[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; + gBattle_BG1_X = gMorningSunLightBeamCoordsTable[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; if (++gTasks[taskId].data[2] == 4) gTasks[taskId].data[0] = 4; else @@ -2503,8 +2509,8 @@ void AnimGreenStar(struct Sprite *sprite) sprite->data[1] = gBattleAnimArgs[0]; sprite->data[2] = gBattleAnimArgs[1]; - spriteId1 = CreateSprite(&gUnknown_085CE48C, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); - spriteId2 = CreateSprite(&gUnknown_085CE48C, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); + spriteId1 = CreateSprite(&gGreenStarSpriteTemplate, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); + spriteId2 = CreateSprite(&gGreenStarSpriteTemplate, sprite->pos1.x, sprite->pos1.y, sprite->subpriority + 1); StartSpriteAnim(&gSprites[spriteId1], 1); StartSpriteAnim(&gSprites[spriteId2], 2); @@ -2595,10 +2601,10 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); */ - sub_80752A0 - sub_807543C - sub_80753B4 - LoadCompressedPalette + sub_80752A0( , + sub_807543C( , gUnknown_8D2A8C0 + sub_80753B4( , gUnknown_8D2A808 + LoadCompressedPalette(gUnknown_8D2A808 //... if (IsContest()) @@ -2631,8 +2637,8 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) gBattle_BG1_Y = 0; } - AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); - LoadCompressedPalette(gUnknown_08C2A6D4, animBg.paletteId * 16, 32); + //AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); + //LoadCompressedPalette(gUnknown_08C2A6D4, animBg.paletteId * 16, 32); gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; gTasks[taskId].data[0]++; @@ -2640,9 +2646,9 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) case 1: gTasks[taskId].data[3] = 0; if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) - gBattle_BG1_X = gTasks[taskId].data[10] + gUnknown_085CE4A4[gTasks[taskId].data[2]]; + gBattle_BG1_X = gTasks[taskId].data[10] + gDoomDesireLightBeamCoordTable[gTasks[taskId].data[2]]; else - gBattle_BG1_X = gTasks[taskId].data[10] - gUnknown_085CE4A4[gTasks[taskId].data[2]]; + gBattle_BG1_X = gTasks[taskId].data[10] - gDoomDesireLightBeamCoordTable[gTasks[taskId].data[2]]; if (++gTasks[taskId].data[2] == 5) gTasks[taskId].data[0] = 5; @@ -2658,7 +2664,7 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) gTasks[taskId].data[0]++; break; case 3: - if (++gTasks[taskId].data[3] > gUnknown_085CE4A8[gTasks[taskId].data[2]]) + if (++gTasks[taskId].data[3] > gDoomDesireLightBeamDelayTable[gTasks[taskId].data[2]]) gTasks[taskId].data[0]++; break; case 4: diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c new file mode 100644 index 000000000..d0d40a6d8 --- /dev/null +++ b/src/battle_anim_special.c @@ -0,0 +1,2296 @@ +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "battle_controllers.h" +#include "battle_interface.h" +#include "decompress.h" +#include "dma3.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "m4a.h" +#include "main.h" +#include "palette.h" +#include "pokeball.h" +#include "sound.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" +#include "util.h" +#include "constants/items.h" +#include "constants/moves.h" +#include "constants/songs.h" +#include "constants/rgb.h" + +// Defines +#define TAG_PARTICLES_POKEBALL 55020 +#define TAG_PARTICLES_GREATBALL 55021 +#define TAG_PARTICLES_SAFARIBALL 55022 +#define TAG_PARTICLES_ULTRABALL 55023 +#define TAG_PARTICLES_MASTERBALL 55024 +#define TAG_PARTICLES_NETBALL 55025 +#define TAG_PARTICLES_DIVEBALL 55026 +#define TAG_PARTICLES_NESTBALL 55027 +#define TAG_PARTICLES_REPEATBALL 55028 +#define TAG_PARTICLES_TIMERBALL 55029 +#define TAG_PARTICLES_LUXURYBALL 55030 +#define TAG_PARTICLES_PREMIERBALL 55031 + +// IWRAM +EWRAM_DATA int gUnknown_3005424 = 0; +EWRAM_DATA u16 gUnknown_3005428 = 0; +EWRAM_DATA u16 gUnknown_300542C = 0; + +// Function Declarations +static void sub_80EEDF4(u8); +static void sub_80EF1CC(u8); +static void sub_80EF698(u8); +static void sub_80EF8C0(struct Sprite *); +static void sub_80EF7EC(u8); +static void sub_80EF864(u8); +static void sub_80EF8F0(struct Sprite *); +static void sub_80F0478(struct Sprite *); +static void sub_80EF9B4(struct Sprite *); +static void sub_80EFA0C(struct Sprite *); +static void sub_80EFB58(struct Sprite *); +static void sub_80EFB9C(struct Sprite *); +static void sub_80EFF80(struct Sprite *); +static void sub_80EFCA0(struct Sprite *); +static void sub_80EFCEC(struct Sprite *); +static void sub_80EFFA4(struct Sprite *); +static void sub_80F02B0(struct Sprite *); +static void sub_80EFFC4(struct Sprite *); +static void sub_80F01B8(struct Sprite *); +static void sub_80F00A4(struct Sprite *); +static void sub_80F018C(struct Sprite *); +static void sub_80F05B4(u8); +static void sub_80F0278(struct Sprite *); +static void sub_80F0378(struct Sprite *); +static void sub_80F04B4(struct Sprite *); +static void PokeBallOpenParticleAnimation_Step1(struct Sprite *); +static void PokeBallOpenParticleAnimation_Step2(struct Sprite *); +static void DestroyBallOpenAnimationParticle(struct Sprite *); +static void FanOutBallOpenParticles_Step1(struct Sprite *); +static void RepeatBallOpenParticleAnimation_Step1(struct Sprite *); +static void PremierBallOpenParticleAnimation_Step1(struct Sprite *); +static void sub_80F12E0(u8); +static void sub_80F1370(u8); +static void sub_80F13C0(u8); +static void sub_80F181C(u8); +static void sub_80F1A2C(struct Sprite *); +static void sub_80F1A80(struct Sprite *); +static void sub_80F19E0(u8); +static void sub_80F1BCC(struct Sprite *); +static void sub_80F1C04(struct Sprite *); +static void sub_80F1C30(struct Sprite *); +static void PokeBallOpenParticleAnimation(u8); +static void GreatBallOpenParticleAnimation(u8); +static void SafariBallOpenParticleAnimation(u8); +static void UltraBallOpenParticleAnimation(u8); +static void MasterBallOpenParticleAnimation(u8); +static void DiveBallOpenParticleAnimation(u8); +static void RepeatBallOpenParticleAnimation(u8); +static void TimerBallOpenParticleAnimation(u8); +static void PremierBallOpenParticleAnimation(u8); +static void sub_80F1B3C(struct Sprite *); + +// Data +struct BallCaptureSuccessStarData +{ + s8 xOffset; + s8 yOffset; + s8 unk2; +}; + +static const struct BallCaptureSuccessStarData sBallCaptureSuccessStarData[] = //gUnknown_840BF3C +{ + { + .xOffset = 10, + .yOffset = 2, + .unk2 = -3, + }, + { + .xOffset = 15, + .yOffset = 0, + .unk2 = -4, + }, + { + .xOffset = -10, + .yOffset = 2, + .unk2 = -4, + }, +}; + +const struct CompressedSpriteSheet gBallParticleSpritesheets[] = //gUnknown_840BF48 +{ + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_POKEBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_GREATBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_SAFARIBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_ULTRABALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_MASTERBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_NETBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_DIVEBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_NESTBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_REPEATBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_TIMERBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_LUXURYBALL}, + {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_PREMIERBALL}, +}; + +const struct CompressedSpritePalette gBallParticlePalettes[] = //gUnknown_840BFA8 +{ + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_POKEBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_GREATBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_SAFARIBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_ULTRABALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_MASTERBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_NETBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_DIVEBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_NESTBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_REPEATBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_TIMERBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_LUXURYBALL}, + {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_PREMIERBALL}, +}; + +const union AnimCmd gAnim_RegularBall[] = //gAnimCmd_840C008 +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_FRAME(2, 1), + ANIMCMD_FRAME(0, 1, .hFlip = TRUE), + ANIMCMD_FRAME(2, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnim_MasterBall[] = //gAnimCmd_840C024 +{ + ANIMCMD_FRAME(3, 1), + ANIMCMD_END, +}; + +const union AnimCmd gAnim_NetDiveBall[] = //gAnimCmd_840C02C +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd gAnim_NestBall[] = //gAnimCmd_840C034 +{ + ANIMCMD_FRAME(5, 1), + ANIMCMD_END, +}; + +const union AnimCmd gAnim_LuxuryPremierBall[] = //gAnimCmd_840C03C +{ + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(7, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnim_UltraRepeatTimerBall[] = //gAnimCmd_840C048 +{ + ANIMCMD_FRAME(7, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gAnims_BallParticles[] = //gSpriteAnimTable_840C050 +{ + gAnim_RegularBall, + gAnim_MasterBall, + gAnim_NetDiveBall, + gAnim_NestBall, + gAnim_LuxuryPremierBall, + gAnim_UltraRepeatTimerBall, +}; + +const u8 gBallParticleAnimNums[] = //gUnknown_840C068 +{ + [BALL_POKE] = 0, + [BALL_GREAT] = 0, + [BALL_SAFARI] = 0, + [BALL_ULTRA] = 5, + [BALL_MASTER] = 1, + [BALL_NET] = 2, + [BALL_DIVE] = 2, + [BALL_NEST] = 3, + [BALL_REPEAT] = 5, + [BALL_TIMER] = 5, + [BALL_LUXURY] = 4, + [BALL_PREMIER] = 4, +}; + +const TaskFunc gBallParticleAnimationFuncs[] = //gUnknown_840C074 +{ + PokeBallOpenParticleAnimation, + GreatBallOpenParticleAnimation, + SafariBallOpenParticleAnimation, + UltraBallOpenParticleAnimation, + MasterBallOpenParticleAnimation, + SafariBallOpenParticleAnimation, + DiveBallOpenParticleAnimation, + UltraBallOpenParticleAnimation, + RepeatBallOpenParticleAnimation, + TimerBallOpenParticleAnimation, + GreatBallOpenParticleAnimation, + PremierBallOpenParticleAnimation, +}; + +const struct SpriteTemplate gBallParticlesSpriteTemplates[] = //gUnknown_840C0A4 +{ + { + .tileTag = TAG_PARTICLES_POKEBALL, + .paletteTag = TAG_PARTICLES_POKEBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_GREATBALL, + .paletteTag = TAG_PARTICLES_GREATBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_SAFARIBALL, + .paletteTag = TAG_PARTICLES_SAFARIBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_ULTRABALL, + .paletteTag = TAG_PARTICLES_ULTRABALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_MASTERBALL, + .paletteTag = TAG_PARTICLES_MASTERBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_NETBALL, + .paletteTag = TAG_PARTICLES_NETBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_DIVEBALL, + .paletteTag = TAG_PARTICLES_DIVEBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_NESTBALL, + .paletteTag = TAG_PARTICLES_NESTBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_REPEATBALL, + .paletteTag = TAG_PARTICLES_REPEATBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_TIMERBALL, + .paletteTag = TAG_PARTICLES_TIMERBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_LUXURYBALL, + .paletteTag = TAG_PARTICLES_LUXURYBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = TAG_PARTICLES_PREMIERBALL, + .paletteTag = TAG_PARTICLES_PREMIERBALL, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gAnims_BallParticles, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, +}; + +const u16 gBallOpenFadeColors[] = //gUnknown_840C1C4 +{ + [BALL_POKE] = RGB(31, 22, 30), + [BALL_GREAT] = RGB(16, 23, 30), + [BALL_SAFARI] = RGB(23, 30, 20), + [BALL_ULTRA] = RGB(31, 31, 15), + [BALL_MASTER] = RGB(23, 20, 28), + [BALL_NET] = RGB(21, 31, 25), + [BALL_DIVE] = RGB(12, 25, 30), + [BALL_NEST] = RGB(30, 27, 10), + [BALL_REPEAT] = RGB(31, 24, 16), + [BALL_TIMER] = RGB(29, 30, 30), + [BALL_LUXURY] = RGB(31, 17, 10), + [BALL_PREMIER] = RGB(31, 9, 10), + + // Garbage data + RGB(0, 0, 0), + RGB(1, 16, 0), + RGB(3, 0, 1), + RGB(1, 8, 0), + RGB(0, 8, 0), + RGB(3, 8, 1), + RGB(6, 8, 1), + RGB(4, 0, 0), +}; + +const struct SpriteTemplate gPokeblockSpriteTemplate = //gUnknown_840C1EC +{ + .tileTag = ANIM_TAG_POKEBLOCK, + .paletteTag = ANIM_TAG_POKEBLOCK, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80F1B3C, +}; + +const union AnimCmd gUnknown_840C204[] = +{ + ANIMCMD_FRAME(64, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gSpriteAnimTable_840C20C[] = { + gUnknown_840C204, +}; + +const struct SpriteTemplate gUnknown_840C210 = +{ + .tileTag = ANIM_TAG_ROCKS, + .paletteTag = ANIM_TAG_ROCKS, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAnimTable_840C20C, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80F1B3C, +}; + +extern const struct SpriteTemplate gWishStarSpriteTemplate; +extern const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate; + +// Functions +void sub_80EEC0C(u8 taskId) +{ + struct BattleAnimBgData unknownStruct; + u8 healthBoxSpriteId; + u8 battler; + u8 spriteId1, spriteId2, spriteId3, spriteId4; + + battler = gBattleAnimAttacker; + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG2 | WINOUT_WIN01_BG3 | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJWIN_ON); + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 0); + SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); + SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 1); + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); + + healthBoxSpriteId = gHealthboxSpriteIds[battler]; + spriteId1 = gSprites[healthBoxSpriteId].oam.affineParam; + spriteId2 = gSprites[healthBoxSpriteId].data[5]; + spriteId3 = CreateInvisibleSpriteWithCallback(SpriteCallbackDummy); + spriteId4 = CreateInvisibleSpriteWithCallback(SpriteCallbackDummy); + gSprites[healthBoxSpriteId].oam.priority = 1; + gSprites[spriteId1].oam.priority = 1; + gSprites[spriteId2].oam.priority = 1; + gSprites[spriteId3] = gSprites[healthBoxSpriteId]; + gSprites[spriteId4] = gSprites[spriteId1]; + gSprites[spriteId3].oam.objMode = ST_OAM_OBJ_WINDOW; + gSprites[spriteId4].oam.objMode = ST_OAM_OBJ_WINDOW; + gSprites[spriteId3].callback = SpriteCallbackDummy; + gSprites[spriteId4].callback = SpriteCallbackDummy; + + sub_80A6B30(&unknownStruct); + AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_08C2EA9C); + AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_08C2EA50, unknownStruct.tilesOffset); + LoadCompressedPalette(gCureBubblesPal, unknownStruct.paletteId << 4, 32); + + gBattle_BG1_X = -gSprites[spriteId3].pos1.x + 32; + gBattle_BG1_Y = -gSprites[spriteId3].pos1.y - 32; + gTasks[taskId].data[1] = 640; + gTasks[taskId].data[0] = spriteId3; + gTasks[taskId].data[2] = spriteId4; + gTasks[taskId].func = sub_80EEDF4; +} + +static void sub_80EEDF4(u8 taskId) +{ + u8 spriteId1, spriteId2; + u8 battler; + + battler = gBattleAnimAttacker; + gTasks[taskId].data[13] += gTasks[taskId].data[1]; + gBattle_BG1_Y += (u16)gTasks[taskId].data[13] >> 8; + gTasks[taskId].data[13] &= 0xFF; + + switch (gTasks[taskId].data[15]) + { + case 0: + if (gTasks[taskId].data[11]++ > 1) + { + gTasks[taskId].data[11] = 0; + gTasks[taskId].data[12]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[12], 16 - gTasks[taskId].data[12])); + if (gTasks[taskId].data[12] == 8) + gTasks[taskId].data[15]++; + } + break; + case 1: + if (++gTasks[taskId].data[10] == 30) + gTasks[taskId].data[15]++; + break; + case 2: + if (gTasks[taskId].data[11]++ > 1) + { + gTasks[taskId].data[11] = 0; + gTasks[taskId].data[12]--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[12], 16 - gTasks[taskId].data[12])); + if (gTasks[taskId].data[12] == 0) + { + sub_80A477C(0); + gBattle_WIN0H = 0; + gBattle_WIN0V = 0; + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG_ALL | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR); + if (!IsContest()) + SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 0); + + SetGpuReg(REG_OFFSET_DISPCNT, GetGpuReg(REG_OFFSET_DISPCNT) ^ DISPCNT_OBJWIN_ON); + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 0)); + DestroySprite(&gSprites[gTasks[taskId].data[0]]); + DestroySprite(&gSprites[gTasks[taskId].data[2]]); + SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0); + spriteId1 = gSprites[gHealthboxSpriteIds[battler]].oam.affineParam; + spriteId2 = gSprites[gHealthboxSpriteIds[battler]].data[5]; + gSprites[gHealthboxSpriteIds[battler]].oam.priority = 1; + gSprites[spriteId1].oam.priority = 1; + gSprites[spriteId2].oam.priority = 1; + DestroyAnimVisualTask(taskId); + } + } + break; + } +} + +static void sub_80EEFC8(u8 *paletteId1, u8 *paletteId2, u8 battler) +{ + u8 healthBoxSpriteId; + u8 spriteId1, spriteId2; + u16 offset1, offset2; + + healthBoxSpriteId = gHealthboxSpriteIds[battler]; + spriteId1 = gSprites[healthBoxSpriteId].oam.affineParam; + spriteId2 = gSprites[healthBoxSpriteId].data[5]; + *paletteId1 = AllocSpritePalette(0xD709); + *paletteId2 = AllocSpritePalette(0xD70A); + + offset1 = (gSprites[healthBoxSpriteId].oam.paletteNum * 16) + 0x100; + offset2 = (gSprites[spriteId2].oam.paletteNum * 16) + 0x100; + LoadPalette(&gPlttBufferUnfaded[offset1], *paletteId1 * 16 + 0x100, 0x20); + LoadPalette(&gPlttBufferUnfaded[offset2], *paletteId2 * 16 + 0x100, 0x20); + + gSprites[healthBoxSpriteId].oam.paletteNum = *paletteId1; + gSprites[spriteId1].oam.paletteNum = *paletteId1; + gSprites[spriteId2].oam.paletteNum = *paletteId2; +} + +void sub_80EF0B4(u8 taskId) +{ + u8 paletteId1, paletteId2; + sub_80EEFC8(&paletteId1, &paletteId2, gBattleAnimAttacker); + DestroyAnimVisualTask(taskId); +} + +static void sub_80EF0E0(u8 battler) +{ + u8 healthBoxSpriteId; + u8 spriteId1, spriteId2; + u8 paletteId1, paletteId2; + + healthBoxSpriteId = gHealthboxSpriteIds[battler]; + spriteId1 = gSprites[healthBoxSpriteId].oam.affineParam; + spriteId2 = gSprites[healthBoxSpriteId].data[5]; + + FreeSpritePaletteByTag(0xD709); + FreeSpritePaletteByTag(0xD70A); + paletteId1 = IndexOfSpritePaletteTag(0xD6FF); + paletteId2 = IndexOfSpritePaletteTag(0xD704); + gSprites[healthBoxSpriteId].oam.paletteNum = paletteId1; + gSprites[spriteId1].oam.paletteNum = paletteId1; + gSprites[spriteId2].oam.paletteNum = paletteId2; +} + +void sub_80EF180(u8 taskId) +{ + sub_80EF0E0(gBattleAnimAttacker); + DestroyAnimVisualTask(taskId); +} + +void sub_80EF1A0(u8 taskId) +{ + gTasks[taskId].data[10] = gBattleAnimArgs[0]; + gTasks[taskId].data[11] = gBattleAnimArgs[1]; + gTasks[taskId].func = sub_80EF1CC; +} + +static void sub_80EF1CC(u8 taskId) +{ + u8 paletteNum; + int paletteOffset, colorOffset; + + gTasks[taskId].data[0]++; + if (gTasks[taskId].data[0]++ >= gTasks[taskId].data[11]) + { + gTasks[taskId].data[0] = 0; + paletteNum = IndexOfSpritePaletteTag(0xD709); + colorOffset = gTasks[taskId].data[10] == 0 ? 6 : 2; + switch (gTasks[taskId].data[1]) + { + case 0: + gTasks[taskId].data[2] += 2; + if (gTasks[taskId].data[2] > 16) + gTasks[taskId].data[2] = 16; + + paletteOffset = paletteNum * 16 + 0x100; + BlendPalette(paletteOffset + colorOffset, 1, gTasks[taskId].data[2], RGB(20, 27, 31)); + if (gTasks[taskId].data[2] == 16) + gTasks[taskId].data[1]++; + break; + case 1: + gTasks[taskId].data[2] -= 2; + if (gTasks[taskId].data[2] < 0) + gTasks[taskId].data[2] = 0; + + paletteOffset = paletteNum * 16 + 0x100; + BlendPalette(paletteOffset + colorOffset, 1, gTasks[taskId].data[2], RGB(20, 27, 31)); + if (gTasks[taskId].data[2] == 0) + DestroyAnimVisualTask(taskId); + break; + } + } +} + +void sub_80EF298(u8 taskId) +{ + u8 spriteId; + + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + switch (gTasks[taskId].data[0]) + { + case 0: + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + gTasks[taskId].data[10] = 0x100; + gTasks[taskId].data[0]++; + break; + case 1: + gTasks[taskId].data[10] += 0x30; + SetSpriteRotScale(spriteId, gTasks[taskId].data[10], gTasks[taskId].data[10], 0); + SetBattlerSpriteYOffsetFromYScale(spriteId); + if (gTasks[taskId].data[10] >= 0x2D0) + gTasks[taskId].data[0]++; + break; + case 2: + ResetSpriteRotScale(spriteId); + gSprites[spriteId].invisible = 1; + DestroyAnimVisualTask(taskId); + break; + } +} + +void sub_80EF344(u8 taskId) +{ + u8 spriteId; + u16 ball; + u8 ballId; + u8 x, y; + u8 priority, subpriority; + u32 selectedPalettes; + + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + ball = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_POKEBALL); + else + ball = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_POKEBALL); + + ballId = ItemIdToBallId(ball); + switch (gTasks[taskId].data[0]) + { + case 0: + x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + priority = gSprites[spriteId].oam.priority; + subpriority = gSprites[spriteId].subpriority; + gTasks[taskId].data[10] = AnimateBallOpenParticles(x, y + 32, priority, subpriority, ballId); + selectedPalettes = sub_80A75AC(1, 0, 0, 0, 0, 0, 0); + gTasks[taskId].data[11] = LaunchBallFadeMonTask(0, gBattleAnimAttacker, selectedPalettes, ballId); + gTasks[taskId].data[0]++; + break; + case 1: + if (!gTasks[gTasks[taskId].data[10]].isActive && !gTasks[gTasks[taskId].data[11]].isActive) + DestroyAnimVisualTask(taskId); + break; + } +} + +void sub_80EF490(u8 taskId) +{ + u8 ballId = ItemIdToBallId(gLastUsedItem); + LoadBallGfx(ballId); + DestroyAnimVisualTask(taskId); +} + +void sub_80EF4B8(u8 taskId) +{ + u8 ballId = ItemIdToBallId(gLastUsedItem); + FreeBallGfx(ballId); + DestroyAnimVisualTask(taskId); +} + +void AnimTask_IsBallBlockedByTrainer(u8 taskId) +{ + if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_TRAINER_BLOCK) + gBattleAnimArgs[ARG_RET_ID] = -1; + else + gBattleAnimArgs[ARG_RET_ID] = 0; + + DestroyAnimVisualTask(taskId); +} + +u8 ItemIdToBallId(u16 ballItem) +{ + switch (ballItem) + { + case ITEM_MASTER_BALL: + return BALL_MASTER; + case ITEM_ULTRA_BALL: + return BALL_ULTRA; + case ITEM_GREAT_BALL: + return BALL_GREAT; + case ITEM_SAFARI_BALL: + return BALL_SAFARI; + case ITEM_NET_BALL: + return BALL_NET; + case ITEM_DIVE_BALL: + return BALL_DIVE; + case ITEM_NEST_BALL: + return BALL_NEST; + case ITEM_REPEAT_BALL: + return BALL_REPEAT; + case ITEM_TIMER_BALL: + return BALL_TIMER; + case ITEM_LUXURY_BALL: + return BALL_LUXURY; + case ITEM_PREMIER_BALL: + return BALL_PREMIER; + case ITEM_POKE_BALL: + default: + return BALL_POKE; + } +} + +void sub_80EF5AC(u8 taskId) +{ + u8 ballId; + u8 spriteId; + + ballId = ItemIdToBallId(gLastUsedItem); + spriteId = CreateSprite(&gBallSpriteTemplates[ballId], 32, 80, 29); + gSprites[spriteId].data[0] = 34; + gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) - 16; + gSprites[spriteId].callback = sub_80EF8C0; + gBattleSpritesDataPtr->animationData->field_9_x2 = gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible; + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].func = sub_80EF698; +} + +static void sub_80EF698(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[0]; + if ((u16)gSprites[spriteId].data[0] == 0xFFFF) + DestroyAnimVisualTask(taskId); +} + +void sub_80EF6D4(u8 taskId) +{ + int x, y; + u8 ballId; + u8 subpriority; + u8 spriteId; + + if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) + { + x = 32; + y = 11; + } + else + { + x = 23; + y = 5; + } + + ballId = ItemIdToBallId(gLastUsedItem); + subpriority = GetBattlerSpriteSubpriority(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)) + 1; + spriteId = CreateSprite(&gBallSpriteTemplates[ballId], x + 32, y | 80, subpriority); + gSprites[spriteId].data[0] = 34; + gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) - 16; + gSprites[spriteId].callback = SpriteCallbackDummy; + gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].callback = sub_8039E84; + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].func = sub_80EF7EC; +} + +static void sub_80EF7EC(u8 taskId) +{ + if (gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].animCmdIndex == 1) + { + PlaySE12WithPanning(SE_NAGERU, 0); + gSprites[gTasks[taskId].data[0]].callback = sub_80EF8C0; + CreateTask(sub_80EF864, 10); + gTasks[taskId].func = sub_80EF698; + } +} + +static void sub_80EF864(u8 taskId) +{ + if (gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].animEnded) + { + StartSpriteAnim(&gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]], 0); + DestroyTask(taskId); + } +} + +static void sub_80EF8C0(struct Sprite *sprite) +{ + u16 temp = sprite->data[1]; + u16 temp2 = sprite->data[2]; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = temp; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = temp2; + sprite->data[5] = -40; + InitAnimArcTranslation(sprite); + sprite->callback = sub_80EF8F0; +} + +static void sub_80EF8F0(struct Sprite *sprite) +{ + int i; + u8 ballId; + + if (TranslateAnimHorizontalArc(sprite)) + { + if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_TRAINER_BLOCK) + { + sprite->callback = sub_80F0478; + } + else if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_GHOST_DODGE) + { + sprite->callback = sub_80F052C; + } + else + { + StartSpriteAnim(sprite, 1); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + + for (i = 0; i < 8; i++) + sprite->data[i] = 0; + + sprite->data[5] = 0; + sprite->callback = sub_80EF9B4; + + ballId = ItemIdToBallId(gLastUsedItem); + switch (ballId) + { + case 0 ... POKEBALL_COUNT - 1: + AnimateBallOpenParticles(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); + LaunchBallFadeMonTask(0, gBattleAnimTarget, 14, ballId); + break; + } + } + } +} + +static void sub_80EF9B4(struct Sprite *sprite) +{ + if (++sprite->data[5] == 10) + { + sprite->data[5] = CreateTask(TaskDummy, 50); + sprite->callback = sub_80EFA0C; + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] = 0; + } +} + +static void sub_80EFA0C(struct Sprite *sprite) +{ + u8 spriteId; + u8 taskId; + + spriteId = gBattlerSpriteIds[gBattleAnimTarget]; + taskId = sprite->data[5]; + + if (++gTasks[taskId].data[1] == 11) + PlaySE(SE_SUIKOMU); + + switch (gTasks[taskId].data[0]) + { + case 0: + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); + gTasks[taskId].data[10] = 256; + gUnknown_3005424 = 28; + gUnknown_300542C = (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y) - (sprite->pos1.y + sprite->pos2.y); + gUnknown_3005428 = (u32)(gUnknown_300542C * 256) / 28; + gTasks[taskId].data[2] = gUnknown_3005428; + gTasks[taskId].data[0]++; + break; + case 1: + gTasks[taskId].data[10] += 0x20; + SetSpriteRotScale(spriteId, gTasks[taskId].data[10], gTasks[taskId].data[10], 0); + gTasks[taskId].data[3] += gTasks[taskId].data[2]; + gSprites[spriteId].pos2.y = -gTasks[taskId].data[3] >> 8; + if (gTasks[taskId].data[10] >= 0x480) + gTasks[taskId].data[0]++; + break; + case 2: + ResetSpriteRotScale(spriteId); + gSprites[spriteId].invisible = 1; + gTasks[taskId].data[0]++; + break; + default: + if (gTasks[taskId].data[1] > 10) + { + DestroyTask(taskId); + StartSpriteAnim(sprite, 2); + sprite->data[5] = 0; + sprite->callback = sub_80EFB58; + } + break; + } +} + +static void sub_80EFB58(struct Sprite *sprite) +{ + int angle; + + if (sprite->animEnded) + { + sprite->data[3] = 0; + sprite->data[4] = 40; + sprite->data[5] = 0; + angle = 0; + sprite->pos1.y += Cos(angle, 40); + sprite->pos2.y = -Cos(angle, sprite->data[4]); + sprite->callback = sub_80EFB9C; + } +} + +static void sub_80EFB9C(struct Sprite *sprite) +{ + bool8 lastBounce; + int bounceCount; + + lastBounce = 0; + + switch (sprite->data[3] & 0xFF) + { + case 0: + sprite->pos2.y = -Cos(sprite->data[5], sprite->data[4]); + sprite->data[5] += (sprite->data[3] >> 8) + 4; + if (sprite->data[5] >= 64) + { + sprite->data[4] -= 10; + sprite->data[3] += 257; + + bounceCount = sprite->data[3] >> 8; + if (bounceCount == 4) + lastBounce = 1; + + // Play a different sound effect for each pokeball bounce. + switch (bounceCount) + { + case 1: + PlaySE(SE_KON); + break; + case 2: + PlaySE(SE_KON2); + break; + case 3: + PlaySE(SE_KON3); + break; + default: + PlaySE(SE_KON4); + break; + } + } + break; + case 1: + sprite->pos2.y = -Cos(sprite->data[5], sprite->data[4]); + sprite->data[5] -= (sprite->data[3] >> 8) + 4; + if (sprite->data[5] <= 0) + { + sprite->data[5] = 0; + sprite->data[3] &= -0x100; + } + break; + } + + if (lastBounce) + { + sprite->data[3] = 0; + sprite->pos1.y += Cos(64, 40); + sprite->pos2.y = 0; + if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_NO_SHAKES) + { + sprite->data[5] = 0; + sprite->callback = sub_80EFF80; + } + else + { + sprite->callback = sub_80EFCA0; + sprite->data[4] = 1; + sprite->data[5] = 0; + } + } +} + +static void sub_80EFCA0(struct Sprite *sprite) +{ + if (++sprite->data[3] == 31) + { + sprite->data[3] = 0; + sprite->affineAnimPaused = 1; + StartSpriteAffineAnim(sprite, 1); + gBattleSpritesDataPtr->animationData->field_C = 0; + sprite->callback = sub_80EFCEC; + PlaySE(SE_BOWA); + } +} + +static void sub_80EFCEC(struct Sprite *sprite) +{ + s8 state; + u16 var0; + + switch (sprite->data[3] & 0xFF) + { + case 0: + if (gBattleSpritesDataPtr->animationData->field_C > 0xFF) + { + sprite->pos2.x += sprite->data[4]; + gBattleSpritesDataPtr->animationData->field_C &= 0xFF; + } + else + { + gBattleSpritesDataPtr->animationData->field_C += 0xB0; + } + + sprite->data[5]++; + sprite->affineAnimPaused = 0; + var0 = sprite->data[5] + 7; + if (var0 > 14) + { + gBattleSpritesDataPtr->animationData->field_C = 0; + sprite->data[3]++; + sprite->data[5] = 0; + } + break; + case 1: + if (++sprite->data[5] == 1) + { + sprite->data[5] = 0; + sprite->data[4] = -sprite->data[4]; + sprite->data[3]++; + sprite->affineAnimPaused = 0; + if (sprite->data[4] < 0) + ChangeSpriteAffineAnim(sprite, 2); + else + ChangeSpriteAffineAnim(sprite, 1); + } + else + { + sprite->affineAnimPaused = 1; + } + break; + case 2: + if (gBattleSpritesDataPtr->animationData->field_C > 0xFF) + { + sprite->pos2.x += sprite->data[4]; + gBattleSpritesDataPtr->animationData->field_C &= 0xFF; + } + else + { + gBattleSpritesDataPtr->animationData->field_C += 0xB0; + } + + sprite->data[5]++; + sprite->affineAnimPaused = 0; + var0 = sprite->data[5] + 12; + if (var0 > 24) + { + gBattleSpritesDataPtr->animationData->field_C = 0; + sprite->data[3]++; + sprite->data[5] = 0; + } + break; + case 3: + if (sprite->data[5]++ < 0) + { + sprite->affineAnimPaused = 1; + break; + } + + sprite->data[5] = 0; + sprite->data[4] = -sprite->data[4]; + sprite->data[3]++; + sprite->affineAnimPaused = 0; + if (sprite->data[4] < 0) + ChangeSpriteAffineAnim(sprite, 2); + else + ChangeSpriteAffineAnim(sprite, 1); + // fall through + case 4: + if (gBattleSpritesDataPtr->animationData->field_C > 0xFF) + { + sprite->pos2.x += sprite->data[4]; + gBattleSpritesDataPtr->animationData->field_C &= 0xFF; + } + else + { + gBattleSpritesDataPtr->animationData->field_C += 0xB0; + } + + sprite->data[5]++; + sprite->affineAnimPaused = 0; + var0 = sprite->data[5] + 4; + if (var0 > 8) + { + gBattleSpritesDataPtr->animationData->field_C = 0; + sprite->data[3]++; + sprite->data[5] = 0; + sprite->data[4] = -sprite->data[4]; + } + break; + case 5: + sprite->data[3] += 0x100; + state = sprite->data[3] >> 8; + if (state == gBattleSpritesDataPtr->animationData->ballThrowCaseId) + { + sprite->affineAnimPaused = 1; + sprite->callback = sub_80EFF80; + } + else + { + if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_3_SHAKES_SUCCESS && state == 3) + { + sprite->callback = sub_80EFFA4; + sprite->affineAnimPaused = 1; + } + else + { + sprite->data[3]++; + sprite->affineAnimPaused = 1; + } + } + break; + case 6: + default: + if (++sprite->data[5] == 31) + { + sprite->data[5] = 0; + sprite->data[3] &= -0x100; + StartSpriteAffineAnim(sprite, 3); + if (sprite->data[4] < 0) + StartSpriteAffineAnim(sprite, 2); + else + StartSpriteAffineAnim(sprite, 1); + + PlaySE(SE_BOWA); + } + break; + } +} + +static void sub_80EFF80(struct Sprite *sprite) +{ + if (++sprite->data[5] == 31) + { + sprite->data[5] = 0; + sprite->callback = sub_80F02B0; + } +} + +static void sub_80EFFA4(struct Sprite *sprite) +{ + sprite->animPaused = 1; + sprite->callback = sub_80EFFC4; + sprite->data[3] = 0; + sprite->data[4] = 0; + sprite->data[5] = 0; +} + +static void sub_80EFFC4(struct Sprite *sprite) +{ + u8 *battler = &gBattleAnimTarget; + + sprite->data[4]++; + if (sprite->data[4] == 40) + { + PlaySE(SE_RG_GETTING); + BlendPalettes(0x10000 << sprite->oam.paletteNum, 6, RGB(0, 0, 0)); + sub_80F01B8(sprite); + } + else if (sprite->data[4] == 60) + { + BeginNormalPaletteFade(0x10000 << sprite->oam.paletteNum, 2, 6, 0, RGB(0, 0, 0)); + } + else if (sprite->data[4] == 95) + { + gDoingBattleAnim = 0; + UpdateOamPriorityInAllHealthboxes(1); + m4aMPlayAllStop(); + PlaySE(MUS_RG_FAN6); + } + else if (sprite->data[4] == 315) + { + FreeOamMatrix(gSprites[gBattlerSpriteIds[*battler]].oam.matrixNum); + DestroySprite(&gSprites[gBattlerSpriteIds[*battler]]); + sprite->data[0] = 0; + sprite->callback = sub_80F00A4; + } +} + +static void sub_80F00A4(struct Sprite *sprite) +{ + u8 paletteIndex; + + switch (sprite->data[0]) + { + case 0: + sprite->data[1] = 0; + sprite->data[2] = 0; + sprite->oam.objMode = ST_OAM_OBJ_BLEND; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16, 0)); + paletteIndex = IndexOfSpritePaletteTag(sprite->template->paletteTag); + BeginNormalPaletteFade(1 << (paletteIndex + 0x10), 0, 0, 16, RGB(31, 31, 31)); + sprite->data[0]++; + break; + case 1: + if (sprite->data[1]++ > 0) + { + sprite->data[1] = 0; + sprite->data[2]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[2], sprite->data[2])); + if (sprite->data[2] == 16) + sprite->data[0]++; + } + break; + case 2: + sprite->invisible = 1; + sprite->data[0]++; + break; + default: + if (!gPaletteFade.active) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + } + break; + } +} + +static void sub_80F018C(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + sprite->data[0] = -1; + } + else + { + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); + } +} + +static void sub_80F01B8(struct Sprite *sprite) +{ + u32 i; + u8 subpriority; + + if (sprite->subpriority) + { + subpriority = sprite->subpriority - 1; + } + else + { + subpriority = 0; + sprite->subpriority = 1; + } + + sub_80F05B4(4); + for (i = 0; i < 3; i++) + { + u8 spriteId = CreateSprite(&gBallParticlesSpriteTemplates[4], sprite->pos1.x, sprite->pos1.y, subpriority); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].data[0] = 24; + gSprites[spriteId].data[2] = sprite->pos1.x + sBallCaptureSuccessStarData[i].xOffset; + gSprites[spriteId].data[4] = sprite->pos1.y + sBallCaptureSuccessStarData[i].yOffset; + gSprites[spriteId].data[5] = sBallCaptureSuccessStarData[i].unk2; + InitAnimArcTranslation(&gSprites[spriteId]); + gSprites[spriteId].callback = sub_80F0278; + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[4]); + } + } +} + +static void sub_80F0278(struct Sprite *sprite) +{ + sprite->invisible = !sprite->invisible; + if (TranslateAnimHorizontalArc(sprite)) + DestroySprite(sprite); +} + +static void sub_80F02B0(struct Sprite *sprite) +{ + u8 ballId; + + StartSpriteAnim(sprite, 1); + StartSpriteAffineAnim(sprite, 0); + sprite->callback = sub_80F0378; + + ballId = ItemIdToBallId(gLastUsedItem); + switch (ballId) + { + case 0 ... POKEBALL_COUNT - 1: + AnimateBallOpenParticles(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); + LaunchBallFadeMonTask(1, gBattleAnimTarget, 14, ballId); + break; + } + + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible = 0; + StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimTarget]], 1); + AnimateSprite(&gSprites[gBattlerSpriteIds[gBattleAnimTarget]]); + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] = 0x1000; +} + +static void sub_80F0378(struct Sprite *sprite) +{ + int next = FALSE; + + if (sprite->animEnded) + sprite->invisible = 1; + + if (gSprites[gBattlerSpriteIds[gBattleAnimTarget]].affineAnimEnded) + { + StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimTarget]], 0); + next = TRUE; + } + else + { + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] -= 288; + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].pos2.y = gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] >> 8; + } + + if (sprite->animEnded && next) + { + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].pos2.y = 0; + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible = gBattleSpritesDataPtr->animationData->field_9_x2; + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + gDoingBattleAnim = 0; + UpdateOamPriorityInAllHealthboxes(1); + } +} + +static void sub_80F0478(struct Sprite *sprite) +{ + int i; + + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.y = 0; + sprite->pos2.x = 0; + for (i = 0; i < 6; i++) + sprite->data[i] = 0; + + sprite->callback = sub_80F04B4; +} + +static void sub_80F04B4(struct Sprite *sprite) +{ + s16 var0 = sprite->data[0] + 0x800; + s16 var1 = sprite->data[1] + 0x680; + sprite->pos2.x -= var1 >> 8; + sprite->pos2.y += var0 >> 8; + sprite->data[0] = (sprite->data[0] + 0x800) & 0xFF; + sprite->data[1] = (sprite->data[1] + 0x680) & 0xFF; + + if (sprite->pos1.y + sprite->pos2.y > 160 + || sprite->pos1.x + sprite->pos2.x < -8) + { + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + gDoingBattleAnim = 0; + UpdateOamPriorityInAllHealthboxes(1); + } +} + +// GhostBallDodge +static void sub_80F052C(struct Sprite *sprite) +{ + // to do +} + +static void sub_80F0574(struct Sprite *sprite) +{ + //to do +} + +static void sub_80F05B4(u8 ballId) +{ + u8 taskId; + + if (GetSpriteTileStartByTag(gBallParticleSpritesheets[ballId].tag) == 0xFFFF) + { + LoadCompressedSpriteSheetUsingHeap(&gBallParticleSpritesheets[ballId]); + LoadCompressedSpritePaletteUsingHeap(&gBallParticlePalettes[ballId]); + } +} + +u8 AnimateBallOpenParticles(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId) +{ + u8 taskId; + + sub_80F05B4(ballId); + taskId = CreateTask(gBallParticleAnimationFuncs[ballId], 5); + gTasks[taskId].data[1] = x; + gTasks[taskId].data[2] = y; + gTasks[taskId].data[3] = priority; + gTasks[taskId].data[4] = subpriority; + gTasks[taskId].data[15] = ballId; + PlaySE(SE_BOWA2); + + return taskId; +} + +void sub_80F0674(void) +{ + if (gMain.inBattle) + gBattleSpritesDataPtr->animationData->field_A++; +} + +static void PokeBallOpenParticleAnimation(u8 taskId) +{ + u8 spriteId; + u8 x, y; + u8 priority, subpriority; + u8 ballId; + u8 var0; + + ballId = gTasks[taskId].data[15]; + if (gTasks[taskId].data[0] < 16) + { + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = PokeBallOpenParticleAnimation_Step1; + gSprites[spriteId].oam.priority = priority; + + var0 = (u8)gTasks[taskId].data[0]; + if (var0 >= 8) + var0 -= 8; + + gSprites[spriteId].data[0] = var0 * 32; + } + + if (gTasks[taskId].data[0] == 15) + { + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); + return; + } + } + + gTasks[taskId].data[0]++; +} + +static void PokeBallOpenParticleAnimation_Step1(struct Sprite *sprite) +{ + if (sprite->data[1] == 0) + sprite->callback = PokeBallOpenParticleAnimation_Step2; + else + sprite->data[1]--; +} + +static void PokeBallOpenParticleAnimation_Step2(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], sprite->data[1]); + sprite->data[1] += 2; + if (sprite->data[1] == 50) + DestroyBallOpenAnimationParticle(sprite); +} + +static void TimerBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 10; + gSprites[spriteId].data[5] = 2; + gSprites[spriteId].data[6] = 1; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +static void DiveBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 10; + gSprites[spriteId].data[5] = 1; + gSprites[spriteId].data[6] = 2; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +// Also used for Net Ball +static void SafariBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 4; + gSprites[spriteId].data[5] = 1; + gSprites[spriteId].data[6] = 1; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +// Also used for Nest Ball +static void UltraBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 10; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 25; + gSprites[spriteId].data[4] = 5; + gSprites[spriteId].data[5] = 1; + gSprites[spriteId].data[6] = 1; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +// Also used for Luxury Ball +static void GreatBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + if (gTasks[taskId].data[7]) + { + gTasks[taskId].data[7]--; + } + else + { + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 8; + gSprites[spriteId].data[5] = 2; + gSprites[spriteId].data[6] = 2; + } + } + + gTasks[taskId].data[7] = 8; + if (++gTasks[taskId].data[0] == 2) + { + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); + } + } +} + +static void FanOutBallOpenParticles_Step1(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], sprite->data[2]); + sprite->data[0] = (sprite->data[0] + sprite->data[4]) & 0xFF; + sprite->data[1] += sprite->data[5]; + sprite->data[2] += sprite->data[6]; + if (++sprite->data[3] == 51) + DestroyBallOpenAnimationParticle(sprite); +} + +static void RepeatBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < POKEBALL_COUNT; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = RepeatBallOpenParticleAnimation_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 21; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +static void RepeatBallOpenParticleAnimation_Step1(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], Sin(sprite->data[0], sprite->data[2])); + sprite->data[0] = (sprite->data[0] + 6) & 0xFF; + sprite->data[1]++; + sprite->data[2]++; + if (++sprite->data[3] == 51) + DestroyBallOpenAnimationParticle(sprite); +} + +static void MasterBallOpenParticleAnimation(u8 taskId) +{ + u8 i, j; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (j = 0; j < 2; j++) + { + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + gSprites[spriteId].data[4] = 8; + + if (j == 0) + { + gSprites[spriteId].data[5] = 2; + gSprites[spriteId].data[6] = 1; + } + else + { + gSprites[spriteId].data[5] = 1; + gSprites[spriteId].data[6] = 2; + } + } + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +static void PremierBallOpenParticleAnimation(u8 taskId) +{ + u8 i; + u8 x, y, priority, subpriority, ballId; + u8 spriteId; + + ballId = gTasks[taskId].data[15]; + x = gTasks[taskId].data[1]; + y = gTasks[taskId].data[2]; + priority = gTasks[taskId].data[3]; + subpriority = gTasks[taskId].data[4]; + + for (i = 0; i < 8; i++) + { + spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + if (spriteId != MAX_SPRITES) + { + sub_80F0674(); + StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + gSprites[spriteId].callback = PremierBallOpenParticleAnimation_Step1; + gSprites[spriteId].oam.priority = priority; + gSprites[spriteId].data[0] = i * 32; + } + } + + if (!gMain.inBattle) + gSprites[spriteId].data[7] = 1; + + DestroyTask(taskId); +} + +static void PremierBallOpenParticleAnimation_Step1(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], Sin(sprite->data[0] & 0x3F, sprite->data[2])); + sprite->data[0] = (sprite->data[0] + 10) & 0xFF; + sprite->data[1]++; + sprite->data[2]++; + if (++sprite->data[3] == 51) + DestroyBallOpenAnimationParticle(sprite); +} + +static void DestroyBallOpenAnimationParticle(struct Sprite *sprite) +{ + int i, j; + + if (!gMain.inBattle) + { + if (sprite->data[7] == 1) + DestroySpriteAndFreeResources(sprite); + else + DestroySprite(sprite); + } + else + { + gBattleSpritesDataPtr->animationData->field_A--; + if (gBattleSpritesDataPtr->animationData->field_A == 0) + { + for (i = 0; i < POKEBALL_COUNT; i++) + { + if (FuncIsActiveTask(gBallParticleAnimationFuncs[i]) == TRUE) + break; + } + + if (i == POKEBALL_COUNT) + { + for (j = 0; j < POKEBALL_COUNT; j++) + { + FreeSpriteTilesByTag(gBallParticleSpritesheets[j].tag); + FreeSpritePaletteByTag(gBallParticlePalettes[j].tag); + } + } + + DestroySprite(sprite); + } + else + { + DestroySprite(sprite); + } + } +} + +u8 LaunchBallFadeMonTask(u8 unfadeLater, u8 battler, u32 selectedPalettes, u8 ballId) +{ + u8 taskId; + + taskId = CreateTask(sub_80F12E0, 5); + gTasks[taskId].data[15] = ballId; + gTasks[taskId].data[3] = battler; + gTasks[taskId].data[10] = selectedPalettes; + gTasks[taskId].data[11] = selectedPalettes >> 16; + + if (!unfadeLater) + { + BlendPalette(battler * 16 + 0x100, 16, 0, gBallOpenFadeColors[ballId]); + gTasks[taskId].data[1] = 1; + } + else + { + BlendPalette(battler * 16 + 0x100, 16, 16, gBallOpenFadeColors[ballId]); + gTasks[taskId].data[0] = 16; + gTasks[taskId].data[1] = -1; + gTasks[taskId].func = sub_80F1370; + } + + BeginNormalPaletteFade(selectedPalettes, 0, 0, 16, RGB(31, 31, 31)); + return taskId; +} + +static void sub_80F12E0(u8 taskId) +{ + u8 ballId = gTasks[taskId].data[15]; + + if (gTasks[taskId].data[2] <= 16) + { + BlendPalette(gTasks[taskId].data[3] * 16 + 0x100, 16, gTasks[taskId].data[0], gBallOpenFadeColors[ballId]); + gTasks[taskId].data[0] += gTasks[taskId].data[1]; + gTasks[taskId].data[2]++; + } + else if (!gPaletteFade.active) + { + u32 selectedPalettes = (u16)gTasks[taskId].data[10] | ((u16)gTasks[taskId].data[11] << 16); + BeginNormalPaletteFade(selectedPalettes, 0, 16, 0, RGB(31, 31, 31)); + DestroyTask(taskId); + } +} + +static void sub_80F1370(u8 taskId) +{ + if (!gPaletteFade.active) + { + u32 selectedPalettes = (u16)gTasks[taskId].data[10] | ((u16)gTasks[taskId].data[11] << 16); + BeginNormalPaletteFade(selectedPalettes, 0, 16, 0, RGB(31, 31, 31)); + gTasks[taskId].func = sub_80F13C0; + } +} + +static void sub_80F13C0(u8 taskId) +{ + u8 ballId = gTasks[taskId].data[15]; + + if (gTasks[taskId].data[2] <= 16) + { + BlendPalette(gTasks[taskId].data[3] * 16 + 0x100, 16, gTasks[taskId].data[0], gBallOpenFadeColors[ballId]); + gTasks[taskId].data[0] += gTasks[taskId].data[1]; + gTasks[taskId].data[2]++; + } + else + { + DestroyTask(taskId); + } +} + +void sub_80F1420(u8 taskId) +{ + u8 spriteId; + u32 x; + u32 done = FALSE; + + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + switch (gTasks[taskId].data[10]) + { + case 0: + gTasks[taskId].data[11] = gBattleAnimArgs[0]; + gTasks[taskId].data[0] += 0x500; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gSprites[spriteId].pos2.x += gTasks[taskId].data[0] >> 8; + else + gSprites[spriteId].pos2.x -= gTasks[taskId].data[0] >> 8; + + gTasks[taskId].data[0] &= 0xFF; + x = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x + 32; + if (x > 304) + gTasks[taskId].data[10]++; + break; + case 1: + LoadBattleMonGfxAndAnimate(gBattleAnimAttacker, gTasks[taskId].data[11], spriteId); + gTasks[taskId].data[10]++; + break; + case 2: + gTasks[taskId].data[0] += 0x500; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gSprites[spriteId].pos2.x -= gTasks[taskId].data[0] >> 8; + else + gSprites[spriteId].pos2.x += gTasks[taskId].data[0] >> 8; + + gTasks[taskId].data[0] &= 0xFF; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + if (gSprites[spriteId].pos2.x <= 0) + { + gSprites[spriteId].pos2.x = 0; + done = TRUE; + } + } + else + { + if (gSprites[spriteId].pos2.x >= 0) + { + gSprites[spriteId].pos2.x = 0; + done = TRUE; + } + } + + if (done) + DestroyAnimVisualTask(taskId); + + break; + } +} + +void sub_80F15C8(u8 taskId) +{ + u8 spriteId; + + switch (gTasks[taskId].data[15]) + { + case 0: + if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == B_POSITION_OPPONENT_LEFT) + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG1 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + else + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16, 0)); + gTasks[taskId].data[15]++; + break; + case 1: + if (gTasks[taskId].data[1]++ > 1) + { + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[0]++; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - gTasks[taskId].data[0], gTasks[taskId].data[0])); + if (gTasks[taskId].data[0] == 16) + gTasks[taskId].data[15]++; + } + break; + case 2: + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + RequestDma3Fill(0, (void *)OBJ_VRAM0 + gSprites[spriteId].oam.tileNum * TILE_SIZE_4BPP, 0x800, 1); + ClearBehindSubstituteBit(gBattleAnimAttacker); + DestroyAnimVisualTask(taskId); + break; + } +} + +void AnimTask_IsAttackerBehindSubstitute(u8 taskId) +{ + gBattleAnimArgs[ARG_RET_ID] = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].behindSubstitute; + DestroyAnimVisualTask(taskId); +} + +void AnimTask_TargetToEffectBattler(u8 taskId) +{ + gBattleAnimTarget = gEffectBattler; + DestroyAnimVisualTask(taskId); +} + +void sub_80F1720(u8 battler, struct Pokemon *mon) +{ + int isShiny; + u32 otId, personality; + u32 shinyValue; + u8 taskId1, taskId2; + + isShiny = 0; + gBattleSpritesDataPtr->healthBoxesData[battler].flag_x80 = 1; + otId = GetMonData(mon, MON_DATA_OT_ID); + personality = GetMonData(mon, MON_DATA_PERSONALITY); + + if (IsBattlerSpriteVisible(battler)) + { + shinyValue = HIHALF(otId) ^ LOHALF(otId) ^ HIHALF(personality) ^ LOHALF(personality); + if (shinyValue < SHINY_ODDS) + isShiny = TRUE; + + if (isShiny) + { + if (GetSpriteTileStartByTag(ANIM_TAG_GOLD_STARS) == 0xFFFF) + { + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[ANIM_TAG_GOLD_STARS - ANIM_SPRITES_START]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[ANIM_TAG_GOLD_STARS - ANIM_SPRITES_START]); + } + + taskId1 = CreateTask(sub_80F181C, 10); + taskId2 = CreateTask(sub_80F181C, 10); + gTasks[taskId1].data[0] = battler; + gTasks[taskId2].data[0] = battler; + gTasks[taskId1].data[1] = 0; + gTasks[taskId2].data[1] = 1; + return; + } + } + + gBattleSpritesDataPtr->healthBoxesData[battler].field_1_x1 = 1; +} + +static void sub_80F181C(u8 taskId) +{ + u8 battler; + u8 x, y; + u8 spriteId; + u16 counter; + s16 state; + u8 pan; + + if (gTasks[taskId].data[13] < 60) + { + gTasks[taskId].data[13]++; + return; + } + + if (gBattleSpritesDataPtr->animationData->field_A) + return; + + counter = gTasks[taskId].data[10]++; + if (counter & 3) + return; + + battler = gTasks[taskId].data[0]; + x = GetBattlerSpriteCoord(battler, 0); + y = GetBattlerSpriteCoord(battler, 1); + state = gTasks[taskId].data[11]; + if (state == 0) + { + spriteId = CreateSprite(&gWishStarSpriteTemplate, x, y, 5); + } + else if (state >= 0 && gTasks[taskId].data[11] < 4) + { + spriteId = CreateSprite(&gMiniTwinklingStarSpriteTemplate, x, y, 5); + gSprites[spriteId].oam.tileNum += 4; + } + else + { + spriteId = CreateSprite(&gMiniTwinklingStarSpriteTemplate, x, y, 5); + gSprites[spriteId].oam.tileNum += 5; + } + + if (gTasks[taskId].data[1] == 0) + { + gSprites[spriteId].callback = sub_80F1A2C; + } + else + { + gSprites[spriteId].callback = sub_80F1A80; + gSprites[spriteId].pos2.x = -32; + gSprites[spriteId].pos2.y = 32; + gSprites[spriteId].invisible = 1; + if (gTasks[taskId].data[11] == 0) + { + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + pan = -64; + else + pan = 63; + + PlaySE12WithPanning(SE_REAPOKE, pan); + } + } + + gSprites[spriteId].data[0] = taskId; + gTasks[taskId].data[11]++; + if (spriteId != MAX_SPRITES) + gTasks[taskId].data[12]++; + + if (gTasks[taskId].data[11] == 5) + gTasks[taskId].func = sub_80F19E0; +} + +static void sub_80F19E0(u8 taskId) +{ + u8 battler; + + if (gTasks[taskId].data[12] == 0) + { + if (gTasks[taskId].data[1] == 1) + { + battler = gTasks[taskId].data[0]; + gBattleSpritesDataPtr->healthBoxesData[battler].field_1_x1 = 1; + } + + DestroyTask(taskId); + } +} + +static void sub_80F1A2C(struct Sprite *sprite) +{ + sprite->pos2.x = Sin(sprite->data[1], 24); + sprite->pos2.y = Cos(sprite->data[1], 24); + sprite->data[1] += 12; + if (sprite->data[1] > 0xFF) + { + gTasks[sprite->data[0]].data[12]--; + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); + } +} + +static void sub_80F1A80(struct Sprite *sprite) +{ + if (sprite->data[1] < 4) + { + sprite->data[1]++; + } + else + { + sprite->invisible = 0; + sprite->pos2.x += 5; + sprite->pos2.y -= 5; + if (sprite->pos2.x > 32) + { + gTasks[sprite->data[0]].data[12]--; + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); + } + } +} + +void AnimTask_LoadPokeblockGfx(u8 taskId) +{ + u8 paletteIndex; + + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[ANIM_TAG_POKEBLOCK - ANIM_SPRITES_START]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[ANIM_TAG_POKEBLOCK - ANIM_SPRITES_START]); + paletteIndex = IndexOfSpritePaletteTag(ANIM_TAG_POKEBLOCK); // unused + DestroyAnimVisualTask(taskId); +} + +void AnimTask_FreePokeblockGfx(u8 taskId) +{ + FreeSpriteTilesByTag(ANIM_TAG_POKEBLOCK); + FreeSpritePaletteByTag(ANIM_TAG_POKEBLOCK); + DestroyAnimVisualTask(taskId); +} + +static void sub_80F1B3C(struct Sprite *sprite) +{ + InitSpritePosToAnimAttacker(sprite, 0); + sprite->data[0] = 30; + sprite->data[2] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), 0) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), 1) + gBattleAnimArgs[3]; + sprite->data[5] = -32; + InitAnimArcTranslation(sprite); + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].callback = sub_8039E84; + sprite->callback = sub_80F1BCC; +} + +static void sub_80F1BCC(struct Sprite *sprite) +{ + if (gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].animCmdIndex == 1) + sprite->callback = sub_80F1C04; +} + +static void sub_80F1C04(struct Sprite *sprite) +{ + if (TranslateAnimHorizontalArc(sprite)) //TranslateAnimArc? + { + sprite->data[0] = 0; + sprite->invisible = 1; + sprite->callback = sub_80F1C30; + } +} + +static void sub_80F1C30(struct Sprite *sprite) +{ + if (gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].animEnded) + { + if (++sprite->data[0] > 0) + { + StartSpriteAnim(&gSprites[gBattlerSpriteIds[gBattleAnimAttacker]], 0); + DestroyAnimSprite(sprite); + } + } +} + +void sub_80F1C8C(u8 taskId) +{ + switch (gBattleAnimArgs[0]) + { + case 0: + gBattleAnimAttacker = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + gBattleAnimTarget = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + break; + case 1: + gBattleAnimAttacker = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + gBattleAnimTarget = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + break; + } + + DestroyAnimVisualTask(taskId); +} + +void sub_80F1C8C(u8 taskId) +{ + // to do +} + +// 080F1D14 +void AnimTask_GetTrappedMoveAnimId(u8 taskId) +{ + if (gBattleSpritesDataPtr->animationData->animArg == MOVE_FIRE_SPIN) + gBattleAnimArgs[0] = TRAP_ANIM_FIRE_SPIN; + else if (gBattleSpritesDataPtr->animationData->animArg == MOVE_WHIRLPOOL) + gBattleAnimArgs[0] = TRAP_ANIM_WHIRLPOOL; + else if (gBattleSpritesDataPtr->animationData->animArg == MOVE_CLAMP) + gBattleAnimArgs[0] = TRAP_ANIM_CLAMP; + else if (gBattleSpritesDataPtr->animationData->animArg == MOVE_SAND_TOMB) + gBattleAnimArgs[0] = TRAP_ANIM_SAND_TOMB; + else + gBattleAnimArgs[0] = TRAP_ANIM_BIND; + + DestroyAnimVisualTask(taskId); +} + +void AnimTask_GetBattlersFromArg(u8 taskId) +{ + gBattleAnimAttacker = gBattleSpritesDataPtr->animationData->animArg; + gBattleAnimTarget = gBattleSpritesDataPtr->animationData->animArg >> 8; + DestroyAnimVisualTask(taskId); +} -- cgit v1.2.3 From 5c40e5ea212c947b1853a8c8dc23dcb8d882bf90 Mon Sep 17 00:00:00 2001 From: Evan Date: Mon, 2 Dec 2019 17:58:49 -0700 Subject: battle_anim_status_effects --- src/battle_anim_effects_3.c | 1 - src/battle_anim_status_effects.c | 538 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 538 insertions(+), 1 deletion(-) create mode 100644 src/battle_anim_status_effects.c (limited to 'src') diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 4fd6ada0b..426d39056 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -1182,7 +1182,6 @@ const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = //83FF7A8 }; // Functions - // 80DE2C0 void AnimBlackSmoke(struct Sprite *sprite) { diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c new file mode 100644 index 000000000..582dd20a5 --- /dev/null +++ b/src/battle_anim_status_effects.c @@ -0,0 +1,538 @@ +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "decompress.h" +#include "gpu_regs.h" +#include "palette.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" +#include "util.h" +#include "constants/battle_anim.h" +#include "constants/rgb.h" + +// Function Declarations +static u8 sub_8078178(u8 battlerId, bool8 b); +static void sub_80782BC(u8 taskId); +static void sub_80784D8(u8 taskId); +static void sub_8078528(u8 taskId); +static void sub_80785D8(u8 taskId); +static void sub_807862C(u8 taskId); +static void Task_DoStatusAnimation(u8 taskId); +static void sub_807834C(struct Sprite *sprite); +static void sub_8078380(struct Sprite *sprite); + +// Data +extern const struct CompressedSpriteSheet gBattleAnimPicTable[]; +extern const struct CompressedSpritePalette gBattleAnimPaletteTable[]; +extern const u8 *const gBattleAnims_StatusConditions[]; +extern const struct OamData gOamData_AffineOff_ObjNormal_8x8; +extern const struct OamData gOamData_AffineOff_ObjBlend_64x64; + +static const union AnimCmd gUnknown_83BF3E0[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(4, 3), + ANIMCMD_FRAME(8, 3), + ANIMCMD_FRAME(12, 3), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const gSpriteAnimTable_83BF3F4[] = +{ + gUnknown_83BF3E0 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF3F8 = +{ + .tileTag = ANIM_TAG_ORB, + .paletteTag = ANIM_TAG_ORB, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gSpriteAnimTable_83BF3F4, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8AEC, +}; + +const struct SpriteTemplate gSpriteTemplate_83BF410 = +{ + .tileTag = ANIM_TAG_ORB, + .paletteTag = ANIM_TAG_ORB, + .oam = &gOamData_AffineOff_ObjNormal_16x16, + .anims = gSpriteAnimTable_83BF3F4, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8A6C, +}; + +static const union AnimCmd gUnknown_83BF428[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const gSpriteAnimTable_83BF430[] = +{ + gUnknown_83BF428 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF434 = +{ + .tileTag = ANIM_TAG_WEATHER_BALL, + .paletteTag = ANIM_TAG_WEATHER_BALL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAnimTable_83BF430, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8E30, +}; + +const struct SpriteTemplate gSpriteTemplate_83BF44C = +{ + .tileTag = ANIM_TAG_WEATHER_BALL, + .paletteTag = ANIM_TAG_WEATHER_BALL, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAnimTable_83BF430, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8EE4, +}; + +static const union AnimCmd gUnknown_83BF464[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(32, 3), + ANIMCMD_FRAME(48, 3), + ANIMCMD_FRAME(64, 3), + ANIMCMD_END +}; + +static const union AnimCmd *const gSpriteAnimTable_83BF47C[] = +{ + gUnknown_83BF464 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF480 = +{ + .tileTag = ANIM_TAG_SPARKLE_4, + .paletteTag = ANIM_TAG_SPARKLE_4, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAnimTable_83BF47C, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8B64, +}; + +const struct SpriteTemplate gSpriteTemplate_83BF498 = +{ + .tileTag = ANIM_TAG_MONSTER_FOOT, + .paletteTag = ANIM_TAG_MONSTER_FOOT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8AEC, +}; + +static const union AnimCmd gUnknown_83BF4B0[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd gUnknown_83BF4B8[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd gUnknown_83BF4C0[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const gSpriteAniimTable_83BF4C8[] = +{ + gUnknown_83BF4B0, + gUnknown_83BF4B8, + gUnknown_83BF4C0 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF4D4 = +{ + .tileTag = ANIM_TAG_IMPACT, + .paletteTag = ANIM_TAG_IMPACT, + .oam = &gOamData_AffineOff_ObjNormal_32x32, + .anims = gSpriteAniimTable_83BF4C8, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A8AEC, +}; + +static const union AnimCmd gUnknown_83BF4EC[] = +{ + ANIMCMD_FRAME(0, 15), + ANIMCMD_JUMP(0) +}; + +static const union AnimCmd *const gSpriteAnimTable_83BF4F4[] = +{ + gUnknown_83BF4EC +}; + +static const union AffineAnimCmd gUnknown_83BF4F8[] = +{ + AFFINEANIMCMD_FRAME(96, 96, 0, 0), + AFFINEANIMCMD_FRAME(2, 2, 0, 1), + AFFINEANIMCMD_JUMP(1) +}; + +static const union AffineAnimCmd *const gSpriteAffineAnimTable_83BF510[] = +{ + gUnknown_83BF4F8 +}; + +const struct SpriteTemplate gSpriteTemplate_83BF514 = +{ + .tileTag = ANIM_TAG_ORB, + .paletteTag = ANIM_TAG_ORB, + .oam = &gOamData_AffineDouble_ObjNormal_16x16, + .anims = gSpriteAnimTable_83BF4F4, + .images = NULL, + .affineAnims = gSpriteAffineAnimTable_83BF510, + .callback = sub_80A8A6C, +}; + +static const u32 gUnknown_83BF52C = _("TASK OVER\nタスクがオーバーしました$"); + +static const struct Subsprite gSubsprites_83BF544[] = +{ + {.x = -16, .y = -16, .shape = ST_OAM_SQUARE, .size = 3, .tileOffset = 0, .priority = 2}, + {.x = -16, .y = 48, .shape = ST_OAM_H_RECTANGLE, .size = 3, .tileOffset = 64, .priority = 2}, + {.x = 48, .y = -16, .shape = ST_OAM_V_RECTANGLE, .size = 3, .tileOffset = 96, .priority = 2}, + {.x = 48, .y = 48, .shape = ST_OAM_SQUARE, .size = 2, .tileOffset = 128, .priority = 2}, +}; + +static const struct SubspriteTable gUnknown_83BF554[] = +{ + {ARRAY_COUNT(gSubsprites_83BF544), gSubsprites_83BF544}, +}; + +static const struct SpriteTemplate gUnknown_83BF55C = +{ + .tileTag = ANIM_TAG_ICE_CUBE, + .paletteTag = ANIM_TAG_ICE_CUBE, + .oam = &gOamData_AffineOff_ObjBlend_64x64, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +static const struct SpriteTemplate gUnknown_83BF574 = +{ + .tileTag = ANIM_TAG_CIRCLE_IMPACT, + .paletteTag = ANIM_TAG_CIRCLE_IMPACT, + .oam = &gOamData_AffineOff_ObjNormal_8x8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_807834C, +}; + +// Functions +static u8 sub_8078178(u8 battlerId, bool8 b) +{ + u8 battlerSpriteId = gBattlerSpriteIds[battlerId]; + u8 taskId = CreateTask(sub_80782BC, 10); + u8 spriteId2; + u8 i; + + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(ANIM_TAG_CIRCLE_IMPACT)]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(ANIM_TAG_CIRCLE_IMPACT)]); + gTasks[taskId].data[0] = battlerId; + if (b) + { + gTasks[taskId].data[1] = RGB_RED; + for (i = 0; i < 10; i++) + { + spriteId2 = CreateSprite(&gUnknown_83BF574, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y + 32, 0); + gSprites[spriteId2].data[0] = i * 51; + gSprites[spriteId2].data[1] = -256; + gSprites[spriteId2].invisible = TRUE; + if (i > 4) + gSprites[spriteId2].data[6] = 21; + } + } + else + { + gTasks[taskId].data[1] = RGB_BLUE; + for (i = 0; i < 10; i++) + { + spriteId2 = CreateSprite(&gUnknown_83BF574, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y - 32, 0); + gSprites[spriteId2].data[0] = i * 51; + gSprites[spriteId2].data[1] = 256; + gSprites[spriteId2].invisible = TRUE; + if (i > 4) + gSprites[spriteId2].data[6] = 21; + } + } + gSprites[spriteId2].data[7] = 1; + return taskId; +} + +// Functions +static void sub_80782BC(u8 taskId) +{ + if (gTasks[taskId].data[2] == 2) + { + gTasks[taskId].data[2] = 0; + BlendPalette(0x100 + gTasks[taskId].data[0] * 16, 16, gTasks[taskId].data[4], gTasks[taskId].data[1]); + if (gTasks[taskId].data[5] == 0) + { + gTasks[taskId].data[4]++; + if (gTasks[taskId].data[4] > 8) + gTasks[taskId].data[5] ^= 1; + } + else + { + u16 var = gTasks[taskId].data[4]; + + gTasks[taskId].data[4]--; + if (gTasks[taskId].data[4] < 0) + { + gTasks[taskId].data[4] = var; + gTasks[taskId].data[5] ^= 1; + gTasks[taskId].data[3]++; + if (gTasks[taskId].data[3] == 2) + DestroyTask(taskId); + } + } + } + else + { + gTasks[taskId].data[2]++; + } +} + +static void sub_807834C(struct Sprite *sprite) +{ + if (sprite->data[6] == 0) + { + sprite->invisible = FALSE; + sprite->callback = sub_8078380; + sub_8078380(sprite); + } + else + { + sprite->data[6]--; + } +} + +static void sub_8078380(struct Sprite *sprite) +{ + sprite->pos2.x = Cos(sprite->data[0], 32); + sprite->pos2.y = Sin(sprite->data[0], 8); + if (sprite->data[0] < 128) + sprite->subpriority = 29; + else + sprite->subpriority = 31; + sprite->data[0] = (sprite->data[0] + 8) & 0xFF; + sprite->data[5] += sprite->data[1]; + sprite->pos2.y += sprite->data[5] >> 8; + sprite->data[2]++; + if (sprite->data[2] == 52) + { + if (sprite->data[7]) + DestroySpriteAndFreeResources(sprite); + else + DestroySprite(sprite); + } +} + +void sub_80783FC(u8 taskId) +{ + s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) - 32; + s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) - 36; + u8 spriteId; + + if (IsContest()) + x -= 6; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + spriteId = CreateSprite(&gUnknown_83BF55C, x, y, 4); + if (GetSpriteTileStartByTag(ANIM_TAG_ICE_CUBE) == 0xFFFF) + gSprites[spriteId].invisible = TRUE; + SetSubspriteTables(&gSprites[spriteId], gUnknown_83BF554); + gTasks[taskId].data[15] = spriteId; + gTasks[taskId].func = sub_80784D8; +} + +static void sub_80784D8(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] == 10) + { + gTasks[taskId].func = sub_8078528; + gTasks[taskId].data[1] = 0; + } + else + { + u8 var = gTasks[taskId].data[1]; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(var, 16 - var)); + } +} + +static void sub_8078528(u8 taskId) +{ + u8 palIndex = IndexOfSpritePaletteTag(ANIM_TAG_ICE_CUBE); + + if (gTasks[taskId].data[1]++ > 13) + { + gTasks[taskId].data[2]++; + if (gTasks[taskId].data[2] == 3) + { + u16 temp; + + temp = gPlttBufferFaded[0x100 + palIndex * 16 + 13]; + gPlttBufferFaded[0x100 + palIndex * 16 + 13] = gPlttBufferFaded[0x100 + palIndex * 16 + 14]; + gPlttBufferFaded[0x100 + palIndex * 16 + 14] = gPlttBufferFaded[0x100 + palIndex * 16 + 15]; + gPlttBufferFaded[0x100 + palIndex * 16 + 15] = temp; + + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[3]++; + if (gTasks[taskId].data[3] == 3) + { + gTasks[taskId].data[3] = 0; + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[4]++; + if (gTasks[taskId].data[4] == 2) + { + gTasks[taskId].data[1] = 9; + gTasks[taskId].func = sub_80785D8; + } + } + } + } +} + +static void sub_80785D8(u8 taskId) +{ + gTasks[taskId].data[1]--; + if (gTasks[taskId].data[1] == -1) + { + gTasks[taskId].func = sub_807862C; + gTasks[taskId].data[1] = 0; + } + else + { + u8 var = gTasks[taskId].data[1]; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(var, 16 - var)); + } +} + +static void sub_807862C(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] == 37) + { + u8 spriteId = gTasks[taskId].data[15]; + + FreeSpriteOamMatrix(&gSprites[spriteId]); + DestroySprite(&gSprites[spriteId]); + } + else if (gTasks[taskId].data[1] == 39) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimVisualTask(taskId); + } +} + +#define CASE(by, stat) case (STAT_ANIM_##by + stat - 1) + +void AnimTask_StatsChange(u8 taskId) +{ + bool16 goesDown = FALSE; + s16 animStatId = 0; + bool16 sharply = FALSE; + + switch (gBattleSpritesDataPtr->animationData->animArg) + { + CASE(PLUS1, STAT_ATK): goesDown = FALSE; animStatId = 0; break; + CASE(PLUS1, STAT_DEF): goesDown = FALSE; animStatId = 1; break; + CASE(PLUS1, STAT_SPEED): goesDown = FALSE; animStatId = 3; break; + CASE(PLUS1, STAT_SPATK): goesDown = FALSE; animStatId = 5; break; + CASE(PLUS1, STAT_SPDEF): goesDown = FALSE; animStatId = 6; break; + CASE(PLUS1, STAT_ACC): goesDown = FALSE; animStatId = 2; break; + CASE(PLUS1, STAT_EVASION): goesDown = FALSE; animStatId = 4; break; + + CASE(MINUS1, STAT_ATK): goesDown = TRUE; animStatId = 0; break; + CASE(MINUS1, STAT_DEF): goesDown = TRUE; animStatId = 1; break; + CASE(MINUS1, STAT_SPEED): goesDown = TRUE; animStatId = 3; break; + CASE(MINUS1, STAT_SPATK): goesDown = TRUE; animStatId = 5; break; + CASE(MINUS1, STAT_SPDEF): goesDown = TRUE; animStatId = 6; break; + CASE(MINUS1, STAT_ACC): goesDown = TRUE; animStatId = 2; break; + CASE(MINUS1, STAT_EVASION): goesDown = TRUE; animStatId = 4; break; + + CASE(PLUS2, STAT_ATK): goesDown = FALSE; animStatId = 0; sharply = TRUE; break; + CASE(PLUS2, STAT_DEF): goesDown = FALSE; animStatId = 1; sharply = TRUE; break; + CASE(PLUS2, STAT_SPEED): goesDown = FALSE; animStatId = 3; sharply = TRUE; break; + CASE(PLUS2, STAT_SPATK): goesDown = FALSE; animStatId = 5; sharply = TRUE; break; + CASE(PLUS2, STAT_SPDEF): goesDown = FALSE; animStatId = 6; sharply = TRUE; break; + CASE(PLUS2, STAT_ACC): goesDown = FALSE; animStatId = 2; sharply = TRUE; break; + CASE(PLUS2, STAT_EVASION): goesDown = FALSE; animStatId = 4; sharply = TRUE; break; + + CASE(MINUS2, STAT_ATK): goesDown = TRUE; animStatId = 0; sharply = TRUE; break; + CASE(MINUS2, STAT_DEF): goesDown = TRUE; animStatId = 1; sharply = TRUE; break; + CASE(MINUS2, STAT_SPEED): goesDown = TRUE; animStatId = 3; sharply = TRUE; break; + CASE(MINUS2, STAT_SPATK): goesDown = TRUE; animStatId = 5; sharply = TRUE; break; + CASE(MINUS2, STAT_SPDEF): goesDown = TRUE; animStatId = 6; sharply = TRUE; break; + CASE(MINUS2, STAT_ACC): goesDown = TRUE; animStatId = 2; sharply = TRUE; break; + CASE(MINUS2, STAT_EVASION): goesDown = TRUE; animStatId = 4; sharply = TRUE; break; + + case STAT_ANIM_MULTIPLE_PLUS1: goesDown = FALSE; animStatId = 0xFF; sharply = FALSE; break; + case STAT_ANIM_MULTIPLE_PLUS2: goesDown = FALSE; animStatId = 0xFF; sharply = TRUE; break; + case STAT_ANIM_MULTIPLE_MINUS1: goesDown = TRUE; animStatId = 0xFF; sharply = FALSE; break; + case STAT_ANIM_MULTIPLE_MINUS2: goesDown = TRUE; animStatId = 0xFF; sharply = TRUE; break; + + default: + DestroyAnimVisualTask(taskId); + return; + } + + gBattleAnimArgs[0] = goesDown; + gBattleAnimArgs[1] = animStatId; + gBattleAnimArgs[2] = 0; + gBattleAnimArgs[3] = 0; + gBattleAnimArgs[4] = sharply; + gTasks[taskId].func = sub_8116EB4; + sub_8116EB4(taskId); +} + +#undef CASE + +void LaunchStatusAnimation(u8 battlerId, u8 statusAnimId) +{ + u8 taskId; + + gBattleAnimAttacker = battlerId; + gBattleAnimTarget = battlerId; + LaunchBattleAnimation(gBattleAnims_StatusConditions, statusAnimId, 0); + taskId = CreateTask(Task_DoStatusAnimation, 10); + gTasks[taskId].data[0] = battlerId; +} + +static void Task_DoStatusAnimation(u8 taskId) +{ + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + gBattleSpritesDataPtr->healthBoxesData[gTasks[taskId].data[0]].statusAnimActive = FALSE; + DestroyTask(taskId); + } +} -- cgit v1.2.3 From f1bd7a41cc1e2bcd730a0c2c6c5c4c618044f631 Mon Sep 17 00:00:00 2001 From: Evan Date: Mon, 2 Dec 2019 20:58:12 -0700 Subject: resolve compiler errors --- src/battle_anim_effects_1.c | 7 +- src/battle_anim_effects_2.c | 5 +- src/battle_anim_effects_3.c | 261 +++++++++++++-------------------------- src/battle_anim_special.c | 69 +++++++---- src/battle_anim_status_effects.c | 25 ++-- 5 files changed, 154 insertions(+), 213 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 9d820b628..ff0927f88 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -13,7 +13,6 @@ #include "sound.h" #include "trig.h" #include "util.h" -#include "constants/rgb.h" #include "constants/songs.h" // RAM @@ -4373,7 +4372,7 @@ static void AnimLockOnTargetStep4(struct Sprite* sprite) sprite->data[1] = 0; } - BlendPalettes(sub_80A75AC(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB(31, 31, 31)); + BlendPalettes(sub_8075BE8(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB(31, 31, 31)); if (sprite->data[1] == 16) { int pal; @@ -5029,7 +5028,7 @@ void AnimTask_FadeScreenBlueStep(u8); void AnimTask_FadeScreenBlue(u8 taskId) { - int a = sub_80A75AC(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; + int a = sub_8075BE8(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; int b; int c; int d; @@ -5044,7 +5043,7 @@ void AnimTask_FadeScreenBlue(u8 taskId) gTasks[taskId].data[7] = 13; gTasks[taskId].data[8] = 14; gTasks[taskId].data[9] = 15; - b = sub_80A76C4(1, 1, 1, 1); + b = sub_8075CB8(1, 1, 1, 1); c = a | b; StorePointerInVars(&gTasks[taskId].data[14], &gTasks[taskId].data[15], (void*)c); b = b | (0x10000 << IndexOfSpritePaletteTag(ANIM_TAG_MOON)); diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 32ed2fba9..cea915921 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -13,7 +13,6 @@ #include "sound.h" #include "trig.h" #include "util.h" -#include "constants/rgb.h" #include "constants/songs.h" void sub_80A6E48(struct Sprite *); @@ -344,7 +343,7 @@ const struct SpriteTemplate gWaterPulseRingSpriteTemplate = //gUnknown_83E3CE8 .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gWaterPulseRingAffineAnimTable, - .callback = AnimWaterPulseRing, + .callback = sub_80AC6D8, }; const struct SpriteTemplate gEggThrowSpriteTemplate = //gUnknown_83E3D00 @@ -3096,7 +3095,7 @@ static void FakeOutStep2(u8 taskId) { gTasks[taskId].data[11] = 0x88; SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_LIGHTEN); - BlendPalettes(sub_80A75AC(1, 0, 0, 0, 0, 0, 0), 16, RGB(31, 31, 31)); + BlendPalettes(sub_8075BE8(1, 0, 0, 0, 0, 0, 0), 16, RGB(31, 31, 31)); } else if (gTasks[taskId].data[10] > 4) { diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 426d39056..ab8b3f20a 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -3,7 +3,6 @@ #include "battle.h" #include "battle_anim.h" #include "bg.h" -#include "contest.h" #include "data.h" #include "decompress.h" #include "dma3.h" @@ -19,7 +18,6 @@ #include "trig.h" #include "util.h" #include "constants/battle_anim.h" -#include "constants/rgb.h" #include "constants/songs.h" #include "constants/species.h" #include "constants/weather.h" @@ -122,6 +120,10 @@ static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); // Data +extern const u32 gUnknown_8D2A8C0[]; +extern const u32 gUnknown_8D2A808[]; +extern const u32 gUnknown_8D2A8A8[]; + const union AnimCmd gScratchAnimCmds[] = //83FEDE4 { ANIMCMD_FRAME(0, 4), @@ -468,8 +470,8 @@ const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = //83FF0D4 const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = //83FF0D8 { - .tileTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, - .paletteTag = ANIM_TAG_TRI_ATTACK_TRIANGLE, + .tileTag = ANIM_TAG_TRI_FORCE_TRIANGLE, + .paletteTag = ANIM_TAG_TRI_FORCE_TRIANGLE, .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gTriAttackTriangleAnimTable, .images = NULL, @@ -719,7 +721,7 @@ const struct SpriteTemplate gSweetScentPetalSpriteTemplate = //83FF324 .callback = AnimSweetScentPetal, }; -const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/unknown/unk_83FF33C.gbapal"); //Unused +const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/battle_anims/unk_83FF33C.gbapal"); //Unused const union AnimCmd gPainSplitAnimCmds[] = //83FF35C { @@ -1214,7 +1216,7 @@ static void AnimBlackSmokeStep(struct Sprite *sprite) void AnimTask_SmokescreenImpact(u8 taskId) { - SmokescreenImpact( + SmokescreenImpact( //sub_804A76C GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 8, GetBattlerSpriteCoord(gBattleAnimTarget, 3) + 8, 0); @@ -2288,8 +2290,7 @@ void AnimTask_TransformMon(u8 taskId) break; case 2: HandleSpeciesGfxDataChange(gBattleAnimAttacker, gBattleAnimTarget, gTasks[taskId].data[10]); - sub_80A6BFC(&animBg, gBattleAnimAttacker); - + sub_8075300(&animBg, gBattleAnimAttacker); if (IsContest()) position = 0; else @@ -2297,40 +2298,8 @@ void AnimTask_TransformMon(u8 taskId) src = gMonSpritesGfxPtr->sprites[position] + (gBattleMonForms[gBattleAnimAttacker] << 11); dest = animBg.bgTiles; - CpuCopy32(src, dest, 0x800); + CpuSet(src, dest, 0x4000200); LoadBgTiles(1, animBg.bgTiles, 0x800, animBg.tilesOffset); - if (IsContest()) - { - if (IsSpeciesNotUnown(gContestResources->field_18->species) != IsSpeciesNotUnown(gContestResources->field_18->unk2)) - { - bgTilemap = (u16 *)animBg.bgTilemap; - for (i = 0; i < 8; i++) - { - for (j = 0; j < 4; j++) - { - u16 temp = bgTilemap[j + i * 0x20]; - bgTilemap[j + i * 0x20] = bgTilemap[(7 - j) + i * 0x20]; - bgTilemap[(7 - j) + i * 0x20] = temp; - } - } - - for (i = 0; i < 8; i++) - { - for (j = 0; j < 8; j++) - { - bgTilemap[j + i * 0x20] ^= 0x400; - } - } - } - - if (IsSpeciesNotUnown(gContestResources->field_18->unk2)) - gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].affineAnims = gUnknown_082FF6C0; - else - gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].affineAnims = gUnknown_082FF694; - - StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimAttacker]], 0); - } - gTasks[taskId].data[0]++; break; case 3: @@ -2392,13 +2361,13 @@ void AnimTask_MorningSunLightBeam(u8 taskId) if (!IsContest()) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); - sub_80752A0 - sub_807543C - sub_80753B4 //AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); + sub_80752A0(&animBg); + AnimLoadCompressedBgTilemap(animBg.bgId, gUnknown_8D2A8C0); + AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_8D2A808, animBg.tilesOffset); LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); if (IsContest()) { - sub_80730C0(animBg.paletteId, [sp+4 ???], 0, 0); + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); gBattle_BG1_X = -56; } else @@ -2410,30 +2379,6 @@ void AnimTask_MorningSunLightBeam(u8 taskId) } gBattle_BG1_Y = 0; - - /* - sub_80752A0(&animBg); - sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); - - if (IsContest()) - { - gBattle_BG1_X = -56; - gBattle_BG1_Y = 0; - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) - gBattle_BG1_X = -135; - else - gBattle_BG1_X = -10; - - gBattle_BG1_Y = 0; - } - */ - - - - gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; @@ -2594,21 +2539,16 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); if (!IsContest()) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); - - /* - sub_80752A0(&animBg); - sub_80A6D60(&animBg, &gUnknown_08C2A6EC, 0); - */ - - sub_80752A0( , - sub_807543C( , gUnknown_8D2A8C0 - sub_80753B4( , gUnknown_8D2A808 - LoadCompressedPalette(gUnknown_8D2A808 - //... + sub_80752A0(&animBg); + AnimLoadCompressedBgTilemap(animBg.bgId, gUnknown_8D2A8C0); + AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_8D2A808, animBg.tilesOffset); + LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); + if (IsContest()) { - gBattle_BG1_X = -56; + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + gBattle_BG1_X = -56; gBattle_BG1_Y = 0; } else @@ -2636,8 +2576,6 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) gBattle_BG1_Y = 0; } - //AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C2A634, animBg.tilesOffset); - //LoadCompressedPalette(gUnknown_08C2A6D4, animBg.paletteId * 16, 32); gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; gTasks[taskId].data[0]++; @@ -3229,62 +3167,51 @@ void AnimTask_RolePlaySilhouette(u8 taskId) s16 coord1, coord2; GetAnimBattlerSpriteId(ANIM_ATTACKER); - if (IsContest()) - { - isBackPic = 1; - personality = gContestResources->field_18->unk10; - otId = gContestResources->field_18->unkC; - species = gContestResources->field_18->unk2; - xOffset = 20; - priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) - { - isBackPic = 0; - personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) - { - if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - else - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - } - else - { - species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; - } - xOffset = 20; - priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); - } - else - { - isBackPic = 1; - personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) - { - if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - else - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - } - else - { - species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; - } + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + isBackPic = 0; + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } - xOffset = -20; - priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); - } - } + xOffset = 20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + else + { + isBackPic = 1; + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } + + xOffset = -20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } coord1 = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); coord2 = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); - spriteId = sub_80A8394(species, isBackPic, 0, coord1 + xOffset, coord2, 5, personality, otId, gBattleAnimTarget, 1); + spriteId = sub_80768D0(species, isBackPic, 0, coord1 + xOffset, coord2, 5, personality, otId, gBattleAnimTarget, 1); gSprites[spriteId].oam.priority = priority; gSprites[spriteId].oam.objMode = ST_OAM_OBJ_BLEND; @@ -5056,46 +4983,34 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) } break; case 1: - if (IsContest()) - { - personality = gContestResources->field_18->unk8; - otId = gContestResources->field_18->unkC; - species = gContestResources->field_18->species; - subpriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker); - isBackPic = 0; - x = -32; - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - { - personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; - isBackPic = 0; - x = 272; - } - else - { - personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; - isBackPic = 1; - x = -32; - } - } + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; + isBackPic = 0; + x = 272; + } + else + { + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + isBackPic = 1; + x = -32; + } - spriteId2 = sub_80A8394(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); + spriteId2 = sub_80768D0(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) BlendPalette((gSprites[spriteId2].oam.paletteNum * 16) | 0x100, 16, 6, RGB_WHITE); diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index d0d40a6d8..a93913b82 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -1,6 +1,7 @@ #include "global.h" #include "battle.h" #include "battle_anim.h" +#include "battle_main.h" #include "battle_controllers.h" #include "battle_interface.h" #include "decompress.h" @@ -19,7 +20,6 @@ #include "constants/items.h" #include "constants/moves.h" #include "constants/songs.h" -#include "constants/rgb.h" // Defines #define TAG_PARTICLES_POKEBALL 55020 @@ -35,6 +35,9 @@ #define TAG_PARTICLES_LUXURYBALL 55030 #define TAG_PARTICLES_PREMIERBALL 55031 +#define HIHALF(n) (((n) & 0xFFFF0000) >> 16) +#define LOHALF(n) ((n) & 0xFFFF) + // IWRAM EWRAM_DATA int gUnknown_3005424 = 0; EWRAM_DATA u16 gUnknown_3005428 = 0; @@ -66,6 +69,8 @@ static void sub_80F05B4(u8); static void sub_80F0278(struct Sprite *); static void sub_80F0378(struct Sprite *); static void sub_80F04B4(struct Sprite *); +static void sub_80F052C(struct Sprite *sprite); +static void sub_80F0574(struct Sprite *sprite); static void PokeBallOpenParticleAnimation_Step1(struct Sprite *); static void PokeBallOpenParticleAnimation_Step2(struct Sprite *); static void DestroyBallOpenAnimationParticle(struct Sprite *); @@ -94,6 +99,10 @@ static void PremierBallOpenParticleAnimation(u8); static void sub_80F1B3C(struct Sprite *); // Data +extern const u32 gUnknown_8D2EC24[]; +extern const u32 gUnknown_8D2EC70[]; +extern const struct SpriteTemplate gBallSpriteTemplates[]; //for now + struct BallCaptureSuccessStarData { s8 xOffset; @@ -445,9 +454,9 @@ void sub_80EEC0C(u8 taskId) gSprites[spriteId3].callback = SpriteCallbackDummy; gSprites[spriteId4].callback = SpriteCallbackDummy; - sub_80A6B30(&unknownStruct); - AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_08C2EA9C); - AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_08C2EA50, unknownStruct.tilesOffset); + sub_80752A0(&unknownStruct); + AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_8D2EC70); + AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_8D2EC24, unknownStruct.tilesOffset); LoadCompressedPalette(gCureBubblesPal, unknownStruct.paletteId << 4, 32); gBattle_BG1_X = -gSprites[spriteId3].pos1.x + 32; @@ -492,7 +501,7 @@ static void sub_80EEDF4(u8 taskId) SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[12], 16 - gTasks[taskId].data[12])); if (gTasks[taskId].data[12] == 0) { - sub_80A477C(0); + sub_8073128(0); gBattle_WIN0H = 0; gBattle_WIN0V = 0; SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ | WININ_WIN1_CLR); @@ -518,7 +527,7 @@ static void sub_80EEDF4(u8 taskId) } } -static void sub_80EEFC8(u8 *paletteId1, u8 *paletteId2, u8 battler) +void sub_80EEFC8(u8 *paletteId1, u8 *paletteId2, u8 battler) { u8 healthBoxSpriteId; u8 spriteId1, spriteId2; @@ -547,7 +556,7 @@ void sub_80EF0B4(u8 taskId) DestroyAnimVisualTask(taskId); } -static void sub_80EF0E0(u8 battler) +void sub_80EF0E0(u8 battler) { u8 healthBoxSpriteId; u8 spriteId1, spriteId2; @@ -666,8 +675,8 @@ void sub_80EF344(u8 taskId) y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); priority = gSprites[spriteId].oam.priority; subpriority = gSprites[spriteId].subpriority; - gTasks[taskId].data[10] = AnimateBallOpenParticles(x, y + 32, priority, subpriority, ballId); - selectedPalettes = sub_80A75AC(1, 0, 0, 0, 0, 0, 0); + gTasks[taskId].data[10] = LaunchBallStarsTask(x, y + 32, priority, subpriority, ballId); + selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0); gTasks[taskId].data[11] = LaunchBallFadeMonTask(0, gBattleAnimAttacker, selectedPalettes, ballId); gTasks[taskId].data[0]++; break; @@ -764,25 +773,27 @@ void sub_80EF6D4(u8 taskId) u8 subpriority; u8 spriteId; - if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) + if (gBattleTypeFlags & BATTLE_TYPE_OLD_MAN_TUTORIAL) { - x = 32; + x = 28; y = 11; } else { x = 23; - y = 5; + y = 11; + if (gSaveBlock2Ptr->playerGender == FEMALE) + y = 13; } ballId = ItemIdToBallId(gLastUsedItem); subpriority = GetBattlerSpriteSubpriority(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)) + 1; - spriteId = CreateSprite(&gBallSpriteTemplates[ballId], x + 32, y | 80, subpriority); + spriteId = CreateSprite(&gBallSpriteTemplates[ballId], x | 32, y | 80, subpriority); gSprites[spriteId].data[0] = 34; gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, 0); gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) - 16; gSprites[spriteId].callback = SpriteCallbackDummy; - gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].callback = sub_8039E84; + gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].callback = sub_8012354; gTasks[taskId].data[0] = spriteId; gTasks[taskId].func = sub_80EF7EC; } @@ -853,7 +864,7 @@ static void sub_80EF8F0(struct Sprite *sprite) switch (ballId) { case 0 ... POKEBALL_COUNT - 1: - AnimateBallOpenParticles(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); + LaunchBallStarsTask(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); LaunchBallFadeMonTask(0, gBattleAnimTarget, 14, ballId); break; } @@ -1185,7 +1196,7 @@ static void sub_80EFFC4(struct Sprite *sprite) sprite->data[4]++; if (sprite->data[4] == 40) { - PlaySE(SE_RG_GETTING); + PlaySE(SE_GETTING); BlendPalettes(0x10000 << sprite->oam.paletteNum, 6, RGB(0, 0, 0)); sub_80F01B8(sprite); } @@ -1198,7 +1209,7 @@ static void sub_80EFFC4(struct Sprite *sprite) gDoingBattleAnim = 0; UpdateOamPriorityInAllHealthboxes(1); m4aMPlayAllStop(); - PlaySE(MUS_RG_FAN6); + PlaySE(MUS_FAN6); } else if (sprite->data[4] == 315) { @@ -1315,7 +1326,7 @@ static void sub_80F02B0(struct Sprite *sprite) switch (ballId) { case 0 ... POKEBALL_COUNT - 1: - AnimateBallOpenParticles(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); + LaunchBallStarsTask(sprite->pos1.x, sprite->pos1.y - 5, 1, 28, ballId); LaunchBallFadeMonTask(1, gBattleAnimTarget, 14, ballId); break; } @@ -1391,7 +1402,23 @@ static void sub_80F04B4(struct Sprite *sprite) // GhostBallDodge static void sub_80F052C(struct Sprite *sprite) { - // to do + s16 x; + s16 y; + + x = sprite->pos1.x + sprite->pos2.x; + sprite->pos1.x = x; + y = sprite->pos1.y + sprite->pos2.y; + sprite->pos1.y = y; + sprite->pos2.x = sprite->pos2.y = 0; + sprite->data[0] = 0x22; + sprite->data[1] = x; + sprite->data[2] = x - 8; + sprite->data[3] = y; + sprite->data[4] = 0x90; + sprite->data[5] = 0x20; + InitAnimArcTranslation(sprite); + TranslateAnimVerticalArc(sprite); + sprite->callback = sub_80F0574; } static void sub_80F0574(struct Sprite *sprite) @@ -1410,7 +1437,7 @@ static void sub_80F05B4(u8 ballId) } } -u8 AnimateBallOpenParticles(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId) +u8 LaunchBallStarsTask(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId) { u8 taskId; @@ -2217,7 +2244,7 @@ static void sub_80F1B3C(struct Sprite *sprite) sprite->data[4] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), 1) + gBattleAnimArgs[3]; sprite->data[5] = -32; InitAnimArcTranslation(sprite); - gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].callback = sub_8039E84; + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].callback = sub_8012354; sprite->callback = sub_80F1BCC; } diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c index 582dd20a5..91c1fabec 100644 --- a/src/battle_anim_status_effects.c +++ b/src/battle_anim_status_effects.c @@ -9,7 +9,7 @@ #include "trig.h" #include "util.h" #include "constants/battle_anim.h" -#include "constants/rgb.h" +#include "constants/pokemon.h" // Function Declarations static u8 sub_8078178(u8 battlerId, bool8 b); @@ -51,7 +51,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF3F8 = .anims = gSpriteAnimTable_83BF3F4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8AEC, + .callback = sub_8076F58, }; const struct SpriteTemplate gSpriteTemplate_83BF410 = @@ -62,7 +62,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF410 = .anims = gSpriteAnimTable_83BF3F4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8A6C, + .callback = sub_8076ED8, }; static const union AnimCmd gUnknown_83BF428[] = @@ -84,7 +84,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF434 = .anims = gSpriteAnimTable_83BF430, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8E30, + .callback = sub_807729C, }; const struct SpriteTemplate gSpriteTemplate_83BF44C = @@ -95,7 +95,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF44C = .anims = gSpriteAnimTable_83BF430, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8EE4, + .callback = sub_8077350, }; static const union AnimCmd gUnknown_83BF464[] = @@ -121,7 +121,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF480 = .anims = gSpriteAnimTable_83BF47C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8B64, + .callback = sub_8076FD0, }; const struct SpriteTemplate gSpriteTemplate_83BF498 = @@ -132,7 +132,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF498 = .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8AEC, + .callback = sub_8076F58, }; static const union AnimCmd gUnknown_83BF4B0[] = @@ -168,7 +168,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF4D4 = .anims = gSpriteAniimTable_83BF4C8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80A8AEC, + .callback = sub_8076F58, }; static const union AnimCmd gUnknown_83BF4EC[] = @@ -202,10 +202,11 @@ const struct SpriteTemplate gSpriteTemplate_83BF514 = .anims = gSpriteAnimTable_83BF4F4, .images = NULL, .affineAnims = gSpriteAffineAnimTable_83BF510, - .callback = sub_80A8A6C, + .callback = sub_8076ED8, }; -static const u32 gUnknown_83BF52C = _("TASK OVER\nタスクがオーバーしました$"); +const u8 gUnknown_83BF52C[] = _("TASK OVER\n"); +const u8 gUnknown_83BF536[] = {0x60, 0x5D, 0x58, 0x37, 0x55, 0xAE, 0x96, 0xAE, 0x0C, 0x1F, 0x0C, 0x10, 0xFF}; // static const struct Subsprite gSubsprites_83BF544[] = { @@ -510,8 +511,8 @@ void AnimTask_StatsChange(u8 taskId) gBattleAnimArgs[2] = 0; gBattleAnimArgs[3] = 0; gBattleAnimArgs[4] = sharply; - gTasks[taskId].func = sub_8116EB4; - sub_8116EB4(taskId); + gTasks[taskId].func = sub_80BB088; + sub_80BB088(taskId); } #undef CASE -- cgit v1.2.3 From 2453b88b9db93cf195c79f001c9c8ba22013fd6a Mon Sep 17 00:00:00 2001 From: Evan Date: Tue, 3 Dec 2019 10:54:47 -0700 Subject: resolve compiler errors --- src/battle_anim_effects_1.c | 6 +++--- src/battle_anim_effects_2.c | 25 +++++++++++++------------ src/battle_anim_effects_3.c | 32 ++++++++++++++------------------ src/battle_anim_mons.c | 2 +- src/battle_anim_special.c | 29 +++++++++++++++++++---------- src/ghost.c | 6 +++--- 6 files changed, 53 insertions(+), 47 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index ff0927f88..093d2b345 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -2375,7 +2375,7 @@ static void AnimAbsorptionOrbStep(struct Sprite* sprite) void AnimHyperBeamOrb(struct Sprite* sprite) { u16 speed; - u16 animNum = Random2(); + u16 animNum = Random(); StartSpriteAnim(sprite, animNum % 8); sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); @@ -2385,14 +2385,14 @@ void AnimHyperBeamOrb(struct Sprite* sprite) else sprite->pos1.x += 20; - speed = Random2(); + speed = Random(); sprite->data[0] = (speed & 31) + 64; sprite->data[1] = sprite->pos1.x; sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); sprite->data[3] = sprite->pos1.y; sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); InitAnimFastLinearTranslationWithSpeed(sprite); - sprite->data[5] = Random2() & 0xFF; + sprite->data[5] = Random() & 0xFF; sprite->data[6] = sprite->subpriority; sprite->callback = AnimHyperBeamOrbStep; sprite->callback(sprite); diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index cea915921..9cd6f4839 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -343,7 +343,7 @@ const struct SpriteTemplate gWaterPulseRingSpriteTemplate = //gUnknown_83E3CE8 .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gWaterPulseRingAffineAnimTable, - .callback = sub_80AC6D8, + .callback = AnimWaterPulseRing, //water.c }; const struct SpriteTemplate gEggThrowSpriteTemplate = //gUnknown_83E3D00 @@ -1828,9 +1828,9 @@ static void AnimBulletSeed_Step1(struct Sprite *sprite) for (i = 0; i < 8; i++) ptr[i - 7] = 0; - rand = Random2(); + rand = Random(); sprite->data[6] = 0xFFF4 - (rand & 7); - rand = Random2(); + rand = Random(); sprite->data[7] = (rand % 0xA0) + 0xA0; sprite->callback = AnimBulletSeed_Step2; sprite->affineAnimPaused = 0; @@ -3238,9 +3238,9 @@ void AnimTask_HeartsBackground(u8 taskId) SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); sub_80752A0(&animBg); - AnimLoadCompressedBgGfx(animBg.bgId, &gUnknown_08C232E0, animBg.tilesOffset); - sub_80A6D60(&animBg, &gUnknown_08C23D78, 0); - LoadCompressedPalette(&gUnknown_08C23D50, animBg.paletteId * 16, 32); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBg_AttractTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnimBg_AttractGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnimBg_AttractPal, animBg.paletteId * 16, 32); gTasks[taskId].func = HeartsBackground_Step; } @@ -3316,15 +3316,16 @@ void AnimTask_ScaryFace(u8 taskId) SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); sub_80752A0(&animBg); + if (IsContest()) - sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFaceContest, 0); + LZDecompressVram(gBattleAnimBgTilemap_ScaryFaceContest, animBg.bgTilemap); else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) - sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFacePlayer, 0); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBgTilemap_ScaryFacePlayer); else - sub_80A6D60(&animBg, &gBattleAnimBgTilemap_ScaryFaceOpponent, 0); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBgTilemap_ScaryFaceOpponent); - AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_08C249F8, animBg.tilesOffset); - LoadCompressedPalette(gUnknown_08C249D0, animBg.paletteId * 16, 32); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_ScaryFaceGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnim_ScaryFacePal, animBg.paletteId * 16, 32); gTasks[taskId].func = ScaryFace_Step; } @@ -3546,7 +3547,7 @@ void AnimPinkHeart(struct Sprite *sprite) sprite->pos1.y += sprite->pos2.y; sprite->pos2.x = 0; sprite->pos2.y = 0; - sprite->data[3] = Random2() % 180; + sprite->data[3] = Random() % 180; } } } diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index ab8b3f20a..4b2a3f310 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -120,10 +120,6 @@ static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); // Data -extern const u32 gUnknown_8D2A8C0[]; -extern const u32 gUnknown_8D2A808[]; -extern const u32 gUnknown_8D2A8A8[]; - const union AnimCmd gScratchAnimCmds[] = //83FEDE4 { ANIMCMD_FRAME(0, 4), @@ -2151,13 +2147,13 @@ void AnimMiniTwinklingStar(struct Sprite *sprite) u8 rand; s8 y; - rand = Random2() & 3; + rand = Random() & 3; if (rand == 0) sprite->oam.tileNum += 4; else sprite->oam.tileNum += 5; - y = Random2() & 7; + y = Random() & 7; if (y > 3) y = -y; @@ -2362,9 +2358,9 @@ void AnimTask_MorningSunLightBeam(u8 taskId) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); sub_80752A0(&animBg); - AnimLoadCompressedBgTilemap(animBg.bgId, gUnknown_8D2A8C0); - AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_8D2A808, animBg.tilesOffset); - LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnim_MorningSunTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_MorningSunGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnim_MorningSunPal, animBg.paletteId * 16, 32); if (IsContest()) { sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); @@ -2443,7 +2439,7 @@ void AnimGreenStar(struct Sprite *sprite) u8 spriteId1; u8 spriteId2; - xOffset = Random2(); + xOffset = Random(); xOffset &= 0x3F; if (xOffset > 31) xOffset = 32 - xOffset; @@ -2541,9 +2537,9 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); sub_80752A0(&animBg); - AnimLoadCompressedBgTilemap(animBg.bgId, gUnknown_8D2A8C0); - AnimLoadCompressedBgGfx(animBg.bgId, gUnknown_8D2A808, animBg.tilesOffset); - LoadCompressedPalette(gUnknown_8D2A8A8, animBg.paletteId * 16, 32); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnim_MorningSunTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_MorningSunGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnim_MorningSunPal, animBg.paletteId * 16, 32); if (IsContest()) { @@ -3011,10 +3007,10 @@ void AnimFlatterConfetti(struct Sprite *sprite) int rand1; int rand2; - tileOffset = Random2() % 12; + tileOffset = Random() % 12; sprite->oam.tileNum += tileOffset; - rand1 = Random2() & 0x1FF; - rand2 = Random2() & 0xFF; + rand1 = Random() & 0x1FF; + rand2 = Random() & 0xFF; if (rand1 & 1) sprite->data[0] = 0x5E0 + rand1; @@ -3249,7 +3245,7 @@ static void AnimTask_RolePlaySilhouetteStep2(u8 taskId) TrySetSpriteRotScale(&gSprites[spriteId], TRUE, gTasks[taskId].data[10], gTasks[taskId].data[11], 0); if (++gTasks[taskId].data[12] == 9) { - sub_80A749C(&gSprites[spriteId]); + sub_8075AD8(&gSprites[spriteId]); DestroySpriteAndFreeResources_(&gSprites[spriteId]); gTasks[taskId].func = DestroyAnimVisualTaskAndDisableBlend; } @@ -3771,7 +3767,7 @@ static void CreateSweatDroplets(u8 taskId, bool8 arg1) for (i = 0; i < 4; i++) { - u8 spriteId = CreateSprite(&gFacadeSweatDrop, xCoords[i], yCoords[i & 1], task->data[6] - 5); + u8 spriteId = CreateSprite(&gFacadeSweatDropSpriteTemplate, xCoords[i], yCoords[i & 1], task->data[6] - 5); if (spriteId != MAX_SPRITES) { gSprites[spriteId].data[0] = 0; diff --git a/src/battle_anim_mons.c b/src/battle_anim_mons.c index bdba7ae3b..7f3516670 100644 --- a/src/battle_anim_mons.c +++ b/src/battle_anim_mons.c @@ -884,7 +884,7 @@ void AnimLoadCompressedBgTilemap(u32 bgId, const u32 *src) CopyBgTilemapBufferToVram(bgId); } -u8 sub_8075454(void) +u8 GetBattleBgPaletteNum(void) { return 2; } diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index a93913b82..c228048cc 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -20,6 +20,7 @@ #include "constants/items.h" #include "constants/moves.h" #include "constants/songs.h" +#include "constants/pokemon.h" // Defines #define TAG_PARTICLES_POKEBALL 55020 @@ -39,9 +40,13 @@ #define LOHALF(n) ((n) & 0xFFFF) // IWRAM -EWRAM_DATA int gUnknown_3005424 = 0; -EWRAM_DATA u16 gUnknown_3005428 = 0; -EWRAM_DATA u16 gUnknown_300542C = 0; +//EWRAM_DATA int gUnknown_3005424 = 0; +//EWRAM_DATA u16 gUnknown_3005428 = 0; +//EWRAM_DATA u16 gUnknown_300542C = 0; + +extern u32 gUnknown_3005424; +extern u32 gUnknown_3005428; +extern u32 gUnknown_300542C; // Function Declarations static void sub_80EEDF4(u8); @@ -99,9 +104,8 @@ static void PremierBallOpenParticleAnimation(u8); static void sub_80F1B3C(struct Sprite *); // Data -extern const u32 gUnknown_8D2EC24[]; -extern const u32 gUnknown_8D2EC70[]; -extern const struct SpriteTemplate gBallSpriteTemplates[]; //for now +extern const struct SpriteTemplate gBallSpriteTemplates[POKEBALL_COUNT]; //for now +extern const u32 gBattleAnimSpriteGfx_Particles[]; struct BallCaptureSuccessStarData { @@ -455,8 +459,8 @@ void sub_80EEC0C(u8 taskId) gSprites[spriteId4].callback = SpriteCallbackDummy; sub_80752A0(&unknownStruct); - AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_8D2EC70); - AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_8D2EC24, unknownStruct.tilesOffset); + AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_D2EC24_Tilemap); + AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_D2EC24_Gfx, unknownStruct.tilesOffset); LoadCompressedPalette(gCureBubblesPal, unknownStruct.paletteId << 4, 32); gBattle_BG1_X = -gSprites[spriteId3].pos1.x + 32; @@ -2293,9 +2297,14 @@ void sub_80F1C8C(u8 taskId) DestroyAnimVisualTask(taskId); } -void sub_80F1C8C(u8 taskId) +void sub_80F1CE4(u8 taskId) { - // to do + if (gBattleCommunication[MULTISTRING_CHOOSER] > 2) + gBattleAnimArgs[7] = 0; + else + gBattleAnimArgs[7] = gBattleCommunication[MULTISTRING_CHOOSER]; + + DestroyAnimVisualTask(taskId); } // 080F1D14 diff --git a/src/ghost.c b/src/ghost.c index 643cc3b0d..793c9838c 100644 --- a/src/ghost.c +++ b/src/ghost.c @@ -1319,13 +1319,13 @@ static void sub_80B6BE4(u8 taskId) SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X); SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y); sub_80752C8(&animBgData, 2); - AnimLoadCompressedBgGfx(animBgData.bgId, gFile_graphics_battle_anims_backgrounds_scary_face_sheet, animBgData.tilesOffset); - LoadCompressedPalette(gFile_graphics_battle_anims_backgrounds_scary_face_palette, 16 * animBgData.paletteId, 0x20); + AnimLoadCompressedBgGfx(animBgData.bgId, gBattleAnim_ScaryFaceGfx, animBgData.tilesOffset); + LoadCompressedPalette(gBattleAnim_ScaryFacePal, 16 * animBgData.paletteId, 0x20); break; case 3: sub_80752C8(&animBgData, 2); gMonSpritesGfxPtr->field_17C = AllocZeroed(0x2000); - LZDecompressWram(gFile_graphics_battle_anims_backgrounds_scary_face_player_tilemap, gMonSpritesGfxPtr->field_17C); + LZDecompressWram(gBattleAnimBgTilemap_ScaryFacePlayer, gMonSpritesGfxPtr->field_17C); sub_80730C0(animBgData.paletteId, gMonSpritesGfxPtr->field_17C, 256, 0); CopyToBgTilemapBufferRect_ChangePalette(animBgData.bgId, gMonSpritesGfxPtr->field_17C, 0, 0, 0x20, 0x20, 0x11); CopyBgTilemapBufferToVram(2); -- cgit v1.2.3 From a9548849d7d9fab7ef78d1e693573caf11c9b5b7 Mon Sep 17 00:00:00 2001 From: Evan Date: Tue, 3 Dec 2019 19:50:42 -0700 Subject: resolve references --- src/battle_anim_effects_2.c | 4 ++-- src/battle_anim_special.c | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 9cd6f4839..215b7d869 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -292,12 +292,12 @@ const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = +const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = //gUnknown_83E3C98 { gGrowingRingAffineAnimCmds, }; -const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = +const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = //83E3C9C { gWaterPulseRingAffineAnimCmds, }; diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index c228048cc..108e6c196 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -104,8 +104,7 @@ static void PremierBallOpenParticleAnimation(u8); static void sub_80F1B3C(struct Sprite *); // Data -extern const struct SpriteTemplate gBallSpriteTemplates[POKEBALL_COUNT]; //for now -extern const u32 gBattleAnimSpriteGfx_Particles[]; +extern const struct SpriteTemplate gBallSpriteTemplates[]; //for now struct BallCaptureSuccessStarData { -- cgit v1.2.3 From 0acdd40d92dc2856f7438fadac000c9e85a60665 Mon Sep 17 00:00:00 2001 From: Evan Date: Wed, 4 Dec 2019 07:46:49 -0700 Subject: match battle_anim funcs --- src/battle_anim.c | 104 ++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 70 insertions(+), 34 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index de5f08f38..6510003e0 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -2165,52 +2165,83 @@ static void ScriptCmd_monbg(void) u8 taskId; u8 battlerId; u8 animBattler; + u8 position; + u8 spriteId; sBattleAnimScriptPtr++; - animBattler = sBattleAnimScriptPtr[0]; - if (animBattler & ANIM_TARGET) - battlerId = gBattleAnimTarget; - else - battlerId = gBattleAnimAttacker; + if (animBattler == 0) + animBattler = 2; + else if (animBattler == 1) + animBattler = 3; + if (animBattler == 0 || animBattler == 2) + battlerId = gBattleAnimAttacker; + else + battlerId = gBattleAnimTarget; + if (IsBattlerSpriteVisible(battlerId)) { - u8 position = GetBattlerPosition(battlerId); - toBG_2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) // || position == B_POSITION_PLAYER_RIGHT) + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; + else + toBG_2 = TRUE; MoveBattlerSpriteToBG(battlerId, toBG_2); + spriteId = gBattlerSpriteIds[battlerId]; taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); - gAnimVisualTaskCount++; - gTasks[taskId].data[t1_MONBG_BATTLER] = battlerId; - gTasks[taskId].data[t1_MON_IN_BG2] = toBG_2; - gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE; - gTasks[taskId].data[t1_IS_SECONDMON_BG] = 0; + gTasks[taskId].data[t1_MONBG_BATTLER] = spriteId; + gTasks[taskId].data[1] = gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x; + gTasks[taskId].data[2] = gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y; + if (!toBG_2) + { + gTasks[taskId].data[3] = gBattle_BG1_X; + gTasks[taskId].data[4] = gBattle_BG1_Y; + } + else + { + gTasks[taskId].data[3] = gBattle_BG2_X; + gTasks[taskId].data[4] = gBattle_BG2_Y; + } + gTasks[taskId].data[5] = toBG_2; + gTasks[taskId].data[6] = battlerId; + sMonAnimTaskIdArray[0] = taskId; } battlerId ^= BIT_FLANK; - if (IsBattlerSpriteVisible(battlerId)) + if (animBattler > 1 && IsBattlerSpriteVisible(battlerId)) { - u8 position = GetBattlerPosition(battlerId); - toBG_2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) // || position == B_POSITION_PLAYER_RIGHT) + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; + else + toBG_2 = TRUE; MoveBattlerSpriteToBG(battlerId, toBG_2); + spriteId = gBattlerSpriteIds[battlerId]; taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); - gAnimVisualTaskCount++; - gTasks[taskId].data[0] = battlerId; - gTasks[taskId].data[1] = toBG_2; - gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE; - gTasks[taskId].data[t1_IS_SECONDMON_BG] = 1; + gTasks[taskId].data[t1_MONBG_BATTLER] = spriteId; + gTasks[taskId].data[1] = gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x; + gTasks[taskId].data[2] = gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y; + if (!toBG_2) + { + gTasks[taskId].data[3] = gBattle_BG1_X; + gTasks[taskId].data[4] = gBattle_BG1_Y; + } + else + { + gTasks[taskId].data[3] = gBattle_BG2_X; + gTasks[taskId].data[4] = gBattle_BG2_Y; + } + + gTasks[taskId].data[5] = toBG_2; + gTasks[taskId].data[6] = battlerId; + sMonAnimTaskIdArray[1] = taskId; } sBattleAnimScriptPtr++; - gAnimFramesToWait = 1; - gAnimScriptCallback = WaitAnimFrameCount; } bool8 IsBattlerSpriteVisible(u8 battlerId) @@ -2224,26 +2255,30 @@ bool8 IsBattlerSpriteVisible(u8 battlerId) return FALSE; } +// re-check needed? void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) { struct BattleAnimBgData animBg; u8 battlerSpriteId; + struct Sprite *sprite; if (!toBG_2) { - u8 battlerPosition; - RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(16)), 0x2000, 1); - RequestDma3Fill(0xFF, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 0); + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(8)), 0x2000, 1); + RequestDma3Fill(0xFF, (void*)(BG_SCREEN_ADDR(28)), 0x1000, 0); sub_80752A0(&animBg); - CpuFill16(0, animBg.bgTiles, 0x1000); - CpuFill16(0xFF, animBg.bgTilemap, 0x800); + CpuFill16(toBG_2, animBg.bgTiles, 0x1000); + CpuFill16(toBG_2, animBg.bgTilemap, 0x800); SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 2); SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 1); SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0); battlerSpriteId = gBattlerSpriteIds[battlerId]; + gBattle_BG1_X = -(gSprites[battlerSpriteId].pos1.x + gSprites[battlerSpriteId].pos2.x) + 0x20; + gBattle_BG1_Y = -(gSprites[battlerSpriteId].pos1.y + gSprites[battlerSpriteId].pos2.y) + 0x20; + gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE; SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); @@ -2251,9 +2286,7 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], animBg.paletteId * 16, 0x20); CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + animBg.paletteId * 32), 0x20); - battlerPosition = GetBattlerPosition(battlerId); - - sub_80BCEF4(1, 0, 0, battlerPosition, animBg.paletteId, animBg.bgTiles, animBg.bgTilemap, animBg.tilesOffset); + sub_80BCEF4(1, 0, 0, GetBattlerPosition(battlerId), animBg.paletteId, animBg.bgTiles, animBg.bgTilemap, animBg.tilesOffset); } else { @@ -2261,15 +2294,15 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 1); sub_80752C8(&animBg, 2); CpuFill16(0, animBg.bgTiles + 0x1000, 0x1000); - CpuFill16(0, animBg.bgTilemap + 0x400, 0x800); + CpuFill16(0, animBg.bgTilemap + 0x400, 0x400); SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1); SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0); battlerSpriteId = gBattlerSpriteIds[battlerId]; - gBattle_BG2_X = -(gSprites[battlerSpriteId].pos1.x + gSprites[battlerSpriteId].pos2.x) + 0x20; gBattle_BG2_Y = -(gSprites[battlerSpriteId].pos1.y + gSprites[battlerSpriteId].pos2.y) + 0x20; + gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE; SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X); SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y); @@ -2285,6 +2318,7 @@ void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) { s32 i, j; s32 var; + s32 x; if (d == 0) var = 32; @@ -2295,7 +2329,9 @@ void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) for (i = 0; i < var; i++) { for (j = 0; j < 32; j++) + { b[j + i * 32] = ((b[j + i * 32] & 0xFFF) | a) + c; + } } } -- cgit v1.2.3 From 661a581176ecb6ad28e9d795fe02c3178c50b660 Mon Sep 17 00:00:00 2001 From: Evan Date: Wed, 4 Dec 2019 14:49:35 -0700 Subject: matching up battle_anim_special --- src/battle_anim.c | 97 +++++++++++++++++++++++++-------------------- src/battle_anim_effects_1.c | 16 ++------ src/battle_anim_effects_2.c | 18 ++++++--- src/battle_anim_effects_3.c | 72 ++++++++++++--------------------- src/battle_anim_special.c | 68 ++++++++++++++++++------------- 5 files changed, 137 insertions(+), 134 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index 6510003e0..16cf56920 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -65,6 +65,7 @@ static void LoadDefaultBg(void); static void Task_LoopAndPlaySE(u8 taskId); static void Task_WaitAndPlaySE(u8 taskId); static void sub_807331C(u8 taskId); +static bool8 sub_807378C(u16 a); static void ScriptCmd_loadspritegfx(void); static void ScriptCmd_unloadspritegfx(void); @@ -2316,9 +2317,8 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) { - s32 i, j; - s32 var; - s32 x; + u8 i, j; + u32 var; if (d == 0) var = 32; @@ -2330,7 +2330,7 @@ void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) { for (j = 0; j < 32; j++) { - b[j + i * 32] = ((b[j + i * 32] & 0xFFF) | a) + c; + b[32 * i + j] = ((b[32 * i + j] & 0xFFF) | a) + c; } } } @@ -2398,13 +2398,12 @@ static void ScriptCmd_clearmonbg(void) sBattleAnimScriptPtr++; animBattlerId = sBattleAnimScriptPtr[0]; + if (animBattlerId == 0) + animBattlerId = 2; + else if (animBattlerId == 1) + animBattlerId = 3; - if (animBattlerId == ANIM_ATTACKER) - animBattlerId = ANIM_ATK_PARTNER; - else if (animBattlerId == ANIM_TARGET) - animBattlerId = ANIM_DEF_PARTNER; - - if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + if (animBattlerId == 0 || animBattlerId == 2) battlerId = gBattleAnimAttacker; else battlerId = gBattleAnimTarget; @@ -2425,24 +2424,27 @@ static void ScriptCmd_clearmonbg(void) static void sub_807331C(u8 taskId) { - gTasks[taskId].data[1]++; + u8 toBG_2; + u8 position; + + gTasks[taskId].data[1]++; if (gTasks[taskId].data[1] != 1) { - u8 to_BG2; - u8 position = GetBattlerPosition(gTasks[taskId].data[2]); - to_BG2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) - to_BG2 = FALSE; + position = ((GetBattlerPosition((u8)gTasks[taskId].data[2]) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) + toBG_2 = FALSE; + else + toBG_2 = TRUE; if (sMonAnimTaskIdArray[0] != 0xFF) { - sub_8073128(to_BG2); + sub_8073128(toBG_2); DestroyTask(sMonAnimTaskIdArray[0]); sMonAnimTaskIdArray[0] = 0xFF; } if (gTasks[taskId].data[0] > 1) { - sub_8073128(to_BG2 ^ 1); + sub_8073128(toBG_2 ^ 1); DestroyTask(sMonAnimTaskIdArray[1]); sMonAnimTaskIdArray[1] = 0xFF; } @@ -2455,40 +2457,43 @@ static void ScriptCmd_monbg_22(void) bool8 toBG_2; u8 battlerId; u8 animBattlerId; + u8 position; sBattleAnimScriptPtr++; - animBattlerId = sBattleAnimScriptPtr[0]; + if (animBattlerId == 0) + animBattlerId = 2; + else if (animBattlerId == 1) + animBattlerId = 3; - if (animBattlerId == ANIM_ATTACKER) - animBattlerId = ANIM_ATK_PARTNER; - else if (animBattlerId == ANIM_TARGET) - animBattlerId = ANIM_DEF_PARTNER; - - if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) + if (animBattlerId == 0 || animBattlerId == 2) battlerId = gBattleAnimAttacker; else battlerId = gBattleAnimTarget; if (IsBattlerSpriteVisible(battlerId)) { - u8 position = GetBattlerPosition(battlerId); - toBG_2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; - + else + toBG_2 = TRUE; + MoveBattlerSpriteToBG(battlerId, toBG_2); + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; } battlerId ^= BIT_FLANK; if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId)) { - u8 position = GetBattlerPosition(battlerId); - toBG_2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) toBG_2 = FALSE; + else + toBG_2 = TRUE; MoveBattlerSpriteToBG(battlerId, toBG_2); + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; } sBattleAnimScriptPtr++; @@ -2530,16 +2535,19 @@ static void ScriptCmd_clearmonbg_23(void) static void sub_8073558(u8 taskId) { bool8 to_BG2; + u8 position; + u8 battlerId; gTasks[taskId].data[1]++; if (gTasks[taskId].data[1] != 1) { bool8 toBG_2; - u8 battlerId = gTasks[taskId].data[2]; - u8 position = GetBattlerPosition(battlerId); - to_BG2 = TRUE; - if (position < B_POSITION_OPPONENT_LEFT) - to_BG2 = FALSE; + battlerId = gTasks[taskId].data[2]; + position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code + if (position <= B_POSITION_OPPONENT_LEFT) + toBG_2 = FALSE; + else + toBG_2 = TRUE; if (IsBattlerSpriteVisible(battlerId)) sub_8073128(toBG_2); @@ -2625,6 +2633,7 @@ static void ScriptCmd_choosetwoturnanim(void) static void ScriptCmd_jumpifmoveturn(void) { u8 toCheck; + sBattleAnimScriptPtr++; toCheck = sBattleAnimScriptPtr[0]; sBattleAnimScriptPtr++; @@ -2641,13 +2650,18 @@ static void ScriptCmd_goto(void) sBattleAnimScriptPtr = T2_READ_PTR(sBattleAnimScriptPtr); } -//unused bool8 IsContest(void) { - if (!gMain.inBattle) - return TRUE; - else + return FALSE; +} + +// Unused +static bool8 sub_807378C(u16 a) +{ + if (a == 0xC9) return FALSE; + else + return TRUE; } #define tBackgroundId data[0] @@ -3192,7 +3206,6 @@ static void ScriptCmd_jumpargeq(void) static void ScriptCmd_jumpifcontest(void) { - sBattleAnimScriptPtr++; sBattleAnimScriptPtr += 5; } diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 093d2b345..2f92515c1 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -2215,6 +2215,7 @@ const struct SpriteTemplate gTauntFingerSpriteTemplate = //gUnknown_83E3AC4 .callback = AnimTauntFinger, }; +// Functions // Animates the falling particles that horizontally wave back and forth. // Used by Sleep Powder, Stun Spore, and Poison Powder. // arg 0: initial x pixel offset @@ -2734,7 +2735,7 @@ static void AnimTranslateLinearSingleSineWaveStep(struct Sprite* sprite) // arg 4: speedup frame (particles move faster at the end of the animation) void AnimMoveTwisterParticle(struct Sprite* sprite) { - if (IsDoubleBattle() == TRUE) + if (!IsContest() && IsDoubleBattle() == TRUE) SetAverageBattlerPositions(gBattleAnimTarget, 1, &sprite->pos1.x, &sprite->pos1.y); sprite->pos1.y += 32; @@ -2836,11 +2837,6 @@ void sub_80A2F0C(u8 taskId) else { PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_BLEND); - gTasks[taskId].data[14] = gSprites[spriteId].oam.priority; - gSprites[spriteId].oam.priority = GetBattlerSpriteBGPriority(gBattleAnimTarget); - spriteId = GetAnimBattlerSpriteId(ANIM_DEF_PARTNER); - gTasks[taskId].data[15] = gSprites[spriteId].oam.priority; - gSprites[spriteId].oam.priority = GetBattlerSpriteBGPriority(BATTLE_PARTNER(gBattleAnimTarget)); gTasks[taskId].data[0] = gBattleAnimArgs[0]; gTasks[taskId].data[1] = gBattleAnimArgs[1]; gTasks[taskId].data[11] = 0x100; @@ -2874,12 +2870,8 @@ static void AnimTask_DuplicateAndShrinkToPosStep2(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); ResetSpriteRotScale(spriteId); - gSprites[spriteId].pos2.x = 0; - gSprites[spriteId].pos2.y = 0; - gSprites[spriteId].oam.priority = gTasks[taskId].data[14]; - spriteId = GetAnimBattlerSpriteId(ANIM_DEF_PARTNER); - gSprites[spriteId].oam.priority = gTasks[taskId].data[15]; - gTasks[taskId].data[0]++; + gSprites[spriteId].pos2.y = gSprites[spriteId].pos2.x = 0; + gTasks[taskId].data[0]++; return; } } diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 215b7d869..1fe43b78c 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -51,7 +51,7 @@ void AnimAngel(struct Sprite *); void AnimPinkHeart(struct Sprite *); void AnimDevil(struct Sprite *); void AnimFurySwipes(struct Sprite *); -void AnimMovmentWaves(struct Sprite *); +void AnimMovementWaves(struct Sprite *); void AnimJaggedMusicNote(struct Sprite *); void AnimPerishSongMusicNote2(struct Sprite *); void AnimPerishSongMusicNote(struct Sprite *); @@ -98,7 +98,7 @@ static void HeartsBackground_Step(u8); static void ScaryFace_Step(u8); static void AnimOrbitFastStep(struct Sprite *); static void AnimOrbitScatterStep(struct Sprite *); -static void AnimMovmentWaves_Step(struct Sprite *); +static void AnimMovementWaves_Step(struct Sprite *); static void UproarDistortion_Step(u8); static void AnimJaggedMusicNote_Step(struct Sprite *); static void AnimPerishSongMusicNote_Step1(struct Sprite *); @@ -1152,7 +1152,7 @@ const struct SpriteTemplate gMovementWavesSpriteTemplate = //gUnknown_83E43F8 .anims = gMovementWavesAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = AnimMovmentWaves, + .callback = AnimMovementWaves, }; const union AffineAnimCmd gUnknown_08593B98[] = @@ -3241,6 +3241,9 @@ void AnimTask_HeartsBackground(u8 taskId) AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBg_AttractTilemap); AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnimBg_AttractGfx, animBg.tilesOffset); LoadCompressedPalette(gBattleAnimBg_AttractPal, animBg.paletteId * 16, 32); + if (IsContest()) + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + gTasks[taskId].func = HeartsBackground_Step; } @@ -3326,6 +3329,9 @@ void AnimTask_ScaryFace(u8 taskId) AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_ScaryFaceGfx, animBg.tilesOffset); LoadCompressedPalette(gBattleAnim_ScaryFacePal, animBg.paletteId * 16, 32); + if (IsContest()) + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + gTasks[taskId].func = ScaryFace_Step; } @@ -3596,7 +3602,7 @@ void AnimFurySwipes(struct Sprite *sprite) } } -void AnimMovmentWaves(struct Sprite *sprite) +void AnimMovementWaves(struct Sprite *sprite) { if (!gBattleAnimArgs[2]) { @@ -3623,11 +3629,11 @@ void AnimMovmentWaves(struct Sprite *sprite) sprite->data[0] = gBattleAnimArgs[2]; sprite->data[1] = gBattleAnimArgs[1]; StartSpriteAnim(sprite, sprite->data[1]); - sprite->callback = AnimMovmentWaves_Step; + sprite->callback = AnimMovementWaves_Step; } } -static void AnimMovmentWaves_Step(struct Sprite *sprite) +static void AnimMovementWaves_Step(struct Sprite *sprite) { if (sprite->animEnded) { diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 4b2a3f310..ec99a9f95 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -2365,6 +2365,7 @@ void AnimTask_MorningSunLightBeam(u8 taskId) { sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); gBattle_BG1_X = -56; + gBattle_BG1_Y = 0; } else { @@ -2372,15 +2373,17 @@ void AnimTask_MorningSunLightBeam(u8 taskId) gBattle_BG1_X = -135; else gBattle_BG1_X = -10; + + gBattle_BG1_Y = 0; } - - gBattle_BG1_Y = 0; + gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; gTasks[taskId].data[0]++; PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(-64)); break; + break; case 1: if (gTasks[taskId].data[4]++ > 0) { @@ -3890,18 +3893,9 @@ void AnimTask_GlareEyeDots(u8 taskId) { struct Task *task = &gTasks[taskId]; - if (IsContest()) - { - task->data[5] = 8; - task->data[6] = 3; - task->data[7] = 1; - } - else - { - task->data[5] = 12; - task->data[6] = 3; - task->data[7] = 0; - } + task->data[5] = 12; + task->data[6] = 3; + task->data[7] = 0; if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; @@ -4379,29 +4373,22 @@ void AnimTask_HelpingHandAttackerMovement(u8 taskId) struct Task *task = &gTasks[taskId]; task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); - if (!IsContest()) - { - if (IsDoubleBattle() == TRUE) - { - int x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); - int y = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimAttacker), 0); - if (x > y) - task->data[14] = 1; - else - task->data[14] = -1; - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - task->data[14] = -1; - else - task->data[14] = 1; - } - } - else - { - task->data[14] = 1; - } + if (IsDoubleBattle() == TRUE) + { + int x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + int y = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimAttacker), 0); + if (x > y) + task->data[14] = 1; + else + task->data[14] = -1; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + task->data[14] = -1; + else + task->data[14] = 1; + } task->func = AnimTask_HelpingHandAttackerMovementStep; } @@ -4641,7 +4628,7 @@ void AnimMeteorMashStar(struct Sprite *sprite) s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); // unused local variable s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); // unused local variable - if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER || IsContest()) + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) { sprite->data[0] = sprite->pos1.x - gBattleAnimArgs[0]; sprite->data[2] = sprite->pos1.x - gBattleAnimArgs[2]; @@ -4831,12 +4818,6 @@ void AnimTask_OdorSleuthMovement(u8 taskId) { s16 spriteId1, spriteId2; - if (IsContest()) - { - DestroyAnimVisualTask(taskId); - return; - } - spriteId1 = CloneBattlerSpriteWithBlend(ANIM_TARGET); if (spriteId1 < 0) { @@ -5095,7 +5076,7 @@ void sub_80E3E84(struct Sprite *sprite) sprite->data[0] = -32; sprite->data[7]++; sprite->invisible = 0; - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT && !IsContest()) + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) sprite->subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; } else @@ -5239,7 +5220,6 @@ static void AnimTask_TeeterDanceMovementStep(u8 taskId) static void AnimKnockOffStrikeStep(struct Sprite *sprite) { - // These two cases are identical. if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) { sprite->data[1] += sprite->data[0]; diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 108e6c196..0ee1eee2e 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -40,13 +40,13 @@ #define LOHALF(n) ((n) & 0xFFFF) // IWRAM -//EWRAM_DATA int gUnknown_3005424 = 0; -//EWRAM_DATA u16 gUnknown_3005428 = 0; -//EWRAM_DATA u16 gUnknown_300542C = 0; +EWRAM_DATA u16 gUnknown_3005424 = 0; +EWRAM_DATA u16 gUnknown_3005428 = 0; +EWRAM_DATA u16 gUnknown_300542C = 0; -extern u32 gUnknown_3005424; -extern u32 gUnknown_3005428; -extern u32 gUnknown_300542C; +//extern u32 gUnknown_3005424; +//extern u32 gUnknown_3005428; +//extern u32 gUnknown_300542C; // Function Declarations static void sub_80EEDF4(u8); @@ -704,12 +704,20 @@ void sub_80EF4B8(u8 taskId) DestroyAnimVisualTask(taskId); } -void AnimTask_IsBallBlockedByTrainer(u8 taskId) +void AnimTask_IsBallBlockedByTrainerOrDodged(u8 taskId) { - if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_TRAINER_BLOCK) - gBattleAnimArgs[ARG_RET_ID] = -1; - else - gBattleAnimArgs[ARG_RET_ID] = 0; + switch (gBattleSpritesDataPtr->animationData->ballThrowCaseId) + { + case BALL_TRAINER_BLOCK: + gBattleAnimArgs[ARG_RET_ID] = -1; + break; + case BALL_GHOST_DODGE: + gBattleAnimArgs[ARG_RET_ID] = -2; + break; + default: + gBattleAnimArgs[ARG_RET_ID] = 0; + break; + } DestroyAnimVisualTask(taskId); } @@ -902,8 +910,8 @@ static void sub_80EFA0C(struct Sprite *sprite) PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); gTasks[taskId].data[10] = 256; gUnknown_3005424 = 28; - gUnknown_300542C = (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y) - (sprite->pos1.y + sprite->pos2.y); - gUnknown_3005428 = (u32)(gUnknown_300542C * 256) / 28; + gUnknown_300542C = (gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y) - (sprite->pos2.y + sprite->pos1.y); + gUnknown_3005428 = (gUnknown_300542C * 256) / 28; gTasks[taskId].data[2] = gUnknown_3005428; gTasks[taskId].data[0]++; break; @@ -1209,7 +1217,7 @@ static void sub_80EFFC4(struct Sprite *sprite) } else if (sprite->data[4] == 95) { - gDoingBattleAnim = 0; + gDoingBattleAnim = FALSE; UpdateOamPriorityInAllHealthboxes(1); m4aMPlayAllStop(); PlaySE(MUS_FAN6); @@ -1364,7 +1372,7 @@ static void sub_80F0378(struct Sprite *sprite) gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible = gBattleSpritesDataPtr->animationData->field_9_x2; sprite->data[0] = 0; sprite->callback = sub_80F018C; - gDoingBattleAnim = 0; + gDoingBattleAnim = FALSE; UpdateOamPriorityInAllHealthboxes(1); } } @@ -1397,7 +1405,7 @@ static void sub_80F04B4(struct Sprite *sprite) { sprite->data[0] = 0; sprite->callback = sub_80F018C; - gDoingBattleAnim = 0; + gDoingBattleAnim = FALSE; UpdateOamPriorityInAllHealthboxes(1); } } @@ -1405,18 +1413,13 @@ static void sub_80F04B4(struct Sprite *sprite) // GhostBallDodge static void sub_80F052C(struct Sprite *sprite) { - s16 x; - s16 y; - - x = sprite->pos1.x + sprite->pos2.x; - sprite->pos1.x = x; - y = sprite->pos1.y + sprite->pos2.y; - sprite->pos1.y = y; - sprite->pos2.x = sprite->pos2.y = 0; + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = sprite->pos2.y = 0; sprite->data[0] = 0x22; - sprite->data[1] = x; - sprite->data[2] = x - 8; - sprite->data[3] = y; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = sprite->pos1.x - 8; + sprite->data[3] = sprite->pos1.y; sprite->data[4] = 0x90; sprite->data[5] = 0x20; InitAnimArcTranslation(sprite); @@ -1426,7 +1429,16 @@ static void sub_80F052C(struct Sprite *sprite) static void sub_80F0574(struct Sprite *sprite) { - //to do + if (!TranslateAnimVerticalArc(sprite)) + { + if ((sprite->pos1.y + sprite->pos2.y) < 65) + return; + } + + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + gDoingBattleAnim = FALSE; + UpdateOamPriorityInAllHealthboxes(1); } static void sub_80F05B4(u8 ballId) -- cgit v1.2.3 From 6581fdb69ddb2be974aa2278381c334b71a4a5ff Mon Sep 17 00:00:00 2001 From: Evan Date: Wed, 4 Dec 2019 18:53:21 -0700 Subject: almost all matching --- src/battle_anim.c | 33 +- src/battle_anim_effects_3.c | 810 ++++++++++++++++++++++++++++++++++++++- src/battle_anim_special.c | 27 +- src/battle_anim_status_effects.c | 4 +- 4 files changed, 835 insertions(+), 39 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index 16cf56920..6f4c8a91e 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -23,8 +23,8 @@ extern const u16 gMovesWithQuietBGM[]; extern const u8 *const gBattleAnims_Moves[]; -extern const struct CompressedSpriteSheet gUnknown_8399388[]; -extern const struct CompressedSpritePalette gUnknown_8399C90[]; +//extern const struct CompressedSpriteSheet gUnknown_8399388[]; +//extern const struct CompressedSpritePalette gUnknown_8399C90[]; // RAM EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; @@ -1958,9 +1958,14 @@ static void ScriptCmd_loadspritegfx(void) sBattleAnimScriptPtr++; index = T1_READ_16(sBattleAnimScriptPtr); - LoadCompressedSpriteSheetUsingHeap(&gUnknown_8399388[GET_TRUE_SPRITE_INDEX(index)]); - LoadCompressedSpritePaletteUsingHeap(&gUnknown_8399C90[GET_TRUE_SPRITE_INDEX(index)]); - sBattleAnimScriptPtr += 2; + + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[index]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[index]); + + //LoadCompressedSpriteSheetUsingHeap(&gUnknown_8399388[GET_TRUE_SPRITE_INDEX(index)]); + //LoadCompressedSpritePaletteUsingHeap(&gUnknown_8399C90[GET_TRUE_SPRITE_INDEX(index)]); + + sBattleAnimScriptPtr += 2; AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); gAnimFramesToWait = 1; gAnimScriptCallback = WaitAnimFrameCount; @@ -2193,8 +2198,8 @@ static void ScriptCmd_monbg(void) spriteId = gBattlerSpriteIds[battlerId]; taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); gTasks[taskId].data[t1_MONBG_BATTLER] = spriteId; - gTasks[taskId].data[1] = gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x; - gTasks[taskId].data[2] = gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y; + gTasks[taskId].data[1] = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x; + gTasks[taskId].data[2] = gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y; if (!toBG_2) { gTasks[taskId].data[3] = gBattle_BG1_X; @@ -2224,8 +2229,8 @@ static void ScriptCmd_monbg(void) spriteId = gBattlerSpriteIds[battlerId]; taskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10); gTasks[taskId].data[t1_MONBG_BATTLER] = spriteId; - gTasks[taskId].data[1] = gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x; - gTasks[taskId].data[2] = gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y; + gTasks[taskId].data[1] = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x; + gTasks[taskId].data[2] = gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y; if (!toBG_2) { gTasks[taskId].data[3] = gBattle_BG1_X; @@ -2247,10 +2252,12 @@ static void ScriptCmd_monbg(void) bool8 IsBattlerSpriteVisible(u8 battlerId) { - if (!IsBattlerSpritePresent(battlerId)) + u8 battler = battlerId; + + if (!IsBattlerSpritePresent(battler)) return FALSE; - if (!gBattleSpritesDataPtr->battlerData[battlerId].invisible || !gSprites[gBattlerSpriteIds[battlerId]].invisible) + if (!gBattleSpritesDataPtr->battlerData[battler].invisible || !gSprites[gBattlerSpriteIds[battler]].invisible) return TRUE; return FALSE; @@ -2267,7 +2274,7 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) { RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(8)), 0x2000, 1); - RequestDma3Fill(0xFF, (void*)(BG_SCREEN_ADDR(28)), 0x1000, 0); + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(28)), 0x1000, 1); sub_80752A0(&animBg); CpuFill16(toBG_2, animBg.bgTiles, 0x1000); CpuFill16(toBG_2, animBg.bgTilemap, 0x800); @@ -2295,7 +2302,7 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(30)), 0x1000, 1); sub_80752C8(&animBg, 2); CpuFill16(0, animBg.bgTiles + 0x1000, 0x1000); - CpuFill16(0, animBg.bgTilemap + 0x400, 0x400); + CpuFill16(0, animBg.bgTilemap + 0x400, 0x800); SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1); SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0); diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index ec99a9f95..a1484739e 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -4931,14 +4931,160 @@ void AnimTask_GetReturnPowerLevel(u8 taskId) // Makes the mon run out of screen, run past the opposing mon, and return to its original position. // No args. +/* +attempt.. void AnimTask_SnatchOpposingMonMove(u8 taskId) { u8 spriteId, spriteId2; - int personality; - int otId; + u32 personality; + u32 otId; u16 species; u8 subpriority; - u8 isBackPic; + //bool8 isBackPic; + s16 x; + + u16 tSpecies; + + switch (gTasks[taskId].data[0]) + { + case 0: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.x += (gTasks[taskId].data[1] >> 8); + else + gSprites[spriteId].pos2.x -= (gTasks[taskId].data[1] >> 8); + + gTasks[taskId].data[1] &= 0xFF; + x = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x; + if ((u16)(x + 32) > 304) + { + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[0]++; + } + break; + case 1: + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + + tSpecies = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + if (tSpecies == SPECIES_NONE) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; + //isBackPic = FALSE; + //x = 272; + spriteId = sub_80768D0(species, FALSE, 0, 272, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); + } + else + { + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + + tSpecies = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + if (tSpecies == SPECIES_NONE) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + //isBackPic = TRUE; + //x = -32; + spriteId = sub_80768D0(species, TRUE, 0, -32, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); + } + + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) + BlendPalette((gSprites[spriteId].oam.paletteNum * 16) | 0x100, 16, 6, RGB_WHITE); + + gTasks[taskId].data[15] = spriteId; + gTasks[taskId].data[0]++; + break; + case 2: + spriteId2 = gTasks[taskId].data[15]; + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId2].pos2.x -= (gTasks[taskId].data[1] >> 8); + else + gSprites[spriteId2].pos2.x += (gTasks[taskId].data[1] >> 8); + + gTasks[taskId].data[1] &= 0xFF; + x = gSprites[spriteId2].pos1.x + gSprites[spriteId2].pos2.x; + if (gTasks[taskId].data[14] == 0) + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + if (x < GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X)) + { + gTasks[taskId].data[14]++; + gBattleAnimArgs[7] = 0xFFFF; + } + } + else + { + if (x > GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X)) + { + gTasks[taskId].data[14]++; + gBattleAnimArgs[7] = 0xFFFF; + } + } + } + + if ((u16)(x + 32) > 304) + { + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[0]++; + } + break; + case 3: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + spriteId2 = gTasks[taskId].data[15]; + DestroySpriteAndFreeResources_(&gSprites[spriteId2]); + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + gSprites[spriteId].pos2.x = -gSprites[spriteId].pos1.x - 32; + else + gSprites[spriteId].pos2.x = 272 - gSprites[spriteId].pos1.x; + + gTasks[taskId].data[0]++; + break; + case 4: + spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + gTasks[taskId].data[1] += 0x800; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + gSprites[spriteId].pos2.x += (gTasks[taskId].data[1] >> 8); + if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x >= GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X)) + gSprites[spriteId].pos2.x = 0; + } + else + { + gSprites[spriteId].pos2.x -= (gTasks[taskId].data[1] >> 8); + if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x <= GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X)) + gSprites[spriteId].pos2.x = 0; + } + + gTasks[taskId].data[1] = (u8)gTasks[taskId].data[1]; + if (gSprites[spriteId].pos2.x == 0) + DestroyAnimVisualTask(taskId); + break; + } +} +*/ + +#ifdef NONMATCHING +// `species` variable getting loaded into r6 instead of r5 +//https://cexplore.karathan.at/z/0gMuxf +void AnimTask_SnatchOpposingMonMove(u8 taskId) +{ + u8 spriteId, spriteId2; + u32 personality; + u32 otId; + u16 species; + u8 subpriority; + bool8 isBackPic; s16 x; switch (gTasks[taskId].data[0]) @@ -4964,13 +5110,14 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) { personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); else species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; - isBackPic = 0; + isBackPic = FALSE; x = 272; } else @@ -4983,7 +5130,7 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; - isBackPic = 1; + isBackPic = TRUE; x = -32; } @@ -5063,6 +5210,659 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) break; } } +#else +NAKED +void AnimTask_SnatchOpposingMonMove(u8 taskId) +{ + asm_unified("\tpush {r4-r7,lr}\n" + "\tmov r7, r10\n" + "\tmov r6, r9\n" + "\tmov r5, r8\n" + "\tpush {r5-r7}\n" + "\tsub sp, 0x1C\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tmov r8, r0\n" + "\tldr r1, _080E395C @ =gTasks\n" + "\tlsls r0, 2\n" + "\tadd r0, r8\n" + "\tlsls r0, 3\n" + "\tadds r0, r1\n" + "\tmovs r1, 0x8\n" + "\tldrsh r0, [r0, r1]\n" + "\tcmp r0, 0x4\n" + "\tbls _080E3952\n" + "\tb _080E3E6C\n" + "_080E3952:\n" + "\tlsls r0, 2\n" + "\tldr r1, _080E3960 @ =_080E3964\n" + "\tadds r0, r1\n" + "\tldr r0, [r0]\n" + "\tmov pc, r0\n" + "\t.align 2, 0\n" + "_080E395C: .4byte gTasks\n" + "_080E3960: .4byte _080E3964\n" + "\t.align 2, 0\n" + "_080E3964:\n" + "\t.4byte _080E3978\n" + "\t.4byte _080E3A2C\n" + "\t.4byte _080E3BEC\n" + "\t.4byte _080E3D0C\n" + "\t.4byte _080E3D90\n" + "_080E3978:\n" + "\tmovs r0, 0\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tlsls r0, 24\n" + "\tlsrs r7, r0, 24\n" + "\tldr r1, _080E39C4 @ =gTasks\n" + "\tmov r2, r8\n" + "\tlsls r4, r2, 2\n" + "\tadds r0, r4, r2\n" + "\tlsls r0, 3\n" + "\tadds r6, r0, r1\n" + "\tmovs r3, 0x80\n" + "\tlsls r3, 4\n" + "\tadds r0, r3, 0\n" + "\tldrh r1, [r6, 0xA]\n" + "\tadds r0, r1\n" + "\tstrh r0, [r6, 0xA]\n" + "\tldr r0, _080E39C8 @ =gBattleAnimAttacker\n" + "\tldrb r0, [r0]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tmov r9, r4\n" + "\tcmp r0, 0\n" + "\tbne _080E39D0\n" + "\tldr r2, _080E39CC @ =gSprites\n" + "\tlsls r3, r7, 4\n" + "\tadds r1, r3, r7\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tldrh r0, [r6, 0xA]\n" + "\tlsls r0, 16\n" + "\tasrs r0, 24\n" + "\tldrh r4, [r1, 0x24]\n" + "\tadds r0, r4\n" + "\tstrh r0, [r1, 0x24]\n" + "\tb _080E39EA\n" + "\t.align 2, 0\n" + "_080E39C4: .4byte gTasks\n" + "_080E39C8: .4byte gBattleAnimAttacker\n" + "_080E39CC: .4byte gSprites\n" + "_080E39D0:\n" + "\tldr r3, _080E3A24 @ =gSprites\n" + "\tlsls r4, r7, 4\n" + "\tadds r2, r4, r7\n" + "\tlsls r2, 2\n" + "\tadds r2, r3\n" + "\tldrh r1, [r6, 0xA]\n" + "\tlsls r1, 16\n" + "\tasrs r1, 24\n" + "\tldrh r0, [r2, 0x24]\n" + "\tsubs r0, r1\n" + "\tstrh r0, [r2, 0x24]\n" + "\tadds r2, r3, 0\n" + "\tadds r3, r4, 0\n" + "_080E39EA:\n" + "\tldr r1, _080E3A28 @ =gTasks\n" + "\tmov r0, r9\n" + "\tadd r0, r8\n" + "\tlsls r0, 3\n" + "\tadds r4, r0, r1\n" + "\tldrb r0, [r4, 0xA]\n" + "\tstrh r0, [r4, 0xA]\n" + "\tadds r1, r3, r7\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tldrh r0, [r1, 0x24]\n" + "\tldrh r1, [r1, 0x20]\n" + "\tadds r0, r1\n" + "\tlsls r0, 16\n" + "\tmovs r1, 0x80\n" + "\tlsls r1, 14\n" + "\tadds r0, r1\n" + "\tmovs r1, 0x98\n" + "\tlsls r1, 17\n" + "\tcmp r0, r1\n" + "\tbhi _080E3A16\n" + "\tb _080E3E6C\n" + "_080E3A16:\n" + "\tmovs r0, 0\n" + "\tstrh r0, [r4, 0xA]\n" + "\tldrh r0, [r4, 0x8]\n" + "\tadds r0, 0x1\n" + "\tstrh r0, [r4, 0x8]\n" + "\tb _080E3E6C\n" + "\t.align 2, 0\n" + "_080E3A24: .4byte gSprites\n" + "_080E3A28: .4byte gTasks\n" + "_080E3A2C:\n" + "\tldr r4, _080E3A90 @ =gBattleAnimAttacker\n" + "\tldrb r0, [r4]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tcmp r0, 0\n" + "\tbne _080E3ACC\n" + "\tldr r7, _080E3A94 @ =gBattlerPartyIndexes\n" + "\tldrb r0, [r4]\n" + "\tlsls r0, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmovs r6, 0x64\n" + "\tmuls r0, r6\n" + "\tldr r5, _080E3A98 @ =gPlayerParty\n" + "\tadds r0, r5\n" + "\tmovs r1, 0\n" + "\tbl GetMonData\n" + "\tmov r10, r0\n" + "\tldrb r0, [r4]\n" + "\tlsls r0, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmuls r0, r6\n" + "\tadds r0, r5\n" + "\tmovs r1, 0x1\n" + "\tbl GetMonData\n" + "\tmov r9, r0\n" + "\tldr r0, _080E3A9C @ =gBattleSpritesDataPtr\n" + "\tldr r0, [r0]\n" + "\tldrb r2, [r4]\n" + "\tldr r1, [r0]\n" + "\tlsls r0, r2, 2\n" + "\tadds r1, r0, r1\n" + "\tldrh r0, [r1, 0x2]\n" + "\tcmp r0, 0\n" + "\tbne _080E3AA0\n" + "\tlsls r0, r2, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmuls r0, r6\n" + "\tadds r0, r5\n" + "\tmovs r1, 0xB\n" + "\tbl GetMonData\n" + "\tlsls r0, 16\n" + "\tlsrs r5, r0, 16\n" + "\tb _080E3AA2\n" + "\t.align 2, 0\n" + "_080E3A90: .4byte gBattleAnimAttacker\n" + "_080E3A94: .4byte gBattlerPartyIndexes\n" + "_080E3A98: .4byte gPlayerParty\n" + "_080E3A9C: .4byte gBattleSpritesDataPtr\n" + "_080E3AA0:\n" + "\tldrh r5, [r1, 0x2]\n" + "_080E3AA2:\n" + "\tmovs r0, 0x1\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tldr r2, _080E3AC8 @ =gSprites\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tlsls r1, r0, 4\n" + "\tadds r1, r0\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tadds r1, 0x43\n" + "\tldrb r0, [r1]\n" + "\tadds r0, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r4, r0, 24\n" + "\tmovs r7, 0\n" + "\tmovs r6, 0x88\n" + "\tlsls r6, 1\n" + "\tb _080E3B54\n" + "\t.align 2, 0\n" + "_080E3AC8: .4byte gSprites\n" + "_080E3ACC:\n" + "\tldr r7, _080E3B24 @ =gBattlerPartyIndexes\n" + "\tldrb r0, [r4]\n" + "\tlsls r0, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmovs r6, 0x64\n" + "\tmuls r0, r6\n" + "\tldr r5, _080E3B28 @ =gEnemyParty\n" + "\tadds r0, r5\n" + "\tmovs r1, 0\n" + "\tbl GetMonData\n" + "\tmov r10, r0\n" + "\tldrb r0, [r4]\n" + "\tlsls r0, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmuls r0, r6\n" + "\tadds r0, r5\n" + "\tmovs r1, 0x1\n" + "\tbl GetMonData\n" + "\tmov r9, r0\n" + "\tldr r0, _080E3B2C @ =gBattleSpritesDataPtr\n" + "\tldr r0, [r0]\n" + "\tldrb r2, [r4]\n" + "\tldr r1, [r0]\n" + "\tlsls r0, r2, 2\n" + "\tadds r1, r0, r1\n" + "\tldrh r0, [r1, 0x2]\n" + "\tcmp r0, 0\n" + "\tbne _080E3B30\n" + "\tlsls r0, r2, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmuls r0, r6\n" + "\tadds r0, r5\n" + "\tmovs r1, 0xB\n" + "\tbl GetMonData\n" + "\tlsls r0, 16\n" + "\tlsrs r5, r0, 16\n" + "\tb _080E3B32\n" + "\t.align 2, 0\n" + "_080E3B24: .4byte gBattlerPartyIndexes\n" + "_080E3B28: .4byte gEnemyParty\n" + "_080E3B2C: .4byte gBattleSpritesDataPtr\n" + "_080E3B30:\n" + "\tldrh r5, [r1, 0x2]\n" + "_080E3B32:\n" + "\tmovs r0, 0x1\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tldr r2, _080E3BD0 @ =gSprites\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tlsls r1, r0, 4\n" + "\tadds r1, r0\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tadds r1, 0x43\n" + "\tldrb r0, [r1]\n" + "\tsubs r0, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r4, r0, 24\n" + "\tmovs r7, 0x1\n" + "\tldr r6, _080E3BD4 @ =0x0000ffe0\n" + "_080E3B54:\n" + "\tldr r0, _080E3BD8 @ =gBattleAnimTarget\n" + "\tldrb r0, [r0]\n" + "\tmovs r1, 0x1\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tlsls r3, r6, 16\n" + "\tasrs r3, 16\n" + "\tstr r0, [sp]\n" + "\tstr r4, [sp, 0x4]\n" + "\tmov r2, r10\n" + "\tstr r2, [sp, 0x8]\n" + "\tmov r4, r9\n" + "\tstr r4, [sp, 0xC]\n" + "\tldr r4, _080E3BDC @ =gBattleAnimAttacker\n" + "\tldrb r0, [r4]\n" + "\tstr r0, [sp, 0x10]\n" + "\tmovs r0, 0\n" + "\tstr r0, [sp, 0x14]\n" + "\tadds r0, r5, 0\n" + "\tadds r1, r7, 0\n" + "\tmovs r2, 0\n" + "\tbl sub_80768D0\n" + "\tlsls r0, 24\n" + "\tlsrs r5, r0, 24\n" + "\tldr r0, _080E3BE0 @ =gBattleSpritesDataPtr\n" + "\tldr r1, [r0]\n" + "\tldrb r0, [r4]\n" + "\tldr r1, [r1]\n" + "\tlsls r0, 2\n" + "\tadds r0, r1\n" + "\tldrh r0, [r0, 0x2]\n" + "\tcmp r0, 0\n" + "\tbeq _080E3BBE\n" + "\tldr r1, _080E3BD0 @ =gSprites\n" + "\tlsls r0, r5, 4\n" + "\tadds r0, r5\n" + "\tlsls r0, 2\n" + "\tadds r0, r1\n" + "\tldrb r0, [r0, 0x5]\n" + "\tlsrs r0, 4\n" + "\tlsls r0, 4\n" + "\tmovs r2, 0x80\n" + "\tlsls r2, 1\n" + "\tadds r1, r2, 0\n" + "\torrs r0, r1\n" + "\tldr r3, _080E3BE4 @ =0x00007fff\n" + "\tmovs r1, 0x10\n" + "\tmovs r2, 0x6\n" + "\tbl BlendPalette\n" + "_080E3BBE:\n" + "\tldr r0, _080E3BE8 @ =gTasks\n" + "\tmov r3, r8\n" + "\tlsls r1, r3, 2\n" + "\tadd r1, r8\n" + "\tlsls r1, 3\n" + "\tadds r1, r0\n" + "\tstrh r5, [r1, 0x26]\n" + "\tb _080E3D82\n" + "\t.align 2, 0\n" + "_080E3BD0: .4byte gSprites\n" + "_080E3BD4: .4byte 0x0000ffe0\n" + "_080E3BD8: .4byte gBattleAnimTarget\n" + "_080E3BDC: .4byte gBattleAnimAttacker\n" + "_080E3BE0: .4byte gBattleSpritesDataPtr\n" + "_080E3BE4: .4byte 0x00007fff\n" + "_080E3BE8: .4byte gTasks\n" + "_080E3BEC:\n" + "\tldr r1, _080E3C38 @ =gTasks\n" + "\tmov r0, r8\n" + "\tlsls r4, r0, 2\n" + "\tadds r0, r4, r0\n" + "\tlsls r0, 3\n" + "\tadds r6, r0, r1\n" + "\tldrh r0, [r6, 0x26]\n" + "\tlsls r0, 24\n" + "\tlsrs r5, r0, 24\n" + "\tmovs r1, 0x80\n" + "\tlsls r1, 4\n" + "\tadds r0, r1, 0\n" + "\tldrh r2, [r6, 0xA]\n" + "\tadds r0, r2\n" + "\tstrh r0, [r6, 0xA]\n" + "\tldr r0, _080E3C3C @ =gBattleAnimAttacker\n" + "\tldrb r0, [r0]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tmov r9, r4\n" + "\tcmp r0, 0\n" + "\tbne _080E3C44\n" + "\tldr r3, _080E3C40 @ =gSprites\n" + "\tlsls r4, r5, 4\n" + "\tadds r2, r4, r5\n" + "\tlsls r2, 2\n" + "\tadds r2, r3\n" + "\tldrh r1, [r6, 0xA]\n" + "\tlsls r1, 16\n" + "\tasrs r1, 24\n" + "\tldrh r0, [r2, 0x24]\n" + "\tsubs r0, r1\n" + "\tstrh r0, [r2, 0x24]\n" + "\tadds r2, r3, 0\n" + "\tadds r3, r4, 0\n" + "\tb _080E3C5A\n" + "\t.align 2, 0\n" + "_080E3C38: .4byte gTasks\n" + "_080E3C3C: .4byte gBattleAnimAttacker\n" + "_080E3C40: .4byte gSprites\n" + "_080E3C44:\n" + "\tldr r2, _080E3CA8 @ =gSprites\n" + "\tlsls r3, r5, 4\n" + "\tadds r1, r3, r5\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tldrh r0, [r6, 0xA]\n" + "\tlsls r0, 16\n" + "\tasrs r0, 24\n" + "\tldrh r4, [r1, 0x24]\n" + "\tadds r0, r4\n" + "\tstrh r0, [r1, 0x24]\n" + "_080E3C5A:\n" + "\tldr r1, _080E3CAC @ =gTasks\n" + "\tmov r0, r9\n" + "\tadd r0, r8\n" + "\tlsls r0, 3\n" + "\tadds r6, r0, r1\n" + "\tldrb r0, [r6, 0xA]\n" + "\tstrh r0, [r6, 0xA]\n" + "\tadds r1, r3, r5\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tldrh r0, [r1, 0x24]\n" + "\tldrh r1, [r1, 0x20]\n" + "\tadds r0, r1\n" + "\tlsls r0, 16\n" + "\tlsrs r5, r0, 16\n" + "\tmovs r1, 0x24\n" + "\tldrsh r0, [r6, r1]\n" + "\tcmp r0, 0\n" + "\tbne _080E3CDA\n" + "\tldr r0, _080E3CB0 @ =gBattleAnimAttacker\n" + "\tldrb r0, [r0]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tcmp r0, 0\n" + "\tbne _080E3CB8\n" + "\tlsls r4, r5, 16\n" + "\tasrs r4, 16\n" + "\tldr r0, _080E3CB4 @ =gBattleAnimTarget\n" + "\tldrb r0, [r0]\n" + "\tmovs r1, 0\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tcmp r4, r0\n" + "\tbge _080E3CDA\n" + "\tb _080E3CCE\n" + "\t.align 2, 0\n" + "_080E3CA8: .4byte gSprites\n" + "_080E3CAC: .4byte gTasks\n" + "_080E3CB0: .4byte gBattleAnimAttacker\n" + "_080E3CB4: .4byte gBattleAnimTarget\n" + "_080E3CB8:\n" + "\tlsls r4, r5, 16\n" + "\tasrs r4, 16\n" + "\tldr r0, _080E3CFC @ =gBattleAnimTarget\n" + "\tldrb r0, [r0]\n" + "\tmovs r1, 0\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tcmp r4, r0\n" + "\tble _080E3CDA\n" + "_080E3CCE:\n" + "\tldrh r0, [r6, 0x24]\n" + "\tadds r0, 0x1\n" + "\tstrh r0, [r6, 0x24]\n" + "\tldr r1, _080E3D00 @ =gBattleAnimArgs\n" + "\tldr r0, _080E3D04 @ =0x0000ffff\n" + "\tstrh r0, [r1, 0xE]\n" + "_080E3CDA:\n" + "\tlsls r0, r5, 16\n" + "\tmovs r2, 0x80\n" + "\tlsls r2, 14\n" + "\tadds r0, r2\n" + "\tmovs r1, 0x98\n" + "\tlsls r1, 17\n" + "\tcmp r0, r1\n" + "\tbhi _080E3CEC\n" + "\tb _080E3E6C\n" + "_080E3CEC:\n" + "\tldr r0, _080E3D08 @ =gTasks\n" + "\tmov r1, r9\n" + "\tadd r1, r8\n" + "\tlsls r1, 3\n" + "\tadds r1, r0\n" + "\tmovs r0, 0\n" + "\tstrh r0, [r1, 0xA]\n" + "\tb _080E3D82\n" + "\t.align 2, 0\n" + "_080E3CFC: .4byte gBattleAnimTarget\n" + "_080E3D00: .4byte gBattleAnimArgs\n" + "_080E3D04: .4byte 0x0000ffff\n" + "_080E3D08: .4byte gTasks\n" + "_080E3D0C:\n" + "\tmovs r0, 0\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tlsls r0, 24\n" + "\tlsrs r7, r0, 24\n" + "\tldr r1, _080E3D58 @ =gTasks\n" + "\tmov r3, r8\n" + "\tlsls r4, r3, 2\n" + "\tadds r0, r4, r3\n" + "\tlsls r0, 3\n" + "\tadds r0, r1\n" + "\tldrh r0, [r0, 0x26]\n" + "\tlsls r0, 24\n" + "\tlsrs r5, r0, 24\n" + "\tlsls r0, r5, 4\n" + "\tadds r0, r5\n" + "\tlsls r0, 2\n" + "\tldr r5, _080E3D5C @ =gSprites\n" + "\tadds r0, r5\n" + "\tbl DestroySpriteAndFreeResources_\n" + "\tldr r0, _080E3D60 @ =gBattleAnimAttacker\n" + "\tldrb r0, [r0]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tmov r9, r4\n" + "\tcmp r0, 0\n" + "\tbne _080E3D64\n" + "\tlsls r1, r7, 4\n" + "\tadds r1, r7\n" + "\tlsls r1, 2\n" + "\tadds r1, r5\n" + "\tldrh r0, [r1, 0x20]\n" + "\tnegs r0, r0\n" + "\tsubs r0, 0x20\n" + "\tstrh r0, [r1, 0x24]\n" + "\tb _080E3D78\n" + "\t.align 2, 0\n" + "_080E3D58: .4byte gTasks\n" + "_080E3D5C: .4byte gSprites\n" + "_080E3D60: .4byte gBattleAnimAttacker\n" + "_080E3D64:\n" + "\tlsls r0, r7, 4\n" + "\tadds r0, r7\n" + "\tlsls r0, 2\n" + "\tadds r0, r5\n" + "\tldrh r2, [r0, 0x20]\n" + "\tmovs r4, 0x88\n" + "\tlsls r4, 1\n" + "\tadds r1, r4, 0\n" + "\tsubs r1, r2\n" + "\tstrh r1, [r0, 0x24]\n" + "_080E3D78:\n" + "\tldr r0, _080E3D8C @ =gTasks\n" + "\tmov r1, r9\n" + "\tadd r1, r8\n" + "\tlsls r1, 3\n" + "\tadds r1, r0\n" + "_080E3D82:\n" + "\tldrh r0, [r1, 0x8]\n" + "\tadds r0, 0x1\n" + "\tstrh r0, [r1, 0x8]\n" + "\tb _080E3E6C\n" + "\t.align 2, 0\n" + "_080E3D8C: .4byte gTasks\n" + "_080E3D90:\n" + "\tmovs r0, 0\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tlsls r0, 24\n" + "\tlsrs r7, r0, 24\n" + "\tldr r1, _080E3E04 @ =gTasks\n" + "\tmov r0, r8\n" + "\tlsls r4, r0, 2\n" + "\tadds r0, r4, r0\n" + "\tlsls r0, 3\n" + "\tadds r2, r0, r1\n" + "\tmovs r1, 0x80\n" + "\tlsls r1, 4\n" + "\tadds r0, r1, 0\n" + "\tldrh r3, [r2, 0xA]\n" + "\tadds r0, r3\n" + "\tstrh r0, [r2, 0xA]\n" + "\tldr r0, _080E3E08 @ =gBattleAnimAttacker\n" + "\tmov r10, r0\n" + "\tldrb r0, [r0]\n" + "\tstr r2, [sp, 0x18]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tmov r9, r4\n" + "\tldr r2, [sp, 0x18]\n" + "\tcmp r0, 0\n" + "\tbne _080E3E10\n" + "\tldr r1, _080E3E0C @ =gSprites\n" + "\tlsls r5, r7, 4\n" + "\tadds r0, r5, r7\n" + "\tlsls r0, 2\n" + "\tadds r6, r0, r1\n" + "\tldrh r0, [r2, 0xA]\n" + "\tlsls r0, 16\n" + "\tasrs r0, 24\n" + "\tldrh r1, [r6, 0x24]\n" + "\tadds r0, r1\n" + "\tstrh r0, [r6, 0x24]\n" + "\tmovs r2, 0x24\n" + "\tldrsh r4, [r6, r2]\n" + "\tmovs r3, 0x20\n" + "\tldrsh r0, [r6, r3]\n" + "\tadds r4, r0\n" + "\tmov r1, r10\n" + "\tldrb r0, [r1]\n" + "\tmovs r1, 0\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tadds r3, r5, 0\n" + "\tcmp r4, r0\n" + "\tblt _080E3E48\n" + "\tmovs r2, 0\n" + "\tstrh r2, [r6, 0x24]\n" + "\tb _080E3E48\n" + "\t.align 2, 0\n" + "_080E3E04: .4byte gTasks\n" + "_080E3E08: .4byte gBattleAnimAttacker\n" + "_080E3E0C: .4byte gSprites\n" + "_080E3E10:\n" + "\tldr r1, _080E3E7C @ =gSprites\n" + "\tlsls r5, r7, 4\n" + "\tadds r0, r5, r7\n" + "\tlsls r0, 2\n" + "\tadds r6, r0, r1\n" + "\tldrh r1, [r2, 0xA]\n" + "\tlsls r1, 16\n" + "\tasrs r1, 24\n" + "\tldrh r0, [r6, 0x24]\n" + "\tsubs r0, r1\n" + "\tstrh r0, [r6, 0x24]\n" + "\tmovs r3, 0x24\n" + "\tldrsh r4, [r6, r3]\n" + "\tmovs r1, 0x20\n" + "\tldrsh r0, [r6, r1]\n" + "\tadds r4, r0\n" + "\tmov r2, r10\n" + "\tldrb r0, [r2]\n" + "\tmovs r1, 0\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tadds r3, r5, 0\n" + "\tcmp r4, r0\n" + "\tbgt _080E3E48\n" + "\tmovs r4, 0\n" + "\tstrh r4, [r6, 0x24]\n" + "_080E3E48:\n" + "\tldr r1, _080E3E80 @ =gTasks\n" + "\tmov r0, r9\n" + "\tadd r0, r8\n" + "\tlsls r0, 3\n" + "\tadds r0, r1\n" + "\tldrb r1, [r0, 0xA]\n" + "\tstrh r1, [r0, 0xA]\n" + "\tldr r1, _080E3E7C @ =gSprites\n" + "\tadds r0, r3, r7\n" + "\tlsls r0, 2\n" + "\tadds r0, r1\n" + "\tmovs r1, 0x24\n" + "\tldrsh r0, [r0, r1]\n" + "\tcmp r0, 0\n" + "\tbne _080E3E6C\n" + "\tmov r0, r8\n" + "\tbl DestroyAnimVisualTask\n" + "_080E3E6C:\n" + "\tadd sp, 0x1C\n" + "\tpop {r3-r5}\n" + "\tmov r8, r3\n" + "\tmov r9, r4\n" + "\tmov r10, r5\n" + "\tpop {r4-r7}\n" + "\tpop {r0}\n" + "\tbx r0\n" + "\t.align 2, 0\n" + "_080E3E7C: .4byte gSprites\n" + "_080E3E80: .4byte gTasks\n"); +} +#endif void sub_80E3E84(struct Sprite *sprite) { diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 0ee1eee2e..7d512b950 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -40,7 +40,7 @@ #define LOHALF(n) ((n) & 0xFFFF) // IWRAM -EWRAM_DATA u16 gUnknown_3005424 = 0; +EWRAM_DATA int gUnknown_3005424 = 0; EWRAM_DATA u16 gUnknown_3005428 = 0; EWRAM_DATA u16 gUnknown_300542C = 0; @@ -104,8 +104,6 @@ static void PremierBallOpenParticleAnimation(u8); static void sub_80F1B3C(struct Sprite *); // Data -extern const struct SpriteTemplate gBallSpriteTemplates[]; //for now - struct BallCaptureSuccessStarData { s8 xOffset; @@ -910,8 +908,8 @@ static void sub_80EFA0C(struct Sprite *sprite) PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); gTasks[taskId].data[10] = 256; gUnknown_3005424 = 28; - gUnknown_300542C = (gSprites[spriteId].pos2.y + gSprites[spriteId].pos1.y) - (sprite->pos2.y + sprite->pos1.y); - gUnknown_3005428 = (gUnknown_300542C * 256) / 28; + gUnknown_300542C = (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y) - (sprite->pos1.y + sprite->pos2.y); + gUnknown_3005428 = (u32)(gUnknown_300542C * 256) / 28; gTasks[taskId].data[2] = gUnknown_3005428; gTasks[taskId].data[0]++; break; @@ -1876,20 +1874,11 @@ static void DestroyBallOpenAnimationParticle(struct Sprite *sprite) gBattleSpritesDataPtr->animationData->field_A--; if (gBattleSpritesDataPtr->animationData->field_A == 0) { - for (i = 0; i < POKEBALL_COUNT; i++) - { - if (FuncIsActiveTask(gBallParticleAnimationFuncs[i]) == TRUE) - break; - } - - if (i == POKEBALL_COUNT) - { - for (j = 0; j < POKEBALL_COUNT; j++) - { - FreeSpriteTilesByTag(gBallParticleSpritesheets[j].tag); - FreeSpritePaletteByTag(gBallParticlePalettes[j].tag); - } - } + for (j = 0; j < POKEBALL_COUNT; j++) + { + FreeSpriteTilesByTag(gBallParticleSpritesheets[j].tag); + FreeSpritePaletteByTag(gBallParticlePalettes[j].tag); + } DestroySprite(sprite); } diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c index 91c1fabec..4a45a3d8b 100644 --- a/src/battle_anim_status_effects.c +++ b/src/battle_anim_status_effects.c @@ -205,8 +205,8 @@ const struct SpriteTemplate gSpriteTemplate_83BF514 = .callback = sub_8076ED8, }; -const u8 gUnknown_83BF52C[] = _("TASK OVER\n"); -const u8 gUnknown_83BF536[] = {0x60, 0x5D, 0x58, 0x37, 0x55, 0xAE, 0x96, 0xAE, 0x0C, 0x1F, 0x0C, 0x10, 0xFF}; // +//const u8 gUnknown_83BF52C[] = _("TASK OVER\nタスクがオーバーしました"); //wont compile...? +const u8 gUnknown_83BF52C[] = {0xCE, 0xBB, 0xCD, 0xC5, 0x00, 0xC9, 0xD0, 0xBF, 0xCC, 0xFE, 0x60, 0x5D, 0x58, 0x37, 0x55, 0xAE, 0x96, 0xAE, 0x0C, 0x1F, 0x0C, 0x10, 0xFF}; static const struct Subsprite gSubsprites_83BF544[] = { -- cgit v1.2.3 From c8b22e2680d64f3a52e8f9ba8ccc81de9480ad5f Mon Sep 17 00:00:00 2001 From: Evan Date: Wed, 4 Dec 2019 21:18:40 -0700 Subject: format fixes --- src/battle_anim.c | 324 +++--- src/battle_anim_effects_1.c | 491 +++++----- src/battle_anim_effects_2.c | 243 +++-- src/battle_anim_effects_3.c | 1999 +++++++++++++++++--------------------- src/battle_anim_special.c | 182 ++-- src/battle_anim_status_effects.c | 8 +- 6 files changed, 1567 insertions(+), 1680 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index 6f4c8a91e..fd219bc11 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -18,14 +18,8 @@ #include "task.h" #include "constants/battle_anim.h" -// Defines #define ANIM_SPRITE_INDEX_COUNT 8 -extern const u16 gMovesWithQuietBGM[]; -extern const u8 *const gBattleAnims_Moves[]; -//extern const struct CompressedSpriteSheet gUnknown_8399388[]; -//extern const struct CompressedSpritePalette gUnknown_8399C90[]; - // RAM EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; EWRAM_DATA static const u8 *sBattleAnimScriptRetAddr = NULL; @@ -117,7 +111,10 @@ static void ScriptCmd_doublebattle_2E(void); static void ScriptCmd_stopsound(void); // Data -const struct OamData gOamData_AffineOff_ObjNormal_8x8 = //gOamData_83AC9C8 +extern const u16 gMovesWithQuietBGM[]; +extern const u8 *const gBattleAnims_Moves[]; + +const struct OamData gOamData_AffineOff_ObjNormal_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -132,7 +129,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x8 = //gOamData_83AC9C8 }; -const struct OamData gOamData_AffineOff_ObjNormal_16x16 = //gOamData_83AC9D0 +const struct OamData gOamData_AffineOff_ObjNormal_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -146,7 +143,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x16 = //gOamData_83AC9D0 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x32 = //gOamData_83AC9D8 +const struct OamData gOamData_AffineOff_ObjNormal_32x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -160,7 +157,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x32 = //gOamData_83AC9D8 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_64x64 = //gOamData_83AC9E0 +const struct OamData gOamData_AffineOff_ObjNormal_64x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -174,7 +171,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_64x64 = //gOamData_83AC9E0 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_16x8 = //gOamData_83AC9E8 +const struct OamData gOamData_AffineOff_ObjNormal_16x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -188,7 +185,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x8 = //gOamData_83AC9E8 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x8 = //gOamData_83AC9F0 +const struct OamData gOamData_AffineOff_ObjNormal_32x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -202,7 +199,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x8 = //gOamData_83AC9F0 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x16 = //gOamData_83AC9F8 +const struct OamData gOamData_AffineOff_ObjNormal_32x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -216,7 +213,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x16 = //gOamData_83AC9F8 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_64x32 = //gOamData_83ACA00 +const struct OamData gOamData_AffineOff_ObjNormal_64x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -230,7 +227,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_64x32 = //gOamData_83ACA00 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_8x16 = //gOamData_83ACA08 +const struct OamData gOamData_AffineOff_ObjNormal_8x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -244,7 +241,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x16 = //gOamData_83ACA08 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_8x32 = //gOamData_83ACA10 +const struct OamData gOamData_AffineOff_ObjNormal_8x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -258,7 +255,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x32 = //gOamData_83ACA10 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_16x32 = //gOamData_83ACA18 +const struct OamData gOamData_AffineOff_ObjNormal_16x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -272,7 +269,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_16x32 = //gOamData_83ACA18 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjNormal_32x64 = //gOamData_83ACA20 +const struct OamData gOamData_AffineOff_ObjNormal_32x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -286,7 +283,7 @@ const struct OamData gOamData_AffineOff_ObjNormal_32x64 = //gOamData_83ACA20 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = //gOamData_83ACA28 +const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -300,7 +297,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x8 = //gOamData_83ACA28 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = //gOamData_83ACA30 +const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -314,7 +311,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x16 = //gOamData_83ACA30 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = //gOamData_83ACA38 +const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -328,7 +325,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x32 = //gOamData_83ACA38 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = //gOamData_83ACA40 +const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -342,7 +339,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_64x64 = //gOamData_83ACA40 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = //gOamData_83ACA48 +const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -356,7 +353,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x8 = //gOamData_83ACA48 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = //gOamData_83ACA50 +const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -370,7 +367,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x8 = //gOamData_83ACA50 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = //gOamData_83ACA58 +const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -384,7 +381,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x16 = //gOamData_83ACA58 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = //gOamData_83ACA60 +const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -398,7 +395,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_64x32 = //gOamData_83ACA60 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = //gOamData_83ACA68 +const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -412,7 +409,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x16 = //gOamData_83ACA68 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = //gOamData_83ACA70 +const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -426,7 +423,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_8x32 = //gOamData_83ACA70 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = //gOamData_83ACA78 +const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -440,7 +437,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_16x32 = //gOamData_83ACA78 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = //gOamData_83ACA80 +const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -454,7 +451,7 @@ const struct OamData gOamData_AffineNormal_ObjNormal_32x64 = //gOamData_83ACA80 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = //gOamData_83ACA88 +const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -468,7 +465,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x8 = //gOamData_83ACA88 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = //gOamData_83ACA90 +const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -482,7 +479,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x16 = //gOamData_83ACA90 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = //gOamData_83ACA98 +const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -496,7 +493,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x32 = //gOamData_83ACA98 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = //gOamData_83ACAA0 +const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -510,7 +507,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_64x64 = //gOamData_83ACAA0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = //gOamData_83ACAA8 +const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -524,7 +521,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x8 = //gOamData_83ACAA8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = //gOamData_83ACAB0 +const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -538,7 +535,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x8 = //gOamData_83ACAB0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = //gOamData_83ACAB8 +const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -552,7 +549,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x16 = //gOamData_83ACAB8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = //gOamData_83ACAC0 +const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -566,7 +563,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_64x32 = //gOamData_83ACAC0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = //gOamData_83ACAC8 +const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -580,7 +577,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x16 = //gOamData_83ACAC8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = //gOamData_83ACAD0 +const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -594,7 +591,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_8x32 = //gOamData_83ACAD0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = //gOamData_83ACAD8 +const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -608,7 +605,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_16x32 = //gOamData_83ACAD8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = //gOamData_83ACAE0 +const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -622,7 +619,7 @@ const struct OamData gOamData_AffineDouble_ObjNormal_32x64 = //gOamData_83ACAE0 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x8 = //gOamData_83ACAE8 +const struct OamData gOamData_AffineOff_ObjBlend_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -636,7 +633,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x8 = //gOamData_83ACAE8 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x16 = //gOamData_83ACAF0 +const struct OamData gOamData_AffineOff_ObjBlend_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -650,7 +647,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x16 = //gOamData_83ACAF0 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x32 = //gOamData_83ACAF8 +const struct OamData gOamData_AffineOff_ObjBlend_32x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -664,7 +661,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x32 = //gOamData_83ACAF8 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_64x64 = //gOamData_83ACB00 +const struct OamData gOamData_AffineOff_ObjBlend_64x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -678,7 +675,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_64x64 = //gOamData_83ACB00 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x8 = //gOamData_83ACB08 +const struct OamData gOamData_AffineOff_ObjBlend_16x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -692,7 +689,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x8 = //gOamData_83ACB08 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x8 = //gOamData_83ACB10 +const struct OamData gOamData_AffineOff_ObjBlend_32x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -706,7 +703,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x8 = //gOamData_83ACB10 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x16 = //gOamData_83ACB18 +const struct OamData gOamData_AffineOff_ObjBlend_32x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -720,7 +717,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x16 = //gOamData_83ACB18 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_64x32 = //gOamData_83ACB20 +const struct OamData gOamData_AffineOff_ObjBlend_64x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -734,7 +731,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_64x32 = //gOamData_83ACB20 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x16 = //gOamData_83ACB28 +const struct OamData gOamData_AffineOff_ObjBlend_8x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -748,7 +745,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x16 = //gOamData_83ACB28 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_8x32 = //gOamData_83ACB30 +const struct OamData gOamData_AffineOff_ObjBlend_8x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -762,7 +759,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_8x32 = //gOamData_83ACB30 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_16x32 = //gOamData_83ACB38 +const struct OamData gOamData_AffineOff_ObjBlend_16x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -776,7 +773,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_16x32 = //gOamData_83ACB38 .paletteNum = 0, }; -const struct OamData gOamData_AffineOff_ObjBlend_32x64 = //gOamData_83ACB40 +const struct OamData gOamData_AffineOff_ObjBlend_32x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, @@ -790,7 +787,7 @@ const struct OamData gOamData_AffineOff_ObjBlend_32x64 = //gOamData_83ACB40 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = //gOamData_83ACB48 +const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -804,7 +801,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x8 = //gOamData_83ACB48 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = //gOamData_83ACB50 +const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -818,7 +815,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x16 = //gOamData_83ACB50 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = //gOamData_83ACB58 +const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -832,7 +829,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x32 = //gOamData_83ACB58 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = //gOamData_83ACB60 +const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -846,7 +843,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_64x64 = //gOamData_83ACB60 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = //gOamData_83ACB68 +const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -860,7 +857,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x8 = //gOamData_83ACB68 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = //gOamData_83ACB70 +const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -874,7 +871,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x8 = //gOamData_83ACB70 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = //gOamData_83ACB78 +const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -888,7 +885,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x16 = //gOamData_83ACB78 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = //gOamData_83ACB80 +const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -902,7 +899,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_64x32 = //gOamData_83ACB80 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = //gOamData_83ACB88 +const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -916,7 +913,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x16 = //gOamData_83ACB88 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = //gOamData_83ACB90 +const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -930,7 +927,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_8x32 = //gOamData_83ACB90 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = //gOamData_83ACB98 +const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -944,7 +941,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_16x32 = //gOamData_83ACB98 .paletteNum = 0, }; -const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = //gOamData_83ACBA0 +const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, @@ -958,7 +955,7 @@ const struct OamData gOamData_AffineNormal_ObjBlend_32x64 = //gOamData_83ACBA0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = //gOamData_83ACBA8 +const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -972,7 +969,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x8 = //gOamData_83ACBA8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = //gOamData_83ACBB0 +const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -986,7 +983,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x16 = //gOamData_83ACBB0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = //gOamData_83ACBB8 +const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1000,7 +997,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x32 = //gOamData_83ACBB8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = //gOamData_83ACBC0 +const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1014,7 +1011,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_64x64 = //gOamData_83ACBC0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = //gOamData_83ACBC8 +const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1028,7 +1025,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x8 = //gOamData_83ACBC8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = //gOamData_83ACBD0 +const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1042,7 +1039,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x8 = //gOamData_83ACBD0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = //gOamData_83ACBD8 +const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1056,7 +1053,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x16 = //gOamData_83ACBD8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = //gOamData_83ACBE0 +const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1070,7 +1067,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_64x32 = //gOamData_83ACBE0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = //gOamData_83ACBE8 +const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1084,7 +1081,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x16 = //gOamData_83ACBE8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = //gOamData_83ACBF0 +const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1098,7 +1095,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_8x32 = //gOamData_83ACBF0 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = //gOamData_83ACBF8 +const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1112,7 +1109,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_16x32 = //gOamData_83ACBF8 .paletteNum = 0, }; -const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = //gOamData_83ACC00 +const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_DOUBLE, @@ -1126,7 +1123,7 @@ const struct OamData gOamData_AffineDouble_ObjBlend_32x64 = //gOamData_83ACC00 .paletteNum = 0, }; -const struct CompressedSpriteSheet gBattleAnimPicTable[] = // 83ACC08 +const struct CompressedSpriteSheet gBattleAnimPicTable[] = { {gBattleAnimSpriteGfx_Bone, 0x0200, ANIM_TAG_BONE}, {gBattleAnimSpriteGfx_Spark, 0x0300, ANIM_TAG_SPARK}, @@ -1712,7 +1709,7 @@ const struct CompressedSpritePalette gBattleAnimPaletteTable[] = {gBattleAnimSpritePal_BlueRing2, ANIM_TAG_BLUE_RING_2}, }; -const struct BattleAnimBackground gBattleAnimBackgroundTable[] = // 83ADE18 +const struct BattleAnimBackground gBattleAnimBackgroundTable[] = { [BG_DARK_] = {gBattleAnimBgImage_Dark, gBattleAnimBgPalette_Dark, gBattleAnimBgTilemap_Dark}, [BG_DARK] = {gBattleAnimBgImage_Dark, gBattleAnimBgPalette_Dark, gBattleAnimBgTilemap_Dark}, @@ -1743,7 +1740,7 @@ const struct BattleAnimBackground gBattleAnimBackgroundTable[] = // 83ADE18 [BG_SOLARBEAM_CONTESTS] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Solarbeam, gBattleAnimBgTilemap_ImpactContests}, }; -static void (* const sScriptCmdTable[])(void) = // 83ADF5C +static void (* const sScriptCmdTable[])(void) = { ScriptCmd_loadspritegfx, ScriptCmd_unloadspritegfx, @@ -1808,7 +1805,7 @@ void ClearBattleAnimationVars(void) gAnimMoveDmg = 0; gAnimMovePower = 0; gAnimFriendship = 0; - + // Clear index array. for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) sAnimSpriteIndexArray[i] |= 0xFFFF; @@ -1838,15 +1835,15 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo { s32 i; - sub_80767F0(); - UpdateOamPriorityInAllHealthboxes(0); - for (i = 0; i < MAX_BATTLERS_COUNT; i++) - { - if (GetBattlerSide(i) != B_SIDE_PLAYER) - gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); - else - gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); - } + sub_80767F0(); + UpdateOamPriorityInAllHealthboxes(0); + for (i = 0; i < MAX_BATTLERS_COUNT; i++) + { + if (GetBattlerSide(i) != B_SIDE_PLAYER) + gAnimBattlerSpecies[i] = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + else + gAnimBattlerSpecies[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + } if (!isMoveAnim) sAnimMoveIndex = 0; @@ -1958,14 +1955,9 @@ static void ScriptCmd_loadspritegfx(void) sBattleAnimScriptPtr++; index = T1_READ_16(sBattleAnimScriptPtr); - - LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[index]); - LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[index]); - - //LoadCompressedSpriteSheetUsingHeap(&gUnknown_8399388[GET_TRUE_SPRITE_INDEX(index)]); - //LoadCompressedSpritePaletteUsingHeap(&gUnknown_8399C90[GET_TRUE_SPRITE_INDEX(index)]); - - sBattleAnimScriptPtr += 2; + LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)]); + LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(index)]); + sBattleAnimScriptPtr += 2; AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); gAnimFramesToWait = 1; gAnimScriptCallback = WaitAnimFrameCount; @@ -2077,7 +2069,6 @@ static void ScriptCmd_delay(void) gAnimScriptCallback = WaitAnimFrameCount; } -// Wait for visual tasks to finish. static void ScriptCmd_waitforvisualfinish(void) { if (gAnimVisualTaskCount == 0) @@ -2140,11 +2131,11 @@ static void ScriptCmd_end(void) } } - if (!continuousAnim) // May have been used for debug? + if (!continuousAnim) { m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256); - sub_80767F0(); - UpdateOamPriorityInAllHealthboxes(1); + sub_80767F0(); + UpdateOamPriorityInAllHealthboxes(1); gAnimScriptActive = FALSE; } } @@ -2176,20 +2167,20 @@ static void ScriptCmd_monbg(void) sBattleAnimScriptPtr++; animBattler = sBattleAnimScriptPtr[0]; - if (animBattler == 0) - animBattler = 2; - else if (animBattler == 1) - animBattler = 3; + if (animBattler == ANIM_ATTACKER) + animBattler = ANIM_ATK_PARTNER; + else if (animBattler == ANIM_TARGET) + animBattler = ANIM_DEF_PARTNER; - if (animBattler == 0 || animBattler == 2) + if (animBattler == ANIM_ATTACKER || animBattler == ANIM_ATK_PARTNER) battlerId = gBattleAnimAttacker; else battlerId = gBattleAnimTarget; - + if (IsBattlerSpriteVisible(battlerId)) { - position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code - if (position <= B_POSITION_OPPONENT_LEFT) + position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; else toBG_2 = TRUE; @@ -2217,10 +2208,10 @@ static void ScriptCmd_monbg(void) } battlerId ^= BIT_FLANK; - if (animBattler > 1 && IsBattlerSpriteVisible(battlerId)) + if (animBattler > ANIM_TARGET && IsBattlerSpriteVisible(battlerId)) { - position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code - if (position <= B_POSITION_OPPONENT_LEFT) + position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; else toBG_2 = TRUE; @@ -2253,8 +2244,8 @@ static void ScriptCmd_monbg(void) bool8 IsBattlerSpriteVisible(u8 battlerId) { u8 battler = battlerId; - - if (!IsBattlerSpritePresent(battler)) + + if (!IsBattlerSpritePresent(battler)) return FALSE; if (!gBattleSpritesDataPtr->battlerData[battler].invisible || !gSprites[gBattlerSpriteIds[battler]].invisible) @@ -2263,7 +2254,6 @@ bool8 IsBattlerSpriteVisible(u8 battlerId) return FALSE; } -// re-check needed? void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) { struct BattleAnimBgData animBg; @@ -2273,8 +2263,8 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2) if (!toBG_2) { - RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(8)), 0x2000, 1); - RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(28)), 0x1000, 1); + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(8)), 0x2000, 1); + RequestDma3Fill(0, (void*)(BG_SCREEN_ADDR(28)), 0x1000, 1); sub_80752A0(&animBg); CpuFill16(toBG_2, animBg.bgTiles, 0x1000); CpuFill16(toBG_2, animBg.bgTilemap, 0x800); @@ -2331,14 +2321,14 @@ void sub_80730C0(u16 a, u16 *b, s32 c, u8 d) var = 32; else var = 64; - + a <<= 12; for (i = 0; i < var; i++) { for (j = 0; j < 32; j++) - { + { b[32 * i + j] = ((b[32 * i + j] & 0xFFF) | a) + c; - } + } } } @@ -2405,22 +2395,22 @@ static void ScriptCmd_clearmonbg(void) sBattleAnimScriptPtr++; animBattlerId = sBattleAnimScriptPtr[0]; - if (animBattlerId == 0) - animBattlerId = 2; - else if (animBattlerId == 1) - animBattlerId = 3; + if (animBattlerId == ANIM_ATTACKER) + animBattlerId = ANIM_ATK_PARTNER; + else if (animBattlerId == ANIM_TARGET) + animBattlerId = ANIM_DEF_PARTNER; - if (animBattlerId == 0 || animBattlerId == 2) + if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) battlerId = gBattleAnimAttacker; else battlerId = gBattleAnimTarget; if (sMonAnimTaskIdArray[0] != 0xFF) gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; - if (animBattlerId > 1 && sMonAnimTaskIdArray[1] != 0xFF) + if (animBattlerId > ANIM_TARGET && sMonAnimTaskIdArray[1] != 0xFF) gSprites[gBattlerSpriteIds[battlerId ^ BIT_FLANK]].invisible = FALSE; else - animBattlerId = 0; + animBattlerId = ANIM_ATTACKER; taskId = CreateTask(sub_807331C, 5); gTasks[taskId].data[0] = animBattlerId; @@ -2431,14 +2421,14 @@ static void ScriptCmd_clearmonbg(void) static void sub_807331C(u8 taskId) { - u8 toBG_2; - u8 position; - - gTasks[taskId].data[1]++; + u8 toBG_2; + u8 position; + + gTasks[taskId].data[1]++; if (gTasks[taskId].data[1] != 1) { - position = ((GetBattlerPosition((u8)gTasks[taskId].data[2]) << 0x18) + 0xFF000000) >> 0x18; //make human code - if (position <= B_POSITION_OPPONENT_LEFT) + position = GetBattlerPosition((u8)gTasks[taskId].data[2]); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; else toBG_2 = TRUE; @@ -2464,43 +2454,43 @@ static void ScriptCmd_monbg_22(void) bool8 toBG_2; u8 battlerId; u8 animBattlerId; - u8 position; + u8 position; sBattleAnimScriptPtr++; animBattlerId = sBattleAnimScriptPtr[0]; - if (animBattlerId == 0) - animBattlerId = 2; - else if (animBattlerId == 1) - animBattlerId = 3; + if (animBattlerId == ANIM_ATTACKER) + animBattlerId = ANIM_ATK_PARTNER; + else if (animBattlerId == ANIM_TARGET) + animBattlerId = ANIM_DEF_PARTNER; - if (animBattlerId == 0 || animBattlerId == 2) + if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER) battlerId = gBattleAnimAttacker; else battlerId = gBattleAnimTarget; if (IsBattlerSpriteVisible(battlerId)) { - position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code - if (position <= B_POSITION_OPPONENT_LEFT) + position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; else toBG_2 = TRUE; - + MoveBattlerSpriteToBG(battlerId, toBG_2); - gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; } battlerId ^= BIT_FLANK; - if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId)) + if (animBattlerId > ANIM_TARGET && IsBattlerSpriteVisible(battlerId)) { - position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code - if (position <= B_POSITION_OPPONENT_LEFT) + position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; else toBG_2 = TRUE; MoveBattlerSpriteToBG(battlerId, toBG_2); - gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; + gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; } sBattleAnimScriptPtr++; @@ -2527,10 +2517,10 @@ static void ScriptCmd_clearmonbg_23(void) if (IsBattlerSpriteVisible(battlerId)) gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE; - if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) + if (animBattlerId > ANIM_TARGET && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) gSprites[gBattlerSpriteIds[battlerId ^ BIT_FLANK]].invisible = FALSE; else - animBattlerId = 0; + animBattlerId = ANIM_ATTACKER; taskId = CreateTask(sub_8073558, 5); gTasks[taskId].data[0] = animBattlerId; @@ -2544,21 +2534,21 @@ static void sub_8073558(u8 taskId) bool8 to_BG2; u8 position; u8 battlerId; - - gTasks[taskId].data[1]++; + + gTasks[taskId].data[1]++; if (gTasks[taskId].data[1] != 1) { bool8 toBG_2; battlerId = gTasks[taskId].data[2]; - position = ((GetBattlerPosition(battlerId) << 0x18) + 0xFF000000) >> 0x18; //make human code - if (position <= B_POSITION_OPPONENT_LEFT) + position = GetBattlerPosition(battlerId); + if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT) toBG_2 = FALSE; else toBG_2 = TRUE; if (IsBattlerSpriteVisible(battlerId)) sub_8073128(toBG_2); - + if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(battlerId ^ BIT_FLANK)) sub_8073128(toBG_2 ^ 1); @@ -2640,7 +2630,7 @@ static void ScriptCmd_choosetwoturnanim(void) static void ScriptCmd_jumpifmoveturn(void) { u8 toCheck; - + sBattleAnimScriptPtr++; toCheck = sBattleAnimScriptPtr[0]; sBattleAnimScriptPtr++; @@ -2659,7 +2649,7 @@ static void ScriptCmd_goto(void) bool8 IsContest(void) { - return FALSE; + return FALSE; } // Unused @@ -2746,14 +2736,14 @@ static void Task_FadeToBg(u8 taskId) static void LoadMoveBg(u16 bgId) { - LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26))); - LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2))); - LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32); + LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(BG_SCREEN_ADDR(26))); + LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(BG_CHAR_ADDR(2))); + LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32); } static void LoadDefaultBg(void) { - DrawMainBattleBackground(); + DrawMainBattleBackground(); } static void ScriptCmd_restorebg(void) @@ -2957,18 +2947,18 @@ static void Task_PanFromInitialToTarget(u8 taskId) pan = currentPan + incrementPan; gTasks[taskId].tCurrentPan = pan; - if (incrementPan == 0) // If we're not incrementing, just cancel the task immediately. + if (incrementPan == 0) { destroyTask = TRUE; } - else if (initialPanning < targetPanning) // Panning increasing. + else if (initialPanning < targetPanning) { - if (pan >= targetPanning) // Target reached. + if (pan >= targetPanning) destroyTask = TRUE; } else // Panning decreasing. { - if (pan <= targetPanning) // Target reached. + if (pan <= targetPanning) destroyTask = TRUE; } @@ -3213,7 +3203,7 @@ static void ScriptCmd_jumpargeq(void) static void ScriptCmd_jumpifcontest(void) { - sBattleAnimScriptPtr += 5; + sBattleAnimScriptPtr += 5; } static void ScriptCmd_monbgprio_28(void) diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 2f92515c1..b1209bb81 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -153,7 +153,7 @@ static void AnimTauntFingerStep2(struct Sprite *); static const u8 gUnknown_83E2964[] = {0x02, 0x04, 0x01, 0x03}; -const union AnimCmd gPowderParticlesAnimCmds[] = //gUnknown_83E2968 +const union AnimCmd gPowderParticlesAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(2, 5), @@ -166,12 +166,12 @@ const union AnimCmd gPowderParticlesAnimCmds[] = //gUnknown_83E2968 ANIMCMD_JUMP(0), }; -const union AnimCmd *const gPowderParticlesAnimTable[] = //gUnknown_83E298C +const union AnimCmd *const gPowderParticlesAnimTable[] = { gPowderParticlesAnimCmds, }; -const struct SpriteTemplate gSleepPowderParticleSpriteTemplate = //gUnknown_83E2990 +const struct SpriteTemplate gSleepPowderParticleSpriteTemplate = { .tileTag = ANIM_TAG_SLEEP_POWDER, .paletteTag = ANIM_TAG_SLEEP_POWDER, @@ -182,7 +182,7 @@ const struct SpriteTemplate gSleepPowderParticleSpriteTemplate = //gUnknown_83E2 .callback = AnimMovePowderParticle, }; -const struct SpriteTemplate gStunSporeParticleSpriteTemplate = //gUnknown_83E29A8 +const struct SpriteTemplate gStunSporeParticleSpriteTemplate = { .tileTag = ANIM_TAG_STUN_SPORE, .paletteTag = ANIM_TAG_STUN_SPORE, @@ -193,7 +193,7 @@ const struct SpriteTemplate gStunSporeParticleSpriteTemplate = //gUnknown_83E29A .callback = AnimMovePowderParticle, }; -const struct SpriteTemplate gPoisonPowderParticleSpriteTemplate = //gUnknown_83E29C0 +const struct SpriteTemplate gPoisonPowderParticleSpriteTemplate = { .tileTag = ANIM_TAG_POISON_POWDER, .paletteTag = ANIM_TAG_POISON_POWDER, @@ -204,7 +204,7 @@ const struct SpriteTemplate gPoisonPowderParticleSpriteTemplate = //gUnknown_83E .callback = AnimMovePowderParticle, }; -const union AnimCmd gSolarbeamBigOrbAnimCmds1[] = //gUnknown_83E29D8 +const union AnimCmd gSolarbeamBigOrbAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, @@ -258,7 +258,7 @@ const union AnimCmd gPowerAbsorptionOrbAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = //gUnknown_83E2A20 +const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = { gSolarbeamBigOrbAnimCmds1, gSolarbeamBigOrbAnimCmds2, @@ -269,28 +269,28 @@ const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = //gUnknown_83E2A20 gSolarbeamBigOrbAnimCmds7, }; -const union AnimCmd *const gSolarbeamSmallOrbAnimTable[] = //gUnknown_83E2A3C +const union AnimCmd *const gSolarbeamSmallOrbAnimTable[] = { gSolarbeamSmallOrbAnimCms, }; -const union AnimCmd *const gPowerAbsorptionOrbAnimTable[] = //gUnknown_83E2A40 +const union AnimCmd *const gPowerAbsorptionOrbAnimTable[] = { gPowerAbsorptionOrbAnimCmds, }; -const union AffineAnimCmd gPowerAbsorptionOrbAffineAnimCmds[] = //gUnknown_83E2A44 +const union AffineAnimCmd gPowerAbsorptionOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-5, -5, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gPowerAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2A54 +const union AffineAnimCmd *const gPowerAbsorptionOrbAffineAnimTable[] = { gPowerAbsorptionOrbAffineAnimCmds, }; -const struct SpriteTemplate gPowerAbsorptionOrbSpriteTemplate = //gUnknown_83E2A58 +const struct SpriteTemplate gPowerAbsorptionOrbSpriteTemplate = { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -301,7 +301,7 @@ const struct SpriteTemplate gPowerAbsorptionOrbSpriteTemplate = //gUnknown_83E2A .callback = AnimPowerAbsorptionOrb, }; -const struct SpriteTemplate gSolarbeamBigOrbSpriteTemplate = //gUnknown_83E2A70 +const struct SpriteTemplate gSolarbeamBigOrbSpriteTemplate = { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -312,7 +312,7 @@ const struct SpriteTemplate gSolarbeamBigOrbSpriteTemplate = //gUnknown_83E2A70 .callback = AnimSolarbeamBigOrb, }; -const struct SpriteTemplate gSolarbeamSmallOrbSpriteTemplate = //gUnknown_83E2A88 +const struct SpriteTemplate gSolarbeamSmallOrbSpriteTemplate = { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -323,19 +323,19 @@ const struct SpriteTemplate gSolarbeamSmallOrbSpriteTemplate = //gUnknown_83E2A8 .callback = AnimSolarbeamSmallOrb, }; -const union AffineAnimCmd gStockpileAbsorptionOrbAffineCmds[] = //gUnknown_83E2AA0 +const union AffineAnimCmd gStockpileAbsorptionOrbAffineCmds[] = { AFFINEANIMCMD_FRAME(320, 320, 0, 0), AFFINEANIMCMD_FRAME(-14, -14, 0, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gStockpileAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2AB8 +const union AffineAnimCmd *const gStockpileAbsorptionOrbAffineAnimTable[] = { gStockpileAbsorptionOrbAffineCmds, }; -const struct SpriteTemplate gStockpileAbsorptionOrbSpriteTemplate = //gUnknown_83E2ABC +const struct SpriteTemplate gStockpileAbsorptionOrbSpriteTemplate = { .tileTag = ANIM_TAG_GRAY_ORB, .paletteTag = ANIM_TAG_GRAY_ORB, @@ -346,18 +346,18 @@ const struct SpriteTemplate gStockpileAbsorptionOrbSpriteTemplate = //gUnknown_8 .callback = AnimPowerAbsorptionOrb, }; -const union AffineAnimCmd gAbsorptionOrbAffineAnimCmds[] = //gUnknown_83E2AD4 +const union AffineAnimCmd gAbsorptionOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-5, -5, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gAbsorptionOrbAffineAnimTable[] = //gUnknown_83E2AE4 +const union AffineAnimCmd *const gAbsorptionOrbAffineAnimTable[] = { gAbsorptionOrbAffineAnimCmds, }; -const struct SpriteTemplate gAbsorptionOrbSpriteTemplate = //gUnknown_83E2AE8 +const struct SpriteTemplate gAbsorptionOrbSpriteTemplate = { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -368,7 +368,7 @@ const struct SpriteTemplate gAbsorptionOrbSpriteTemplate = //gUnknown_83E2AE8 .callback = AnimAbsorptionOrb, }; -const struct SpriteTemplate gHyperBeamOrbSpriteTemplate = //gUnknown_83E2B00 +const struct SpriteTemplate gHyperBeamOrbSpriteTemplate = { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -379,26 +379,26 @@ const struct SpriteTemplate gHyperBeamOrbSpriteTemplate = //gUnknown_83E2B00 .callback = AnimHyperBeamOrb, }; -const union AnimCmd gLeechSeedAnimCmds1[] = //gUnknown_83E2B18 +const union AnimCmd gLeechSeedAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gLeechSeedAnimCmds2[] = //gUnknown_83E2B20 +const union AnimCmd gLeechSeedAnimCmds2[] = { ANIMCMD_FRAME(4, 7), ANIMCMD_FRAME(8, 7), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gLeechSeedAnimTable[] = //gUnknown_83E2B2C +const union AnimCmd *const gLeechSeedAnimTable[] = { gLeechSeedAnimCmds1, gLeechSeedAnimCmds2, }; -const struct SpriteTemplate gLeechSeedSpriteTemplate = //gUnknown_83E2B34 +const struct SpriteTemplate gLeechSeedSpriteTemplate = { .tileTag = ANIM_TAG_SEED, .paletteTag = ANIM_TAG_SEED, @@ -409,25 +409,25 @@ const struct SpriteTemplate gLeechSeedSpriteTemplate = //gUnknown_83E2B34 .callback = AnimLeechSeed, }; -const union AnimCmd gSporeParticleAnimCmds1[] = //gUnknown_83E2B4C +const union AnimCmd gSporeParticleAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gSporeParticleAnimCmds2[] = //gUnknown_83E2B54 +const union AnimCmd gSporeParticleAnimCmds2[] = { ANIMCMD_FRAME(4, 7), ANIMCMD_END, }; -const union AnimCmd *const gSporeParticleAnimTable[] = //gUnknown_83E2B5C +const union AnimCmd *const gSporeParticleAnimTable[] = { gSporeParticleAnimCmds1, gSporeParticleAnimCmds2, }; -const struct SpriteTemplate gSporeParticleSpriteTemplate = //gUnknown_83E2B64 +const struct SpriteTemplate gSporeParticleSpriteTemplate = { .tileTag = ANIM_TAG_SPORE, .paletteTag = ANIM_TAG_SPORE, @@ -438,29 +438,29 @@ const struct SpriteTemplate gSporeParticleSpriteTemplate = //gUnknown_83E2B64 .callback = AnimSporeParticle, }; -const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = //gUnknown_83E2B7C +const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = //gUnknown_83E2B84 +const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = //gUnknown_83E2B8C +const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = { gPetalDanceBigFlowerAnimCmds, }; -const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = //gUnknown_83E2B90 +const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = { gPetalDanceSmallFlowerAnimCmds, }; -const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = //gUnknown_83E2B94 +const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -471,7 +471,7 @@ const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = //gUnknown_83E2 .callback = AnimPetalDanceBigFlower, }; -const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = //gUnknown_83E2BAC +const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -482,7 +482,7 @@ const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = //gUnknown_83 .callback = AnimPetalDanceSmallFlower, }; -const union AnimCmd gRazorLeafParticleAnimCmds1[] = //gUnknown_83E2BC4 +const union AnimCmd gRazorLeafParticleAnimCmds1[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 5), @@ -497,7 +497,7 @@ const union AnimCmd gRazorLeafParticleAnimCmds1[] = //gUnknown_83E2BC4 ANIMCMD_JUMP(0), }; -const union AnimCmd gRazorLeafParticleAnimCmds2[] = //gUnknown_83E2BF0 +const union AnimCmd gRazorLeafParticleAnimCmds2[] = { ANIMCMD_FRAME(24, 5), ANIMCMD_FRAME(28, 5), @@ -505,13 +505,13 @@ const union AnimCmd gRazorLeafParticleAnimCmds2[] = //gUnknown_83E2BF0 ANIMCMD_END, }; -const union AnimCmd *const gRazorLeafParticleAnimTable[] = //gUnknown_83E2C00 +const union AnimCmd *const gRazorLeafParticleAnimTable[] = { gRazorLeafParticleAnimCmds1, gRazorLeafParticleAnimCmds2, }; -const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = //gUnknown_83E2C08 +const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -522,7 +522,7 @@ const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = //gUnknown_83E2C0 .callback = AnimRazorLeafParticle, }; -const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = //gUnknown_83E2C20 +const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -533,7 +533,7 @@ const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = //gUnknown_83E2 .callback = AnimMoveTwisterParticle, }; -const union AnimCmd gRazorLeafCutterAnimCmds[] = //gUnknown_83E2C38 +const union AnimCmd gRazorLeafCutterAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(0, 3, .hFlip = TRUE), @@ -542,12 +542,12 @@ const union AnimCmd gRazorLeafCutterAnimCmds[] = //gUnknown_83E2C38 ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRazorLeafCutterAnimTable[] = //gUnknown_83E2C4C +const union AnimCmd *const gRazorLeafCutterAnimTable[] = { gRazorLeafCutterAnimCmds, }; -const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = //gUnknown_83E2C50 +const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = { .tileTag = ANIM_TAG_RAZOR_LEAF, .paletteTag = ANIM_TAG_RAZOR_LEAF, @@ -558,18 +558,18 @@ const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = //gUnknown_83E2C50 .callback = AnimTranslateLinearSingleSineWave, }; -const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = //gUnknown_83E2C68 +const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = //gUnknown_83E2C78 +const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = { gSwiftStarAffineAnimCmds, }; -const struct SpriteTemplate gSwiftStarSpriteTemplate = //gUnknown_83E2C7C +const struct SpriteTemplate gSwiftStarSpriteTemplate = { .tileTag = ANIM_TAG_YELLOW_STAR, .paletteTag = ANIM_TAG_YELLOW_STAR, @@ -580,7 +580,7 @@ const struct SpriteTemplate gSwiftStarSpriteTemplate = //gUnknown_83E2C7C .callback = AnimTranslateLinearSingleSineWave, }; -const union AnimCmd gConstrictBindingAnimCmds1[] = //gUnknown_83E2C94 +const union AnimCmd gConstrictBindingAnimCmds1[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(32, 4), @@ -589,7 +589,7 @@ const union AnimCmd gConstrictBindingAnimCmds1[] = //gUnknown_83E2C94 ANIMCMD_END, }; -const union AnimCmd gConstrictBindingAnimCmds2[] = //gUnknown_83E2CA8 +const union AnimCmd gConstrictBindingAnimCmds2[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(32, 4, .hFlip = TRUE), @@ -598,13 +598,13 @@ const union AnimCmd gConstrictBindingAnimCmds2[] = //gUnknown_83E2CA8 ANIMCMD_END, }; -const union AnimCmd *const gConstrictBindingAnimTable[] = //gUnknown_83E2CBC +const union AnimCmd *const gConstrictBindingAnimTable[] = { gConstrictBindingAnimCmds1, gConstrictBindingAnimCmds2, }; -const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = //gUnknown_83E2CC4 +const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(-11, 0, 0, 6), @@ -612,7 +612,7 @@ const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = //gUnknown_83E2C AFFINEANIMCMD_END, }; -const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = //gUnknown_83E2CE4 +const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(11, 0, 0, 6), @@ -620,13 +620,13 @@ const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = //gUnknown_83E2C AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = //gUnknown_83E2D04 +const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = { gConstrictBindingAffineAnimCmds1, gConstrictBindingAffineAnimCmds2, }; -const struct SpriteTemplate gConstrictBindingSpriteTemplate = //gUnknown_83E2D0C +const struct SpriteTemplate gConstrictBindingSpriteTemplate = { .tileTag = ANIM_TAG_TENDRILS, .paletteTag = ANIM_TAG_TENDRILS, @@ -637,26 +637,26 @@ const struct SpriteTemplate gConstrictBindingSpriteTemplate = //gUnknown_83E2D0C .callback = AnimConstrictBinding, }; -const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = //gUnknown_83E2D24 +const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 0), AFFINEANIMCMD_FRAME(48, 48, 0, 14), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = //gUnknown_83E2D3C +const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(-16, -16, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = //gUnknown_83E2D4C +const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = { gMimicOrbAffineAnimCmds1, gMimicOrbAffineAnimCmds2, }; -const struct SpriteTemplate gMimicOrbSpriteTemplate = //gUnknown_83E2D54 +const struct SpriteTemplate gMimicOrbSpriteTemplate = { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -667,7 +667,7 @@ const struct SpriteTemplate gMimicOrbSpriteTemplate = //gUnknown_83E2D54 .callback = AnimMimicOrb, }; -const union AnimCmd gIngrainRootAnimCmds1[] = //gUnknown_83E2D6C +const union AnimCmd gIngrainRootAnimCmds1[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -676,7 +676,7 @@ const union AnimCmd gIngrainRootAnimCmds1[] = //gUnknown_83E2D6C ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds2[] = //gUnknown_83E2D80 +const union AnimCmd gIngrainRootAnimCmds2[] = { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -685,7 +685,7 @@ const union AnimCmd gIngrainRootAnimCmds2[] = //gUnknown_83E2D80 ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds3[] = //gUnknown_83E2D94 +const union AnimCmd gIngrainRootAnimCmds3[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -693,7 +693,7 @@ const union AnimCmd gIngrainRootAnimCmds3[] = //gUnknown_83E2D94 ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds4[] = //gUnknown_83E2DA4 +const union AnimCmd gIngrainRootAnimCmds4[] = { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -701,7 +701,7 @@ const union AnimCmd gIngrainRootAnimCmds4[] = //gUnknown_83E2DA4 ANIMCMD_END, }; -const union AnimCmd *const gIngrainRootAnimTable[] = //gUnknown_83E2DB4 +const union AnimCmd *const gIngrainRootAnimTable[] = { gIngrainRootAnimCmds1, gIngrainRootAnimCmds2, @@ -709,7 +709,7 @@ const union AnimCmd *const gIngrainRootAnimTable[] = //gUnknown_83E2DB4 gIngrainRootAnimCmds4, }; -const struct SpriteTemplate gIngrainRootSpriteTemplate = //gUnknown_83E2DC4 +const struct SpriteTemplate gIngrainRootSpriteTemplate = { .tileTag = ANIM_TAG_ROOTS, .paletteTag = ANIM_TAG_ROOTS, @@ -720,7 +720,7 @@ const struct SpriteTemplate gIngrainRootSpriteTemplate = //gUnknown_83E2DC4 .callback = AnimIngrainRoot, }; -const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = //gUnknown_83E2DDC +const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = { .tileTag = ANIM_TAG_ROOTS, .paletteTag = ANIM_TAG_ROOTS, @@ -731,19 +731,19 @@ const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = //gUnknown_83E2DDC .callback = AnimFrenzyPlantRoot, }; -const union AnimCmd gIngrainOrbAnimCmds[] = //gUnknown_83E2DF4 +const union AnimCmd gIngrainOrbAnimCmds[] = { ANIMCMD_FRAME(3, 3), ANIMCMD_FRAME(0, 5), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gIngrainOrbAnimTable[] = //gUnknown_83E2E00 +const union AnimCmd *const gIngrainOrbAnimTable[] = { gIngrainOrbAnimCmds, }; -const struct SpriteTemplate gIngrainOrbSpriteTemplate = //gUnknown_83E2E04 +const struct SpriteTemplate gIngrainOrbSpriteTemplate = { .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, @@ -754,18 +754,18 @@ const struct SpriteTemplate gIngrainOrbSpriteTemplate = //gUnknown_83E2E04 .callback = AnimIngrainOrb, }; -const union AnimCmd gFallingBagAnimCmds[] = //gUnknown_83E2E1C +const union AnimCmd gFallingBagAnimCmds[] = { ANIMCMD_FRAME(0, 30), ANIMCMD_END, }; -const union AnimCmd *const gFallingBagAnimTable[] = //gUnknown_83E2E24 +const union AnimCmd *const gFallingBagAnimTable[] = { gFallingBagAnimCmds, }; -const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = //gUnknown_83E2E28 +const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 10), AFFINEANIMCMD_FRAME(0, 0, 4, 20), @@ -773,7 +773,7 @@ const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = //gUnknown_83E2E28 AFFINEANIMCMD_END, }; -const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = //gUnknown_83E2E48 +const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0, 0, -1, 2), AFFINEANIMCMD_FRAME(0, 0, 1, 4), @@ -784,13 +784,13 @@ const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = //gUnknown_83E2E48 AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = //gUnknown_83E2E80 +const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = { gFallingBagAffineAnimCmds1, gFallingBagAffineAnimCmds2, }; -const struct SpriteTemplate gPresentSpriteTemplate = //gUnknown_83E2E88 +const struct SpriteTemplate gPresentSpriteTemplate = { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -801,7 +801,7 @@ const struct SpriteTemplate gPresentSpriteTemplate = //gUnknown_83E2E88 .callback = AnimPresent, }; -const struct SpriteTemplate gKnockOffItemSpriteTemplate = //gUnknown_83E2EA0 +const struct SpriteTemplate gKnockOffItemSpriteTemplate = { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -812,7 +812,7 @@ const struct SpriteTemplate gKnockOffItemSpriteTemplate = //gUnknown_83E2EA0 .callback = AnimKnockOffItem, }; -const union AnimCmd gPresentHealParticleAnimCmds[] = //gUnknown_83E2EB8 +const union AnimCmd gPresentHealParticleAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 4), @@ -821,12 +821,12 @@ const union AnimCmd gPresentHealParticleAnimCmds[] = //gUnknown_83E2EB8 ANIMCMD_END, }; -const union AnimCmd *const gPresentHealParticleAnimTable[] = //gUnknown_83E2ECC +const union AnimCmd *const gPresentHealParticleAnimTable[] = { gPresentHealParticleAnimCmds, }; -const struct SpriteTemplate gPresentHealParticleSpriteTemplate = //gUnknown_83E2ED0 +const struct SpriteTemplate gPresentHealParticleSpriteTemplate = { .tileTag = ANIM_TAG_GREEN_SPARKLE, .paletteTag = ANIM_TAG_GREEN_SPARKLE, @@ -837,7 +837,7 @@ const struct SpriteTemplate gPresentHealParticleSpriteTemplate = //gUnknown_83E2 .callback = AnimPresentHealParticle, }; -const struct SpriteTemplate gItemStealSpriteTemplate = //gUnknown_83E2EE8 +const struct SpriteTemplate gItemStealSpriteTemplate = { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -848,13 +848,13 @@ const struct SpriteTemplate gItemStealSpriteTemplate = //gUnknown_83E2EE8 .callback = AnimItemSteal, }; -const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = //gUnknown_83E2F00 +const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 3), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = //gUnknown_83E2F10 +const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0, -10, 0, 3), AFFINEANIMCMD_FRAME(0, -6, 0, 3), @@ -866,7 +866,7 @@ const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = //gUnknown_83E2F10 AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = //gUnknown_83E2F50 +const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = { gTrickBagAffineAnimCmds1, gTrickBagAffineAnimCmds2, @@ -874,7 +874,7 @@ const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = //gUnknown_83E2F5 gFallingBagAffineAnimCmds2, }; -const struct SpriteTemplate gTrickBagSpriteTemplate = //gUnknown_83E2F60 +const struct SpriteTemplate gTrickBagSpriteTemplate = { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -885,7 +885,7 @@ const struct SpriteTemplate gTrickBagSpriteTemplate = //gUnknown_83E2F60 .callback = AnimTrickBag, }; -const s8 gTrickBagCoordinates[][3] = //gUnknown_83E2F78 +const s8 gTrickBagCoordinates[][3] = { {5, 24, 1}, {0, 4, 0}, @@ -900,49 +900,49 @@ const s8 gTrickBagCoordinates[][3] = //gUnknown_83E2F78 {0, 0, 127}, }; -const union AnimCmd gLeafBladeAnimCmds1[] = //gUnknown_83E2F9C +const union AnimCmd gLeafBladeAnimCmds1[] = { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds2[] = //gUnknown_83E2FA4 +const union AnimCmd gLeafBladeAnimCmds2[] = { ANIMCMD_FRAME(32, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds3[] = //gUnknown_83E2FAC +const union AnimCmd gLeafBladeAnimCmds3[] = { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds4[] = //gUnknown_83E2FB4 +const union AnimCmd gLeafBladeAnimCmds4[] = { ANIMCMD_FRAME(28, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds5[] = //gUnknown_83E2FBC +const union AnimCmd gLeafBladeAnimCmds5[] = { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds6[] = //gUnknown_83E2FC4 +const union AnimCmd gLeafBladeAnimCmds6[] = { ANIMCMD_FRAME(16, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds7[] = //gUnknown_83E2FCC +const union AnimCmd gLeafBladeAnimCmds7[] = { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -const union AnimCmd *const gLeafBladeAnimTable[] = //gUnknown_83E2FD4 +const union AnimCmd *const gLeafBladeAnimTable[] = { gLeafBladeAnimCmds1, gLeafBladeAnimCmds2, @@ -953,7 +953,7 @@ const union AnimCmd *const gLeafBladeAnimTable[] = //gUnknown_83E2FD4 gLeafBladeAnimCmds7, }; -const struct SpriteTemplate gLeafBladeSpriteTemplate = //gUnknown_83E2FF0 +const struct SpriteTemplate gLeafBladeSpriteTemplate = { .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, @@ -964,19 +964,19 @@ const struct SpriteTemplate gLeafBladeSpriteTemplate = //gUnknown_83E2FF0 .callback = SpriteCallbackDummy, }; -const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = //gUnknown_83E3008 +const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = //gUnknown_83E3020 +const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = { gAromatherapyBigFlowerAffineAnimCmds, }; -const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = //gUnknown_83E3024 +const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -987,7 +987,7 @@ const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = //gUnknown_ .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = //gUnknown_83E303C +const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = { .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, @@ -998,43 +998,43 @@ const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = //gUnknown_83 .callback = AnimFlyingParticle, }; -const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = //gUnknown_83E3054 +const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -10, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = //gUnknown_83E306C +const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(192, 192, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -12, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = //gUnknown_83E3084 +const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(143, 143, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -15, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = //gUnknown_83E309C +const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = { gSilverWindBigSparkAffineAnimCmds, }; -const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = //gUnknown_83E30A0 +const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = { gSilverWindMediumSparkAffineAnimCmds, }; -const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = //gUnknown_83E30A4 +const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = { gSilverWindSmallSparkAffineAnimCmds, }; -const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = //gUnknown_83E30A8 +const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1045,7 +1045,7 @@ const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = //gUnknown_83E30 .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = //gUnknown_83E30C0 +const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1056,7 +1056,7 @@ const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = //gUnknown_83 .callback = AnimFlyingParticle, }; -const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = //gUnknown_83E30D8 +const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = { .tileTag = ANIM_TAG_SPARKLE_6, .paletteTag = ANIM_TAG_SPARKLE_6, @@ -1067,7 +1067,7 @@ const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = //gUnknown_83E .callback = AnimFlyingParticle, }; -const u16 gMagicalLeafBlendColors[] = //gUnknown_83E30F0 +const u16 gMagicalLeafBlendColors[] = { RGB(31, 0, 0), RGB(31, 19, 0), @@ -1078,7 +1078,7 @@ const u16 gMagicalLeafBlendColors[] = //gUnknown_83E30F0 RGB(22, 21, 31), }; -const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = //gUnknown_83E3100 +const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = { .tileTag = ANIM_TAG_GREEN_SPIKE, .paletteTag = ANIM_TAG_GREEN_SPIKE, @@ -1089,7 +1089,7 @@ const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = //gUnknown_83E3100 .callback = AnimNeedleArmSpike, }; -const union AnimCmd gWhipAnimCmds1[] = //gUnknown_83E3118 +const union AnimCmd gWhipAnimCmds1[] = { ANIMCMD_FRAME(64, 3), ANIMCMD_FRAME(80, 3), @@ -1098,7 +1098,7 @@ const union AnimCmd gWhipAnimCmds1[] = //gUnknown_83E3118 ANIMCMD_END, }; -const union AnimCmd gWhipAnimCmds2[] = //gUnknown_83E312C +const union AnimCmd gWhipAnimCmds2[] = { ANIMCMD_FRAME(64, 3, .hFlip = TRUE), ANIMCMD_FRAME(80, 3, .hFlip = TRUE), @@ -1107,13 +1107,13 @@ const union AnimCmd gWhipAnimCmds2[] = //gUnknown_83E312C ANIMCMD_END, }; -const union AnimCmd *const gWhipAnimTable[] = //gUnknown_83E3140 +const union AnimCmd *const gWhipAnimTable[] = { gWhipAnimCmds1, gWhipAnimCmds2, }; -const struct SpriteTemplate gSlamHitSpriteTemplate = //gUnknown_83E3148 +const struct SpriteTemplate gSlamHitSpriteTemplate = { .tileTag = ANIM_TAG_SLAM_HIT, .paletteTag = ANIM_TAG_SLAM_HIT, @@ -1124,7 +1124,7 @@ const struct SpriteTemplate gSlamHitSpriteTemplate = //gUnknown_83E3148 .callback = AnimWhipHit, }; -const struct SpriteTemplate gVineWhipSpriteTemplate = //gUnknown_83E3160 +const struct SpriteTemplate gVineWhipSpriteTemplate = { .tileTag = ANIM_TAG_WHIP_HIT, .paletteTag = ANIM_TAG_WHIP_HIT, @@ -1150,7 +1150,8 @@ const union AnimCmd *const gUnknown_83E3190[] = gUnknown_83E3178, }; -const struct SpriteTemplate gUnknown_83E3194 = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E3194 = { .tileTag = ANIM_TAG_HIT, .paletteTag = ANIM_TAG_HIT, @@ -1161,7 +1162,8 @@ const struct SpriteTemplate gUnknown_83E3194 = // Unused .callback = sub_80A43F8, }; -const struct SpriteTemplate gUnknown_83E31AC = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E31AC = { .tileTag = ANIM_TAG_HIT_2, .paletteTag = ANIM_TAG_HIT_2, @@ -1232,7 +1234,8 @@ const union AffineAnimCmd *const gUnknown_83E3244[] = gUnknown_83E3234, }; -const struct SpriteTemplate gUnknown_83E3264 = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E3264 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, @@ -1243,7 +1246,7 @@ const struct SpriteTemplate gUnknown_83E3264 = // Unused .callback = sub_80A4494, }; -const union AnimCmd gCuttingSliceAnimCmds[] = //gUnknown_83E327C +const union AnimCmd gCuttingSliceAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(16, 5), @@ -1252,12 +1255,12 @@ const union AnimCmd gCuttingSliceAnimCmds[] = //gUnknown_83E327C ANIMCMD_END, }; -const union AnimCmd *const gCuttingSliceAnimTable[] = //gUnknown_83E3290 +const union AnimCmd *const gCuttingSliceAnimTable[] = { gCuttingSliceAnimCmds, }; -const struct SpriteTemplate gCuttingSliceSpriteTemplate = //gUnknown_83E3294 +const struct SpriteTemplate gCuttingSliceSpriteTemplate = { .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, @@ -1268,7 +1271,7 @@ const struct SpriteTemplate gCuttingSliceSpriteTemplate = //gUnknown_83E3294 .callback = AnimCuttingSlice, }; -const struct SpriteTemplate gAirCutterSliceSpriteTemplate = //gUnknown_83E32AC +const struct SpriteTemplate gAirCutterSliceSpriteTemplate = { .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, @@ -1353,7 +1356,8 @@ const union AnimCmd *const gUnknown_83E3314[] = gUnknown_83E330C, }; -const struct SpriteTemplate gUnknown_83E333C = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E333C = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -1364,7 +1368,7 @@ const struct SpriteTemplate gUnknown_83E333C = // Unused .callback = sub_80A481C, }; -const struct SpriteTemplate gProtectWallSpriteTemplate = //gUnknown_83E3354 +const struct SpriteTemplate gProtectWallSpriteTemplate = { .tileTag = ANIM_TAG_PROTECT, .paletteTag = ANIM_TAG_PROTECT, @@ -1375,13 +1379,13 @@ const struct SpriteTemplate gProtectWallSpriteTemplate = //gUnknown_83E3354 .callback = AnimProtect, }; -const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = //gUnknown_83E336C +const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] =//gUnknown_83E337C +const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), @@ -1391,13 +1395,13 @@ const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] =//gUnknown_83E337C AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] =//gUnknown_83E33AC +const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] = { gMilkBottleAffineAnimCmds1, gMilkBottleAffineAnimCmds2, }; -const struct SpriteTemplate gMilkBottleSpriteTemplate =//gUnknown_83E33B4 +const struct SpriteTemplate gMilkBottleSpriteTemplate = { .tileTag = ANIM_TAG_MILK_BOTTLE, .paletteTag = ANIM_TAG_MILK_BOTTLE, @@ -1408,7 +1412,7 @@ const struct SpriteTemplate gMilkBottleSpriteTemplate =//gUnknown_83E33B4 .callback = AnimMilkBottle, }; -const union AnimCmd gGrantingStarsAnimCmds[] =//gUnknown_83E33CC +const union AnimCmd gGrantingStarsAnimCmds[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -1421,12 +1425,12 @@ const union AnimCmd gGrantingStarsAnimCmds[] =//gUnknown_83E33CC ANIMCMD_JUMP(0), }; -const union AnimCmd *const gGrantingStarsAnimTable[] =//gUnknown_83E33F0 +const union AnimCmd *const gGrantingStarsAnimTable[] = { gGrantingStarsAnimCmds, }; -const struct SpriteTemplate gGrantingStarsSpriteTemplate = //gUnknown_83E33F4 +const struct SpriteTemplate gGrantingStarsSpriteTemplate = { .tileTag = ANIM_TAG_SPARKLE_2, .paletteTag = ANIM_TAG_SPARKLE_2, @@ -1437,7 +1441,7 @@ const struct SpriteTemplate gGrantingStarsSpriteTemplate = //gUnknown_83E33F4 .callback = AnimGrantingStars, }; -const struct SpriteTemplate gSparklingStarsSpriteTemplate = //gUnknown_83E340C +const struct SpriteTemplate gSparklingStarsSpriteTemplate = { .tileTag = ANIM_TAG_SPARKLE_2, .paletteTag = ANIM_TAG_SPARKLE_2, @@ -1480,7 +1484,8 @@ const union AnimCmd *const gUnknown_83E346C[] = gUnknown_83E3448, }; -const struct SpriteTemplate gUnknown_83E3474 = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E3474 = { .tileTag = ANIM_TAG_BUBBLE_BURST, .paletteTag = ANIM_TAG_BUBBLE_BURST, @@ -1491,13 +1496,13 @@ const struct SpriteTemplate gUnknown_83E3474 = // Unused .callback = sub_80A4E40, }; -const union AnimCmd gSleepLetterZAnimCmds[] =//gUnknown_83E348C +const union AnimCmd gSleepLetterZAnimCmds[] = { ANIMCMD_FRAME(0, 40), ANIMCMD_END, }; -const union AnimCmd *const gSleepLetterZAnimTable[] =//gUnknown_83E3494 +const union AnimCmd *const gSleepLetterZAnimTable[] = { gSleepLetterZAnimCmds, }; @@ -1530,13 +1535,13 @@ const union AffineAnimCmd gSleepLetterZAffineAnimCmds2_2[] = AFFINEANIMCMD_LOOP(10), }; -const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] =//gUnknown_83E34F8 +const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] = { gSleepLetterZAffineAnimCmds1, gSleepLetterZAffineAnimCmds2, }; -const struct SpriteTemplate gSleepLetterZSpriteTemplate = //gUnknown_83E3500 +const struct SpriteTemplate gSleepLetterZSpriteTemplate = { .tileTag = ANIM_TAG_LETTER_Z, .paletteTag = ANIM_TAG_LETTER_Z, @@ -1547,7 +1552,7 @@ const struct SpriteTemplate gSleepLetterZSpriteTemplate = //gUnknown_83E3500 .callback = AnimSleepLetterZ, }; -const struct SpriteTemplate gLockOnTargetSpriteTemplate = //gUnknown_83E3518 +const struct SpriteTemplate gLockOnTargetSpriteTemplate = { .tileTag = ANIM_TAG_LOCK_ON, .paletteTag = ANIM_TAG_LOCK_ON, @@ -1558,7 +1563,7 @@ const struct SpriteTemplate gLockOnTargetSpriteTemplate = //gUnknown_83E3518 .callback = AnimLockOnTarget, }; -const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = //gUnknown_83E3530 +const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = { .tileTag = ANIM_TAG_LOCK_ON, .paletteTag = ANIM_TAG_LOCK_ON, @@ -1577,7 +1582,7 @@ const s8 gInclineMonCoordTable[][2] = { 32, -32}, }; -const struct SpriteTemplate gBowMonSpriteTemplate = //gUnknown_83E3550 +const struct SpriteTemplate gBowMonSpriteTemplate = { .tileTag = 0, .paletteTag = 0, @@ -1588,7 +1593,8 @@ const struct SpriteTemplate gBowMonSpriteTemplate = //gUnknown_83E3550 .callback = AnimBowMon, }; -const struct SpriteTemplate gUnknown_83E3568 = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E3568 = { .tileTag = 0, .paletteTag = 0, @@ -1599,7 +1605,7 @@ const struct SpriteTemplate gUnknown_83E3568 = // Unused .callback = sub_80A5590, }; -const union AnimCmd gSlashSliceAnimCmds1[] = //gUnknown_83E3580 +const union AnimCmd gSlashSliceAnimCmds1[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1620,7 +1626,7 @@ const union AnimCmd *const gSlashSliceAnimTable[] = gSlashSliceAnimCmds2, }; -const struct SpriteTemplate gSlashSliceSpriteTemplate = //gUnknown_83E35A4 +const struct SpriteTemplate gSlashSliceSpriteTemplate = { .tileTag = ANIM_TAG_SLASH, .paletteTag = ANIM_TAG_SLASH, @@ -1631,7 +1637,7 @@ const struct SpriteTemplate gSlashSliceSpriteTemplate = //gUnknown_83E35A4 .callback = AnimSlashSlice, }; -const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = //gUnknown_83E35BC +const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = { .tileTag = ANIM_TAG_SLASH_2, .paletteTag = ANIM_TAG_SLASH_2, @@ -1642,7 +1648,7 @@ const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = //gUnknown_83E35BC .callback = AnimFalseSwipeSlice, }; -const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = //gUnknown_83E35D4 +const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = { .tileTag = ANIM_TAG_SLASH_2, .paletteTag = ANIM_TAG_SLASH_2, @@ -1667,7 +1673,7 @@ const union AnimCmd *const gEndureEnergyAnimTable[] = gEndureEnergyAnimCmds, }; -const struct SpriteTemplate gEndureEnergySpriteTemplate = //gUnknown_83E3604 +const struct SpriteTemplate gEndureEnergySpriteTemplate = { .tileTag = ANIM_TAG_FOCUS_ENERGY, .paletteTag = ANIM_TAG_FOCUS_ENERGY, @@ -1702,7 +1708,7 @@ const union AnimCmd *const gSharpenSphereAnimTable[] = gSharpenSphereAnimCmds, }; -const struct SpriteTemplate gSharpenSphereSpriteTemplate = //gUnknown_83E365C +const struct SpriteTemplate gSharpenSphereSpriteTemplate = { .tileTag = ANIM_TAG_SPHERE_TO_CUBE, .paletteTag = ANIM_TAG_SPHERE_TO_CUBE, @@ -1713,7 +1719,7 @@ const struct SpriteTemplate gSharpenSphereSpriteTemplate = //gUnknown_83E365C .callback = AnimSharpenSphere, }; -const struct SpriteTemplate gOctazookaBallSpriteTemplate = //gUnknown_83E3674 +const struct SpriteTemplate gOctazookaBallSpriteTemplate = { .tileTag = ANIM_TAG_BLACK_BALL, .paletteTag = ANIM_TAG_BLACK_BALL, @@ -1739,7 +1745,7 @@ const union AnimCmd *const gOctazookaAnimTable[] = gOctazookaAnimCmds, }; -const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = //gUnknown_83E36A8 +const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = { .tileTag = ANIM_TAG_GRAY_SMOKE, .paletteTag = ANIM_TAG_GRAY_SMOKE, @@ -1775,7 +1781,7 @@ const union AffineAnimCmd *const gConversionAffineAnimTable[] = gConversionAffineAnimCmds, }; -const struct SpriteTemplate gConversionSpriteTemplate = //gUnknown_83E36EC +const struct SpriteTemplate gConversionSpriteTemplate = { .tileTag = ANIM_TAG_CONVERSION, .paletteTag = ANIM_TAG_CONVERSION, @@ -1800,7 +1806,7 @@ const union AnimCmd *const gConversion2AnimTable[] = gConversion2AnimCmds, }; -const struct SpriteTemplate gConversion2SpriteTemplate = //gUnknown_83E371C +const struct SpriteTemplate gConversion2SpriteTemplate = { .tileTag = ANIM_TAG_CONVERSION, .paletteTag = ANIM_TAG_CONVERSION, @@ -1811,7 +1817,7 @@ const struct SpriteTemplate gConversion2SpriteTemplate = //gUnknown_83E371C .callback = AnimConversion2, }; -const struct SpriteTemplate gMoonSpriteTemplate = //gUnknown_83E3734 +const struct SpriteTemplate gMoonSpriteTemplate = { .tileTag = ANIM_TAG_MOON, .paletteTag = ANIM_TAG_MOON, @@ -1836,7 +1842,7 @@ const union AnimCmd *const gMoonlightSparkleAnimTable[] = gMoonlightSparkleAnimCmds, }; -const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = //gUnknown_83E3764 +const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = { .tileTag = ANIM_TAG_GREEN_SPARKLE, .paletteTag = ANIM_TAG_GREEN_SPARKLE, @@ -1865,7 +1871,7 @@ const union AnimCmd *const gHealingBlueStarAnimTable[] = gHealingBlueStarAnimCmds, }; -const struct SpriteTemplate gHealingBlueStarSpriteTemplate = //gUnknown_83E37A4 +const struct SpriteTemplate gHealingBlueStarSpriteTemplate = { .tileTag = ANIM_TAG_BLUE_STAR, .paletteTag = ANIM_TAG_BLUE_STAR, @@ -1876,7 +1882,7 @@ const struct SpriteTemplate gHealingBlueStarSpriteTemplate = //gUnknown_83E37A4 .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gHornHitSpriteTemplate = //gUnknown_83E37BC +const struct SpriteTemplate gHornHitSpriteTemplate = { .tileTag = ANIM_TAG_HORN_HIT, .paletteTag = ANIM_TAG_HORN_HIT, @@ -1901,7 +1907,7 @@ const union AnimCmd *const gSuperFangAnimTable[] = gSuperFangAnimCmds, }; -const struct SpriteTemplate gSuperFangSpriteTemplate = //gUnknown_83E37EC +const struct SpriteTemplate gSuperFangSpriteTemplate = { .tileTag = ANIM_TAG_FANG_ATTACK, .paletteTag = ANIM_TAG_FANG_ATTACK, @@ -1960,7 +1966,7 @@ const union AnimCmd gWavyMusicNotesAnimCmds8[] = ANIMCMD_END, }; -const union AnimCmd *const gMusicNotesAnimTable[] = //gUnknown_83E3844 +const union AnimCmd *const gMusicNotesAnimTable[] = { gWavyMusicNotesAnimCmds1, gWavyMusicNotesAnimCmds2, @@ -1972,19 +1978,19 @@ const union AnimCmd *const gMusicNotesAnimTable[] = //gUnknown_83E3844 gWavyMusicNotesAnimCmds8, }; -const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = //gUnknown_83E3864 +const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0xC, 0xC, 0, 16), AFFINEANIMCMD_FRAME(0xFFF4, 0xFFF4, 0, 16), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = //gUnknown_83E387C +const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = { gWavyMusicNotesAffineAnimCmds, }; -const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = //gUnknown_83E3880 +const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -1995,7 +2001,7 @@ const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = //gUnknown_83E3880 .callback = AnimWavyMusicNotes, }; -const u16 gParticlesColorBlendTable[][6] = //gUnknown_83E3898 +const u16 gParticlesColorBlendTable[][6] = { {ANIM_TAG_MUSIC_NOTES, RGB(31, 31, 31), RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, {ANIM_TAG_BENT_SPOON, RGB(31, 31, 31), RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, @@ -2003,7 +2009,7 @@ const u16 gParticlesColorBlendTable[][6] = //gUnknown_83E3898 {ANIM_TAG_LARGE_FRESH_EGG, RGB(31, 31, 31), RGB(26, 28, 31), RGB(21, 26, 31), RGB(16, 24, 31), RGB(12, 22, 31)}, }; -const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = //gUnknown_83E38C8 +const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -2014,7 +2020,7 @@ const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = //gUnknown_83E .callback = AnimFlyingMusicNotes, }; -const struct SpriteTemplate gBellyDrumHandSpriteTemplate = // gUnknown_83E38E0 +const struct SpriteTemplate gBellyDrumHandSpriteTemplate = { .tileTag = ANIM_TAG_PURPLE_HAND_OUTLINE, .paletteTag = ANIM_TAG_PURPLE_HAND_OUTLINE, @@ -2037,7 +2043,7 @@ const union AffineAnimCmd *const gSlowFlyingMusicNotesAffineAnimTable[] = gSlowFlyingMusicNotesAffineAnimCmds, }; -const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = //gUnknown_83E3914 +const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -2092,7 +2098,7 @@ const union AnimCmd *const gMetronomeThroughtBubbleAnimTable[] = gMetronomeThroughtBubbleAnimCmds4, }; -const struct SpriteTemplate gThoughtBubbleSpriteTemplate = //gUnknown_83E398C +const struct SpriteTemplate gThoughtBubbleSpriteTemplate = { .tileTag = ANIM_TAG_THOUGHT_BUBBLE, .paletteTag = ANIM_TAG_THOUGHT_BUBBLE, @@ -2138,7 +2144,7 @@ const union AffineAnimCmd *const gMetronomeFingerAffineAnimTable[] = gMetronomeFingerAffineAnimCmds2, }; -const struct SpriteTemplate gMetronomeFingerSpriteTemplate = //gUnknown_83E3A34 +const struct SpriteTemplate gMetronomeFingerSpriteTemplate = { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -2149,7 +2155,7 @@ const struct SpriteTemplate gMetronomeFingerSpriteTemplate = //gUnknown_83E3A34 .callback = AnimMetronomeFinger, }; -const struct SpriteTemplate gFollowMeFingerSpriteTemplate = //gUnknown_83E3A4C +const struct SpriteTemplate gFollowMeFingerSpriteTemplate = { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -2204,7 +2210,7 @@ const union AnimCmd *const gTauntFingerAnimTable[] = gTauntFingerAnimCmds4, }; -const struct SpriteTemplate gTauntFingerSpriteTemplate = //gUnknown_83E3AC4 +const struct SpriteTemplate gTauntFingerSpriteTemplate = { .tileTag = ANIM_TAG_FINGER_2, .paletteTag = ANIM_TAG_FINGER_2, @@ -2575,7 +2581,7 @@ void AnimPetalDanceSmallFlower(struct Sprite* sprite) sprite->data[1] = sprite->pos1.x; sprite->data[2] = sprite->pos1.x; sprite->data[3] = sprite->pos1.y; - sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; InitAnimLinearTranslation(sprite); sprite->data[5] = 0x40; sprite->callback = AnimPetalDanceSmallFlowerStep; @@ -2735,7 +2741,7 @@ static void AnimTranslateLinearSingleSineWaveStep(struct Sprite* sprite) // arg 4: speedup frame (particles move faster at the end of the animation) void AnimMoveTwisterParticle(struct Sprite* sprite) { - if (!IsContest() && IsDoubleBattle() == TRUE) + if (!IsContest() && IsDoubleBattle() == TRUE) SetAverageBattlerPositions(gBattleAnimTarget, 1, &sprite->pos1.x, &sprite->pos1.y); sprite->pos1.y += 32; @@ -2806,6 +2812,7 @@ static void AnimConstrictBindingStep1(struct Sprite* sprite) static void AnimConstrictBindingStep2(struct Sprite* sprite) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (!sprite->data[2]) sprite->data[0] += 11; else @@ -2830,6 +2837,7 @@ static void AnimConstrictBindingStep2(struct Sprite* sprite) void sub_80A2F0C(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (gSprites[spriteId].invisible) { DestroyAnimVisualTask(taskId); @@ -2847,6 +2855,7 @@ void sub_80A2F0C(u8 taskId) static void AnimTask_DuplicateAndShrinkToPosStep1(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + gTasks[taskId].data[10] += gTasks[taskId].data[0]; gSprites[spriteId].pos2.x = gTasks[taskId].data[10] >> 8; if (GetBattlerSide(gBattleAnimTarget) != B_SIDE_PLAYER) @@ -2871,7 +2880,7 @@ static void AnimTask_DuplicateAndShrinkToPosStep2(u8 taskId) u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); ResetSpriteRotScale(spriteId); gSprites[spriteId].pos2.y = gSprites[spriteId].pos2.x = 0; - gTasks[taskId].data[0]++; + gTasks[taskId].data[0]++; return; } } @@ -2948,7 +2957,6 @@ void AnimIngrainRoot(struct Sprite* sprite) // arg 3: sprite subpriority offset // arg 4: sprite anum num // arg 5: duration -//sub_80A31EC void AnimFrenzyPlantRoot(struct Sprite *sprite) { s16 attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); @@ -2991,8 +2999,8 @@ void AnimIngrainOrb(struct Sprite* sprite) { if (!sprite->data[0]) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[0]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y) + gBattleAnimArgs[1]; sprite->data[1] = gBattleAnimArgs[2]; sprite->data[2] = gBattleAnimArgs[3]; sprite->data[3] = gBattleAnimArgs[4]; @@ -3078,6 +3086,7 @@ void AnimPresent(struct Sprite* sprite) { s16 targetX; s16 targetY; + InitSpritePosToAnimAttacker(sprite, FALSE); targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); @@ -3103,6 +3112,7 @@ void AnimPresent(struct Sprite* sprite) static void sub_80A3590(struct Sprite* sprite) { int zero; + sprite->data[0] += ((sprite->data[3] * 128) / sprite->data[4]); zero = 0; if (sprite->data[0] > 0x7F) @@ -3123,6 +3133,7 @@ static void sub_80A3590(struct Sprite* sprite) void AnimKnockOffItem(struct Sprite* sprite) { s16 targetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) { sprite->data[6] = 0; @@ -3169,6 +3180,7 @@ void AnimItemSteal(struct Sprite* sprite) { s16 attackerX; s16 attackerY; + InitSpritePosToAnimTarget(sprite, FALSE); attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); attackerY = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); @@ -3194,6 +3206,7 @@ void AnimItemSteal(struct Sprite* sprite) static void AnimItemStealStep3(struct Sprite* sprite) { int zero; + sprite->data[0] += ((sprite->data[3] * 128) / sprite->data[4]); zero = 0; if (sprite->data[0] > 127) @@ -3329,8 +3342,8 @@ void AnimTask_LeafBlade(u8 taskId) struct Task *task = &gTasks[taskId]; task->data[4] = GetBattlerSpriteSubpriority(gBattleAnimTarget) - 1; - task->data[6] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); - task->data[7] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + task->data[6] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + task->data[7] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); task->data[10] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_WIDTH); task->data[11] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT); task->data[5] = (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) ? 1 : -1; @@ -3355,6 +3368,7 @@ static void AnimTask_LeafBladeStep(u8 taskId) struct Task* task = &gTasks[taskId]; struct Sprite* sprite = &gSprites[task->data[2]]; int a = task->data[0]; + switch (a) { case 4: @@ -3538,6 +3552,7 @@ static void AnimTask_LeafBladeStep(u8 taskId) static s16 LeafBladeGetPosFactor(struct Sprite* sprite) { s16 var = 8; + if (sprite->data[4] < sprite->pos1.y) var = -var; @@ -3589,6 +3604,7 @@ static void AnimTask_LeafBladeStep2_Callback(struct Sprite* sprite) void AnimFlyingParticle(struct Sprite* sprite) { u8 battler; + if (!gBattleAnimArgs[6]) battler = gBattleAnimAttacker; else @@ -3621,11 +3637,11 @@ void AnimFlyingParticle(struct Sprite* sprite) sprite->oam.priority = GetBattlerSpriteBGPriority(battler) + 1; break; case 2: - sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[0]; sprite->oam.priority = GetBattlerSpriteBGPriority(battler); break; case 3: - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[0]; GetAnimBattlerSpriteId(ANIM_TARGET); sprite->oam.priority = GetBattlerSpriteBGPriority(battler) + 1; break; @@ -3637,6 +3653,7 @@ void AnimFlyingParticle(struct Sprite* sprite) static void AnimFlyingParticleStep(struct Sprite* sprite) { int a = sprite->data[7]; + sprite->data[7]++; sprite->pos2.y = (sprite->data[1] * gSineTable[sprite->data[0]]) >> 8; sprite->pos2.x = sprite->data[2] * a; @@ -3658,6 +3675,7 @@ static void AnimFlyingParticleStep(struct Sprite* sprite) void sub_80A41C4(u8 taskId) { struct Task* task = &gTasks[taskId]; + switch (task->data[0]) { case 0: @@ -3701,13 +3719,13 @@ void AnimNeedleArmSpike(struct Sprite* sprite) { if (gBattleAnimArgs[0] == 0) { - a = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - b = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + a = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + b = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); } else { - a = GetBattlerSpriteCoord(gBattleAnimTarget, 2); - b = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + a = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + b = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); } sprite->data[0] = gBattleAnimArgs[4]; @@ -3810,8 +3828,8 @@ void sub_80A4494(struct Sprite* sprite) // arg 2: slice direction; 0 = right-to-left, 1 = left-to-right void AnimCuttingSlice(struct Sprite* sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) sprite->pos1.y += 8; @@ -3838,15 +3856,16 @@ void AnimAirCutterSlice(struct Sprite* sprite) { u8 a; u8 b; + switch (gBattleAnimArgs[3]) { case 1: - a = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 0); - b = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 1); + a = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), BATTLER_COORD_X); + b = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), BATTLER_COORD_Y); break; case 2: - a = GetBattlerSpriteCoord(gBattleAnimTarget, 0); - b = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + a = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + b = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget))) { a = (GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimTarget), 0) + a) / 2; @@ -3855,8 +3874,8 @@ void AnimAirCutterSlice(struct Sprite* sprite) break; case 0: default: - a = GetBattlerSpriteCoord(gBattleAnimTarget, 0); - b = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + a = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + b = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); break; } @@ -3976,8 +3995,8 @@ void AnimProtect(struct Sprite* sprite) if (IsContest()) gBattleAnimArgs[1] += 8; - sprite->pos1.x = GetBattlerSpriteCoord2(gBattleAnimAttacker, 0) + gBattleAnimArgs[0]; - sprite->pos1.y = GetBattlerSpriteCoord2(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + sprite->pos1.x = GetBattlerSpriteCoord2(gBattleAnimAttacker, BATTLER_COORD_X) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord2(gBattleAnimAttacker, BATTLER_COORD_Y) + gBattleAnimArgs[1]; if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER || IsContest()) sprite->oam.priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker) + 1; else @@ -3995,6 +4014,7 @@ static void AnimProtectStep(struct Sprite *sprite) { int a; int i; + sprite->data[5] += 96; sprite->pos2.x = -(sprite->data[5] >> 8); if (++sprite->data[1] > 1) @@ -4036,8 +4056,8 @@ static void AnimProtectStep(struct Sprite *sprite) void AnimMilkBottle(struct Sprite* sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + 0xFFE8; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + 0xFFE8; sprite->data[0] = 0; sprite->data[1] = 0; sprite->data[2] = 0; @@ -4161,6 +4181,7 @@ void AnimGrantingStars(struct Sprite* sprite) void AnimSparkingStars(struct Sprite* sprite) { u8 battler; + if (!gBattleAnimArgs[2]) battler = gBattleAnimAttacker; else @@ -4176,13 +4197,13 @@ void AnimSparkingStars(struct Sprite* sprite) { if (!gBattleAnimArgs[6]) { - sprite->pos1.x = GetBattlerSpriteCoord(battler, 0); - sprite->pos1.y = GetBattlerSpriteCoord(battler, 1) + gBattleAnimArgs[1]; + sprite->pos1.x = GetBattlerSpriteCoord(battler, BATTLER_COORD_X); + sprite->pos1.y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y) + gBattleAnimArgs[1]; } else { - sprite->pos1.x = GetBattlerSpriteCoord(battler, 2); - sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[1]; + sprite->pos1.x = GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[1]; } SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); @@ -4310,6 +4331,7 @@ static void AnimLockOnTargetStep3(struct Sprite* sprite) { s16 a; s16 b; + if (sprite->oam.affineParam == 0) { sprite->data[0] = 3; @@ -4345,8 +4367,8 @@ static void AnimLockOnTargetStep3(struct Sprite* sprite) sprite->pos2.y = 0; sprite->pos2.x = 0; sprite->data[0] = 6; - sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + a; - sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + b; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + a; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + b; sprite->callback = StartAnimLinearTranslation; StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep5); } @@ -4621,6 +4643,7 @@ void AnimTask_SkullBashPosition(u8 taskId) static void AnimTask_SkullBashPositionSet(u8 taskId) { struct Task *task = &gTasks[taskId]; + switch (task->data[2]) { case 0: @@ -4712,6 +4735,7 @@ static void AnimTask_SkullBashPositionSet(u8 taskId) static void AnimTask_SkullBashPositionReset(u8 taskId) { struct Task* task = &gTasks[taskId]; + if (task->data[3]) { task->data[4] -= task->data[5]; @@ -4730,13 +4754,13 @@ void AnimSlashSlice(struct Sprite* sprite) { if (gBattleAnimArgs[0] == 0) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[1]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; } else { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[1]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[2]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; } sprite->data[0] = 0; @@ -4747,16 +4771,16 @@ void AnimSlashSlice(struct Sprite* sprite) void AnimFalseSwipeSlice(struct Sprite* sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 0xFFD0; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + 0xFFD0; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); StoreSpriteCallbackInData6(sprite, AnimFalseSwipeSliceStep1); sprite->callback = RunStoredCallbackWhenAnimEnds; } void AnimFalseSwipePositionedSlice(struct Sprite* sprite) { - sprite->pos1.x = sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 0xFFD0 + gBattleAnimArgs[0]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->pos1.x = sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + 0xFFD0 + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); StartSpriteAnim(sprite, 1); sprite->data[0] = 0; sprite->data[1] = 0; @@ -4797,13 +4821,13 @@ void AnimEndureEnergy(struct Sprite* sprite) { if (gBattleAnimArgs[0] == 0) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[1]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[2]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y) + gBattleAnimArgs[2]; } else { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) + gBattleAnimArgs[1]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1) + gBattleAnimArgs[2]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + gBattleAnimArgs[2]; } sprite->data[0] = 0; @@ -4826,8 +4850,8 @@ static void AnimEndureEnergyStep(struct Sprite* sprite) void AnimSharpenSphere(struct Sprite* sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) - 12; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) - 12; sprite->data[0] = 0; sprite->data[1] = 2; sprite->data[2] = 0; @@ -4865,8 +4889,8 @@ void AnimConversion(struct Sprite* sprite) { if (sprite->data[0] == 0) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[0]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[1]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y) + gBattleAnimArgs[1]; if (IsContest()) sprite->pos1.y += 10; @@ -4919,8 +4943,8 @@ static void AnimConversion2Step(struct Sprite* sprite) { sprite->animPaused = 0; sprite->data[0] = 30; - sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); sprite->callback = StartAnimLinearTranslation; StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); } @@ -4941,6 +4965,7 @@ void AnimTask_Conversion2AlphaBlend(u8 taskId) void sub_80A5E34(u8 taskId) { u8 i; + for (i = 0; i < gBattlersCount; i++) { if (gBattleAnimArgs[0] == 1 && GetBattlerSide(i) == B_SIDE_PLAYER) @@ -4956,6 +4981,7 @@ void sub_80A5E34(u8 taskId) void sub_80A5EA8(u8 taskId) { u8 i; + for (i = 0; i < gBattlersCount; i++) SetHealthboxSpriteVisible(gHealthboxSpriteIds[i]); @@ -4989,7 +5015,7 @@ static void AnimMoonStep(struct Sprite* sprite) void AnimMoonlightSparkle(struct Sprite* sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[0]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + gBattleAnimArgs[0]; sprite->pos1.y = gBattleAnimArgs[1]; sprite->data[0] = 0; sprite->data[1] = 0; @@ -5048,6 +5074,7 @@ void AnimTask_FadeScreenBlue(u8 taskId) void AnimTask_FadeScreenBlueStep(u8 taskId) { struct Task* task = &gTasks[taskId]; + switch (task->data[0]) { case 0: @@ -5133,8 +5160,8 @@ void AnimHornHit(struct Sprite* sprite) sprite->data[0] = 0; sprite->data[1] = gBattleAnimArgs[2]; - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[0]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[1]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + gBattleAnimArgs[0]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[1]; sprite->data[6] = sprite->pos1.x; sprite->data[7] = sprite->pos1.y; if (IsContest()) @@ -5193,6 +5220,7 @@ void AnimTask_DoubleTeam(u8 taskId) u16 r3; u16 r4; struct Task* task = &gTasks[taskId]; + task->data[0] = GetAnimBattlerSpriteId(ANIM_ATTACKER); task->data[1] = AllocSpritePalette(ANIM_TAG_BENT_SPOON); r3 = (task->data[1] * 16) + 0x100; @@ -5224,6 +5252,7 @@ void AnimTask_DoubleTeam(u8 taskId) static void AnimTask_DoubleTeamStep(u8 taskId) { struct Task* task = &gTasks[taskId]; + if (!task->data[3]) { if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1) @@ -5295,6 +5324,7 @@ void AnimTask_MusicNotesRainbowBlend(u8 taskId) void AnimTask_MusicNotesClearRainbowBlend(u8 taskId) { u16 i; + for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable); i++) FreeSpritePaletteByTag(gParticlesColorBlendTable[i][0]); @@ -5306,6 +5336,7 @@ void AnimWavyMusicNotes(struct Sprite* sprite) u8 index; u8 a; u8 b; + SetSpriteCoordsToAnimAttackerCoords(sprite); StartSpriteAnim(sprite, gBattleAnimArgs[0]); if ((index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[gBattleAnimArgs[1]][0])) != 0xFF) @@ -5321,8 +5352,8 @@ void AnimWavyMusicNotes(struct Sprite* sprite) } else { - a = GetBattlerSpriteCoord(gBattleAnimTarget, 2); - b = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + a = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + b = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); } sprite->data[4] = sprite->pos1.x << 4; @@ -5335,6 +5366,7 @@ static void AnimWavyMusicNotesGetNextPos(s16 a, s16 b, s16* c, s16* d, s8 e) { int f; int g; + if (a < 0) e = -e; @@ -5385,8 +5417,8 @@ void AnimFlyingMusicNotes(struct Sprite* sprite) if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) gBattleAnimArgs[1] *= -1; - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + gBattleAnimArgs[1]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + gBattleAnimArgs[2]; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; StartSpriteAnim(sprite, gBattleAnimArgs[0]); sprite->data[2] = 0; sprite->data[3] = 0; @@ -5419,6 +5451,7 @@ static void AnimFlyingMusicNotesStep(struct Sprite* sprite) void AnimBellyDrumHand(struct Sprite* sprite) { s16 a; + if (gBattleAnimArgs[0] == 1) { sprite->oam.matrixNum = ST_OAM_HFLIP; @@ -5429,8 +5462,8 @@ void AnimBellyDrumHand(struct Sprite* sprite) a = -16; } - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2) + a; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3) + 8; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + a; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET) + 8; sprite->data[0] = 8; sprite->callback = WaitAnimForDuration; StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); @@ -5440,6 +5473,7 @@ void AnimSlowFlyingMusicNotes(struct Sprite* sprite) { s16 xDiff; u8 index; + SetSpriteCoordsToAnimAttackerCoords(sprite); sprite->pos1.y += 8; StartSpriteAnim(sprite, gBattleAnimArgs[1]); @@ -5463,6 +5497,7 @@ static void AnimSlowFlyingMusicNotesStep(struct Sprite* sprite) if (AnimTranslateLinear(sprite) == 0) { s16 xDiff; + xDiff = Sin(sprite->data[5], 8); if (sprite->pos2.x < 0) xDiff = -xDiff; @@ -5484,13 +5519,14 @@ void SetSpriteNextToMonHead(u8 battler, struct Sprite* sprite) else sprite->pos1.x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_LEFT) - 8; - sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) - (s16)GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_HEIGHT) / 4; + sprite->pos1.y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET) - (s16)GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_HEIGHT) / 4; } void AnimThoughtBubble(struct Sprite* sprite) { u8 a; u8 battler; + if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else @@ -5518,6 +5554,7 @@ static void AnimThoughtBubbleStep(struct Sprite* sprite) void AnimMetronomeFinger(struct Sprite* sprite) { u8 battler; + if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else @@ -5542,12 +5579,13 @@ static void AnimMetronomeFingerStep(struct Sprite* sprite) void AnimFollowMeFinger(struct Sprite* sprite) { u8 battler; + if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else battler = gBattleAnimTarget; - sprite->pos1.x = GetBattlerSpriteCoord(battler, 0); + sprite->pos1.x = GetBattlerSpriteCoord(battler, BATTLER_COORD_X); sprite->pos1.y = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_TOP); if (sprite->pos1.y <= 9) sprite->pos1.y = 10; @@ -5600,6 +5638,7 @@ static void AnimFollowMeFingerStep2(struct Sprite* sprite) void AnimTauntFinger(struct Sprite* sprite) { u8 battler; + if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 1fe43b78c..b58a88799 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -105,7 +105,10 @@ static void AnimPerishSongMusicNote_Step1(struct Sprite *); static void AnimPerishSongMusicNote_Step2(struct Sprite *); // Data -const struct SpriteTemplate gUnknown_83E3ADC = // Unused +extern const union AffineAnimCmd *const gUnknown_83E7910[]; +extern const union AnimCmd *const gMusicNotesAnimTable[]; +// Unused +const struct SpriteTemplate gUnknown_83E3ADC = { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -127,7 +130,8 @@ const union AnimCmd *const gUnknown_83E3AFC[] = gUnknown_83E3AF4, }; -const struct SpriteTemplate gUnknown_83E3B00 = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E3B00 = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -138,7 +142,8 @@ const struct SpriteTemplate gUnknown_83E3B00 = // Unused .callback = sub_80A6E98, }; -const struct SpriteTemplate gUnknown_83E3B18 = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E3B18 = { .tileTag = 0, .paletteTag = 0, @@ -149,8 +154,8 @@ const struct SpriteTemplate gUnknown_83E3B18 = // Unused .callback = sub_80A6F8C, }; -extern const union AffineAnimCmd *const gUnknown_83E7910[]; -const struct SpriteTemplate gUnknown_83E3B30 = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E3B30 = { .tileTag = ANIM_TAG_CLAMP, .paletteTag = ANIM_TAG_CLAMP, @@ -187,7 +192,8 @@ const union AffineAnimCmd *const gUnknown_83E3B78[] = gUnknown_83E3B60, }; -const struct SpriteTemplate gUnknown_83E3B7C = // Unused +// Unused +const struct SpriteTemplate gUnknown_83E3B7C = { .tileTag = ANIM_TAG_EXPLOSION_6, .paletteTag = ANIM_TAG_EXPLOSION_6, @@ -216,7 +222,7 @@ const union AnimCmd *const gKinesisZapEnergyAnimTable[] = gKinesisZapEnergyAnimCmds, }; -const struct SpriteTemplate gKinesisZapEnergySpriteTemplate = //gUnknown_83E3BBC +const struct SpriteTemplate gKinesisZapEnergySpriteTemplate = { .tileTag = ANIM_TAG_ALERT, .paletteTag = ANIM_TAG_ALERT, @@ -240,7 +246,7 @@ const union AffineAnimCmd *const gSwordsDanceBladeAffineAnimTable[] = gSwordsDanceBladeAffineAnimCmds, }; -const struct SpriteTemplate gSwordsDanceBladeSpriteTemplate = //gUnknown_83E3BF8 +const struct SpriteTemplate gSwordsDanceBladeSpriteTemplate = { .tileTag = ANIM_TAG_SWORD, .paletteTag = ANIM_TAG_SWORD, @@ -251,7 +257,7 @@ const struct SpriteTemplate gSwordsDanceBladeSpriteTemplate = //gUnknown_83E3BF8 .callback = Anim_SwordsDanceBlade, }; -const struct SpriteTemplate gSonicBoomSpriteTemplate = //gUnknown_83E3C10 +const struct SpriteTemplate gSonicBoomSpriteTemplate = { .tileTag = ANIM_TAG_AIR_WAVE, .paletteTag = ANIM_TAG_AIR_WAVE, @@ -262,7 +268,7 @@ const struct SpriteTemplate gSonicBoomSpriteTemplate = //gUnknown_83E3C10 .callback = AnimSonicBoomProjectile, }; -const struct SpriteTemplate gAirWaveProjectileSpriteTemplate = //gUnknown_83E3C28 +const struct SpriteTemplate gAirWaveProjectileSpriteTemplate = { .tileTag = ANIM_TAG_AIR_WAVE, .paletteTag = ANIM_TAG_AIR_WAVE, @@ -292,17 +298,17 @@ const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = //gUnknown_83E3C98 +const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = { gGrowingRingAffineAnimCmds, }; -const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = //83E3C9C +const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = { gWaterPulseRingAffineAnimCmds, }; -const struct SpriteTemplate gSupersonicWaveSpriteTemplate = //gUnknown_83E3CA0 +const struct SpriteTemplate gSupersonicWaveSpriteTemplate = { .tileTag = ANIM_TAG_GOLD_RING, .paletteTag = ANIM_TAG_GOLD_RING, @@ -313,7 +319,7 @@ const struct SpriteTemplate gSupersonicWaveSpriteTemplate = //gUnknown_83E3CA0 .callback = TranslateAnimSpriteToTargetMonLocation, }; -const struct SpriteTemplate gScreechWaveSpriteTemplate = //gUnknown_83E3CB8 +const struct SpriteTemplate gScreechWaveSpriteTemplate = { .tileTag = ANIM_TAG_PURPLE_RING, .paletteTag = ANIM_TAG_PURPLE_RING, @@ -324,7 +330,7 @@ const struct SpriteTemplate gScreechWaveSpriteTemplate = //gUnknown_83E3CB8 .callback = TranslateAnimSpriteToTargetMonLocation, }; -const struct SpriteTemplate gMetalSoundSpriteTemplate = //gUnknown_83E3CD0 +const struct SpriteTemplate gMetalSoundSpriteTemplate = { .tileTag = ANIM_TAG_METAL_SOUND_WAVES, .paletteTag = ANIM_TAG_METAL_SOUND_WAVES, @@ -335,7 +341,7 @@ const struct SpriteTemplate gMetalSoundSpriteTemplate = //gUnknown_83E3CD0 .callback = TranslateAnimSpriteToTargetMonLocation, }; -const struct SpriteTemplate gWaterPulseRingSpriteTemplate = //gUnknown_83E3CE8 +const struct SpriteTemplate gWaterPulseRingSpriteTemplate = { .tileTag = ANIM_TAG_BLUE_RING_2, .paletteTag = ANIM_TAG_BLUE_RING_2, @@ -343,10 +349,10 @@ const struct SpriteTemplate gWaterPulseRingSpriteTemplate = //gUnknown_83E3CE8 .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gWaterPulseRingAffineAnimTable, - .callback = AnimWaterPulseRing, //water.c + .callback = AnimWaterPulseRing, }; -const struct SpriteTemplate gEggThrowSpriteTemplate = //gUnknown_83E3D00 +const struct SpriteTemplate gEggThrowSpriteTemplate = { .tileTag = ANIM_TAG_LARGE_FRESH_EGG, .paletteTag = ANIM_TAG_LARGE_FRESH_EGG, @@ -390,7 +396,7 @@ const union AffineAnimCmd *const gFallingCoinAffineAnimTable[] = gFallingCoinAffineAnimCmds, }; -const struct SpriteTemplate gCoinThrowSpriteTemplate = //gUnknown_83E3D50 +const struct SpriteTemplate gCoinThrowSpriteTemplate = { .tileTag = ANIM_TAG_COIN, .paletteTag = ANIM_TAG_COIN, @@ -401,7 +407,7 @@ const struct SpriteTemplate gCoinThrowSpriteTemplate = //gUnknown_83E3D50 .callback = AnimCoinThrow, }; -const struct SpriteTemplate gFallingCoinSpriteTemplate = //gUnknown_83E3D68 +const struct SpriteTemplate gFallingCoinSpriteTemplate = { .tileTag = ANIM_TAG_COIN, .paletteTag = ANIM_TAG_COIN, @@ -423,7 +429,7 @@ const union AffineAnimCmd *const gBulletSeedAffineAnimTable[] = gBulletSeedAffineAnimCmds, }; -const struct SpriteTemplate gBulletSeedSpriteTemplate = //gUnknown_83E3D94 +const struct SpriteTemplate gBulletSeedSpriteTemplate = { .tileTag = ANIM_TAG_SEED, .paletteTag = ANIM_TAG_SEED, @@ -446,7 +452,7 @@ const union AffineAnimCmd *const gRazorWindTornadoAffineAnimTable[] = gRazorWindTornadoAffineAnimCmds, }; -const struct SpriteTemplate gRazorWindTornadoSpriteTemplate = //gUnknown_83E3DC8 +const struct SpriteTemplate gRazorWindTornadoSpriteTemplate = { .tileTag = ANIM_TAG_GUST, .paletteTag = ANIM_TAG_GUST, @@ -479,7 +485,7 @@ const union AnimCmd *const gViceGripAnimTable[] = gViceGripAnimCmds2, }; -const struct SpriteTemplate gViceGripSpriteTemplate = //gUnknown_83E3E08 +const struct SpriteTemplate gViceGripSpriteTemplate = { .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, @@ -512,7 +518,7 @@ const union AnimCmd *const gGuillotineAnimTable[] = gGuillotineAnimCmds2, }; -const struct SpriteTemplate gGuillotineSpriteTemplate = //gUnknown_83E3E48 +const struct SpriteTemplate gGuillotineSpriteTemplate = { .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, @@ -563,7 +569,7 @@ const union AnimCmd *const gBreathPuffAnimTable[] = gBreathPuffAnimCmds2, }; -const struct SpriteTemplate gBreathPuffSpriteTemplate = //gUnknown_83E3ED0 +const struct SpriteTemplate gBreathPuffSpriteTemplate = { .tileTag = ANIM_TAG_BREATH, .paletteTag = ANIM_TAG_BREATH, @@ -586,7 +592,7 @@ const union AffineAnimCmd *const gAngerMarkAffineAnimTable[] = gAngerMarkAffineAnimCmds, }; -const struct SpriteTemplate gAngerMarkSpriteTemplate = //gUnknown_83E3F04 +const struct SpriteTemplate gAngerMarkSpriteTemplate = { .tileTag = ANIM_TAG_ANGER, .paletteTag = ANIM_TAG_ANGER, @@ -607,7 +613,7 @@ const union AffineAnimCmd gThrashMoveMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gPencilSpriteTemplate = //gUnknown_83E3F4C +const struct SpriteTemplate gPencilSpriteTemplate = { .tileTag = ANIM_TAG_PENCIL, .paletteTag = ANIM_TAG_PENCIL, @@ -618,7 +624,7 @@ const struct SpriteTemplate gPencilSpriteTemplate = //gUnknown_83E3F4C .callback = AnimPencil, }; -const struct SpriteTemplate gSnoreZSpriteTemplate = //gUnknown_83E3F64 +const struct SpriteTemplate gSnoreZSpriteTemplate = { .tileTag = ANIM_TAG_SNORE_Z, .paletteTag = ANIM_TAG_SNORE_Z, @@ -643,7 +649,7 @@ const union AnimCmd *const gExplosionAnimTable[] = gExplosionAnimCmds, }; -const struct SpriteTemplate gExplosionSpriteTemplate = //gUnknown_83E3F94 +const struct SpriteTemplate gExplosionSpriteTemplate = { .tileTag = ANIM_TAG_EXPLOSION, .paletteTag = ANIM_TAG_EXPLOSION, @@ -687,7 +693,7 @@ const union AffineAnimCmd *const gSoftBoiledEggAffineAnimTable[] = gSoftBoiledEggAffineAnimCmds3, }; -const struct SpriteTemplate gSoftBoiledEggSpriteTemplate = //gUnknown_83E4028 +const struct SpriteTemplate gSoftBoiledEggSpriteTemplate = { .tileTag = ANIM_TAG_BREAKING_EGG, .paletteTag = ANIM_TAG_BREAKING_EGG, @@ -730,7 +736,7 @@ const union AffineAnimCmd *const gHyperVoiceRingAffineAnimTable[] = gHyperVoiceRingAffineAnimCmds, }; -const struct SpriteTemplate gThinRingExpandingSpriteTemplate = //gUnknown_83E4094 +const struct SpriteTemplate gThinRingExpandingSpriteTemplate = { .tileTag = ANIM_TAG_THIN_RING, .paletteTag = ANIM_TAG_THIN_RING, @@ -753,7 +759,7 @@ const union AffineAnimCmd *const gThinRingShrinkingAffineAnimTable[] = gThinRingShrinkingAffineAnimCmds, }; -const struct SpriteTemplate gThinRingShrinkingSpriteTemplate = //gUnknown_83E40C8 +const struct SpriteTemplate gThinRingShrinkingSpriteTemplate = { .tileTag = ANIM_TAG_THIN_RING, .paletteTag = ANIM_TAG_THIN_RING, @@ -764,7 +770,7 @@ const struct SpriteTemplate gThinRingShrinkingSpriteTemplate = //gUnknown_83E40C .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gBlendThinRingExpandingSpriteTemplate = //gUnknown_83E40E0 +const struct SpriteTemplate gBlendThinRingExpandingSpriteTemplate = { .tileTag = ANIM_TAG_THIN_RING, .paletteTag = ANIM_TAG_THIN_RING, @@ -775,7 +781,7 @@ const struct SpriteTemplate gBlendThinRingExpandingSpriteTemplate = //gUnknown_8 .callback = AnimBlendThinRing, }; -const struct SpriteTemplate gHyperVoiceRingSpriteTemplate = //gUnknown_83E40F8 +const struct SpriteTemplate gHyperVoiceRingSpriteTemplate = { .tileTag = ANIM_TAG_THIN_RING, .paletteTag = ANIM_TAG_THIN_RING, @@ -786,7 +792,7 @@ const struct SpriteTemplate gHyperVoiceRingSpriteTemplate = //gUnknown_83E40F8 .callback = AnimHyperVoiceRing, }; -const struct SpriteTemplate gUproarRingSpriteTemplate = //gUnknown_83E4110 +const struct SpriteTemplate gUproarRingSpriteTemplate = { .tileTag = ANIM_TAG_THIN_RING, .paletteTag = ANIM_TAG_THIN_RING, @@ -818,7 +824,7 @@ const union AnimCmd *const gSpeedDustAnimTable[] = gSpeedDustAnimCmds, }; -const struct SpriteTemplate gSpeedDustSpriteTemplate = //gUnknown_83E4154 +const struct SpriteTemplate gSpeedDustSpriteTemplate = { .tileTag = ANIM_TAG_SPEED_DUST, .paletteTag = ANIM_TAG_SPEED_DUST, @@ -860,7 +866,7 @@ const union AnimCmd *const gBellAnimTable[] = gBellAnimCmds, }; -const struct SpriteTemplate gBellSpriteTemplate = //gUnknown_83E41B0 +const struct SpriteTemplate gBellSpriteTemplate = { .tileTag = ANIM_TAG_BELL, .paletteTag = ANIM_TAG_BELL, @@ -878,7 +884,7 @@ const u16 gMusicNotePaletteTagsTable[] = ANIM_SPRITES_START - 2, }; -const struct SpriteTemplate gHealBellMusicNoteSpriteTemplate = //gUnknown_83E41D0 +const struct SpriteTemplate gHealBellMusicNoteSpriteTemplate = { .tileTag = ANIM_TAG_MUSIC_NOTES_2, .paletteTag = ANIM_TAG_MUSIC_NOTES_2, @@ -889,7 +895,7 @@ const struct SpriteTemplate gHealBellMusicNoteSpriteTemplate = //gUnknown_83E41D .callback = AnimHealBellMusicNote, }; -const struct SpriteTemplate gMagentaHeartSpriteTemplate = //gUnknown_83E41E8 +const struct SpriteTemplate gMagentaHeartSpriteTemplate = { .tileTag = ANIM_TAG_MAGENTA_HEART, .paletteTag = ANIM_TAG_MAGENTA_HEART, @@ -907,7 +913,7 @@ const union AffineAnimCmd gUnknown_83E4200[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gRedHeartProjectileSpriteTemplate = //gUnknown_83E4218 +const struct SpriteTemplate gRedHeartProjectileSpriteTemplate = { .tileTag = ANIM_TAG_RED_HEART, .paletteTag = ANIM_TAG_RED_HEART, @@ -918,7 +924,7 @@ const struct SpriteTemplate gRedHeartProjectileSpriteTemplate = //gUnknown_83E42 .callback = AnimRedHeartProjectile, }; -const struct SpriteTemplate gRedHeartBurstSpriteTemplate = //gUnknown_83E4230 +const struct SpriteTemplate gRedHeartBurstSpriteTemplate = { .tileTag = ANIM_TAG_RED_HEART, .paletteTag = ANIM_TAG_RED_HEART, @@ -929,7 +935,7 @@ const struct SpriteTemplate gRedHeartBurstSpriteTemplate = //gUnknown_83E4230 .callback = AnimParticuleBurst, }; -const struct SpriteTemplate gRedHeartRisingSpriteTemplate = //gUnknown_83E4248 +const struct SpriteTemplate gRedHeartRisingSpriteTemplate = { .tileTag = ANIM_TAG_RED_HEART, .paletteTag = ANIM_TAG_RED_HEART, @@ -952,7 +958,7 @@ const union AffineAnimCmd *const gHiddenPowerOrbAffineAnimTable[] = gHiddenPowerOrbAffineAnimCmds, }; -const struct SpriteTemplate gHiddenPowerOrbSpriteTemplate = //gUnknown_83E427C +const struct SpriteTemplate gHiddenPowerOrbSpriteTemplate = { .tileTag = ANIM_TAG_RED_ORB, .paletteTag = ANIM_TAG_RED_ORB, @@ -963,7 +969,7 @@ const struct SpriteTemplate gHiddenPowerOrbSpriteTemplate = //gUnknown_83E427C .callback = AnimOrbitFast, }; -const struct SpriteTemplate gHiddenPowerOrbScatterSpriteTemplate = //gUnknown_83E4294 +const struct SpriteTemplate gHiddenPowerOrbScatterSpriteTemplate = { .tileTag = ANIM_TAG_RED_ORB, .paletteTag = ANIM_TAG_RED_ORB, @@ -986,7 +992,7 @@ const union AffineAnimCmd *const gSpitUpOrbAffineAnimTable[] = gSpitUpOrbAffineAnimCmds, }; -const struct SpriteTemplate gSpitUpOrbSpriteTemplate = //gUnknown_83E42C8 +const struct SpriteTemplate gSpitUpOrbSpriteTemplate = { .tileTag = ANIM_TAG_RED_ORB_2, .paletteTag = ANIM_TAG_RED_ORB_2, @@ -1012,7 +1018,7 @@ const union AnimCmd *const gEyeSparkleAnimTable[] = gEyeSparkleAnimCmds, }; -const struct SpriteTemplate gEyeSparkleSpriteTemplate = //gUnknown_83E42FC +const struct SpriteTemplate gEyeSparkleSpriteTemplate = { .tileTag = ANIM_TAG_EYE_SPARKLE, .paletteTag = ANIM_TAG_EYE_SPARKLE, @@ -1034,7 +1040,7 @@ const union AnimCmd *const gAngelSpriteAnimTable[] = gAngelSpriteAnimCmds, }; -const struct SpriteTemplate gAngelSpriteTemplate = //gUnknown_83E4320 +const struct SpriteTemplate gAngelSpriteTemplate = { .tileTag = ANIM_TAG_ANGEL, .paletteTag = ANIM_TAG_ANGEL, @@ -1045,7 +1051,7 @@ const struct SpriteTemplate gAngelSpriteTemplate = //gUnknown_83E4320 .callback = AnimAngel, }; -const struct SpriteTemplate gPinkHeartSpriteTemplate = //gUnknown_83E4338 +const struct SpriteTemplate gPinkHeartSpriteTemplate = { .tileTag = ANIM_TAG_PINK_HEART, .paletteTag = ANIM_TAG_PINK_HEART, @@ -1074,7 +1080,7 @@ const union AnimCmd *const gDevilAnimTable[] = gDevilAnimCmds2, }; -const struct SpriteTemplate gDevilSpriteTemplate = //gUnknown_83E4368 +const struct SpriteTemplate gDevilSpriteTemplate = { .tileTag = ANIM_TAG_DEVIL, .paletteTag = ANIM_TAG_DEVIL, @@ -1109,7 +1115,7 @@ const union AnimCmd *const gFurySwipesAnimTable[] = gUnknown_08593B1C, }; -const struct SpriteTemplate gFurySwipesSpriteTemplate = //gUnknown_83E43B0 +const struct SpriteTemplate gFurySwipesSpriteTemplate = { .tileTag = ANIM_TAG_SWIPE, .paletteTag = ANIM_TAG_SWIPE, @@ -1144,7 +1150,7 @@ const union AnimCmd *const gMovementWavesAnimTable[] = gMovementWavesAnimCmds2, }; -const struct SpriteTemplate gMovementWavesSpriteTemplate = //gUnknown_83E43F8 +const struct SpriteTemplate gMovementWavesSpriteTemplate = { .tileTag = ANIM_TAG_MOVEMENT_WAVES, .paletteTag = ANIM_TAG_MOVEMENT_WAVES, @@ -1163,7 +1169,7 @@ const union AffineAnimCmd gUnknown_08593B98[] = AFFINEANIMCMD_END, }; -const struct SpriteTemplate gJaggedMusicNoteSpriteTemplate = //gUnknown_83E4430 +const struct SpriteTemplate gJaggedMusicNoteSpriteTemplate = { .tileTag = ANIM_TAG_JAGGED_MUSIC_NOTE, .paletteTag = ANIM_TAG_JAGGED_MUSIC_NOTE, @@ -1199,8 +1205,7 @@ const union AffineAnimCmd *const gPerishSongMusicNoteAffineAnimTable[] = gPerishSongMusicNoteAffineAnimCmds3, }; -extern const union AnimCmd *const gMusicNotesAnimTable[]; -const struct SpriteTemplate gPerishSongMusicNoteSpriteTemplate = //gUnknown_83E4484 +const struct SpriteTemplate gPerishSongMusicNoteSpriteTemplate = { .tileTag = ANIM_TAG_MUSIC_NOTES_2, .paletteTag = ANIM_TAG_MUSIC_NOTES_2, @@ -1211,7 +1216,7 @@ const struct SpriteTemplate gPerishSongMusicNoteSpriteTemplate = //gUnknown_83E4 .callback = AnimPerishSongMusicNote, }; -const struct SpriteTemplate gPerishSongMusicNote2SpriteTemplate = //gUnknown_83E449C +const struct SpriteTemplate gPerishSongMusicNote2SpriteTemplate = { .tileTag = ANIM_TAG_MUSIC_NOTES_2, .paletteTag = ANIM_TAG_MUSIC_NOTES_2, @@ -1240,7 +1245,7 @@ const union AffineAnimCmd *const gGuardRingAffineAnimTable[] = gGuardRingAffineAnimCmds2, }; -const struct SpriteTemplate gGuardRingSpriteTemplate = //gUnknown_83E44DC +const struct SpriteTemplate gGuardRingSpriteTemplate = { .tileTag = ANIM_TAG_GUARD_RING, .paletteTag = ANIM_TAG_GUARD_RING, @@ -1269,6 +1274,7 @@ void sub_80A6E48(struct Sprite *sprite) void sub_80A6E98(struct Sprite *sprite) { u8 battler; + if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else @@ -1304,6 +1310,7 @@ static void sub_80A6ED8(struct Sprite *sprite) static void sub_80A6F3C(struct Sprite *sprite) { s16 temp; + gSprites[sprite->data[2]].pos2.x += sprite->data[1]; temp = sprite->data[1]; sprite->data[1] = -temp; @@ -1319,8 +1326,9 @@ static void sub_80A6F3C(struct Sprite *sprite) void sub_80A6F8C(struct Sprite *sprite) { u8 spriteId; - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); spriteId = gBattlerSpriteIds[gBattleAnimTarget]; if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) sprite->pos1.x -= gBattleAnimArgs[0]; @@ -1374,6 +1382,7 @@ static void AnimTask_WithdrawStep(u8 taskId) { u8 spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; s16 rotation; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) rotation = -gTasks[taskId].data[0]; else @@ -1488,8 +1497,8 @@ void AnimSonicBoomProjectile(struct Sprite *sprite) } InitSpritePosToAnimAttacker(sprite, TRUE); - targetXPos = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[2]; - targetYPos = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[3]; + targetXPos = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + gBattleAnimArgs[2]; + targetYPos = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[3]; rotation = ArcTan2Neg(targetXPos - sprite->pos1.x, targetYPos - sprite->pos1.y); rotation += 0xF000; if (IsContest()) @@ -1515,6 +1524,7 @@ static void AnimAirWaveProjectile_Step2(struct Sprite *sprite) static void AnimAirWaveProjectile_Step1(struct Sprite *sprite) { struct Task* task = &gTasks[sprite->data[7]]; + if (sprite->data[0] > task->data[5]) { sprite->data[5] += sprite->data[3]; @@ -1550,8 +1560,9 @@ void AnimAirWaveProjectile(struct Sprite *sprite) s16 a; s16 b; s16 c; - + struct Task* task = &gTasks[sprite->data[7]]; + sprite->data[1] += (-2 & task->data[7]); sprite->data[2] += (-2 & task->data[8]); if (1 & task->data[7]) @@ -1762,8 +1773,8 @@ void AnimCoinThrow(struct Sprite *sprite) u16 var; InitSpritePosToAnimAttacker(sprite, TRUE); - r6 = GetBattlerSpriteCoord(gBattleAnimTarget, 2); - r7 = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[3]; + r6 = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + r7 = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[3]; if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) gBattleAnimArgs[2] = -gBattleAnimArgs[2]; @@ -1819,6 +1830,7 @@ static void AnimBulletSeed_Step1(struct Sprite *sprite) int i; u16 rand; s16* ptr; + PlaySE12WithPanning(SE_W030, BattleAnimAdjustPanning(63)); sprite->pos1.x += sprite->pos2.x; sprite->pos1.y += sprite->pos2.y; @@ -1886,6 +1898,7 @@ void AnimViceGripPincer(struct Sprite *sprite) s16 startYOffset = -32; s16 endXOffset = 16; s16 endYOffset = -16; + if (gBattleAnimArgs[0]) { startXOffset = -32; @@ -1918,6 +1931,7 @@ void AnimGuillotinePincer(struct Sprite *sprite) s16 startYOffset = -32; s16 endXOffset = 16; s16 endYOffset = -16; + if (gBattleAnimArgs[0]) { startXOffset = -32; @@ -1992,6 +2006,7 @@ static void AnimGuillotinePincerStep3(struct Sprite *sprite) void AnimTask_GrowAndGreyscale(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_BLEND); SetSpriteRotScale(spriteId, 0xD0, 0xD0, 0); SetGreyscaleOrOriginalPalette(gSprites[spriteId].oam.paletteNum + 16, FALSE); @@ -2017,6 +2032,7 @@ void AnimTask_Minimize(u8 taskId) { struct Task* task = &gTasks[taskId]; u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); task->data[1] = 0; @@ -2032,6 +2048,7 @@ void AnimTask_Minimize(u8 taskId) static void AnimTask_MinimizeStep1(u8 taskId) { struct Task* task = &gTasks[taskId]; + switch (task->data[1]) { case 0: @@ -2099,6 +2116,7 @@ static void CreateMinimizeSprite(struct Task* task, u8 taskId) { u16 matrixNum; s16 spriteId = CloneBattlerSpriteWithBlend(ANIM_ATTACKER); + if (spriteId >= 0) { if ((matrixNum = AllocOamMatrix()) == 0xFF) @@ -2141,6 +2159,7 @@ static void ClonedMinizeSprite_Step(struct Sprite *sprite) void AnimTask_Splash(u8 taskId) { struct Task* task = &gTasks[taskId]; + if (gBattleAnimArgs[1] == 0) { DestroyAnimVisualTask(taskId); @@ -2161,6 +2180,7 @@ void AnimTask_Splash(u8 taskId) static void AnimTask_SplashStep(u8 taskId) { struct Task* task = &gTasks[taskId]; + switch (task->data[1]) { case 0: @@ -2216,6 +2236,7 @@ void AnimTask_GrowAndShrink(u8 taskId) { struct Task* task = &gTasks[taskId]; u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + PrepareAffineAnimInTaskData(task, spriteId, gGrowAndShrinkAffineAnimCmds); task->func = AnimTask_GrowAndShrinkStep; } @@ -2223,6 +2244,7 @@ void AnimTask_GrowAndShrink(u8 taskId) static void AnimTask_GrowAndShrinkStep(u8 taskId) { struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) DestroyAnimVisualTask(taskId); } @@ -2261,6 +2283,7 @@ void AnimBreathPuff(struct Sprite *sprite) void AnimAngerMark(struct Sprite *sprite) { u8 battler; + if (!gBattleAnimArgs[0]) battler = gBattleAnimAttacker; else @@ -2283,6 +2306,7 @@ void AnimTask_ThrashMoveMonHorizontal(u8 taskId) { struct Task* task = &gTasks[taskId]; u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; task->data[1] = 0; PrepareAffineAnimInTaskData(task, spriteId, gThrashMoveMonAffineAnimCmds); @@ -2292,6 +2316,7 @@ void AnimTask_ThrashMoveMonHorizontal(u8 taskId) static void ThrashMoveMonStep(u8 taskId) { struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) DestroyAnimVisualTask(taskId); } @@ -2300,6 +2325,7 @@ static void ThrashMoveMonStep(u8 taskId) void AnimTask_ThrashMoveMonVertical(u8 taskId) { struct Task* task = &gTasks[taskId]; + task->data[0] = GetAnimBattlerSpriteId(ANIM_ATTACKER); task->data[1] = 0; task->data[2] = 4; @@ -2319,6 +2345,7 @@ void AnimTask_ThrashMoveMonVertical(u8 taskId) static void ThrashMoveMon(u8 taskId) { struct Task* task = &gTasks[taskId]; + if (++task->data[7] > 2) { task->data[7] = 0; @@ -2371,8 +2398,8 @@ void sub_80A8874(u8 taskId) { struct Task* task = &gTasks[taskId]; struct ScanlineEffectParams params; - s16 i; + task->data[0] = GetBattlerYCoordWithElevation(gBattleAnimTarget) + 32; task->data[1] = 4; task->data[2] = 0; @@ -2457,7 +2484,7 @@ static void AnimTask_SketchDrawMon(u8 taskId) void AnimPencil(struct Sprite *sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) - 16; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X) - 16; sprite->pos1.y = GetBattlerYCoordWithElevation(gBattleAnimTarget) + 16; sprite->data[0] = 0; sprite->data[1] = 0; @@ -2545,12 +2572,12 @@ void AnimBlendThinRing(struct Sprite *sprite) { SetAverageBattlerPositions(battler, r4, &sp0, &sp1); if (r4 == 0) - r4 = GetBattlerSpriteCoord(battler, 0); + r4 = GetBattlerSpriteCoord(battler, BATTLER_COORD_X); else - r4 = GetBattlerSpriteCoord(battler, 2); + r4 = GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2); if (GetBattlerSide(battler) != B_SIDE_PLAYER) - gBattleAnimArgs[0] -= (sp0 - r4) - gBattleAnimArgs[0]; // This is weird. + gBattleAnimArgs[0] -= (sp0 - r4) - gBattleAnimArgs[0]; else gBattleAnimArgs[0] = sp0 - r4; } @@ -2656,6 +2683,7 @@ void AnimHyperVoiceRing(struct Sprite *sprite) void AnimUproarRing(struct Sprite *sprite) { u8 index = IndexOfSpritePaletteTag(ANIM_TAG_THIN_RING); + if (index != 0xFF) { BlendPalette(((index << 20) + 0x1010000) >> 16, 15, gBattleAnimArgs[5], gBattleAnimArgs[4]); @@ -2669,6 +2697,7 @@ void AnimUproarRing(struct Sprite *sprite) void AnimSoftBoiledEgg(struct Sprite *sprite) { s16 r1; + InitSpritePosToAnimAttacker(sprite, FALSE); r1 = GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER ? -160 : 160; sprite->data[0] = 0x380; @@ -2680,6 +2709,7 @@ void AnimSoftBoiledEgg(struct Sprite *sprite) static void AnimSoftBoiledEgg_Step1(struct Sprite *sprite) { s16 add; + sprite->pos2.y -= (sprite->data[0] >> 8); sprite->pos2.x = sprite->data[1] >> 8; sprite->data[0] -= 32; @@ -2772,6 +2802,7 @@ void AnimTask_StretchAttacker(u8 taskId) { struct Task* task = &gTasks[taskId]; u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[0] = spriteId; PrepareAffineAnimInTaskData(task, spriteId, gStretchAttackerAffineAnimCmds); task->func = StretchAttacker_Step; @@ -2780,6 +2811,7 @@ void AnimTask_StretchAttacker(u8 taskId) static void StretchAttacker_Step(u8 taskId) { struct Task* task = &gTasks[taskId]; + if (!RunAffineAnimFromTaskData(task)) { gSprites[task->data[0]].pos2.y = 0; @@ -2791,6 +2823,7 @@ static void StretchAttacker_Step(u8 taskId) void AnimTask_ExtremeSpeedImpact(u8 taskId) { struct Task* task = &gTasks[taskId]; + task->data[0] = 0; task->data[1] = 0; task->data[2] = 0; @@ -2860,6 +2893,7 @@ static void ExtremeSpeedImpact_Step(u8 taskId) void AnimTask_ExtremeSpeedMonReappear(u8 taskId) { struct Task* task = &gTasks[taskId]; + task->data[0] = 0; task->data[1] = 0; task->data[2] = 0; @@ -2874,6 +2908,7 @@ void AnimTask_ExtremeSpeedMonReappear(u8 taskId) static void ExtremeSpeedMonReappear_Step(u8 taskId) { struct Task* task = &gTasks[taskId]; + if (task->data[0] == 0 && ++task->data[1] > task->data[4]) { task->data[1] = 0; @@ -2902,6 +2937,7 @@ static void ExtremeSpeedMonReappear_Step(u8 taskId) void AnimTask_SpeedDust(u8 taskId) { struct Task* task = &gTasks[taskId]; + task->data[0] = 0; task->data[1] = 4; task->data[2] = 0; @@ -2912,14 +2948,15 @@ void AnimTask_SpeedDust(u8 taskId) task->data[7] = 0; task->data[8] = 0; task->data[13] = 0; - task->data[14] = GetBattlerSpriteCoord(gBattleAnimAttacker, ANIM_ATTACKER); - task->data[15] = GetBattlerSpriteCoord(gBattleAnimAttacker, ANIM_TARGET); + task->data[14] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + task->data[15] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); task->func = SpeedDust_Step1; } static void SpeedDust_Step1(u8 taskId) { struct Task* task = &gTasks[taskId]; + switch (task->data[8]) { case 0: @@ -3014,6 +3051,7 @@ void sub_80A96B4(u8 taskId) void sub_80A9760(u8 taskId) { int i; + for (i = 0; i < 3; i++) FreeSpritePaletteByTag(gMusicNotePaletteTagsTable[i]); @@ -3023,6 +3061,7 @@ void sub_80A9760(u8 taskId) static void SetMusicNotePalette(struct Sprite *sprite, u8 a, u8 b) { u8 tile; + tile = (b & 1); tile = ((-tile | tile) >> 31) & 32; sprite->oam.tileNum += tile + (a << 2); @@ -3036,8 +3075,8 @@ void AnimHealBellMusicNote(struct Sprite *sprite) gBattleAnimArgs[2] = -gBattleAnimArgs[2]; sprite->data[0] = gBattleAnimArgs[4]; - sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[2]; - sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + gBattleAnimArgs[3]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y) + gBattleAnimArgs[3]; sprite->callback = StartAnimLinearTranslation; StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); SetMusicNotePalette(sprite, gBattleAnimArgs[5], gBattleAnimArgs[6]); @@ -3112,9 +3151,10 @@ static void FakeOutStep2(u8 taskId) void sub_80A9A20(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); + if (++gTasks[taskId].data[0] == 1) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(1), gUnknown_83E4200); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_TARGET), gUnknown_83E4200); gSprites[spriteId].pos2.x = 4; } else @@ -3132,9 +3172,10 @@ void sub_80A9A20(u8 taskId) void sub_80A9AB0(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); + if (++gTasks[taskId].data[0] == 1) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(0), gUnknown_83E4200); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_83E4200); gSprites[spriteId].pos2.x = 4; } else @@ -3154,9 +3195,9 @@ void AnimRedHeartProjectile(struct Sprite *sprite) InitSpritePosToAnimAttacker(sprite, TRUE); sprite->data[0] = 95; sprite->data[1] = sprite->pos1.x; - sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); sprite->data[3] = sprite->pos1.y; - sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); InitAnimLinearTranslation(sprite); sprite->callback = AnimRedHeartProjectile_Step; } @@ -3209,6 +3250,7 @@ void AnimRedHeartRising(struct Sprite *sprite) static void AnimRedHeartRising_Step(struct Sprite *sprite) { s16 y; + sprite->data[2] += sprite->data[1]; sprite->pos2.y = -((u16)sprite->data[2] >> 8); sprite->pos2.x = Sin(sprite->data[3], 4); @@ -3238,12 +3280,12 @@ void AnimTask_HeartsBackground(u8 taskId) SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); sub_80752A0(&animBg); - AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBg_AttractTilemap); - AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnimBg_AttractGfx, animBg.tilesOffset); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBg_AttractTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnimBg_AttractGfx, animBg.tilesOffset); LoadCompressedPalette(gBattleAnimBg_AttractPal, animBg.paletteId * 16, 32); - if (IsContest()) - sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); - + if (IsContest()) + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + gTasks[taskId].func = HeartsBackground_Step; } @@ -3319,9 +3361,9 @@ void AnimTask_ScaryFace(u8 taskId) SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X); SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y); sub_80752A0(&animBg); - + if (IsContest()) - LZDecompressVram(gBattleAnimBgTilemap_ScaryFaceContest, animBg.bgTilemap); + LZDecompressVram(gBattleAnimBgTilemap_ScaryFaceContest, animBg.bgTilemap); else if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnimBgTilemap_ScaryFacePlayer); else @@ -3329,9 +3371,9 @@ void AnimTask_ScaryFace(u8 taskId) AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_ScaryFaceGfx, animBg.tilesOffset); LoadCompressedPalette(gBattleAnim_ScaryFacePal, animBg.paletteId * 16, 32); - if (IsContest()) - sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); - + if (IsContest()) + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + gTasks[taskId].func = ScaryFace_Step; } @@ -3398,8 +3440,8 @@ static void ScaryFace_Step(u8 taskId) // arg 1: initial wave offset void AnimOrbitFast(struct Sprite *sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); sprite->affineAnimPaused = 1; sprite->data[0] = gBattleAnimArgs[0]; sprite->data[1] = gBattleAnimArgs[1]; @@ -3449,8 +3491,8 @@ static void AnimOrbitFastStep(struct Sprite *sprite) // arg 0: initial wave offset void AnimOrbitScatter(struct Sprite *sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); sprite->data[0] = Sin(gBattleAnimArgs[0], 10); sprite->data[1] = Cos(gBattleAnimArgs[0], 7); sprite->callback = AnimOrbitScatterStep; @@ -3474,8 +3516,8 @@ static void AnimSpitUpOrb_Step(struct Sprite *sprite) void AnimSpitUpOrb(struct Sprite *sprite) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); sprite->data[0] = Sin(gBattleAnimArgs[0], 10); sprite->data[1] = Cos(gBattleAnimArgs[0], 7); sprite->data[2] = gBattleAnimArgs[1]; @@ -3497,6 +3539,7 @@ void AnimEyeSparkle(struct Sprite *sprite) void AnimAngel(struct Sprite *sprite) { s16 var0; + if (!sprite->data[0]) { sprite->pos1.x += gBattleAnimArgs[0]; @@ -3612,13 +3655,13 @@ void AnimMovementWaves(struct Sprite *sprite) { if (!gBattleAnimArgs[0]) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); } else { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); } if (!gBattleAnimArgs[1]) @@ -3666,8 +3709,8 @@ void AnimJaggedMusicNote(struct Sprite *sprite) if (GetBattlerSide(battler) == B_SIDE_OPPONENT) gBattleAnimArgs[1] *= -1; - sprite->pos1.x = GetBattlerSpriteCoord(battler, 2) + gBattleAnimArgs[1]; - sprite->pos1.y = GetBattlerSpriteCoord(battler, 3) + gBattleAnimArgs[2]; + sprite->pos1.x = GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[2]; sprite->data[0] = 0; sprite->data[1] = (u16)sprite->pos1.x << 3; sprite->data[2] = (u16)sprite->pos1.y << 3; @@ -3799,8 +3842,8 @@ void AnimGuardRing(struct Sprite *sprite) } else { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + 40; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y) + 40; } sprite->data[0] = 13; diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index cabe18fb6..4bb839a02 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -22,8 +22,7 @@ #include "constants/species.h" #include "constants/weather.h" -extern const struct SpriteTemplate gThoughtBubbleSpriteTemplate; - +// Function Declarations void AnimBlackSmoke(struct Sprite *); void AnimWhiteHalo(struct Sprite *); void AnimTealAlert(struct Sprite *); @@ -120,7 +119,9 @@ static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); // Data -const union AnimCmd gScratchAnimCmds[] = //83FEDE4 +extern const struct SpriteTemplate gThoughtBubbleSpriteTemplate; + +const union AnimCmd gScratchAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -130,12 +131,12 @@ const union AnimCmd gScratchAnimCmds[] = //83FEDE4 ANIMCMD_END, }; -const union AnimCmd *const gScratchAnimTable[] = //83FEDFC +const union AnimCmd *const gScratchAnimTable[] = { gScratchAnimCmds, }; -const struct SpriteTemplate gScratchSpriteTemplate = //83FEE00 +const struct SpriteTemplate gScratchSpriteTemplate = { .tileTag = ANIM_TAG_SCRATCH, .paletteTag = ANIM_TAG_SCRATCH, @@ -146,7 +147,7 @@ const struct SpriteTemplate gScratchSpriteTemplate = //83FEE00 .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gBlackSmokeSpriteTemplate = //83FEE18 +const struct SpriteTemplate gBlackSmokeSpriteTemplate = { .tileTag = ANIM_TAG_BLACK_SMOKE, .paletteTag = ANIM_TAG_BLACK_SMOKE, @@ -157,7 +158,7 @@ const struct SpriteTemplate gBlackSmokeSpriteTemplate = //83FEE18 .callback = AnimBlackSmoke, }; -const struct SpriteTemplate gBlackBallSpriteTemplate = //83FEE30 +const struct SpriteTemplate gBlackBallSpriteTemplate = { .tileTag = ANIM_TAG_BLACK_BALL, .paletteTag = ANIM_TAG_BLACK_BALL, @@ -168,7 +169,7 @@ const struct SpriteTemplate gBlackBallSpriteTemplate = //83FEE30 .callback = AnimThrowProjectile, }; -const union AnimCmd gOpeningEyeAnimCmds[] = //83FEE48 +const union AnimCmd gOpeningEyeAnimCmds[] = { ANIMCMD_FRAME(0, 40), ANIMCMD_FRAME(16, 8), @@ -176,12 +177,12 @@ const union AnimCmd gOpeningEyeAnimCmds[] = //83FEE48 ANIMCMD_END, }; -const union AnimCmd *const gOpeningEyeAnimTable[] = //83FEE58 +const union AnimCmd *const gOpeningEyeAnimTable[] = { gOpeningEyeAnimCmds, }; -const struct SpriteTemplate gOpeningEyeSpriteTemplate = //83FEE5C +const struct SpriteTemplate gOpeningEyeSpriteTemplate = { .tileTag = ANIM_TAG_OPENING_EYE, .paletteTag = ANIM_TAG_OPENING_EYE, @@ -192,7 +193,7 @@ const struct SpriteTemplate gOpeningEyeSpriteTemplate = //83FEE5C .callback = AnimSpriteOnMonPos, }; -const struct SpriteTemplate gWhiteHaloSpriteTemplate = //83FEE74 +const struct SpriteTemplate gWhiteHaloSpriteTemplate = { .tileTag = ANIM_TAG_ROUND_WHITE_HALO, .paletteTag = ANIM_TAG_ROUND_WHITE_HALO, @@ -203,7 +204,7 @@ const struct SpriteTemplate gWhiteHaloSpriteTemplate = //83FEE74 .callback = AnimWhiteHalo, }; -const struct SpriteTemplate gTealAlertSpriteTemplate = //83FEE8C +const struct SpriteTemplate gTealAlertSpriteTemplate = { .tileTag = ANIM_TAG_TEAL_ALERT, .paletteTag = ANIM_TAG_TEAL_ALERT, @@ -214,7 +215,7 @@ const struct SpriteTemplate gTealAlertSpriteTemplate = //83FEE8C .callback = AnimTealAlert, }; -const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = //83FEEA4 +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x180, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x20, 0x18, 0, 5), @@ -222,20 +223,20 @@ const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = //83FEEA4 AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = //83FEEC4 +const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x30, 0x30, 0, 0), AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 6), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = //83FEEDC +const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = { gMeanLookEyeAffineAnimCmds1, gMeanLookEyeAffineAnimCmds2, }; -const struct SpriteTemplate gMeanLookEyeSpriteTemplate = //83FEEE4 +const struct SpriteTemplate gMeanLookEyeSpriteTemplate = { .tileTag = ANIM_TAG_EYE, .paletteTag = ANIM_TAG_EYE, @@ -246,7 +247,7 @@ const struct SpriteTemplate gMeanLookEyeSpriteTemplate = //83FEEE4 .callback = AnimMeanLookEye, }; -const struct SpriteTemplate gSpikesSpriteTemplate = //83FEEFC +const struct SpriteTemplate gSpikesSpriteTemplate = { .tileTag = ANIM_TAG_SPIKES, .paletteTag = ANIM_TAG_SPIKES, @@ -257,7 +258,7 @@ const struct SpriteTemplate gSpikesSpriteTemplate = //83FEEFC .callback = AnimSpikes, }; -const union AnimCmd gLeerAnimCmds[] = //83FEF14 +const union AnimCmd gLeerAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -267,12 +268,12 @@ const union AnimCmd gLeerAnimCmds[] = //83FEF14 ANIMCMD_END, }; -const union AnimCmd *const gLeerAnimTable[] = //83FEF2C +const union AnimCmd *const gLeerAnimTable[] = { gLeerAnimCmds, }; -const struct SpriteTemplate gLeerSpriteTemplate = //83FEF30 +const struct SpriteTemplate gLeerSpriteTemplate = { .tileTag = ANIM_TAG_LEER, .paletteTag = ANIM_TAG_LEER, @@ -283,30 +284,30 @@ const struct SpriteTemplate gLeerSpriteTemplate = //83FEF30 .callback = AnimLeer, }; -const union AnimCmd gLetterZAnimCmds[] = //83FEF48 +const union AnimCmd gLetterZAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_END, }; -const union AnimCmd *const gLetterZAnimTable[] = //83FEF50 +const union AnimCmd *const gLetterZAnimTable[] = { gLetterZAnimCmds, }; -const union AffineAnimCmd gLetterZAffineAnimCmds[] = //83FEF54 +const union AffineAnimCmd gLetterZAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-7, -7, -3, 16), AFFINEANIMCMD_FRAME(7, 7, 3, 16), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gLetterZAffineAnimTable[] = //83FEF6C +const union AffineAnimCmd *const gLetterZAffineAnimTable[] = { gLetterZAffineAnimCmds, }; -const struct SpriteTemplate gLetterZSpriteTemplate = //83FEF70 +const struct SpriteTemplate gLetterZSpriteTemplate = { .tileTag = ANIM_TAG_LETTER_Z, .paletteTag = ANIM_TAG_LETTER_Z, @@ -317,7 +318,7 @@ const struct SpriteTemplate gLetterZSpriteTemplate = //83FEF70 .callback = AnimLetterZ, }; -const union AnimCmd gFangAnimCmds[] = //83FEF88 +const union AnimCmd gFangAnimCmds[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(16, 16), @@ -326,24 +327,24 @@ const union AnimCmd gFangAnimCmds[] = //83FEF88 ANIMCMD_END, }; -const union AnimCmd *const gFangAnimTable[] = //83FEF9C +const union AnimCmd *const gFangAnimTable[] = { gFangAnimCmds, }; -const union AffineAnimCmd gFangAffineAnimCmds[] = //83FEFA0 +const union AffineAnimCmd gFangAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), AFFINEANIMCMD_FRAME(-0x20, -0x20, 0, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gFangAffineAnimTable[] = //83FEFB8 +const union AffineAnimCmd *const gFangAffineAnimTable[] = { gFangAffineAnimCmds, }; -const struct SpriteTemplate gFangSpriteTemplate = //83FEFBC +const struct SpriteTemplate gFangSpriteTemplate = { .tileTag = ANIM_TAG_FANG_ATTACK, .paletteTag = ANIM_TAG_FANG_ATTACK, @@ -354,27 +355,27 @@ const struct SpriteTemplate gFangSpriteTemplate = //83FEFBC .callback = AnimFang, }; -const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = //83FEFD4 +const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x0, 0x180, 0, 0), AFFINEANIMCMD_FRAME(0x10, 0x0, 0, 20), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = //83FEFEC +const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x140, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x10, 0x0, 0, 19), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = //83FF004 +const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = { gSpotlightAffineAnimCmds1, gSpotlightAffineAnimCmds2, }; -const struct SpriteTemplate gSpotlightSpriteTemplate = //83FF00C +const struct SpriteTemplate gSpotlightSpriteTemplate = { .tileTag = ANIM_TAG_SPOTLIGHT, .paletteTag = ANIM_TAG_SPOTLIGHT, @@ -385,7 +386,7 @@ const struct SpriteTemplate gSpotlightSpriteTemplate = //83FF00C .callback = AnimSpotlight, }; -const struct SpriteTemplate gClappingHandSpriteTemplate = //83FF024 +const struct SpriteTemplate gClappingHandSpriteTemplate = { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -396,7 +397,7 @@ const struct SpriteTemplate gClappingHandSpriteTemplate = //83FF024 .callback = AnimClappingHand, }; -const struct SpriteTemplate gClappingHand2SpriteTemplate = //83FF03C +const struct SpriteTemplate gClappingHand2SpriteTemplate = { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -407,7 +408,7 @@ const struct SpriteTemplate gClappingHand2SpriteTemplate = //83FF03C .callback = AnimClappingHand2, }; -const union AnimCmd gRapidSpinAnimCmds[] = //83FF054 +const union AnimCmd gRapidSpinAnimCmds[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(8, 2), @@ -415,12 +416,12 @@ const union AnimCmd gRapidSpinAnimCmds[] = //83FF054 ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRapidSpinAnimTable[] = //83FF064 +const union AnimCmd *const gRapidSpinAnimTable[] = { gRapidSpinAnimCmds, }; -const struct SpriteTemplate gRapidSpinSpriteTemplate = //83FF068 +const struct SpriteTemplate gRapidSpinSpriteTemplate = { .tileTag = ANIM_TAG_RAPID_SPIN, .paletteTag = ANIM_TAG_RAPID_SPIN, @@ -431,7 +432,7 @@ const struct SpriteTemplate gRapidSpinSpriteTemplate = //83FF068 .callback = AnimRapidSpin, }; -const union AffineAnimCmd gUnknown_83FF080[] = //83FF080 +const union AffineAnimCmd gUnknown_83FF080[] = { AFFINEANIMCMD_FRAME(-12, 8, 0, 4), AFFINEANIMCMD_FRAME(20, -20, 0, 4), @@ -439,18 +440,18 @@ const union AffineAnimCmd gUnknown_83FF080[] = //83FF080 AFFINEANIMCMD_END, }; -const union AnimCmd gTriAttackTriangleAnimCmds[] = //83FF0A0 +const union AnimCmd gTriAttackTriangleAnimCmds[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -const union AnimCmd *const gTriAttackTriangleAnimTable[] = //83FF0A8 +const union AnimCmd *const gTriAttackTriangleAnimTable[] = { gTriAttackTriangleAnimCmds, }; -const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = //83FF0AC +const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 5, 40), AFFINEANIMCMD_FRAME(0, 0, 10, 10), @@ -459,12 +460,12 @@ const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = //83FF0AC AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = //83FF0D4 +const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = { gTriAttackTriangleAffineAnimCmds, }; -const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = //83FF0D8 +const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = { .tileTag = ANIM_TAG_TRI_FORCE_TRIANGLE, .paletteTag = ANIM_TAG_TRI_FORCE_TRIANGLE, @@ -475,7 +476,7 @@ const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = //83FF0D8 .callback = AnimTriAttackTriangle, }; -const union AnimCmd gEclipsingOrbAnimCmds[] = //83FF0F0 +const union AnimCmd gEclipsingOrbAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -488,12 +489,12 @@ const union AnimCmd gEclipsingOrbAnimCmds[] = //83FF0F0 ANIMCMD_END, }; -const union AnimCmd *const gEclipsingOrbAnimTable[] = //83FF114 +const union AnimCmd *const gEclipsingOrbAnimTable[] = { gEclipsingOrbAnimCmds, }; -const struct SpriteTemplate gEclipsingOrbSpriteTemplate = //83FF118 +const struct SpriteTemplate gEclipsingOrbSpriteTemplate = { .tileTag = ANIM_TAG_ECLIPSING_ORB, .paletteTag = ANIM_TAG_ECLIPSING_ORB, @@ -504,7 +505,7 @@ const struct SpriteTemplate gEclipsingOrbSpriteTemplate = //83FF118 .callback = AnimSpriteOnMonPos, }; -const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = //83FF130 +const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-12, 20, 0, 8), AFFINEANIMCMD_FRAME(12, -20, 0, 8), @@ -512,7 +513,7 @@ const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = //83FF130 AFFINEANIMCMD_END, }; -const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = //83FF150 +const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = { .tileTag = ANIM_TAG_POKEBALL, .paletteTag = ANIM_TAG_POKEBALL, @@ -523,7 +524,7 @@ const struct SpriteTemplate gBatonPassPokeballSpriteTemplate = //83FF150 .callback = AnimBatonPassPokeball, }; -const struct SpriteTemplate gWishStarSpriteTemplate = //83FF168 +const struct SpriteTemplate gWishStarSpriteTemplate = { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -534,7 +535,7 @@ const struct SpriteTemplate gWishStarSpriteTemplate = //83FF168 .callback = AnimWishStar, }; -const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = //83FF180 +const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -545,7 +546,7 @@ const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = //83FF180 .callback = AnimMiniTwinklingStar, }; -const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = //83FF198 +const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(8, -8, 0, 12), AFFINEANIMCMD_FRAME(-16, 16, 0, 12), @@ -554,7 +555,7 @@ const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = //83FF198 AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = //83FF1C0 +const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -565,7 +566,7 @@ const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = //83FF1C0 AFFINEANIMCMD_END, }; -const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = //83FF1F8 +const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = { .tileTag = ANIM_TAG_BLUE_ORB, .paletteTag = ANIM_TAG_BLUE_ORB, @@ -576,7 +577,7 @@ const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = //83FF1F8 .callback = AnimSwallowBlueOrb, }; -const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = //83FF210 +const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -586,7 +587,7 @@ const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = //83FF210 AFFINEANIMCMD_END, }; -const s8 gMorningSunLightBeamCoordsTable[] = //83FF240 +const s8 gMorningSunLightBeamCoordsTable[] = { 0xE8, 0x18, @@ -594,33 +595,33 @@ const s8 gMorningSunLightBeamCoordsTable[] = //83FF240 0x00, }; -const union AnimCmd gGreenStarAnimCmds1[] = //83FF244 +const union AnimCmd gGreenStarAnimCmds1[] = { ANIMCMD_FRAME(0, 6), ANIMCMD_FRAME(4, 6), ANIMCMD_JUMP(0), }; -const union AnimCmd gGreenStarAnimCmds2[] = //83FF250 +const union AnimCmd gGreenStarAnimCmds2[] = { ANIMCMD_FRAME(8, 6), ANIMCMD_END, }; -const union AnimCmd gGreenStarAnimCmds3[] = //83FF258 +const union AnimCmd gGreenStarAnimCmds3[] = { ANIMCMD_FRAME(12, 6), ANIMCMD_END, }; -const union AnimCmd *const gGreenStarAnimTable[] = //83FF260 +const union AnimCmd *const gGreenStarAnimTable[] = { gGreenStarAnimCmds1, gGreenStarAnimCmds2, gGreenStarAnimCmds3, }; -const struct SpriteTemplate gGreenStarSpriteTemplate = //83FF26C +const struct SpriteTemplate gGreenStarSpriteTemplate = { .tileTag = ANIM_TAG_GREEN_STAR, .paletteTag = ANIM_TAG_GREEN_STAR, @@ -631,7 +632,7 @@ const struct SpriteTemplate gGreenStarSpriteTemplate = //83FF26C .callback = AnimGreenStar, }; -const s8 gDoomDesireLightBeamCoordTable[] = //83FF284 +const s8 gDoomDesireLightBeamCoordTable[] = { 0x78, 0x50, @@ -639,7 +640,7 @@ const s8 gDoomDesireLightBeamCoordTable[] = //83FF284 0x00, }; -const u8 gDoomDesireLightBeamDelayTable[] = //83FF288 +const u8 gDoomDesireLightBeamDelayTable[] = { 0, 0, @@ -648,7 +649,7 @@ const u8 gDoomDesireLightBeamDelayTable[] = //83FF288 50, }; -const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = //83FF290 +const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, -15, 0, 7), AFFINEANIMCMD_FRAME(0, 15, 0, 7), @@ -656,7 +657,7 @@ const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = //83FF290 AFFINEANIMCMD_END, }; -const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = //83FF2B0 +const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = { .tileTag = ANIM_TAG_ANGER, .paletteTag = ANIM_TAG_ANGER, @@ -667,7 +668,7 @@ const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = //83FF2B0 .callback = AnimWeakFrustrationAngerMark, }; -const union AnimCmd gSweetScentPetalAnimCmds1[] = //83FF2C8 +const union AnimCmd gSweetScentPetalAnimCmds1[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(1, 8), @@ -680,7 +681,7 @@ const union AnimCmd gSweetScentPetalAnimCmds1[] = //83FF2C8 ANIMCMD_JUMP(0), }; -const union AnimCmd gSweetScentPetalAnimCmds2[] = //83FF2EC +const union AnimCmd gSweetScentPetalAnimCmds2[] = { ANIMCMD_FRAME(0, 8, .hFlip = TRUE), ANIMCMD_FRAME(1, 8, .hFlip = TRUE), @@ -693,20 +694,20 @@ const union AnimCmd gSweetScentPetalAnimCmds2[] = //83FF2EC ANIMCMD_JUMP(0), }; -const union AnimCmd gSweetScentPetalAnimCmds3[] = //83FF310 +const union AnimCmd gSweetScentPetalAnimCmds3[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = //83FF318 +const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = { gSweetScentPetalAnimCmds1, gSweetScentPetalAnimCmds2, gSweetScentPetalAnimCmds3, }; -const struct SpriteTemplate gSweetScentPetalSpriteTemplate = //83FF324 +const struct SpriteTemplate gSweetScentPetalSpriteTemplate = { .tileTag = ANIM_TAG_PINK_PETAL, .paletteTag = ANIM_TAG_PINK_PETAL, @@ -717,9 +718,9 @@ const struct SpriteTemplate gSweetScentPetalSpriteTemplate = //83FF324 .callback = AnimSweetScentPetal, }; -const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/battle_anims/unk_83FF33C.gbapal"); //Unused +const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/battle_anims/unk_83FF33C.gbapal"); //Unused -const union AnimCmd gPainSplitAnimCmds[] = //83FF35C +const union AnimCmd gPainSplitAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 9), @@ -727,12 +728,12 @@ const union AnimCmd gPainSplitAnimCmds[] = //83FF35C ANIMCMD_END, }; -const union AnimCmd *const gPainSplitAnimCmdTable[] = //83FF36C +const union AnimCmd *const gPainSplitAnimCmdTable[] = { gPainSplitAnimCmds, }; -const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = //83FF370 +const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = { .tileTag = ANIM_TAG_PAIN_SPLIT, .paletteTag = ANIM_TAG_PAIN_SPLIT, @@ -743,7 +744,7 @@ const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = //83FF370 .callback = AnimPainSplitProjectile, }; -const struct SpriteTemplate gFlatterConfettiSpriteTemplate = //83FF388 +const struct SpriteTemplate gFlatterConfettiSpriteTemplate = { .tileTag = ANIM_TAG_CONFETTI, .paletteTag = ANIM_TAG_CONFETTI, @@ -754,7 +755,7 @@ const struct SpriteTemplate gFlatterConfettiSpriteTemplate = //83FF388 .callback = AnimFlatterConfetti, }; -const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = //83FF3A0 +const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = { .tileTag = ANIM_TAG_SPOTLIGHT, .paletteTag = ANIM_TAG_SPOTLIGHT, @@ -765,7 +766,7 @@ const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = //83FF3A0 .callback = AnimFlatterSpotlight, }; -const struct SpriteTemplate gReversalOrbSpriteTemplate = //83FF3B8 +const struct SpriteTemplate gReversalOrbSpriteTemplate = { .tileTag = ANIM_TAG_BLUE_ORB, .paletteTag = ANIM_TAG_BLUE_ORB, @@ -776,7 +777,7 @@ const struct SpriteTemplate gReversalOrbSpriteTemplate = //83FF3B8 .callback = AnimReversalOrb, }; -const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = //83FF3D0 +const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 0, 0, 4), AFFINEANIMCMD_FRAME(0, -3, 0, 16), @@ -786,7 +787,7 @@ const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = //83FF3D0 AFFINEANIMCMD_END, }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = //83FF400 +const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-8, -8, 0, 8), @@ -794,7 +795,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = //83FF400 AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = //83FF420 +const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -802,7 +803,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = //83FF420 AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = //83FF440 +const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -810,14 +811,14 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = //83FF440 AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = //83FF460 +const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = { gYawnCloudAffineAnimCmds1, gYawnCloudAffineAnimCmds2, gYawnCloudAffineAnimCmds3, }; -const struct SpriteTemplate gYawnCloudSpriteTemplate = //83FF46C +const struct SpriteTemplate gYawnCloudSpriteTemplate = { .tileTag = ANIM_TAG_PINK_CLOUD, .paletteTag = ANIM_TAG_PINK_CLOUD, @@ -828,7 +829,7 @@ const struct SpriteTemplate gYawnCloudSpriteTemplate = //83FF46C .callback = AnimYawnCloud, }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = //83FF484 +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-4, -6, 0, 16), @@ -836,7 +837,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = //83FF484 AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = //83FF4A4 +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -844,7 +845,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = //83FF4A4 AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = //83FF4C4 +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -852,7 +853,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = //83FF4C4 AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = //83FF4E4 +const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 10, 0, 30), @@ -860,7 +861,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = //83FF4E4 AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = //83FF504 +const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = { gSmokeBallEscapeCloudAffineAnimCmds1, gSmokeBallEscapeCloudAffineAnimCmds2, @@ -868,7 +869,7 @@ const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = //83FF gSmokeBallEscapeCloudAffineAnimCmds4, }; -const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = //83FF514 +const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = { .tileTag = ANIM_TAG_PINK_CLOUD, .paletteTag = ANIM_TAG_PINK_CLOUD, @@ -879,7 +880,7 @@ const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = //83FF514 .callback = AnimSmokeBallEscapeCloud, }; -const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = //83FF52C +const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-16, 16, 0, 6), AFFINEANIMCMD_FRAME(16, -16, 0, 12), @@ -887,7 +888,7 @@ const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = //83FF52C AFFINEANIMCMD_END, }; -const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = //83FF54C +const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = { .tileTag = ANIM_TAG_SWEAT_DROP, .paletteTag = ANIM_TAG_SWEAT_DROP, @@ -898,7 +899,7 @@ const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = //83FF54C .callback = AnimFacadeSweatDrop, }; -const u16 gFacadeBlendColors[] = //83FF564 +const u16 gFacadeBlendColors[] = { RGB(28, 25, 1), RGB(28, 21, 5), @@ -926,27 +927,27 @@ const u16 gFacadeBlendColors[] = //83FF564 RGB(29, 27, 0), }; -const union AnimCmd gRoarNoiseLineAnimCmds1[] = //83FF594 +const union AnimCmd gRoarNoiseLineAnimCmds1[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd gRoarNoiseLineAnimCmds2[] = //83FF5A0 +const union AnimCmd gRoarNoiseLineAnimCmds2[] = { ANIMCMD_FRAME(32, 3), ANIMCMD_FRAME(48, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRoarNoiseLineAnimTable[] = //83FF5AC +const union AnimCmd *const gRoarNoiseLineAnimTable[] = { gRoarNoiseLineAnimCmds1, gRoarNoiseLineAnimCmds2, }; -const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = //83FF5B4 +const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = { .tileTag = ANIM_TAG_NOISE_LINE, .paletteTag = ANIM_TAG_NOISE_LINE, @@ -957,7 +958,7 @@ const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = //83FF5B4 .callback = AnimRoarNoiseLine, }; -const struct SpriteTemplate gGlareEyeDotSpriteTemplate = //83FF5CC +const struct SpriteTemplate gGlareEyeDotSpriteTemplate = { .tileTag = ANIM_TAG_SMALL_RED_EYE, .paletteTag = ANIM_TAG_SMALL_RED_EYE, @@ -968,7 +969,7 @@ const struct SpriteTemplate gGlareEyeDotSpriteTemplate = //83FF5CC .callback = AnimGlareEyeDot, }; -const struct SpriteTemplate gAssistPawprintSpriteTemplate = //83FF5E4 +const struct SpriteTemplate gAssistPawprintSpriteTemplate = { .tileTag = ANIM_TAG_PAW_PRINT, .paletteTag = ANIM_TAG_PAW_PRINT, @@ -979,26 +980,26 @@ const struct SpriteTemplate gAssistPawprintSpriteTemplate = //83FF5E4 .callback = AnimAssistPawprint, }; -const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = //83FF5FC +const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = //83FF60C +const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = //83FF624 +const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = { gBarrageBallAffineAnimCmds1, gBarrageBallAffineAnimCmds2, }; -const struct SpriteTemplate gBarrageBallSpriteTemplate = //83FF62C +const struct SpriteTemplate gBarrageBallSpriteTemplate = { .tileTag = ANIM_TAG_RED_BALL, .paletteTag = ANIM_TAG_RED_BALL, @@ -1009,7 +1010,7 @@ const struct SpriteTemplate gBarrageBallSpriteTemplate = //83FF62C .callback = SpriteCallbackDummy, }; -const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = //83FF644 +const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -1020,14 +1021,14 @@ const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = //83FF644 .callback = AnimSmellingSaltsHand, }; -const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = //83FF65C +const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, -16, 0, 6), AFFINEANIMCMD_FRAME(0, 16, 0, 6), AFFINEANIMCMD_END, }; -const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = //83FF674 +const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = { .tileTag = ANIM_TAG_SMELLINGSALT_EFFECT, .paletteTag = ANIM_TAG_SMELLINGSALT_EFFECT, @@ -1038,7 +1039,7 @@ const struct SpriteTemplate gSmellingSaltExclamationSpriteTemplate = //83FF674 .callback = AnimSmellingSaltExclamation, }; -const struct SpriteTemplate gHelpingHandClapSpriteTemplate = //83FF68C +const struct SpriteTemplate gHelpingHandClapSpriteTemplate = { .tileTag = ANIM_TAG_TAG_HAND, .paletteTag = ANIM_TAG_TAG_HAND, @@ -1049,7 +1050,7 @@ const struct SpriteTemplate gHelpingHandClapSpriteTemplate = //83FF68C .callback = AnimHelpingHandClap, }; -const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = //83FF6A4 +const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = { .tileTag = ANIM_TAG_MAGNIFYING_GLASS, .paletteTag = ANIM_TAG_MAGNIFYING_GLASS, @@ -1060,7 +1061,7 @@ const struct SpriteTemplate gForesightMagnifyingGlassSpriteTemplate = //83FF6A4 .callback = AnimForesightMagnifyingGlass, }; -const struct SpriteTemplate gMeteorMashStarSpriteTemplate = //83FF6BC +const struct SpriteTemplate gMeteorMashStarSpriteTemplate = { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -1071,7 +1072,7 @@ const struct SpriteTemplate gMeteorMashStarSpriteTemplate = //83FF6BC .callback = AnimMeteorMashStar, }; -const struct SpriteTemplate gUnknown_83FF6D4 = //83FF6D4 +const struct SpriteTemplate gUnknown_83FF6D4 = { .tileTag = ANIM_TAG_GOLD_STARS, .paletteTag = ANIM_TAG_GOLD_STARS, @@ -1082,7 +1083,7 @@ const struct SpriteTemplate gUnknown_83FF6D4 = //83FF6D4 .callback = AnimParticuleBurst, }; -const struct SpriteTemplate gBlockXSpriteTemplate = //83FF6EC +const struct SpriteTemplate gBlockXSpriteTemplate = { .tileTag = ANIM_TAG_X_SIGN, .paletteTag = ANIM_TAG_X_SIGN, @@ -1093,7 +1094,7 @@ const struct SpriteTemplate gBlockXSpriteTemplate = //83FF6EC .callback = AnimBlockX, }; -const struct SpriteTemplate gUnknown_83FF704 = //83FF704 +const struct SpriteTemplate gUnknown_83FF704 = { .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, @@ -1104,39 +1105,39 @@ const struct SpriteTemplate gUnknown_83FF704 = //83FF704 .callback = sub_80E3E84, }; -const union AnimCmd gKnockOffStrikeAnimCmds[] = //83FF71C +const union AnimCmd gKnockOffStrikeAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(64, 4), ANIMCMD_END, }; -const union AnimCmd *const gKnockOffStrikeAnimTable[] = //83FF728 +const union AnimCmd *const gKnockOffStrikeAnimTable[] = { gKnockOffStrikeAnimCmds, }; -const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = //83FF72C +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -4, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = //83FF744 +const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = //83FF75C +const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = { gKnockOffStrikeAffineanimCmds1, gKnockOffStrikeAffineanimCmds2, }; -const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = //83FF764 +const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = { .tileTag = ANIM_TAG_SLAM_HIT_2, .paletteTag = ANIM_TAG_SLAM_HIT_2, @@ -1147,18 +1148,18 @@ const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = //83FF764 .callback = AnimKnockOffStrike, }; -const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = //83FF77C +const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 64), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = //83FF78C +const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = { gRecycleSpriteAffineAnimCmds, }; -const struct SpriteTemplate gRecycleSpriteTemplate = //83FF790 +const struct SpriteTemplate gRecycleSpriteTemplate = { .tileTag = ANIM_TAG_RECYCLE, .paletteTag = ANIM_TAG_RECYCLE, @@ -1169,7 +1170,7 @@ const struct SpriteTemplate gRecycleSpriteTemplate = //83FF790 .callback = AnimRecycle, }; -const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = //83FF7A8 +const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 16, 0, 4), AFFINEANIMCMD_FRAME(-2, 0, 0, 8), @@ -1180,12 +1181,10 @@ const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = //83FF7A8 }; // Functions -// 80DE2C0 void AnimBlackSmoke(struct Sprite *sprite) { sprite->pos1.x += gBattleAnimArgs[0]; sprite->pos1.y += gBattleAnimArgs[1]; - if (!gBattleAnimArgs[3]) sprite->data[0] = gBattleAnimArgs[2]; else @@ -1212,10 +1211,7 @@ static void AnimBlackSmokeStep(struct Sprite *sprite) void AnimTask_SmokescreenImpact(u8 taskId) { - SmokescreenImpact( //sub_804A76C - GetBattlerSpriteCoord(gBattleAnimTarget, 2) + 8, - GetBattlerSpriteCoord(gBattleAnimTarget, 3) + 8, - 0); + SmokescreenImpact(GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + 8, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + 8, 0); DestroyAnimVisualTask(taskId); } @@ -1249,18 +1245,16 @@ static void AnimWhiteHalo_Step2(struct Sprite *sprite) void AnimTealAlert(struct Sprite *sprite) { u16 rotation; - u8 x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); - u8 y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + u8 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + u8 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); InitSpritePosToAnimTarget(sprite, TRUE); - rotation = ArcTan2Neg(sprite->pos1.x - x, sprite->pos1.y - y); rotation += 0x6000; if (IsContest()) rotation += 0x4000; TrySetSpriteRotScale(sprite, FALSE, 0x100, 0x100, rotation); - sprite->data[0] = gBattleAnimArgs[2]; sprite->data[2] = x; sprite->data[4] = y; @@ -1279,7 +1273,6 @@ void AnimMeanLookEye(struct Sprite *sprite) static void AnimMeanLookEye_Step1(struct Sprite *sprite) { SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 16 - sprite->data[0])); - if (sprite->data[1]) sprite->data[0]--; else @@ -1353,7 +1346,6 @@ static void AnimMeanLookEye_Step3(struct Sprite *sprite) static void AnimMeanLookEye_Step4(struct Sprite *sprite) { SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[0], 16 - sprite->data[0])); - if (sprite->data[1]++ > 1) { sprite->data[0]--; @@ -1435,7 +1427,6 @@ void AnimSpikes(struct Sprite *sprite) InitSpritePosToAnimAttacker(sprite, TRUE); SetAverageBattlerPositions(gBattleAnimTarget, FALSE, &x, &y); - if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) gBattleAnimArgs[2] = -gBattleAnimArgs[2]; @@ -1443,7 +1434,6 @@ void AnimSpikes(struct Sprite *sprite) sprite->data[2] = x + gBattleAnimArgs[2]; sprite->data[4] = y + gBattleAnimArgs[3]; sprite->data[5] = -50; - InitAnimArcTranslation(sprite); sprite->callback = AnimSpikes_Step1; } @@ -1480,6 +1470,7 @@ void AnimLeer(struct Sprite *sprite) void AnimLetterZ(struct Sprite *sprite) { int var0; + if (sprite->data[0] == 0) { SetSpriteCoordsToAnimAttackerCoords(sprite); @@ -1510,7 +1501,6 @@ void AnimLetterZ(struct Sprite *sprite) sprite->data[4] += sprite->data[2]; sprite->pos2.x = sprite->data[3] / 2; sprite->pos2.y = Sin(var0 & 0xFF, 5) + (sprite->data[4] / 2); - if ((u16)(sprite->pos1.x + sprite->pos2.x) > 240) DestroyAnimSprite(sprite); } @@ -1549,9 +1539,7 @@ void AnimSpotlight(struct Sprite *sprite) gBattle_WIN0V = 0; SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); - InitSpritePosToAnimTarget(sprite, FALSE); - sprite->oam.objMode = ST_OAM_OBJ_WINDOW; sprite->invisible = 1; sprite->callback = AnimSpotlight_Step1; @@ -1610,14 +1598,13 @@ void AnimClappingHand(struct Sprite *sprite) { if (gBattleAnimArgs[3] == 0) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); } sprite->pos1.x += gBattleAnimArgs[0]; sprite->pos1.y += gBattleAnimArgs[1]; sprite->oam.tileNum += 16; - if (gBattleAnimArgs[2] == 0) { sprite->oam.matrixNum = ST_OAM_HFLIP; @@ -1631,7 +1618,6 @@ void AnimClappingHand(struct Sprite *sprite) } sprite->data[0] = gBattleAnimArgs[4]; - if (sprite->data[3] != 255) sprite->data[3] = gBattleAnimArgs[2]; @@ -1712,17 +1698,16 @@ void AnimRapidSpin(struct Sprite *sprite) { if (gBattleAnimArgs[0] == 0) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + gBattleAnimArgs[1]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); } else { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 0) + gBattleAnimArgs[1]; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 1); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X) + gBattleAnimArgs[1]; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y); } sprite->pos2.y = gBattleAnimArgs[2]; - sprite->data[0] = (sprite->pos2.y > gBattleAnimArgs[3]); sprite->data[1] = 0; sprite->data[2] = gBattleAnimArgs[4]; @@ -1736,7 +1721,6 @@ static void AnimRapidSpin_Step(struct Sprite *sprite) sprite->data[1] = (sprite->data[1] + sprite->data[2]) & 0xFF; sprite->pos2.x = gSineTable[sprite->data[1]] >> 4; sprite->pos2.y += sprite->data[3]; - if (sprite->data[0]) { if (sprite->pos2.y < sprite->data[4]) @@ -1782,7 +1766,6 @@ void AnimTask_RapinSpinMonElevation(u8 taskId) task->data[5] = gBattleAnimArgs[1]; task->data[6] = 0; task->data[7] = 0; - if (toBG2 == 1) { var3 = gBattle_BG1_X; @@ -1798,7 +1781,6 @@ void AnimTask_RapinSpinMonElevation(u8 taskId) task->data[9] = var4; task->data[10] = gBattleAnimArgs[2]; - if (!gBattleAnimArgs[2]) { task->data[11] = var4; @@ -1811,7 +1793,6 @@ void AnimTask_RapinSpinMonElevation(u8 taskId) } task->data[15] = 0; - i = task->data[2]; while (i <= task->data[3]) { @@ -1898,8 +1879,8 @@ void AnimTask_TormentAttacker(u8 taskId) task->data[0] = 0; task->data[1] = 0; - task->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - task->data[3] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + task->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + task->data[3] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); task->data[4] = 32; task->data[5] = -20; task->data[6] = 0; @@ -1990,7 +1971,6 @@ static void TormentAttacker_Step(u8 taskId) gSprites[i].data[1] = 6; StartSpriteAnim(&gSprites[i], 2); gSprites[i].callback = TormentAttacker_Callback; - if (++j == 6) break; } @@ -2040,8 +2020,8 @@ void AnimTriAttackTriangle(struct Sprite *sprite) sprite->pos2.x = 0; sprite->pos2.y = 0; sprite->data[0] = 20; - sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); - sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); sprite->callback = StartAnimLinearTranslation; } } @@ -2068,8 +2048,8 @@ void AnimBatonPassPokeball(struct Sprite *sprite) switch (sprite->data[0]) { case 0: - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); sprite->data[1] = 256; sprite->data[2] = 256; @@ -2224,7 +2204,7 @@ void AnimSwallowBlueOrb(struct Sprite *sprite) case 0: InitSpritePosToAnimAttacker(sprite, FALSE); sprite->data[1] = 0x900; - sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); sprite->data[0]++; break; case 1: @@ -2250,7 +2230,6 @@ void AnimTask_SwallowDeformMon(u8 taskId) } } -// case 2 quite different :/ void AnimTask_TransformMon(u8 taskId) { int i, j; @@ -2357,25 +2336,25 @@ void AnimTask_MorningSunLightBeam(u8 taskId) if (!IsContest()) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); - sub_80752A0(&animBg); - AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnim_MorningSunTilemap); - AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_MorningSunGfx, animBg.tilesOffset); - LoadCompressedPalette(gBattleAnim_MorningSunPal, animBg.paletteId * 16, 32); - if (IsContest()) - { - sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); + sub_80752A0(&animBg); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnim_MorningSunTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_MorningSunGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnim_MorningSunPal, animBg.paletteId * 16, 32); + if (IsContest()) + { + sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); gBattle_BG1_X = -56; gBattle_BG1_Y = 0; - } - else - { + } + else + { if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) gBattle_BG1_X = -135; else gBattle_BG1_X = -10; gBattle_BG1_Y = 0; - } + } gTasks[taskId].data[10] = gBattle_BG1_X; gTasks[taskId].data[11] = gBattle_BG1_Y; @@ -2447,8 +2426,8 @@ void AnimGreenStar(struct Sprite *sprite) if (xOffset > 31) xOffset = 32 - xOffset; - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0) + xOffset; - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1) + 32; + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X) + xOffset; + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y) + 32; sprite->data[1] = gBattleAnimArgs[0]; sprite->data[2] = gBattleAnimArgs[1]; @@ -2476,6 +2455,7 @@ void AnimGreenStar(struct Sprite *sprite) static void AnimGreenStar_Step1(struct Sprite *sprite) { s16 delta = sprite->data[3] + sprite->data[2]; + sprite->pos2.y -= delta >> 8; sprite->data[3] += sprite->data[2]; sprite->data[3] &= 0xFF; @@ -2538,16 +2518,16 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1); if (!IsContest()) SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); - - sub_80752A0(&animBg); - AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnim_MorningSunTilemap); - AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_MorningSunGfx, animBg.tilesOffset); - LoadCompressedPalette(gBattleAnim_MorningSunPal, animBg.paletteId * 16, 32); - + + sub_80752A0(&animBg); + AnimLoadCompressedBgTilemap(animBg.bgId, gBattleAnim_MorningSunTilemap); + AnimLoadCompressedBgGfx(animBg.bgId, gBattleAnim_MorningSunGfx, animBg.tilesOffset); + LoadCompressedPalette(gBattleAnim_MorningSunPal, animBg.paletteId * 16, 32); + if (IsContest()) { sub_80730C0(animBg.paletteId, animBg.bgTilemap, 0, 0); - gBattle_BG1_X = -56; + gBattle_BG1_X = -56; gBattle_BG1_Y = 0; } else @@ -2887,7 +2867,6 @@ static void AnimTask_FlailMovementStep(u8 taskId) SetSpriteRotScale(task->data[15], 0x100, 0x100, task->data[2]); SetBattlerSpriteYOffsetFromRotation(task->data[15]); gSprites[task->data[15]].pos2.x = -(((temp = task->data[2]) >= 0 ? task->data[2] : temp + 63) >> 6); - if (++task->data[1] > 8) { if (task->data[12]) @@ -3069,7 +3048,6 @@ void AnimFlatterSpotlight(struct Sprite *sprite) gBattle_WIN0V = 0; SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); - sprite->data[0] = gBattleAnimArgs[2]; InitSpritePosToAnimTarget(sprite, FALSE); sprite->oam.objMode = ST_OAM_OBJ_WINDOW; @@ -3166,59 +3144,56 @@ void AnimTask_RolePlaySilhouette(u8 taskId) s16 coord1, coord2; GetAnimBattlerSpriteId(ANIM_ATTACKER); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + isBackPic = 0; + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } - if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) - { - isBackPic = 0; - personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) - { - if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - else - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - } - else - { - species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; - } - - xOffset = 20; - priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); - } - else - { - isBackPic = 1; - personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) - { - if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - else - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); - } - else - { - species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; - } - - xOffset = -20; - priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); - } - - coord1 = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); - coord2 = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); - spriteId = sub_80768D0(species, isBackPic, 0, coord1 + xOffset, coord2, 5, personality, otId, gBattleAnimTarget, 1); + xOffset = 20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + else + { + isBackPic = 1; + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) + { + if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + else + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_SPECIES); + } + else + { + species = gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies; + } + + xOffset = -20; + priority = GetBattlerSpriteBGPriority(gBattleAnimAttacker); + } + coord1 = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + coord2 = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); + spriteId = sub_80768D0(species, isBackPic, 0, coord1 + xOffset, coord2, 5, personality, otId, gBattleAnimTarget, 1); gSprites[spriteId].oam.priority = priority; gSprites[spriteId].oam.objMode = ST_OAM_OBJ_BLEND; FillPalette(RGB_WHITE, (gSprites[spriteId].oam.paletteNum << 4) + 0x100, 32); gSprites[spriteId].oam.priority = priority; SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); - gTasks[taskId].data[0] = spriteId; gTasks[taskId].func = AnimTask_RolePlaySilhouetteStep1; } @@ -3242,6 +3217,7 @@ static void AnimTask_RolePlaySilhouetteStep1(u8 taskId) static void AnimTask_RolePlaySilhouetteStep2(u8 taskId) { u8 spriteId = gTasks[taskId].data[0]; + gTasks[taskId].data[10] -= 16; gTasks[taskId].data[11] += 128; gSprites[spriteId].oam.affineMode |= ST_OAM_AFFINE_DOUBLE_MASK; @@ -3437,6 +3413,7 @@ static void AnimTask_AcidArmorStep(u8 taskId) void AnimTask_DeepInhale(u8 taskId) { struct Task *task = &gTasks[taskId]; + task->data[0] = 0; task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); PrepareAffineAnimInTaskData(&gTasks[taskId], task->data[15], gDeepInhaleAffineAnimCmds); @@ -3446,8 +3423,8 @@ void AnimTask_DeepInhale(u8 taskId) static void AnimTask_DeepInhaleStep(u8 taskId) { u16 var0; - struct Task *task = &gTasks[taskId]; + var0 = task->data[0]; task->data[0]++; var0 -= 20; @@ -3827,17 +3804,7 @@ static void AnimTask_FacadeColorBlendStep(u8 taskId) void sub_80E2084(u8 taskId) { - sub_80BBA20(taskId, - 0, - 0x1A0, - gBattleAnimAttacker, - gBattleAnimArgs[0], - 10, - 2, - 30, - gCureBubblesGfx, - gCureBubblesTilemap, - gCureBubblesPal); + sub_80BBA20(taskId, 0, 0x1A0, gBattleAnimAttacker, gBattleAnimArgs[0], 10, 2, 30, gCureBubblesGfx, gCureBubblesTilemap, gCureBubblesPal); } // Moves a noise line from the mon. @@ -3893,9 +3860,9 @@ void AnimTask_GlareEyeDots(u8 taskId) { struct Task *task = &gTasks[taskId]; - task->data[5] = 12; - task->data[6] = 3; - task->data[7] = 0; + task->data[5] = 12; + task->data[6] = 3; + task->data[7] = 0; if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) task->data[11] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2) + GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_HEIGHT) / 4; @@ -4116,7 +4083,7 @@ void AnimSmellingSaltsHand(struct Sprite *sprite) sprite->oam.tileNum += 16; sprite->data[6] = gBattleAnimArgs[2]; sprite->data[7] = gBattleAnimArgs[1] == 0 ? -1 : 1; - sprite->pos1.y = GetBattlerSpriteCoord(battler, 3); + sprite->pos1.y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET); if (gBattleAnimArgs[1] == 0) { sprite->oam.matrixNum |= ST_OAM_HFLIP; @@ -4231,12 +4198,12 @@ void AnimSmellingSaltExclamation(struct Sprite *sprite) { if (gBattleAnimArgs[0] == ANIM_ATTACKER) { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); sprite->pos1.y = GetBattlerSpriteCoordAttr(gBattleAnimAttacker, BATTLER_COORD_ATTR_TOP); } else { - sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); sprite->pos1.y = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_TOP); } @@ -4373,22 +4340,22 @@ void AnimTask_HelpingHandAttackerMovement(u8 taskId) struct Task *task = &gTasks[taskId]; task->data[15] = GetAnimBattlerSpriteId(ANIM_ATTACKER); - if (IsDoubleBattle() == TRUE) - { - int x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); - int y = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimAttacker), 0); - if (x > y) - task->data[14] = 1; - else - task->data[14] = -1; - } - else - { - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - task->data[14] = -1; - else - task->data[14] = 1; - } + if (IsDoubleBattle() == TRUE) + { + int x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + int y = GetBattlerSpriteCoord(BATTLE_PARTNER(gBattleAnimAttacker), BATTLER_COORD_X); + if (x > y) + task->data[14] = 1; + else + task->data[14] = -1; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + task->data[14] = -1; + else + task->data[14] = 1; + } task->func = AnimTask_HelpingHandAttackerMovementStep; } @@ -4510,24 +4477,24 @@ static void AnimForesightMagnifyingGlassStep(struct Sprite *sprite) sprite->data[6] = 0; case 0: case 4: - x = GetBattlerSpriteCoordAttr(sprite->data[7], 5) - 4; - y = GetBattlerSpriteCoordAttr(sprite->data[7], 3) - 4; + x = GetBattlerSpriteCoordAttr(sprite->data[7], BATTLER_COORD_ATTR_RIGHT) - 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], BATTLER_COORD_ATTR_BOTTOM) - 4; break; case 1: - x = GetBattlerSpriteCoordAttr(sprite->data[7], 5) - 4; - y = GetBattlerSpriteCoordAttr(sprite->data[7], 2) + 4; + x = GetBattlerSpriteCoordAttr(sprite->data[7], BATTLER_COORD_ATTR_RIGHT) - 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], BATTLER_COORD_ATTR_TOP) + 4; break; case 2: - x = GetBattlerSpriteCoordAttr(sprite->data[7], 4) + 4; - y = GetBattlerSpriteCoordAttr(sprite->data[7], 3) - 4; + x = GetBattlerSpriteCoordAttr(sprite->data[7], BATTLER_COORD_ATTR_LEFT) + 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], BATTLER_COORD_ATTR_BOTTOM) - 4; break; case 3: - x = GetBattlerSpriteCoordAttr(sprite->data[7], 4) + 4; - y = GetBattlerSpriteCoordAttr(sprite->data[7], 2) - 4; + x = GetBattlerSpriteCoordAttr(sprite->data[7], BATTLER_COORD_ATTR_LEFT) + 4; + y = GetBattlerSpriteCoordAttr(sprite->data[7], BATTLER_COORD_ATTR_TOP) - 4; break; case 5: - x = GetBattlerSpriteCoord(sprite->data[7], 2); - y = GetBattlerSpriteCoord(sprite->data[7], 3); + x = GetBattlerSpriteCoord(sprite->data[7], BATTLER_COORD_X_2); + y = GetBattlerSpriteCoord(sprite->data[7], BATTLER_COORD_Y_PIC_OFFSET); break; } @@ -4625,8 +4592,8 @@ static void AnimMeteorMashStarStep(struct Sprite *sprite) // arg 4: duration void AnimMeteorMashStar(struct Sprite *sprite) { - s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); // unused local variable - s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); // unused local variable + s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); + s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_PLAYER) { @@ -4752,7 +4719,7 @@ void AnimBlockX(struct Sprite *sprite) y = -96; } - sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); sprite->pos2.y = y; sprite->callback = AnimBlockXStep; } @@ -4880,6 +4847,7 @@ static void AnimTask_OdorSleuthMovementWaitFinish(u8 taskId) static void MoveOdorSleuthClone(struct Sprite *sprite) { int zero = 0; + if (++sprite->data[1] > 1) { sprite->data[1] = 0; @@ -4931,8 +4899,8 @@ void AnimTask_GetReturnPowerLevel(u8 taskId) // Makes the mon run out of screen, run past the opposing mon, and return to its original position. // No args. -/* -attempt.. +#ifdef NONMATCHING +// `species` variable getting loaded into r6 instead of r5 void AnimTask_SnatchOpposingMonMove(u8 taskId) { u8 spriteId, spriteId2; @@ -4940,11 +4908,9 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) u32 otId; u16 species; u8 subpriority; - //bool8 isBackPic; + bool8 isBackPic; s16 x; - u16 tSpecies; - switch (gTasks[taskId].data[0]) { case 0: @@ -4964,174 +4930,32 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) } break; case 1: - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - { - personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - - tSpecies = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - if (tSpecies == SPECIES_NONE) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; - //isBackPic = FALSE; - //x = 272; - spriteId = sub_80768D0(species, FALSE, 0, 272, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); - } - else - { - personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - - tSpecies = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - if (tSpecies == SPECIES_NONE) - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; - //isBackPic = TRUE; - //x = -32; - spriteId = sub_80768D0(species, TRUE, 0, -32, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); - } - - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) - BlendPalette((gSprites[spriteId].oam.paletteNum * 16) | 0x100, 16, 6, RGB_WHITE); - - gTasks[taskId].data[15] = spriteId; - gTasks[taskId].data[0]++; - break; - case 2: - spriteId2 = gTasks[taskId].data[15]; - gTasks[taskId].data[1] += 0x800; if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - gSprites[spriteId2].pos2.x -= (gTasks[taskId].data[1] >> 8); - else - gSprites[spriteId2].pos2.x += (gTasks[taskId].data[1] >> 8); - - gTasks[taskId].data[1] &= 0xFF; - x = gSprites[spriteId2].pos1.x + gSprites[spriteId2].pos2.x; - if (gTasks[taskId].data[14] == 0) { - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - { - if (x < GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X)) - { - gTasks[taskId].data[14]++; - gBattleAnimArgs[7] = 0xFFFF; - } - } + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); else - { - if (x > GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X)) - { - gTasks[taskId].data[14]++; - gBattleAnimArgs[7] = 0xFFFF; - } - } - } - - if ((u16)(x + 32) > 304) - { - gTasks[taskId].data[1] = 0; - gTasks[taskId].data[0]++; - } - break; - case 3: - spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); - spriteId2 = gTasks[taskId].data[15]; - DestroySpriteAndFreeResources_(&gSprites[spriteId2]); - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - gSprites[spriteId].pos2.x = -gSprites[spriteId].pos1.x - 32; - else - gSprites[spriteId].pos2.x = 272 - gSprites[spriteId].pos1.x; + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - gTasks[taskId].data[0]++; - break; - case 4: - spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); - gTasks[taskId].data[1] += 0x800; - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - { - gSprites[spriteId].pos2.x += (gTasks[taskId].data[1] >> 8); - if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x >= GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X)) - gSprites[spriteId].pos2.x = 0; + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; + isBackPic = FALSE; + x = 272; } else { - gSprites[spriteId].pos2.x -= (gTasks[taskId].data[1] >> 8); - if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x <= GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X)) - gSprites[spriteId].pos2.x = 0; - } - - gTasks[taskId].data[1] = (u8)gTasks[taskId].data[1]; - if (gSprites[spriteId].pos2.x == 0) - DestroyAnimVisualTask(taskId); - break; - } -} -*/ - -#ifdef NONMATCHING -// `species` variable getting loaded into r6 instead of r5 -//https://cexplore.karathan.at/z/0gMuxf -void AnimTask_SnatchOpposingMonMove(u8 taskId) -{ - u8 spriteId, spriteId2; - u32 personality; - u32 otId; - u16 species; - u8 subpriority; - bool8 isBackPic; - s16 x; - - switch (gTasks[taskId].data[0]) - { - case 0: - spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); - gTasks[taskId].data[1] += 0x800; - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - gSprites[spriteId].pos2.x += (gTasks[taskId].data[1] >> 8); - else - gSprites[spriteId].pos2.x -= (gTasks[taskId].data[1] >> 8); + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - gTasks[taskId].data[1] &= 0xFF; - x = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x; - if ((u16)(x + 32) > 304) - { - gTasks[taskId].data[1] = 0; - gTasks[taskId].data[0]++; + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + isBackPic = TRUE; + x = -32; } - break; - case 1: - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) - { - personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; - isBackPic = FALSE; - x = 272; - } - else - { - personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; - isBackPic = TRUE; - x = -32; - } spriteId2 = sub_80768D0(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) @@ -5213,653 +5037,653 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) NAKED void AnimTask_SnatchOpposingMonMove(u8 taskId) { - asm_unified("\tpush {r4-r7,lr}\n" - "\tmov r7, r10\n" - "\tmov r6, r9\n" - "\tmov r5, r8\n" - "\tpush {r5-r7}\n" - "\tsub sp, 0x1C\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tmov r8, r0\n" - "\tldr r1, _080E395C @ =gTasks\n" - "\tlsls r0, 2\n" - "\tadd r0, r8\n" - "\tlsls r0, 3\n" - "\tadds r0, r1\n" - "\tmovs r1, 0x8\n" - "\tldrsh r0, [r0, r1]\n" - "\tcmp r0, 0x4\n" - "\tbls _080E3952\n" - "\tb _080E3E6C\n" - "_080E3952:\n" - "\tlsls r0, 2\n" - "\tldr r1, _080E3960 @ =_080E3964\n" - "\tadds r0, r1\n" - "\tldr r0, [r0]\n" - "\tmov pc, r0\n" - "\t.align 2, 0\n" - "_080E395C: .4byte gTasks\n" - "_080E3960: .4byte _080E3964\n" - "\t.align 2, 0\n" - "_080E3964:\n" - "\t.4byte _080E3978\n" - "\t.4byte _080E3A2C\n" - "\t.4byte _080E3BEC\n" - "\t.4byte _080E3D0C\n" - "\t.4byte _080E3D90\n" - "_080E3978:\n" - "\tmovs r0, 0\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tlsls r0, 24\n" - "\tlsrs r7, r0, 24\n" - "\tldr r1, _080E39C4 @ =gTasks\n" - "\tmov r2, r8\n" - "\tlsls r4, r2, 2\n" - "\tadds r0, r4, r2\n" - "\tlsls r0, 3\n" - "\tadds r6, r0, r1\n" - "\tmovs r3, 0x80\n" - "\tlsls r3, 4\n" - "\tadds r0, r3, 0\n" - "\tldrh r1, [r6, 0xA]\n" - "\tadds r0, r1\n" - "\tstrh r0, [r6, 0xA]\n" - "\tldr r0, _080E39C8 @ =gBattleAnimAttacker\n" - "\tldrb r0, [r0]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tmov r9, r4\n" - "\tcmp r0, 0\n" - "\tbne _080E39D0\n" - "\tldr r2, _080E39CC @ =gSprites\n" - "\tlsls r3, r7, 4\n" - "\tadds r1, r3, r7\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tldrh r0, [r6, 0xA]\n" - "\tlsls r0, 16\n" - "\tasrs r0, 24\n" - "\tldrh r4, [r1, 0x24]\n" - "\tadds r0, r4\n" - "\tstrh r0, [r1, 0x24]\n" - "\tb _080E39EA\n" - "\t.align 2, 0\n" - "_080E39C4: .4byte gTasks\n" - "_080E39C8: .4byte gBattleAnimAttacker\n" - "_080E39CC: .4byte gSprites\n" - "_080E39D0:\n" - "\tldr r3, _080E3A24 @ =gSprites\n" - "\tlsls r4, r7, 4\n" - "\tadds r2, r4, r7\n" - "\tlsls r2, 2\n" - "\tadds r2, r3\n" - "\tldrh r1, [r6, 0xA]\n" - "\tlsls r1, 16\n" - "\tasrs r1, 24\n" - "\tldrh r0, [r2, 0x24]\n" - "\tsubs r0, r1\n" - "\tstrh r0, [r2, 0x24]\n" - "\tadds r2, r3, 0\n" - "\tadds r3, r4, 0\n" - "_080E39EA:\n" - "\tldr r1, _080E3A28 @ =gTasks\n" - "\tmov r0, r9\n" - "\tadd r0, r8\n" - "\tlsls r0, 3\n" - "\tadds r4, r0, r1\n" - "\tldrb r0, [r4, 0xA]\n" - "\tstrh r0, [r4, 0xA]\n" - "\tadds r1, r3, r7\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tldrh r0, [r1, 0x24]\n" - "\tldrh r1, [r1, 0x20]\n" - "\tadds r0, r1\n" - "\tlsls r0, 16\n" - "\tmovs r1, 0x80\n" - "\tlsls r1, 14\n" - "\tadds r0, r1\n" - "\tmovs r1, 0x98\n" - "\tlsls r1, 17\n" - "\tcmp r0, r1\n" - "\tbhi _080E3A16\n" - "\tb _080E3E6C\n" - "_080E3A16:\n" - "\tmovs r0, 0\n" - "\tstrh r0, [r4, 0xA]\n" - "\tldrh r0, [r4, 0x8]\n" - "\tadds r0, 0x1\n" - "\tstrh r0, [r4, 0x8]\n" - "\tb _080E3E6C\n" - "\t.align 2, 0\n" - "_080E3A24: .4byte gSprites\n" - "_080E3A28: .4byte gTasks\n" - "_080E3A2C:\n" - "\tldr r4, _080E3A90 @ =gBattleAnimAttacker\n" - "\tldrb r0, [r4]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tcmp r0, 0\n" - "\tbne _080E3ACC\n" - "\tldr r7, _080E3A94 @ =gBattlerPartyIndexes\n" - "\tldrb r0, [r4]\n" - "\tlsls r0, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmovs r6, 0x64\n" - "\tmuls r0, r6\n" - "\tldr r5, _080E3A98 @ =gPlayerParty\n" - "\tadds r0, r5\n" - "\tmovs r1, 0\n" - "\tbl GetMonData\n" - "\tmov r10, r0\n" - "\tldrb r0, [r4]\n" - "\tlsls r0, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmuls r0, r6\n" - "\tadds r0, r5\n" - "\tmovs r1, 0x1\n" - "\tbl GetMonData\n" - "\tmov r9, r0\n" - "\tldr r0, _080E3A9C @ =gBattleSpritesDataPtr\n" - "\tldr r0, [r0]\n" - "\tldrb r2, [r4]\n" - "\tldr r1, [r0]\n" - "\tlsls r0, r2, 2\n" - "\tadds r1, r0, r1\n" - "\tldrh r0, [r1, 0x2]\n" - "\tcmp r0, 0\n" - "\tbne _080E3AA0\n" - "\tlsls r0, r2, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmuls r0, r6\n" - "\tadds r0, r5\n" - "\tmovs r1, 0xB\n" - "\tbl GetMonData\n" - "\tlsls r0, 16\n" - "\tlsrs r5, r0, 16\n" - "\tb _080E3AA2\n" - "\t.align 2, 0\n" - "_080E3A90: .4byte gBattleAnimAttacker\n" - "_080E3A94: .4byte gBattlerPartyIndexes\n" - "_080E3A98: .4byte gPlayerParty\n" - "_080E3A9C: .4byte gBattleSpritesDataPtr\n" - "_080E3AA0:\n" - "\tldrh r5, [r1, 0x2]\n" - "_080E3AA2:\n" - "\tmovs r0, 0x1\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tldr r2, _080E3AC8 @ =gSprites\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tlsls r1, r0, 4\n" - "\tadds r1, r0\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tadds r1, 0x43\n" - "\tldrb r0, [r1]\n" - "\tadds r0, 0x1\n" - "\tlsls r0, 24\n" - "\tlsrs r4, r0, 24\n" - "\tmovs r7, 0\n" - "\tmovs r6, 0x88\n" - "\tlsls r6, 1\n" - "\tb _080E3B54\n" - "\t.align 2, 0\n" - "_080E3AC8: .4byte gSprites\n" - "_080E3ACC:\n" - "\tldr r7, _080E3B24 @ =gBattlerPartyIndexes\n" - "\tldrb r0, [r4]\n" - "\tlsls r0, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmovs r6, 0x64\n" - "\tmuls r0, r6\n" - "\tldr r5, _080E3B28 @ =gEnemyParty\n" - "\tadds r0, r5\n" - "\tmovs r1, 0\n" - "\tbl GetMonData\n" - "\tmov r10, r0\n" - "\tldrb r0, [r4]\n" - "\tlsls r0, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmuls r0, r6\n" - "\tadds r0, r5\n" - "\tmovs r1, 0x1\n" - "\tbl GetMonData\n" - "\tmov r9, r0\n" - "\tldr r0, _080E3B2C @ =gBattleSpritesDataPtr\n" - "\tldr r0, [r0]\n" - "\tldrb r2, [r4]\n" - "\tldr r1, [r0]\n" - "\tlsls r0, r2, 2\n" - "\tadds r1, r0, r1\n" - "\tldrh r0, [r1, 0x2]\n" - "\tcmp r0, 0\n" - "\tbne _080E3B30\n" - "\tlsls r0, r2, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmuls r0, r6\n" - "\tadds r0, r5\n" - "\tmovs r1, 0xB\n" - "\tbl GetMonData\n" - "\tlsls r0, 16\n" - "\tlsrs r5, r0, 16\n" - "\tb _080E3B32\n" - "\t.align 2, 0\n" - "_080E3B24: .4byte gBattlerPartyIndexes\n" - "_080E3B28: .4byte gEnemyParty\n" - "_080E3B2C: .4byte gBattleSpritesDataPtr\n" - "_080E3B30:\n" - "\tldrh r5, [r1, 0x2]\n" - "_080E3B32:\n" - "\tmovs r0, 0x1\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tldr r2, _080E3BD0 @ =gSprites\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tlsls r1, r0, 4\n" - "\tadds r1, r0\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tadds r1, 0x43\n" - "\tldrb r0, [r1]\n" - "\tsubs r0, 0x1\n" - "\tlsls r0, 24\n" - "\tlsrs r4, r0, 24\n" - "\tmovs r7, 0x1\n" - "\tldr r6, _080E3BD4 @ =0x0000ffe0\n" - "_080E3B54:\n" - "\tldr r0, _080E3BD8 @ =gBattleAnimTarget\n" - "\tldrb r0, [r0]\n" - "\tmovs r1, 0x1\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tlsls r3, r6, 16\n" - "\tasrs r3, 16\n" - "\tstr r0, [sp]\n" - "\tstr r4, [sp, 0x4]\n" - "\tmov r2, r10\n" - "\tstr r2, [sp, 0x8]\n" - "\tmov r4, r9\n" - "\tstr r4, [sp, 0xC]\n" - "\tldr r4, _080E3BDC @ =gBattleAnimAttacker\n" - "\tldrb r0, [r4]\n" - "\tstr r0, [sp, 0x10]\n" - "\tmovs r0, 0\n" - "\tstr r0, [sp, 0x14]\n" - "\tadds r0, r5, 0\n" - "\tadds r1, r7, 0\n" - "\tmovs r2, 0\n" - "\tbl sub_80768D0\n" - "\tlsls r0, 24\n" - "\tlsrs r5, r0, 24\n" - "\tldr r0, _080E3BE0 @ =gBattleSpritesDataPtr\n" - "\tldr r1, [r0]\n" - "\tldrb r0, [r4]\n" - "\tldr r1, [r1]\n" - "\tlsls r0, 2\n" - "\tadds r0, r1\n" - "\tldrh r0, [r0, 0x2]\n" - "\tcmp r0, 0\n" - "\tbeq _080E3BBE\n" - "\tldr r1, _080E3BD0 @ =gSprites\n" - "\tlsls r0, r5, 4\n" - "\tadds r0, r5\n" - "\tlsls r0, 2\n" - "\tadds r0, r1\n" - "\tldrb r0, [r0, 0x5]\n" - "\tlsrs r0, 4\n" - "\tlsls r0, 4\n" - "\tmovs r2, 0x80\n" - "\tlsls r2, 1\n" - "\tadds r1, r2, 0\n" - "\torrs r0, r1\n" - "\tldr r3, _080E3BE4 @ =0x00007fff\n" - "\tmovs r1, 0x10\n" - "\tmovs r2, 0x6\n" - "\tbl BlendPalette\n" - "_080E3BBE:\n" - "\tldr r0, _080E3BE8 @ =gTasks\n" - "\tmov r3, r8\n" - "\tlsls r1, r3, 2\n" - "\tadd r1, r8\n" - "\tlsls r1, 3\n" - "\tadds r1, r0\n" - "\tstrh r5, [r1, 0x26]\n" - "\tb _080E3D82\n" - "\t.align 2, 0\n" - "_080E3BD0: .4byte gSprites\n" - "_080E3BD4: .4byte 0x0000ffe0\n" - "_080E3BD8: .4byte gBattleAnimTarget\n" - "_080E3BDC: .4byte gBattleAnimAttacker\n" - "_080E3BE0: .4byte gBattleSpritesDataPtr\n" - "_080E3BE4: .4byte 0x00007fff\n" - "_080E3BE8: .4byte gTasks\n" - "_080E3BEC:\n" - "\tldr r1, _080E3C38 @ =gTasks\n" - "\tmov r0, r8\n" - "\tlsls r4, r0, 2\n" - "\tadds r0, r4, r0\n" - "\tlsls r0, 3\n" - "\tadds r6, r0, r1\n" - "\tldrh r0, [r6, 0x26]\n" - "\tlsls r0, 24\n" - "\tlsrs r5, r0, 24\n" - "\tmovs r1, 0x80\n" - "\tlsls r1, 4\n" - "\tadds r0, r1, 0\n" - "\tldrh r2, [r6, 0xA]\n" - "\tadds r0, r2\n" - "\tstrh r0, [r6, 0xA]\n" - "\tldr r0, _080E3C3C @ =gBattleAnimAttacker\n" - "\tldrb r0, [r0]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tmov r9, r4\n" - "\tcmp r0, 0\n" - "\tbne _080E3C44\n" - "\tldr r3, _080E3C40 @ =gSprites\n" - "\tlsls r4, r5, 4\n" - "\tadds r2, r4, r5\n" - "\tlsls r2, 2\n" - "\tadds r2, r3\n" - "\tldrh r1, [r6, 0xA]\n" - "\tlsls r1, 16\n" - "\tasrs r1, 24\n" - "\tldrh r0, [r2, 0x24]\n" - "\tsubs r0, r1\n" - "\tstrh r0, [r2, 0x24]\n" - "\tadds r2, r3, 0\n" - "\tadds r3, r4, 0\n" - "\tb _080E3C5A\n" - "\t.align 2, 0\n" - "_080E3C38: .4byte gTasks\n" - "_080E3C3C: .4byte gBattleAnimAttacker\n" - "_080E3C40: .4byte gSprites\n" - "_080E3C44:\n" - "\tldr r2, _080E3CA8 @ =gSprites\n" - "\tlsls r3, r5, 4\n" - "\tadds r1, r3, r5\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tldrh r0, [r6, 0xA]\n" - "\tlsls r0, 16\n" - "\tasrs r0, 24\n" - "\tldrh r4, [r1, 0x24]\n" - "\tadds r0, r4\n" - "\tstrh r0, [r1, 0x24]\n" - "_080E3C5A:\n" - "\tldr r1, _080E3CAC @ =gTasks\n" - "\tmov r0, r9\n" - "\tadd r0, r8\n" - "\tlsls r0, 3\n" - "\tadds r6, r0, r1\n" - "\tldrb r0, [r6, 0xA]\n" - "\tstrh r0, [r6, 0xA]\n" - "\tadds r1, r3, r5\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tldrh r0, [r1, 0x24]\n" - "\tldrh r1, [r1, 0x20]\n" - "\tadds r0, r1\n" - "\tlsls r0, 16\n" - "\tlsrs r5, r0, 16\n" - "\tmovs r1, 0x24\n" - "\tldrsh r0, [r6, r1]\n" - "\tcmp r0, 0\n" - "\tbne _080E3CDA\n" - "\tldr r0, _080E3CB0 @ =gBattleAnimAttacker\n" - "\tldrb r0, [r0]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tcmp r0, 0\n" - "\tbne _080E3CB8\n" - "\tlsls r4, r5, 16\n" - "\tasrs r4, 16\n" - "\tldr r0, _080E3CB4 @ =gBattleAnimTarget\n" - "\tldrb r0, [r0]\n" - "\tmovs r1, 0\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tcmp r4, r0\n" - "\tbge _080E3CDA\n" - "\tb _080E3CCE\n" - "\t.align 2, 0\n" - "_080E3CA8: .4byte gSprites\n" - "_080E3CAC: .4byte gTasks\n" - "_080E3CB0: .4byte gBattleAnimAttacker\n" - "_080E3CB4: .4byte gBattleAnimTarget\n" - "_080E3CB8:\n" - "\tlsls r4, r5, 16\n" - "\tasrs r4, 16\n" - "\tldr r0, _080E3CFC @ =gBattleAnimTarget\n" - "\tldrb r0, [r0]\n" - "\tmovs r1, 0\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tcmp r4, r0\n" - "\tble _080E3CDA\n" - "_080E3CCE:\n" - "\tldrh r0, [r6, 0x24]\n" - "\tadds r0, 0x1\n" - "\tstrh r0, [r6, 0x24]\n" - "\tldr r1, _080E3D00 @ =gBattleAnimArgs\n" - "\tldr r0, _080E3D04 @ =0x0000ffff\n" - "\tstrh r0, [r1, 0xE]\n" - "_080E3CDA:\n" - "\tlsls r0, r5, 16\n" - "\tmovs r2, 0x80\n" - "\tlsls r2, 14\n" - "\tadds r0, r2\n" - "\tmovs r1, 0x98\n" - "\tlsls r1, 17\n" - "\tcmp r0, r1\n" - "\tbhi _080E3CEC\n" - "\tb _080E3E6C\n" - "_080E3CEC:\n" - "\tldr r0, _080E3D08 @ =gTasks\n" - "\tmov r1, r9\n" - "\tadd r1, r8\n" - "\tlsls r1, 3\n" - "\tadds r1, r0\n" - "\tmovs r0, 0\n" - "\tstrh r0, [r1, 0xA]\n" - "\tb _080E3D82\n" - "\t.align 2, 0\n" - "_080E3CFC: .4byte gBattleAnimTarget\n" - "_080E3D00: .4byte gBattleAnimArgs\n" - "_080E3D04: .4byte 0x0000ffff\n" - "_080E3D08: .4byte gTasks\n" - "_080E3D0C:\n" - "\tmovs r0, 0\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tlsls r0, 24\n" - "\tlsrs r7, r0, 24\n" - "\tldr r1, _080E3D58 @ =gTasks\n" - "\tmov r3, r8\n" - "\tlsls r4, r3, 2\n" - "\tadds r0, r4, r3\n" - "\tlsls r0, 3\n" - "\tadds r0, r1\n" - "\tldrh r0, [r0, 0x26]\n" - "\tlsls r0, 24\n" - "\tlsrs r5, r0, 24\n" - "\tlsls r0, r5, 4\n" - "\tadds r0, r5\n" - "\tlsls r0, 2\n" - "\tldr r5, _080E3D5C @ =gSprites\n" - "\tadds r0, r5\n" - "\tbl DestroySpriteAndFreeResources_\n" - "\tldr r0, _080E3D60 @ =gBattleAnimAttacker\n" - "\tldrb r0, [r0]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tmov r9, r4\n" - "\tcmp r0, 0\n" - "\tbne _080E3D64\n" - "\tlsls r1, r7, 4\n" - "\tadds r1, r7\n" - "\tlsls r1, 2\n" - "\tadds r1, r5\n" - "\tldrh r0, [r1, 0x20]\n" - "\tnegs r0, r0\n" - "\tsubs r0, 0x20\n" - "\tstrh r0, [r1, 0x24]\n" - "\tb _080E3D78\n" - "\t.align 2, 0\n" - "_080E3D58: .4byte gTasks\n" - "_080E3D5C: .4byte gSprites\n" - "_080E3D60: .4byte gBattleAnimAttacker\n" - "_080E3D64:\n" - "\tlsls r0, r7, 4\n" - "\tadds r0, r7\n" - "\tlsls r0, 2\n" - "\tadds r0, r5\n" - "\tldrh r2, [r0, 0x20]\n" - "\tmovs r4, 0x88\n" - "\tlsls r4, 1\n" - "\tadds r1, r4, 0\n" - "\tsubs r1, r2\n" - "\tstrh r1, [r0, 0x24]\n" - "_080E3D78:\n" - "\tldr r0, _080E3D8C @ =gTasks\n" - "\tmov r1, r9\n" - "\tadd r1, r8\n" - "\tlsls r1, 3\n" - "\tadds r1, r0\n" - "_080E3D82:\n" - "\tldrh r0, [r1, 0x8]\n" - "\tadds r0, 0x1\n" - "\tstrh r0, [r1, 0x8]\n" - "\tb _080E3E6C\n" - "\t.align 2, 0\n" - "_080E3D8C: .4byte gTasks\n" - "_080E3D90:\n" - "\tmovs r0, 0\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tlsls r0, 24\n" - "\tlsrs r7, r0, 24\n" - "\tldr r1, _080E3E04 @ =gTasks\n" - "\tmov r0, r8\n" - "\tlsls r4, r0, 2\n" - "\tadds r0, r4, r0\n" - "\tlsls r0, 3\n" - "\tadds r2, r0, r1\n" - "\tmovs r1, 0x80\n" - "\tlsls r1, 4\n" - "\tadds r0, r1, 0\n" - "\tldrh r3, [r2, 0xA]\n" - "\tadds r0, r3\n" - "\tstrh r0, [r2, 0xA]\n" - "\tldr r0, _080E3E08 @ =gBattleAnimAttacker\n" - "\tmov r10, r0\n" - "\tldrb r0, [r0]\n" - "\tstr r2, [sp, 0x18]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tmov r9, r4\n" - "\tldr r2, [sp, 0x18]\n" - "\tcmp r0, 0\n" - "\tbne _080E3E10\n" - "\tldr r1, _080E3E0C @ =gSprites\n" - "\tlsls r5, r7, 4\n" - "\tadds r0, r5, r7\n" - "\tlsls r0, 2\n" - "\tadds r6, r0, r1\n" - "\tldrh r0, [r2, 0xA]\n" - "\tlsls r0, 16\n" - "\tasrs r0, 24\n" - "\tldrh r1, [r6, 0x24]\n" - "\tadds r0, r1\n" - "\tstrh r0, [r6, 0x24]\n" - "\tmovs r2, 0x24\n" - "\tldrsh r4, [r6, r2]\n" - "\tmovs r3, 0x20\n" - "\tldrsh r0, [r6, r3]\n" - "\tadds r4, r0\n" - "\tmov r1, r10\n" - "\tldrb r0, [r1]\n" - "\tmovs r1, 0\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tadds r3, r5, 0\n" - "\tcmp r4, r0\n" - "\tblt _080E3E48\n" - "\tmovs r2, 0\n" - "\tstrh r2, [r6, 0x24]\n" - "\tb _080E3E48\n" - "\t.align 2, 0\n" - "_080E3E04: .4byte gTasks\n" - "_080E3E08: .4byte gBattleAnimAttacker\n" - "_080E3E0C: .4byte gSprites\n" - "_080E3E10:\n" - "\tldr r1, _080E3E7C @ =gSprites\n" - "\tlsls r5, r7, 4\n" - "\tadds r0, r5, r7\n" - "\tlsls r0, 2\n" - "\tadds r6, r0, r1\n" - "\tldrh r1, [r2, 0xA]\n" - "\tlsls r1, 16\n" - "\tasrs r1, 24\n" - "\tldrh r0, [r6, 0x24]\n" - "\tsubs r0, r1\n" - "\tstrh r0, [r6, 0x24]\n" - "\tmovs r3, 0x24\n" - "\tldrsh r4, [r6, r3]\n" - "\tmovs r1, 0x20\n" - "\tldrsh r0, [r6, r1]\n" - "\tadds r4, r0\n" - "\tmov r2, r10\n" - "\tldrb r0, [r2]\n" - "\tmovs r1, 0\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tadds r3, r5, 0\n" - "\tcmp r4, r0\n" - "\tbgt _080E3E48\n" - "\tmovs r4, 0\n" - "\tstrh r4, [r6, 0x24]\n" - "_080E3E48:\n" - "\tldr r1, _080E3E80 @ =gTasks\n" - "\tmov r0, r9\n" - "\tadd r0, r8\n" - "\tlsls r0, 3\n" - "\tadds r0, r1\n" - "\tldrb r1, [r0, 0xA]\n" - "\tstrh r1, [r0, 0xA]\n" - "\tldr r1, _080E3E7C @ =gSprites\n" - "\tadds r0, r3, r7\n" - "\tlsls r0, 2\n" - "\tadds r0, r1\n" - "\tmovs r1, 0x24\n" - "\tldrsh r0, [r0, r1]\n" - "\tcmp r0, 0\n" - "\tbne _080E3E6C\n" - "\tmov r0, r8\n" - "\tbl DestroyAnimVisualTask\n" - "_080E3E6C:\n" - "\tadd sp, 0x1C\n" - "\tpop {r3-r5}\n" - "\tmov r8, r3\n" - "\tmov r9, r4\n" - "\tmov r10, r5\n" - "\tpop {r4-r7}\n" - "\tpop {r0}\n" - "\tbx r0\n" - "\t.align 2, 0\n" - "_080E3E7C: .4byte gSprites\n" - "_080E3E80: .4byte gTasks\n"); + asm_unified("\tpush {r4-r7,lr}\n" + "\tmov r7, r10\n" + "\tmov r6, r9\n" + "\tmov r5, r8\n" + "\tpush {r5-r7}\n" + "\tsub sp, 0x1C\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tmov r8, r0\n" + "\tldr r1, _080E395C @ =gTasks\n" + "\tlsls r0, 2\n" + "\tadd r0, r8\n" + "\tlsls r0, 3\n" + "\tadds r0, r1\n" + "\tmovs r1, 0x8\n" + "\tldrsh r0, [r0, r1]\n" + "\tcmp r0, 0x4\n" + "\tbls _080E3952\n" + "\tb _080E3E6C\n" + "_080E3952:\n" + "\tlsls r0, 2\n" + "\tldr r1, _080E3960 @ =_080E3964\n" + "\tadds r0, r1\n" + "\tldr r0, [r0]\n" + "\tmov pc, r0\n" + "\t.align 2, 0\n" + "_080E395C: .4byte gTasks\n" + "_080E3960: .4byte _080E3964\n" + "\t.align 2, 0\n" + "_080E3964:\n" + "\t.4byte _080E3978\n" + "\t.4byte _080E3A2C\n" + "\t.4byte _080E3BEC\n" + "\t.4byte _080E3D0C\n" + "\t.4byte _080E3D90\n" + "_080E3978:\n" + "\tmovs r0, 0\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tlsls r0, 24\n" + "\tlsrs r7, r0, 24\n" + "\tldr r1, _080E39C4 @ =gTasks\n" + "\tmov r2, r8\n" + "\tlsls r4, r2, 2\n" + "\tadds r0, r4, r2\n" + "\tlsls r0, 3\n" + "\tadds r6, r0, r1\n" + "\tmovs r3, 0x80\n" + "\tlsls r3, 4\n" + "\tadds r0, r3, 0\n" + "\tldrh r1, [r6, 0xA]\n" + "\tadds r0, r1\n" + "\tstrh r0, [r6, 0xA]\n" + "\tldr r0, _080E39C8 @ =gBattleAnimAttacker\n" + "\tldrb r0, [r0]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tmov r9, r4\n" + "\tcmp r0, 0\n" + "\tbne _080E39D0\n" + "\tldr r2, _080E39CC @ =gSprites\n" + "\tlsls r3, r7, 4\n" + "\tadds r1, r3, r7\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tldrh r0, [r6, 0xA]\n" + "\tlsls r0, 16\n" + "\tasrs r0, 24\n" + "\tldrh r4, [r1, 0x24]\n" + "\tadds r0, r4\n" + "\tstrh r0, [r1, 0x24]\n" + "\tb _080E39EA\n" + "\t.align 2, 0\n" + "_080E39C4: .4byte gTasks\n" + "_080E39C8: .4byte gBattleAnimAttacker\n" + "_080E39CC: .4byte gSprites\n" + "_080E39D0:\n" + "\tldr r3, _080E3A24 @ =gSprites\n" + "\tlsls r4, r7, 4\n" + "\tadds r2, r4, r7\n" + "\tlsls r2, 2\n" + "\tadds r2, r3\n" + "\tldrh r1, [r6, 0xA]\n" + "\tlsls r1, 16\n" + "\tasrs r1, 24\n" + "\tldrh r0, [r2, 0x24]\n" + "\tsubs r0, r1\n" + "\tstrh r0, [r2, 0x24]\n" + "\tadds r2, r3, 0\n" + "\tadds r3, r4, 0\n" + "_080E39EA:\n" + "\tldr r1, _080E3A28 @ =gTasks\n" + "\tmov r0, r9\n" + "\tadd r0, r8\n" + "\tlsls r0, 3\n" + "\tadds r4, r0, r1\n" + "\tldrb r0, [r4, 0xA]\n" + "\tstrh r0, [r4, 0xA]\n" + "\tadds r1, r3, r7\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tldrh r0, [r1, 0x24]\n" + "\tldrh r1, [r1, 0x20]\n" + "\tadds r0, r1\n" + "\tlsls r0, 16\n" + "\tmovs r1, 0x80\n" + "\tlsls r1, 14\n" + "\tadds r0, r1\n" + "\tmovs r1, 0x98\n" + "\tlsls r1, 17\n" + "\tcmp r0, r1\n" + "\tbhi _080E3A16\n" + "\tb _080E3E6C\n" + "_080E3A16:\n" + "\tmovs r0, 0\n" + "\tstrh r0, [r4, 0xA]\n" + "\tldrh r0, [r4, 0x8]\n" + "\tadds r0, 0x1\n" + "\tstrh r0, [r4, 0x8]\n" + "\tb _080E3E6C\n" + "\t.align 2, 0\n" + "_080E3A24: .4byte gSprites\n" + "_080E3A28: .4byte gTasks\n" + "_080E3A2C:\n" + "\tldr r4, _080E3A90 @ =gBattleAnimAttacker\n" + "\tldrb r0, [r4]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tcmp r0, 0\n" + "\tbne _080E3ACC\n" + "\tldr r7, _080E3A94 @ =gBattlerPartyIndexes\n" + "\tldrb r0, [r4]\n" + "\tlsls r0, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmovs r6, 0x64\n" + "\tmuls r0, r6\n" + "\tldr r5, _080E3A98 @ =gPlayerParty\n" + "\tadds r0, r5\n" + "\tmovs r1, 0\n" + "\tbl GetMonData\n" + "\tmov r10, r0\n" + "\tldrb r0, [r4]\n" + "\tlsls r0, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmuls r0, r6\n" + "\tadds r0, r5\n" + "\tmovs r1, 0x1\n" + "\tbl GetMonData\n" + "\tmov r9, r0\n" + "\tldr r0, _080E3A9C @ =gBattleSpritesDataPtr\n" + "\tldr r0, [r0]\n" + "\tldrb r2, [r4]\n" + "\tldr r1, [r0]\n" + "\tlsls r0, r2, 2\n" + "\tadds r1, r0, r1\n" + "\tldrh r0, [r1, 0x2]\n" + "\tcmp r0, 0\n" + "\tbne _080E3AA0\n" + "\tlsls r0, r2, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmuls r0, r6\n" + "\tadds r0, r5\n" + "\tmovs r1, 0xB\n" + "\tbl GetMonData\n" + "\tlsls r0, 16\n" + "\tlsrs r5, r0, 16\n" + "\tb _080E3AA2\n" + "\t.align 2, 0\n" + "_080E3A90: .4byte gBattleAnimAttacker\n" + "_080E3A94: .4byte gBattlerPartyIndexes\n" + "_080E3A98: .4byte gPlayerParty\n" + "_080E3A9C: .4byte gBattleSpritesDataPtr\n" + "_080E3AA0:\n" + "\tldrh r5, [r1, 0x2]\n" + "_080E3AA2:\n" + "\tmovs r0, 0x1\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tldr r2, _080E3AC8 @ =gSprites\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tlsls r1, r0, 4\n" + "\tadds r1, r0\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tadds r1, 0x43\n" + "\tldrb r0, [r1]\n" + "\tadds r0, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r4, r0, 24\n" + "\tmovs r7, 0\n" + "\tmovs r6, 0x88\n" + "\tlsls r6, 1\n" + "\tb _080E3B54\n" + "\t.align 2, 0\n" + "_080E3AC8: .4byte gSprites\n" + "_080E3ACC:\n" + "\tldr r7, _080E3B24 @ =gBattlerPartyIndexes\n" + "\tldrb r0, [r4]\n" + "\tlsls r0, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmovs r6, 0x64\n" + "\tmuls r0, r6\n" + "\tldr r5, _080E3B28 @ =gEnemyParty\n" + "\tadds r0, r5\n" + "\tmovs r1, 0\n" + "\tbl GetMonData\n" + "\tmov r10, r0\n" + "\tldrb r0, [r4]\n" + "\tlsls r0, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmuls r0, r6\n" + "\tadds r0, r5\n" + "\tmovs r1, 0x1\n" + "\tbl GetMonData\n" + "\tmov r9, r0\n" + "\tldr r0, _080E3B2C @ =gBattleSpritesDataPtr\n" + "\tldr r0, [r0]\n" + "\tldrb r2, [r4]\n" + "\tldr r1, [r0]\n" + "\tlsls r0, r2, 2\n" + "\tadds r1, r0, r1\n" + "\tldrh r0, [r1, 0x2]\n" + "\tcmp r0, 0\n" + "\tbne _080E3B30\n" + "\tlsls r0, r2, 1\n" + "\tadds r0, r7\n" + "\tldrh r0, [r0]\n" + "\tmuls r0, r6\n" + "\tadds r0, r5\n" + "\tmovs r1, 0xB\n" + "\tbl GetMonData\n" + "\tlsls r0, 16\n" + "\tlsrs r5, r0, 16\n" + "\tb _080E3B32\n" + "\t.align 2, 0\n" + "_080E3B24: .4byte gBattlerPartyIndexes\n" + "_080E3B28: .4byte gEnemyParty\n" + "_080E3B2C: .4byte gBattleSpritesDataPtr\n" + "_080E3B30:\n" + "\tldrh r5, [r1, 0x2]\n" + "_080E3B32:\n" + "\tmovs r0, 0x1\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tldr r2, _080E3BD0 @ =gSprites\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tlsls r1, r0, 4\n" + "\tadds r1, r0\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tadds r1, 0x43\n" + "\tldrb r0, [r1]\n" + "\tsubs r0, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r4, r0, 24\n" + "\tmovs r7, 0x1\n" + "\tldr r6, _080E3BD4 @ =0x0000ffe0\n" + "_080E3B54:\n" + "\tldr r0, _080E3BD8 @ =gBattleAnimTarget\n" + "\tldrb r0, [r0]\n" + "\tmovs r1, 0x1\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tlsls r3, r6, 16\n" + "\tasrs r3, 16\n" + "\tstr r0, [sp]\n" + "\tstr r4, [sp, 0x4]\n" + "\tmov r2, r10\n" + "\tstr r2, [sp, 0x8]\n" + "\tmov r4, r9\n" + "\tstr r4, [sp, 0xC]\n" + "\tldr r4, _080E3BDC @ =gBattleAnimAttacker\n" + "\tldrb r0, [r4]\n" + "\tstr r0, [sp, 0x10]\n" + "\tmovs r0, 0\n" + "\tstr r0, [sp, 0x14]\n" + "\tadds r0, r5, 0\n" + "\tadds r1, r7, 0\n" + "\tmovs r2, 0\n" + "\tbl sub_80768D0\n" + "\tlsls r0, 24\n" + "\tlsrs r5, r0, 24\n" + "\tldr r0, _080E3BE0 @ =gBattleSpritesDataPtr\n" + "\tldr r1, [r0]\n" + "\tldrb r0, [r4]\n" + "\tldr r1, [r1]\n" + "\tlsls r0, 2\n" + "\tadds r0, r1\n" + "\tldrh r0, [r0, 0x2]\n" + "\tcmp r0, 0\n" + "\tbeq _080E3BBE\n" + "\tldr r1, _080E3BD0 @ =gSprites\n" + "\tlsls r0, r5, 4\n" + "\tadds r0, r5\n" + "\tlsls r0, 2\n" + "\tadds r0, r1\n" + "\tldrb r0, [r0, 0x5]\n" + "\tlsrs r0, 4\n" + "\tlsls r0, 4\n" + "\tmovs r2, 0x80\n" + "\tlsls r2, 1\n" + "\tadds r1, r2, 0\n" + "\torrs r0, r1\n" + "\tldr r3, _080E3BE4 @ =0x00007fff\n" + "\tmovs r1, 0x10\n" + "\tmovs r2, 0x6\n" + "\tbl BlendPalette\n" + "_080E3BBE:\n" + "\tldr r0, _080E3BE8 @ =gTasks\n" + "\tmov r3, r8\n" + "\tlsls r1, r3, 2\n" + "\tadd r1, r8\n" + "\tlsls r1, 3\n" + "\tadds r1, r0\n" + "\tstrh r5, [r1, 0x26]\n" + "\tb _080E3D82\n" + "\t.align 2, 0\n" + "_080E3BD0: .4byte gSprites\n" + "_080E3BD4: .4byte 0x0000ffe0\n" + "_080E3BD8: .4byte gBattleAnimTarget\n" + "_080E3BDC: .4byte gBattleAnimAttacker\n" + "_080E3BE0: .4byte gBattleSpritesDataPtr\n" + "_080E3BE4: .4byte 0x00007fff\n" + "_080E3BE8: .4byte gTasks\n" + "_080E3BEC:\n" + "\tldr r1, _080E3C38 @ =gTasks\n" + "\tmov r0, r8\n" + "\tlsls r4, r0, 2\n" + "\tadds r0, r4, r0\n" + "\tlsls r0, 3\n" + "\tadds r6, r0, r1\n" + "\tldrh r0, [r6, 0x26]\n" + "\tlsls r0, 24\n" + "\tlsrs r5, r0, 24\n" + "\tmovs r1, 0x80\n" + "\tlsls r1, 4\n" + "\tadds r0, r1, 0\n" + "\tldrh r2, [r6, 0xA]\n" + "\tadds r0, r2\n" + "\tstrh r0, [r6, 0xA]\n" + "\tldr r0, _080E3C3C @ =gBattleAnimAttacker\n" + "\tldrb r0, [r0]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tmov r9, r4\n" + "\tcmp r0, 0\n" + "\tbne _080E3C44\n" + "\tldr r3, _080E3C40 @ =gSprites\n" + "\tlsls r4, r5, 4\n" + "\tadds r2, r4, r5\n" + "\tlsls r2, 2\n" + "\tadds r2, r3\n" + "\tldrh r1, [r6, 0xA]\n" + "\tlsls r1, 16\n" + "\tasrs r1, 24\n" + "\tldrh r0, [r2, 0x24]\n" + "\tsubs r0, r1\n" + "\tstrh r0, [r2, 0x24]\n" + "\tadds r2, r3, 0\n" + "\tadds r3, r4, 0\n" + "\tb _080E3C5A\n" + "\t.align 2, 0\n" + "_080E3C38: .4byte gTasks\n" + "_080E3C3C: .4byte gBattleAnimAttacker\n" + "_080E3C40: .4byte gSprites\n" + "_080E3C44:\n" + "\tldr r2, _080E3CA8 @ =gSprites\n" + "\tlsls r3, r5, 4\n" + "\tadds r1, r3, r5\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tldrh r0, [r6, 0xA]\n" + "\tlsls r0, 16\n" + "\tasrs r0, 24\n" + "\tldrh r4, [r1, 0x24]\n" + "\tadds r0, r4\n" + "\tstrh r0, [r1, 0x24]\n" + "_080E3C5A:\n" + "\tldr r1, _080E3CAC @ =gTasks\n" + "\tmov r0, r9\n" + "\tadd r0, r8\n" + "\tlsls r0, 3\n" + "\tadds r6, r0, r1\n" + "\tldrb r0, [r6, 0xA]\n" + "\tstrh r0, [r6, 0xA]\n" + "\tadds r1, r3, r5\n" + "\tlsls r1, 2\n" + "\tadds r1, r2\n" + "\tldrh r0, [r1, 0x24]\n" + "\tldrh r1, [r1, 0x20]\n" + "\tadds r0, r1\n" + "\tlsls r0, 16\n" + "\tlsrs r5, r0, 16\n" + "\tmovs r1, 0x24\n" + "\tldrsh r0, [r6, r1]\n" + "\tcmp r0, 0\n" + "\tbne _080E3CDA\n" + "\tldr r0, _080E3CB0 @ =gBattleAnimAttacker\n" + "\tldrb r0, [r0]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tcmp r0, 0\n" + "\tbne _080E3CB8\n" + "\tlsls r4, r5, 16\n" + "\tasrs r4, 16\n" + "\tldr r0, _080E3CB4 @ =gBattleAnimTarget\n" + "\tldrb r0, [r0]\n" + "\tmovs r1, 0\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tcmp r4, r0\n" + "\tbge _080E3CDA\n" + "\tb _080E3CCE\n" + "\t.align 2, 0\n" + "_080E3CA8: .4byte gSprites\n" + "_080E3CAC: .4byte gTasks\n" + "_080E3CB0: .4byte gBattleAnimAttacker\n" + "_080E3CB4: .4byte gBattleAnimTarget\n" + "_080E3CB8:\n" + "\tlsls r4, r5, 16\n" + "\tasrs r4, 16\n" + "\tldr r0, _080E3CFC @ =gBattleAnimTarget\n" + "\tldrb r0, [r0]\n" + "\tmovs r1, 0\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tcmp r4, r0\n" + "\tble _080E3CDA\n" + "_080E3CCE:\n" + "\tldrh r0, [r6, 0x24]\n" + "\tadds r0, 0x1\n" + "\tstrh r0, [r6, 0x24]\n" + "\tldr r1, _080E3D00 @ =gBattleAnimArgs\n" + "\tldr r0, _080E3D04 @ =0x0000ffff\n" + "\tstrh r0, [r1, 0xE]\n" + "_080E3CDA:\n" + "\tlsls r0, r5, 16\n" + "\tmovs r2, 0x80\n" + "\tlsls r2, 14\n" + "\tadds r0, r2\n" + "\tmovs r1, 0x98\n" + "\tlsls r1, 17\n" + "\tcmp r0, r1\n" + "\tbhi _080E3CEC\n" + "\tb _080E3E6C\n" + "_080E3CEC:\n" + "\tldr r0, _080E3D08 @ =gTasks\n" + "\tmov r1, r9\n" + "\tadd r1, r8\n" + "\tlsls r1, 3\n" + "\tadds r1, r0\n" + "\tmovs r0, 0\n" + "\tstrh r0, [r1, 0xA]\n" + "\tb _080E3D82\n" + "\t.align 2, 0\n" + "_080E3CFC: .4byte gBattleAnimTarget\n" + "_080E3D00: .4byte gBattleAnimArgs\n" + "_080E3D04: .4byte 0x0000ffff\n" + "_080E3D08: .4byte gTasks\n" + "_080E3D0C:\n" + "\tmovs r0, 0\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tlsls r0, 24\n" + "\tlsrs r7, r0, 24\n" + "\tldr r1, _080E3D58 @ =gTasks\n" + "\tmov r3, r8\n" + "\tlsls r4, r3, 2\n" + "\tadds r0, r4, r3\n" + "\tlsls r0, 3\n" + "\tadds r0, r1\n" + "\tldrh r0, [r0, 0x26]\n" + "\tlsls r0, 24\n" + "\tlsrs r5, r0, 24\n" + "\tlsls r0, r5, 4\n" + "\tadds r0, r5\n" + "\tlsls r0, 2\n" + "\tldr r5, _080E3D5C @ =gSprites\n" + "\tadds r0, r5\n" + "\tbl DestroySpriteAndFreeResources_\n" + "\tldr r0, _080E3D60 @ =gBattleAnimAttacker\n" + "\tldrb r0, [r0]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tmov r9, r4\n" + "\tcmp r0, 0\n" + "\tbne _080E3D64\n" + "\tlsls r1, r7, 4\n" + "\tadds r1, r7\n" + "\tlsls r1, 2\n" + "\tadds r1, r5\n" + "\tldrh r0, [r1, 0x20]\n" + "\tnegs r0, r0\n" + "\tsubs r0, 0x20\n" + "\tstrh r0, [r1, 0x24]\n" + "\tb _080E3D78\n" + "\t.align 2, 0\n" + "_080E3D58: .4byte gTasks\n" + "_080E3D5C: .4byte gSprites\n" + "_080E3D60: .4byte gBattleAnimAttacker\n" + "_080E3D64:\n" + "\tlsls r0, r7, 4\n" + "\tadds r0, r7\n" + "\tlsls r0, 2\n" + "\tadds r0, r5\n" + "\tldrh r2, [r0, 0x20]\n" + "\tmovs r4, 0x88\n" + "\tlsls r4, 1\n" + "\tadds r1, r4, 0\n" + "\tsubs r1, r2\n" + "\tstrh r1, [r0, 0x24]\n" + "_080E3D78:\n" + "\tldr r0, _080E3D8C @ =gTasks\n" + "\tmov r1, r9\n" + "\tadd r1, r8\n" + "\tlsls r1, 3\n" + "\tadds r1, r0\n" + "_080E3D82:\n" + "\tldrh r0, [r1, 0x8]\n" + "\tadds r0, 0x1\n" + "\tstrh r0, [r1, 0x8]\n" + "\tb _080E3E6C\n" + "\t.align 2, 0\n" + "_080E3D8C: .4byte gTasks\n" + "_080E3D90:\n" + "\tmovs r0, 0\n" + "\tbl GetAnimBattlerSpriteId\n" + "\tlsls r0, 24\n" + "\tlsrs r7, r0, 24\n" + "\tldr r1, _080E3E04 @ =gTasks\n" + "\tmov r0, r8\n" + "\tlsls r4, r0, 2\n" + "\tadds r0, r4, r0\n" + "\tlsls r0, 3\n" + "\tadds r2, r0, r1\n" + "\tmovs r1, 0x80\n" + "\tlsls r1, 4\n" + "\tadds r0, r1, 0\n" + "\tldrh r3, [r2, 0xA]\n" + "\tadds r0, r3\n" + "\tstrh r0, [r2, 0xA]\n" + "\tldr r0, _080E3E08 @ =gBattleAnimAttacker\n" + "\tmov r10, r0\n" + "\tldrb r0, [r0]\n" + "\tstr r2, [sp, 0x18]\n" + "\tbl GetBattlerSide\n" + "\tlsls r0, 24\n" + "\tmov r9, r4\n" + "\tldr r2, [sp, 0x18]\n" + "\tcmp r0, 0\n" + "\tbne _080E3E10\n" + "\tldr r1, _080E3E0C @ =gSprites\n" + "\tlsls r5, r7, 4\n" + "\tadds r0, r5, r7\n" + "\tlsls r0, 2\n" + "\tadds r6, r0, r1\n" + "\tldrh r0, [r2, 0xA]\n" + "\tlsls r0, 16\n" + "\tasrs r0, 24\n" + "\tldrh r1, [r6, 0x24]\n" + "\tadds r0, r1\n" + "\tstrh r0, [r6, 0x24]\n" + "\tmovs r2, 0x24\n" + "\tldrsh r4, [r6, r2]\n" + "\tmovs r3, 0x20\n" + "\tldrsh r0, [r6, r3]\n" + "\tadds r4, r0\n" + "\tmov r1, r10\n" + "\tldrb r0, [r1]\n" + "\tmovs r1, 0\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tadds r3, r5, 0\n" + "\tcmp r4, r0\n" + "\tblt _080E3E48\n" + "\tmovs r2, 0\n" + "\tstrh r2, [r6, 0x24]\n" + "\tb _080E3E48\n" + "\t.align 2, 0\n" + "_080E3E04: .4byte gTasks\n" + "_080E3E08: .4byte gBattleAnimAttacker\n" + "_080E3E0C: .4byte gSprites\n" + "_080E3E10:\n" + "\tldr r1, _080E3E7C @ =gSprites\n" + "\tlsls r5, r7, 4\n" + "\tadds r0, r5, r7\n" + "\tlsls r0, 2\n" + "\tadds r6, r0, r1\n" + "\tldrh r1, [r2, 0xA]\n" + "\tlsls r1, 16\n" + "\tasrs r1, 24\n" + "\tldrh r0, [r6, 0x24]\n" + "\tsubs r0, r1\n" + "\tstrh r0, [r6, 0x24]\n" + "\tmovs r3, 0x24\n" + "\tldrsh r4, [r6, r3]\n" + "\tmovs r1, 0x20\n" + "\tldrsh r0, [r6, r1]\n" + "\tadds r4, r0\n" + "\tmov r2, r10\n" + "\tldrb r0, [r2]\n" + "\tmovs r1, 0\n" + "\tbl GetBattlerSpriteCoord\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tadds r3, r5, 0\n" + "\tcmp r4, r0\n" + "\tbgt _080E3E48\n" + "\tmovs r4, 0\n" + "\tstrh r4, [r6, 0x24]\n" + "_080E3E48:\n" + "\tldr r1, _080E3E80 @ =gTasks\n" + "\tmov r0, r9\n" + "\tadd r0, r8\n" + "\tlsls r0, 3\n" + "\tadds r0, r1\n" + "\tldrb r1, [r0, 0xA]\n" + "\tstrh r1, [r0, 0xA]\n" + "\tldr r1, _080E3E7C @ =gSprites\n" + "\tadds r0, r3, r7\n" + "\tlsls r0, 2\n" + "\tadds r0, r1\n" + "\tmovs r1, 0x24\n" + "\tldrsh r0, [r0, r1]\n" + "\tcmp r0, 0\n" + "\tbne _080E3E6C\n" + "\tmov r0, r8\n" + "\tbl DestroyAnimVisualTask\n" + "_080E3E6C:\n" + "\tadd sp, 0x1C\n" + "\tpop {r3-r5}\n" + "\tmov r8, r3\n" + "\tmov r9, r4\n" + "\tmov r10, r5\n" + "\tpop {r4-r7}\n" + "\tpop {r0}\n" + "\tbx r0\n" + "\t.align 2, 0\n" + "_080E3E7C: .4byte gSprites\n" + "_080E3E80: .4byte gTasks\n"); } #endif @@ -5972,6 +5796,7 @@ void AnimTask_SnatchPartnerMove(u8 taskId) void AnimTask_TeeterDanceMovement(u8 taskId) { struct Task *task = &gTasks[taskId]; + task->data[3] = GetAnimBattlerSpriteId(ANIM_ATTACKER); task->data[4] = GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER ? 1 : -1; task->data[6] = gSprites[task->data[3]].pos1.y; @@ -5986,6 +5811,7 @@ void AnimTask_TeeterDanceMovement(u8 taskId) static void AnimTask_TeeterDanceMovementStep(u8 taskId) { struct Task *task = &gTasks[taskId]; + switch (task->data[0]) { case 0: @@ -6157,6 +5983,7 @@ void AnimTask_GetWeather(u8 taskId) void AnimTask_SlackOffSquish(u8 taskId) { struct Task *task = &gTasks[taskId]; + task->data[0] = 0; task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); PrepareAffineAnimInTaskData(task, task->data[15], gSlackOffSquishAffineAnimCmds); diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 7d512b950..46bcc2cbb 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -39,15 +39,11 @@ #define HIHALF(n) (((n) & 0xFFFF0000) >> 16) #define LOHALF(n) ((n) & 0xFFFF) -// IWRAM +// RAM EWRAM_DATA int gUnknown_3005424 = 0; EWRAM_DATA u16 gUnknown_3005428 = 0; EWRAM_DATA u16 gUnknown_300542C = 0; -//extern u32 gUnknown_3005424; -//extern u32 gUnknown_3005428; -//extern u32 gUnknown_300542C; - // Function Declarations static void sub_80EEDF4(u8); static void sub_80EF1CC(u8); @@ -74,7 +70,7 @@ static void sub_80F05B4(u8); static void sub_80F0278(struct Sprite *); static void sub_80F0378(struct Sprite *); static void sub_80F04B4(struct Sprite *); -static void sub_80F052C(struct Sprite *sprite); +static void GhostBallDodge(struct Sprite *sprite); static void sub_80F0574(struct Sprite *sprite); static void PokeBallOpenParticleAnimation_Step1(struct Sprite *); static void PokeBallOpenParticleAnimation_Step2(struct Sprite *); @@ -111,7 +107,7 @@ struct BallCaptureSuccessStarData s8 unk2; }; -static const struct BallCaptureSuccessStarData sBallCaptureSuccessStarData[] = //gUnknown_840BF3C +static const struct BallCaptureSuccessStarData sBallCaptureSuccessStarData[] = { { .xOffset = 10, @@ -130,7 +126,7 @@ static const struct BallCaptureSuccessStarData sBallCaptureSuccessStarData[] = / }, }; -const struct CompressedSpriteSheet gBallParticleSpritesheets[] = //gUnknown_840BF48 +const struct CompressedSpriteSheet gBallParticleSpritesheets[] = { {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_POKEBALL}, {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_GREATBALL}, @@ -146,7 +142,7 @@ const struct CompressedSpriteSheet gBallParticleSpritesheets[] = //gUnknown_840B {gBattleAnimSpriteGfx_Particles, 0x100, TAG_PARTICLES_PREMIERBALL}, }; -const struct CompressedSpritePalette gBallParticlePalettes[] = //gUnknown_840BFA8 +const struct CompressedSpritePalette gBallParticlePalettes[] = { {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_POKEBALL}, {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_GREATBALL}, @@ -162,7 +158,7 @@ const struct CompressedSpritePalette gBallParticlePalettes[] = //gUnknown_840BFA {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_PREMIERBALL}, }; -const union AnimCmd gAnim_RegularBall[] = //gAnimCmd_840C008 +const union AnimCmd gAnim_RegularBall[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_FRAME(1, 1), @@ -173,38 +169,38 @@ const union AnimCmd gAnim_RegularBall[] = //gAnimCmd_840C008 ANIMCMD_JUMP(0), }; -const union AnimCmd gAnim_MasterBall[] = //gAnimCmd_840C024 +const union AnimCmd gAnim_MasterBall[] = { ANIMCMD_FRAME(3, 1), ANIMCMD_END, }; -const union AnimCmd gAnim_NetDiveBall[] = //gAnimCmd_840C02C +const union AnimCmd gAnim_NetDiveBall[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd gAnim_NestBall[] = //gAnimCmd_840C034 +const union AnimCmd gAnim_NestBall[] = { ANIMCMD_FRAME(5, 1), ANIMCMD_END, }; -const union AnimCmd gAnim_LuxuryPremierBall[] = //gAnimCmd_840C03C +const union AnimCmd gAnim_LuxuryPremierBall[] = { ANIMCMD_FRAME(6, 4), ANIMCMD_FRAME(7, 4), ANIMCMD_JUMP(0), }; -const union AnimCmd gAnim_UltraRepeatTimerBall[] = //gAnimCmd_840C048 +const union AnimCmd gAnim_UltraRepeatTimerBall[] = { ANIMCMD_FRAME(7, 4), ANIMCMD_END, }; -const union AnimCmd *const gAnims_BallParticles[] = //gSpriteAnimTable_840C050 +const union AnimCmd *const gAnims_BallParticles[] = { gAnim_RegularBall, gAnim_MasterBall, @@ -214,7 +210,7 @@ const union AnimCmd *const gAnims_BallParticles[] = //gSpriteAnimTable_840C050 gAnim_UltraRepeatTimerBall, }; -const u8 gBallParticleAnimNums[] = //gUnknown_840C068 +const u8 gBallParticleAnimNums[] = { [BALL_POKE] = 0, [BALL_GREAT] = 0, @@ -230,7 +226,7 @@ const u8 gBallParticleAnimNums[] = //gUnknown_840C068 [BALL_PREMIER] = 4, }; -const TaskFunc gBallParticleAnimationFuncs[] = //gUnknown_840C074 +const TaskFunc gBallParticleAnimationFuncs[] = { PokeBallOpenParticleAnimation, GreatBallOpenParticleAnimation, @@ -246,7 +242,7 @@ const TaskFunc gBallParticleAnimationFuncs[] = //gUnknown_840C074 PremierBallOpenParticleAnimation, }; -const struct SpriteTemplate gBallParticlesSpriteTemplates[] = //gUnknown_840C0A4 +const struct SpriteTemplate gBallParticlesSpriteTemplates[] = { { .tileTag = TAG_PARTICLES_POKEBALL, @@ -358,7 +354,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = //gUnknown_840C0A4 }, }; -const u16 gBallOpenFadeColors[] = //gUnknown_840C1C4 +const u16 gBallOpenFadeColors[] = { [BALL_POKE] = RGB(31, 22, 30), [BALL_GREAT] = RGB(16, 23, 30), @@ -373,7 +369,7 @@ const u16 gBallOpenFadeColors[] = //gUnknown_840C1C4 [BALL_LUXURY] = RGB(31, 17, 10), [BALL_PREMIER] = RGB(31, 9, 10), - // Garbage data + // Unused RGB(0, 0, 0), RGB(1, 16, 0), RGB(3, 0, 1), @@ -384,7 +380,7 @@ const u16 gBallOpenFadeColors[] = //gUnknown_840C1C4 RGB(4, 0, 0), }; -const struct SpriteTemplate gPokeblockSpriteTemplate = //gUnknown_840C1EC +const struct SpriteTemplate gPokeblockSpriteTemplate = { .tileTag = ANIM_TAG_POKEBLOCK, .paletteTag = ANIM_TAG_POKEBLOCK, @@ -401,7 +397,8 @@ const union AnimCmd gUnknown_840C204[] = ANIMCMD_END, }; -const union AnimCmd *const gSpriteAnimTable_840C20C[] = { +const union AnimCmd *const gSpriteAnimTable_840C20C[] = +{ gUnknown_840C204, }; @@ -439,7 +436,6 @@ void sub_80EEC0C(u8 taskId) SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 0); SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 1); SetAnimBgAttribute(1, BG_ANIM_CHAR_BASE_BLOCK, 1); - healthBoxSpriteId = gHealthboxSpriteIds[battler]; spriteId1 = gSprites[healthBoxSpriteId].oam.affineParam; spriteId2 = gSprites[healthBoxSpriteId].data[5]; @@ -454,12 +450,10 @@ void sub_80EEC0C(u8 taskId) gSprites[spriteId4].oam.objMode = ST_OAM_OBJ_WINDOW; gSprites[spriteId3].callback = SpriteCallbackDummy; gSprites[spriteId4].callback = SpriteCallbackDummy; - sub_80752A0(&unknownStruct); AnimLoadCompressedBgTilemap(unknownStruct.bgId, gUnknown_D2EC24_Tilemap); AnimLoadCompressedBgGfx(unknownStruct.bgId, gUnknown_D2EC24_Gfx, unknownStruct.tilesOffset); LoadCompressedPalette(gCureBubblesPal, unknownStruct.paletteId << 4, 32); - gBattle_BG1_X = -gSprites[spriteId3].pos1.x + 32; gBattle_BG1_Y = -gSprites[spriteId3].pos1.y - 32; gTasks[taskId].data[1] = 640; @@ -539,12 +533,10 @@ void sub_80EEFC8(u8 *paletteId1, u8 *paletteId2, u8 battler) spriteId2 = gSprites[healthBoxSpriteId].data[5]; *paletteId1 = AllocSpritePalette(0xD709); *paletteId2 = AllocSpritePalette(0xD70A); - offset1 = (gSprites[healthBoxSpriteId].oam.paletteNum * 16) + 0x100; offset2 = (gSprites[spriteId2].oam.paletteNum * 16) + 0x100; LoadPalette(&gPlttBufferUnfaded[offset1], *paletteId1 * 16 + 0x100, 0x20); LoadPalette(&gPlttBufferUnfaded[offset2], *paletteId2 * 16 + 0x100, 0x20); - gSprites[healthBoxSpriteId].oam.paletteNum = *paletteId1; gSprites[spriteId1].oam.paletteNum = *paletteId1; gSprites[spriteId2].oam.paletteNum = *paletteId2; @@ -553,6 +545,7 @@ void sub_80EEFC8(u8 *paletteId1, u8 *paletteId2, u8 battler) void sub_80EF0B4(u8 taskId) { u8 paletteId1, paletteId2; + sub_80EEFC8(&paletteId1, &paletteId2, gBattleAnimAttacker); DestroyAnimVisualTask(taskId); } @@ -566,7 +559,6 @@ void sub_80EF0E0(u8 battler) healthBoxSpriteId = gHealthboxSpriteIds[battler]; spriteId1 = gSprites[healthBoxSpriteId].oam.affineParam; spriteId2 = gSprites[healthBoxSpriteId].data[5]; - FreeSpritePaletteByTag(0xD709); FreeSpritePaletteByTag(0xD70A); paletteId1 = IndexOfSpritePaletteTag(0xD6FF); @@ -672,8 +664,8 @@ void sub_80EF344(u8 taskId) switch (gTasks[taskId].data[0]) { case 0: - x = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); - y = GetBattlerSpriteCoord(gBattleAnimAttacker, 1); + x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X); + y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y); priority = gSprites[spriteId].oam.priority; subpriority = gSprites[spriteId].subpriority; gTasks[taskId].data[10] = LaunchBallStarsTask(x, y + 32, priority, subpriority, ballId); @@ -691,6 +683,7 @@ void sub_80EF344(u8 taskId) void sub_80EF490(u8 taskId) { u8 ballId = ItemIdToBallId(gLastUsedItem); + LoadBallGfx(ballId); DestroyAnimVisualTask(taskId); } @@ -698,6 +691,7 @@ void sub_80EF490(u8 taskId) void sub_80EF4B8(u8 taskId) { u8 ballId = ItemIdToBallId(gLastUsedItem); + FreeBallGfx(ballId); DestroyAnimVisualTask(taskId); } @@ -705,17 +699,17 @@ void sub_80EF4B8(u8 taskId) void AnimTask_IsBallBlockedByTrainerOrDodged(u8 taskId) { switch (gBattleSpritesDataPtr->animationData->ballThrowCaseId) - { - case BALL_TRAINER_BLOCK: - gBattleAnimArgs[ARG_RET_ID] = -1; - break; - case BALL_GHOST_DODGE: - gBattleAnimArgs[ARG_RET_ID] = -2; - break; - default: - gBattleAnimArgs[ARG_RET_ID] = 0; - break; - } + { + case BALL_TRAINER_BLOCK: + gBattleAnimArgs[ARG_RET_ID] = -1; + break; + case BALL_GHOST_DODGE: + gBattleAnimArgs[ARG_RET_ID] = -2; + break; + default: + gBattleAnimArgs[ARG_RET_ID] = 0; + break; + } DestroyAnimVisualTask(taskId); } @@ -760,8 +754,8 @@ void sub_80EF5AC(u8 taskId) ballId = ItemIdToBallId(gLastUsedItem); spriteId = CreateSprite(&gBallSpriteTemplates[ballId], 32, 80, 29); gSprites[spriteId].data[0] = 34; - gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, 0); - gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) - 16; + gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) - 16; gSprites[spriteId].callback = sub_80EF8C0; gBattleSpritesDataPtr->animationData->field_9_x2 = gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible; gTasks[taskId].data[0] = spriteId; @@ -771,6 +765,7 @@ void sub_80EF5AC(u8 taskId) static void sub_80EF698(u8 taskId) { u8 spriteId = gTasks[taskId].data[0]; + if ((u16)gSprites[spriteId].data[0] == 0xFFFF) DestroyAnimVisualTask(taskId); } @@ -791,16 +786,16 @@ void sub_80EF6D4(u8 taskId) { x = 23; y = 11; - if (gSaveBlock2Ptr->playerGender == FEMALE) - y = 13; + if (gSaveBlock2Ptr->playerGender == FEMALE) + y = 13; } ballId = ItemIdToBallId(gLastUsedItem); subpriority = GetBattlerSpriteSubpriority(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)) + 1; spriteId = CreateSprite(&gBallSpriteTemplates[ballId], x | 32, y | 80, subpriority); gSprites[spriteId].data[0] = 34; - gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, 0); - gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 1) - 16; + gSprites[spriteId].data[1] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X); + gSprites[spriteId].data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) - 16; gSprites[spriteId].callback = SpriteCallbackDummy; gSprites[gBattlerSpriteIds[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]].callback = sub_8012354; gTasks[taskId].data[0] = spriteId; @@ -831,6 +826,7 @@ static void sub_80EF8C0(struct Sprite *sprite) { u16 temp = sprite->data[1]; u16 temp2 = sprite->data[2]; + sprite->data[1] = sprite->pos1.x; sprite->data[2] = temp; sprite->data[3] = sprite->pos1.y; @@ -851,10 +847,10 @@ static void sub_80EF8F0(struct Sprite *sprite) { sprite->callback = sub_80F0478; } - else if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_GHOST_DODGE) - { - sprite->callback = sub_80F052C; - } + else if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_GHOST_DODGE) + { + sprite->callback = GhostBallDodge; + } else { StartSpriteAnim(sprite, 1); @@ -898,7 +894,6 @@ static void sub_80EFA0C(struct Sprite *sprite) spriteId = gBattlerSpriteIds[gBattleAnimTarget]; taskId = sprite->data[5]; - if (++gTasks[taskId].data[1] == 11) PlaySE(SE_SUIKOMU); @@ -960,7 +955,6 @@ static void sub_80EFB9C(struct Sprite *sprite) int bounceCount; lastBounce = 0; - switch (sprite->data[3] & 0xFF) { case 0: @@ -1330,7 +1324,6 @@ static void sub_80F02B0(struct Sprite *sprite) StartSpriteAnim(sprite, 1); StartSpriteAffineAnim(sprite, 0); sprite->callback = sub_80F0378; - ballId = ItemIdToBallId(gLastUsedItem); switch (ballId) { @@ -1393,11 +1386,11 @@ static void sub_80F04B4(struct Sprite *sprite) { s16 var0 = sprite->data[0] + 0x800; s16 var1 = sprite->data[1] + 0x680; + sprite->pos2.x -= var1 >> 8; sprite->pos2.y += var0 >> 8; sprite->data[0] = (sprite->data[0] + 0x800) & 0xFF; sprite->data[1] = (sprite->data[1] + 0x680) & 0xFF; - if (sprite->pos1.y + sprite->pos2.y > 160 || sprite->pos1.x + sprite->pos2.x < -8) { @@ -1408,35 +1401,34 @@ static void sub_80F04B4(struct Sprite *sprite) } } -// GhostBallDodge -static void sub_80F052C(struct Sprite *sprite) +static void GhostBallDodge(struct Sprite *sprite) { - sprite->pos1.x += sprite->pos2.x; - sprite->pos1.y += sprite->pos2.y; + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; sprite->pos2.x = sprite->pos2.y = 0; - sprite->data[0] = 0x22; - sprite->data[1] = sprite->pos1.x; - sprite->data[2] = sprite->pos1.x - 8; - sprite->data[3] = sprite->pos1.y; - sprite->data[4] = 0x90; - sprite->data[5] = 0x20; - InitAnimArcTranslation(sprite); - TranslateAnimVerticalArc(sprite); - sprite->callback = sub_80F0574; + sprite->data[0] = 0x22; + sprite->data[1] = sprite->pos1.x; + sprite->data[2] = sprite->pos1.x - 8; + sprite->data[3] = sprite->pos1.y; + sprite->data[4] = 0x90; + sprite->data[5] = 0x20; + InitAnimArcTranslation(sprite); + TranslateAnimVerticalArc(sprite); + sprite->callback = sub_80F0574; } static void sub_80F0574(struct Sprite *sprite) { - if (!TranslateAnimVerticalArc(sprite)) - { - if ((sprite->pos1.y + sprite->pos2.y) < 65) - return; - } - - sprite->data[0] = 0; - sprite->callback = sub_80F018C; - gDoingBattleAnim = FALSE; - UpdateOamPriorityInAllHealthboxes(1); + if (!TranslateAnimVerticalArc(sprite)) + { + if ((sprite->pos1.y + sprite->pos2.y) < 65) + return; + } + + sprite->data[0] = 0; + sprite->callback = sub_80F018C; + gDoingBattleAnim = FALSE; + UpdateOamPriorityInAllHealthboxes(1); } static void sub_80F05B4(u8 ballId) @@ -1462,7 +1454,6 @@ u8 LaunchBallStarsTask(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId) gTasks[taskId].data[4] = subpriority; gTasks[taskId].data[15] = ballId; PlaySE(SE_BOWA2); - return taskId; } @@ -1875,10 +1866,10 @@ static void DestroyBallOpenAnimationParticle(struct Sprite *sprite) if (gBattleSpritesDataPtr->animationData->field_A == 0) { for (j = 0; j < POKEBALL_COUNT; j++) - { - FreeSpriteTilesByTag(gBallParticleSpritesheets[j].tag); - FreeSpritePaletteByTag(gBallParticlePalettes[j].tag); - } + { + FreeSpriteTilesByTag(gBallParticleSpritesheets[j].tag); + FreeSpritePaletteByTag(gBallParticlePalettes[j].tag); + } DestroySprite(sprite); } @@ -2126,8 +2117,8 @@ static void sub_80F181C(u8 taskId) return; battler = gTasks[taskId].data[0]; - x = GetBattlerSpriteCoord(battler, 0); - y = GetBattlerSpriteCoord(battler, 1); + x = GetBattlerSpriteCoord(battler, BATTLER_COORD_X); + y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y); state = gTasks[taskId].data[11]; if (state == 0) { @@ -2244,8 +2235,8 @@ static void sub_80F1B3C(struct Sprite *sprite) { InitSpritePosToAnimAttacker(sprite, 0); sprite->data[0] = 30; - sprite->data[2] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), 0) + gBattleAnimArgs[2]; - sprite->data[4] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), 1) + gBattleAnimArgs[3]; + sprite->data[2] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), BATTLER_COORD_X) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), BATTLER_COORD_Y) + gBattleAnimArgs[3]; sprite->data[5] = -32; InitAnimArcTranslation(sprite); gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].callback = sub_8012354; @@ -2260,7 +2251,7 @@ static void sub_80F1BCC(struct Sprite *sprite) static void sub_80F1C04(struct Sprite *sprite) { - if (TranslateAnimHorizontalArc(sprite)) //TranslateAnimArc? + if (TranslateAnimHorizontalArc(sprite)) { sprite->data[0] = 0; sprite->invisible = 1; @@ -2299,15 +2290,14 @@ void sub_80F1C8C(u8 taskId) void sub_80F1CE4(u8 taskId) { - if (gBattleCommunication[MULTISTRING_CHOOSER] > 2) - gBattleAnimArgs[7] = 0; - else - gBattleAnimArgs[7] = gBattleCommunication[MULTISTRING_CHOOSER]; - - DestroyAnimVisualTask(taskId); + if (gBattleCommunication[MULTISTRING_CHOOSER] > 2) + gBattleAnimArgs[7] = 0; + else + gBattleAnimArgs[7] = gBattleCommunication[MULTISTRING_CHOOSER]; + + DestroyAnimVisualTask(taskId); } -// 080F1D14 void AnimTask_GetTrappedMoveAnimId(u8 taskId) { if (gBattleSpritesDataPtr->animationData->animArg == MOVE_FIRE_SPIN) diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c index 4a45a3d8b..1e05e0e68 100644 --- a/src/battle_anim_status_effects.c +++ b/src/battle_anim_status_effects.c @@ -26,8 +26,6 @@ static void sub_8078380(struct Sprite *sprite); extern const struct CompressedSpriteSheet gBattleAnimPicTable[]; extern const struct CompressedSpritePalette gBattleAnimPaletteTable[]; extern const u8 *const gBattleAnims_StatusConditions[]; -extern const struct OamData gOamData_AffineOff_ObjNormal_8x8; -extern const struct OamData gOamData_AffineOff_ObjBlend_64x64; static const union AnimCmd gUnknown_83BF3E0[] = { @@ -205,8 +203,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF514 = .callback = sub_8076ED8, }; -//const u8 gUnknown_83BF52C[] = _("TASK OVER\nタスクがオーバーしました"); //wont compile...? -const u8 gUnknown_83BF52C[] = {0xCE, 0xBB, 0xCD, 0xC5, 0x00, 0xC9, 0xD0, 0xBF, 0xCC, 0xFE, 0x60, 0x5D, 0x58, 0x37, 0x55, 0xAE, 0x96, 0xAE, 0x0C, 0x1F, 0x0C, 0x10, 0xFF}; +const u8 gUnknown_83BF52C[] = _("TASK OVER\nタスクがオ-バ-しました"); static const struct Subsprite gSubsprites_83BF544[] = { @@ -284,7 +281,6 @@ static u8 sub_8078178(u8 battlerId, bool8 b) return taskId; } -// Functions static void sub_80782BC(u8 taskId) { if (gTasks[taskId].data[2] == 2) @@ -361,11 +357,13 @@ void sub_80783FC(u8 taskId) if (IsContest()) x -= 6; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); spriteId = CreateSprite(&gUnknown_83BF55C, x, y, 4); if (GetSpriteTileStartByTag(ANIM_TAG_ICE_CUBE) == 0xFFFF) gSprites[spriteId].invisible = TRUE; + SetSubspriteTables(&gSprites[spriteId], gUnknown_83BF554); gTasks[taskId].data[15] = spriteId; gTasks[taskId].func = sub_80784D8; -- cgit v1.2.3 From 66cf904343a3aa7e9f161707ee2d366053afba63 Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 14:18:45 -0700 Subject: data type fixes --- src/battle_anim.c | 5 +- src/battle_anim_effects_1.c | 110 +++++++++----------------------------- src/battle_anim_effects_2.c | 111 ++++++++++++--------------------------- src/battle_anim_effects_3.c | 88 ++++++++----------------------- src/battle_anim_special.c | 86 +++++++++++++++--------------- src/battle_anim_status_effects.c | 16 +++--- src/mevent_8145654.c | 3 +- 7 files changed, 131 insertions(+), 288 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index fd219bc11..ce20a4f01 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -111,9 +111,6 @@ static void ScriptCmd_doublebattle_2E(void); static void ScriptCmd_stopsound(void); // Data -extern const u16 gMovesWithQuietBGM[]; -extern const u8 *const gBattleAnims_Moves[]; - const struct OamData gOamData_AffineOff_ObjNormal_8x8 = { .y = 0, @@ -1740,7 +1737,7 @@ const struct BattleAnimBackground gBattleAnimBackgroundTable[] = [BG_SOLARBEAM_CONTESTS] = {gBattleAnimBgImage_Impact, gBattleAnimBgPalette_Solarbeam, gBattleAnimBgTilemap_ImpactContests}, }; -static void (* const sScriptCmdTable[])(void) = +static void (*const sScriptCmdTable[])(void) = { ScriptCmd_loadspritegfx, ScriptCmd_unloadspritegfx, diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index b1209bb81..1cbbf92de 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -19,66 +19,6 @@ EWRAM_DATA s16 gUnknown_203999C[4] = {0}; // Function Declarations -void AnimMovePowderParticle(struct Sprite *); -void AnimPowerAbsorptionOrb(struct Sprite *); -void AnimSolarbeamBigOrb(struct Sprite *); -void AnimSolarbeamSmallOrb(struct Sprite *); -void AnimAbsorptionOrb(struct Sprite *); -void AnimHyperBeamOrb(struct Sprite *); -void AnimSporeParticle(struct Sprite *); -void AnimPetalDanceBigFlower(struct Sprite *); -void AnimPetalDanceSmallFlower(struct Sprite *); -void AnimRazorLeafParticle(struct Sprite *); -void AnimLeechSeed(struct Sprite *); -void AnimTranslateLinearSingleSineWave(struct Sprite *); -void AnimMoveTwisterParticle(struct Sprite *); -void AnimConstrictBinding(struct Sprite *); -void AnimMimicOrb(struct Sprite *); -void AnimIngrainRoot(struct Sprite *); -void AnimFrenzyPlantRoot(struct Sprite *); -void AnimIngrainOrb(struct Sprite *); -void AnimPresent(struct Sprite *); -void AnimKnockOffItem(struct Sprite *); -void AnimPresentHealParticle(struct Sprite *); -void AnimItemSteal(struct Sprite *); -void AnimTrickBag(struct Sprite *); -void AnimFlyingParticle(struct Sprite *); -void AnimNeedleArmSpike(struct Sprite *); -void sub_80A43F8(struct Sprite *); -void AnimWhipHit(struct Sprite *); -void sub_80A4494(struct Sprite *); -void AnimCuttingSlice(struct Sprite *); -void AnimAirCutterSlice(struct Sprite *); -void sub_80A481C(struct Sprite *); -void AnimProtect(struct Sprite *); -void AnimMilkBottle(struct Sprite *); -void AnimGrantingStars(struct Sprite *); -void AnimSparkingStars(struct Sprite *); -void sub_80A4E40(struct Sprite *); -void AnimSleepLetterZ(struct Sprite *); -void AnimLockOnTarget(struct Sprite *); -void AnimLockOnMoveTarget(struct Sprite *); -void AnimBowMon(struct Sprite *); -void sub_80A5590(struct Sprite *); -void AnimSlashSlice(struct Sprite *); -void AnimFalseSwipeSlice(struct Sprite *); -void AnimFalseSwipePositionedSlice(struct Sprite *); -void AnimEndureEnergy(struct Sprite *); -void AnimSharpenSphere(struct Sprite *); -void AnimConversion(struct Sprite *); -void AnimConversion2(struct Sprite *); -void AnimMoon(struct Sprite *); -void AnimMoonlightSparkle(struct Sprite *); -void AnimHornHit(struct Sprite *); -void AnimSuperFang(struct Sprite *); -void AnimWavyMusicNotes(struct Sprite *); -void AnimFlyingMusicNotes(struct Sprite *); -void AnimBellyDrumHand(struct Sprite *); -void AnimSlowFlyingMusicNotes(struct Sprite *); -void AnimThoughtBubble(struct Sprite *); -void AnimMetronomeFinger(struct Sprite *); -void AnimFollowMeFinger(struct Sprite *); -void AnimTauntFinger(struct Sprite *); static void AnimMovePowderParticleStep(struct Sprite *); static void AnimSolarbeamSmallOrbStep(struct Sprite *); static void AnimAbsorptionOrbStep(struct Sprite *); @@ -2003,10 +1943,10 @@ const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = const u16 gParticlesColorBlendTable[][6] = { - {ANIM_TAG_MUSIC_NOTES, RGB(31, 31, 31), RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, - {ANIM_TAG_BENT_SPOON, RGB(31, 31, 31), RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, - {ANIM_TAG_SPHERE_TO_CUBE, RGB(31, 31, 31), RGB(31, 31, 24), RGB(31, 31, 17), RGB(31, 31, 10), RGB(31, 31, 3)}, - {ANIM_TAG_LARGE_FRESH_EGG, RGB(31, 31, 31), RGB(26, 28, 31), RGB(21, 26, 31), RGB(16, 24, 31), RGB(12, 22, 31)}, + {ANIM_TAG_MUSIC_NOTES, RGB_WHITE, RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, + {ANIM_TAG_BENT_SPOON, RGB_WHITE, RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, + {ANIM_TAG_SPHERE_TO_CUBE, RGB_WHITE, RGB(31, 31, 24), RGB(31, 31, 17), RGB(31, 31, 10), RGB(31, 31, 3)}, + {ANIM_TAG_LARGE_FRESH_EGG, RGB_WHITE, RGB(26, 28, 31), RGB(21, 26, 31), RGB(16, 24, 31), RGB(12, 22, 31)}, }; const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = @@ -2450,7 +2390,7 @@ static void AnimLeechSeedStep(struct Sprite* sprite) { if (TranslateAnimHorizontalArc(sprite)) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->data[0] = 10; sprite->callback = WaitAnimForDuration; StoreSpriteCallbackInData6(sprite, AnimLeechSeedSprouts); @@ -2459,7 +2399,7 @@ static void AnimLeechSeedStep(struct Sprite* sprite) static void AnimLeechSeedSprouts(struct Sprite* sprite) { - sprite->invisible = 0; + sprite->invisible = FALSE; StartSpriteAnim(sprite, 1); sprite->data[0] = 60; sprite->callback = WaitAnimForDuration; @@ -2789,7 +2729,7 @@ static void AnimMoveTwisterParticleStep(struct Sprite* sprite) void AnimConstrictBinding(struct Sprite* sprite) { InitSpritePosToAnimTarget(sprite, FALSE); - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; StartSpriteAffineAnim(sprite, gBattleAnimArgs[2]); sprite->data[6] = gBattleAnimArgs[2]; sprite->data[7] = gBattleAnimArgs[3]; @@ -2802,7 +2742,7 @@ static void AnimConstrictBindingStep1(struct Sprite* sprite) if ((u16)gBattleAnimArgs[7] == 0xFFFF) { - sprite->affineAnimPaused = 0; + sprite->affineAnimPaused = FALSE; spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); sprite->data[0] = 0x100; sprite->callback = AnimConstrictBindingStep2; @@ -2908,11 +2848,11 @@ void AnimMimicOrb(struct Sprite* sprite) sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X) + gBattleAnimArgs[0]; sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + gBattleAnimArgs[1]; - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->data[0]++; break; case 1: - sprite->invisible = 0; + sprite->invisible = FALSE; if (sprite->affineAnimEnded) { ChangeSpriteAffineAnim(sprite, 1); @@ -3930,15 +3870,15 @@ void sub_80A4738(struct Sprite* sprite) { if (sprite->data[3] & 1) { - sprite->invisible = 0; - gSprites[sprite->data[0]].invisible = 0; - gSprites[sprite->data[1]].invisible = 0; + sprite->invisible = FALSE; + gSprites[sprite->data[0]].invisible = FALSE; + gSprites[sprite->data[1]].invisible = FALSE; } else { - sprite->invisible = 1; - gSprites[sprite->data[0]].invisible = 1; - gSprites[sprite->data[1]].invisible = 1; + sprite->invisible = TRUE; + gSprites[sprite->data[0]].invisible = TRUE; + gSprites[sprite->data[1]].invisible = TRUE; } sprite->data[2] = 0; @@ -4048,7 +3988,7 @@ static void AnimProtectStep(struct Sprite *sprite) SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16 - sprite->data[7], sprite->data[7])); if (sprite->data[7] == 16) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->callback = DestroyAnimSpriteAndDisableBlend; } } @@ -4132,7 +4072,7 @@ static void AnimMilkBottleStep1(struct Sprite* sprite) } break; case 3: - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->data[0]++; break; case 4: @@ -4386,7 +4326,7 @@ static void AnimLockOnTargetStep4(struct Sprite* sprite) sprite->data[1] = 0; } - BlendPalettes(sub_8075BE8(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB(31, 31, 31)); + BlendPalettes(sub_8075BE8(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB_WHITE); if (sprite->data[1] == 16) { int pal; @@ -4458,7 +4398,7 @@ void AnimLockOnMoveTarget(struct Sprite* sprite) void AnimBowMon(struct Sprite* sprite) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->data[0] = 0; switch (gBattleAnimArgs[0]) { @@ -5228,7 +5168,7 @@ void AnimTask_DoubleTeam(u8 taskId) for (i = 1; i < 16; i++) gPlttBufferUnfaded[r3 + i] = gPlttBufferUnfaded[r4 + i]; - BlendPalette(r3, 16, 11, RGB(0, 0, 0)); + BlendPalette(r3, 16, 11, RGB_BLACK); task->data[3] = 0; i = 0; while (i < 2 && (obj = CloneBattlerSpriteWithBlend(0)) >= 0) @@ -5303,17 +5243,17 @@ void AnimTask_MusicNotesRainbowBlend(u8 taskId) if (index != 0xFF) { index = (index << 4) + 0x100; - for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable[0]); i++) + for (i = 1; i < NELEMS(gParticlesColorBlendTable[0]); i++) gPlttBufferFaded[index + i] = gParticlesColorBlendTable[0][i]; } - for (j = 1; j < ARRAY_COUNT(gParticlesColorBlendTable); j++) + for (j = 1; j < NELEMS(gParticlesColorBlendTable); j++) { index = AllocSpritePalette(gParticlesColorBlendTable[j][0]); if (index != 0xFF) { index = (index << 4) + 0x100; - for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable[0]); i++) + for (i = 1; i < NELEMS(gParticlesColorBlendTable[0]); i++) gPlttBufferFaded[index + i] = gParticlesColorBlendTable[j][i]; } } @@ -5325,7 +5265,7 @@ void AnimTask_MusicNotesClearRainbowBlend(u8 taskId) { u16 i; - for (i = 1; i < ARRAY_COUNT(gParticlesColorBlendTable); i++) + for (i = 1; i < NELEMS(gParticlesColorBlendTable); i++) FreeSpritePaletteByTag(gParticlesColorBlendTable[i][0]); DestroyAnimVisualTask(taskId); diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index b58a88799..2a1ee41e2 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -15,47 +15,6 @@ #include "util.h" #include "constants/songs.h" -void sub_80A6E48(struct Sprite *); -void sub_80A6E98(struct Sprite *); -void sub_80A6F8C(struct Sprite *); -void sub_80A7020(struct Sprite *); -void Anim_KinesisZapEnergy(struct Sprite *); -void Anim_SwordsDanceBlade(struct Sprite *); -void AnimSonicBoomProjectile(struct Sprite *); -void AnimAirWaveProjectile(struct Sprite *); -void sub_80A79E8(struct Sprite *); -void AnimCoinThrow(struct Sprite *); -void AnimFallingCoin(struct Sprite *); -void AnimBulletSeed(struct Sprite *); -void AnimRazorWindTornado(struct Sprite *); -void AnimViceGripPincer(struct Sprite *); -void AnimGuillotinePincer(struct Sprite *); -void AnimBreathPuff(struct Sprite *); -void AnimAngerMark(struct Sprite *); -void AnimPencil(struct Sprite *); -void AnimBlendThinRing(struct Sprite *); -void AnimHyperVoiceRing(struct Sprite *); -void AnimUproarRing(struct Sprite *); -void AnimSoftBoiledEgg(struct Sprite *); -void AnimSpeedDust(struct Sprite *); -void AnimHealBellMusicNote(struct Sprite *); -void AnimMagentaHeart(struct Sprite *); -void AnimRedHeartProjectile(struct Sprite *); -void AnimParticuleBurst(struct Sprite *); -void AnimRedHeartRising(struct Sprite *); -void AnimOrbitFast(struct Sprite *); -void AnimOrbitScatter(struct Sprite *); -void AnimSpitUpOrb(struct Sprite *); -void AnimEyeSparkle(struct Sprite *); -void AnimAngel(struct Sprite *); -void AnimPinkHeart(struct Sprite *); -void AnimDevil(struct Sprite *); -void AnimFurySwipes(struct Sprite *); -void AnimMovementWaves(struct Sprite *); -void AnimJaggedMusicNote(struct Sprite *); -void AnimPerishSongMusicNote2(struct Sprite *); -void AnimPerishSongMusicNote(struct Sprite *); -void AnimGuardRing(struct Sprite *); static void sub_80A6ED8(struct Sprite *); static void sub_80A7058(struct Sprite *); static void sub_80A7080(struct Sprite *); @@ -105,8 +64,6 @@ static void AnimPerishSongMusicNote_Step1(struct Sprite *); static void AnimPerishSongMusicNote_Step2(struct Sprite *); // Data -extern const union AffineAnimCmd *const gUnknown_83E7910[]; -extern const union AnimCmd *const gMusicNotesAnimTable[]; // Unused const struct SpriteTemplate gUnknown_83E3ADC = { @@ -289,11 +246,11 @@ const union AffineAnimCmd gGrowingRingAffineAnimCmds[] = const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0x5, 0x5, 0, 10), - AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(-10, -10, 0, 10), AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), - AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(-10, -10, 0, 10), AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), - AFFINEANIMCMD_FRAME(0xFFF6, 0xFFF6, 0, 10), + AFFINEANIMCMD_FRAME(-10, -10, 0, 10), AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), AFFINEANIMCMD_END, }; @@ -583,7 +540,7 @@ const struct SpriteTemplate gBreathPuffSpriteTemplate = const union AffineAnimCmd gAngerMarkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0xB, 0xB, 0, 8), - AFFINEANIMCMD_FRAME(0xFFF5, 0xFFF5, 0, 8), + AFFINEANIMCMD_FRAME(-11, -11, 0, 8), AFFINEANIMCMD_END, }; @@ -676,10 +633,10 @@ const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds2[] = const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = { - AFFINEANIMCMD_FRAME(0xFFF8, 0x4, 0, 8), + AFFINEANIMCMD_FRAME(-8, 0x4, 0, 8), AFFINEANIMCMD_LOOP(0), - AFFINEANIMCMD_FRAME(0x10, 0xFFF8, 0, 8), - AFFINEANIMCMD_FRAME(0xFFF0, 0x8, 0, 8), + AFFINEANIMCMD_FRAME(0x10, -8, 0, 8), + AFFINEANIMCMD_FRAME(-16, 0x8, 0, 8), AFFINEANIMCMD_LOOP(1), AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 15), @@ -750,7 +707,7 @@ const struct SpriteTemplate gThinRingExpandingSpriteTemplate = const union AffineAnimCmd gThinRingShrinkingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), - AFFINEANIMCMD_FRAME(0xFFF0, 0xFFF0, 0, 30), + AFFINEANIMCMD_FRAME(-16, -16, 0, 30), AFFINEANIMCMD_END_ALT(1), }; @@ -908,8 +865,8 @@ const struct SpriteTemplate gMagentaHeartSpriteTemplate = const union AffineAnimCmd gUnknown_83E4200[] = { - AFFINEANIMCMD_FRAME(0x000A, 0xFFF3, 0x00, 0x0A), - AFFINEANIMCMD_FRAME(0xFFF6, 0x000D, 0x00, 0x0A), + AFFINEANIMCMD_FRAME(0xA, -13, 0x0, 0xA), + AFFINEANIMCMD_FRAME(-10, 0xD, 0x0, 0xA), AFFINEANIMCMD_END, }; @@ -1340,7 +1297,7 @@ void sub_80A6F8C(struct Sprite *sprite) sprite->data[1] = gBattleAnimArgs[3]; sprite->data[2] = spriteId; sprite->callback = sub_80A6F3C; - sprite->invisible = 1; + sprite->invisible = TRUE; } void sub_80A7020(struct Sprite *sprite) @@ -1439,14 +1396,14 @@ void Anim_KinesisZapEnergy(struct Sprite *sprite) sprite->pos1.y += gBattleAnimArgs[1]; if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) { - sprite->hFlip = 1; + sprite->hFlip = TRUE; if (gBattleAnimArgs[2]) - sprite->vFlip = 1; + sprite->vFlip = TRUE; } else { if (gBattleAnimArgs[2]) - sprite->vFlip = 1; + sprite->vFlip = TRUE; } sprite->callback = RunStoredCallbackWhenAnimEnds; @@ -1633,7 +1590,7 @@ static void AirCutterProjectileStep1(u8 taskId) gTasks[taskId].data[gTasks[taskId].data[1] + 13] = spriteId; gTasks[taskId].data[0] = gTasks[taskId].data[3]; gTasks[taskId].data[1]++; - PlaySE12WithPanning(SE_W059B, BattleAnimAdjustPanning(-63)); + PlaySE12WithPanning(SE_W059B, BattleAnimAdjustPanning(-SOUND_PAN_TARGET)); if (gTasks[taskId].data[1] > 2) gTasks[taskId].func = AirCutterProjectileStep2; } @@ -1821,7 +1778,7 @@ void AnimBulletSeed(struct Sprite *sprite) sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2); sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET); sprite->callback = StartAnimLinearTranslation; - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; StoreSpriteCallbackInData6(sprite, AnimBulletSeed_Step1); } @@ -1845,7 +1802,7 @@ static void AnimBulletSeed_Step1(struct Sprite *sprite) rand = Random(); sprite->data[7] = (rand % 0xA0) + 0xA0; sprite->callback = AnimBulletSeed_Step2; - sprite->affineAnimPaused = 0; + sprite->affineAnimPaused = FALSE; } static void AnimBulletSeed_Step2(struct Sprite *sprite) @@ -1959,7 +1916,7 @@ static void AnimGuillotinePincerStep1(struct Sprite *sprite) if (AnimTranslateLinear(sprite) && sprite->animEnded) { SeekSpriteAnim(sprite, 0); - sprite->animPaused = 1; + sprite->animPaused = TRUE; sprite->pos1.x += sprite->pos2.x; sprite->pos1.y += sprite->pos2.y; sprite->pos2.x = 2; @@ -1988,7 +1945,7 @@ static void AnimGuillotinePincerStep2(struct Sprite *sprite) sprite->pos2.x = 0; sprite->data[4] = 0; sprite->data[3] = 0; - sprite->animPaused = 0; + sprite->animPaused = FALSE; StartSpriteAnim(sprite, sprite->data[5] ^ 1); sprite->callback = AnimGuillotinePincerStep3; } @@ -2137,7 +2094,7 @@ static void CreateMinimizeSprite(struct Task* task, u8 taskId) gSprites[spriteId].data[2] = 6; gSprites[spriteId].callback = ClonedMinizeSprite_Step; SetSpriteRotScale(spriteId, task->data[4], task->data[4], 0); - gSprites[spriteId].oam.affineMode = 1; + gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_NORMAL; CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode); } } @@ -2492,7 +2449,7 @@ void AnimPencil(struct Sprite *sprite) sprite->data[3] = 16; sprite->data[4] = 0; sprite->data[5] = GetBattlerSpriteCoordAttr(gBattleAnimTarget, BATTLER_COORD_ATTR_HEIGHT) + 2; - sprite->data[6] = BattleAnimAdjustPanning(63); + sprite->data[6] = BattleAnimAdjustPanning(SOUND_PAN_TARGET); sprite->callback = AnimPencil_Step; } @@ -2508,7 +2465,7 @@ static void AnimPencil_Step(struct Sprite *sprite) } if (++sprite->data[1] > 16) { - sprite->invisible = 0; + sprite->invisible = FALSE; sprite->data[0]++; } break; @@ -2548,7 +2505,7 @@ static void AnimPencil_Step(struct Sprite *sprite) } if (++sprite->data[1] > 16) { - sprite->invisible = 0; + sprite->invisible = FALSE; DestroyAnimSprite(sprite); } break; @@ -2783,7 +2740,7 @@ static void AnimSoftBoiledEgg_Step4(struct Sprite *sprite) { if ((u16)gBattleAnimArgs[7] == 0xFFFF) { - sprite->invisible = 1; + sprite->invisible = TRUE; if (sprite->data[7] == 0) sprite->callback = AnimSoftBoiledEgg_Step4_Callback; else @@ -2815,7 +2772,7 @@ static void StretchAttacker_Step(u8 taskId) if (!RunAffineAnimFromTaskData(task)) { gSprites[task->data[0]].pos2.y = 0; - gSprites[task->data[0]].invisible = 1; + gSprites[task->data[0]].invisible = TRUE; DestroyAnimVisualTask(taskId); } } @@ -2913,9 +2870,9 @@ static void ExtremeSpeedMonReappear_Step(u8 taskId) { task->data[1] = 0; if (++task->data[2] & 1) - gSprites[task->data[15]].invisible = 0; + gSprites[task->data[15]].invisible = FALSE; else - gSprites[task->data[15]].invisible = 1; + gSprites[task->data[15]].invisible = TRUE; if (++task->data[3] >= task->data[13]) { @@ -2927,7 +2884,7 @@ static void ExtremeSpeedMonReappear_Step(u8 taskId) } else { - gSprites[task->data[15]].invisible = 0; + gSprites[task->data[15]].invisible = FALSE; DestroyAnimVisualTask(taskId); } } @@ -3104,10 +3061,10 @@ void AnimTask_FakeOut(u8 taskId) gBattle_WIN0V = 0xA0; SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H); SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); - SetGpuReg(REG_OFFSET_WININ, 0x3F1F); - SetGpuReg(REG_OFFSET_WINOUT, 0x3F3F); + SetGpuReg(REG_OFFSET_WININ, WININ_WIN1_CLR | WININ_WIN1_OBJ | WININ_WIN1_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_BG_ALL); + SetGpuReg(REG_OFFSET_WINOUT, WININ_WIN1_CLR | WININ_WIN1_OBJ | WININ_WIN1_BG_ALL | WININ_WIN0_CLR | WININ_WIN0_OBJ | WININ_WIN0_BG_ALL); SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_DARKEN); - SetGpuReg(REG_OFFSET_BLDY, 0x10); + SetGpuReg(REG_OFFSET_BLDY, BLDCNT_TGT1_OBJ); gTasks[taskId].data[0] = win0v; gTasks[taskId].data[1] = win0h; gTasks[taskId].func = FakeOutStep1; @@ -3134,7 +3091,7 @@ static void FakeOutStep2(u8 taskId) { gTasks[taskId].data[11] = 0x88; SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_LIGHTEN); - BlendPalettes(sub_8075BE8(1, 0, 0, 0, 0, 0, 0), 16, RGB(31, 31, 31)); + BlendPalettes(sub_8075BE8(1, 0, 0, 0, 0, 0, 0), 16, RGB_WHITE); } else if (gTasks[taskId].data[10] > 4) { @@ -3442,7 +3399,7 @@ void AnimOrbitFast(struct Sprite *sprite) { sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; sprite->data[0] = gBattleAnimArgs[0]; sprite->data[1] = gBattleAnimArgs[1]; sprite->data[7] = GetBattlerSpriteSubpriority(gBattleAnimAttacker); @@ -3744,7 +3701,7 @@ void AnimPerishSongMusicNote2(struct Sprite *sprite) if (!sprite->data[0]) { sprite->data[1] = 120 - gBattleAnimArgs[0]; - sprite->invisible = 1; + sprite->invisible = TRUE; } if (++sprite->data[0] == sprite->data[1]) diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 4bb839a02..3faaa88ab 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -23,46 +23,6 @@ #include "constants/weather.h" // Function Declarations -void AnimBlackSmoke(struct Sprite *); -void AnimWhiteHalo(struct Sprite *); -void AnimTealAlert(struct Sprite *); -void AnimMeanLookEye(struct Sprite *); -void AnimSpikes(struct Sprite *); -void AnimLeer(struct Sprite *); -void AnimLetterZ(struct Sprite *); -void AnimFang(struct Sprite *); -void AnimSpotlight(struct Sprite *); -void AnimClappingHand(struct Sprite *); -void AnimClappingHand2(struct Sprite *); -void AnimRapidSpin(struct Sprite *); -void AnimTriAttackTriangle(struct Sprite *); -void AnimBatonPassPokeball(struct Sprite *); -void AnimWishStar(struct Sprite *); -void AnimMiniTwinklingStar(struct Sprite *); -void AnimSwallowBlueOrb(struct Sprite *); -void AnimGreenStar(struct Sprite *); -void AnimWeakFrustrationAngerMark(struct Sprite *); -void AnimSweetScentPetal(struct Sprite *); -void AnimPainSplitProjectile(struct Sprite *); -void AnimFlatterConfetti(struct Sprite *); -void AnimFlatterSpotlight(struct Sprite *); -void AnimReversalOrb(struct Sprite *); -void AnimYawnCloud(struct Sprite *); -void AnimSmokeBallEscapeCloud(struct Sprite *); -void AnimFacadeSweatDrop(struct Sprite *); -void AnimRoarNoiseLine(struct Sprite *); -void AnimGlareEyeDot(struct Sprite *); -void AnimAssistPawprint(struct Sprite *); -void AnimSmellingSaltsHand(struct Sprite *); -void AnimSmellingSaltExclamation(struct Sprite *); -void AnimHelpingHandClap(struct Sprite *); -void AnimForesightMagnifyingGlass(struct Sprite *); -void AnimMeteorMashStar(struct Sprite *); -void AnimBlockX(struct Sprite *); -void sub_80E3E84(struct Sprite *); -void AnimParticuleBurst(struct Sprite *); -void AnimKnockOffStrike(struct Sprite *); -void AnimRecycle(struct Sprite *); static void AnimBlackSmokeStep(struct Sprite *); static void AnimWhiteHalo_Step1(struct Sprite *); static void AnimWhiteHalo_Step2(struct Sprite *); @@ -119,8 +79,6 @@ static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); // Data -extern const struct SpriteTemplate gThoughtBubbleSpriteTemplate; - const union AnimCmd gScratchAnimCmds[] = { ANIMCMD_FRAME(0, 4), @@ -1634,7 +1592,7 @@ static void AnimClappingHand_Step(struct Sprite *sprite) sprite->data[2]++; if (sprite->data[3] == 0) { - PlaySE1WithPanning(SE_W227, BattleAnimAdjustPanning(-64)); + PlaySE1WithPanning(SE_W227, BattleAnimAdjustPanning(SOUND_PAN_ATTACKER)); } } } @@ -1664,18 +1622,18 @@ void AnimTask_CreateSpotlight(u8 taskId) { if (IsContest()) { - SetGpuReg(REG_OFFSET_WININ, 0x1F3F); - gBattle_WIN1H = 0x98F0; - gBattle_WIN1V = 0x00A0; + SetGpuReg(REG_OFFSET_WININ, WININ_WIN1_OBJ | WININ_WIN1_BG_ALL | WININ_WIN0_CLR | WININ_WIN0_OBJ | WININ_WIN0_BG_ALL); + gBattle_WIN1H = WININ_WIN1_OBJ | WININ_WIN1_BG3 | WIN_RANGE(0, 0xF0) | WIN_RANGE(0x80, 0x0); + gBattle_WIN1V = WININ_WIN0_CLR | WIN_RANGE(0, 0x80); SetGpuReg(REG_OFFSET_WIN1H, gBattle_WIN0H); SetGpuReg(REG_OFFSET_WIN1V, gBattle_WIN0V); } else { SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ); - gBattle_WIN1H = 0x00F0; - gBattle_WIN1V = 0x78A0; - SetGpuReg(REG_OFFSET_WIN1H, 0x00F0); + gBattle_WIN1H = WIN_RANGE(0, 0xF0); + gBattle_WIN1V = WININ_WIN0_CLR | WIN_RANGE(0, 0x80) | WININ_WIN1_BG3 | WININ_WIN1_OBJ | WININ_WIN1_CLR | WIN_RANGE(0x40, 0); + SetGpuReg(REG_OFFSET_WIN1H, WIN_RANGE(0, 0xF0)); SetGpuReg(REG_OFFSET_WIN1V, gBattle_WIN1V); SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON); } @@ -1913,7 +1871,7 @@ static void TormentAttacker_Step(u8 taskId) y = task->data[3] + task->data[5]; spriteId = CreateSprite(&gThoughtBubbleSpriteTemplate, x, y, 6 - task->data[1]); - PlaySE12WithPanning(SE_W118, BattleAnimAdjustPanning(-64)); + PlaySE12WithPanning(SE_W118, BattleAnimAdjustPanning(SOUND_PAN_ATTACKER)); if (spriteId != MAX_SPRITES) { @@ -2273,7 +2231,7 @@ void AnimTask_TransformMon(u8 taskId) src = gMonSpritesGfxPtr->sprites[position] + (gBattleMonForms[gBattleAnimAttacker] << 11); dest = animBg.bgTiles; - CpuSet(src, dest, 0x4000200); + CpuCopy32(src, dest, 0x800); LoadBgTiles(1, animBg.bgTiles, 0x800, animBg.tilesOffset); gTasks[taskId].data[0]++; break; @@ -2360,7 +2318,7 @@ void AnimTask_MorningSunLightBeam(u8 taskId) gTasks[taskId].data[11] = gBattle_BG1_Y; gTasks[taskId].data[0]++; - PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(-64)); + PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(SOUND_PAN_ATTACKER)); break; break; case 1: @@ -2396,7 +2354,7 @@ void AnimTask_MorningSunLightBeam(u8 taskId) { gTasks[taskId].data[3] = 0; gTasks[taskId].data[0] = 1; - PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(-64)); + PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(SOUND_PAN_ATTACKER)); } break; case 4: @@ -3134,7 +3092,7 @@ static void AnimReversalOrbStep(struct Sprite *sprite) // Copies the target mon's sprite, and makes a white silhouette that shrinks away. void AnimTask_RolePlaySilhouette(u8 taskId) { - u8 isBackPic; + bool8 isBackPic; u32 personality; u32 otId; u16 species; @@ -3146,7 +3104,7 @@ void AnimTask_RolePlaySilhouette(u8 taskId) GetAnimBattlerSpriteId(ANIM_ATTACKER); if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) { - isBackPic = 0; + isBackPic = FALSE; personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) @@ -3166,7 +3124,7 @@ void AnimTask_RolePlaySilhouette(u8 taskId) } else { - isBackPic = 1; + isBackPic = TRUE; personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_PERSONALITY); otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimTarget]], MON_DATA_OT_ID); if (gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].transformSpecies == SPECIES_NONE) @@ -3797,7 +3755,7 @@ static void AnimTask_FacadeColorBlendStep(u8 taskId) } else { - BlendPalette(gTasks[taskId].data[2], 16, 0, RGB(0, 0, 0)); + BlendPalette(gTasks[taskId].data[2], 16, 0, RGB_BLACK); DestroyAnimVisualTask(taskId); } } @@ -3825,7 +3783,7 @@ void AnimRoarNoiseLine(struct Sprite *sprite) } else if (gBattleAnimArgs[2] == 1) { - sprite->vFlip = 1; + sprite->vFlip = TRUE; sprite->data[0] = 0x280; sprite->data[1] = 0x280; } @@ -3838,7 +3796,7 @@ void AnimRoarNoiseLine(struct Sprite *sprite) if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) { sprite->data[0] = -sprite->data[0]; - sprite->hFlip = 1; + sprite->hFlip = TRUE; } sprite->callback = AnimRoarNoiseLineStep; @@ -4673,7 +4631,7 @@ static void AnimTask_MonToSubstituteDoll(u8 taskId) if (gSprites[spriteId].pos2.y == 0) { - PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(SOUND_PAN_ATTACKER)); gTasks[taskId].data[10] -= 0x800; gTasks[taskId].data[0]++; } @@ -4695,7 +4653,7 @@ static void AnimTask_MonToSubstituteDoll(u8 taskId) if (gSprites[spriteId].pos2.y == 0) { - PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(SOUND_PAN_ATTACKER)); DestroyAnimVisualTask(taskId); } break; @@ -4732,7 +4690,7 @@ static void AnimBlockXStep(struct Sprite *sprite) sprite->pos2.y += 10; if (sprite->pos2.y >= 0) { - PlaySE12WithPanning(SE_W166, BattleAnimAdjustPanning(63)); + PlaySE12WithPanning(SE_W166, BattleAnimAdjustPanning(SOUND_PAN_TARGET)); sprite->pos2.y = 0; sprite->data[0]++; } @@ -4742,7 +4700,7 @@ static void AnimBlockXStep(struct Sprite *sprite) sprite->pos2.y = -(gSineTable[sprite->data[1]] >> 3); if (sprite->data[1] > 0x7F) { - PlaySE12WithPanning(SE_W166, BattleAnimAdjustPanning(63)); + PlaySE12WithPanning(SE_W166, BattleAnimAdjustPanning(SOUND_PAN_TARGET)); sprite->data[1] = 0; sprite->pos2.y = 0; sprite->data[0]++; @@ -4761,7 +4719,7 @@ static void AnimBlockXStep(struct Sprite *sprite) case 3: if (++sprite->data[1] > 8) { - PlaySE12WithPanning(SE_W043, BattleAnimAdjustPanning(63)); + PlaySE12WithPanning(SE_W043, BattleAnimAdjustPanning(SOUND_PAN_TARGET)); sprite->data[1] = 0; sprite->data[0]++; } @@ -5694,7 +5652,7 @@ void sub_80E3E84(struct Sprite *sprite) case 0: if (gBattleAnimArgs[7] == -1) { - PlaySE12WithPanning(SE_W233, BattleAnimAdjustPanning(63)); + PlaySE12WithPanning(SE_W233, BattleAnimAdjustPanning(SOUND_PAN_TARGET)); sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + 16; sprite->data[0] = -32; sprite->data[7]++; diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 46bcc2cbb..8390857bb 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -370,7 +370,7 @@ const u16 gBallOpenFadeColors[] = [BALL_PREMIER] = RGB(31, 9, 10), // Unused - RGB(0, 0, 0), + RGB_BLACK, RGB(1, 16, 0), RGB(3, 0, 1), RGB(1, 8, 0), @@ -413,9 +413,6 @@ const struct SpriteTemplate gUnknown_840C210 = .callback = sub_80F1B3C, }; -extern const struct SpriteTemplate gWishStarSpriteTemplate; -extern const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate; - // Functions void sub_80EEC0C(u8 taskId) { @@ -639,7 +636,7 @@ void sub_80EF298(u8 taskId) break; case 2: ResetSpriteRotScale(spriteId); - gSprites[spriteId].invisible = 1; + gSprites[spriteId].invisible = TRUE; DestroyAnimVisualTask(taskId); break; } @@ -918,7 +915,7 @@ static void sub_80EFA0C(struct Sprite *sprite) break; case 2: ResetSpriteRotScale(spriteId); - gSprites[spriteId].invisible = 1; + gSprites[spriteId].invisible = TRUE; gTasks[taskId].data[0]++; break; default: @@ -954,7 +951,7 @@ static void sub_80EFB9C(struct Sprite *sprite) bool8 lastBounce; int bounceCount; - lastBounce = 0; + lastBounce = FALSE; switch (sprite->data[3] & 0xFF) { case 0: @@ -967,7 +964,7 @@ static void sub_80EFB9C(struct Sprite *sprite) bounceCount = sprite->data[3] >> 8; if (bounceCount == 4) - lastBounce = 1; + lastBounce = TRUE; // Play a different sound effect for each pokeball bounce. switch (bounceCount) @@ -1022,7 +1019,7 @@ static void sub_80EFCA0(struct Sprite *sprite) if (++sprite->data[3] == 31) { sprite->data[3] = 0; - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; StartSpriteAffineAnim(sprite, 1); gBattleSpritesDataPtr->animationData->field_C = 0; sprite->callback = sub_80EFCEC; @@ -1049,7 +1046,7 @@ static void sub_80EFCEC(struct Sprite *sprite) } sprite->data[5]++; - sprite->affineAnimPaused = 0; + sprite->affineAnimPaused = FALSE; var0 = sprite->data[5] + 7; if (var0 > 14) { @@ -1064,7 +1061,7 @@ static void sub_80EFCEC(struct Sprite *sprite) sprite->data[5] = 0; sprite->data[4] = -sprite->data[4]; sprite->data[3]++; - sprite->affineAnimPaused = 0; + sprite->affineAnimPaused = FALSE; if (sprite->data[4] < 0) ChangeSpriteAffineAnim(sprite, 2); else @@ -1072,7 +1069,7 @@ static void sub_80EFCEC(struct Sprite *sprite) } else { - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; } break; case 2: @@ -1087,7 +1084,7 @@ static void sub_80EFCEC(struct Sprite *sprite) } sprite->data[5]++; - sprite->affineAnimPaused = 0; + sprite->affineAnimPaused = FALSE; var0 = sprite->data[5] + 12; if (var0 > 24) { @@ -1099,14 +1096,14 @@ static void sub_80EFCEC(struct Sprite *sprite) case 3: if (sprite->data[5]++ < 0) { - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; break; } sprite->data[5] = 0; sprite->data[4] = -sprite->data[4]; sprite->data[3]++; - sprite->affineAnimPaused = 0; + sprite->affineAnimPaused = FALSE; if (sprite->data[4] < 0) ChangeSpriteAffineAnim(sprite, 2); else @@ -1124,7 +1121,7 @@ static void sub_80EFCEC(struct Sprite *sprite) } sprite->data[5]++; - sprite->affineAnimPaused = 0; + sprite->affineAnimPaused = FALSE; var0 = sprite->data[5] + 4; if (var0 > 8) { @@ -1139,7 +1136,7 @@ static void sub_80EFCEC(struct Sprite *sprite) state = sprite->data[3] >> 8; if (state == gBattleSpritesDataPtr->animationData->ballThrowCaseId) { - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; sprite->callback = sub_80EFF80; } else @@ -1147,12 +1144,12 @@ static void sub_80EFCEC(struct Sprite *sprite) if (gBattleSpritesDataPtr->animationData->ballThrowCaseId == BALL_3_SHAKES_SUCCESS && state == 3) { sprite->callback = sub_80EFFA4; - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; } else { sprite->data[3]++; - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; } } break; @@ -1185,7 +1182,7 @@ static void sub_80EFF80(struct Sprite *sprite) static void sub_80EFFA4(struct Sprite *sprite) { - sprite->animPaused = 1; + sprite->animPaused = TRUE; sprite->callback = sub_80EFFC4; sprite->data[3] = 0; sprite->data[4] = 0; @@ -1200,12 +1197,12 @@ static void sub_80EFFC4(struct Sprite *sprite) if (sprite->data[4] == 40) { PlaySE(SE_GETTING); - BlendPalettes(0x10000 << sprite->oam.paletteNum, 6, RGB(0, 0, 0)); + BlendPalettes(0x10000 << sprite->oam.paletteNum, 6, RGB_BLACK); sub_80F01B8(sprite); } else if (sprite->data[4] == 60) { - BeginNormalPaletteFade(0x10000 << sprite->oam.paletteNum, 2, 6, 0, RGB(0, 0, 0)); + BeginNormalPaletteFade(0x10000 << sprite->oam.paletteNum, 2, 6, 0, RGB_BLACK); } else if (sprite->data[4] == 95) { @@ -1236,7 +1233,7 @@ static void sub_80F00A4(struct Sprite *sprite) SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(16, 0)); paletteIndex = IndexOfSpritePaletteTag(sprite->template->paletteTag); - BeginNormalPaletteFade(1 << (paletteIndex + 0x10), 0, 0, 16, RGB(31, 31, 31)); + BeginNormalPaletteFade(1 << (paletteIndex + 0x10), 0, 0, 16, RGB_WHITE); sprite->data[0]++; break; case 1: @@ -1250,7 +1247,7 @@ static void sub_80F00A4(struct Sprite *sprite) } break; case 2: - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->data[0]++; break; default: @@ -1333,7 +1330,7 @@ static void sub_80F02B0(struct Sprite *sprite) break; } - gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible = 0; + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].invisible = FALSE; StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[gBattleAnimTarget]], 1); AnimateSprite(&gSprites[gBattlerSpriteIds[gBattleAnimTarget]]); gSprites[gBattlerSpriteIds[gBattleAnimTarget]].data[1] = 0x1000; @@ -1341,10 +1338,10 @@ static void sub_80F02B0(struct Sprite *sprite) static void sub_80F0378(struct Sprite *sprite) { - int next = FALSE; + bool32 next = FALSE; if (sprite->animEnded) - sprite->invisible = 1; + sprite->invisible = TRUE; if (gSprites[gBattlerSpriteIds[gBattleAnimTarget]].affineAnimEnded) { @@ -1374,8 +1371,7 @@ static void sub_80F0478(struct Sprite *sprite) sprite->pos1.x += sprite->pos2.x; sprite->pos1.y += sprite->pos2.y; - sprite->pos2.y = 0; - sprite->pos2.x = 0; + sprite->pos2.x = sprite->pos2.y = 0; for (i = 0; i < 6; i++) sprite->data[i] = 0; @@ -1880,7 +1876,7 @@ static void DestroyBallOpenAnimationParticle(struct Sprite *sprite) } } -u8 LaunchBallFadeMonTask(u8 unfadeLater, u8 battler, u32 selectedPalettes, u8 ballId) +u8 LaunchBallFadeMonTask(bool8 unfadeLater, u8 battler, u32 selectedPalettes, u8 ballId) { u8 taskId; @@ -1903,7 +1899,7 @@ u8 LaunchBallFadeMonTask(u8 unfadeLater, u8 battler, u32 selectedPalettes, u8 ba gTasks[taskId].func = sub_80F1370; } - BeginNormalPaletteFade(selectedPalettes, 0, 0, 16, RGB(31, 31, 31)); + BeginNormalPaletteFade(selectedPalettes, 0, 0, 16, RGB_WHITE); return taskId; } @@ -1920,7 +1916,7 @@ static void sub_80F12E0(u8 taskId) else if (!gPaletteFade.active) { u32 selectedPalettes = (u16)gTasks[taskId].data[10] | ((u16)gTasks[taskId].data[11] << 16); - BeginNormalPaletteFade(selectedPalettes, 0, 16, 0, RGB(31, 31, 31)); + BeginNormalPaletteFade(selectedPalettes, 0, 16, 0, RGB_WHITE); DestroyTask(taskId); } } @@ -1930,7 +1926,7 @@ static void sub_80F1370(u8 taskId) if (!gPaletteFade.active) { u32 selectedPalettes = (u16)gTasks[taskId].data[10] | ((u16)gTasks[taskId].data[11] << 16); - BeginNormalPaletteFade(selectedPalettes, 0, 16, 0, RGB(31, 31, 31)); + BeginNormalPaletteFade(selectedPalettes, 0, 16, 0, RGB_WHITE); gTasks[taskId].func = sub_80F13C0; } } @@ -1955,7 +1951,7 @@ void sub_80F1420(u8 taskId) { u8 spriteId; u32 x; - u32 done = FALSE; + bool32 done = FALSE; spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; switch (gTasks[taskId].data[10]) @@ -2057,12 +2053,12 @@ void AnimTask_TargetToEffectBattler(u8 taskId) void sub_80F1720(u8 battler, struct Pokemon *mon) { - int isShiny; + bool32 isShiny; u32 otId, personality; u32 shinyValue; u8 taskId1, taskId2; - isShiny = 0; + isShiny = FALSE; gBattleSpritesDataPtr->healthBoxesData[battler].flag_x80 = 1; otId = GetMonData(mon, MON_DATA_OT_ID); personality = GetMonData(mon, MON_DATA_PERSONALITY); @@ -2135,7 +2131,7 @@ static void sub_80F181C(u8 taskId) gSprites[spriteId].oam.tileNum += 5; } - if (gTasks[taskId].data[1] == 0) + if (gTasks[taskId].data[1] == FALSE) { gSprites[spriteId].callback = sub_80F1A2C; } @@ -2144,13 +2140,13 @@ static void sub_80F181C(u8 taskId) gSprites[spriteId].callback = sub_80F1A80; gSprites[spriteId].pos2.x = -32; gSprites[spriteId].pos2.y = 32; - gSprites[spriteId].invisible = 1; - if (gTasks[taskId].data[11] == 0) + gSprites[spriteId].invisible = TRUE; + if (gTasks[taskId].data[11] == FALSE) { if (GetBattlerSide(battler) == B_SIDE_PLAYER) - pan = -64; + pan = SOUND_PAN_ATTACKER; else - pan = 63; + pan = SOUND_PAN_TARGET; PlaySE12WithPanning(SE_REAPOKE, pan); } @@ -2169,9 +2165,9 @@ static void sub_80F19E0(u8 taskId) { u8 battler; - if (gTasks[taskId].data[12] == 0) + if (gTasks[taskId].data[12] == FALSE) { - if (gTasks[taskId].data[1] == 1) + if (gTasks[taskId].data[1] == TRUE) { battler = gTasks[taskId].data[0]; gBattleSpritesDataPtr->healthBoxesData[battler].field_1_x1 = 1; @@ -2202,7 +2198,7 @@ static void sub_80F1A80(struct Sprite *sprite) } else { - sprite->invisible = 0; + sprite->invisible = FALSE; sprite->pos2.x += 5; sprite->pos2.y -= 5; if (sprite->pos2.x > 32) @@ -2254,7 +2250,7 @@ static void sub_80F1C04(struct Sprite *sprite) if (TranslateAnimHorizontalArc(sprite)) { sprite->data[0] = 0; - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->callback = sub_80F1C30; } } diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c index 1e05e0e68..afa0c5c42 100644 --- a/src/battle_anim_status_effects.c +++ b/src/battle_anim_status_effects.c @@ -23,10 +23,6 @@ static void sub_807834C(struct Sprite *sprite); static void sub_8078380(struct Sprite *sprite); // Data -extern const struct CompressedSpriteSheet gBattleAnimPicTable[]; -extern const struct CompressedSpritePalette gBattleAnimPaletteTable[]; -extern const u8 *const gBattleAnims_StatusConditions[]; - static const union AnimCmd gUnknown_83BF3E0[] = { ANIMCMD_FRAME(0, 3), @@ -207,15 +203,15 @@ const u8 gUnknown_83BF52C[] = _("TASK OVER\nタスクがオ-バ-しました"); static const struct Subsprite gSubsprites_83BF544[] = { - {.x = -16, .y = -16, .shape = ST_OAM_SQUARE, .size = 3, .tileOffset = 0, .priority = 2}, - {.x = -16, .y = 48, .shape = ST_OAM_H_RECTANGLE, .size = 3, .tileOffset = 64, .priority = 2}, - {.x = 48, .y = -16, .shape = ST_OAM_V_RECTANGLE, .size = 3, .tileOffset = 96, .priority = 2}, - {.x = 48, .y = 48, .shape = ST_OAM_SQUARE, .size = 2, .tileOffset = 128, .priority = 2}, + {.x = -16, .y = -16, .shape = SPRITE_SHAPE(8x8), .size = 3, .tileOffset = 0, .priority = 2}, + {.x = -16, .y = 48, .shape = SPRITE_SHAPE(16x8), .size = 3, .tileOffset = 64, .priority = 2}, + {.x = 48, .y = -16, .shape = SPRITE_SHAPE(8x16), .size = 3, .tileOffset = 96, .priority = 2}, + {.x = 48, .y = 48, .shape = SPRITE_SHAPE(8x8), .size = 2, .tileOffset = 128, .priority = 2}, }; static const struct SubspriteTable gUnknown_83BF554[] = { - {ARRAY_COUNT(gSubsprites_83BF544), gSubsprites_83BF544}, + {NELEMS(gSubsprites_83BF544), gSubsprites_83BF544}, }; static const struct SpriteTemplate gUnknown_83BF55C = @@ -361,7 +357,7 @@ void sub_80783FC(u8 taskId) SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); spriteId = CreateSprite(&gUnknown_83BF55C, x, y, 4); - if (GetSpriteTileStartByTag(ANIM_TAG_ICE_CUBE) == 0xFFFF) + if (GetSpriteTileStartByTag(ANIM_TAG_ICE_CUBE) == SPRITE_INVALID_TAG) gSprites[spriteId].invisible = TRUE; SetSubspriteTables(&gSprites[spriteId], gUnknown_83BF554); diff --git a/src/mevent_8145654.c b/src/mevent_8145654.c index a35e9e9f8..3de09ab44 100644 --- a/src/mevent_8145654.c +++ b/src/mevent_8145654.c @@ -13,6 +13,7 @@ #include "string_util.h" #include "link_rfu.h" #include "mevent.h" +#include "battle_anim.h" struct UnkStruct_8467FB8 { @@ -59,8 +60,6 @@ void sub_8145D18(u8 whichWindow); void sub_8146060(void); void sub_81461D8(void); -extern const struct OamData gOamData_AffineOff_ObjNormal_32x16; - const u8 gUnknown_8467068[][3] = { {0, 2, 3}, {0, 1, 2} -- cgit v1.2.3 From 949d8638d0f2632344883c457f618153512cf487 Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 14:21:55 -0700 Subject: minor affinecmdframe fix --- src/battle_anim_effects_1.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 1cbbf92de..6a3fdedbb 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -2061,7 +2061,7 @@ const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 11), AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 11), AFFINEANIMCMD_LOOP(2), - AFFINEANIMCMD_FRAME(0xFFE2, 0xFFE2, 0, 8), + AFFINEANIMCMD_FRAME(-0x1D, -0x1D, 0, 8), AFFINEANIMCMD_END, }; -- cgit v1.2.3 From 1d173de35b3d9e8893c515518bf5f2332aea2025 Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 14:23:48 -0700 Subject: compare fix --- src/battle_anim_effects_1.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 6a3fdedbb..6c09f3a5b 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -2061,7 +2061,7 @@ const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 11), AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 11), AFFINEANIMCMD_LOOP(2), - AFFINEANIMCMD_FRAME(-0x1D, -0x1D, 0, 8), + AFFINEANIMCMD_FRAME(-0x1E, -0x1E, 0, 8), AFFINEANIMCMD_END, }; -- cgit v1.2.3 From dc7c82edaa70a90ad10b71a2fec2c3cebe477a6b Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 14:25:05 -0700 Subject: update invis booleans --- src/battle_anim_effects_3.c | 62 ++++++++++++++++++++++----------------------- 1 file changed, 31 insertions(+), 31 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 3faaa88ab..c9c906778 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -1188,7 +1188,7 @@ static void AnimWhiteHalo_Step1(struct Sprite *sprite) SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[1], 16 - sprite->data[1])); if (--sprite->data[1] < 0) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->callback = AnimWhiteHalo_Step2; } } @@ -1245,7 +1245,7 @@ static void AnimMeanLookEye_Step1(struct Sprite *sprite) SetGpuReg(REG_OFFSET_BLDALPHA, 0); StartSpriteAffineAnim(sprite, 1); sprite->data[2] = 0; - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->affineAnimPaused = 1; sprite->callback = AnimMeanLookEye_Step2; } @@ -1255,7 +1255,7 @@ static void AnimMeanLookEye_Step2(struct Sprite *sprite) { if (sprite->data[2]++ > 9) { - sprite->invisible = 0; + sprite->invisible = FALSE; sprite->affineAnimPaused = 0; if (sprite->affineAnimEnded) sprite->callback = AnimMeanLookEye_Step3; @@ -1311,7 +1311,7 @@ static void AnimMeanLookEye_Step4(struct Sprite *sprite) } if (sprite->data[0] == 0) - sprite->invisible = 1; + sprite->invisible = TRUE; if (sprite->data[0] < 0) { @@ -1499,7 +1499,7 @@ void AnimSpotlight(struct Sprite *sprite) SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V); InitSpritePosToAnimTarget(sprite, FALSE); sprite->oam.objMode = ST_OAM_OBJ_WINDOW; - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->callback = AnimSpotlight_Step1; } @@ -1508,7 +1508,7 @@ static void AnimSpotlight_Step1(struct Sprite *sprite) switch (sprite->data[0]) { case 0: - sprite->invisible = 0; + sprite->invisible = FALSE; if (sprite->affineAnimEnded) sprite->data[0]++; break; @@ -1538,7 +1538,7 @@ static void AnimSpotlight_Step1(struct Sprite *sprite) case 5: if (sprite->affineAnimEnded) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->callback = AnimSpotlight_Step2; } break; @@ -1962,13 +1962,13 @@ void AnimTriAttackTriangle(struct Sprite *sprite) { u16 var = sprite->data[0]; if ((var & 1) == 0) - sprite->invisible = 1; + sprite->invisible = TRUE; else - sprite->invisible = 0; + sprite->invisible = FALSE; } if (sprite->data[0] > 30) - sprite->invisible = 0; + sprite->invisible = FALSE; if (sprite->data[0] == 61) { @@ -2029,7 +2029,7 @@ void AnimBatonPassPokeball(struct Sprite *sprite) if (++sprite->data[3] == 9) { sprite->data[3] = 0; - gSprites[spriteId].invisible = 1; + gSprites[spriteId].invisible = TRUE; ResetSpriteRotScale(spriteId); sprite->data[0]++; } @@ -2112,11 +2112,11 @@ static void AnimMiniTwinklingStar_Step(struct Sprite *sprite) else { if (sprite->data[1] == 2) - sprite->invisible = 0; + sprite->invisible = FALSE; if (sprite->data[1] == 3) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->data[1] = -1; } @@ -2400,8 +2400,8 @@ void AnimGreenStar(struct Sprite *sprite) gSprites[spriteId2].data[2] = gBattleAnimArgs[1]; gSprites[spriteId1].data[7] = -1; gSprites[spriteId2].data[7] = -1; - gSprites[spriteId1].invisible = 1; - gSprites[spriteId2].invisible = 1; + gSprites[spriteId1].invisible = TRUE; + gSprites[spriteId2].invisible = TRUE; gSprites[spriteId1].callback = AnimGreenStar_Callback; gSprites[spriteId2].callback = AnimGreenStar_Callback; @@ -2419,19 +2419,19 @@ static void AnimGreenStar_Step1(struct Sprite *sprite) sprite->data[3] &= 0xFF; if (sprite->data[4] == 0 && sprite->pos2.y < -8) { - gSprites[sprite->data[6]].invisible = 0; + gSprites[sprite->data[6]].invisible = FALSE; sprite->data[4]++; } if (sprite->data[4] == 1 && sprite->pos2.y < -16) { - gSprites[sprite->data[7]].invisible = 0; + gSprites[sprite->data[7]].invisible = FALSE; sprite->data[4]++; } if (--sprite->data[1] == -1) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->callback = AnimGreenStar_Step2; } } @@ -2457,7 +2457,7 @@ static void AnimGreenStar_Callback(struct Sprite *sprite) sprite->data[3] &= 0xFF; if (--sprite->data[1] == -1) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->callback = SpriteCallbackDummy; } } @@ -3009,7 +3009,7 @@ void AnimFlatterSpotlight(struct Sprite *sprite) sprite->data[0] = gBattleAnimArgs[2]; InitSpritePosToAnimTarget(sprite, FALSE); sprite->oam.objMode = ST_OAM_OBJ_WINDOW; - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->callback = AnimFlatterSpotlightStep; } @@ -3018,7 +3018,7 @@ static void AnimFlatterSpotlightStep(struct Sprite *sprite) switch (sprite->data[1]) { case 0: - sprite->invisible = 0; + sprite->invisible = FALSE; if (sprite->affineAnimEnded) sprite->data[1]++; break; @@ -3032,7 +3032,7 @@ static void AnimFlatterSpotlightStep(struct Sprite *sprite) case 2: if (sprite->affineAnimEnded) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->data[1]++; } break; @@ -4514,7 +4514,7 @@ static void AnimForesightMagnifyingGlassStep(struct Sprite *sprite) SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(sprite->data[1], sprite->data[2])); if (++sprite->data[0] == 32) { - sprite->invisible = 1; + sprite->invisible = TRUE; sprite->data[5]++; } break; @@ -4593,7 +4593,7 @@ void AnimTask_MonToSubstitute(u8 taskId) { gTasks[taskId].data[3] = 0; ResetSpriteRotScale(spriteId); - gSprites[spriteId].invisible = 1; + gSprites[spriteId].invisible = TRUE; gTasks[taskId].data[0]++; } } @@ -4616,7 +4616,7 @@ static void AnimTask_MonToSubstituteDoll(u8 taskId) case 0: gSprites[spriteId].pos2.y = -200; gSprites[spriteId].pos2.x = 200; - gSprites[spriteId].invisible = 0; + gSprites[spriteId].invisible = FALSE; gTasks[taskId].data[10] = 0; gTasks[taskId].data[0]++; break; @@ -4780,13 +4780,13 @@ void AnimTask_OdorSleuthMovement(u8 taskId) if (!gBattleSpritesDataPtr->battlerData[gBattleAnimTarget].invisible) { - gSprites[spriteId2].invisible = 0; - gSprites[spriteId1].invisible = 1; + gSprites[spriteId2].invisible = FALSE; + gSprites[spriteId1].invisible = TRUE; } else { - gSprites[spriteId2].invisible = 1; - gSprites[spriteId1].invisible = 1; + gSprites[spriteId2].invisible = TRUE; + gSprites[spriteId1].invisible = TRUE; } gSprites[spriteId2].oam.objMode = ST_OAM_OBJ_NORMAL; @@ -5656,13 +5656,13 @@ void sub_80E3E84(struct Sprite *sprite) sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y) + 16; sprite->data[0] = -32; sprite->data[7]++; - sprite->invisible = 0; + sprite->invisible = FALSE; if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_OPPONENT) sprite->subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; } else { - sprite->invisible = 1; + sprite->invisible = TRUE; } break; case 1: -- cgit v1.2.3 From 646f34f9811201c1e299756cf71991e2bee50a8e Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 14:33:45 -0700 Subject: format fix --- src/battle_anim_effects_3.c | 3 --- 1 file changed, 3 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index c9c906778..f4e7da1b4 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -2320,7 +2320,6 @@ void AnimTask_MorningSunLightBeam(u8 taskId) gTasks[taskId].data[0]++; PlaySE12WithPanning(SE_W234, BattleAnimAdjustPanning(SOUND_PAN_ATTACKER)); break; - break; case 1: if (gTasks[taskId].data[4]++ > 0) { @@ -2329,7 +2328,6 @@ void AnimTask_MorningSunLightBeam(u8 taskId) gTasks[taskId].data[1] = 12; SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); - if (gTasks[taskId].data[1] == 12) gTasks[taskId].data[0]++; } @@ -2339,7 +2337,6 @@ void AnimTask_MorningSunLightBeam(u8 taskId) gTasks[taskId].data[1] = 0; SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); - if (!gTasks[taskId].data[1]) { gBattle_BG1_X = gMorningSunLightBeamCoordsTable[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; -- cgit v1.2.3 From b0963b831e6d5e5d5bb2d2ce95d70aabd1f075f8 Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 14:46:17 -0700 Subject: common_syms update --- src/battle_anim_special.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 8390857bb..1c9d6fe9b 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -40,9 +40,9 @@ #define LOHALF(n) ((n) & 0xFFFF) // RAM -EWRAM_DATA int gUnknown_3005424 = 0; -EWRAM_DATA u16 gUnknown_3005428 = 0; -EWRAM_DATA u16 gUnknown_300542C = 0; +int gUnknown_3005424; +u16 gUnknown_3005428; +u16 gUnknown_300542C; // Function Declarations static void sub_80EEDF4(u8); -- cgit v1.2.3 From 91e7d3064c2bae1f346c5d6c2ee61c030d313078 Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 16:30:32 -0700 Subject: update animcmdframe data --- src/battle_anim_effects_2.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 2a1ee41e2..9e44c9106 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -865,7 +865,7 @@ const struct SpriteTemplate gMagentaHeartSpriteTemplate = const union AffineAnimCmd gUnknown_83E4200[] = { - AFFINEANIMCMD_FRAME(0xA, -13, 0x0, 0xA), + AFFINEANIMCMD_FRAME(10, -13, 0x0, 0xA), AFFINEANIMCMD_FRAME(-10, 0xD, 0x0, 0xA), AFFINEANIMCMD_END, }; -- cgit v1.2.3 From 7253d9b86b366bf0ba1e81cf89c793f117daec78 Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 16:34:51 -0700 Subject: consistency fix --- src/battle_anim_effects_2.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 9e44c9106..8812c9db2 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -865,8 +865,8 @@ const struct SpriteTemplate gMagentaHeartSpriteTemplate = const union AffineAnimCmd gUnknown_83E4200[] = { - AFFINEANIMCMD_FRAME(10, -13, 0x0, 0xA), - AFFINEANIMCMD_FRAME(-10, 0xD, 0x0, 0xA), + AFFINEANIMCMD_FRAME(10, -13, 0x0, 10), + AFFINEANIMCMD_FRAME(-10, 13, 0x0, 10), AFFINEANIMCMD_END, }; -- cgit v1.2.3 From 1e915e58b957a136f9ea089bc783d72885a767fb Mon Sep 17 00:00:00 2001 From: Evan Date: Thu, 5 Dec 2019 17:05:42 -0700 Subject: affine params --- src/battle_anim_effects_2.c | 86 ++++++++++++++++++++++----------------------- 1 file changed, 43 insertions(+), 43 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 8812c9db2..ad2da7d2e 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -139,8 +139,8 @@ const union AnimCmd *const gUnknown_83E3B5C[] = const union AffineAnimCmd gUnknown_83E3B60[] = { - AFFINEANIMCMD_FRAME(0x50, 0x50, 0, 0), - AFFINEANIMCMD_FRAME(0x9, 0x9, 0, 18), + AFFINEANIMCMD_FRAME(80, 80, 0, 0), + AFFINEANIMCMD_FRAME(9, 9, 0, 18), AFFINEANIMCMD_END, }; @@ -192,9 +192,9 @@ const struct SpriteTemplate gKinesisZapEnergySpriteTemplate = const union AffineAnimCmd gSwordsDanceBladeAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x10, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x14, 0x0, 0, 12), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), + AFFINEANIMCMD_FRAME(16, 256, 0, 0), + AFFINEANIMCMD_FRAME(20, 0, 0, 12), + AFFINEANIMCMD_FRAME(0, 0, 0, 32), AFFINEANIMCMD_END, }; @@ -238,20 +238,20 @@ const struct SpriteTemplate gAirWaveProjectileSpriteTemplate = const union AffineAnimCmd gGrowingRingAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 0), - AFFINEANIMCMD_FRAME(0x7, 0x7, 0, -56), + AFFINEANIMCMD_FRAME(32, 32, 0, 0), + AFFINEANIMCMD_FRAME(7, 7, 0, -56), AFFINEANIMCMD_END, }; const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x5, 0x5, 0, 10), + AFFINEANIMCMD_FRAME(5, 5, 0, 10), AFFINEANIMCMD_FRAME(-10, -10, 0, 10), - AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_FRAME(10, 10, 0, 10), AFFINEANIMCMD_FRAME(-10, -10, 0, 10), - AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_FRAME(10, 10, 0, 10), AFFINEANIMCMD_FRAME(-10, -10, 0, 10), - AFFINEANIMCMD_FRAME(0xA, 0xA, 0, 10), + AFFINEANIMCMD_FRAME(10, 10, 0, 10), AFFINEANIMCMD_END, }; @@ -344,7 +344,7 @@ const union AnimCmd *const gCoinAnimTable[] = const union AffineAnimCmd gFallingCoinAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, 10, 1), + AFFINEANIMCMD_FRAME(0, 0, 10, 1), AFFINEANIMCMD_JUMP(0), }; @@ -377,7 +377,7 @@ const struct SpriteTemplate gFallingCoinSpriteTemplate = const union AffineAnimCmd gBulletSeedAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, 20, 1), + AFFINEANIMCMD_FRAME(0, 0, 20, 1), AFFINEANIMCMD_JUMP(0), }; @@ -399,8 +399,8 @@ const struct SpriteTemplate gBulletSeedSpriteTemplate = const union AffineAnimCmd gRazorWindTornadoAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x10, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x4, 0x0, 0, 40), + AFFINEANIMCMD_FRAME(16, 256, 0, 0), + AFFINEANIMCMD_FRAME(4, 0, 0, 40), AFFINEANIMCMD_END, }; @@ -539,7 +539,7 @@ const struct SpriteTemplate gBreathPuffSpriteTemplate = const union AffineAnimCmd gAngerMarkAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0xB, 0xB, 0, 8), + AFFINEANIMCMD_FRAME(11, 11, 0, 8), AFFINEANIMCMD_FRAME(-11, -11, 0, 8), AFFINEANIMCMD_END, }; @@ -619,27 +619,27 @@ const struct SpriteTemplate gExplosionSpriteTemplate = const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds1[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 2), - AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 4), - AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 2), + AFFINEANIMCMD_FRAME(0, 0, -8, 2), + AFFINEANIMCMD_FRAME(0, 0, 8, 4), + AFFINEANIMCMD_FRAME(0, 0, -8, 2), AFFINEANIMCMD_JUMP(0), }; const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds2[] = { - AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = { - AFFINEANIMCMD_FRAME(-8, 0x4, 0, 8), + AFFINEANIMCMD_FRAME(-8, 4, 0, 8), AFFINEANIMCMD_LOOP(0), - AFFINEANIMCMD_FRAME(0x10, -8, 0, 8), - AFFINEANIMCMD_FRAME(-16, 0x8, 0, 8), + AFFINEANIMCMD_FRAME(16, -8, 0, 8), + AFFINEANIMCMD_FRAME(-16, 8, 0, 8), AFFINEANIMCMD_LOOP(1), - AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 15), + AFFINEANIMCMD_FRAME(256, 256, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, 0, 15), AFFINEANIMCMD_END, }; @@ -663,22 +663,22 @@ const struct SpriteTemplate gSoftBoiledEggSpriteTemplate = const union AffineAnimCmd gThinRingExpandingAffineAnimCmds1[] = { - AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), - AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 30), + AFFINEANIMCMD_FRAME(16, 16, 0, 0), + AFFINEANIMCMD_FRAME(16, 16, 0, 30), AFFINEANIMCMD_END_ALT(1), }; const union AffineAnimCmd gThinRingExpandingAffineAnimCmds2[] = { - AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), - AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 15), + AFFINEANIMCMD_FRAME(16, 16, 0, 0), + AFFINEANIMCMD_FRAME(32, 32, 0, 15), AFFINEANIMCMD_END_ALT(1), }; const union AffineAnimCmd gHyperVoiceRingAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), - AFFINEANIMCMD_FRAME(0xB, 0xB, 0, 45), + AFFINEANIMCMD_FRAME(16, 16, 0, 0), + AFFINEANIMCMD_FRAME(11, 11, 0, 45), AFFINEANIMCMD_END_ALT(1), }; @@ -706,7 +706,7 @@ const struct SpriteTemplate gThinRingExpandingSpriteTemplate = const union AffineAnimCmd gThinRingShrinkingAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), + AFFINEANIMCMD_FRAME(512, 512, 0, 0), AFFINEANIMCMD_FRAME(-16, -16, 0, 30), AFFINEANIMCMD_END_ALT(1), }; @@ -865,8 +865,8 @@ const struct SpriteTemplate gMagentaHeartSpriteTemplate = const union AffineAnimCmd gUnknown_83E4200[] = { - AFFINEANIMCMD_FRAME(10, -13, 0x0, 10), - AFFINEANIMCMD_FRAME(-10, 13, 0x0, 10), + AFFINEANIMCMD_FRAME(10, -13, 0, 10), + AFFINEANIMCMD_FRAME(-10, 13, 0, 10), AFFINEANIMCMD_END, }; @@ -905,8 +905,8 @@ const struct SpriteTemplate gRedHeartRisingSpriteTemplate = const union AffineAnimCmd gHiddenPowerOrbAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), - AFFINEANIMCMD_FRAME(0x8, 0x8, 0, 1), + AFFINEANIMCMD_FRAME(128, 128, 0, 0), + AFFINEANIMCMD_FRAME(8, 8, 0, 1), AFFINEANIMCMD_JUMP(1), }; @@ -939,8 +939,8 @@ const struct SpriteTemplate gHiddenPowerOrbScatterSpriteTemplate = const union AffineAnimCmd gSpitUpOrbAffineAnimCmds[] = { - AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), - AFFINEANIMCMD_FRAME(0x8, 0x8, 0, 1), + AFFINEANIMCMD_FRAME(128, 128, 0, 0), + AFFINEANIMCMD_FRAME(8, 8, 0, 1), AFFINEANIMCMD_JUMP(1), }; @@ -1139,19 +1139,19 @@ const struct SpriteTemplate gJaggedMusicNoteSpriteTemplate = const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds1[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 5), + AFFINEANIMCMD_FRAME(0, 0, 0, 5), AFFINEANIMCMD_END, }; const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds2[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 16), + AFFINEANIMCMD_FRAME(0, 0, -8, 16), AFFINEANIMCMD_END_ALT(1), }; const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds3[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 16), + AFFINEANIMCMD_FRAME(0, 0, 8, 16), AFFINEANIMCMD_END_ALT(1), }; @@ -1186,13 +1186,13 @@ const struct SpriteTemplate gPerishSongMusicNote2SpriteTemplate = const union AffineAnimCmd gGuardRingAffineAnimCmds1[] = { - AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; const union AffineAnimCmd gGuardRingAffineAnimCmds2[] = { - AFFINEANIMCMD_FRAME(0x200, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(512, 256, 0, 0), AFFINEANIMCMD_END, }; -- cgit v1.2.3 From cb6830bab3fa77764393a36a2fba5e95c0f32353 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Sat, 7 Dec 2019 03:02:32 +0800 Subject: AnimTask_SnatchOpposingMonMove --- src/battle_anim_effects_3.c | 718 ++------------------------------------------ 1 file changed, 33 insertions(+), 685 deletions(-) (limited to 'src') diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 4bb839a02..84375fa86 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -4899,8 +4899,6 @@ void AnimTask_GetReturnPowerLevel(u8 taskId) // Makes the mon run out of screen, run past the opposing mon, and return to its original position. // No args. -#ifdef NONMATCHING -// `species` variable getting loaded into r6 instead of r5 void AnimTask_SnatchOpposingMonMove(u8 taskId) { u8 spriteId, spriteId2; @@ -4930,40 +4928,44 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) } break; case 1: - if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) { - personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) - species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + s16 x; - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; - isBackPic = FALSE; - x = 272; - } - else - { - personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) - species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); - else - species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; + if (GetBattlerSide(gBattleAnimAttacker) == B_SIDE_PLAYER) + { + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; - isBackPic = TRUE; - x = -32; - } + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority + 1; + isBackPic = FALSE; + x = 272; + } + else + { + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_OT_ID); + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies == SPECIES_NONE) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattleAnimAttacker]], MON_DATA_SPECIES); + else + species = gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies; - spriteId2 = sub_80768D0(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); - if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) - BlendPalette((gSprites[spriteId2].oam.paletteNum * 16) | 0x100, 16, 6, RGB_WHITE); + subpriority = gSprites[GetAnimBattlerSpriteId(ANIM_TARGET)].subpriority - 1; + isBackPic = TRUE; + x = -32; + } - gTasks[taskId].data[15] = spriteId2; - gTasks[taskId].data[0]++; - break; + spriteId2 = sub_80768D0(species, isBackPic, 0, x, GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y), subpriority, personality, otId, gBattleAnimAttacker, 0); + + if (gBattleSpritesDataPtr->battlerData[gBattleAnimAttacker].transformSpecies != SPECIES_NONE) + BlendPalette((gSprites[spriteId2].oam.paletteNum * 16) | 0x100, 16, 6, RGB_WHITE); + gTasks[taskId].data[15] = spriteId2; + gTasks[taskId].data[0]++; + break; + } case 2: spriteId2 = gTasks[taskId].data[15]; gTasks[taskId].data[1] += 0x800; @@ -4993,7 +4995,6 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) } } } - if ((u16)(x + 32) > 304) { gTasks[taskId].data[1] = 0; @@ -5033,659 +5034,6 @@ void AnimTask_SnatchOpposingMonMove(u8 taskId) break; } } -#else -NAKED -void AnimTask_SnatchOpposingMonMove(u8 taskId) -{ - asm_unified("\tpush {r4-r7,lr}\n" - "\tmov r7, r10\n" - "\tmov r6, r9\n" - "\tmov r5, r8\n" - "\tpush {r5-r7}\n" - "\tsub sp, 0x1C\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tmov r8, r0\n" - "\tldr r1, _080E395C @ =gTasks\n" - "\tlsls r0, 2\n" - "\tadd r0, r8\n" - "\tlsls r0, 3\n" - "\tadds r0, r1\n" - "\tmovs r1, 0x8\n" - "\tldrsh r0, [r0, r1]\n" - "\tcmp r0, 0x4\n" - "\tbls _080E3952\n" - "\tb _080E3E6C\n" - "_080E3952:\n" - "\tlsls r0, 2\n" - "\tldr r1, _080E3960 @ =_080E3964\n" - "\tadds r0, r1\n" - "\tldr r0, [r0]\n" - "\tmov pc, r0\n" - "\t.align 2, 0\n" - "_080E395C: .4byte gTasks\n" - "_080E3960: .4byte _080E3964\n" - "\t.align 2, 0\n" - "_080E3964:\n" - "\t.4byte _080E3978\n" - "\t.4byte _080E3A2C\n" - "\t.4byte _080E3BEC\n" - "\t.4byte _080E3D0C\n" - "\t.4byte _080E3D90\n" - "_080E3978:\n" - "\tmovs r0, 0\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tlsls r0, 24\n" - "\tlsrs r7, r0, 24\n" - "\tldr r1, _080E39C4 @ =gTasks\n" - "\tmov r2, r8\n" - "\tlsls r4, r2, 2\n" - "\tadds r0, r4, r2\n" - "\tlsls r0, 3\n" - "\tadds r6, r0, r1\n" - "\tmovs r3, 0x80\n" - "\tlsls r3, 4\n" - "\tadds r0, r3, 0\n" - "\tldrh r1, [r6, 0xA]\n" - "\tadds r0, r1\n" - "\tstrh r0, [r6, 0xA]\n" - "\tldr r0, _080E39C8 @ =gBattleAnimAttacker\n" - "\tldrb r0, [r0]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tmov r9, r4\n" - "\tcmp r0, 0\n" - "\tbne _080E39D0\n" - "\tldr r2, _080E39CC @ =gSprites\n" - "\tlsls r3, r7, 4\n" - "\tadds r1, r3, r7\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tldrh r0, [r6, 0xA]\n" - "\tlsls r0, 16\n" - "\tasrs r0, 24\n" - "\tldrh r4, [r1, 0x24]\n" - "\tadds r0, r4\n" - "\tstrh r0, [r1, 0x24]\n" - "\tb _080E39EA\n" - "\t.align 2, 0\n" - "_080E39C4: .4byte gTasks\n" - "_080E39C8: .4byte gBattleAnimAttacker\n" - "_080E39CC: .4byte gSprites\n" - "_080E39D0:\n" - "\tldr r3, _080E3A24 @ =gSprites\n" - "\tlsls r4, r7, 4\n" - "\tadds r2, r4, r7\n" - "\tlsls r2, 2\n" - "\tadds r2, r3\n" - "\tldrh r1, [r6, 0xA]\n" - "\tlsls r1, 16\n" - "\tasrs r1, 24\n" - "\tldrh r0, [r2, 0x24]\n" - "\tsubs r0, r1\n" - "\tstrh r0, [r2, 0x24]\n" - "\tadds r2, r3, 0\n" - "\tadds r3, r4, 0\n" - "_080E39EA:\n" - "\tldr r1, _080E3A28 @ =gTasks\n" - "\tmov r0, r9\n" - "\tadd r0, r8\n" - "\tlsls r0, 3\n" - "\tadds r4, r0, r1\n" - "\tldrb r0, [r4, 0xA]\n" - "\tstrh r0, [r4, 0xA]\n" - "\tadds r1, r3, r7\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tldrh r0, [r1, 0x24]\n" - "\tldrh r1, [r1, 0x20]\n" - "\tadds r0, r1\n" - "\tlsls r0, 16\n" - "\tmovs r1, 0x80\n" - "\tlsls r1, 14\n" - "\tadds r0, r1\n" - "\tmovs r1, 0x98\n" - "\tlsls r1, 17\n" - "\tcmp r0, r1\n" - "\tbhi _080E3A16\n" - "\tb _080E3E6C\n" - "_080E3A16:\n" - "\tmovs r0, 0\n" - "\tstrh r0, [r4, 0xA]\n" - "\tldrh r0, [r4, 0x8]\n" - "\tadds r0, 0x1\n" - "\tstrh r0, [r4, 0x8]\n" - "\tb _080E3E6C\n" - "\t.align 2, 0\n" - "_080E3A24: .4byte gSprites\n" - "_080E3A28: .4byte gTasks\n" - "_080E3A2C:\n" - "\tldr r4, _080E3A90 @ =gBattleAnimAttacker\n" - "\tldrb r0, [r4]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tcmp r0, 0\n" - "\tbne _080E3ACC\n" - "\tldr r7, _080E3A94 @ =gBattlerPartyIndexes\n" - "\tldrb r0, [r4]\n" - "\tlsls r0, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmovs r6, 0x64\n" - "\tmuls r0, r6\n" - "\tldr r5, _080E3A98 @ =gPlayerParty\n" - "\tadds r0, r5\n" - "\tmovs r1, 0\n" - "\tbl GetMonData\n" - "\tmov r10, r0\n" - "\tldrb r0, [r4]\n" - "\tlsls r0, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmuls r0, r6\n" - "\tadds r0, r5\n" - "\tmovs r1, 0x1\n" - "\tbl GetMonData\n" - "\tmov r9, r0\n" - "\tldr r0, _080E3A9C @ =gBattleSpritesDataPtr\n" - "\tldr r0, [r0]\n" - "\tldrb r2, [r4]\n" - "\tldr r1, [r0]\n" - "\tlsls r0, r2, 2\n" - "\tadds r1, r0, r1\n" - "\tldrh r0, [r1, 0x2]\n" - "\tcmp r0, 0\n" - "\tbne _080E3AA0\n" - "\tlsls r0, r2, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmuls r0, r6\n" - "\tadds r0, r5\n" - "\tmovs r1, 0xB\n" - "\tbl GetMonData\n" - "\tlsls r0, 16\n" - "\tlsrs r5, r0, 16\n" - "\tb _080E3AA2\n" - "\t.align 2, 0\n" - "_080E3A90: .4byte gBattleAnimAttacker\n" - "_080E3A94: .4byte gBattlerPartyIndexes\n" - "_080E3A98: .4byte gPlayerParty\n" - "_080E3A9C: .4byte gBattleSpritesDataPtr\n" - "_080E3AA0:\n" - "\tldrh r5, [r1, 0x2]\n" - "_080E3AA2:\n" - "\tmovs r0, 0x1\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tldr r2, _080E3AC8 @ =gSprites\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tlsls r1, r0, 4\n" - "\tadds r1, r0\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tadds r1, 0x43\n" - "\tldrb r0, [r1]\n" - "\tadds r0, 0x1\n" - "\tlsls r0, 24\n" - "\tlsrs r4, r0, 24\n" - "\tmovs r7, 0\n" - "\tmovs r6, 0x88\n" - "\tlsls r6, 1\n" - "\tb _080E3B54\n" - "\t.align 2, 0\n" - "_080E3AC8: .4byte gSprites\n" - "_080E3ACC:\n" - "\tldr r7, _080E3B24 @ =gBattlerPartyIndexes\n" - "\tldrb r0, [r4]\n" - "\tlsls r0, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmovs r6, 0x64\n" - "\tmuls r0, r6\n" - "\tldr r5, _080E3B28 @ =gEnemyParty\n" - "\tadds r0, r5\n" - "\tmovs r1, 0\n" - "\tbl GetMonData\n" - "\tmov r10, r0\n" - "\tldrb r0, [r4]\n" - "\tlsls r0, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmuls r0, r6\n" - "\tadds r0, r5\n" - "\tmovs r1, 0x1\n" - "\tbl GetMonData\n" - "\tmov r9, r0\n" - "\tldr r0, _080E3B2C @ =gBattleSpritesDataPtr\n" - "\tldr r0, [r0]\n" - "\tldrb r2, [r4]\n" - "\tldr r1, [r0]\n" - "\tlsls r0, r2, 2\n" - "\tadds r1, r0, r1\n" - "\tldrh r0, [r1, 0x2]\n" - "\tcmp r0, 0\n" - "\tbne _080E3B30\n" - "\tlsls r0, r2, 1\n" - "\tadds r0, r7\n" - "\tldrh r0, [r0]\n" - "\tmuls r0, r6\n" - "\tadds r0, r5\n" - "\tmovs r1, 0xB\n" - "\tbl GetMonData\n" - "\tlsls r0, 16\n" - "\tlsrs r5, r0, 16\n" - "\tb _080E3B32\n" - "\t.align 2, 0\n" - "_080E3B24: .4byte gBattlerPartyIndexes\n" - "_080E3B28: .4byte gEnemyParty\n" - "_080E3B2C: .4byte gBattleSpritesDataPtr\n" - "_080E3B30:\n" - "\tldrh r5, [r1, 0x2]\n" - "_080E3B32:\n" - "\tmovs r0, 0x1\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tldr r2, _080E3BD0 @ =gSprites\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tlsls r1, r0, 4\n" - "\tadds r1, r0\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tadds r1, 0x43\n" - "\tldrb r0, [r1]\n" - "\tsubs r0, 0x1\n" - "\tlsls r0, 24\n" - "\tlsrs r4, r0, 24\n" - "\tmovs r7, 0x1\n" - "\tldr r6, _080E3BD4 @ =0x0000ffe0\n" - "_080E3B54:\n" - "\tldr r0, _080E3BD8 @ =gBattleAnimTarget\n" - "\tldrb r0, [r0]\n" - "\tmovs r1, 0x1\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tlsls r3, r6, 16\n" - "\tasrs r3, 16\n" - "\tstr r0, [sp]\n" - "\tstr r4, [sp, 0x4]\n" - "\tmov r2, r10\n" - "\tstr r2, [sp, 0x8]\n" - "\tmov r4, r9\n" - "\tstr r4, [sp, 0xC]\n" - "\tldr r4, _080E3BDC @ =gBattleAnimAttacker\n" - "\tldrb r0, [r4]\n" - "\tstr r0, [sp, 0x10]\n" - "\tmovs r0, 0\n" - "\tstr r0, [sp, 0x14]\n" - "\tadds r0, r5, 0\n" - "\tadds r1, r7, 0\n" - "\tmovs r2, 0\n" - "\tbl sub_80768D0\n" - "\tlsls r0, 24\n" - "\tlsrs r5, r0, 24\n" - "\tldr r0, _080E3BE0 @ =gBattleSpritesDataPtr\n" - "\tldr r1, [r0]\n" - "\tldrb r0, [r4]\n" - "\tldr r1, [r1]\n" - "\tlsls r0, 2\n" - "\tadds r0, r1\n" - "\tldrh r0, [r0, 0x2]\n" - "\tcmp r0, 0\n" - "\tbeq _080E3BBE\n" - "\tldr r1, _080E3BD0 @ =gSprites\n" - "\tlsls r0, r5, 4\n" - "\tadds r0, r5\n" - "\tlsls r0, 2\n" - "\tadds r0, r1\n" - "\tldrb r0, [r0, 0x5]\n" - "\tlsrs r0, 4\n" - "\tlsls r0, 4\n" - "\tmovs r2, 0x80\n" - "\tlsls r2, 1\n" - "\tadds r1, r2, 0\n" - "\torrs r0, r1\n" - "\tldr r3, _080E3BE4 @ =0x00007fff\n" - "\tmovs r1, 0x10\n" - "\tmovs r2, 0x6\n" - "\tbl BlendPalette\n" - "_080E3BBE:\n" - "\tldr r0, _080E3BE8 @ =gTasks\n" - "\tmov r3, r8\n" - "\tlsls r1, r3, 2\n" - "\tadd r1, r8\n" - "\tlsls r1, 3\n" - "\tadds r1, r0\n" - "\tstrh r5, [r1, 0x26]\n" - "\tb _080E3D82\n" - "\t.align 2, 0\n" - "_080E3BD0: .4byte gSprites\n" - "_080E3BD4: .4byte 0x0000ffe0\n" - "_080E3BD8: .4byte gBattleAnimTarget\n" - "_080E3BDC: .4byte gBattleAnimAttacker\n" - "_080E3BE0: .4byte gBattleSpritesDataPtr\n" - "_080E3BE4: .4byte 0x00007fff\n" - "_080E3BE8: .4byte gTasks\n" - "_080E3BEC:\n" - "\tldr r1, _080E3C38 @ =gTasks\n" - "\tmov r0, r8\n" - "\tlsls r4, r0, 2\n" - "\tadds r0, r4, r0\n" - "\tlsls r0, 3\n" - "\tadds r6, r0, r1\n" - "\tldrh r0, [r6, 0x26]\n" - "\tlsls r0, 24\n" - "\tlsrs r5, r0, 24\n" - "\tmovs r1, 0x80\n" - "\tlsls r1, 4\n" - "\tadds r0, r1, 0\n" - "\tldrh r2, [r6, 0xA]\n" - "\tadds r0, r2\n" - "\tstrh r0, [r6, 0xA]\n" - "\tldr r0, _080E3C3C @ =gBattleAnimAttacker\n" - "\tldrb r0, [r0]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tmov r9, r4\n" - "\tcmp r0, 0\n" - "\tbne _080E3C44\n" - "\tldr r3, _080E3C40 @ =gSprites\n" - "\tlsls r4, r5, 4\n" - "\tadds r2, r4, r5\n" - "\tlsls r2, 2\n" - "\tadds r2, r3\n" - "\tldrh r1, [r6, 0xA]\n" - "\tlsls r1, 16\n" - "\tasrs r1, 24\n" - "\tldrh r0, [r2, 0x24]\n" - "\tsubs r0, r1\n" - "\tstrh r0, [r2, 0x24]\n" - "\tadds r2, r3, 0\n" - "\tadds r3, r4, 0\n" - "\tb _080E3C5A\n" - "\t.align 2, 0\n" - "_080E3C38: .4byte gTasks\n" - "_080E3C3C: .4byte gBattleAnimAttacker\n" - "_080E3C40: .4byte gSprites\n" - "_080E3C44:\n" - "\tldr r2, _080E3CA8 @ =gSprites\n" - "\tlsls r3, r5, 4\n" - "\tadds r1, r3, r5\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tldrh r0, [r6, 0xA]\n" - "\tlsls r0, 16\n" - "\tasrs r0, 24\n" - "\tldrh r4, [r1, 0x24]\n" - "\tadds r0, r4\n" - "\tstrh r0, [r1, 0x24]\n" - "_080E3C5A:\n" - "\tldr r1, _080E3CAC @ =gTasks\n" - "\tmov r0, r9\n" - "\tadd r0, r8\n" - "\tlsls r0, 3\n" - "\tadds r6, r0, r1\n" - "\tldrb r0, [r6, 0xA]\n" - "\tstrh r0, [r6, 0xA]\n" - "\tadds r1, r3, r5\n" - "\tlsls r1, 2\n" - "\tadds r1, r2\n" - "\tldrh r0, [r1, 0x24]\n" - "\tldrh r1, [r1, 0x20]\n" - "\tadds r0, r1\n" - "\tlsls r0, 16\n" - "\tlsrs r5, r0, 16\n" - "\tmovs r1, 0x24\n" - "\tldrsh r0, [r6, r1]\n" - "\tcmp r0, 0\n" - "\tbne _080E3CDA\n" - "\tldr r0, _080E3CB0 @ =gBattleAnimAttacker\n" - "\tldrb r0, [r0]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tcmp r0, 0\n" - "\tbne _080E3CB8\n" - "\tlsls r4, r5, 16\n" - "\tasrs r4, 16\n" - "\tldr r0, _080E3CB4 @ =gBattleAnimTarget\n" - "\tldrb r0, [r0]\n" - "\tmovs r1, 0\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tcmp r4, r0\n" - "\tbge _080E3CDA\n" - "\tb _080E3CCE\n" - "\t.align 2, 0\n" - "_080E3CA8: .4byte gSprites\n" - "_080E3CAC: .4byte gTasks\n" - "_080E3CB0: .4byte gBattleAnimAttacker\n" - "_080E3CB4: .4byte gBattleAnimTarget\n" - "_080E3CB8:\n" - "\tlsls r4, r5, 16\n" - "\tasrs r4, 16\n" - "\tldr r0, _080E3CFC @ =gBattleAnimTarget\n" - "\tldrb r0, [r0]\n" - "\tmovs r1, 0\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tcmp r4, r0\n" - "\tble _080E3CDA\n" - "_080E3CCE:\n" - "\tldrh r0, [r6, 0x24]\n" - "\tadds r0, 0x1\n" - "\tstrh r0, [r6, 0x24]\n" - "\tldr r1, _080E3D00 @ =gBattleAnimArgs\n" - "\tldr r0, _080E3D04 @ =0x0000ffff\n" - "\tstrh r0, [r1, 0xE]\n" - "_080E3CDA:\n" - "\tlsls r0, r5, 16\n" - "\tmovs r2, 0x80\n" - "\tlsls r2, 14\n" - "\tadds r0, r2\n" - "\tmovs r1, 0x98\n" - "\tlsls r1, 17\n" - "\tcmp r0, r1\n" - "\tbhi _080E3CEC\n" - "\tb _080E3E6C\n" - "_080E3CEC:\n" - "\tldr r0, _080E3D08 @ =gTasks\n" - "\tmov r1, r9\n" - "\tadd r1, r8\n" - "\tlsls r1, 3\n" - "\tadds r1, r0\n" - "\tmovs r0, 0\n" - "\tstrh r0, [r1, 0xA]\n" - "\tb _080E3D82\n" - "\t.align 2, 0\n" - "_080E3CFC: .4byte gBattleAnimTarget\n" - "_080E3D00: .4byte gBattleAnimArgs\n" - "_080E3D04: .4byte 0x0000ffff\n" - "_080E3D08: .4byte gTasks\n" - "_080E3D0C:\n" - "\tmovs r0, 0\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tlsls r0, 24\n" - "\tlsrs r7, r0, 24\n" - "\tldr r1, _080E3D58 @ =gTasks\n" - "\tmov r3, r8\n" - "\tlsls r4, r3, 2\n" - "\tadds r0, r4, r3\n" - "\tlsls r0, 3\n" - "\tadds r0, r1\n" - "\tldrh r0, [r0, 0x26]\n" - "\tlsls r0, 24\n" - "\tlsrs r5, r0, 24\n" - "\tlsls r0, r5, 4\n" - "\tadds r0, r5\n" - "\tlsls r0, 2\n" - "\tldr r5, _080E3D5C @ =gSprites\n" - "\tadds r0, r5\n" - "\tbl DestroySpriteAndFreeResources_\n" - "\tldr r0, _080E3D60 @ =gBattleAnimAttacker\n" - "\tldrb r0, [r0]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tmov r9, r4\n" - "\tcmp r0, 0\n" - "\tbne _080E3D64\n" - "\tlsls r1, r7, 4\n" - "\tadds r1, r7\n" - "\tlsls r1, 2\n" - "\tadds r1, r5\n" - "\tldrh r0, [r1, 0x20]\n" - "\tnegs r0, r0\n" - "\tsubs r0, 0x20\n" - "\tstrh r0, [r1, 0x24]\n" - "\tb _080E3D78\n" - "\t.align 2, 0\n" - "_080E3D58: .4byte gTasks\n" - "_080E3D5C: .4byte gSprites\n" - "_080E3D60: .4byte gBattleAnimAttacker\n" - "_080E3D64:\n" - "\tlsls r0, r7, 4\n" - "\tadds r0, r7\n" - "\tlsls r0, 2\n" - "\tadds r0, r5\n" - "\tldrh r2, [r0, 0x20]\n" - "\tmovs r4, 0x88\n" - "\tlsls r4, 1\n" - "\tadds r1, r4, 0\n" - "\tsubs r1, r2\n" - "\tstrh r1, [r0, 0x24]\n" - "_080E3D78:\n" - "\tldr r0, _080E3D8C @ =gTasks\n" - "\tmov r1, r9\n" - "\tadd r1, r8\n" - "\tlsls r1, 3\n" - "\tadds r1, r0\n" - "_080E3D82:\n" - "\tldrh r0, [r1, 0x8]\n" - "\tadds r0, 0x1\n" - "\tstrh r0, [r1, 0x8]\n" - "\tb _080E3E6C\n" - "\t.align 2, 0\n" - "_080E3D8C: .4byte gTasks\n" - "_080E3D90:\n" - "\tmovs r0, 0\n" - "\tbl GetAnimBattlerSpriteId\n" - "\tlsls r0, 24\n" - "\tlsrs r7, r0, 24\n" - "\tldr r1, _080E3E04 @ =gTasks\n" - "\tmov r0, r8\n" - "\tlsls r4, r0, 2\n" - "\tadds r0, r4, r0\n" - "\tlsls r0, 3\n" - "\tadds r2, r0, r1\n" - "\tmovs r1, 0x80\n" - "\tlsls r1, 4\n" - "\tadds r0, r1, 0\n" - "\tldrh r3, [r2, 0xA]\n" - "\tadds r0, r3\n" - "\tstrh r0, [r2, 0xA]\n" - "\tldr r0, _080E3E08 @ =gBattleAnimAttacker\n" - "\tmov r10, r0\n" - "\tldrb r0, [r0]\n" - "\tstr r2, [sp, 0x18]\n" - "\tbl GetBattlerSide\n" - "\tlsls r0, 24\n" - "\tmov r9, r4\n" - "\tldr r2, [sp, 0x18]\n" - "\tcmp r0, 0\n" - "\tbne _080E3E10\n" - "\tldr r1, _080E3E0C @ =gSprites\n" - "\tlsls r5, r7, 4\n" - "\tadds r0, r5, r7\n" - "\tlsls r0, 2\n" - "\tadds r6, r0, r1\n" - "\tldrh r0, [r2, 0xA]\n" - "\tlsls r0, 16\n" - "\tasrs r0, 24\n" - "\tldrh r1, [r6, 0x24]\n" - "\tadds r0, r1\n" - "\tstrh r0, [r6, 0x24]\n" - "\tmovs r2, 0x24\n" - "\tldrsh r4, [r6, r2]\n" - "\tmovs r3, 0x20\n" - "\tldrsh r0, [r6, r3]\n" - "\tadds r4, r0\n" - "\tmov r1, r10\n" - "\tldrb r0, [r1]\n" - "\tmovs r1, 0\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tadds r3, r5, 0\n" - "\tcmp r4, r0\n" - "\tblt _080E3E48\n" - "\tmovs r2, 0\n" - "\tstrh r2, [r6, 0x24]\n" - "\tb _080E3E48\n" - "\t.align 2, 0\n" - "_080E3E04: .4byte gTasks\n" - "_080E3E08: .4byte gBattleAnimAttacker\n" - "_080E3E0C: .4byte gSprites\n" - "_080E3E10:\n" - "\tldr r1, _080E3E7C @ =gSprites\n" - "\tlsls r5, r7, 4\n" - "\tadds r0, r5, r7\n" - "\tlsls r0, 2\n" - "\tadds r6, r0, r1\n" - "\tldrh r1, [r2, 0xA]\n" - "\tlsls r1, 16\n" - "\tasrs r1, 24\n" - "\tldrh r0, [r6, 0x24]\n" - "\tsubs r0, r1\n" - "\tstrh r0, [r6, 0x24]\n" - "\tmovs r3, 0x24\n" - "\tldrsh r4, [r6, r3]\n" - "\tmovs r1, 0x20\n" - "\tldrsh r0, [r6, r1]\n" - "\tadds r4, r0\n" - "\tmov r2, r10\n" - "\tldrb r0, [r2]\n" - "\tmovs r1, 0\n" - "\tbl GetBattlerSpriteCoord\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tadds r3, r5, 0\n" - "\tcmp r4, r0\n" - "\tbgt _080E3E48\n" - "\tmovs r4, 0\n" - "\tstrh r4, [r6, 0x24]\n" - "_080E3E48:\n" - "\tldr r1, _080E3E80 @ =gTasks\n" - "\tmov r0, r9\n" - "\tadd r0, r8\n" - "\tlsls r0, 3\n" - "\tadds r0, r1\n" - "\tldrb r1, [r0, 0xA]\n" - "\tstrh r1, [r0, 0xA]\n" - "\tldr r1, _080E3E7C @ =gSprites\n" - "\tadds r0, r3, r7\n" - "\tlsls r0, 2\n" - "\tadds r0, r1\n" - "\tmovs r1, 0x24\n" - "\tldrsh r0, [r0, r1]\n" - "\tcmp r0, 0\n" - "\tbne _080E3E6C\n" - "\tmov r0, r8\n" - "\tbl DestroyAnimVisualTask\n" - "_080E3E6C:\n" - "\tadd sp, 0x1C\n" - "\tpop {r3-r5}\n" - "\tmov r8, r3\n" - "\tmov r9, r4\n" - "\tmov r10, r5\n" - "\tpop {r4-r7}\n" - "\tpop {r0}\n" - "\tbx r0\n" - "\t.align 2, 0\n" - "_080E3E7C: .4byte gSprites\n" - "_080E3E80: .4byte gTasks\n"); -} -#endif void sub_80E3E84(struct Sprite *sprite) { -- cgit v1.2.3 From cb1e4ab326f15ea4dd346e2b19d0f9c7a34fdd14 Mon Sep 17 00:00:00 2001 From: Evan Date: Fri, 6 Dec 2019 22:44:15 -0700 Subject: update static declarations --- src/battle_anim.c | 21 +-- src/battle_anim_effects_1.c | 395 ++++++++++++++++++++-------------------- src/battle_anim_effects_2.c | 172 ++++++++--------- src/battle_anim_effects_3.c | 142 +++++++-------- src/battle_anim_special.c | 20 +- src/battle_anim_utility_funcs.c | 4 +- src/rock.c | 4 +- 7 files changed, 378 insertions(+), 380 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index ce20a4f01..dbaffa31b 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -59,7 +59,6 @@ static void LoadDefaultBg(void); static void Task_LoopAndPlaySE(u8 taskId); static void Task_WaitAndPlaySE(u8 taskId); static void sub_807331C(u8 taskId); -static bool8 sub_807378C(u16 a); static void ScriptCmd_loadspritegfx(void); static void ScriptCmd_unloadspritegfx(void); @@ -125,7 +124,6 @@ const struct OamData gOamData_AffineOff_ObjNormal_8x8 = .paletteNum = 0, }; - const struct OamData gOamData_AffineOff_ObjNormal_16x16 = { .y = 0, @@ -2082,6 +2080,7 @@ static void ScriptCmd_waitforvisualfinish(void) static void ScriptCmd_hang1(void) { } + static void ScriptCmd_hang2(void) { } @@ -3281,7 +3280,7 @@ static void ScriptCmd_visible(void) static void ScriptCmd_doublebattle_2D(void) { u8 wantedBattler; - u8 r4; + u8 priority; u8 spriteId; wantedBattler = sBattleAnimScriptPtr[1]; @@ -3291,21 +3290,21 @@ static void ScriptCmd_doublebattle_2D(void) { if (wantedBattler == ANIM_ATTACKER) { - r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); + priority = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); } else { - r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); + priority = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); } if (spriteId != 0xFF) { gSprites[spriteId].invisible = FALSE; - if (r4 == 2) + if (priority == 2) gSprites[spriteId].oam.priority = 3; - if (r4 == 1) + if (priority == 1) sub_8073128(FALSE); else sub_8073128(TRUE); @@ -3316,7 +3315,7 @@ static void ScriptCmd_doublebattle_2D(void) static void ScriptCmd_doublebattle_2E(void) { u8 wantedBattler; - u8 r4; + u8 priority; u8 spriteId; wantedBattler = sBattleAnimScriptPtr[1]; @@ -3326,16 +3325,16 @@ static void ScriptCmd_doublebattle_2E(void) { if (wantedBattler == ANIM_ATTACKER) { - r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); + priority = GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker); spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); } else { - r4 = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); + priority = GetBattlerSpriteBGPriorityRank(gBattleAnimTarget); spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); } - if (spriteId != 0xFF && r4 == 2) + if (spriteId != 0xFF && priority == 2) gSprites[spriteId].oam.priority = 2; } } diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 6c09f3a5b..da9998c2f 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -16,7 +16,7 @@ #include "constants/songs.h" // RAM -EWRAM_DATA s16 gUnknown_203999C[4] = {0}; +static EWRAM_DATA s16 gUnknown_203999C[4] = {0}; // Function Declarations static void AnimMovePowderParticleStep(struct Sprite *); @@ -93,7 +93,7 @@ static void AnimTauntFingerStep2(struct Sprite *); static const u8 gUnknown_83E2964[] = {0x02, 0x04, 0x01, 0x03}; -const union AnimCmd gPowderParticlesAnimCmds[] = +static const union AnimCmd gPowderParticlesAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(2, 5), @@ -106,7 +106,7 @@ const union AnimCmd gPowderParticlesAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gPowderParticlesAnimTable[] = +static const union AnimCmd *const gPowderParticlesAnimTable[] = { gPowderParticlesAnimCmds, }; @@ -144,61 +144,61 @@ const struct SpriteTemplate gPoisonPowderParticleSpriteTemplate = .callback = AnimMovePowderParticle, }; -const union AnimCmd gSolarbeamBigOrbAnimCmds1[] = +static const union AnimCmd gSolarbeamBigOrbAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gSolarbeamBigOrbAnimCmds2[] = +static const union AnimCmd gSolarbeamBigOrbAnimCmds2[] = { ANIMCMD_FRAME(1, 1), ANIMCMD_END, }; -const union AnimCmd gSolarbeamBigOrbAnimCmds3[] = +static const union AnimCmd gSolarbeamBigOrbAnimCmds3[] = { ANIMCMD_FRAME(2, 1), ANIMCMD_END, }; -const union AnimCmd gSolarbeamBigOrbAnimCmds4[] = +static const union AnimCmd gSolarbeamBigOrbAnimCmds4[] = { ANIMCMD_FRAME(3, 1), ANIMCMD_END, }; -const union AnimCmd gSolarbeamBigOrbAnimCmds5[] = +static const union AnimCmd gSolarbeamBigOrbAnimCmds5[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd gSolarbeamBigOrbAnimCmds6[] = +static const union AnimCmd gSolarbeamBigOrbAnimCmds6[] = { ANIMCMD_FRAME(5, 1), ANIMCMD_END, }; -const union AnimCmd gSolarbeamBigOrbAnimCmds7[] = +static const union AnimCmd gSolarbeamBigOrbAnimCmds7[] = { ANIMCMD_FRAME(6, 1), ANIMCMD_END, }; -const union AnimCmd gSolarbeamSmallOrbAnimCms[] = +static const union AnimCmd gSolarbeamSmallOrbAnimCms[] = { ANIMCMD_FRAME(7, 1), ANIMCMD_END, }; -const union AnimCmd gPowerAbsorptionOrbAnimCmds[] = +static const union AnimCmd gPowerAbsorptionOrbAnimCmds[] = { ANIMCMD_FRAME(8, 1), ANIMCMD_END, }; -const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = +static const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = { gSolarbeamBigOrbAnimCmds1, gSolarbeamBigOrbAnimCmds2, @@ -209,23 +209,23 @@ const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = gSolarbeamBigOrbAnimCmds7, }; -const union AnimCmd *const gSolarbeamSmallOrbAnimTable[] = +static const union AnimCmd *const gSolarbeamSmallOrbAnimTable[] = { gSolarbeamSmallOrbAnimCms, }; -const union AnimCmd *const gPowerAbsorptionOrbAnimTable[] = +static const union AnimCmd *const gPowerAbsorptionOrbAnimTable[] = { gPowerAbsorptionOrbAnimCmds, }; -const union AffineAnimCmd gPowerAbsorptionOrbAffineAnimCmds[] = +static const union AffineAnimCmd gPowerAbsorptionOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-5, -5, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gPowerAbsorptionOrbAffineAnimTable[] = +static const union AffineAnimCmd *const gPowerAbsorptionOrbAffineAnimTable[] = { gPowerAbsorptionOrbAffineAnimCmds, }; @@ -263,14 +263,14 @@ const struct SpriteTemplate gSolarbeamSmallOrbSpriteTemplate = .callback = AnimSolarbeamSmallOrb, }; -const union AffineAnimCmd gStockpileAbsorptionOrbAffineCmds[] = +static const union AffineAnimCmd gStockpileAbsorptionOrbAffineCmds[] = { AFFINEANIMCMD_FRAME(320, 320, 0, 0), AFFINEANIMCMD_FRAME(-14, -14, 0, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gStockpileAbsorptionOrbAffineAnimTable[] = +static const union AffineAnimCmd *const gStockpileAbsorptionOrbAffineAnimTable[] = { gStockpileAbsorptionOrbAffineCmds, }; @@ -286,13 +286,13 @@ const struct SpriteTemplate gStockpileAbsorptionOrbSpriteTemplate = .callback = AnimPowerAbsorptionOrb, }; -const union AffineAnimCmd gAbsorptionOrbAffineAnimCmds[] = +static const union AffineAnimCmd gAbsorptionOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-5, -5, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gAbsorptionOrbAffineAnimTable[] = +static const union AffineAnimCmd *const gAbsorptionOrbAffineAnimTable[] = { gAbsorptionOrbAffineAnimCmds, }; @@ -319,20 +319,20 @@ const struct SpriteTemplate gHyperBeamOrbSpriteTemplate = .callback = AnimHyperBeamOrb, }; -const union AnimCmd gLeechSeedAnimCmds1[] = +static const union AnimCmd gLeechSeedAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gLeechSeedAnimCmds2[] = +static const union AnimCmd gLeechSeedAnimCmds2[] = { ANIMCMD_FRAME(4, 7), ANIMCMD_FRAME(8, 7), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gLeechSeedAnimTable[] = +static const union AnimCmd *const gLeechSeedAnimTable[] = { gLeechSeedAnimCmds1, gLeechSeedAnimCmds2, @@ -349,19 +349,19 @@ const struct SpriteTemplate gLeechSeedSpriteTemplate = .callback = AnimLeechSeed, }; -const union AnimCmd gSporeParticleAnimCmds1[] = +static const union AnimCmd gSporeParticleAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gSporeParticleAnimCmds2[] = +static const union AnimCmd gSporeParticleAnimCmds2[] = { ANIMCMD_FRAME(4, 7), ANIMCMD_END, }; -const union AnimCmd *const gSporeParticleAnimTable[] = +static const union AnimCmd *const gSporeParticleAnimTable[] = { gSporeParticleAnimCmds1, gSporeParticleAnimCmds2, @@ -378,24 +378,24 @@ const struct SpriteTemplate gSporeParticleSpriteTemplate = .callback = AnimSporeParticle, }; -const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = +static const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = +static const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = +static const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = { gPetalDanceBigFlowerAnimCmds, }; -const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = +static const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = { gPetalDanceSmallFlowerAnimCmds, }; @@ -422,7 +422,7 @@ const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = .callback = AnimPetalDanceSmallFlower, }; -const union AnimCmd gRazorLeafParticleAnimCmds1[] = +static const union AnimCmd gRazorLeafParticleAnimCmds1[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 5), @@ -437,7 +437,7 @@ const union AnimCmd gRazorLeafParticleAnimCmds1[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gRazorLeafParticleAnimCmds2[] = +static const union AnimCmd gRazorLeafParticleAnimCmds2[] = { ANIMCMD_FRAME(24, 5), ANIMCMD_FRAME(28, 5), @@ -445,7 +445,7 @@ const union AnimCmd gRazorLeafParticleAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gRazorLeafParticleAnimTable[] = +static const union AnimCmd *const gRazorLeafParticleAnimTable[] = { gRazorLeafParticleAnimCmds1, gRazorLeafParticleAnimCmds2, @@ -473,7 +473,7 @@ const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = .callback = AnimMoveTwisterParticle, }; -const union AnimCmd gRazorLeafCutterAnimCmds[] = +static const union AnimCmd gRazorLeafCutterAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(0, 3, .hFlip = TRUE), @@ -482,7 +482,7 @@ const union AnimCmd gRazorLeafCutterAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRazorLeafCutterAnimTable[] = +static const union AnimCmd *const gRazorLeafCutterAnimTable[] = { gRazorLeafCutterAnimCmds, }; @@ -498,13 +498,13 @@ const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = .callback = AnimTranslateLinearSingleSineWave, }; -const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = +static const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = +static const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = { gSwiftStarAffineAnimCmds, }; @@ -520,7 +520,7 @@ const struct SpriteTemplate gSwiftStarSpriteTemplate = .callback = AnimTranslateLinearSingleSineWave, }; -const union AnimCmd gConstrictBindingAnimCmds1[] = +static const union AnimCmd gConstrictBindingAnimCmds1[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(32, 4), @@ -529,7 +529,7 @@ const union AnimCmd gConstrictBindingAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gConstrictBindingAnimCmds2[] = +static const union AnimCmd gConstrictBindingAnimCmds2[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(32, 4, .hFlip = TRUE), @@ -538,13 +538,13 @@ const union AnimCmd gConstrictBindingAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gConstrictBindingAnimTable[] = +static const union AnimCmd *const gConstrictBindingAnimTable[] = { gConstrictBindingAnimCmds1, gConstrictBindingAnimCmds2, }; -const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = +static const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(-11, 0, 0, 6), @@ -552,7 +552,7 @@ const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = +static const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(11, 0, 0, 6), @@ -560,7 +560,7 @@ const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = +static const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = { gConstrictBindingAffineAnimCmds1, gConstrictBindingAffineAnimCmds2, @@ -577,20 +577,20 @@ const struct SpriteTemplate gConstrictBindingSpriteTemplate = .callback = AnimConstrictBinding, }; -const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = +static const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 0), AFFINEANIMCMD_FRAME(48, 48, 0, 14), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = +static const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(-16, -16, 0, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = +static const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = { gMimicOrbAffineAnimCmds1, gMimicOrbAffineAnimCmds2, @@ -607,7 +607,7 @@ const struct SpriteTemplate gMimicOrbSpriteTemplate = .callback = AnimMimicOrb, }; -const union AnimCmd gIngrainRootAnimCmds1[] = +static const union AnimCmd gIngrainRootAnimCmds1[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -616,7 +616,7 @@ const union AnimCmd gIngrainRootAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds2[] = +static const union AnimCmd gIngrainRootAnimCmds2[] = { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -625,7 +625,7 @@ const union AnimCmd gIngrainRootAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds3[] = +static const union AnimCmd gIngrainRootAnimCmds3[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -633,7 +633,7 @@ const union AnimCmd gIngrainRootAnimCmds3[] = ANIMCMD_END, }; -const union AnimCmd gIngrainRootAnimCmds4[] = +static const union AnimCmd gIngrainRootAnimCmds4[] = { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -641,7 +641,7 @@ const union AnimCmd gIngrainRootAnimCmds4[] = ANIMCMD_END, }; -const union AnimCmd *const gIngrainRootAnimTable[] = +static const union AnimCmd *const gIngrainRootAnimTable[] = { gIngrainRootAnimCmds1, gIngrainRootAnimCmds2, @@ -671,14 +671,14 @@ const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = .callback = AnimFrenzyPlantRoot, }; -const union AnimCmd gIngrainOrbAnimCmds[] = +static const union AnimCmd gIngrainOrbAnimCmds[] = { ANIMCMD_FRAME(3, 3), ANIMCMD_FRAME(0, 5), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gIngrainOrbAnimTable[] = +static const union AnimCmd *const gIngrainOrbAnimTable[] = { gIngrainOrbAnimCmds, }; @@ -694,18 +694,18 @@ const struct SpriteTemplate gIngrainOrbSpriteTemplate = .callback = AnimIngrainOrb, }; -const union AnimCmd gFallingBagAnimCmds[] = +static const union AnimCmd gFallingBagAnimCmds[] = { ANIMCMD_FRAME(0, 30), ANIMCMD_END, }; -const union AnimCmd *const gFallingBagAnimTable[] = +static const union AnimCmd *const gFallingBagAnimTable[] = { gFallingBagAnimCmds, }; -const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = +static const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 10), AFFINEANIMCMD_FRAME(0, 0, 4, 20), @@ -713,7 +713,7 @@ const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = +static const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0, 0, -1, 2), AFFINEANIMCMD_FRAME(0, 0, 1, 4), @@ -724,7 +724,7 @@ const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = +static const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = { gFallingBagAffineAnimCmds1, gFallingBagAffineAnimCmds2, @@ -752,7 +752,7 @@ const struct SpriteTemplate gKnockOffItemSpriteTemplate = .callback = AnimKnockOffItem, }; -const union AnimCmd gPresentHealParticleAnimCmds[] = +static const union AnimCmd gPresentHealParticleAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 4), @@ -761,7 +761,7 @@ const union AnimCmd gPresentHealParticleAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gPresentHealParticleAnimTable[] = +static const union AnimCmd *const gPresentHealParticleAnimTable[] = { gPresentHealParticleAnimCmds, }; @@ -788,13 +788,13 @@ const struct SpriteTemplate gItemStealSpriteTemplate = .callback = AnimItemSteal, }; -const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = +static const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 3), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = +static const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0, -10, 0, 3), AFFINEANIMCMD_FRAME(0, -6, 0, 3), @@ -806,7 +806,7 @@ const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = +static const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = { gTrickBagAffineAnimCmds1, gTrickBagAffineAnimCmds2, @@ -825,7 +825,7 @@ const struct SpriteTemplate gTrickBagSpriteTemplate = .callback = AnimTrickBag, }; -const s8 gTrickBagCoordinates[][3] = +static const s8 gTrickBagCoordinates[][3] = { {5, 24, 1}, {0, 4, 0}, @@ -840,49 +840,49 @@ const s8 gTrickBagCoordinates[][3] = {0, 0, 127}, }; -const union AnimCmd gLeafBladeAnimCmds1[] = +static const union AnimCmd gLeafBladeAnimCmds1[] = { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds2[] = +static const union AnimCmd gLeafBladeAnimCmds2[] = { ANIMCMD_FRAME(32, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds3[] = +static const union AnimCmd gLeafBladeAnimCmds3[] = { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds4[] = +static const union AnimCmd gLeafBladeAnimCmds4[] = { ANIMCMD_FRAME(28, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds5[] = +static const union AnimCmd gLeafBladeAnimCmds5[] = { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds6[] = +static const union AnimCmd gLeafBladeAnimCmds6[] = { ANIMCMD_FRAME(16, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gLeafBladeAnimCmds7[] = +static const union AnimCmd gLeafBladeAnimCmds7[] = { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -const union AnimCmd *const gLeafBladeAnimTable[] = +static const union AnimCmd *const gLeafBladeAnimTable[] = { gLeafBladeAnimCmds1, gLeafBladeAnimCmds2, @@ -904,14 +904,14 @@ const struct SpriteTemplate gLeafBladeSpriteTemplate = .callback = SpriteCallbackDummy, }; -const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = +static const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = +static const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = { gAromatherapyBigFlowerAffineAnimCmds, }; @@ -938,38 +938,38 @@ const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = .callback = AnimFlyingParticle, }; -const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = +static const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -10, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = +static const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(192, 192, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -12, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = +static const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(143, 143, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -15, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = +static const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = { gSilverWindBigSparkAffineAnimCmds, }; -const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = +static const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = { gSilverWindMediumSparkAffineAnimCmds, }; -const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = +static const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = { gSilverWindSmallSparkAffineAnimCmds, }; @@ -1007,7 +1007,7 @@ const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = .callback = AnimFlyingParticle, }; -const u16 gMagicalLeafBlendColors[] = +static const u16 gMagicalLeafBlendColors[] = { RGB(31, 0, 0), RGB(31, 19, 0), @@ -1029,7 +1029,7 @@ const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = .callback = AnimNeedleArmSpike, }; -const union AnimCmd gWhipAnimCmds1[] = +static const union AnimCmd gWhipAnimCmds1[] = { ANIMCMD_FRAME(64, 3), ANIMCMD_FRAME(80, 3), @@ -1038,7 +1038,7 @@ const union AnimCmd gWhipAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gWhipAnimCmds2[] = +static const union AnimCmd gWhipAnimCmds2[] = { ANIMCMD_FRAME(64, 3, .hFlip = TRUE), ANIMCMD_FRAME(80, 3, .hFlip = TRUE), @@ -1047,7 +1047,7 @@ const union AnimCmd gWhipAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gWhipAnimTable[] = +static const union AnimCmd *const gWhipAnimTable[] = { gWhipAnimCmds1, gWhipAnimCmds2, @@ -1075,7 +1075,7 @@ const struct SpriteTemplate gVineWhipSpriteTemplate = .callback = AnimWhipHit, }; -const union AnimCmd gUnknown_83E3178[] = +static const union AnimCmd gUnknown_83E3178[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1085,13 +1085,13 @@ const union AnimCmd gUnknown_83E3178[] = ANIMCMD_END, }; -const union AnimCmd *const gUnknown_83E3190[] = +static const union AnimCmd *const gUnknown_83E3190[] = { gUnknown_83E3178, }; // Unused -const struct SpriteTemplate gUnknown_83E3194 = +static const struct SpriteTemplate gUnknown_83E3194 = { .tileTag = ANIM_TAG_HIT, .paletteTag = ANIM_TAG_HIT, @@ -1103,7 +1103,7 @@ const struct SpriteTemplate gUnknown_83E3194 = }; // Unused -const struct SpriteTemplate gUnknown_83E31AC = +static const struct SpriteTemplate gUnknown_83E31AC = { .tileTag = ANIM_TAG_HIT_2, .paletteTag = ANIM_TAG_HIT_2, @@ -1114,55 +1114,55 @@ const struct SpriteTemplate gUnknown_83E31AC = .callback = sub_80A43F8, }; -const union AffineAnimCmd gUnknown_83E31C4[] = +static const union AffineAnimCmd gUnknown_83E31C4[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_83E31D4[] = +static const union AffineAnimCmd gUnknown_83E31D4[] = { AFFINEANIMCMD_FRAME(256, 256, 32, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_83E31E4[] = +static const union AffineAnimCmd gUnknown_83E31E4[] = { AFFINEANIMCMD_FRAME(256, 256, 64, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_83E31F4[] = +static const union AffineAnimCmd gUnknown_83E31F4[] = { AFFINEANIMCMD_FRAME(256, 256, 96, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_83E3204[] = +static const union AffineAnimCmd gUnknown_83E3204[] = { AFFINEANIMCMD_FRAME(256, 256, -128, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_83E3214[] = +static const union AffineAnimCmd gUnknown_83E3214[] = { AFFINEANIMCMD_FRAME(256, 256, -96, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_83E3224[] = +static const union AffineAnimCmd gUnknown_83E3224[] = { AFFINEANIMCMD_FRAME(256, 256, -64, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gUnknown_83E3234[] = +static const union AffineAnimCmd gUnknown_83E3234[] = { AFFINEANIMCMD_FRAME(256, 256, -32, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gUnknown_83E3244[] = +static const union AffineAnimCmd *const gUnknown_83E3244[] = { gUnknown_83E31C4, gUnknown_83E31D4, @@ -1175,7 +1175,7 @@ const union AffineAnimCmd *const gUnknown_83E3244[] = }; // Unused -const struct SpriteTemplate gUnknown_83E3264 = +static const struct SpriteTemplate gUnknown_83E3264 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, @@ -1186,7 +1186,7 @@ const struct SpriteTemplate gUnknown_83E3264 = .callback = sub_80A4494, }; -const union AnimCmd gCuttingSliceAnimCmds[] = +static const union AnimCmd gCuttingSliceAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(16, 5), @@ -1195,7 +1195,7 @@ const union AnimCmd gCuttingSliceAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gCuttingSliceAnimTable[] = +static const union AnimCmd *const gCuttingSliceAnimTable[] = { gCuttingSliceAnimCmds, }; @@ -1222,67 +1222,67 @@ const struct SpriteTemplate gAirCutterSliceSpriteTemplate = .callback = AnimAirCutterSlice, }; -const union AnimCmd gUnknown_83E32C4[] = +static const union AnimCmd gUnknown_83E32C4[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E32CC[] = +static const union AnimCmd gUnknown_83E32CC[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E32D4[] = +static const union AnimCmd gUnknown_83E32D4[] = { ANIMCMD_FRAME(8, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E32DC[] = +static const union AnimCmd gUnknown_83E32DC[] = { ANIMCMD_FRAME(12, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E32E4[] = +static const union AnimCmd gUnknown_83E32E4[] = { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E32EC[] = +static const union AnimCmd gUnknown_83E32EC[] = { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E32F4[] = +static const union AnimCmd gUnknown_83E32F4[] = { ANIMCMD_FRAME(0, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E32FC[] = +static const union AnimCmd gUnknown_83E32FC[] = { ANIMCMD_FRAME(4, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E3304[] = +static const union AnimCmd gUnknown_83E3304[] = { ANIMCMD_FRAME(8, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gUnknown_83E330C[] = +static const union AnimCmd gUnknown_83E330C[] = { ANIMCMD_FRAME(12, 1, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd *const gUnknown_83E3314[] = +static const union AnimCmd *const gUnknown_83E3314[] = { gUnknown_83E32C4, gUnknown_83E32CC, @@ -1297,7 +1297,7 @@ const union AnimCmd *const gUnknown_83E3314[] = }; // Unused -const struct SpriteTemplate gUnknown_83E333C = +static const struct SpriteTemplate gUnknown_83E333C = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -1319,13 +1319,13 @@ const struct SpriteTemplate gProtectWallSpriteTemplate = .callback = AnimProtect, }; -const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = +static const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = +static const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), @@ -1335,7 +1335,7 @@ const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] = +static const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] = { gMilkBottleAffineAnimCmds1, gMilkBottleAffineAnimCmds2, @@ -1352,7 +1352,7 @@ const struct SpriteTemplate gMilkBottleSpriteTemplate = .callback = AnimMilkBottle, }; -const union AnimCmd gGrantingStarsAnimCmds[] = +static const union AnimCmd gGrantingStarsAnimCmds[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -1365,7 +1365,7 @@ const union AnimCmd gGrantingStarsAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gGrantingStarsAnimTable[] = +static const union AnimCmd *const gGrantingStarsAnimTable[] = { gGrantingStarsAnimCmds, }; @@ -1392,7 +1392,7 @@ const struct SpriteTemplate gSparklingStarsSpriteTemplate = .callback = AnimSparkingStars, }; -const union AnimCmd gUnknown_83E3424[] = +static const union AnimCmd gUnknown_83E3424[] = { ANIMCMD_FRAME(0, 10), ANIMCMD_FRAME(4, 10), @@ -1405,7 +1405,7 @@ const union AnimCmd gUnknown_83E3424[] = ANIMCMD_END, }; -const union AnimCmd gUnknown_83E3448[] = +static const union AnimCmd gUnknown_83E3448[] = { ANIMCMD_FRAME(0, 10, .hFlip = TRUE), ANIMCMD_FRAME(4, 10, .hFlip = TRUE), @@ -1418,14 +1418,14 @@ const union AnimCmd gUnknown_83E3448[] = ANIMCMD_END, }; -const union AnimCmd *const gUnknown_83E346C[] = +static const union AnimCmd *const gUnknown_83E346C[] = { gUnknown_83E3424, gUnknown_83E3448, }; // Unused -const struct SpriteTemplate gUnknown_83E3474 = +static const struct SpriteTemplate gUnknown_83E3474 = { .tileTag = ANIM_TAG_BUBBLE_BURST, .paletteTag = ANIM_TAG_BUBBLE_BURST, @@ -1436,46 +1436,46 @@ const struct SpriteTemplate gUnknown_83E3474 = .callback = sub_80A4E40, }; -const union AnimCmd gSleepLetterZAnimCmds[] = +static const union AnimCmd gSleepLetterZAnimCmds[] = { ANIMCMD_FRAME(0, 40), ANIMCMD_END, }; -const union AnimCmd *const gSleepLetterZAnimTable[] = +static const union AnimCmd *const gSleepLetterZAnimTable[] = { gSleepLetterZAnimCmds, }; -const union AffineAnimCmd gSleepLetterZAffineAnimCmds1[] = +static const union AffineAnimCmd gSleepLetterZAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x14, 0x14, -30, 0), AFFINEANIMCMD_FRAME(0x8, 0x8, 1, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSleepLetterZAffineAnimCmds1_2[] = +static const union AffineAnimCmd gSleepLetterZAffineAnimCmds1_2[] = { AFFINEANIMCMD_LOOP(0), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), AFFINEANIMCMD_LOOP(10), }; -const union AffineAnimCmd gSleepLetterZAffineAnimCmds2[] = +static const union AffineAnimCmd gSleepLetterZAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x14, 0x14, 30, 0), AFFINEANIMCMD_FRAME(0x8, 0x8, -1, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSleepLetterZAffineAnimCmds2_2[] = +static const union AffineAnimCmd gSleepLetterZAffineAnimCmds2_2[] = { AFFINEANIMCMD_LOOP(0), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 24), AFFINEANIMCMD_LOOP(10), }; -const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] = +static const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] = { gSleepLetterZAffineAnimCmds1, gSleepLetterZAffineAnimCmds2, @@ -1514,7 +1514,7 @@ const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = .callback = AnimLockOnMoveTarget, }; -const s8 gInclineMonCoordTable[][2] = +static const s8 gInclineMonCoordTable[][2] = { { 64, 64}, { 0, -64}, @@ -1534,7 +1534,7 @@ const struct SpriteTemplate gBowMonSpriteTemplate = }; // Unused -const struct SpriteTemplate gUnknown_83E3568 = +static const struct SpriteTemplate gUnknown_83E3568 = { .tileTag = 0, .paletteTag = 0, @@ -1545,7 +1545,7 @@ const struct SpriteTemplate gUnknown_83E3568 = .callback = sub_80A5590, }; -const union AnimCmd gSlashSliceAnimCmds1[] = +static const union AnimCmd gSlashSliceAnimCmds1[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1554,13 +1554,13 @@ const union AnimCmd gSlashSliceAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gSlashSliceAnimCmds2[] = +static const union AnimCmd gSlashSliceAnimCmds2[] = { ANIMCMD_FRAME(48, 4), ANIMCMD_END, }; -const union AnimCmd *const gSlashSliceAnimTable[] = +static const union AnimCmd *const gSlashSliceAnimTable[] = { gSlashSliceAnimCmds1, gSlashSliceAnimCmds2, @@ -1599,7 +1599,7 @@ const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = .callback = AnimFalseSwipePositionedSlice, }; -const union AnimCmd gEndureEnergyAnimCmds[] = +static const union AnimCmd gEndureEnergyAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(8, 12), @@ -1608,7 +1608,7 @@ const union AnimCmd gEndureEnergyAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gEndureEnergyAnimTable[] = +static const union AnimCmd *const gEndureEnergyAnimTable[] = { gEndureEnergyAnimCmds, }; @@ -1624,7 +1624,7 @@ const struct SpriteTemplate gEndureEnergySpriteTemplate = .callback = AnimEndureEnergy, }; -const union AnimCmd gSharpenSphereAnimCmds[] = +static const union AnimCmd gSharpenSphereAnimCmds[] = { ANIMCMD_FRAME(0, 18), ANIMCMD_FRAME(0, 6), @@ -1643,7 +1643,7 @@ const union AnimCmd gSharpenSphereAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gSharpenSphereAnimTable[] = +static const union AnimCmd *const gSharpenSphereAnimTable[] = { gSharpenSphereAnimCmds, }; @@ -1670,7 +1670,7 @@ const struct SpriteTemplate gOctazookaBallSpriteTemplate = .callback = TranslateAnimSpriteToTargetMonLocation, }; -const union AnimCmd gOctazookaAnimCmds[] = +static const union AnimCmd gOctazookaAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -1680,7 +1680,7 @@ const union AnimCmd gOctazookaAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gOctazookaAnimTable[] = +static const union AnimCmd *const gOctazookaAnimTable[] = { gOctazookaAnimCmds, }; @@ -1696,7 +1696,7 @@ const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const union AnimCmd gConversionAnimCmds[] = +static const union AnimCmd gConversionAnimCmds[] = { ANIMCMD_FRAME(3, 5), ANIMCMD_FRAME(2, 5), @@ -1705,18 +1705,18 @@ const union AnimCmd gConversionAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gConversionAnimTable[] = +static const union AnimCmd *const gConversionAnimTable[] = { gConversionAnimCmds, }; -const union AffineAnimCmd gConversionAffineAnimCmds[] = +static const union AffineAnimCmd gConversionAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gConversionAffineAnimTable[] = +static const union AffineAnimCmd *const gConversionAffineAnimTable[] = { gConversionAffineAnimCmds, }; @@ -1732,7 +1732,7 @@ const struct SpriteTemplate gConversionSpriteTemplate = .callback = AnimConversion, }; -const union AnimCmd gConversion2AnimCmds[] = +static const union AnimCmd gConversion2AnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(1, 5), @@ -1741,7 +1741,7 @@ const union AnimCmd gConversion2AnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gConversion2AnimTable[] = +static const union AnimCmd *const gConversion2AnimTable[] = { gConversion2AnimCmds, }; @@ -1768,7 +1768,7 @@ const struct SpriteTemplate gMoonSpriteTemplate = .callback = AnimMoon, }; -const union AnimCmd gMoonlightSparkleAnimCmds[] = +static const union AnimCmd gMoonlightSparkleAnimCmds[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(4, 8), @@ -1777,7 +1777,7 @@ const union AnimCmd gMoonlightSparkleAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gMoonlightSparkleAnimTable[] = +static const union AnimCmd *const gMoonlightSparkleAnimTable[] = { gMoonlightSparkleAnimCmds, }; @@ -1793,7 +1793,7 @@ const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = .callback = AnimMoonlightSparkle, }; -const union AnimCmd gHealingBlueStarAnimCmds[] = +static const union AnimCmd gHealingBlueStarAnimCmds[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(16, 2), @@ -1806,7 +1806,7 @@ const union AnimCmd gHealingBlueStarAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gHealingBlueStarAnimTable[] = +static const union AnimCmd *const gHealingBlueStarAnimTable[] = { gHealingBlueStarAnimCmds, }; @@ -1833,7 +1833,7 @@ const struct SpriteTemplate gHornHitSpriteTemplate = .callback = AnimHornHit, }; -const union AnimCmd gSuperFangAnimCmds[] = +static const union AnimCmd gSuperFangAnimCmds[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(16, 2), @@ -1842,7 +1842,7 @@ const union AnimCmd gSuperFangAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gSuperFangAnimTable[] = +static const union AnimCmd *const gSuperFangAnimTable[] = { gSuperFangAnimCmds, }; @@ -1858,49 +1858,49 @@ const struct SpriteTemplate gSuperFangSpriteTemplate = .callback = AnimSuperFang, }; -const union AnimCmd gWavyMusicNotesAnimCmds1[] = +static const union AnimCmd gWavyMusicNotesAnimCmds1[] = { ANIMCMD_FRAME(0, 10), ANIMCMD_END, }; -const union AnimCmd gWavyMusicNotesAnimCmds2[] = +static const union AnimCmd gWavyMusicNotesAnimCmds2[] = { ANIMCMD_FRAME(4, 10), ANIMCMD_END, }; -const union AnimCmd gWavyMusicNotesAnimCmds3[] = +static const union AnimCmd gWavyMusicNotesAnimCmds3[] = { ANIMCMD_FRAME(8, 41), ANIMCMD_END, }; -const union AnimCmd gWavyMusicNotesAnimCmds4[] = +static const union AnimCmd gWavyMusicNotesAnimCmds4[] = { ANIMCMD_FRAME(12, 10), ANIMCMD_END, }; -const union AnimCmd gWavyMusicNotesAnimCmds5[] = +static const union AnimCmd gWavyMusicNotesAnimCmds5[] = { ANIMCMD_FRAME(16, 10), ANIMCMD_END, }; -const union AnimCmd gWavyMusicNotesAnimCmds6[] = +static const union AnimCmd gWavyMusicNotesAnimCmds6[] = { ANIMCMD_FRAME(20, 10), ANIMCMD_END, }; -const union AnimCmd gWavyMusicNotesAnimCmds7[] = +static const union AnimCmd gWavyMusicNotesAnimCmds7[] = { ANIMCMD_FRAME(0, 10, .vFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gWavyMusicNotesAnimCmds8[] = +static const union AnimCmd gWavyMusicNotesAnimCmds8[] = { ANIMCMD_FRAME(4, 10, .vFlip = TRUE), ANIMCMD_END, @@ -1918,14 +1918,14 @@ const union AnimCmd *const gMusicNotesAnimTable[] = gWavyMusicNotesAnimCmds8, }; -const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = +static const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0xC, 0xC, 0, 16), AFFINEANIMCMD_FRAME(0xFFF4, 0xFFF4, 0, 16), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = +static const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = { gWavyMusicNotesAffineAnimCmds, }; @@ -1941,7 +1941,7 @@ const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = .callback = AnimWavyMusicNotes, }; -const u16 gParticlesColorBlendTable[][6] = +static const u16 gParticlesColorBlendTable[][6] = { {ANIM_TAG_MUSIC_NOTES, RGB_WHITE, RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, {ANIM_TAG_BENT_SPOON, RGB_WHITE, RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, @@ -1971,14 +1971,14 @@ const struct SpriteTemplate gBellyDrumHandSpriteTemplate = .callback = AnimBellyDrumHand, }; -const union AffineAnimCmd gSlowFlyingMusicNotesAffineAnimCmds[] = +static const union AffineAnimCmd gSlowFlyingMusicNotesAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0xA0, 0xA0, 0, 0), AFFINEANIMCMD_FRAME(0x4, 0x4, 0, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gSlowFlyingMusicNotesAffineAnimTable[] = +static const union AffineAnimCmd *const gSlowFlyingMusicNotesAffineAnimTable[] = { gSlowFlyingMusicNotesAffineAnimCmds, }; @@ -1994,7 +1994,7 @@ const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = .callback = AnimSlowFlyingMusicNotes, }; -const union AnimCmd gMetronomeThroughtBubbleAnimCmds1[] = +static const union AnimCmd gMetronomeThroughtBubbleAnimCmds1[] = { ANIMCMD_FRAME(0, 2, .hFlip = TRUE), ANIMCMD_FRAME(16, 2, .hFlip = TRUE), @@ -2003,7 +2003,7 @@ const union AnimCmd gMetronomeThroughtBubbleAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gMetronomeThroughtBubbleAnimCmds3[] = +static const union AnimCmd gMetronomeThroughtBubbleAnimCmds3[] = { ANIMCMD_FRAME(48, 2, .hFlip = TRUE), ANIMCMD_FRAME(32, 2, .hFlip = TRUE), @@ -2012,7 +2012,7 @@ const union AnimCmd gMetronomeThroughtBubbleAnimCmds3[] = ANIMCMD_END, }; -const union AnimCmd gMetronomeThroughtBubbleAnimCmds2[] = +static const union AnimCmd gMetronomeThroughtBubbleAnimCmds2[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(16, 2), @@ -2021,7 +2021,7 @@ const union AnimCmd gMetronomeThroughtBubbleAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd gMetronomeThroughtBubbleAnimCmds4[] = +static const union AnimCmd gMetronomeThroughtBubbleAnimCmds4[] = { ANIMCMD_FRAME(48, 2), ANIMCMD_FRAME(32, 2), @@ -2030,7 +2030,7 @@ const union AnimCmd gMetronomeThroughtBubbleAnimCmds4[] = ANIMCMD_END, }; -const union AnimCmd *const gMetronomeThroughtBubbleAnimTable[] = +static const union AnimCmd *const gMetronomeThroughtBubbleAnimTable[] = { gMetronomeThroughtBubbleAnimCmds1, gMetronomeThroughtBubbleAnimCmds2, @@ -2049,14 +2049,14 @@ const struct SpriteTemplate gThoughtBubbleSpriteTemplate = .callback = AnimThoughtBubble, }; -const union AffineAnimCmd gMetronomeFingerAffineAnimCmds1[] = +static const union AffineAnimCmd gMetronomeFingerAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), AFFINEANIMCMD_FRAME(0x1E, 0x1E, 0, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = +static const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 11), AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 11), @@ -2065,7 +2065,7 @@ const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2_2[] = +static const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2_2[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_FRAME(30, 30, 0, 8), @@ -2078,7 +2078,7 @@ const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2_2[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gMetronomeFingerAffineAnimTable[] = +static const union AffineAnimCmd *const gMetronomeFingerAffineAnimTable[] = { gMetronomeFingerAffineAnimCmds1, gMetronomeFingerAffineAnimCmds2, @@ -2106,19 +2106,19 @@ const struct SpriteTemplate gFollowMeFingerSpriteTemplate = .callback = AnimFollowMeFinger, }; -const union AnimCmd gTauntFingerAnimCmds1[] = +static const union AnimCmd gTauntFingerAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -const union AnimCmd gTauntFingerAnimCmds2[] = +static const union AnimCmd gTauntFingerAnimCmds2[] = { ANIMCMD_FRAME(0, 1, .hFlip = TRUE), ANIMCMD_END, }; -const union AnimCmd gTauntFingerAnimCmds3[] = +static const union AnimCmd gTauntFingerAnimCmds3[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -2130,7 +2130,7 @@ const union AnimCmd gTauntFingerAnimCmds3[] = ANIMCMD_END, }; -const union AnimCmd gTauntFingerAnimCmds4[] = +static const union AnimCmd gTauntFingerAnimCmds4[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(16, 4, .hFlip = TRUE), @@ -2142,7 +2142,7 @@ const union AnimCmd gTauntFingerAnimCmds4[] = ANIMCMD_END, }; -const union AnimCmd *const gTauntFingerAnimTable[] = +static const union AnimCmd *const gTauntFingerAnimTable[] = { gTauntFingerAnimCmds1, gTauntFingerAnimCmds2, @@ -2655,7 +2655,7 @@ static void AnimTranslateLinearSingleSineWaveStep(struct Sprite* sprite) if (b > 200 && r0 < 56 && sprite->oam.affineParam == 0) sprite->oam.affineParam++; - if (sprite->oam.affineParam && sprite->data[0]) + if (sprite->oam.affineParam != 0 && sprite->data[0] != 0) { sprite->invisible ^= 1; sprite->oam.affineParam++; @@ -2773,7 +2773,6 @@ static void AnimConstrictBindingStep2(struct Sprite* sprite) } } -// Unused void sub_80A2F0C(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(ANIM_TARGET); @@ -3157,14 +3156,14 @@ static void AnimItemStealStep3(struct Sprite* sprite) sprite->pos2.y = Sin(sprite->data[0] + 0x80, 30 - sprite->data[1] * 8); if (sprite->pos2.y == 0) - PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(63)); + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(SOUND_PAN_TARGET)); if (MoveAlongLinearPath(sprite)) { sprite->pos2.y = 0; sprite->data[0] = 0; sprite->callback = AnimItemStealStep2; - PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(-64)); + PlaySE12WithPanning(SE_W145B, BattleAnimAdjustPanning(SOUND_PAN_ATTACKER)); } } @@ -4246,7 +4245,7 @@ static void AnimLockOnTargetStep1(struct Sprite* sprite) sprite->callback = StartAnimLinearTranslation; StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep2); sprite->data[5] += 0x100; - PlaySE12WithPanning(SE_W199, BattleAnimAdjustPanning(63)); + PlaySE12WithPanning(SE_W199, BattleAnimAdjustPanning(SOUND_PAN_TARGET)); break; } @@ -4333,7 +4332,7 @@ static void AnimLockOnTargetStep4(struct Sprite* sprite) sprite->data[2]++; pal = sprite->oam.paletteNum; LoadPalette(&gPlttBufferUnfaded[0x108 + pal * 16], pal * 16 | 0x101, 4); - PlaySE12WithPanning(SE_W043, BattleAnimAdjustPanning(63)); + PlaySE12WithPanning(SE_W043, BattleAnimAdjustPanning(SOUND_PAN_TARGET)); } else if (sprite->data[1] == 0) { @@ -4420,7 +4419,7 @@ void AnimBowMon(struct Sprite* sprite) static void AnimBowMonStep1(struct Sprite* sprite) { sprite->data[0] = 6; - sprite->data[1] = (GetBattlerSide(gBattleAnimAttacker)) ? 2 : -2; + sprite->data[1] = (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) ? 2 : -2; sprite->data[2] = 0; sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; StoreSpriteCallbackInData6(sprite, AnimBowMonStep1_Callback); @@ -4450,7 +4449,7 @@ static void AnimBowMonStep1_Callback(struct Sprite* sprite) static void AnimBowMonStep2(struct Sprite* sprite) { sprite->data[0] = 4; - sprite->data[1] = (GetBattlerSide(gBattleAnimAttacker)) ? -3 : 3; + sprite->data[1] = (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) ? -3 : 3; sprite->data[2] = 0; sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; StoreSpriteCallbackInData6(sprite, AnimBowMonStep4); @@ -4544,11 +4543,11 @@ static void sub_80A55A0(struct Sprite *sprite) void AnimTask_SkullBashPosition(u8 taskId) { - u8 a; + u8 side; gTasks[taskId].data[0] = gBattlerSpriteIds[gBattleAnimAttacker]; - a = GetBattlerSide(gBattleAnimAttacker); - gTasks[taskId].data[1] = a; + side = GetBattlerSide(gBattleAnimAttacker); + gTasks[taskId].data[1] = side; gTasks[taskId].data[2] = 0; switch (gBattleAnimArgs[0]) { @@ -4560,7 +4559,7 @@ void AnimTask_SkullBashPosition(u8 taskId) gTasks[taskId].data[3] = 8; gTasks[taskId].data[4] = 0; gTasks[taskId].data[5] = 3; - if (a == 0) + if (side == B_SIDE_PLAYER) gTasks[taskId].data[5] *= -1; gTasks[taskId].func = AnimTask_SkullBashPositionSet; @@ -4569,7 +4568,7 @@ void AnimTask_SkullBashPosition(u8 taskId) gTasks[taskId].data[3] = 8; gTasks[taskId].data[4] = 0x600; gTasks[taskId].data[5] = 0xC0; - if (a == 0) + if (side == B_SIDE_PLAYER) { gTasks[taskId].data[4] = -gTasks[taskId].data[4]; gTasks[taskId].data[5] = -gTasks[taskId].data[5]; @@ -4797,7 +4796,7 @@ void AnimSharpenSphere(struct Sprite* sprite) sprite->data[2] = 0; sprite->data[3] = 0; sprite->data[4] = 0; - sprite->data[5] = BattleAnimAdjustPanning(-64); + sprite->data[5] = BattleAnimAdjustPanning(SOUND_PAN_ATTACKER); sprite->callback = AnimSharpenSphereStep; } @@ -4868,7 +4867,7 @@ void AnimTask_ConversionAlphaBlend(u8 taskId) void AnimConversion2(struct Sprite* sprite) { InitSpritePosToAnimTarget(sprite, FALSE); - sprite->animPaused = 1; + sprite->animPaused = TRUE; sprite->data[0] = gBattleAnimArgs[2]; sprite->callback = AnimConversion2Step; } @@ -4881,7 +4880,7 @@ static void AnimConversion2Step(struct Sprite* sprite) } else { - sprite->animPaused = 0; + sprite->animPaused = FALSE; sprite->data[0] = 30; sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET); @@ -4941,8 +4940,8 @@ void AnimMoon(struct Sprite* sprite) sprite->pos1.y = gBattleAnimArgs[1]; } - sprite->oam.shape = 0; - sprite->oam.size = 3; + sprite->oam.shape = SPRITE_SHAPE(8x8); + sprite->oam.size = SPRITE_SIZE(64x32); sprite->data[0] = 0; sprite->callback = AnimMoonStep; } @@ -5434,7 +5433,7 @@ void AnimSlowFlyingMusicNotes(struct Sprite* sprite) static void AnimSlowFlyingMusicNotesStep(struct Sprite* sprite) { - if (AnimTranslateLinear(sprite) == 0) + if (!AnimTranslateLinear(sprite)) { s16 xDiff; diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index ad2da7d2e..3a33276a1 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -65,7 +65,7 @@ static void AnimPerishSongMusicNote_Step2(struct Sprite *); // Data // Unused -const struct SpriteTemplate gUnknown_83E3ADC = +static const struct SpriteTemplate gUnknown_83E3ADC = { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -76,19 +76,19 @@ const struct SpriteTemplate gUnknown_83E3ADC = .callback = sub_80A6E48, }; -const union AnimCmd gUnknown_83E3AF4[] = +static const union AnimCmd gUnknown_83E3AF4[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd *const gUnknown_83E3AFC[] = +static const union AnimCmd *const gUnknown_83E3AFC[] = { gUnknown_83E3AF4, }; // Unused -const struct SpriteTemplate gUnknown_83E3B00 = +static const struct SpriteTemplate gUnknown_83E3B00 = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -100,7 +100,7 @@ const struct SpriteTemplate gUnknown_83E3B00 = }; // Unused -const struct SpriteTemplate gUnknown_83E3B18 = +static const struct SpriteTemplate gUnknown_83E3B18 = { .tileTag = 0, .paletteTag = 0, @@ -112,7 +112,7 @@ const struct SpriteTemplate gUnknown_83E3B18 = }; // Unused -const struct SpriteTemplate gUnknown_83E3B30 = +static const struct SpriteTemplate gUnknown_83E3B30 = { .tileTag = ANIM_TAG_CLAMP, .paletteTag = ANIM_TAG_CLAMP, @@ -123,7 +123,7 @@ const struct SpriteTemplate gUnknown_83E3B30 = .callback = sub_80A7020, }; -const union AnimCmd gUnknown_83E3B48[] = +static const union AnimCmd gUnknown_83E3B48[] = { ANIMCMD_FRAME(0, 9), ANIMCMD_FRAME(16, 3), @@ -132,25 +132,25 @@ const union AnimCmd gUnknown_83E3B48[] = ANIMCMD_END, }; -const union AnimCmd *const gUnknown_83E3B5C[] = +static const union AnimCmd *const gUnknown_83E3B5C[] = { gUnknown_83E3B48, }; -const union AffineAnimCmd gUnknown_83E3B60[] = +static const union AffineAnimCmd gUnknown_83E3B60[] = { AFFINEANIMCMD_FRAME(80, 80, 0, 0), AFFINEANIMCMD_FRAME(9, 9, 0, 18), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gUnknown_83E3B78[] = +static const union AffineAnimCmd *const gUnknown_83E3B78[] = { gUnknown_83E3B60, }; // Unused -const struct SpriteTemplate gUnknown_83E3B7C = +static const struct SpriteTemplate gUnknown_83E3B7C = { .tileTag = ANIM_TAG_EXPLOSION_6, .paletteTag = ANIM_TAG_EXPLOSION_6, @@ -161,7 +161,7 @@ const struct SpriteTemplate gUnknown_83E3B7C = .callback = AnimSpriteOnMonPos, }; -const union AnimCmd gKinesisZapEnergyAnimCmds[] = +static const union AnimCmd gKinesisZapEnergyAnimCmds[] = { ANIMCMD_FRAME(0, 3, .hFlip = TRUE), ANIMCMD_FRAME(8, 3, .hFlip = TRUE), @@ -174,7 +174,7 @@ const union AnimCmd gKinesisZapEnergyAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gKinesisZapEnergyAnimTable[] = +static const union AnimCmd *const gKinesisZapEnergyAnimTable[] = { gKinesisZapEnergyAnimCmds, }; @@ -190,7 +190,7 @@ const struct SpriteTemplate gKinesisZapEnergySpriteTemplate = .callback = Anim_KinesisZapEnergy, }; -const union AffineAnimCmd gSwordsDanceBladeAffineAnimCmds[] = +static const union AffineAnimCmd gSwordsDanceBladeAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 256, 0, 0), AFFINEANIMCMD_FRAME(20, 0, 0, 12), @@ -198,7 +198,7 @@ const union AffineAnimCmd gSwordsDanceBladeAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gSwordsDanceBladeAffineAnimTable[] = +static const union AffineAnimCmd *const gSwordsDanceBladeAffineAnimTable[] = { gSwordsDanceBladeAffineAnimCmds, }; @@ -236,14 +236,14 @@ const struct SpriteTemplate gAirWaveProjectileSpriteTemplate = .callback = AnimAirWaveProjectile, }; -const union AffineAnimCmd gGrowingRingAffineAnimCmds[] = +static const union AffineAnimCmd gGrowingRingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(32, 32, 0, 0), AFFINEANIMCMD_FRAME(7, 7, 0, -56), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = +static const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(5, 5, 0, 10), AFFINEANIMCMD_FRAME(-10, -10, 0, 10), @@ -260,7 +260,7 @@ const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = gGrowingRingAffineAnimCmds, }; -const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = +static const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = { gWaterPulseRingAffineAnimCmds, }; @@ -331,24 +331,24 @@ const struct SpriteTemplate gUnknown_83E3D18 = .callback = sub_80A79E8, }; -const union AnimCmd gCoinAnimCmds[] = +static const union AnimCmd gCoinAnimCmds[] = { ANIMCMD_FRAME(8, 1), ANIMCMD_END, }; -const union AnimCmd *const gCoinAnimTable[] = +static const union AnimCmd *const gCoinAnimTable[] = { gCoinAnimCmds, }; -const union AffineAnimCmd gFallingCoinAffineAnimCmds[] = +static const union AffineAnimCmd gFallingCoinAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 10, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gFallingCoinAffineAnimTable[] = +static const union AffineAnimCmd *const gFallingCoinAffineAnimTable[] = { gFallingCoinAffineAnimCmds, }; @@ -375,13 +375,13 @@ const struct SpriteTemplate gFallingCoinSpriteTemplate = .callback = AnimFallingCoin, }; -const union AffineAnimCmd gBulletSeedAffineAnimCmds[] = +static const union AffineAnimCmd gBulletSeedAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 20, 1), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gBulletSeedAffineAnimTable[] = +static const union AffineAnimCmd *const gBulletSeedAffineAnimTable[] = { gBulletSeedAffineAnimCmds, }; @@ -397,14 +397,14 @@ const struct SpriteTemplate gBulletSeedSpriteTemplate = .callback = AnimBulletSeed, }; -const union AffineAnimCmd gRazorWindTornadoAffineAnimCmds[] = +static const union AffineAnimCmd gRazorWindTornadoAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 256, 0, 0), AFFINEANIMCMD_FRAME(4, 0, 0, 40), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gRazorWindTornadoAffineAnimTable[] = +static const union AffineAnimCmd *const gRazorWindTornadoAffineAnimTable[] = { gRazorWindTornadoAffineAnimCmds, }; @@ -420,7 +420,7 @@ const struct SpriteTemplate gRazorWindTornadoSpriteTemplate = .callback = AnimRazorWindTornado, }; -const union AnimCmd gViceGripAnimCmds1[] = +static const union AnimCmd gViceGripAnimCmds1[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -428,7 +428,7 @@ const union AnimCmd gViceGripAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gViceGripAnimCmds2[] = +static const union AnimCmd gViceGripAnimCmds2[] = { ANIMCMD_FRAME(0, 3, .vFlip = TRUE, .hFlip = TRUE), ANIMCMD_FRAME(16, 3, .vFlip = TRUE, .hFlip = TRUE), @@ -436,7 +436,7 @@ const union AnimCmd gViceGripAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gViceGripAnimTable[] = +static const union AnimCmd *const gViceGripAnimTable[] = { gViceGripAnimCmds1, gViceGripAnimCmds2, @@ -453,7 +453,7 @@ const struct SpriteTemplate gViceGripSpriteTemplate = .callback = AnimViceGripPincer, }; -const union AnimCmd gGuillotineAnimCmds1[] = +static const union AnimCmd gGuillotineAnimCmds1[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(16, 2), @@ -461,7 +461,7 @@ const union AnimCmd gGuillotineAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gGuillotineAnimCmds2[] = +static const union AnimCmd gGuillotineAnimCmds2[] = { ANIMCMD_FRAME(0, 2, .vFlip = TRUE, .hFlip = TRUE), ANIMCMD_FRAME(16, 2, .vFlip = TRUE, .hFlip = TRUE), @@ -469,7 +469,7 @@ const union AnimCmd gGuillotineAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gGuillotineAnimTable[] = +static const union AnimCmd *const gGuillotineAnimTable[] = { gGuillotineAnimCmds1, gGuillotineAnimCmds2, @@ -486,7 +486,7 @@ const struct SpriteTemplate gGuillotineSpriteTemplate = .callback = AnimGuillotinePincer, }; -const union AffineAnimCmd gSplashEffectAffineAnimCmds[] = +static const union AffineAnimCmd gSplashEffectAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-6, 4, 0, 8), AFFINEANIMCMD_FRAME(10, -10, 0, 8), @@ -494,7 +494,7 @@ const union AffineAnimCmd gSplashEffectAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gGrowAndShrinkAffineAnimCmds[] = +static const union AffineAnimCmd gGrowAndShrinkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-4, -5, 0, 12), AFFINEANIMCMD_FRAME(0, 0, 0, 24), @@ -502,7 +502,7 @@ const union AffineAnimCmd gGrowAndShrinkAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AnimCmd gBreathPuffAnimCmds1[] = +static const union AnimCmd gBreathPuffAnimCmds1[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(4, 40, .hFlip = TRUE), @@ -511,7 +511,7 @@ const union AnimCmd gBreathPuffAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gBreathPuffAnimCmds2[] = +static const union AnimCmd gBreathPuffAnimCmds2[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 40), @@ -520,7 +520,7 @@ const union AnimCmd gBreathPuffAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gBreathPuffAnimTable[] = +static const union AnimCmd *const gBreathPuffAnimTable[] = { gBreathPuffAnimCmds1, gBreathPuffAnimCmds2, @@ -537,14 +537,14 @@ const struct SpriteTemplate gBreathPuffSpriteTemplate = .callback = AnimBreathPuff, }; -const union AffineAnimCmd gAngerMarkAffineAnimCmds[] = +static const union AffineAnimCmd gAngerMarkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(11, 11, 0, 8), AFFINEANIMCMD_FRAME(-11, -11, 0, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gAngerMarkAffineAnimTable[] = +static const union AffineAnimCmd *const gAngerMarkAffineAnimTable[] = { gAngerMarkAffineAnimCmds, }; @@ -560,7 +560,7 @@ const struct SpriteTemplate gAngerMarkSpriteTemplate = .callback = AnimAngerMark, }; -const union AffineAnimCmd gThrashMoveMonAffineAnimCmds[] = +static const union AffineAnimCmd gThrashMoveMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-10, 9, 0, 7), AFFINEANIMCMD_FRAME(20, -20, 0, 7), @@ -592,7 +592,7 @@ const struct SpriteTemplate gSnoreZSpriteTemplate = .callback = AnimSnoreZ, }; -const union AnimCmd gExplosionAnimCmds[] = +static const union AnimCmd gExplosionAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(16, 5), @@ -601,7 +601,7 @@ const union AnimCmd gExplosionAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gExplosionAnimTable[] = +static const union AnimCmd *const gExplosionAnimTable[] = { gExplosionAnimCmds, }; @@ -617,7 +617,7 @@ const struct SpriteTemplate gExplosionSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds1[] = +static const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, -8, 2), AFFINEANIMCMD_FRAME(0, 0, 8, 4), @@ -625,13 +625,13 @@ const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds2[] = +static const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = +static const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(-8, 4, 0, 8), AFFINEANIMCMD_LOOP(0), @@ -643,7 +643,7 @@ const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gSoftBoiledEggAffineAnimTable[] = +static const union AffineAnimCmd *const gSoftBoiledEggAffineAnimTable[] = { gSoftBoiledEggAffineAnimCmds1, gSoftBoiledEggAffineAnimCmds2, @@ -661,34 +661,34 @@ const struct SpriteTemplate gSoftBoiledEggSpriteTemplate = .callback = AnimSoftBoiledEgg, }; -const union AffineAnimCmd gThinRingExpandingAffineAnimCmds1[] = +static const union AffineAnimCmd gThinRingExpandingAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_FRAME(16, 16, 0, 30), AFFINEANIMCMD_END_ALT(1), }; -const union AffineAnimCmd gThinRingExpandingAffineAnimCmds2[] = +static const union AffineAnimCmd gThinRingExpandingAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_FRAME(32, 32, 0, 15), AFFINEANIMCMD_END_ALT(1), }; -const union AffineAnimCmd gHyperVoiceRingAffineAnimCmds[] = +static const union AffineAnimCmd gHyperVoiceRingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_FRAME(11, 11, 0, 45), AFFINEANIMCMD_END_ALT(1), }; -const union AffineAnimCmd *const gThinRingExpandingAffineAnimTable[] = +static const union AffineAnimCmd *const gThinRingExpandingAffineAnimTable[] = { gThinRingExpandingAffineAnimCmds1, gThinRingExpandingAffineAnimCmds2, }; -const union AffineAnimCmd *const gHyperVoiceRingAffineAnimTable[] = +static const union AffineAnimCmd *const gHyperVoiceRingAffineAnimTable[] = { gHyperVoiceRingAffineAnimCmds, }; @@ -704,14 +704,14 @@ const struct SpriteTemplate gThinRingExpandingSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const union AffineAnimCmd gThinRingShrinkingAffineAnimCmds[] = +static const union AffineAnimCmd gThinRingShrinkingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(512, 512, 0, 0), AFFINEANIMCMD_FRAME(-16, -16, 0, 30), AFFINEANIMCMD_END_ALT(1), }; -const union AffineAnimCmd *const gThinRingShrinkingAffineAnimTable[] = +static const union AffineAnimCmd *const gThinRingShrinkingAffineAnimTable[] = { gThinRingShrinkingAffineAnimCmds, }; @@ -760,13 +760,13 @@ const struct SpriteTemplate gUproarRingSpriteTemplate = .callback = AnimUproarRing, }; -const union AffineAnimCmd gStretchAttackerAffineAnimCmds[] = +static const union AffineAnimCmd gStretchAttackerAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(96, -13, 0, 8), AFFINEANIMCMD_END, }; -const union AnimCmd gSpeedDustAnimCmds[] = +static const union AnimCmd gSpeedDustAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(4, 3), @@ -776,7 +776,7 @@ const union AnimCmd gSpeedDustAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gSpeedDustAnimTable[] = +static const union AnimCmd *const gSpeedDustAnimTable[] = { gSpeedDustAnimCmds, }; @@ -800,7 +800,7 @@ const s8 gSpeedDustPosTable[][2] = {-10, 28}, }; -const union AnimCmd gBellAnimCmds[] = +static const union AnimCmd gBellAnimCmds[] = { ANIMCMD_FRAME(0, 6), ANIMCMD_FRAME(16, 6), @@ -818,7 +818,7 @@ const union AnimCmd gBellAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gBellAnimTable[] = +static const union AnimCmd *const gBellAnimTable[] = { gBellAnimCmds, }; @@ -863,7 +863,7 @@ const struct SpriteTemplate gMagentaHeartSpriteTemplate = .callback = AnimMagentaHeart, }; -const union AffineAnimCmd gUnknown_83E4200[] = +static const union AffineAnimCmd gUnknown_83E4200[] = { AFFINEANIMCMD_FRAME(10, -13, 0, 10), AFFINEANIMCMD_FRAME(-10, 13, 0, 10), @@ -903,14 +903,14 @@ const struct SpriteTemplate gRedHeartRisingSpriteTemplate = .callback = AnimRedHeartRising, }; -const union AffineAnimCmd gHiddenPowerOrbAffineAnimCmds[] = +static const union AffineAnimCmd gHiddenPowerOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(128, 128, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gHiddenPowerOrbAffineAnimTable[] = +static const union AffineAnimCmd *const gHiddenPowerOrbAffineAnimTable[] = { gHiddenPowerOrbAffineAnimCmds, }; @@ -937,14 +937,14 @@ const struct SpriteTemplate gHiddenPowerOrbScatterSpriteTemplate = .callback = AnimOrbitScatter, }; -const union AffineAnimCmd gSpitUpOrbAffineAnimCmds[] = +static const union AffineAnimCmd gSpitUpOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(128, 128, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 1), AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd *const gSpitUpOrbAffineAnimTable[] = +static const union AffineAnimCmd *const gSpitUpOrbAffineAnimTable[] = { gSpitUpOrbAffineAnimCmds, }; @@ -960,7 +960,7 @@ const struct SpriteTemplate gSpitUpOrbSpriteTemplate = .callback = AnimSpitUpOrb, }; -const union AnimCmd gEyeSparkleAnimCmds[] = +static const union AnimCmd gEyeSparkleAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 4), @@ -970,7 +970,7 @@ const union AnimCmd gEyeSparkleAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gEyeSparkleAnimTable[] = +static const union AnimCmd *const gEyeSparkleAnimTable[] = { gEyeSparkleAnimCmds, }; @@ -986,13 +986,13 @@ const struct SpriteTemplate gEyeSparkleSpriteTemplate = .callback = AnimEyeSparkle, }; -const union AnimCmd gAngelSpriteAnimCmds[] = +static const union AnimCmd gAngelSpriteAnimCmds[] = { ANIMCMD_FRAME(0, 24), ANIMCMD_END, }; -const union AnimCmd *const gAngelSpriteAnimTable[] = +static const union AnimCmd *const gAngelSpriteAnimTable[] = { gAngelSpriteAnimCmds, }; @@ -1019,19 +1019,19 @@ const struct SpriteTemplate gPinkHeartSpriteTemplate = .callback = AnimPinkHeart, }; -const union AnimCmd gDevilAnimCmds1[] = +static const union AnimCmd gDevilAnimCmds1[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd gDevilAnimCmds2[] = +static const union AnimCmd gDevilAnimCmds2[] = { ANIMCMD_FRAME(16, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gDevilAnimTable[] = +static const union AnimCmd *const gDevilAnimTable[] = { gDevilAnimCmds1, gDevilAnimCmds2, @@ -1048,7 +1048,7 @@ const struct SpriteTemplate gDevilSpriteTemplate = .callback = AnimDevil, }; -const union AnimCmd gUnknown_08593B08[] = +static const union AnimCmd gUnknown_08593B08[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1057,7 +1057,7 @@ const union AnimCmd gUnknown_08593B08[] = ANIMCMD_END, }; -const union AnimCmd gUnknown_08593B1C[] = +static const union AnimCmd gUnknown_08593B1C[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(16, 4, .hFlip = TRUE), @@ -1066,7 +1066,7 @@ const union AnimCmd gUnknown_08593B1C[] = ANIMCMD_END, }; -const union AnimCmd *const gFurySwipesAnimTable[] = +static const union AnimCmd *const gFurySwipesAnimTable[] = { gUnknown_08593B08, gUnknown_08593B1C, @@ -1083,7 +1083,7 @@ const struct SpriteTemplate gFurySwipesSpriteTemplate = .callback = AnimFurySwipes, }; -const union AnimCmd gMovementWavesAnimCmds1[] = +static const union AnimCmd gMovementWavesAnimCmds1[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(16, 8), @@ -1092,7 +1092,7 @@ const union AnimCmd gMovementWavesAnimCmds1[] = ANIMCMD_END, }; -const union AnimCmd gMovementWavesAnimCmds2[] = +static const union AnimCmd gMovementWavesAnimCmds2[] = { ANIMCMD_FRAME(16, 8, .hFlip = TRUE), ANIMCMD_FRAME(32, 8, .hFlip = TRUE), @@ -1101,7 +1101,7 @@ const union AnimCmd gMovementWavesAnimCmds2[] = ANIMCMD_END, }; -const union AnimCmd *const gMovementWavesAnimTable[] = +static const union AnimCmd *const gMovementWavesAnimTable[] = { gMovementWavesAnimCmds1, gMovementWavesAnimCmds2, @@ -1118,7 +1118,7 @@ const struct SpriteTemplate gMovementWavesSpriteTemplate = .callback = AnimMovementWaves, }; -const union AffineAnimCmd gUnknown_08593B98[] = +static const union AffineAnimCmd gUnknown_08593B98[] = { AFFINEANIMCMD_FRAME(-12, 8, 0, 4), AFFINEANIMCMD_FRAME(20, -20, 0, 4), @@ -1137,25 +1137,25 @@ const struct SpriteTemplate gJaggedMusicNoteSpriteTemplate = .callback = AnimJaggedMusicNote, }; -const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds1[] = +static const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 5), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds2[] = +static const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0, 0, -8, 16), AFFINEANIMCMD_END_ALT(1), }; -const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds3[] = +static const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(0, 0, 8, 16), AFFINEANIMCMD_END_ALT(1), }; -const union AffineAnimCmd *const gPerishSongMusicNoteAffineAnimTable[] = +static const union AffineAnimCmd *const gPerishSongMusicNoteAffineAnimTable[] = { gPerishSongMusicNoteAffineAnimCmds1, gPerishSongMusicNoteAffineAnimCmds2, @@ -1184,19 +1184,19 @@ const struct SpriteTemplate gPerishSongMusicNote2SpriteTemplate = .callback = AnimPerishSongMusicNote2, }; -const union AffineAnimCmd gGuardRingAffineAnimCmds1[] = +static const union AffineAnimCmd gGuardRingAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gGuardRingAffineAnimCmds2[] = +static const union AffineAnimCmd gGuardRingAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(512, 256, 0, 0), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gGuardRingAffineAnimTable[] = +static const union AffineAnimCmd *const gGuardRingAffineAnimTable[] = { gGuardRingAffineAnimCmds1, gGuardRingAffineAnimCmds2, @@ -1788,7 +1788,7 @@ static void AnimBulletSeed_Step1(struct Sprite *sprite) u16 rand; s16* ptr; - PlaySE12WithPanning(SE_W030, BattleAnimAdjustPanning(63)); + PlaySE12WithPanning(SE_W030, BattleAnimAdjustPanning(SOUND_PAN_TARGET)); sprite->pos1.x += sprite->pos2.x; sprite->pos1.y += sprite->pos2.y; sprite->pos2.y = 0; @@ -2621,7 +2621,7 @@ void AnimHyperVoiceRing(struct Sprite *sprite) sp1 = GetBattlerSpriteCoord(battler2, sp4); } - if (GetBattlerSide(battler2)) + if (GetBattlerSide(battler2) != B_SIDE_PLAYER) sp0 += gBattleAnimArgs[3]; else sp0 -= gBattleAnimArgs[3]; diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index f9efc04cd..cb2f8b78e 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -79,7 +79,7 @@ static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); // Data -const union AnimCmd gScratchAnimCmds[] = +static const union AnimCmd gScratchAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -89,7 +89,7 @@ const union AnimCmd gScratchAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gScratchAnimTable[] = +static const union AnimCmd *const gScratchAnimTable[] = { gScratchAnimCmds, }; @@ -127,7 +127,7 @@ const struct SpriteTemplate gBlackBallSpriteTemplate = .callback = AnimThrowProjectile, }; -const union AnimCmd gOpeningEyeAnimCmds[] = +static const union AnimCmd gOpeningEyeAnimCmds[] = { ANIMCMD_FRAME(0, 40), ANIMCMD_FRAME(16, 8), @@ -135,7 +135,7 @@ const union AnimCmd gOpeningEyeAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gOpeningEyeAnimTable[] = +static const union AnimCmd *const gOpeningEyeAnimTable[] = { gOpeningEyeAnimCmds, }; @@ -173,7 +173,7 @@ const struct SpriteTemplate gTealAlertSpriteTemplate = .callback = AnimTealAlert, }; -const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = +static const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x180, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x20, 0x18, 0, 5), @@ -181,14 +181,14 @@ const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(1), }; -const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = +static const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x30, 0x30, 0, 0), AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 6), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = +static const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = { gMeanLookEyeAffineAnimCmds1, gMeanLookEyeAffineAnimCmds2, @@ -216,7 +216,7 @@ const struct SpriteTemplate gSpikesSpriteTemplate = .callback = AnimSpikes, }; -const union AnimCmd gLeerAnimCmds[] = +static const union AnimCmd gLeerAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -226,7 +226,7 @@ const union AnimCmd gLeerAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gLeerAnimTable[] = +static const union AnimCmd *const gLeerAnimTable[] = { gLeerAnimCmds, }; @@ -242,25 +242,25 @@ const struct SpriteTemplate gLeerSpriteTemplate = .callback = AnimLeer, }; -const union AnimCmd gLetterZAnimCmds[] = +static const union AnimCmd gLetterZAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_END, }; -const union AnimCmd *const gLetterZAnimTable[] = +static const union AnimCmd *const gLetterZAnimTable[] = { gLetterZAnimCmds, }; -const union AffineAnimCmd gLetterZAffineAnimCmds[] = +static const union AffineAnimCmd gLetterZAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-7, -7, -3, 16), AFFINEANIMCMD_FRAME(7, 7, 3, 16), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gLetterZAffineAnimTable[] = +static const union AffineAnimCmd *const gLetterZAffineAnimTable[] = { gLetterZAffineAnimCmds, }; @@ -276,7 +276,7 @@ const struct SpriteTemplate gLetterZSpriteTemplate = .callback = AnimLetterZ, }; -const union AnimCmd gFangAnimCmds[] = +static const union AnimCmd gFangAnimCmds[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(16, 16), @@ -285,19 +285,19 @@ const union AnimCmd gFangAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gFangAnimTable[] = +static const union AnimCmd *const gFangAnimTable[] = { gFangAnimCmds, }; -const union AffineAnimCmd gFangAffineAnimCmds[] = +static const union AffineAnimCmd gFangAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), AFFINEANIMCMD_FRAME(-0x20, -0x20, 0, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gFangAffineAnimTable[] = +static const union AffineAnimCmd *const gFangAffineAnimTable[] = { gFangAffineAnimCmds, }; @@ -313,21 +313,21 @@ const struct SpriteTemplate gFangSpriteTemplate = .callback = AnimFang, }; -const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = +static const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x0, 0x180, 0, 0), AFFINEANIMCMD_FRAME(0x10, 0x0, 0, 20), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = +static const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x140, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x10, 0x0, 0, 19), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = +static const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = { gSpotlightAffineAnimCmds1, gSpotlightAffineAnimCmds2, @@ -366,7 +366,7 @@ const struct SpriteTemplate gClappingHand2SpriteTemplate = .callback = AnimClappingHand2, }; -const union AnimCmd gRapidSpinAnimCmds[] = +static const union AnimCmd gRapidSpinAnimCmds[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(8, 2), @@ -374,7 +374,7 @@ const union AnimCmd gRapidSpinAnimCmds[] = ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRapidSpinAnimTable[] = +static const union AnimCmd *const gRapidSpinAnimTable[] = { gRapidSpinAnimCmds, }; @@ -390,7 +390,7 @@ const struct SpriteTemplate gRapidSpinSpriteTemplate = .callback = AnimRapidSpin, }; -const union AffineAnimCmd gUnknown_83FF080[] = +static const union AffineAnimCmd gUnknown_83FF080[] = { AFFINEANIMCMD_FRAME(-12, 8, 0, 4), AFFINEANIMCMD_FRAME(20, -20, 0, 4), @@ -398,18 +398,18 @@ const union AffineAnimCmd gUnknown_83FF080[] = AFFINEANIMCMD_END, }; -const union AnimCmd gTriAttackTriangleAnimCmds[] = +static const union AnimCmd gTriAttackTriangleAnimCmds[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -const union AnimCmd *const gTriAttackTriangleAnimTable[] = +static const union AnimCmd *const gTriAttackTriangleAnimTable[] = { gTriAttackTriangleAnimCmds, }; -const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = +static const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 5, 40), AFFINEANIMCMD_FRAME(0, 0, 10, 10), @@ -418,7 +418,7 @@ const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = +static const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = { gTriAttackTriangleAffineAnimCmds, }; @@ -434,7 +434,7 @@ const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = .callback = AnimTriAttackTriangle, }; -const union AnimCmd gEclipsingOrbAnimCmds[] = +static const union AnimCmd gEclipsingOrbAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -447,7 +447,7 @@ const union AnimCmd gEclipsingOrbAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gEclipsingOrbAnimTable[] = +static const union AnimCmd *const gEclipsingOrbAnimTable[] = { gEclipsingOrbAnimCmds, }; @@ -463,7 +463,7 @@ const struct SpriteTemplate gEclipsingOrbSpriteTemplate = .callback = AnimSpriteOnMonPos, }; -const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = +static const union AffineAnimCmd DefenseCurlDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-12, 20, 0, 8), AFFINEANIMCMD_FRAME(12, -20, 0, 8), @@ -504,7 +504,7 @@ const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = .callback = AnimMiniTwinklingStar, }; -const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = +static const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(8, -8, 0, 12), AFFINEANIMCMD_FRAME(-16, 16, 0, 12), @@ -513,7 +513,7 @@ const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = +static const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -535,7 +535,7 @@ const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = .callback = AnimSwallowBlueOrb, }; -const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = +static const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -553,26 +553,26 @@ const s8 gMorningSunLightBeamCoordsTable[] = 0x00, }; -const union AnimCmd gGreenStarAnimCmds1[] = +static const union AnimCmd gGreenStarAnimCmds1[] = { ANIMCMD_FRAME(0, 6), ANIMCMD_FRAME(4, 6), ANIMCMD_JUMP(0), }; -const union AnimCmd gGreenStarAnimCmds2[] = +static const union AnimCmd gGreenStarAnimCmds2[] = { ANIMCMD_FRAME(8, 6), ANIMCMD_END, }; -const union AnimCmd gGreenStarAnimCmds3[] = +static const union AnimCmd gGreenStarAnimCmds3[] = { ANIMCMD_FRAME(12, 6), ANIMCMD_END, }; -const union AnimCmd *const gGreenStarAnimTable[] = +static const union AnimCmd *const gGreenStarAnimTable[] = { gGreenStarAnimCmds1, gGreenStarAnimCmds2, @@ -607,7 +607,7 @@ const u8 gDoomDesireLightBeamDelayTable[] = 50, }; -const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = +static const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, -15, 0, 7), AFFINEANIMCMD_FRAME(0, 15, 0, 7), @@ -626,7 +626,7 @@ const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = .callback = AnimWeakFrustrationAngerMark, }; -const union AnimCmd gSweetScentPetalAnimCmds1[] = +static const union AnimCmd gSweetScentPetalAnimCmds1[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(1, 8), @@ -639,7 +639,7 @@ const union AnimCmd gSweetScentPetalAnimCmds1[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gSweetScentPetalAnimCmds2[] = +static const union AnimCmd gSweetScentPetalAnimCmds2[] = { ANIMCMD_FRAME(0, 8, .hFlip = TRUE), ANIMCMD_FRAME(1, 8, .hFlip = TRUE), @@ -652,13 +652,13 @@ const union AnimCmd gSweetScentPetalAnimCmds2[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gSweetScentPetalAnimCmds3[] = +static const union AnimCmd gSweetScentPetalAnimCmds3[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = +static const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = { gSweetScentPetalAnimCmds1, gSweetScentPetalAnimCmds2, @@ -676,9 +676,9 @@ const struct SpriteTemplate gSweetScentPetalSpriteTemplate = .callback = AnimSweetScentPetal, }; -const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/battle_anims/unk_83FF33C.gbapal"); //Unused +static const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/battle_anims/unk_83FF33C.gbapal"); //Unused -const union AnimCmd gPainSplitAnimCmds[] = +static const union AnimCmd gPainSplitAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 9), @@ -686,7 +686,7 @@ const union AnimCmd gPainSplitAnimCmds[] = ANIMCMD_END, }; -const union AnimCmd *const gPainSplitAnimCmdTable[] = +static const union AnimCmd *const gPainSplitAnimCmdTable[] = { gPainSplitAnimCmds, }; @@ -735,7 +735,7 @@ const struct SpriteTemplate gReversalOrbSpriteTemplate = .callback = AnimReversalOrb, }; -const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = +static const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 0, 0, 4), AFFINEANIMCMD_FRAME(0, -3, 0, 16), @@ -745,7 +745,7 @@ const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = +static const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-8, -8, 0, 8), @@ -753,7 +753,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = +static const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -761,7 +761,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = +static const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -769,7 +769,7 @@ const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = +static const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = { gYawnCloudAffineAnimCmds1, gYawnCloudAffineAnimCmds2, @@ -787,7 +787,7 @@ const struct SpriteTemplate gYawnCloudSpriteTemplate = .callback = AnimYawnCloud, }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = +static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-4, -6, 0, 16), @@ -795,7 +795,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = +static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -803,7 +803,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = +static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -811,7 +811,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = +static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 10, 0, 30), @@ -819,7 +819,7 @@ const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = +static const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = { gSmokeBallEscapeCloudAffineAnimCmds1, gSmokeBallEscapeCloudAffineAnimCmds2, @@ -838,7 +838,7 @@ const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = .callback = AnimSmokeBallEscapeCloud, }; -const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = +static const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-16, 16, 0, 6), AFFINEANIMCMD_FRAME(16, -16, 0, 12), @@ -885,21 +885,21 @@ const u16 gFacadeBlendColors[] = RGB(29, 27, 0), }; -const union AnimCmd gRoarNoiseLineAnimCmds1[] = +static const union AnimCmd gRoarNoiseLineAnimCmds1[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd gRoarNoiseLineAnimCmds2[] = +static const union AnimCmd gRoarNoiseLineAnimCmds2[] = { ANIMCMD_FRAME(32, 3), ANIMCMD_FRAME(48, 3), ANIMCMD_JUMP(0), }; -const union AnimCmd *const gRoarNoiseLineAnimTable[] = +static const union AnimCmd *const gRoarNoiseLineAnimTable[] = { gRoarNoiseLineAnimCmds1, gRoarNoiseLineAnimCmds2, @@ -938,20 +938,20 @@ const struct SpriteTemplate gAssistPawprintSpriteTemplate = .callback = AnimAssistPawprint, }; -const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = +static const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = +static const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 24), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = +static const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = { gBarrageBallAffineAnimCmds1, gBarrageBallAffineAnimCmds2, @@ -979,7 +979,7 @@ const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = .callback = AnimSmellingSaltsHand, }; -const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = +static const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, -16, 0, 6), AFFINEANIMCMD_FRAME(0, 16, 0, 6), @@ -1063,33 +1063,33 @@ const struct SpriteTemplate gUnknown_83FF704 = .callback = sub_80E3E84, }; -const union AnimCmd gKnockOffStrikeAnimCmds[] = +static const union AnimCmd gKnockOffStrikeAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(64, 4), ANIMCMD_END, }; -const union AnimCmd *const gKnockOffStrikeAnimTable[] = +static const union AnimCmd *const gKnockOffStrikeAnimTable[] = { gKnockOffStrikeAnimCmds, }; -const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = +static const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -4, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = +static const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 8), AFFINEANIMCMD_END, }; -const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = +static const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = { gKnockOffStrikeAffineanimCmds1, gKnockOffStrikeAffineanimCmds2, @@ -1106,13 +1106,13 @@ const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = .callback = AnimKnockOffStrike, }; -const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = +static const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 64), AFFINEANIMCMD_JUMP(0), }; -const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = +static const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = { gRecycleSpriteAffineAnimCmds, }; @@ -1128,7 +1128,7 @@ const struct SpriteTemplate gRecycleSpriteTemplate = .callback = AnimRecycle, }; -const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = +static const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 16, 0, 4), AFFINEANIMCMD_FRAME(-2, 0, 0, 8), diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 1c9d6fe9b..44a7928d8 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -158,7 +158,7 @@ const struct CompressedSpritePalette gBallParticlePalettes[] = {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_PREMIERBALL}, }; -const union AnimCmd gAnim_RegularBall[] = +static const union AnimCmd gAnim_RegularBall[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_FRAME(1, 1), @@ -169,38 +169,38 @@ const union AnimCmd gAnim_RegularBall[] = ANIMCMD_JUMP(0), }; -const union AnimCmd gAnim_MasterBall[] = +static const union AnimCmd gAnim_MasterBall[] = { ANIMCMD_FRAME(3, 1), ANIMCMD_END, }; -const union AnimCmd gAnim_NetDiveBall[] = +static const union AnimCmd gAnim_NetDiveBall[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -const union AnimCmd gAnim_NestBall[] = +static const union AnimCmd gAnim_NestBall[] = { ANIMCMD_FRAME(5, 1), ANIMCMD_END, }; -const union AnimCmd gAnim_LuxuryPremierBall[] = +static const union AnimCmd gAnim_LuxuryPremierBall[] = { ANIMCMD_FRAME(6, 4), ANIMCMD_FRAME(7, 4), ANIMCMD_JUMP(0), }; -const union AnimCmd gAnim_UltraRepeatTimerBall[] = +static const union AnimCmd gAnim_UltraRepeatTimerBall[] = { ANIMCMD_FRAME(7, 4), ANIMCMD_END, }; -const union AnimCmd *const gAnims_BallParticles[] = +static const union AnimCmd *const gAnims_BallParticles[] = { gAnim_RegularBall, gAnim_MasterBall, @@ -391,13 +391,13 @@ const struct SpriteTemplate gPokeblockSpriteTemplate = .callback = sub_80F1B3C, }; -const union AnimCmd gUnknown_840C204[] = +static const union AnimCmd gUnknown_840C204[] = { ANIMCMD_FRAME(64, 1), ANIMCMD_END, }; -const union AnimCmd *const gSpriteAnimTable_840C20C[] = +static const union AnimCmd *const gSpriteAnimTable_840C20C[] = { gUnknown_840C204, }; @@ -2216,7 +2216,7 @@ void AnimTask_LoadPokeblockGfx(u8 taskId) LoadCompressedSpriteSheetUsingHeap(&gBattleAnimPicTable[ANIM_TAG_POKEBLOCK - ANIM_SPRITES_START]); LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[ANIM_TAG_POKEBLOCK - ANIM_SPRITES_START]); - paletteIndex = IndexOfSpritePaletteTag(ANIM_TAG_POKEBLOCK); // unused + paletteIndex = IndexOfSpritePaletteTag(ANIM_TAG_POKEBLOCK); DestroyAnimVisualTask(taskId); } diff --git a/src/battle_anim_utility_funcs.c b/src/battle_anim_utility_funcs.c index d9a6754c7..df4a8243b 100644 --- a/src/battle_anim_utility_funcs.c +++ b/src/battle_anim_utility_funcs.c @@ -496,9 +496,9 @@ static void sub_80BB2A0(u8 taskId) gTasks[taskId].data[7] = gBattlerSpriteIds[sAnimStatsChangeData->battler2]; gTasks[taskId].func = sub_80BB4B8; if (sAnimStatsChangeData->data[0] == 0) - PlaySE12WithPanning(SE_W287, BattleAnimAdjustPanning2(PAN_SIDE_PLAYER)); + PlaySE12WithPanning(SE_W287, BattleAnimAdjustPanning2(SOUND_PAN_ATTACKER)); else - PlaySE12WithPanning(SE_W287B, BattleAnimAdjustPanning2(PAN_SIDE_PLAYER)); + PlaySE12WithPanning(SE_W287B, BattleAnimAdjustPanning2(SOUND_PAN_ATTACKER)); } static void sub_80BB4B8(u8 taskId) diff --git a/src/rock.c b/src/rock.c index b0809fade..082f3b655 100644 --- a/src/rock.c +++ b/src/rock.c @@ -583,8 +583,8 @@ void sub_80B4BD0(u8 taskId) task->data[5] = ((var3 - var1) * 8) / task->data[8]; task->data[6] = 0; task->data[7] = 0; - pan1 = BattleAnimAdjustPanning(PAN_SIDE_PLAYER); - pan2 = BattleAnimAdjustPanning(PAN_SIDE_OPPONENT); + pan1 = BattleAnimAdjustPanning(SOUND_PAN_ATTACKER); + pan2 = BattleAnimAdjustPanning(SOUND_PAN_TARGET); task->data[13] = pan1; task->data[14] = (pan2 - pan1) / task->data[8]; task->data[1] = var4; -- cgit v1.2.3 From 88fae7ed40e47eff562b70cd0a504aeed5bb7102 Mon Sep 17 00:00:00 2001 From: Evan Date: Sat, 7 Dec 2019 18:09:22 -0700 Subject: fix static var names --- src/battle_anim.c | 44 +-- src/battle_anim_effects_1.c | 772 ++++++++++++++++++++------------------- src/battle_anim_effects_2.c | 348 +++++++++--------- src/battle_anim_effects_3.c | 306 ++++++++-------- src/battle_anim_special.c | 130 +++---- src/battle_anim_status_effects.c | 80 ++-- 6 files changed, 841 insertions(+), 839 deletions(-) (limited to 'src') diff --git a/src/battle_anim.c b/src/battle_anim.c index dbaffa31b..0cb88219a 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -24,7 +24,7 @@ EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL; EWRAM_DATA static const u8 *sBattleAnimScriptRetAddr = NULL; EWRAM_DATA void (*gAnimScriptCallback)(void) = NULL; -EWRAM_DATA static s8 gAnimFramesToWait = 0; +EWRAM_DATA static s8 sAnimFramesToWait = 0; EWRAM_DATA bool8 gAnimScriptActive = FALSE; EWRAM_DATA u8 gAnimVisualTaskCount = 0; EWRAM_DATA u8 gAnimSoundTaskCount = 0; @@ -1792,7 +1792,7 @@ void ClearBattleAnimationVars(void) { s32 i; - gAnimFramesToWait = 0; + sAnimFramesToWait = 0; gAnimScriptActive = FALSE; gAnimVisualTaskCount = 0; gAnimSoundTaskCount = 0; @@ -1852,7 +1852,7 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo sMonAnimTaskIdArray[1] = (s8)-1; sBattleAnimScriptPtr = animsTable[tableId]; gAnimScriptActive = TRUE; - gAnimFramesToWait = 0; + sAnimFramesToWait = 0; gAnimScriptCallback = RunAnimScriptCommand; for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++) @@ -1925,14 +1925,14 @@ static void ClearSpriteIndex(u16 index) static void WaitAnimFrameCount(void) { - if (gAnimFramesToWait <= 0) + if (sAnimFramesToWait <= 0) { gAnimScriptCallback = RunAnimScriptCommand; - gAnimFramesToWait = 0; + sAnimFramesToWait = 0; } else { - gAnimFramesToWait--; + sAnimFramesToWait--; } } @@ -1941,7 +1941,7 @@ static void RunAnimScriptCommand(void) do { sScriptCmdTable[sBattleAnimScriptPtr[0]](); - } while (gAnimFramesToWait == 0 && gAnimScriptActive); + } while (sAnimFramesToWait == 0 && gAnimScriptActive); } static void ScriptCmd_loadspritegfx(void) @@ -1954,7 +1954,7 @@ static void ScriptCmd_loadspritegfx(void) LoadCompressedSpritePaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(index)]); sBattleAnimScriptPtr += 2; AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); - gAnimFramesToWait = 1; + sAnimFramesToWait = 1; gAnimScriptCallback = WaitAnimFrameCount; } @@ -2057,9 +2057,9 @@ static void ScriptCmd_createvisualtask(void) static void ScriptCmd_delay(void) { sBattleAnimScriptPtr++; - gAnimFramesToWait = sBattleAnimScriptPtr[0]; - if (gAnimFramesToWait == 0) - gAnimFramesToWait = -1; + sAnimFramesToWait = sBattleAnimScriptPtr[0]; + if (sAnimFramesToWait == 0) + sAnimFramesToWait = -1; sBattleAnimScriptPtr++; gAnimScriptCallback = WaitAnimFrameCount; } @@ -2069,11 +2069,11 @@ static void ScriptCmd_waitforvisualfinish(void) if (gAnimVisualTaskCount == 0) { sBattleAnimScriptPtr++; - gAnimFramesToWait = 0; + sAnimFramesToWait = 0; } else { - gAnimFramesToWait = 1; + sAnimFramesToWait = 1; } } @@ -2095,7 +2095,7 @@ static void ScriptCmd_end(void) || sMonAnimTaskIdArray[0] != 0xFF || sMonAnimTaskIdArray[1] != 0xFF) { sSoundAnimFramesToWait = 0; - gAnimFramesToWait = 1; + sAnimFramesToWait = 1; return; } @@ -2104,7 +2104,7 @@ static void ScriptCmd_end(void) { if (++sSoundAnimFramesToWait <= 90) // Wait 90 frames, then halt the sound effect. { - gAnimFramesToWait = 1; + sAnimFramesToWait = 1; return; } else @@ -2760,11 +2760,11 @@ static void ScriptCmd_waitbgfadeout(void) if (sAnimBackgroundFadeState == 2) { sBattleAnimScriptPtr++; - gAnimFramesToWait = 0; + sAnimFramesToWait = 0; } else { - gAnimFramesToWait = 1; + sAnimFramesToWait = 1; } } @@ -2773,11 +2773,11 @@ static void ScriptCmd_waitbgfadein(void) if (sAnimBackgroundFadeState == 0) { sBattleAnimScriptPtr++; - gAnimFramesToWait = 0; + sAnimFramesToWait = 0; } else { - gAnimFramesToWait = 1; + sAnimFramesToWait = 1; } } @@ -3159,7 +3159,7 @@ static void ScriptCmd_waitsound(void) if (gAnimSoundTaskCount != 0) { sSoundAnimFramesToWait = 0; - gAnimFramesToWait = 1; + sAnimFramesToWait = 1; } else if (IsSEPlaying()) { @@ -3171,14 +3171,14 @@ static void ScriptCmd_waitsound(void) } else { - gAnimFramesToWait = 1; + sAnimFramesToWait = 1; } } else { sSoundAnimFramesToWait = 0; sBattleAnimScriptPtr++; - gAnimFramesToWait = 0; + sAnimFramesToWait = 0; } } diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index da9998c2f..647d2f367 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -16,7 +16,7 @@ #include "constants/songs.h" // RAM -static EWRAM_DATA s16 gUnknown_203999C[4] = {0}; +EWRAM_DATA static s16 gUnknown_203999C[4] = {0}; // Function Declarations static void AnimMovePowderParticleStep(struct Sprite *); @@ -91,9 +91,10 @@ static void AnimFollowMeFingerStep2(struct Sprite *); static void AnimTauntFingerStep1(struct Sprite *); static void AnimTauntFingerStep2(struct Sprite *); -static const u8 gUnknown_83E2964[] = {0x02, 0x04, 0x01, 0x03}; +// Unused +static const u8 sUnknown_83E2964[] = {0x02, 0x04, 0x01, 0x03}; -static const union AnimCmd gPowderParticlesAnimCmds[] = +static const union AnimCmd sPowderParticlesAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(2, 5), @@ -106,9 +107,9 @@ static const union AnimCmd gPowderParticlesAnimCmds[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gPowderParticlesAnimTable[] = +static const union AnimCmd *const sPowderParticlesAnimTable[] = { - gPowderParticlesAnimCmds, + sPowderParticlesAnimCmds, }; const struct SpriteTemplate gSleepPowderParticleSpriteTemplate = @@ -116,7 +117,7 @@ const struct SpriteTemplate gSleepPowderParticleSpriteTemplate = .tileTag = ANIM_TAG_SLEEP_POWDER, .paletteTag = ANIM_TAG_SLEEP_POWDER, .oam = &gOamData_AffineOff_ObjNormal_8x16, - .anims = gPowderParticlesAnimTable, + .anims = sPowderParticlesAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimMovePowderParticle, @@ -127,7 +128,7 @@ const struct SpriteTemplate gStunSporeParticleSpriteTemplate = .tileTag = ANIM_TAG_STUN_SPORE, .paletteTag = ANIM_TAG_STUN_SPORE, .oam = &gOamData_AffineOff_ObjNormal_8x16, - .anims = gPowderParticlesAnimTable, + .anims = sPowderParticlesAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimMovePowderParticle, @@ -138,96 +139,96 @@ const struct SpriteTemplate gPoisonPowderParticleSpriteTemplate = .tileTag = ANIM_TAG_POISON_POWDER, .paletteTag = ANIM_TAG_POISON_POWDER, .oam = &gOamData_AffineOff_ObjNormal_8x16, - .anims = gPowderParticlesAnimTable, + .anims = sPowderParticlesAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimMovePowderParticle, }; -static const union AnimCmd gSolarbeamBigOrbAnimCmds1[] = +static const union AnimCmd sSolarbeamBigOrbAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -static const union AnimCmd gSolarbeamBigOrbAnimCmds2[] = +static const union AnimCmd sSolarbeamBigOrbAnimCmds2[] = { ANIMCMD_FRAME(1, 1), ANIMCMD_END, }; -static const union AnimCmd gSolarbeamBigOrbAnimCmds3[] = +static const union AnimCmd sSolarbeamBigOrbAnimCmds3[] = { ANIMCMD_FRAME(2, 1), ANIMCMD_END, }; -static const union AnimCmd gSolarbeamBigOrbAnimCmds4[] = +static const union AnimCmd sSolarbeamBigOrbAnimCmds4[] = { ANIMCMD_FRAME(3, 1), ANIMCMD_END, }; -static const union AnimCmd gSolarbeamBigOrbAnimCmds5[] = +static const union AnimCmd sSolarbeamBigOrbAnimCmds5[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -static const union AnimCmd gSolarbeamBigOrbAnimCmds6[] = +static const union AnimCmd sSolarbeamBigOrbAnimCmds6[] = { ANIMCMD_FRAME(5, 1), ANIMCMD_END, }; -static const union AnimCmd gSolarbeamBigOrbAnimCmds7[] = +static const union AnimCmd sSolarbeamBigOrbAnimCmds7[] = { ANIMCMD_FRAME(6, 1), ANIMCMD_END, }; -static const union AnimCmd gSolarbeamSmallOrbAnimCms[] = +static const union AnimCmd sSolarbeamSmallOrbAnimCms[] = { ANIMCMD_FRAME(7, 1), ANIMCMD_END, }; -static const union AnimCmd gPowerAbsorptionOrbAnimCmds[] = +static const union AnimCmd sPowerAbsorptionOrbAnimCmds[] = { ANIMCMD_FRAME(8, 1), ANIMCMD_END, }; -static const union AnimCmd *const gSolarbeamBigOrbAnimTable[] = +static const union AnimCmd *const sSolarbeamBigOrbAnimTable[] = { - gSolarbeamBigOrbAnimCmds1, - gSolarbeamBigOrbAnimCmds2, - gSolarbeamBigOrbAnimCmds3, - gSolarbeamBigOrbAnimCmds4, - gSolarbeamBigOrbAnimCmds5, - gSolarbeamBigOrbAnimCmds6, - gSolarbeamBigOrbAnimCmds7, + sSolarbeamBigOrbAnimCmds1, + sSolarbeamBigOrbAnimCmds2, + sSolarbeamBigOrbAnimCmds3, + sSolarbeamBigOrbAnimCmds4, + sSolarbeamBigOrbAnimCmds5, + sSolarbeamBigOrbAnimCmds6, + sSolarbeamBigOrbAnimCmds7, }; -static const union AnimCmd *const gSolarbeamSmallOrbAnimTable[] = +static const union AnimCmd *const sSolarbeamSmallOrbAnimTable[] = { - gSolarbeamSmallOrbAnimCms, + sSolarbeamSmallOrbAnimCms, }; -static const union AnimCmd *const gPowerAbsorptionOrbAnimTable[] = +static const union AnimCmd *const sPowerAbsorptionOrbAnimTable[] = { - gPowerAbsorptionOrbAnimCmds, + sPowerAbsorptionOrbAnimCmds, }; -static const union AffineAnimCmd gPowerAbsorptionOrbAffineAnimCmds[] = +static const union AffineAnimCmd sPowerAbsorptionOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-5, -5, 0, 1), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gPowerAbsorptionOrbAffineAnimTable[] = +static const union AffineAnimCmd *const sPowerAbsorptionOrbAffineAnimTable[] = { - gPowerAbsorptionOrbAffineAnimCmds, + sPowerAbsorptionOrbAffineAnimCmds, }; const struct SpriteTemplate gPowerAbsorptionOrbSpriteTemplate = @@ -235,9 +236,9 @@ const struct SpriteTemplate gPowerAbsorptionOrbSpriteTemplate = .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, .oam = &gOamData_AffineNormal_ObjBlend_16x16, - .anims = gPowerAbsorptionOrbAnimTable, + .anims = sPowerAbsorptionOrbAnimTable, .images = NULL, - .affineAnims = gPowerAbsorptionOrbAffineAnimTable, + .affineAnims = sPowerAbsorptionOrbAffineAnimTable, .callback = AnimPowerAbsorptionOrb, }; @@ -246,7 +247,7 @@ const struct SpriteTemplate gSolarbeamBigOrbSpriteTemplate = .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gSolarbeamBigOrbAnimTable, + .anims = sSolarbeamBigOrbAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSolarbeamBigOrb, @@ -257,22 +258,22 @@ const struct SpriteTemplate gSolarbeamSmallOrbSpriteTemplate = .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gSolarbeamSmallOrbAnimTable, + .anims = sSolarbeamSmallOrbAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSolarbeamSmallOrb, }; -static const union AffineAnimCmd gStockpileAbsorptionOrbAffineCmds[] = +static const union AffineAnimCmd sStockpileAbsorptionOrbAffineCmds[] = { AFFINEANIMCMD_FRAME(320, 320, 0, 0), AFFINEANIMCMD_FRAME(-14, -14, 0, 1), AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd *const gStockpileAbsorptionOrbAffineAnimTable[] = +static const union AffineAnimCmd *const sStockpileAbsorptionOrbAffineAnimTable[] = { - gStockpileAbsorptionOrbAffineCmds, + sStockpileAbsorptionOrbAffineCmds, }; const struct SpriteTemplate gStockpileAbsorptionOrbSpriteTemplate = @@ -282,19 +283,19 @@ const struct SpriteTemplate gStockpileAbsorptionOrbSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gStockpileAbsorptionOrbAffineAnimTable, + .affineAnims = sStockpileAbsorptionOrbAffineAnimTable, .callback = AnimPowerAbsorptionOrb, }; -static const union AffineAnimCmd gAbsorptionOrbAffineAnimCmds[] = +static const union AffineAnimCmd sAbsorptionOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-5, -5, 0, 1), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gAbsorptionOrbAffineAnimTable[] = +static const union AffineAnimCmd *const sAbsorptionOrbAffineAnimTable[] = { - gAbsorptionOrbAffineAnimCmds, + sAbsorptionOrbAffineAnimCmds, }; const struct SpriteTemplate gAbsorptionOrbSpriteTemplate = @@ -302,9 +303,9 @@ const struct SpriteTemplate gAbsorptionOrbSpriteTemplate = .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, .oam = &gOamData_AffineNormal_ObjBlend_16x16, - .anims = gPowerAbsorptionOrbAnimTable, + .anims = sPowerAbsorptionOrbAnimTable, .images = NULL, - .affineAnims = gAbsorptionOrbAffineAnimTable, + .affineAnims = sAbsorptionOrbAffineAnimTable, .callback = AnimAbsorptionOrb, }; @@ -313,29 +314,29 @@ const struct SpriteTemplate gHyperBeamOrbSpriteTemplate = .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gSolarbeamBigOrbAnimTable, + .anims = sSolarbeamBigOrbAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimHyperBeamOrb, }; -static const union AnimCmd gLeechSeedAnimCmds1[] = +static const union AnimCmd sLeechSeedAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -static const union AnimCmd gLeechSeedAnimCmds2[] = +static const union AnimCmd sLeechSeedAnimCmds2[] = { ANIMCMD_FRAME(4, 7), ANIMCMD_FRAME(8, 7), ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gLeechSeedAnimTable[] = +static const union AnimCmd *const sLeechSeedAnimTable[] = { - gLeechSeedAnimCmds1, - gLeechSeedAnimCmds2, + sLeechSeedAnimCmds1, + sLeechSeedAnimCmds2, }; const struct SpriteTemplate gLeechSeedSpriteTemplate = @@ -343,28 +344,28 @@ const struct SpriteTemplate gLeechSeedSpriteTemplate = .tileTag = ANIM_TAG_SEED, .paletteTag = ANIM_TAG_SEED, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gLeechSeedAnimTable, + .anims = sLeechSeedAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimLeechSeed, }; -static const union AnimCmd gSporeParticleAnimCmds1[] = +static const union AnimCmd sSporeParticleAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -static const union AnimCmd gSporeParticleAnimCmds2[] = +static const union AnimCmd sSporeParticleAnimCmds2[] = { ANIMCMD_FRAME(4, 7), ANIMCMD_END, }; -static const union AnimCmd *const gSporeParticleAnimTable[] = +static const union AnimCmd *const sSporeParticleAnimTable[] = { - gSporeParticleAnimCmds1, - gSporeParticleAnimCmds2, + sSporeParticleAnimCmds1, + sSporeParticleAnimCmds2, }; const struct SpriteTemplate gSporeParticleSpriteTemplate = @@ -372,32 +373,32 @@ const struct SpriteTemplate gSporeParticleSpriteTemplate = .tileTag = ANIM_TAG_SPORE, .paletteTag = ANIM_TAG_SPORE, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gSporeParticleAnimTable, + .anims = sSporeParticleAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSporeParticle, }; -static const union AnimCmd gPetalDanceBigFlowerAnimCmds[] = +static const union AnimCmd sPetalDanceBigFlowerAnimCmds[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -static const union AnimCmd gPetalDanceSmallFlowerAnimCmds[] = +static const union AnimCmd sPetalDanceSmallFlowerAnimCmds[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -static const union AnimCmd *const gPetalDanceBigFlowerAnimTable[] = +static const union AnimCmd *const sPetalDanceBigFlowerAnimTable[] = { - gPetalDanceBigFlowerAnimCmds, + sPetalDanceBigFlowerAnimCmds, }; -static const union AnimCmd *const gPetalDanceSmallFlowerAnimTable[] = +static const union AnimCmd *const sPetalDanceSmallFlowerAnimTable[] = { - gPetalDanceSmallFlowerAnimCmds, + sPetalDanceSmallFlowerAnimCmds, }; const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = @@ -405,7 +406,7 @@ const struct SpriteTemplate gPetalDanceBigFlowerSpriteTemplate = .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gPetalDanceBigFlowerAnimTable, + .anims = sPetalDanceBigFlowerAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimPetalDanceBigFlower, @@ -416,13 +417,13 @@ const struct SpriteTemplate gPetalDanceSmallFlowerSpriteTemplate = .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gPetalDanceSmallFlowerAnimTable, + .anims = sPetalDanceSmallFlowerAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimPetalDanceSmallFlower, }; -static const union AnimCmd gRazorLeafParticleAnimCmds1[] = +static const union AnimCmd sRazorLeafParticleAnimCmds1[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 5), @@ -437,7 +438,7 @@ static const union AnimCmd gRazorLeafParticleAnimCmds1[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd gRazorLeafParticleAnimCmds2[] = +static const union AnimCmd sRazorLeafParticleAnimCmds2[] = { ANIMCMD_FRAME(24, 5), ANIMCMD_FRAME(28, 5), @@ -445,10 +446,10 @@ static const union AnimCmd gRazorLeafParticleAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd *const gRazorLeafParticleAnimTable[] = +static const union AnimCmd *const sRazorLeafParticleAnimTable[] = { - gRazorLeafParticleAnimCmds1, - gRazorLeafParticleAnimCmds2, + sRazorLeafParticleAnimCmds1, + sRazorLeafParticleAnimCmds2, }; const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = @@ -456,7 +457,7 @@ const struct SpriteTemplate gRazorLeafParticleSpriteTemplate = .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gRazorLeafParticleAnimTable, + .anims = sRazorLeafParticleAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimRazorLeafParticle, @@ -467,13 +468,13 @@ const struct SpriteTemplate gTwisterLeafParticleSpriteTemplate = .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gRazorLeafParticleAnimTable, + .anims = sRazorLeafParticleAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimMoveTwisterParticle, }; -static const union AnimCmd gRazorLeafCutterAnimCmds[] = +static const union AnimCmd sRazorLeafCutterAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(0, 3, .hFlip = TRUE), @@ -482,9 +483,9 @@ static const union AnimCmd gRazorLeafCutterAnimCmds[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gRazorLeafCutterAnimTable[] = +static const union AnimCmd *const sRazorLeafCutterAnimTable[] = { - gRazorLeafCutterAnimCmds, + sRazorLeafCutterAnimCmds, }; const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = @@ -492,21 +493,21 @@ const struct SpriteTemplate gRazorLeafCutterSpriteTemplate = .tileTag = ANIM_TAG_RAZOR_LEAF, .paletteTag = ANIM_TAG_RAZOR_LEAF, .oam = &gOamData_AffineOff_ObjNormal_32x16, - .anims = gRazorLeafCutterAnimTable, + .anims = sRazorLeafCutterAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimTranslateLinearSingleSineWave, }; -static const union AffineAnimCmd gSwiftStarAffineAnimCmds[] = +static const union AffineAnimCmd sSwiftStarAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 1), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gSwiftStarAffineAnimTable[] = +static const union AffineAnimCmd *const sSwiftStarAffineAnimTable[] = { - gSwiftStarAffineAnimCmds, + sSwiftStarAffineAnimCmds, }; const struct SpriteTemplate gSwiftStarSpriteTemplate = @@ -516,11 +517,11 @@ const struct SpriteTemplate gSwiftStarSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSwiftStarAffineAnimTable, + .affineAnims = sSwiftStarAffineAnimTable, .callback = AnimTranslateLinearSingleSineWave, }; -static const union AnimCmd gConstrictBindingAnimCmds1[] = +static const union AnimCmd sConstrictBindingAnimCmds1[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(32, 4), @@ -529,7 +530,7 @@ static const union AnimCmd gConstrictBindingAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gConstrictBindingAnimCmds2[] = +static const union AnimCmd sConstrictBindingAnimCmds2[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(32, 4, .hFlip = TRUE), @@ -538,13 +539,13 @@ static const union AnimCmd gConstrictBindingAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd *const gConstrictBindingAnimTable[] = +static const union AnimCmd *const sConstrictBindingAnimTable[] = { - gConstrictBindingAnimCmds1, - gConstrictBindingAnimCmds2, + sConstrictBindingAnimCmds1, + sConstrictBindingAnimCmds2, }; -static const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = +static const union AffineAnimCmd sConstrictBindingAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(-11, 0, 0, 6), @@ -552,7 +553,7 @@ static const union AffineAnimCmd gConstrictBindingAffineAnimCmds1[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = +static const union AffineAnimCmd sConstrictBindingAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(11, 0, 0, 6), @@ -560,10 +561,10 @@ static const union AffineAnimCmd gConstrictBindingAffineAnimCmds2[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gConstrictBindingAffineAnimTable[] = +static const union AffineAnimCmd *const sConstrictBindingAffineAnimTable[] = { - gConstrictBindingAffineAnimCmds1, - gConstrictBindingAffineAnimCmds2, + sConstrictBindingAffineAnimCmds1, + sConstrictBindingAffineAnimCmds2, }; const struct SpriteTemplate gConstrictBindingSpriteTemplate = @@ -571,29 +572,29 @@ const struct SpriteTemplate gConstrictBindingSpriteTemplate = .tileTag = ANIM_TAG_TENDRILS, .paletteTag = ANIM_TAG_TENDRILS, .oam = &gOamData_AffineNormal_ObjNormal_64x32, - .anims = gConstrictBindingAnimTable, + .anims = sConstrictBindingAnimTable, .images = NULL, - .affineAnims = gConstrictBindingAffineAnimTable, + .affineAnims = sConstrictBindingAffineAnimTable, .callback = AnimConstrictBinding, }; -static const union AffineAnimCmd gMimicOrbAffineAnimCmds1[] = +static const union AffineAnimCmd sMimicOrbAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 0), AFFINEANIMCMD_FRAME(48, 48, 0, 14), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gMimicOrbAffineAnimCmds2[] = +static const union AffineAnimCmd sMimicOrbAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(-16, -16, 0, 1), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gMimicOrbAffineAnimTable[] = +static const union AffineAnimCmd *const sMimicOrbAffineAnimTable[] = { - gMimicOrbAffineAnimCmds1, - gMimicOrbAffineAnimCmds2, + sMimicOrbAffineAnimCmds1, + sMimicOrbAffineAnimCmds2, }; const struct SpriteTemplate gMimicOrbSpriteTemplate = @@ -601,13 +602,13 @@ const struct SpriteTemplate gMimicOrbSpriteTemplate = .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, .oam = &gOamData_AffineDouble_ObjNormal_16x16, - .anims = gPowerAbsorptionOrbAnimTable, + .anims = sPowerAbsorptionOrbAnimTable, .images = NULL, - .affineAnims = gMimicOrbAffineAnimTable, + .affineAnims = sMimicOrbAffineAnimTable, .callback = AnimMimicOrb, }; -static const union AnimCmd gIngrainRootAnimCmds1[] = +static const union AnimCmd sIngrainRootAnimCmds1[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -616,7 +617,7 @@ static const union AnimCmd gIngrainRootAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gIngrainRootAnimCmds2[] = +static const union AnimCmd sIngrainRootAnimCmds2[] = { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -625,7 +626,7 @@ static const union AnimCmd gIngrainRootAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd gIngrainRootAnimCmds3[] = +static const union AnimCmd sIngrainRootAnimCmds3[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -633,7 +634,7 @@ static const union AnimCmd gIngrainRootAnimCmds3[] = ANIMCMD_END, }; -static const union AnimCmd gIngrainRootAnimCmds4[] = +static const union AnimCmd sIngrainRootAnimCmds4[] = { ANIMCMD_FRAME(0, 7, .hFlip = TRUE), ANIMCMD_FRAME(16, 7, .hFlip = TRUE), @@ -641,12 +642,12 @@ static const union AnimCmd gIngrainRootAnimCmds4[] = ANIMCMD_END, }; -static const union AnimCmd *const gIngrainRootAnimTable[] = +static const union AnimCmd *const sIngrainRootAnimTable[] = { - gIngrainRootAnimCmds1, - gIngrainRootAnimCmds2, - gIngrainRootAnimCmds3, - gIngrainRootAnimCmds4, + sIngrainRootAnimCmds1, + sIngrainRootAnimCmds2, + sIngrainRootAnimCmds3, + sIngrainRootAnimCmds4, }; const struct SpriteTemplate gIngrainRootSpriteTemplate = @@ -654,7 +655,7 @@ const struct SpriteTemplate gIngrainRootSpriteTemplate = .tileTag = ANIM_TAG_ROOTS, .paletteTag = ANIM_TAG_ROOTS, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gIngrainRootAnimTable, + .anims = sIngrainRootAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimIngrainRoot, @@ -665,22 +666,22 @@ const struct SpriteTemplate gFrenzyPlantRootSpriteTemplate = .tileTag = ANIM_TAG_ROOTS, .paletteTag = ANIM_TAG_ROOTS, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gIngrainRootAnimTable, + .anims = sIngrainRootAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimFrenzyPlantRoot, }; -static const union AnimCmd gIngrainOrbAnimCmds[] = +static const union AnimCmd sIngrainOrbAnimCmds[] = { ANIMCMD_FRAME(3, 3), ANIMCMD_FRAME(0, 5), ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gIngrainOrbAnimTable[] = +static const union AnimCmd *const sIngrainOrbAnimTable[] = { - gIngrainOrbAnimCmds, + sIngrainOrbAnimCmds, }; const struct SpriteTemplate gIngrainOrbSpriteTemplate = @@ -688,24 +689,24 @@ const struct SpriteTemplate gIngrainOrbSpriteTemplate = .tileTag = ANIM_TAG_ORBS, .paletteTag = ANIM_TAG_ORBS, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gIngrainOrbAnimTable, + .anims = sIngrainOrbAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimIngrainOrb, }; -static const union AnimCmd gFallingBagAnimCmds[] = +static const union AnimCmd sFallingBagAnimCmds[] = { ANIMCMD_FRAME(0, 30), ANIMCMD_END, }; -static const union AnimCmd *const gFallingBagAnimTable[] = +static const union AnimCmd *const sFallingBagAnimTable[] = { - gFallingBagAnimCmds, + sFallingBagAnimCmds, }; -static const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = +static const union AffineAnimCmd sFallingBagAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 10), AFFINEANIMCMD_FRAME(0, 0, 4, 20), @@ -713,7 +714,7 @@ static const union AffineAnimCmd gFallingBagAffineAnimCmds1[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = +static const union AffineAnimCmd sFallingBagAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0, 0, -1, 2), AFFINEANIMCMD_FRAME(0, 0, 1, 4), @@ -724,10 +725,10 @@ static const union AffineAnimCmd gFallingBagAffineAnimCmds2[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gFallingBagAffineAnimTable[] = +static const union AffineAnimCmd *const sFallingBagAffineAnimTable[] = { - gFallingBagAffineAnimCmds1, - gFallingBagAffineAnimCmds2, + sFallingBagAffineAnimCmds1, + sFallingBagAffineAnimCmds2, }; const struct SpriteTemplate gPresentSpriteTemplate = @@ -735,9 +736,9 @@ const struct SpriteTemplate gPresentSpriteTemplate = .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, .oam = &gOamData_AffineNormal_ObjNormal_32x32, - .anims = gFallingBagAnimTable, + .anims = sFallingBagAnimTable, .images = NULL, - .affineAnims = gFallingBagAffineAnimTable, + .affineAnims = sFallingBagAffineAnimTable, .callback = AnimPresent, }; @@ -746,13 +747,13 @@ const struct SpriteTemplate gKnockOffItemSpriteTemplate = .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, .oam = &gOamData_AffineNormal_ObjNormal_32x32, - .anims = gFallingBagAnimTable, + .anims = sFallingBagAnimTable, .images = NULL, - .affineAnims = gFallingBagAffineAnimTable, + .affineAnims = sFallingBagAffineAnimTable, .callback = AnimKnockOffItem, }; -static const union AnimCmd gPresentHealParticleAnimCmds[] = +static const union AnimCmd sPresentHealParticleAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 4), @@ -761,9 +762,9 @@ static const union AnimCmd gPresentHealParticleAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gPresentHealParticleAnimTable[] = +static const union AnimCmd *const sPresentHealParticleAnimTable[] = { - gPresentHealParticleAnimCmds, + sPresentHealParticleAnimCmds, }; const struct SpriteTemplate gPresentHealParticleSpriteTemplate = @@ -771,7 +772,7 @@ const struct SpriteTemplate gPresentHealParticleSpriteTemplate = .tileTag = ANIM_TAG_GREEN_SPARKLE, .paletteTag = ANIM_TAG_GREEN_SPARKLE, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gPresentHealParticleAnimTable, + .anims = sPresentHealParticleAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimPresentHealParticle, @@ -782,19 +783,19 @@ const struct SpriteTemplate gItemStealSpriteTemplate = .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, .oam = &gOamData_AffineNormal_ObjNormal_32x32, - .anims = gFallingBagAnimTable, + .anims = sFallingBagAnimTable, .images = NULL, - .affineAnims = gFallingBagAffineAnimTable, + .affineAnims = sFallingBagAffineAnimTable, .callback = AnimItemSteal, }; -static const union AffineAnimCmd gTrickBagAffineAnimCmds1[] = +static const union AffineAnimCmd sTrickBagAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 3), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = +static const union AffineAnimCmd sTrickBagAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0, -10, 0, 3), AFFINEANIMCMD_FRAME(0, -6, 0, 3), @@ -806,12 +807,12 @@ static const union AffineAnimCmd gTrickBagAffineAnimCmds2[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gTrickBagAffineAnimTable[] = +static const union AffineAnimCmd *const sTrickBagAffineAnimTable[] = { - gTrickBagAffineAnimCmds1, - gTrickBagAffineAnimCmds2, - gFallingBagAffineAnimCmds1, - gFallingBagAffineAnimCmds2, + sTrickBagAffineAnimCmds1, + sTrickBagAffineAnimCmds2, + sFallingBagAffineAnimCmds1, + sFallingBagAffineAnimCmds2, }; const struct SpriteTemplate gTrickBagSpriteTemplate = @@ -819,9 +820,9 @@ const struct SpriteTemplate gTrickBagSpriteTemplate = .tileTag = ANIM_TAG_ITEM_BAG, .paletteTag = ANIM_TAG_ITEM_BAG, .oam = &gOamData_AffineNormal_ObjNormal_32x32, - .anims = gFallingBagAnimTable, + .anims = sFallingBagAnimTable, .images = NULL, - .affineAnims = gTrickBagAffineAnimTable, + .affineAnims = sTrickBagAffineAnimTable, .callback = AnimTrickBag, }; @@ -840,57 +841,57 @@ static const s8 gTrickBagCoordinates[][3] = {0, 0, 127}, }; -static const union AnimCmd gLeafBladeAnimCmds1[] = +static const union AnimCmd sLeafBladeAnimCmds1[] = { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -static const union AnimCmd gLeafBladeAnimCmds2[] = +static const union AnimCmd sLeafBladeAnimCmds2[] = { ANIMCMD_FRAME(32, 1), ANIMCMD_END, }; -static const union AnimCmd gLeafBladeAnimCmds3[] = +static const union AnimCmd sLeafBladeAnimCmds3[] = { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -static const union AnimCmd gLeafBladeAnimCmds4[] = +static const union AnimCmd sLeafBladeAnimCmds4[] = { ANIMCMD_FRAME(28, 1, .hFlip = TRUE), ANIMCMD_END, }; -static const union AnimCmd gLeafBladeAnimCmds5[] = +static const union AnimCmd sLeafBladeAnimCmds5[] = { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -static const union AnimCmd gLeafBladeAnimCmds6[] = +static const union AnimCmd sLeafBladeAnimCmds6[] = { ANIMCMD_FRAME(16, 1, .hFlip = TRUE), ANIMCMD_END, }; -static const union AnimCmd gLeafBladeAnimCmds7[] = +static const union AnimCmd sLeafBladeAnimCmds7[] = { ANIMCMD_FRAME(28, 1), ANIMCMD_END, }; -static const union AnimCmd *const gLeafBladeAnimTable[] = +static const union AnimCmd *const sLeafBladeAnimTable[] = { - gLeafBladeAnimCmds1, - gLeafBladeAnimCmds2, - gLeafBladeAnimCmds3, - gLeafBladeAnimCmds4, - gLeafBladeAnimCmds5, - gLeafBladeAnimCmds6, - gLeafBladeAnimCmds7, + sLeafBladeAnimCmds1, + sLeafBladeAnimCmds2, + sLeafBladeAnimCmds3, + sLeafBladeAnimCmds4, + sLeafBladeAnimCmds5, + sLeafBladeAnimCmds6, + sLeafBladeAnimCmds7, }; const struct SpriteTemplate gLeafBladeSpriteTemplate = @@ -898,22 +899,22 @@ const struct SpriteTemplate gLeafBladeSpriteTemplate = .tileTag = ANIM_TAG_LEAF, .paletteTag = ANIM_TAG_LEAF, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gLeafBladeAnimTable, + .anims = sLeafBladeAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, }; -static const union AffineAnimCmd gAromatherapyBigFlowerAffineAnimCmds[] = +static const union AffineAnimCmd sAromatherapyBigFlowerAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 1), AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd *const gAromatherapyBigFlowerAffineAnimTable[] = +static const union AffineAnimCmd *const sAromatherapyBigFlowerAffineAnimTable[] = { - gAromatherapyBigFlowerAffineAnimCmds, + sAromatherapyBigFlowerAffineAnimCmds, }; const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = @@ -921,7 +922,7 @@ const struct SpriteTemplate gAromatherapySmallFlowerSpriteTemplate = .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gPetalDanceSmallFlowerAnimTable, + .anims = sPetalDanceSmallFlowerAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimFlyingParticle, @@ -932,46 +933,46 @@ const struct SpriteTemplate gAromatherapyBigFlowerSpriteTemplate = .tileTag = ANIM_TAG_FLOWER, .paletteTag = ANIM_TAG_FLOWER, .oam = &gOamData_AffineNormal_ObjNormal_16x16, - .anims = gPetalDanceBigFlowerAnimTable, + .anims = sPetalDanceBigFlowerAnimTable, .images = NULL, - .affineAnims = gAromatherapyBigFlowerAffineAnimTable, + .affineAnims = sAromatherapyBigFlowerAffineAnimTable, .callback = AnimFlyingParticle, }; -static const union AffineAnimCmd gSilverWindBigSparkAffineAnimCmds[] = +static const union AffineAnimCmd sSilverWindBigSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -10, 1), AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd gSilverWindMediumSparkAffineAnimCmds[] = +static const union AffineAnimCmd sSilverWindMediumSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(192, 192, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -12, 1), AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd gSilverWindSmallSparkAffineAnimCmds[] = +static const union AffineAnimCmd sSilverWindSmallSparkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(143, 143, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -15, 1), AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd *const gSilverWindBigSparkAffineAnimTable[] = +static const union AffineAnimCmd *const sSilverWindBigSparkAffineAnimTable[] = { - gSilverWindBigSparkAffineAnimCmds, + sSilverWindBigSparkAffineAnimCmds, }; -static const union AffineAnimCmd *const gSilverWindMediumSparkAffineAnimTable[] = +static const union AffineAnimCmd *const sSilverWindMediumSparkAffineAnimTable[] = { - gSilverWindMediumSparkAffineAnimCmds, + sSilverWindMediumSparkAffineAnimCmds, }; -static const union AffineAnimCmd *const gSilverWindSmallSparkAffineAnimTable[] = +static const union AffineAnimCmd *const sSilverWindSmallSparkAffineAnimTable[] = { - gSilverWindSmallSparkAffineAnimCmds, + sSilverWindSmallSparkAffineAnimCmds, }; const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = @@ -981,7 +982,7 @@ const struct SpriteTemplate gSilverWindBigSparkSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSilverWindBigSparkAffineAnimTable, + .affineAnims = sSilverWindBigSparkAffineAnimTable, .callback = AnimFlyingParticle, }; @@ -992,7 +993,7 @@ const struct SpriteTemplate gSilverWindMediumSparkSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSilverWindMediumSparkAffineAnimTable, + .affineAnims = sSilverWindMediumSparkAffineAnimTable, .callback = AnimFlyingParticle, }; @@ -1003,11 +1004,11 @@ const struct SpriteTemplate gSilverWindSmallSparkSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSilverWindSmallSparkAffineAnimTable, + .affineAnims = sSilverWindSmallSparkAffineAnimTable, .callback = AnimFlyingParticle, }; -static const u16 gMagicalLeafBlendColors[] = +static const u16 sMagicalLeafBlendColors[] = { RGB(31, 0, 0), RGB(31, 19, 0), @@ -1029,7 +1030,7 @@ const struct SpriteTemplate gNeedleArmSpikeSpriteTemplate = .callback = AnimNeedleArmSpike, }; -static const union AnimCmd gWhipAnimCmds1[] = +static const union AnimCmd sWhipAnimCmds1[] = { ANIMCMD_FRAME(64, 3), ANIMCMD_FRAME(80, 3), @@ -1038,7 +1039,7 @@ static const union AnimCmd gWhipAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gWhipAnimCmds2[] = +static const union AnimCmd sWhipAnimCmds2[] = { ANIMCMD_FRAME(64, 3, .hFlip = TRUE), ANIMCMD_FRAME(80, 3, .hFlip = TRUE), @@ -1047,10 +1048,10 @@ static const union AnimCmd gWhipAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd *const gWhipAnimTable[] = +static const union AnimCmd *const sWhipAnimTable[] = { - gWhipAnimCmds1, - gWhipAnimCmds2, + sWhipAnimCmds1, + sWhipAnimCmds2, }; const struct SpriteTemplate gSlamHitSpriteTemplate = @@ -1058,7 +1059,7 @@ const struct SpriteTemplate gSlamHitSpriteTemplate = .tileTag = ANIM_TAG_SLAM_HIT, .paletteTag = ANIM_TAG_SLAM_HIT, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gWhipAnimTable, + .anims = sWhipAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimWhipHit, @@ -1069,13 +1070,13 @@ const struct SpriteTemplate gVineWhipSpriteTemplate = .tileTag = ANIM_TAG_WHIP_HIT, .paletteTag = ANIM_TAG_WHIP_HIT, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gWhipAnimTable, + .anims = sWhipAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimWhipHit, }; -static const union AnimCmd gUnknown_83E3178[] = +static const union AnimCmd sUnknown_83E3178[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1085,108 +1086,109 @@ static const union AnimCmd gUnknown_83E3178[] = ANIMCMD_END, }; -static const union AnimCmd *const gUnknown_83E3190[] = +// Unused +static const union AnimCmd *const sUnknown_83E3190[] = { - gUnknown_83E3178, + sUnknown_83E3178, }; // Unused -static const struct SpriteTemplate gUnknown_83E3194 = +static const struct SpriteTemplate sUnknown_83E3194 = { .tileTag = ANIM_TAG_HIT, .paletteTag = ANIM_TAG_HIT, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gUnknown_83E3190, + .anims = sUnknown_83E3190, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A43F8, }; // Unused -static const struct SpriteTemplate gUnknown_83E31AC = +static const struct SpriteTemplate sUnknown_83E31AC = { .tileTag = ANIM_TAG_HIT_2, .paletteTag = ANIM_TAG_HIT_2, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gUnknown_83E3190, + .anims = sUnknown_83E3190, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A43F8, }; -static const union AffineAnimCmd gUnknown_83E31C4[] = +static const union AffineAnimCmd sUnknown_83E31C4[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_83E31D4[] = +static const union AffineAnimCmd sUnknown_83E31D4[] = { AFFINEANIMCMD_FRAME(256, 256, 32, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_83E31E4[] = +static const union AffineAnimCmd sUnknown_83E31E4[] = { AFFINEANIMCMD_FRAME(256, 256, 64, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_83E31F4[] = +static const union AffineAnimCmd sUnknown_83E31F4[] = { AFFINEANIMCMD_FRAME(256, 256, 96, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_83E3204[] = +static const union AffineAnimCmd sUnknown_83E3204[] = { AFFINEANIMCMD_FRAME(256, 256, -128, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_83E3214[] = +static const union AffineAnimCmd sUnknown_83E3214[] = { AFFINEANIMCMD_FRAME(256, 256, -96, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_83E3224[] = +static const union AffineAnimCmd sUnknown_83E3224[] = { AFFINEANIMCMD_FRAME(256, 256, -64, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_83E3234[] = +static const union AffineAnimCmd sUnknown_83E3234[] = { AFFINEANIMCMD_FRAME(256, 256, -32, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gUnknown_83E3244[] = +static const union AffineAnimCmd *const sUnknown_83E3244[] = { - gUnknown_83E31C4, - gUnknown_83E31D4, - gUnknown_83E31E4, - gUnknown_83E31F4, - gUnknown_83E3204, - gUnknown_83E3214, - gUnknown_83E3224, - gUnknown_83E3234, + sUnknown_83E31C4, + sUnknown_83E31D4, + sUnknown_83E31E4, + sUnknown_83E31F4, + sUnknown_83E3204, + sUnknown_83E3214, + sUnknown_83E3224, + sUnknown_83E3234, }; // Unused -static const struct SpriteTemplate gUnknown_83E3264 = +static const struct SpriteTemplate sUnknown_83E3264 = { .tileTag = ANIM_TAG_HANDS_AND_FEET, .paletteTag = ANIM_TAG_HANDS_AND_FEET, .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gUnknown_83E3244, + .affineAnims = sUnknown_83E3244, .callback = sub_80A4494, }; -static const union AnimCmd gCuttingSliceAnimCmds[] = +static const union AnimCmd sCuttingSliceAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(16, 5), @@ -1195,9 +1197,9 @@ static const union AnimCmd gCuttingSliceAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gCuttingSliceAnimTable[] = +static const union AnimCmd *const sCuttingSliceAnimTable[] = { - gCuttingSliceAnimCmds, + sCuttingSliceAnimCmds, }; const struct SpriteTemplate gCuttingSliceSpriteTemplate = @@ -1205,7 +1207,7 @@ const struct SpriteTemplate gCuttingSliceSpriteTemplate = .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, .oam = &gOamData_AffineOff_ObjBlend_32x32, - .anims = gCuttingSliceAnimTable, + .anims = sCuttingSliceAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimCuttingSlice, @@ -1216,93 +1218,93 @@ const struct SpriteTemplate gAirCutterSliceSpriteTemplate = .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, .oam = &gOamData_AffineOff_ObjBlend_32x32, - .anims = gCuttingSliceAnimTable, + .anims = sCuttingSliceAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimAirCutterSlice, }; -static const union AnimCmd gUnknown_83E32C4[] = +static const union AnimCmd sUnknown_83E32C4[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E32CC[] = +static const union AnimCmd sUnknown_83E32CC[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E32D4[] = +static const union AnimCmd sUnknown_83E32D4[] = { ANIMCMD_FRAME(8, 1), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E32DC[] = +static const union AnimCmd sUnknown_83E32DC[] = { ANIMCMD_FRAME(12, 1), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E32E4[] = +static const union AnimCmd sUnknown_83E32E4[] = { ANIMCMD_FRAME(16, 1), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E32EC[] = +static const union AnimCmd sUnknown_83E32EC[] = { ANIMCMD_FRAME(20, 1), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E32F4[] = +static const union AnimCmd sUnknown_83E32F4[] = { ANIMCMD_FRAME(0, 1, .vFlip = TRUE), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E32FC[] = +static const union AnimCmd sUnknown_83E32FC[] = { ANIMCMD_FRAME(4, 1, .vFlip = TRUE), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E3304[] = +static const union AnimCmd sUnknown_83E3304[] = { ANIMCMD_FRAME(8, 1, .vFlip = TRUE), ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E330C[] = +static const union AnimCmd sUnknown_83E330C[] = { ANIMCMD_FRAME(12, 1, .vFlip = TRUE), ANIMCMD_END, }; -static const union AnimCmd *const gUnknown_83E3314[] = +static const union AnimCmd *const sUnknown_83E3314[] = { - gUnknown_83E32C4, - gUnknown_83E32CC, - gUnknown_83E32D4, - gUnknown_83E32DC, - gUnknown_83E32E4, - gUnknown_83E32EC, - gUnknown_83E32F4, - gUnknown_83E32FC, - gUnknown_83E3304, - gUnknown_83E330C, + sUnknown_83E32C4, + sUnknown_83E32CC, + sUnknown_83E32D4, + sUnknown_83E32DC, + sUnknown_83E32E4, + sUnknown_83E32EC, + sUnknown_83E32F4, + sUnknown_83E32FC, + sUnknown_83E3304, + sUnknown_83E330C, }; // Unused -static const struct SpriteTemplate gUnknown_83E333C = +static const struct SpriteTemplate sUnknown_83E333C = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gUnknown_83E3314, + .anims = sUnknown_83E3314, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A481C, @@ -1319,13 +1321,13 @@ const struct SpriteTemplate gProtectWallSpriteTemplate = .callback = AnimProtect, }; -static const union AffineAnimCmd gMilkBottleAffineAnimCmds1[] = +static const union AffineAnimCmd sMilkBottleAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = +static const union AffineAnimCmd sMilkBottleAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, 2, 12), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 6), @@ -1335,10 +1337,10 @@ static const union AffineAnimCmd gMilkBottleAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gMilkBottleAffineAnimTable[] = +static const union AffineAnimCmd *const sMilkBottleAffineAnimTable[] = { - gMilkBottleAffineAnimCmds1, - gMilkBottleAffineAnimCmds2, + sMilkBottleAffineAnimCmds1, + sMilkBottleAffineAnimCmds2, }; const struct SpriteTemplate gMilkBottleSpriteTemplate = @@ -1348,11 +1350,11 @@ const struct SpriteTemplate gMilkBottleSpriteTemplate = .oam = &gOamData_AffineNormal_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gMilkBottleAffineAnimTable, + .affineAnims = sMilkBottleAffineAnimTable, .callback = AnimMilkBottle, }; -static const union AnimCmd gGrantingStarsAnimCmds[] = +static const union AnimCmd sGrantingStarsAnimCmds[] = { ANIMCMD_FRAME(0, 7), ANIMCMD_FRAME(16, 7), @@ -1365,9 +1367,9 @@ static const union AnimCmd gGrantingStarsAnimCmds[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gGrantingStarsAnimTable[] = +static const union AnimCmd *const sGrantingStarsAnimTable[] = { - gGrantingStarsAnimCmds, + sGrantingStarsAnimCmds, }; const struct SpriteTemplate gGrantingStarsSpriteTemplate = @@ -1375,7 +1377,7 @@ const struct SpriteTemplate gGrantingStarsSpriteTemplate = .tileTag = ANIM_TAG_SPARKLE_2, .paletteTag = ANIM_TAG_SPARKLE_2, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gGrantingStarsAnimTable, + .anims = sGrantingStarsAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimGrantingStars, @@ -1386,13 +1388,13 @@ const struct SpriteTemplate gSparklingStarsSpriteTemplate = .tileTag = ANIM_TAG_SPARKLE_2, .paletteTag = ANIM_TAG_SPARKLE_2, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gGrantingStarsAnimTable, + .anims = sGrantingStarsAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSparkingStars, }; -static const union AnimCmd gUnknown_83E3424[] = +static const union AnimCmd sUnknown_83E3424[] = { ANIMCMD_FRAME(0, 10), ANIMCMD_FRAME(4, 10), @@ -1405,7 +1407,7 @@ static const union AnimCmd gUnknown_83E3424[] = ANIMCMD_END, }; -static const union AnimCmd gUnknown_83E3448[] = +static const union AnimCmd sUnknown_83E3448[] = { ANIMCMD_FRAME(0, 10, .hFlip = TRUE), ANIMCMD_FRAME(4, 10, .hFlip = TRUE), @@ -1418,67 +1420,67 @@ static const union AnimCmd gUnknown_83E3448[] = ANIMCMD_END, }; -static const union AnimCmd *const gUnknown_83E346C[] = +static const union AnimCmd *const sUnknown_83E346C[] = { - gUnknown_83E3424, - gUnknown_83E3448, + sUnknown_83E3424, + sUnknown_83E3448, }; // Unused -static const struct SpriteTemplate gUnknown_83E3474 = +static const struct SpriteTemplate sUnknown_83E3474 = { .tileTag = ANIM_TAG_BUBBLE_BURST, .paletteTag = ANIM_TAG_BUBBLE_BURST, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gUnknown_83E346C, + .anims = sUnknown_83E346C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80A4E40, }; -static const union AnimCmd gSleepLetterZAnimCmds[] = +static const union AnimCmd sSleepLetterZAnimCmds[] = { ANIMCMD_FRAME(0, 40), ANIMCMD_END, }; -static const union AnimCmd *const gSleepLetterZAnimTable[] = +static const union AnimCmd *const sSleepLetterZAnimTable[] = { - gSleepLetterZAnimCmds, + sSleepLetterZAnimCmds, }; -static const union AffineAnimCmd gSleepLetterZAffineAnimCmds1[] = +static const union AffineAnimCmd sSleepLetterZAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x14, 0x14, -30, 0), AFFINEANIMCMD_FRAME(0x8, 0x8, 1, 24), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gSleepLetterZAffineAnimCmds1_2[] = +static const union AffineAnimCmd sSleepLetterZAffineAnimCmds1_2[] = { AFFINEANIMCMD_LOOP(0), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), AFFINEANIMCMD_LOOP(10), }; -static const union AffineAnimCmd gSleepLetterZAffineAnimCmds2[] = +static const union AffineAnimCmd sSleepLetterZAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x14, 0x14, 30, 0), AFFINEANIMCMD_FRAME(0x8, 0x8, -1, 24), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gSleepLetterZAffineAnimCmds2_2[] = +static const union AffineAnimCmd sSleepLetterZAffineAnimCmds2_2[] = { AFFINEANIMCMD_LOOP(0), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 24), AFFINEANIMCMD_LOOP(10), }; -static const union AffineAnimCmd *const gSleepLetterZAffineAnimTable[] = +static const union AffineAnimCmd *const sSleepLetterZAffineAnimTable[] = { - gSleepLetterZAffineAnimCmds1, - gSleepLetterZAffineAnimCmds2, + sSleepLetterZAffineAnimCmds1, + sSleepLetterZAffineAnimCmds2, }; const struct SpriteTemplate gSleepLetterZSpriteTemplate = @@ -1486,9 +1488,9 @@ const struct SpriteTemplate gSleepLetterZSpriteTemplate = .tileTag = ANIM_TAG_LETTER_Z, .paletteTag = ANIM_TAG_LETTER_Z, .oam = &gOamData_AffineNormal_ObjNormal_32x32, - .anims = gSleepLetterZAnimTable, + .anims = sSleepLetterZAnimTable, .images = NULL, - .affineAnims = gSleepLetterZAffineAnimTable, + .affineAnims = sSleepLetterZAffineAnimTable, .callback = AnimSleepLetterZ, }; @@ -1514,7 +1516,7 @@ const struct SpriteTemplate gLockOnMoveTargetSpriteTemplate = .callback = AnimLockOnMoveTarget, }; -static const s8 gInclineMonCoordTable[][2] = +static const s8 sInclineMonCoordTable[][2] = { { 64, 64}, { 0, -64}, @@ -1534,7 +1536,7 @@ const struct SpriteTemplate gBowMonSpriteTemplate = }; // Unused -static const struct SpriteTemplate gUnknown_83E3568 = +static const struct SpriteTemplate sUnknown_83E3568 = { .tileTag = 0, .paletteTag = 0, @@ -1545,7 +1547,7 @@ static const struct SpriteTemplate gUnknown_83E3568 = .callback = sub_80A5590, }; -static const union AnimCmd gSlashSliceAnimCmds1[] = +static const union AnimCmd sSlashSliceAnimCmds1[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1554,16 +1556,16 @@ static const union AnimCmd gSlashSliceAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gSlashSliceAnimCmds2[] = +static const union AnimCmd sSlashSliceAnimCmds2[] = { ANIMCMD_FRAME(48, 4), ANIMCMD_END, }; -static const union AnimCmd *const gSlashSliceAnimTable[] = +static const union AnimCmd *const sSlashSliceAnimTable[] = { - gSlashSliceAnimCmds1, - gSlashSliceAnimCmds2, + sSlashSliceAnimCmds1, + sSlashSliceAnimCmds2, }; const struct SpriteTemplate gSlashSliceSpriteTemplate = @@ -1571,7 +1573,7 @@ const struct SpriteTemplate gSlashSliceSpriteTemplate = .tileTag = ANIM_TAG_SLASH, .paletteTag = ANIM_TAG_SLASH, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSlashSliceAnimTable, + .anims = sSlashSliceAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSlashSlice, @@ -1582,7 +1584,7 @@ const struct SpriteTemplate gFalseSwipeSliceSpriteTemplate = .tileTag = ANIM_TAG_SLASH_2, .paletteTag = ANIM_TAG_SLASH_2, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSlashSliceAnimTable, + .anims = sSlashSliceAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimFalseSwipeSlice, @@ -1593,13 +1595,13 @@ const struct SpriteTemplate gFalseSwipePositionedSliceSpriteTemplate = .tileTag = ANIM_TAG_SLASH_2, .paletteTag = ANIM_TAG_SLASH_2, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSlashSliceAnimTable, + .anims = sSlashSliceAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimFalseSwipePositionedSlice, }; -static const union AnimCmd gEndureEnergyAnimCmds[] = +static const union AnimCmd sEndureEnergyAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(8, 12), @@ -1608,9 +1610,9 @@ static const union AnimCmd gEndureEnergyAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gEndureEnergyAnimTable[] = +static const union AnimCmd *const sEndureEnergyAnimTable[] = { - gEndureEnergyAnimCmds, + sEndureEnergyAnimCmds, }; const struct SpriteTemplate gEndureEnergySpriteTemplate = @@ -1618,13 +1620,13 @@ const struct SpriteTemplate gEndureEnergySpriteTemplate = .tileTag = ANIM_TAG_FOCUS_ENERGY, .paletteTag = ANIM_TAG_FOCUS_ENERGY, .oam = &gOamData_AffineOff_ObjNormal_16x32, - .anims = gEndureEnergyAnimTable, + .anims = sEndureEnergyAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimEndureEnergy, }; -static const union AnimCmd gSharpenSphereAnimCmds[] = +static const union AnimCmd sSharpenSphereAnimCmds[] = { ANIMCMD_FRAME(0, 18), ANIMCMD_FRAME(0, 6), @@ -1643,9 +1645,9 @@ static const union AnimCmd gSharpenSphereAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gSharpenSphereAnimTable[] = +static const union AnimCmd *const sSharpenSphereAnimTable[] = { - gSharpenSphereAnimCmds, + sSharpenSphereAnimCmds, }; const struct SpriteTemplate gSharpenSphereSpriteTemplate = @@ -1653,7 +1655,7 @@ const struct SpriteTemplate gSharpenSphereSpriteTemplate = .tileTag = ANIM_TAG_SPHERE_TO_CUBE, .paletteTag = ANIM_TAG_SPHERE_TO_CUBE, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSharpenSphereAnimTable, + .anims = sSharpenSphereAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSharpenSphere, @@ -1670,7 +1672,7 @@ const struct SpriteTemplate gOctazookaBallSpriteTemplate = .callback = TranslateAnimSpriteToTargetMonLocation, }; -static const union AnimCmd gOctazookaAnimCmds[] = +static const union AnimCmd sOctazookaAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -1680,9 +1682,9 @@ static const union AnimCmd gOctazookaAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gOctazookaAnimTable[] = +static const union AnimCmd *const sOctazookaAnimTable[] = { - gOctazookaAnimCmds, + sOctazookaAnimCmds, }; const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = @@ -1690,13 +1692,13 @@ const struct SpriteTemplate gOctazookaSmokeSpriteTemplate = .tileTag = ANIM_TAG_GRAY_SMOKE, .paletteTag = ANIM_TAG_GRAY_SMOKE, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gOctazookaAnimTable, + .anims = sOctazookaAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSpriteOnMonPos, }; -static const union AnimCmd gConversionAnimCmds[] = +static const union AnimCmd sConversionAnimCmds[] = { ANIMCMD_FRAME(3, 5), ANIMCMD_FRAME(2, 5), @@ -1705,20 +1707,20 @@ static const union AnimCmd gConversionAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gConversionAnimTable[] = +static const union AnimCmd *const sConversionAnimTable[] = { - gConversionAnimCmds, + sConversionAnimCmds, }; -static const union AffineAnimCmd gConversionAffineAnimCmds[] = +static const union AffineAnimCmd sConversionAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gConversionAffineAnimTable[] = +static const union AffineAnimCmd *const sConversionAffineAnimTable[] = { - gConversionAffineAnimCmds, + sConversionAffineAnimCmds, }; const struct SpriteTemplate gConversionSpriteTemplate = @@ -1726,13 +1728,13 @@ const struct SpriteTemplate gConversionSpriteTemplate = .tileTag = ANIM_TAG_CONVERSION, .paletteTag = ANIM_TAG_CONVERSION, .oam = &gOamData_AffineDouble_ObjBlend_8x8, - .anims = gConversionAnimTable, + .anims = sConversionAnimTable, .images = NULL, - .affineAnims = gConversionAffineAnimTable, + .affineAnims = sConversionAffineAnimTable, .callback = AnimConversion, }; -static const union AnimCmd gConversion2AnimCmds[] = +static const union AnimCmd sConversion2AnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(1, 5), @@ -1741,9 +1743,9 @@ static const union AnimCmd gConversion2AnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gConversion2AnimTable[] = +static const union AnimCmd *const sConversion2AnimTable[] = { - gConversion2AnimCmds, + sConversion2AnimCmds, }; const struct SpriteTemplate gConversion2SpriteTemplate = @@ -1751,9 +1753,9 @@ const struct SpriteTemplate gConversion2SpriteTemplate = .tileTag = ANIM_TAG_CONVERSION, .paletteTag = ANIM_TAG_CONVERSION, .oam = &gOamData_AffineDouble_ObjBlend_8x8, - .anims = gConversion2AnimTable, + .anims = sConversion2AnimTable, .images = NULL, - .affineAnims = gConversionAffineAnimTable, + .affineAnims = sConversionAffineAnimTable, .callback = AnimConversion2, }; @@ -1768,7 +1770,7 @@ const struct SpriteTemplate gMoonSpriteTemplate = .callback = AnimMoon, }; -static const union AnimCmd gMoonlightSparkleAnimCmds[] = +static const union AnimCmd sMoonlightSparkleAnimCmds[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(4, 8), @@ -1777,9 +1779,9 @@ static const union AnimCmd gMoonlightSparkleAnimCmds[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gMoonlightSparkleAnimTable[] = +static const union AnimCmd *const sMoonlightSparkleAnimTable[] = { - gMoonlightSparkleAnimCmds, + sMoonlightSparkleAnimCmds, }; const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = @@ -1787,13 +1789,13 @@ const struct SpriteTemplate gMoonlightSparkleSpriteTemplate = .tileTag = ANIM_TAG_GREEN_SPARKLE, .paletteTag = ANIM_TAG_GREEN_SPARKLE, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gMoonlightSparkleAnimTable, + .anims = sMoonlightSparkleAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimMoonlightSparkle, }; -static const union AnimCmd gHealingBlueStarAnimCmds[] = +static const union AnimCmd sHealingBlueStarAnimCmds[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(16, 2), @@ -1806,9 +1808,9 @@ static const union AnimCmd gHealingBlueStarAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gHealingBlueStarAnimTable[] = +static const union AnimCmd *const sHealingBlueStarAnimTable[] = { - gHealingBlueStarAnimCmds, + sHealingBlueStarAnimCmds, }; const struct SpriteTemplate gHealingBlueStarSpriteTemplate = @@ -1816,7 +1818,7 @@ const struct SpriteTemplate gHealingBlueStarSpriteTemplate = .tileTag = ANIM_TAG_BLUE_STAR, .paletteTag = ANIM_TAG_BLUE_STAR, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gHealingBlueStarAnimTable, + .anims = sHealingBlueStarAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSpriteOnMonPos, @@ -1833,7 +1835,7 @@ const struct SpriteTemplate gHornHitSpriteTemplate = .callback = AnimHornHit, }; -static const union AnimCmd gSuperFangAnimCmds[] = +static const union AnimCmd sSuperFangAnimCmds[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(16, 2), @@ -1842,9 +1844,9 @@ static const union AnimCmd gSuperFangAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gSuperFangAnimTable[] = +static const union AnimCmd *const sSuperFangAnimTable[] = { - gSuperFangAnimCmds, + sSuperFangAnimCmds, }; const struct SpriteTemplate gSuperFangSpriteTemplate = @@ -1852,55 +1854,55 @@ const struct SpriteTemplate gSuperFangSpriteTemplate = .tileTag = ANIM_TAG_FANG_ATTACK, .paletteTag = ANIM_TAG_FANG_ATTACK, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSuperFangAnimTable, + .anims = sSuperFangAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSuperFang, }; -static const union AnimCmd gWavyMusicNotesAnimCmds1[] = +static const union AnimCmd sWavyMusicNotesAnimCmds1[] = { ANIMCMD_FRAME(0, 10), ANIMCMD_END, }; -static const union AnimCmd gWavyMusicNotesAnimCmds2[] = +static const union AnimCmd sWavyMusicNotesAnimCmds2[] = { ANIMCMD_FRAME(4, 10), ANIMCMD_END, }; -static const union AnimCmd gWavyMusicNotesAnimCmds3[] = +static const union AnimCmd sWavyMusicNotesAnimCmds3[] = { ANIMCMD_FRAME(8, 41), ANIMCMD_END, }; -static const union AnimCmd gWavyMusicNotesAnimCmds4[] = +static const union AnimCmd sWavyMusicNotesAnimCmds4[] = { ANIMCMD_FRAME(12, 10), ANIMCMD_END, }; -static const union AnimCmd gWavyMusicNotesAnimCmds5[] = +static const union AnimCmd sWavyMusicNotesAnimCmds5[] = { ANIMCMD_FRAME(16, 10), ANIMCMD_END, }; -static const union AnimCmd gWavyMusicNotesAnimCmds6[] = +static const union AnimCmd sWavyMusicNotesAnimCmds6[] = { ANIMCMD_FRAME(20, 10), ANIMCMD_END, }; -static const union AnimCmd gWavyMusicNotesAnimCmds7[] = +static const union AnimCmd sWavyMusicNotesAnimCmds7[] = { ANIMCMD_FRAME(0, 10, .vFlip = TRUE), ANIMCMD_END, }; -static const union AnimCmd gWavyMusicNotesAnimCmds8[] = +static const union AnimCmd sWavyMusicNotesAnimCmds8[] = { ANIMCMD_FRAME(4, 10, .vFlip = TRUE), ANIMCMD_END, @@ -1908,26 +1910,26 @@ static const union AnimCmd gWavyMusicNotesAnimCmds8[] = const union AnimCmd *const gMusicNotesAnimTable[] = { - gWavyMusicNotesAnimCmds1, - gWavyMusicNotesAnimCmds2, - gWavyMusicNotesAnimCmds3, - gWavyMusicNotesAnimCmds4, - gWavyMusicNotesAnimCmds5, - gWavyMusicNotesAnimCmds6, - gWavyMusicNotesAnimCmds7, - gWavyMusicNotesAnimCmds8, + sWavyMusicNotesAnimCmds1, + sWavyMusicNotesAnimCmds2, + sWavyMusicNotesAnimCmds3, + sWavyMusicNotesAnimCmds4, + sWavyMusicNotesAnimCmds5, + sWavyMusicNotesAnimCmds6, + sWavyMusicNotesAnimCmds7, + sWavyMusicNotesAnimCmds8, }; -static const union AffineAnimCmd gWavyMusicNotesAffineAnimCmds[] = +static const union AffineAnimCmd sWavyMusicNotesAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0xC, 0xC, 0, 16), AFFINEANIMCMD_FRAME(0xFFF4, 0xFFF4, 0, 16), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gMusicNotesAffineAnimTable[] = +static const union AffineAnimCmd *const sMusicNotesAffineAnimTable[] = { - gWavyMusicNotesAffineAnimCmds, + sWavyMusicNotesAffineAnimCmds, }; const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = @@ -1937,11 +1939,11 @@ const struct SpriteTemplate gWavyMusicNotesSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gMusicNotesAnimTable, .images = NULL, - .affineAnims = gMusicNotesAffineAnimTable, + .affineAnims = sMusicNotesAffineAnimTable, .callback = AnimWavyMusicNotes, }; -static const u16 gParticlesColorBlendTable[][6] = +static const u16 sParticlesColorBlendTable[][6] = { {ANIM_TAG_MUSIC_NOTES, RGB_WHITE, RGB(31, 26, 28), RGB(31, 22, 26), RGB(31, 17, 24), RGB(31, 13, 22)}, {ANIM_TAG_BENT_SPOON, RGB_WHITE, RGB(25, 31, 26), RGB(20, 31, 21), RGB(15, 31, 16), RGB(10, 31, 12)}, @@ -1956,7 +1958,7 @@ const struct SpriteTemplate gFastFlyingMusicNotesSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gMusicNotesAnimTable, .images = NULL, - .affineAnims = gMusicNotesAffineAnimTable, + .affineAnims = sMusicNotesAffineAnimTable, .callback = AnimFlyingMusicNotes, }; @@ -1971,16 +1973,16 @@ const struct SpriteTemplate gBellyDrumHandSpriteTemplate = .callback = AnimBellyDrumHand, }; -static const union AffineAnimCmd gSlowFlyingMusicNotesAffineAnimCmds[] = +static const union AffineAnimCmd sSlowFlyingMusicNotesAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0xA0, 0xA0, 0, 0), AFFINEANIMCMD_FRAME(0x4, 0x4, 0, 1), AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd *const gSlowFlyingMusicNotesAffineAnimTable[] = +static const union AffineAnimCmd *const sSlowFlyinsMusicNotesAffineAnimTable[] = { - gSlowFlyingMusicNotesAffineAnimCmds, + sSlowFlyingMusicNotesAffineAnimCmds, }; const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = @@ -1990,11 +1992,11 @@ const struct SpriteTemplate gSlowFlyingMusicNotesSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gMusicNotesAnimTable, .images = NULL, - .affineAnims = gSlowFlyingMusicNotesAffineAnimTable, + .affineAnims = sSlowFlyinsMusicNotesAffineAnimTable, .callback = AnimSlowFlyingMusicNotes, }; -static const union AnimCmd gMetronomeThroughtBubbleAnimCmds1[] = +static const union AnimCmd sMetronomeThroughtBubbleAnimCmds1[] = { ANIMCMD_FRAME(0, 2, .hFlip = TRUE), ANIMCMD_FRAME(16, 2, .hFlip = TRUE), @@ -2003,7 +2005,7 @@ static const union AnimCmd gMetronomeThroughtBubbleAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gMetronomeThroughtBubbleAnimCmds3[] = +static const union AnimCmd sMetronomeThroughtBubbleAnimCmds3[] = { ANIMCMD_FRAME(48, 2, .hFlip = TRUE), ANIMCMD_FRAME(32, 2, .hFlip = TRUE), @@ -2012,7 +2014,7 @@ static const union AnimCmd gMetronomeThroughtBubbleAnimCmds3[] = ANIMCMD_END, }; -static const union AnimCmd gMetronomeThroughtBubbleAnimCmds2[] = +static const union AnimCmd sMetronomeThroughtBubbleAnimCmds2[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(16, 2), @@ -2021,7 +2023,7 @@ static const union AnimCmd gMetronomeThroughtBubbleAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd gMetronomeThroughtBubbleAnimCmds4[] = +static const union AnimCmd sMetronomeThroughtBubbleAnimCmds4[] = { ANIMCMD_FRAME(48, 2), ANIMCMD_FRAME(32, 2), @@ -2030,12 +2032,12 @@ static const union AnimCmd gMetronomeThroughtBubbleAnimCmds4[] = ANIMCMD_END, }; -static const union AnimCmd *const gMetronomeThroughtBubbleAnimTable[] = +static const union AnimCmd *const sMetronomeThroughtBubbleAnimTable[] = { - gMetronomeThroughtBubbleAnimCmds1, - gMetronomeThroughtBubbleAnimCmds2, - gMetronomeThroughtBubbleAnimCmds3, - gMetronomeThroughtBubbleAnimCmds4, + sMetronomeThroughtBubbleAnimCmds1, + sMetronomeThroughtBubbleAnimCmds2, + sMetronomeThroughtBubbleAnimCmds3, + sMetronomeThroughtBubbleAnimCmds4, }; const struct SpriteTemplate gThoughtBubbleSpriteTemplate = @@ -2043,20 +2045,20 @@ const struct SpriteTemplate gThoughtBubbleSpriteTemplate = .tileTag = ANIM_TAG_THOUGHT_BUBBLE, .paletteTag = ANIM_TAG_THOUGHT_BUBBLE, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gMetronomeThroughtBubbleAnimTable, + .anims = sMetronomeThroughtBubbleAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimThoughtBubble, }; -static const union AffineAnimCmd gMetronomeFingerAffineAnimCmds1[] = +static const union AffineAnimCmd sMetronomeFingerAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0), AFFINEANIMCMD_FRAME(0x1E, 0x1E, 0, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = +static const union AffineAnimCmd sMetronomeFingerAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 11), AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 11), @@ -2065,7 +2067,7 @@ static const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2_2[] = +static const union AffineAnimCmd sMetronomeFingerAffineAnimCmds2_2[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_FRAME(30, 30, 0, 8), @@ -2078,10 +2080,10 @@ static const union AffineAnimCmd gMetronomeFingerAffineAnimCmds2_2[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gMetronomeFingerAffineAnimTable[] = +static const union AffineAnimCmd *const sMetronomeFingerAffineAnimTable[] = { - gMetronomeFingerAffineAnimCmds1, - gMetronomeFingerAffineAnimCmds2, + sMetronomeFingerAffineAnimCmds1, + sMetronomeFingerAffineAnimCmds2, }; const struct SpriteTemplate gMetronomeFingerSpriteTemplate = @@ -2091,7 +2093,7 @@ const struct SpriteTemplate gMetronomeFingerSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gMetronomeFingerAffineAnimTable, + .affineAnims = sMetronomeFingerAffineAnimTable, .callback = AnimMetronomeFinger, }; @@ -2102,23 +2104,23 @@ const struct SpriteTemplate gFollowMeFingerSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gMetronomeFingerAffineAnimTable, + .affineAnims = sMetronomeFingerAffineAnimTable, .callback = AnimFollowMeFinger, }; -static const union AnimCmd gTauntFingerAnimCmds1[] = +static const union AnimCmd sTauntFingerAnimCmds1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END, }; -static const union AnimCmd gTauntFingerAnimCmds2[] = +static const union AnimCmd sTauntFingerAnimCmds2[] = { ANIMCMD_FRAME(0, 1, .hFlip = TRUE), ANIMCMD_END, }; -static const union AnimCmd gTauntFingerAnimCmds3[] = +static const union AnimCmd sTauntFingerAnimCmds3[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -2130,7 +2132,7 @@ static const union AnimCmd gTauntFingerAnimCmds3[] = ANIMCMD_END, }; -static const union AnimCmd gTauntFingerAnimCmds4[] = +static const union AnimCmd sTauntFingerAnimCmds4[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(16, 4, .hFlip = TRUE), @@ -2142,12 +2144,12 @@ static const union AnimCmd gTauntFingerAnimCmds4[] = ANIMCMD_END, }; -static const union AnimCmd *const gTauntFingerAnimTable[] = +static const union AnimCmd *const sTauntFingerAnimTable[] = { - gTauntFingerAnimCmds1, - gTauntFingerAnimCmds2, - gTauntFingerAnimCmds3, - gTauntFingerAnimCmds4, + sTauntFingerAnimCmds1, + sTauntFingerAnimCmds2, + sTauntFingerAnimCmds3, + sTauntFingerAnimCmds4, }; const struct SpriteTemplate gTauntFingerSpriteTemplate = @@ -2155,7 +2157,7 @@ const struct SpriteTemplate gTauntFingerSpriteTemplate = .tileTag = ANIM_TAG_FINGER_2, .paletteTag = ANIM_TAG_FINGER_2, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gTauntFingerAnimTable, + .anims = sTauntFingerAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimTauntFinger, @@ -3626,8 +3628,8 @@ void sub_80A41C4(u8 taskId) if (++task->data[9] >= 0) { task->data[9] = 0; - BlendPalette(task->data[8], 16, task->data[10], gMagicalLeafBlendColors[task->data[11]]); - BlendPalette(task->data[12], 16, task->data[10], gMagicalLeafBlendColors[task->data[11]]); + BlendPalette(task->data[8], 16, task->data[10], sMagicalLeafBlendColors[task->data[11]]); + BlendPalette(task->data[12], 16, task->data[10], sMagicalLeafBlendColors[task->data[11]]); if (++task->data[10] == 17) { task->data[10] = 0; @@ -4240,8 +4242,8 @@ static void AnimLockOnTargetStep1(struct Sprite* sprite) sprite->pos2.y = 0; sprite->pos2.x = 0; sprite->data[0] = 8; - sprite->data[2] = sprite->pos1.x + gInclineMonCoordTable[sprite->data[5] >> 8][0]; - sprite->data[4] = sprite->pos1.y + gInclineMonCoordTable[sprite->data[5] >> 8][1]; + sprite->data[2] = sprite->pos1.x + sInclineMonCoordTable[sprite->data[5] >> 8][0]; + sprite->data[4] = sprite->pos1.y + sInclineMonCoordTable[sprite->data[5] >> 8][1]; sprite->callback = StartAnimLinearTranslation; StoreSpriteCallbackInData6(sprite, AnimLockOnTargetStep2); sprite->data[5] += 0x100; @@ -5238,22 +5240,22 @@ void AnimTask_MusicNotesRainbowBlend(u8 taskId) u16 j; u16 index; - index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[0][0]); + index = IndexOfSpritePaletteTag(sParticlesColorBlendTable[0][0]); if (index != 0xFF) { index = (index << 4) + 0x100; - for (i = 1; i < NELEMS(gParticlesColorBlendTable[0]); i++) - gPlttBufferFaded[index + i] = gParticlesColorBlendTable[0][i]; + for (i = 1; i < NELEMS(sParticlesColorBlendTable[0]); i++) + gPlttBufferFaded[index + i] = sParticlesColorBlendTable[0][i]; } - for (j = 1; j < NELEMS(gParticlesColorBlendTable); j++) + for (j = 1; j < NELEMS(sParticlesColorBlendTable); j++) { - index = AllocSpritePalette(gParticlesColorBlendTable[j][0]); + index = AllocSpritePalette(sParticlesColorBlendTable[j][0]); if (index != 0xFF) { index = (index << 4) + 0x100; - for (i = 1; i < NELEMS(gParticlesColorBlendTable[0]); i++) - gPlttBufferFaded[index + i] = gParticlesColorBlendTable[j][i]; + for (i = 1; i < NELEMS(sParticlesColorBlendTable[0]); i++) + gPlttBufferFaded[index + i] = sParticlesColorBlendTable[j][i]; } } DestroyAnimVisualTask(taskId); @@ -5264,8 +5266,8 @@ void AnimTask_MusicNotesClearRainbowBlend(u8 taskId) { u16 i; - for (i = 1; i < NELEMS(gParticlesColorBlendTable); i++) - FreeSpritePaletteByTag(gParticlesColorBlendTable[i][0]); + for (i = 1; i < NELEMS(sParticlesColorBlendTable); i++) + FreeSpritePaletteByTag(sParticlesColorBlendTable[i][0]); DestroyAnimVisualTask(taskId); } @@ -5278,7 +5280,7 @@ void AnimWavyMusicNotes(struct Sprite* sprite) SetSpriteCoordsToAnimAttackerCoords(sprite); StartSpriteAnim(sprite, gBattleAnimArgs[0]); - if ((index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[gBattleAnimArgs[1]][0])) != 0xFF) + if ((index = IndexOfSpritePaletteTag(sParticlesColorBlendTable[gBattleAnimArgs[1]][0])) != 0xFF) sprite->oam.paletteNum = index; sprite->data[1] = gBattleAnimArgs[1]; @@ -5344,7 +5346,7 @@ static void AnimWavyMusicNotesStep(struct Sprite* sprite) if (++sprite->data[1] > 3) sprite->data[1] = 0; - index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[sprite->data[1]][0]); + index = IndexOfSpritePaletteTag(sParticlesColorBlendTable[sprite->data[1]][0]); if (index != 0xFF) sprite->oam.paletteNum = index; } @@ -5416,7 +5418,7 @@ void AnimSlowFlyingMusicNotes(struct Sprite* sprite) SetSpriteCoordsToAnimAttackerCoords(sprite); sprite->pos1.y += 8; StartSpriteAnim(sprite, gBattleAnimArgs[1]); - index = IndexOfSpritePaletteTag(gParticlesColorBlendTable[gBattleAnimArgs[2]][0]); + index = IndexOfSpritePaletteTag(sParticlesColorBlendTable[gBattleAnimArgs[2]][0]); if (index != 0xFF) sprite->oam.paletteNum = index; diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 3a33276a1..23be07785 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -65,7 +65,7 @@ static void AnimPerishSongMusicNote_Step2(struct Sprite *); // Data // Unused -static const struct SpriteTemplate gUnknown_83E3ADC = +static const struct SpriteTemplate sUnknown_83E3ADC = { .tileTag = ANIM_TAG_FINGER, .paletteTag = ANIM_TAG_FINGER, @@ -76,19 +76,19 @@ static const struct SpriteTemplate gUnknown_83E3ADC = .callback = sub_80A6E48, }; -static const union AnimCmd gUnknown_83E3AF4[] = +static const union AnimCmd sUnknown_83E3AF4[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -static const union AnimCmd *const gUnknown_83E3AFC[] = +static const union AnimCmd *const sUnknown_83E3AFC[] = { - gUnknown_83E3AF4, + sUnknown_83E3AF4, }; // Unused -static const struct SpriteTemplate gUnknown_83E3B00 = +static const struct SpriteTemplate sUnknown_83E3B00 = { .tileTag = ANIM_TAG_MUSIC_NOTES, .paletteTag = ANIM_TAG_MUSIC_NOTES, @@ -100,7 +100,7 @@ static const struct SpriteTemplate gUnknown_83E3B00 = }; // Unused -static const struct SpriteTemplate gUnknown_83E3B18 = +static const struct SpriteTemplate sUnknown_83E3B18 = { .tileTag = 0, .paletteTag = 0, @@ -112,7 +112,7 @@ static const struct SpriteTemplate gUnknown_83E3B18 = }; // Unused -static const struct SpriteTemplate gUnknown_83E3B30 = +static const struct SpriteTemplate sUnknown_83E3B30 = { .tileTag = ANIM_TAG_CLAMP, .paletteTag = ANIM_TAG_CLAMP, @@ -123,7 +123,7 @@ static const struct SpriteTemplate gUnknown_83E3B30 = .callback = sub_80A7020, }; -static const union AnimCmd gUnknown_83E3B48[] = +static const union AnimCmd sUnknown_83E3B48[] = { ANIMCMD_FRAME(0, 9), ANIMCMD_FRAME(16, 3), @@ -132,36 +132,36 @@ static const union AnimCmd gUnknown_83E3B48[] = ANIMCMD_END, }; -static const union AnimCmd *const gUnknown_83E3B5C[] = +static const union AnimCmd *const sUnknown_83E3B5C[] = { - gUnknown_83E3B48, + sUnknown_83E3B48, }; -static const union AffineAnimCmd gUnknown_83E3B60[] = +static const union AffineAnimCmd sUnknown_83E3B60[] = { AFFINEANIMCMD_FRAME(80, 80, 0, 0), AFFINEANIMCMD_FRAME(9, 9, 0, 18), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gUnknown_83E3B78[] = +static const union AffineAnimCmd *const sUnknown_83E3B78[] = { - gUnknown_83E3B60, + sUnknown_83E3B60, }; // Unused -static const struct SpriteTemplate gUnknown_83E3B7C = +static const struct SpriteTemplate sUnknown_83E3B7C = { .tileTag = ANIM_TAG_EXPLOSION_6, .paletteTag = ANIM_TAG_EXPLOSION_6, .oam = &gOamData_AffineNormal_ObjNormal_32x32, - .anims = gUnknown_83E3B5C, + .anims = sUnknown_83E3B5C, .images = NULL, - .affineAnims = gUnknown_83E3B78, + .affineAnims = sUnknown_83E3B78, .callback = AnimSpriteOnMonPos, }; -static const union AnimCmd gKinesisZapEnergyAnimCmds[] = +static const union AnimCmd sKinesisZapEnergyAnimCmds[] = { ANIMCMD_FRAME(0, 3, .hFlip = TRUE), ANIMCMD_FRAME(8, 3, .hFlip = TRUE), @@ -174,9 +174,9 @@ static const union AnimCmd gKinesisZapEnergyAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gKinesisZapEnergyAnimTable[] = +static const union AnimCmd *const sKinesisZapEnergyAnimTable[] = { - gKinesisZapEnergyAnimCmds, + sKinesisZapEnergyAnimCmds, }; const struct SpriteTemplate gKinesisZapEnergySpriteTemplate = @@ -184,13 +184,13 @@ const struct SpriteTemplate gKinesisZapEnergySpriteTemplate = .tileTag = ANIM_TAG_ALERT, .paletteTag = ANIM_TAG_ALERT, .oam = &gOamData_AffineOff_ObjNormal_32x16, - .anims = gKinesisZapEnergyAnimTable, + .anims = sKinesisZapEnergyAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = Anim_KinesisZapEnergy, }; -static const union AffineAnimCmd gSwordsDanceBladeAffineAnimCmds[] = +static const union AffineAnimCmd sSwordsDanceBladeAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 256, 0, 0), AFFINEANIMCMD_FRAME(20, 0, 0, 12), @@ -198,9 +198,9 @@ static const union AffineAnimCmd gSwordsDanceBladeAffineAnimCmds[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gSwordsDanceBladeAffineAnimTable[] = +static const union AffineAnimCmd *const sSwordsDanceBladeAffineAnimTable[] = { - gSwordsDanceBladeAffineAnimCmds, + sSwordsDanceBladeAffineAnimCmds, }; const struct SpriteTemplate gSwordsDanceBladeSpriteTemplate = @@ -210,7 +210,7 @@ const struct SpriteTemplate gSwordsDanceBladeSpriteTemplate = .oam = &gOamData_AffineNormal_ObjBlend_32x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSwordsDanceBladeAffineAnimTable, + .affineAnims = sSwordsDanceBladeAffineAnimTable, .callback = Anim_SwordsDanceBlade, }; @@ -236,14 +236,14 @@ const struct SpriteTemplate gAirWaveProjectileSpriteTemplate = .callback = AnimAirWaveProjectile, }; -static const union AffineAnimCmd gGrowingRingAffineAnimCmds[] = +static const union AffineAnimCmd sGrowingRingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(32, 32, 0, 0), AFFINEANIMCMD_FRAME(7, 7, 0, -56), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = +static const union AffineAnimCmd sWaterPulseRingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(5, 5, 0, 10), AFFINEANIMCMD_FRAME(-10, -10, 0, 10), @@ -257,12 +257,12 @@ static const union AffineAnimCmd gWaterPulseRingAffineAnimCmds[] = const union AffineAnimCmd *const gGrowingRingAffineAnimTable[] = { - gGrowingRingAffineAnimCmds, + sGrowingRingAffineAnimCmds, }; -static const union AffineAnimCmd *const gWaterPulseRingAffineAnimTable[] = +static const union AffineAnimCmd *const sWaterPulseRingAffineAnimTable[] = { - gWaterPulseRingAffineAnimCmds, + sWaterPulseRingAffineAnimCmds, }; const struct SpriteTemplate gSupersonicWaveSpriteTemplate = @@ -305,7 +305,7 @@ const struct SpriteTemplate gWaterPulseRingSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_16x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gWaterPulseRingAffineAnimTable, + .affineAnims = sWaterPulseRingAffineAnimTable, .callback = AnimWaterPulseRing, }; @@ -320,7 +320,7 @@ const struct SpriteTemplate gEggThrowSpriteTemplate = .callback = AnimThrowProjectile, }; -const struct SpriteTemplate gUnknown_83E3D18 = +static const struct SpriteTemplate sUnknown_83E3D18 = { .tileTag = ANIM_TAG_VOID_LINES, .paletteTag = ANIM_TAG_VOID_LINES, @@ -331,26 +331,26 @@ const struct SpriteTemplate gUnknown_83E3D18 = .callback = sub_80A79E8, }; -static const union AnimCmd gCoinAnimCmds[] = +static const union AnimCmd sCoinAnimCmds[] = { ANIMCMD_FRAME(8, 1), ANIMCMD_END, }; -static const union AnimCmd *const gCoinAnimTable[] = +static const union AnimCmd *const sCoinAnimTable[] = { - gCoinAnimCmds, + sCoinAnimCmds, }; -static const union AffineAnimCmd gFallingCoinAffineAnimCmds[] = +static const union AffineAnimCmd sFallingCoinAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 10, 1), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gFallingCoinAffineAnimTable[] = +static const union AffineAnimCmd *const sFallingCoinAffineAnimTable[] = { - gFallingCoinAffineAnimCmds, + sFallingCoinAffineAnimCmds, }; const struct SpriteTemplate gCoinThrowSpriteTemplate = @@ -358,7 +358,7 @@ const struct SpriteTemplate gCoinThrowSpriteTemplate = .tileTag = ANIM_TAG_COIN, .paletteTag = ANIM_TAG_COIN, .oam = &gOamData_AffineNormal_ObjNormal_16x16, - .anims = gCoinAnimTable, + .anims = sCoinAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimCoinThrow, @@ -369,21 +369,21 @@ const struct SpriteTemplate gFallingCoinSpriteTemplate = .tileTag = ANIM_TAG_COIN, .paletteTag = ANIM_TAG_COIN, .oam = &gOamData_AffineNormal_ObjNormal_16x16, - .anims = gCoinAnimTable, + .anims = sCoinAnimTable, .images = NULL, - .affineAnims = gFallingCoinAffineAnimTable, + .affineAnims = sFallingCoinAffineAnimTable, .callback = AnimFallingCoin, }; -static const union AffineAnimCmd gBulletSeedAffineAnimCmds[] = +static const union AffineAnimCmd sBulletSeedAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 20, 1), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gBulletSeedAffineAnimTable[] = +static const union AffineAnimCmd *const sBulletSeedAffineAnimTable[] = { - gBulletSeedAffineAnimCmds, + sBulletSeedAffineAnimCmds, }; const struct SpriteTemplate gBulletSeedSpriteTemplate = @@ -393,20 +393,20 @@ const struct SpriteTemplate gBulletSeedSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gBulletSeedAffineAnimTable, + .affineAnims = sBulletSeedAffineAnimTable, .callback = AnimBulletSeed, }; -static const union AffineAnimCmd gRazorWindTornadoAffineAnimCmds[] = +static const union AffineAnimCmd sRazorWindTornadoAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 256, 0, 0), AFFINEANIMCMD_FRAME(4, 0, 0, 40), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gRazorWindTornadoAffineAnimTable[] = +static const union AffineAnimCmd *const sRazorWindTornadoAffineAnimTable[] = { - gRazorWindTornadoAffineAnimCmds, + sRazorWindTornadoAffineAnimCmds, }; const struct SpriteTemplate gRazorWindTornadoSpriteTemplate = @@ -416,11 +416,11 @@ const struct SpriteTemplate gRazorWindTornadoSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_32x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gRazorWindTornadoAffineAnimTable, + .affineAnims = sRazorWindTornadoAffineAnimTable, .callback = AnimRazorWindTornado, }; -static const union AnimCmd gViceGripAnimCmds1[] = +static const union AnimCmd sViceGripAnimCmds1[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -428,7 +428,7 @@ static const union AnimCmd gViceGripAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gViceGripAnimCmds2[] = +static const union AnimCmd sViceGripAnimCmds2[] = { ANIMCMD_FRAME(0, 3, .vFlip = TRUE, .hFlip = TRUE), ANIMCMD_FRAME(16, 3, .vFlip = TRUE, .hFlip = TRUE), @@ -436,10 +436,10 @@ static const union AnimCmd gViceGripAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd *const gViceGripAnimTable[] = +static const union AnimCmd *const sViceGripAnimTable[] = { - gViceGripAnimCmds1, - gViceGripAnimCmds2, + sViceGripAnimCmds1, + sViceGripAnimCmds2, }; const struct SpriteTemplate gViceGripSpriteTemplate = @@ -447,13 +447,13 @@ const struct SpriteTemplate gViceGripSpriteTemplate = .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, .oam = &gOamData_AffineOff_ObjBlend_32x32, - .anims = gViceGripAnimTable, + .anims = sViceGripAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimViceGripPincer, }; -static const union AnimCmd gGuillotineAnimCmds1[] = +static const union AnimCmd sGuillotineAnimCmds1[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(16, 2), @@ -461,7 +461,7 @@ static const union AnimCmd gGuillotineAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gGuillotineAnimCmds2[] = +static const union AnimCmd sGuillotineAnimCmds2[] = { ANIMCMD_FRAME(0, 2, .vFlip = TRUE, .hFlip = TRUE), ANIMCMD_FRAME(16, 2, .vFlip = TRUE, .hFlip = TRUE), @@ -469,10 +469,10 @@ static const union AnimCmd gGuillotineAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd *const gGuillotineAnimTable[] = +static const union AnimCmd *const sGuillotineAnimTable[] = { - gGuillotineAnimCmds1, - gGuillotineAnimCmds2, + sGuillotineAnimCmds1, + sGuillotineAnimCmds2, }; const struct SpriteTemplate gGuillotineSpriteTemplate = @@ -480,13 +480,13 @@ const struct SpriteTemplate gGuillotineSpriteTemplate = .tileTag = ANIM_TAG_CUT, .paletteTag = ANIM_TAG_CUT, .oam = &gOamData_AffineOff_ObjBlend_32x32, - .anims = gGuillotineAnimTable, + .anims = sGuillotineAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimGuillotinePincer, }; -static const union AffineAnimCmd gSplashEffectAffineAnimCmds[] = +static const union AffineAnimCmd sSplashEffectAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-6, 4, 0, 8), AFFINEANIMCMD_FRAME(10, -10, 0, 8), @@ -494,7 +494,7 @@ static const union AffineAnimCmd gSplashEffectAffineAnimCmds[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gGrowAndShrinkAffineAnimCmds[] = +static const union AffineAnimCmd sGrowAndShrinkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-4, -5, 0, 12), AFFINEANIMCMD_FRAME(0, 0, 0, 24), @@ -502,7 +502,7 @@ static const union AffineAnimCmd gGrowAndShrinkAffineAnimCmds[] = AFFINEANIMCMD_END, }; -static const union AnimCmd gBreathPuffAnimCmds1[] = +static const union AnimCmd sBreathPuffAnimCmds1[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(4, 40, .hFlip = TRUE), @@ -511,7 +511,7 @@ static const union AnimCmd gBreathPuffAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gBreathPuffAnimCmds2[] = +static const union AnimCmd sBreathPuffAnimCmds2[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 40), @@ -520,10 +520,10 @@ static const union AnimCmd gBreathPuffAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd *const gBreathPuffAnimTable[] = +static const union AnimCmd *const sBreathPuffAnimTable[] = { - gBreathPuffAnimCmds1, - gBreathPuffAnimCmds2, + sBreathPuffAnimCmds1, + sBreathPuffAnimCmds2, }; const struct SpriteTemplate gBreathPuffSpriteTemplate = @@ -531,22 +531,22 @@ const struct SpriteTemplate gBreathPuffSpriteTemplate = .tileTag = ANIM_TAG_BREATH, .paletteTag = ANIM_TAG_BREATH, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gBreathPuffAnimTable, + .anims = sBreathPuffAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimBreathPuff, }; -static const union AffineAnimCmd gAngerMarkAffineAnimCmds[] = +static const union AffineAnimCmd sAngerMarkAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(11, 11, 0, 8), AFFINEANIMCMD_FRAME(-11, -11, 0, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gAngerMarkAffineAnimTable[] = +static const union AffineAnimCmd *const sAngerMarkAffineAnimTable[] = { - gAngerMarkAffineAnimCmds, + sAngerMarkAffineAnimCmds, }; const struct SpriteTemplate gAngerMarkSpriteTemplate = @@ -556,11 +556,11 @@ const struct SpriteTemplate gAngerMarkSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gAngerMarkAffineAnimTable, + .affineAnims = sAngerMarkAffineAnimTable, .callback = AnimAngerMark, }; -static const union AffineAnimCmd gThrashMoveMonAffineAnimCmds[] = +static const union AffineAnimCmd sThrashMoveMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-10, 9, 0, 7), AFFINEANIMCMD_FRAME(20, -20, 0, 7), @@ -592,7 +592,7 @@ const struct SpriteTemplate gSnoreZSpriteTemplate = .callback = AnimSnoreZ, }; -static const union AnimCmd gExplosionAnimCmds[] = +static const union AnimCmd sExplosionAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(16, 5), @@ -601,9 +601,9 @@ static const union AnimCmd gExplosionAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gExplosionAnimTable[] = +static const union AnimCmd *const sExplosionAnimTable[] = { - gExplosionAnimCmds, + sExplosionAnimCmds, }; const struct SpriteTemplate gExplosionSpriteTemplate = @@ -611,13 +611,13 @@ const struct SpriteTemplate gExplosionSpriteTemplate = .tileTag = ANIM_TAG_EXPLOSION, .paletteTag = ANIM_TAG_EXPLOSION, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gExplosionAnimTable, + .anims = sExplosionAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSpriteOnMonPos, }; -static const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds1[] = +static const union AffineAnimCmd sSoftBoiledEggAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, -8, 2), AFFINEANIMCMD_FRAME(0, 0, 8, 4), @@ -625,13 +625,13 @@ static const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds2[] = +static const union AffineAnimCmd sSoftBoiledEggAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = +static const union AffineAnimCmd sSoftBoiledEggAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(-8, 4, 0, 8), AFFINEANIMCMD_LOOP(0), @@ -643,11 +643,11 @@ static const union AffineAnimCmd gSoftBoiledEggAffineAnimCmds3[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gSoftBoiledEggAffineAnimTable[] = +static const union AffineAnimCmd *const sSoftBoiledEggAffineAnimTable[] = { - gSoftBoiledEggAffineAnimCmds1, - gSoftBoiledEggAffineAnimCmds2, - gSoftBoiledEggAffineAnimCmds3, + sSoftBoiledEggAffineAnimCmds1, + sSoftBoiledEggAffineAnimCmds2, + sSoftBoiledEggAffineAnimCmds3, }; const struct SpriteTemplate gSoftBoiledEggSpriteTemplate = @@ -657,40 +657,40 @@ const struct SpriteTemplate gSoftBoiledEggSpriteTemplate = .oam = &gOamData_AffineDouble_ObjBlend_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSoftBoiledEggAffineAnimTable, + .affineAnims = sSoftBoiledEggAffineAnimTable, .callback = AnimSoftBoiledEgg, }; -static const union AffineAnimCmd gThinRingExpandingAffineAnimCmds1[] = +static const union AffineAnimCmd sThinRingExpandingAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_FRAME(16, 16, 0, 30), AFFINEANIMCMD_END_ALT(1), }; -static const union AffineAnimCmd gThinRingExpandingAffineAnimCmds2[] = +static const union AffineAnimCmd sThinRingExpandingAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_FRAME(32, 32, 0, 15), AFFINEANIMCMD_END_ALT(1), }; -static const union AffineAnimCmd gHyperVoiceRingAffineAnimCmds[] = +static const union AffineAnimCmd sHyperVoiceRingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_FRAME(11, 11, 0, 45), AFFINEANIMCMD_END_ALT(1), }; -static const union AffineAnimCmd *const gThinRingExpandingAffineAnimTable[] = +static const union AffineAnimCmd *const sThinRingExpandingAffineAnimTable[] = { - gThinRingExpandingAffineAnimCmds1, - gThinRingExpandingAffineAnimCmds2, + sThinRingExpandingAffineAnimCmds1, + sThinRingExpandingAffineAnimCmds2, }; -static const union AffineAnimCmd *const gHyperVoiceRingAffineAnimTable[] = +static const union AffineAnimCmd *const sHyperVoiceRingAffineAnimTable[] = { - gHyperVoiceRingAffineAnimCmds, + sHyperVoiceRingAffineAnimCmds, }; const struct SpriteTemplate gThinRingExpandingSpriteTemplate = @@ -700,20 +700,20 @@ const struct SpriteTemplate gThinRingExpandingSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gThinRingExpandingAffineAnimTable, + .affineAnims = sThinRingExpandingAffineAnimTable, .callback = AnimSpriteOnMonPos, }; -static const union AffineAnimCmd gThinRingShrinkingAffineAnimCmds[] = +static const union AffineAnimCmd sThinRingShrinkingAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(512, 512, 0, 0), AFFINEANIMCMD_FRAME(-16, -16, 0, 30), AFFINEANIMCMD_END_ALT(1), }; -static const union AffineAnimCmd *const gThinRingShrinkingAffineAnimTable[] = +static const union AffineAnimCmd *const sThinRingShrinkingAffineAnimTable[] = { - gThinRingShrinkingAffineAnimCmds, + sThinRingShrinkingAffineAnimCmds, }; const struct SpriteTemplate gThinRingShrinkingSpriteTemplate = @@ -723,7 +723,7 @@ const struct SpriteTemplate gThinRingShrinkingSpriteTemplate = .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gThinRingShrinkingAffineAnimTable, + .affineAnims = sThinRingShrinkingAffineAnimTable, .callback = AnimSpriteOnMonPos, }; @@ -734,7 +734,7 @@ const struct SpriteTemplate gBlendThinRingExpandingSpriteTemplate = .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gThinRingExpandingAffineAnimTable, + .affineAnims = sThinRingExpandingAffineAnimTable, .callback = AnimBlendThinRing, }; @@ -745,7 +745,7 @@ const struct SpriteTemplate gHyperVoiceRingSpriteTemplate = .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gHyperVoiceRingAffineAnimTable, + .affineAnims = sHyperVoiceRingAffineAnimTable, .callback = AnimHyperVoiceRing, }; @@ -756,17 +756,17 @@ const struct SpriteTemplate gUproarRingSpriteTemplate = .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gThinRingExpandingAffineAnimTable, + .affineAnims = sThinRingExpandingAffineAnimTable, .callback = AnimUproarRing, }; -static const union AffineAnimCmd gStretchAttackerAffineAnimCmds[] = +static const union AffineAnimCmd sStretchAttackerAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(96, -13, 0, 8), AFFINEANIMCMD_END, }; -static const union AnimCmd gSpeedDustAnimCmds[] = +static const union AnimCmd sSpeedDustAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(4, 3), @@ -776,9 +776,9 @@ static const union AnimCmd gSpeedDustAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gSpeedDustAnimTable[] = +static const union AnimCmd *const sSpeedDustAnimTable[] = { - gSpeedDustAnimCmds, + sSpeedDustAnimCmds, }; const struct SpriteTemplate gSpeedDustSpriteTemplate = @@ -786,13 +786,13 @@ const struct SpriteTemplate gSpeedDustSpriteTemplate = .tileTag = ANIM_TAG_SPEED_DUST, .paletteTag = ANIM_TAG_SPEED_DUST, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gSpeedDustAnimTable, + .anims = sSpeedDustAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSpeedDust, }; -const s8 gSpeedDustPosTable[][2] = +static const s8 sSpeedDustPosTable[][2] = { {30, 28}, {-20, 24}, @@ -800,7 +800,7 @@ const s8 gSpeedDustPosTable[][2] = {-10, 28}, }; -static const union AnimCmd gBellAnimCmds[] = +static const union AnimCmd sBellAnimCmds[] = { ANIMCMD_FRAME(0, 6), ANIMCMD_FRAME(16, 6), @@ -818,9 +818,9 @@ static const union AnimCmd gBellAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gBellAnimTable[] = +static const union AnimCmd *const sBellAnimTable[] = { - gBellAnimCmds, + sBellAnimCmds, }; const struct SpriteTemplate gBellSpriteTemplate = @@ -828,7 +828,7 @@ const struct SpriteTemplate gBellSpriteTemplate = .tileTag = ANIM_TAG_BELL, .paletteTag = ANIM_TAG_BELL, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gBellAnimTable, + .anims = sBellAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSpriteOnMonPos, @@ -863,7 +863,7 @@ const struct SpriteTemplate gMagentaHeartSpriteTemplate = .callback = AnimMagentaHeart, }; -static const union AffineAnimCmd gUnknown_83E4200[] = +static const union AffineAnimCmd sUnknown_83E4200[] = { AFFINEANIMCMD_FRAME(10, -13, 0, 10), AFFINEANIMCMD_FRAME(-10, 13, 0, 10), @@ -903,16 +903,16 @@ const struct SpriteTemplate gRedHeartRisingSpriteTemplate = .callback = AnimRedHeartRising, }; -static const union AffineAnimCmd gHiddenPowerOrbAffineAnimCmds[] = +static const union AffineAnimCmd sHiddenPowerOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(128, 128, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 1), AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd *const gHiddenPowerOrbAffineAnimTable[] = +static const union AffineAnimCmd *const sHiddenPowerOrbAffineAnimTable[] = { - gHiddenPowerOrbAffineAnimCmds, + sHiddenPowerOrbAffineAnimCmds, }; const struct SpriteTemplate gHiddenPowerOrbSpriteTemplate = @@ -922,7 +922,7 @@ const struct SpriteTemplate gHiddenPowerOrbSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gHiddenPowerOrbAffineAnimTable, + .affineAnims = sHiddenPowerOrbAffineAnimTable, .callback = AnimOrbitFast, }; @@ -933,20 +933,20 @@ const struct SpriteTemplate gHiddenPowerOrbScatterSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_16x16, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gHiddenPowerOrbAffineAnimTable, + .affineAnims = sHiddenPowerOrbAffineAnimTable, .callback = AnimOrbitScatter, }; -static const union AffineAnimCmd gSpitUpOrbAffineAnimCmds[] = +static const union AffineAnimCmd sSpitUpOrbAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(128, 128, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 1), AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd *const gSpitUpOrbAffineAnimTable[] = +static const union AffineAnimCmd *const sSpitUpOrbAffineAnimTable[] = { - gSpitUpOrbAffineAnimCmds, + sSpitUpOrbAffineAnimCmds, }; const struct SpriteTemplate gSpitUpOrbSpriteTemplate = @@ -956,11 +956,11 @@ const struct SpriteTemplate gSpitUpOrbSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_8x8, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSpitUpOrbAffineAnimTable, + .affineAnims = sSpitUpOrbAffineAnimTable, .callback = AnimSpitUpOrb, }; -static const union AnimCmd gEyeSparkleAnimCmds[] = +static const union AnimCmd sEyeSparkleAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(4, 4), @@ -970,9 +970,9 @@ static const union AnimCmd gEyeSparkleAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gEyeSparkleAnimTable[] = +static const union AnimCmd *const sEyeSparkleAnimTable[] = { - gEyeSparkleAnimCmds, + sEyeSparkleAnimCmds, }; const struct SpriteTemplate gEyeSparkleSpriteTemplate = @@ -980,21 +980,21 @@ const struct SpriteTemplate gEyeSparkleSpriteTemplate = .tileTag = ANIM_TAG_EYE_SPARKLE, .paletteTag = ANIM_TAG_EYE_SPARKLE, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gEyeSparkleAnimTable, + .anims = sEyeSparkleAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimEyeSparkle, }; -static const union AnimCmd gAngelSpriteAnimCmds[] = +static const union AnimCmd sAngelSpriteAnimCmds[] = { ANIMCMD_FRAME(0, 24), ANIMCMD_END, }; -static const union AnimCmd *const gAngelSpriteAnimTable[] = +static const union AnimCmd *const sAngelSpriteAnimTable[] = { - gAngelSpriteAnimCmds, + sAngelSpriteAnimCmds, }; const struct SpriteTemplate gAngelSpriteTemplate = @@ -1002,7 +1002,7 @@ const struct SpriteTemplate gAngelSpriteTemplate = .tileTag = ANIM_TAG_ANGEL, .paletteTag = ANIM_TAG_ANGEL, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gAngelSpriteAnimTable, + .anims = sAngelSpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimAngel, @@ -1019,22 +1019,22 @@ const struct SpriteTemplate gPinkHeartSpriteTemplate = .callback = AnimPinkHeart, }; -static const union AnimCmd gDevilAnimCmds1[] = +static const union AnimCmd sDevilAnimCmds1[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_JUMP(0), }; -static const union AnimCmd gDevilAnimCmds2[] = +static const union AnimCmd sDevilAnimCmds2[] = { ANIMCMD_FRAME(16, 3), ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gDevilAnimTable[] = +static const union AnimCmd *const sDevilAnimTable[] = { - gDevilAnimCmds1, - gDevilAnimCmds2, + sDevilAnimCmds1, + sDevilAnimCmds2, }; const struct SpriteTemplate gDevilSpriteTemplate = @@ -1042,13 +1042,13 @@ const struct SpriteTemplate gDevilSpriteTemplate = .tileTag = ANIM_TAG_DEVIL, .paletteTag = ANIM_TAG_DEVIL, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gDevilAnimTable, + .anims = sDevilAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimDevil, }; -static const union AnimCmd gUnknown_08593B08[] = +static const union AnimCmd sFurySwipesAnimCmd1[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -1057,7 +1057,7 @@ static const union AnimCmd gUnknown_08593B08[] = ANIMCMD_END, }; -static const union AnimCmd gUnknown_08593B1C[] = +static const union AnimCmd sFurySwipesAnimCmd2[] = { ANIMCMD_FRAME(0, 4, .hFlip = TRUE), ANIMCMD_FRAME(16, 4, .hFlip = TRUE), @@ -1066,10 +1066,10 @@ static const union AnimCmd gUnknown_08593B1C[] = ANIMCMD_END, }; -static const union AnimCmd *const gFurySwipesAnimTable[] = +static const union AnimCmd *const sFurySwipesAnimTable[] = { - gUnknown_08593B08, - gUnknown_08593B1C, + sFurySwipesAnimCmd1, + sFurySwipesAnimCmd2, }; const struct SpriteTemplate gFurySwipesSpriteTemplate = @@ -1077,13 +1077,13 @@ const struct SpriteTemplate gFurySwipesSpriteTemplate = .tileTag = ANIM_TAG_SWIPE, .paletteTag = ANIM_TAG_SWIPE, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gFurySwipesAnimTable, + .anims = sFurySwipesAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimFurySwipes, }; -static const union AnimCmd gMovementWavesAnimCmds1[] = +static const union AnimCmd sMovementWavesAnimCmds1[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(16, 8), @@ -1092,7 +1092,7 @@ static const union AnimCmd gMovementWavesAnimCmds1[] = ANIMCMD_END, }; -static const union AnimCmd gMovementWavesAnimCmds2[] = +static const union AnimCmd sMovementWavesAnimCmds2[] = { ANIMCMD_FRAME(16, 8, .hFlip = TRUE), ANIMCMD_FRAME(32, 8, .hFlip = TRUE), @@ -1101,10 +1101,10 @@ static const union AnimCmd gMovementWavesAnimCmds2[] = ANIMCMD_END, }; -static const union AnimCmd *const gMovementWavesAnimTable[] = +static const union AnimCmd *const sMovementWavesAnimTable[] = { - gMovementWavesAnimCmds1, - gMovementWavesAnimCmds2, + sMovementWavesAnimCmds1, + sMovementWavesAnimCmds2, }; const struct SpriteTemplate gMovementWavesSpriteTemplate = @@ -1112,13 +1112,13 @@ const struct SpriteTemplate gMovementWavesSpriteTemplate = .tileTag = ANIM_TAG_MOVEMENT_WAVES, .paletteTag = ANIM_TAG_MOVEMENT_WAVES, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gMovementWavesAnimTable, + .anims = sMovementWavesAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimMovementWaves, }; -static const union AffineAnimCmd gUnknown_08593B98[] = +static const union AffineAnimCmd sUproarAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-12, 8, 0, 4), AFFINEANIMCMD_FRAME(20, -20, 0, 4), @@ -1137,29 +1137,29 @@ const struct SpriteTemplate gJaggedMusicNoteSpriteTemplate = .callback = AnimJaggedMusicNote, }; -static const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds1[] = +static const union AffineAnimCmd sPerishSongMusicNoteAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, 0, 5), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds2[] = +static const union AffineAnimCmd sPerishSongMusicNoteAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0, 0, -8, 16), AFFINEANIMCMD_END_ALT(1), }; -static const union AffineAnimCmd gPerishSongMusicNoteAffineAnimCmds3[] = +static const union AffineAnimCmd sPerishSongMusicNoteAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(0, 0, 8, 16), AFFINEANIMCMD_END_ALT(1), }; -static const union AffineAnimCmd *const gPerishSongMusicNoteAffineAnimTable[] = +static const union AffineAnimCmd *const sPerishSongMusicNoteAffineAnimTable[] = { - gPerishSongMusicNoteAffineAnimCmds1, - gPerishSongMusicNoteAffineAnimCmds2, - gPerishSongMusicNoteAffineAnimCmds3, + sPerishSongMusicNoteAffineAnimCmds1, + sPerishSongMusicNoteAffineAnimCmds2, + sPerishSongMusicNoteAffineAnimCmds3, }; const struct SpriteTemplate gPerishSongMusicNoteSpriteTemplate = @@ -1169,7 +1169,7 @@ const struct SpriteTemplate gPerishSongMusicNoteSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gMusicNotesAnimTable, .images = NULL, - .affineAnims = gPerishSongMusicNoteAffineAnimTable, + .affineAnims = sPerishSongMusicNoteAffineAnimTable, .callback = AnimPerishSongMusicNote, }; @@ -1180,26 +1180,26 @@ const struct SpriteTemplate gPerishSongMusicNote2SpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_16x16, .anims = gMusicNotesAnimTable, .images = NULL, - .affineAnims = gPerishSongMusicNoteAffineAnimTable, + .affineAnims = sPerishSongMusicNoteAffineAnimTable, .callback = AnimPerishSongMusicNote2, }; -static const union AffineAnimCmd gGuardRingAffineAnimCmds1[] = +static const union AffineAnimCmd sGuardRingAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gGuardRingAffineAnimCmds2[] = +static const union AffineAnimCmd sGuardRingAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(512, 256, 0, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gGuardRingAffineAnimTable[] = +static const union AffineAnimCmd *const sGuardRingAffineAnimTable[] = { - gGuardRingAffineAnimCmds1, - gGuardRingAffineAnimCmds2, + sGuardRingAffineAnimCmds1, + sGuardRingAffineAnimCmds2, }; const struct SpriteTemplate gGuardRingSpriteTemplate = @@ -1209,7 +1209,7 @@ const struct SpriteTemplate gGuardRingSpriteTemplate = .oam = &gOamData_AffineDouble_ObjBlend_64x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gGuardRingAffineAnimTable, + .affineAnims = sGuardRingAffineAnimTable, .callback = AnimGuardRing, }; @@ -1699,7 +1699,7 @@ void AnimTask_AirCutterProjectile(u8 taskId) void sub_80A79E8(struct Sprite *sprite) { InitSpritePosToAnimAttacker(sprite, FALSE); - sprite->data[0] = 0x100 + (IndexOfSpritePaletteTag(gUnknown_83E3D18.paletteTag) << 4); + sprite->data[0] = 0x100 + (IndexOfSpritePaletteTag(sUnknown_83E3D18.paletteTag) << 4); sprite->callback = sub_80A7A18; } @@ -2129,7 +2129,7 @@ void AnimTask_Splash(u8 taskId) task->data[2] = gBattleAnimArgs[1]; task->data[3] = 0; task->data[4] = 0; - PrepareAffineAnimInTaskData(task, spriteId, gSplashEffectAffineAnimCmds); + PrepareAffineAnimInTaskData(task, spriteId, sSplashEffectAffineAnimCmds); task->func = AnimTask_SplashStep; } } @@ -2178,7 +2178,7 @@ static void AnimTask_SplashStep(u8 taskId) } else { - PrepareAffineAnimInTaskData(task, task->data[0], gSplashEffectAffineAnimCmds); + PrepareAffineAnimInTaskData(task, task->data[0], sSplashEffectAffineAnimCmds); task->data[1] = 0; } } @@ -2194,7 +2194,7 @@ void AnimTask_GrowAndShrink(u8 taskId) struct Task* task = &gTasks[taskId]; u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); - PrepareAffineAnimInTaskData(task, spriteId, gGrowAndShrinkAffineAnimCmds); + PrepareAffineAnimInTaskData(task, spriteId, sGrowAndShrinkAffineAnimCmds); task->func = AnimTask_GrowAndShrinkStep; } @@ -2266,7 +2266,7 @@ void AnimTask_ThrashMoveMonHorizontal(u8 taskId) task->data[0] = spriteId; task->data[1] = 0; - PrepareAffineAnimInTaskData(task, spriteId, gThrashMoveMonAffineAnimCmds); + PrepareAffineAnimInTaskData(task, spriteId, sThrashMoveMonAffineAnimCmds); task->func = ThrashMoveMonStep; } @@ -2761,7 +2761,7 @@ void AnimTask_StretchAttacker(u8 taskId) u8 spriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER); task->data[0] = spriteId; - PrepareAffineAnimInTaskData(task, spriteId, gStretchAttackerAffineAnimCmds); + PrepareAffineAnimInTaskData(task, spriteId, sStretchAttackerAffineAnimCmds); task->func = StretchAttacker_Step; } @@ -2958,8 +2958,8 @@ static void SpeedDust_Step1(u8 taskId) { gSprites[spriteId].data[0] = taskId; gSprites[spriteId].data[1] = 13; - gSprites[spriteId].pos2.x = gSpeedDustPosTable[task->data[2]][0]; - gSprites[spriteId].pos2.y = gSpeedDustPosTable[task->data[2]][1]; + gSprites[spriteId].pos2.x = sSpeedDustPosTable[task->data[2]][0]; + gSprites[spriteId].pos2.y = sSpeedDustPosTable[task->data[2]][1]; task->data[13]++; if (++task->data[2] > 3) { @@ -3111,7 +3111,7 @@ void sub_80A9A20(u8 taskId) if (++gTasks[taskId].data[0] == 1) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_TARGET), gUnknown_83E4200); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_TARGET), sUnknown_83E4200); gSprites[spriteId].pos2.x = 4; } else @@ -3132,7 +3132,7 @@ void sub_80A9AB0(u8 taskId) if (++gTasks[taskId].data[0] == 1) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gUnknown_83E4200); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), sUnknown_83E4200); gSprites[spriteId].pos2.x = 4; } else @@ -3648,7 +3648,7 @@ void AnimTask_UproarDistortion(u8 taskId) { u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); - PrepareAffineAnimInTaskData(&gTasks[taskId], spriteId, gUnknown_08593B98); + PrepareAffineAnimInTaskData(&gTasks[taskId], spriteId, sUproarAffineAnimCmds); gTasks[taskId].func = UproarDistortion_Step; } diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index cb2f8b78e..69bae2c6f 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -79,7 +79,7 @@ static void AnimRecycleStep(struct Sprite *); static void AnimTask_SlackOffSquishStep(u8); // Data -static const union AnimCmd gScratchAnimCmds[] = +static const union AnimCmd sScratchAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(16, 4), @@ -89,9 +89,9 @@ static const union AnimCmd gScratchAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gScratchAnimTable[] = +static const union AnimCmd *const sScratchAnimTable[] = { - gScratchAnimCmds, + sScratchAnimCmds, }; const struct SpriteTemplate gScratchSpriteTemplate = @@ -99,7 +99,7 @@ const struct SpriteTemplate gScratchSpriteTemplate = .tileTag = ANIM_TAG_SCRATCH, .paletteTag = ANIM_TAG_SCRATCH, .oam = &gOamData_AffineOff_ObjBlend_32x32, - .anims = gScratchAnimTable, + .anims = sScratchAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSpriteOnMonPos, @@ -127,7 +127,7 @@ const struct SpriteTemplate gBlackBallSpriteTemplate = .callback = AnimThrowProjectile, }; -static const union AnimCmd gOpeningEyeAnimCmds[] = +static const union AnimCmd sOpeningEyeAnimCmds[] = { ANIMCMD_FRAME(0, 40), ANIMCMD_FRAME(16, 8), @@ -135,9 +135,9 @@ static const union AnimCmd gOpeningEyeAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gOpeningEyeAnimTable[] = +static const union AnimCmd *const sOpeningEyeAnimTable[] = { - gOpeningEyeAnimCmds, + sOpeningEyeAnimCmds, }; const struct SpriteTemplate gOpeningEyeSpriteTemplate = @@ -145,7 +145,7 @@ const struct SpriteTemplate gOpeningEyeSpriteTemplate = .tileTag = ANIM_TAG_OPENING_EYE, .paletteTag = ANIM_TAG_OPENING_EYE, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gOpeningEyeAnimTable, + .anims = sOpeningEyeAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSpriteOnMonPos, @@ -173,7 +173,7 @@ const struct SpriteTemplate gTealAlertSpriteTemplate = .callback = AnimTealAlert, }; -static const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = +static const union AffineAnimCmd sMeanLookEyeAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x180, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x20, 0x18, 0, 5), @@ -181,17 +181,17 @@ static const union AffineAnimCmd gMeanLookEyeAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(1), }; -static const union AffineAnimCmd gMeanLookEyeAffineAnimCmds2[] = +static const union AffineAnimCmd sMeanLookEyeAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x30, 0x30, 0, 0), AFFINEANIMCMD_FRAME(0x20, 0x20, 0, 6), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gMeanLookEyeAffineAnimTable[] = +static const union AffineAnimCmd *const sMeanLookEyeAffineAnimTable[] = { - gMeanLookEyeAffineAnimCmds1, - gMeanLookEyeAffineAnimCmds2, + sMeanLookEyeAffineAnimCmds1, + sMeanLookEyeAffineAnimCmds2, }; const struct SpriteTemplate gMeanLookEyeSpriteTemplate = @@ -201,7 +201,7 @@ const struct SpriteTemplate gMeanLookEyeSpriteTemplate = .oam = &gOamData_AffineDouble_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gMeanLookEyeAffineAnimTable, + .affineAnims = sMeanLookEyeAffineAnimTable, .callback = AnimMeanLookEye, }; @@ -216,7 +216,7 @@ const struct SpriteTemplate gSpikesSpriteTemplate = .callback = AnimSpikes, }; -static const union AnimCmd gLeerAnimCmds[] = +static const union AnimCmd sLeerAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -226,9 +226,9 @@ static const union AnimCmd gLeerAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gLeerAnimTable[] = +static const union AnimCmd *const sLeerAnimTable[] = { - gLeerAnimCmds, + sLeerAnimCmds, }; const struct SpriteTemplate gLeerSpriteTemplate = @@ -236,33 +236,33 @@ const struct SpriteTemplate gLeerSpriteTemplate = .tileTag = ANIM_TAG_LEER, .paletteTag = ANIM_TAG_LEER, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gLeerAnimTable, + .anims = sLeerAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimLeer, }; -static const union AnimCmd gLetterZAnimCmds[] = +static const union AnimCmd sLetterZAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_END, }; -static const union AnimCmd *const gLetterZAnimTable[] = +static const union AnimCmd *const sLetterZAnimTable[] = { - gLetterZAnimCmds, + sLetterZAnimCmds, }; -static const union AffineAnimCmd gLetterZAffineAnimCmds[] = +static const union AffineAnimCmd sLetterZAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-7, -7, -3, 16), AFFINEANIMCMD_FRAME(7, 7, 3, 16), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gLetterZAffineAnimTable[] = +static const union AffineAnimCmd *const sLetterZAffineAnimTable[] = { - gLetterZAffineAnimCmds, + sLetterZAffineAnimCmds, }; const struct SpriteTemplate gLetterZSpriteTemplate = @@ -270,13 +270,13 @@ const struct SpriteTemplate gLetterZSpriteTemplate = .tileTag = ANIM_TAG_LETTER_Z, .paletteTag = ANIM_TAG_LETTER_Z, .oam = &gOamData_AffineNormal_ObjNormal_32x32, - .anims = gLetterZAnimTable, + .anims = sLetterZAnimTable, .images = NULL, - .affineAnims = gLetterZAffineAnimTable, + .affineAnims = sLetterZAffineAnimTable, .callback = AnimLetterZ, }; -static const union AnimCmd gFangAnimCmds[] = +static const union AnimCmd sFangAnimCmds[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(16, 16), @@ -285,21 +285,21 @@ static const union AnimCmd gFangAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gFangAnimTable[] = +static const union AnimCmd *const sFangAnimTable[] = { - gFangAnimCmds, + sFangAnimCmds, }; -static const union AffineAnimCmd gFangAffineAnimCmds[] = +static const union AffineAnimCmd sFangAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0x200, 0x200, 0, 0), AFFINEANIMCMD_FRAME(-0x20, -0x20, 0, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gFangAffineAnimTable[] = +static const union AffineAnimCmd *const sFangAffineAnimTable[] = { - gFangAffineAnimCmds, + sFangAffineAnimCmds, }; const struct SpriteTemplate gFangSpriteTemplate = @@ -307,30 +307,30 @@ const struct SpriteTemplate gFangSpriteTemplate = .tileTag = ANIM_TAG_FANG_ATTACK, .paletteTag = ANIM_TAG_FANG_ATTACK, .oam = &gOamData_AffineDouble_ObjNormal_32x32, - .anims = gFangAnimTable, + .anims = sFangAnimTable, .images = NULL, - .affineAnims = gFangAffineAnimTable, + .affineAnims = sFangAffineAnimTable, .callback = AnimFang, }; -static const union AffineAnimCmd gSpotlightAffineAnimCmds1[] = +static const union AffineAnimCmd sSpotlightAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x0, 0x180, 0, 0), AFFINEANIMCMD_FRAME(0x10, 0x0, 0, 20), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gSpotlightAffineAnimCmds2[] = +static const union AffineAnimCmd sSpotlightAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x140, 0x180, 0, 0), AFFINEANIMCMD_FRAME(-0x10, 0x0, 0, 19), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gSpotlightAffineAnimTable[] = +static const union AffineAnimCmd *const sSpotlightAffineAnimTable[] = { - gSpotlightAffineAnimCmds1, - gSpotlightAffineAnimCmds2, + sSpotlightAffineAnimCmds1, + sSpotlightAffineAnimCmds2, }; const struct SpriteTemplate gSpotlightSpriteTemplate = @@ -340,7 +340,7 @@ const struct SpriteTemplate gSpotlightSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSpotlightAffineAnimTable, + .affineAnims = sSpotlightAffineAnimTable, .callback = AnimSpotlight, }; @@ -366,7 +366,7 @@ const struct SpriteTemplate gClappingHand2SpriteTemplate = .callback = AnimClappingHand2, }; -static const union AnimCmd gRapidSpinAnimCmds[] = +static const union AnimCmd sRapidSpinAnimCmds[] = { ANIMCMD_FRAME(0, 2), ANIMCMD_FRAME(8, 2), @@ -374,9 +374,9 @@ static const union AnimCmd gRapidSpinAnimCmds[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gRapidSpinAnimTable[] = +static const union AnimCmd *const sRapidSpinAnimTable[] = { - gRapidSpinAnimCmds, + sRapidSpinAnimCmds, }; const struct SpriteTemplate gRapidSpinSpriteTemplate = @@ -384,13 +384,13 @@ const struct SpriteTemplate gRapidSpinSpriteTemplate = .tileTag = ANIM_TAG_RAPID_SPIN, .paletteTag = ANIM_TAG_RAPID_SPIN, .oam = &gOamData_AffineOff_ObjNormal_32x16, - .anims = gRapidSpinAnimTable, + .anims = sRapidSpinAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimRapidSpin, }; -static const union AffineAnimCmd gUnknown_83FF080[] = +static const union AffineAnimCmd sUnknown_83FF080[] = { AFFINEANIMCMD_FRAME(-12, 8, 0, 4), AFFINEANIMCMD_FRAME(20, -20, 0, 4), @@ -398,18 +398,18 @@ static const union AffineAnimCmd gUnknown_83FF080[] = AFFINEANIMCMD_END, }; -static const union AnimCmd gTriAttackTriangleAnimCmds[] = +static const union AnimCmd sTriAttackTriangleAnimCmds[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -static const union AnimCmd *const gTriAttackTriangleAnimTable[] = +static const union AnimCmd *const sTriAttackTriangleAnimTable[] = { - gTriAttackTriangleAnimCmds, + sTriAttackTriangleAnimCmds, }; -static const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = +static const union AffineAnimCmd sTriAttackTriangleAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, 5, 40), AFFINEANIMCMD_FRAME(0, 0, 10, 10), @@ -418,9 +418,9 @@ static const union AffineAnimCmd gTriAttackTriangleAffineAnimCmds[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gTriAttackTriangleAffineAnimTable[] = +static const union AffineAnimCmd *const sTriAttackTriangleAffineAnimTable[] = { - gTriAttackTriangleAffineAnimCmds, + sTriAttackTriangleAffineAnimCmds, }; const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = @@ -428,13 +428,13 @@ const struct SpriteTemplate gTriAttackTriangleSpriteTemplate = .tileTag = ANIM_TAG_TRI_FORCE_TRIANGLE, .paletteTag = ANIM_TAG_TRI_FORCE_TRIANGLE, .oam = &gOamData_AffineDouble_ObjNormal_64x64, - .anims = gTriAttackTriangleAnimTable, + .anims = sTriAttackTriangleAnimTable, .images = NULL, - .affineAnims = gTriAttackTriangleAffineAnimTable, + .affineAnims = sTriAttackTriangleAffineAnimTable, .callback = AnimTriAttackTriangle, }; -static const union AnimCmd gEclipsingOrbAnimCmds[] = +static const union AnimCmd sEclipsingOrbAnimCmds[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -447,9 +447,9 @@ static const union AnimCmd gEclipsingOrbAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gEclipsingOrbAnimTable[] = +static const union AnimCmd *const sEclipsingOrbAnimTable[] = { - gEclipsingOrbAnimCmds, + sEclipsingOrbAnimCmds, }; const struct SpriteTemplate gEclipsingOrbSpriteTemplate = @@ -457,7 +457,7 @@ const struct SpriteTemplate gEclipsingOrbSpriteTemplate = .tileTag = ANIM_TAG_ECLIPSING_ORB, .paletteTag = ANIM_TAG_ECLIPSING_ORB, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gEclipsingOrbAnimTable, + .anims = sEclipsingOrbAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSpriteOnMonPos, @@ -504,7 +504,7 @@ const struct SpriteTemplate gMiniTwinklingStarSpriteTemplate = .callback = AnimMiniTwinklingStar, }; -static const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = +static const union AffineAnimCmd sStockpileDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(8, -8, 0, 12), AFFINEANIMCMD_FRAME(-16, 16, 0, 12), @@ -513,7 +513,7 @@ static const union AffineAnimCmd gStockpileDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gSpitUpDeformMonAffineAnimCmds[] = +static const union AffineAnimCmd sSpitUpDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -535,7 +535,7 @@ const struct SpriteTemplate gSwallowBlueOrbSpriteTemplate = .callback = AnimSwallowBlueOrb, }; -static const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = +static const union AffineAnimCmd sSwallowDeformMonAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 6, 0, 20), AFFINEANIMCMD_FRAME(0, 0, 0, 20), @@ -545,7 +545,7 @@ static const union AffineAnimCmd gSwallowDeformMonAffineAnimCmds[] = AFFINEANIMCMD_END, }; -const s8 gMorningSunLightBeamCoordsTable[] = +static const s8 sMorningSunLightBeamCoordsTable[] = { 0xE8, 0x18, @@ -553,30 +553,30 @@ const s8 gMorningSunLightBeamCoordsTable[] = 0x00, }; -static const union AnimCmd gGreenStarAnimCmds1[] = +static const union AnimCmd sGreenStarAnimCmds1[] = { ANIMCMD_FRAME(0, 6), ANIMCMD_FRAME(4, 6), ANIMCMD_JUMP(0), }; -static const union AnimCmd gGreenStarAnimCmds2[] = +static const union AnimCmd sGreenStarAnimCmds2[] = { ANIMCMD_FRAME(8, 6), ANIMCMD_END, }; -static const union AnimCmd gGreenStarAnimCmds3[] = +static const union AnimCmd sGreenStarAnimCmds3[] = { ANIMCMD_FRAME(12, 6), ANIMCMD_END, }; -static const union AnimCmd *const gGreenStarAnimTable[] = +static const union AnimCmd *const sGreenStarAnimTable[] = { - gGreenStarAnimCmds1, - gGreenStarAnimCmds2, - gGreenStarAnimCmds3, + sGreenStarAnimCmds1, + sGreenStarAnimCmds2, + sGreenStarAnimCmds3, }; const struct SpriteTemplate gGreenStarSpriteTemplate = @@ -584,13 +584,13 @@ const struct SpriteTemplate gGreenStarSpriteTemplate = .tileTag = ANIM_TAG_GREEN_STAR, .paletteTag = ANIM_TAG_GREEN_STAR, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gGreenStarAnimTable, + .anims = sGreenStarAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimGreenStar, }; -const s8 gDoomDesireLightBeamCoordTable[] = +static const s8 sDoomDesireLightBeamCoordTable[] = { 0x78, 0x50, @@ -598,7 +598,7 @@ const s8 gDoomDesireLightBeamCoordTable[] = 0x00, }; -const u8 gDoomDesireLightBeamDelayTable[] = +static const u8 sDoomDesireLightBeamDelayTable[] = { 0, 0, @@ -607,7 +607,7 @@ const u8 gDoomDesireLightBeamDelayTable[] = 50, }; -static const union AffineAnimCmd gStrongFrustrationAffineAnimCmds[] = +static const union AffineAnimCmd sStrongFrustrationAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, -15, 0, 7), AFFINEANIMCMD_FRAME(0, 15, 0, 7), @@ -626,7 +626,7 @@ const struct SpriteTemplate gWeakFrustrationAngerMarkSpriteTemplate = .callback = AnimWeakFrustrationAngerMark, }; -static const union AnimCmd gSweetScentPetalAnimCmds1[] = +static const union AnimCmd sSweetScentPetalAnimCmds1[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_FRAME(1, 8), @@ -639,7 +639,7 @@ static const union AnimCmd gSweetScentPetalAnimCmds1[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd gSweetScentPetalAnimCmds2[] = +static const union AnimCmd sSweetScentPetalAnimCmds2[] = { ANIMCMD_FRAME(0, 8, .hFlip = TRUE), ANIMCMD_FRAME(1, 8, .hFlip = TRUE), @@ -652,17 +652,17 @@ static const union AnimCmd gSweetScentPetalAnimCmds2[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd gSweetScentPetalAnimCmds3[] = +static const union AnimCmd sSweetScentPetalAnimCmds3[] = { ANIMCMD_FRAME(0, 8), ANIMCMD_END, }; -static const union AnimCmd *const gSweetScentPetalAnimCmdTable[] = +static const union AnimCmd *const sSweetScentPetalAnimCmdTable[] = { - gSweetScentPetalAnimCmds1, - gSweetScentPetalAnimCmds2, - gSweetScentPetalAnimCmds3, + sSweetScentPetalAnimCmds1, + sSweetScentPetalAnimCmds2, + sSweetScentPetalAnimCmds3, }; const struct SpriteTemplate gSweetScentPetalSpriteTemplate = @@ -670,15 +670,15 @@ const struct SpriteTemplate gSweetScentPetalSpriteTemplate = .tileTag = ANIM_TAG_PINK_PETAL, .paletteTag = ANIM_TAG_PINK_PETAL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gSweetScentPetalAnimCmdTable, + .anims = sSweetScentPetalAnimCmdTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimSweetScentPetal, }; -static const u16 gUnknown_83FF33C[] = INCBIN_U16("graphics/battle_anims/unk_83FF33C.gbapal"); //Unused +static const u16 sUnknown_83FF33C[] = INCBIN_U16("graphics/battle_anims/unk_83FF33C.gbapal"); //Unused -static const union AnimCmd gPainSplitAnimCmds[] = +static const union AnimCmd sPainSplitAnimCmds[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_FRAME(4, 9), @@ -686,9 +686,9 @@ static const union AnimCmd gPainSplitAnimCmds[] = ANIMCMD_END, }; -static const union AnimCmd *const gPainSplitAnimCmdTable[] = +static const union AnimCmd *const sPainSplitAnimCmdTable[] = { - gPainSplitAnimCmds, + sPainSplitAnimCmds, }; const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = @@ -696,7 +696,7 @@ const struct SpriteTemplate gPainSplitProjectileSpriteTemplate = .tileTag = ANIM_TAG_PAIN_SPLIT, .paletteTag = ANIM_TAG_PAIN_SPLIT, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gPainSplitAnimCmdTable, + .anims = sPainSplitAnimCmdTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimPainSplitProjectile, @@ -720,7 +720,7 @@ const struct SpriteTemplate gFlatterSpotlightSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSpotlightAffineAnimTable, + .affineAnims = sSpotlightAffineAnimTable, .callback = AnimFlatterSpotlight, }; @@ -735,7 +735,7 @@ const struct SpriteTemplate gReversalOrbSpriteTemplate = .callback = AnimReversalOrb, }; -static const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = +static const union AffineAnimCmd sDeepInhaleAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(16, 0, 0, 4), AFFINEANIMCMD_FRAME(0, -3, 0, 16), @@ -745,7 +745,7 @@ static const union AffineAnimCmd gDeepInhaleAffineAnimCmds[] = AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = +static const union AffineAnimCmd sYawnCloudAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-8, -8, 0, 8), @@ -753,7 +753,7 @@ static const union AffineAnimCmd gYawnCloudAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = +static const union AffineAnimCmd sYawnCloudAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -761,7 +761,7 @@ static const union AffineAnimCmd gYawnCloudAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = +static const union AffineAnimCmd sYawnCloudAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 8), @@ -769,11 +769,11 @@ static const union AffineAnimCmd gYawnCloudAffineAnimCmds3[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gYawnCloudAffineAnimTable[] = +static const union AffineAnimCmd *const sYawnCloudAffineAnimTable[] = { - gYawnCloudAffineAnimCmds1, - gYawnCloudAffineAnimCmds2, - gYawnCloudAffineAnimCmds3, + sYawnCloudAffineAnimCmds1, + sYawnCloudAffineAnimCmds2, + sYawnCloudAffineAnimCmds3, }; const struct SpriteTemplate gYawnCloudSpriteTemplate = @@ -783,11 +783,11 @@ const struct SpriteTemplate gYawnCloudSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gYawnCloudAffineAnimTable, + .affineAnims = sYawnCloudAffineAnimTable, .callback = AnimYawnCloud, }; -static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = +static const union AffineAnimCmd sSmokeBallEscapeCloudAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0), AFFINEANIMCMD_FRAME(-4, -6, 0, 16), @@ -795,7 +795,7 @@ static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds1[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = +static const union AffineAnimCmd sSmokeBallEscapeCloudAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0xC0, 0xC0, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -803,7 +803,7 @@ static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds2[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = +static const union AffineAnimCmd sSmokeBallEscapeCloudAffineAnimCmds3[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(4, 6, 0, 16), @@ -811,7 +811,7 @@ static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds3[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = +static const union AffineAnimCmd sSmokeBallEscapeCloudAffineAnimCmds4[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(8, 10, 0, 30), @@ -819,12 +819,12 @@ static const union AffineAnimCmd gSmokeBallEscapeCloudAffineAnimCmds4[] = AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gSmokeBallEscapeCloudAffineAnimTable[] = +static const union AffineAnimCmd *const sSmokeBallEscapeCloudAffineAnimTable[] = { - gSmokeBallEscapeCloudAffineAnimCmds1, - gSmokeBallEscapeCloudAffineAnimCmds2, - gSmokeBallEscapeCloudAffineAnimCmds3, - gSmokeBallEscapeCloudAffineAnimCmds4, + sSmokeBallEscapeCloudAffineAnimCmds1, + sSmokeBallEscapeCloudAffineAnimCmds2, + sSmokeBallEscapeCloudAffineAnimCmds3, + sSmokeBallEscapeCloudAffineAnimCmds4, }; const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = @@ -834,11 +834,11 @@ const struct SpriteTemplate gSmokeBallEscapeCloudSpriteTemplate = .oam = &gOamData_AffineDouble_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gSmokeBallEscapeCloudAffineAnimTable, + .affineAnims = sSmokeBallEscapeCloudAffineAnimTable, .callback = AnimSmokeBallEscapeCloud, }; -static const union AffineAnimCmd gFacadeSquishAffineAnimCmds[] = +static const union AffineAnimCmd sFacadeSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(-16, 16, 0, 6), AFFINEANIMCMD_FRAME(16, -16, 0, 12), @@ -857,7 +857,7 @@ const struct SpriteTemplate gFacadeSweatDropSpriteTemplate = .callback = AnimFacadeSweatDrop, }; -const u16 gFacadeBlendColors[] = +static const u16 sFacadeBlendColors[] = { RGB(28, 25, 1), RGB(28, 21, 5), @@ -885,24 +885,24 @@ const u16 gFacadeBlendColors[] = RGB(29, 27, 0), }; -static const union AnimCmd gRoarNoiseLineAnimCmds1[] = +static const union AnimCmd sRoarNoiseLineAnimCmds1[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), ANIMCMD_JUMP(0), }; -static const union AnimCmd gRoarNoiseLineAnimCmds2[] = +static const union AnimCmd sRoarNoiseLineAnimCmds2[] = { ANIMCMD_FRAME(32, 3), ANIMCMD_FRAME(48, 3), ANIMCMD_JUMP(0), }; -static const union AnimCmd *const gRoarNoiseLineAnimTable[] = +static const union AnimCmd *const sRoarNoiseLineAnimTable[] = { - gRoarNoiseLineAnimCmds1, - gRoarNoiseLineAnimCmds2, + sRoarNoiseLineAnimCmds1, + sRoarNoiseLineAnimCmds2, }; const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = @@ -910,7 +910,7 @@ const struct SpriteTemplate gRoarNoiseLineSpriteTemplate = .tileTag = ANIM_TAG_NOISE_LINE, .paletteTag = ANIM_TAG_NOISE_LINE, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gRoarNoiseLineAnimTable, + .anims = sRoarNoiseLineAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = AnimRoarNoiseLine, @@ -938,23 +938,23 @@ const struct SpriteTemplate gAssistPawprintSpriteTemplate = .callback = AnimAssistPawprint, }; -static const union AffineAnimCmd gBarrageBallAffineAnimCmds1[] = +static const union AffineAnimCmd sBarrageBallAffineAnimCmds1[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 24), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gBarrageBallAffineAnimCmds2[] = +static const union AffineAnimCmd sBarrageBallAffineAnimCmds2[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 24), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gBarrageBallAffineAnimTable[] = +static const union AffineAnimCmd *const sBarrageBallAffineAnimTable[] = { - gBarrageBallAffineAnimCmds1, - gBarrageBallAffineAnimCmds2, + sBarrageBallAffineAnimCmds1, + sBarrageBallAffineAnimCmds2, }; const struct SpriteTemplate gBarrageBallSpriteTemplate = @@ -964,7 +964,7 @@ const struct SpriteTemplate gBarrageBallSpriteTemplate = .oam = &gOamData_AffineNormal_ObjNormal_32x32, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gBarrageBallAffineAnimTable, + .affineAnims = sBarrageBallAffineAnimTable, .callback = SpriteCallbackDummy, }; @@ -979,7 +979,7 @@ const struct SpriteTemplate gSmellingSaltsHandSpriteTemplate = .callback = AnimSmellingSaltsHand, }; -static const union AffineAnimCmd gSmellingSaltsSquishAffineAnimCmds[] = +static const union AffineAnimCmd sSmellingSaltsSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, -16, 0, 6), AFFINEANIMCMD_FRAME(0, 16, 0, 6), @@ -1063,36 +1063,36 @@ const struct SpriteTemplate gUnknown_83FF704 = .callback = sub_80E3E84, }; -static const union AnimCmd gKnockOffStrikeAnimCmds[] = +static const union AnimCmd sKnockOffStrikeAnimCmds[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(64, 4), ANIMCMD_END, }; -static const union AnimCmd *const gKnockOffStrikeAnimTable[] = +static const union AnimCmd *const sKnockOffStrikeAnimTable[] = { - gKnockOffStrikeAnimCmds, + sKnockOffStrikeAnimCmds, }; -static const union AffineAnimCmd gKnockOffStrikeAffineanimCmds1[] = +static const union AffineAnimCmd sKnockOffStrikeAffineanimCmds1[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, -4, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gKnockOffStrikeAffineanimCmds2[] = +static const union AffineAnimCmd sKnockOffStrikeAffineanimCmds2[] = { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 4, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const gKnockOffStrikeAffineAnimTable[] = +static const union AffineAnimCmd *const sKnockOffStrikeAffineAnimTable[] = { - gKnockOffStrikeAffineanimCmds1, - gKnockOffStrikeAffineanimCmds2, + sKnockOffStrikeAffineanimCmds1, + sKnockOffStrikeAffineanimCmds2, }; const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = @@ -1100,21 +1100,21 @@ const struct SpriteTemplate gKnockOffStrikeSpriteTemplate = .tileTag = ANIM_TAG_SLAM_HIT_2, .paletteTag = ANIM_TAG_SLAM_HIT_2, .oam = &gOamData_AffineNormal_ObjNormal_64x64, - .anims = gKnockOffStrikeAnimTable, + .anims = sKnockOffStrikeAnimTable, .images = NULL, - .affineAnims = gKnockOffStrikeAffineAnimTable, + .affineAnims = sKnockOffStrikeAffineAnimTable, .callback = AnimKnockOffStrike, }; -static const union AffineAnimCmd gRecycleSpriteAffineAnimCmds[] = +static const union AffineAnimCmd sRecycleSpriteAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 0, -4, 64), AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd *const gRecycleSpriteAffineAnimTable[] = +static const union AffineAnimCmd *const sRecycleSpriteAffineAnimTable[] = { - gRecycleSpriteAffineAnimCmds, + sRecycleSpriteAffineAnimCmds, }; const struct SpriteTemplate gRecycleSpriteTemplate = @@ -1124,11 +1124,11 @@ const struct SpriteTemplate gRecycleSpriteTemplate = .oam = &gOamData_AffineNormal_ObjBlend_64x64, .anims = gDummySpriteAnimTable, .images = NULL, - .affineAnims = gRecycleSpriteAffineAnimTable, + .affineAnims = sRecycleSpriteAffineAnimTable, .callback = AnimRecycle, }; -static const union AffineAnimCmd gSlackOffSquishAffineAnimCmds[] = +static const union AffineAnimCmd sSlackOffSquishAffineAnimCmds[] = { AFFINEANIMCMD_FRAME(0, 16, 0, 4), AFFINEANIMCMD_FRAME(-2, 0, 0, 8), @@ -1246,7 +1246,7 @@ static void AnimMeanLookEye_Step1(struct Sprite *sprite) StartSpriteAffineAnim(sprite, 1); sprite->data[2] = 0; sprite->invisible = TRUE; - sprite->affineAnimPaused = 1; + sprite->affineAnimPaused = TRUE; sprite->callback = AnimMeanLookEye_Step2; } } @@ -1256,7 +1256,7 @@ static void AnimMeanLookEye_Step2(struct Sprite *sprite) if (sprite->data[2]++ > 9) { sprite->invisible = FALSE; - sprite->affineAnimPaused = 0; + sprite->affineAnimPaused = FALSE; if (sprite->affineAnimEnded) sprite->callback = AnimMeanLookEye_Step3; } @@ -1885,7 +1885,7 @@ static void TormentAttacker_Step(u8 taskId) task->data[5] -= 6; } - PrepareAffineAnimInTaskData(task, task->data[15], gUnknown_83FF080); + PrepareAffineAnimInTaskData(task, task->data[15], sUnknown_83FF080); task->data[1]++; task->data[0] = 1; break; @@ -2131,7 +2131,7 @@ void AnimTask_StockpileDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gStockpileDeformMonAffineAnimCmds); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), sStockpileDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2145,7 +2145,7 @@ void AnimTask_SpitUpDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gSpitUpDeformMonAffineAnimCmds); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), sSpitUpDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2178,7 +2178,7 @@ void AnimTask_SwallowDeformMon(u8 taskId) { if (!gTasks[taskId].data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gSwallowDeformMonAffineAnimCmds); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), sSwallowDeformMonAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -2339,7 +2339,7 @@ void AnimTask_MorningSunLightBeam(u8 taskId) SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gTasks[taskId].data[1], 16 - gTasks[taskId].data[1])); if (!gTasks[taskId].data[1]) { - gBattle_BG1_X = gMorningSunLightBeamCoordsTable[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; + gBattle_BG1_X = sMorningSunLightBeamCoordsTable[gTasks[taskId].data[2]] + gTasks[taskId].data[10]; if (++gTasks[taskId].data[2] == 4) gTasks[taskId].data[0] = 4; else @@ -2517,9 +2517,9 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) case 1: gTasks[taskId].data[3] = 0; if (GetBattlerSide(gBattleAnimTarget) == B_SIDE_OPPONENT) - gBattle_BG1_X = gTasks[taskId].data[10] + gDoomDesireLightBeamCoordTable[gTasks[taskId].data[2]]; + gBattle_BG1_X = gTasks[taskId].data[10] + sDoomDesireLightBeamCoordTable[gTasks[taskId].data[2]]; else - gBattle_BG1_X = gTasks[taskId].data[10] - gDoomDesireLightBeamCoordTable[gTasks[taskId].data[2]]; + gBattle_BG1_X = gTasks[taskId].data[10] - sDoomDesireLightBeamCoordTable[gTasks[taskId].data[2]]; if (++gTasks[taskId].data[2] == 5) gTasks[taskId].data[0] = 5; @@ -2535,7 +2535,7 @@ void AnimTask_DoomDesireLightBeam(u8 taskId) gTasks[taskId].data[0]++; break; case 3: - if (++gTasks[taskId].data[3] > gDoomDesireLightBeamDelayTable[gTasks[taskId].data[2]]) + if (++gTasks[taskId].data[3] > sDoomDesireLightBeamDelayTable[gTasks[taskId].data[2]]) gTasks[taskId].data[0]++; break; case 4: @@ -2568,7 +2568,7 @@ void AnimTask_StrongFrustrationGrowAndShrink(u8 taskId) { if (gTasks[taskId].data[0] == 0) { - PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), gStrongFrustrationAffineAnimCmds); + PrepareAffineAnimInTaskData(&gTasks[taskId], GetAnimBattlerSpriteId(ANIM_ATTACKER), sStrongFrustrationAffineAnimCmds); gTasks[taskId].data[0]++; } else @@ -3371,7 +3371,7 @@ void AnimTask_DeepInhale(u8 taskId) task->data[0] = 0; task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); - PrepareAffineAnimInTaskData(&gTasks[taskId], task->data[15], gDeepInhaleAffineAnimCmds); + PrepareAffineAnimInTaskData(&gTasks[taskId], task->data[15], sDeepInhaleAffineAnimCmds); task->func = AnimTask_DeepInhaleStep; } @@ -3635,7 +3635,7 @@ void AnimTask_SquishAndSweatDroplets(u8 taskId) task->data[5] = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y); task->data[6] = GetBattlerSpriteSubpriority(battler); task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); - PrepareAffineAnimInTaskData(task, task->data[15], gFacadeSquishAffineAnimCmds); + PrepareAffineAnimInTaskData(task, task->data[15], sFacadeSquishAffineAnimCmds); task->func = AnimTask_SquishAndSweatDropletsStep; } @@ -3662,7 +3662,7 @@ static void AnimTask_SquishAndSweatDropletsStep(u8 taskId) else { task->data[1] = 0; - PrepareAffineAnimInTaskData(task, task->data[15], gFacadeSquishAffineAnimCmds); + PrepareAffineAnimInTaskData(task, task->data[15], sFacadeSquishAffineAnimCmds); } } break; @@ -3744,7 +3744,7 @@ static void AnimTask_FacadeColorBlendStep(u8 taskId) { if (gTasks[taskId].data[1]) { - BlendPalette(gTasks[taskId].data[2], 16, 8, gFacadeBlendColors[gTasks[taskId].data[0]]); + BlendPalette(gTasks[taskId].data[2], 16, 8, sFacadeBlendColors[gTasks[taskId].data[0]]); if (++gTasks[taskId].data[0] > 23) gTasks[taskId].data[0] = 0; @@ -4111,7 +4111,7 @@ void AnimTask_SmellingSaltsSquish(u8 taskId) { gTasks[taskId].data[0] = gBattleAnimArgs[1]; gTasks[taskId].data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); - PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], gSmellingSaltsSquishAffineAnimCmds); + PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], sSmellingSaltsSquishAffineAnimCmds); gTasks[taskId].func = AnimTask_SmellingSaltsSquishStep; } } @@ -4134,7 +4134,7 @@ static void AnimTask_SmellingSaltsSquishStep(u8 taskId) gSprites[task->data[15]].pos2.x = 0; if (--task->data[0]) { - PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], gSmellingSaltsSquishAffineAnimCmds); + PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], sSmellingSaltsSquishAffineAnimCmds); task->data[1] = 0; task->data[2] = 0; } @@ -5289,7 +5289,7 @@ void AnimTask_SlackOffSquish(u8 taskId) task->data[0] = 0; task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); - PrepareAffineAnimInTaskData(task, task->data[15], gSlackOffSquishAffineAnimCmds); + PrepareAffineAnimInTaskData(task, task->data[15], sSlackOffSquishAffineAnimCmds); task->func = AnimTask_SlackOffSquishStep; } diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 44a7928d8..7590c0e58 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -40,9 +40,9 @@ #define LOHALF(n) ((n) & 0xFFFF) // RAM -int gUnknown_3005424; -u16 gUnknown_3005428; -u16 gUnknown_300542C; +int sUnknown_3005424; +u16 sUnknown_3005428; +u16 sUnknown_300542C; // Function Declarations static void sub_80EEDF4(u8); @@ -158,7 +158,7 @@ const struct CompressedSpritePalette gBallParticlePalettes[] = {gBattleAnimSpritePal_CircleImpact, TAG_PARTICLES_PREMIERBALL}, }; -static const union AnimCmd gAnim_RegularBall[] = +static const union AnimCmd sAnim_RegularBall[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_FRAME(1, 1), @@ -169,48 +169,48 @@ static const union AnimCmd gAnim_RegularBall[] = ANIMCMD_JUMP(0), }; -static const union AnimCmd gAnim_MasterBall[] = +static const union AnimCmd sAnim_MasterBall[] = { ANIMCMD_FRAME(3, 1), ANIMCMD_END, }; -static const union AnimCmd gAnim_NetDiveBall[] = +static const union AnimCmd sAnim_NetDiveBall[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END, }; -static const union AnimCmd gAnim_NestBall[] = +static const union AnimCmd sAnim_NestBall[] = { ANIMCMD_FRAME(5, 1), ANIMCMD_END, }; -static const union AnimCmd gAnim_LuxuryPremierBall[] = +static const union AnimCmd sAnim_LuxuryPremierBall[] = { ANIMCMD_FRAME(6, 4), ANIMCMD_FRAME(7, 4), ANIMCMD_JUMP(0), }; -static const union AnimCmd gAnim_UltraRepeatTimerBall[] = +static const union AnimCmd sAnim_UltraRepeatTimerBall[] = { ANIMCMD_FRAME(7, 4), ANIMCMD_END, }; -static const union AnimCmd *const gAnims_BallParticles[] = +static const union AnimCmd *const sAnims_BallParticles[] = { - gAnim_RegularBall, - gAnim_MasterBall, - gAnim_NetDiveBall, - gAnim_NestBall, - gAnim_LuxuryPremierBall, - gAnim_UltraRepeatTimerBall, + sAnim_RegularBall, + sAnim_MasterBall, + sAnim_NetDiveBall, + sAnim_NestBall, + sAnim_LuxuryPremierBall, + sAnim_UltraRepeatTimerBall, }; -const u8 gBallParticleAnimNums[] = +static const u8 sBallParticleAnimNums[] = { [BALL_POKE] = 0, [BALL_GREAT] = 0, @@ -226,7 +226,7 @@ const u8 gBallParticleAnimNums[] = [BALL_PREMIER] = 4, }; -const TaskFunc gBallParticleAnimationFuncs[] = +static const TaskFunc sBallParticleAnimationFuncs[] = { PokeBallOpenParticleAnimation, GreatBallOpenParticleAnimation, @@ -242,13 +242,13 @@ const TaskFunc gBallParticleAnimationFuncs[] = PremierBallOpenParticleAnimation, }; -const struct SpriteTemplate gBallParticlesSpriteTemplates[] = +static const struct SpriteTemplate sBallParticlesSpriteTemplates[] = { { .tileTag = TAG_PARTICLES_POKEBALL, .paletteTag = TAG_PARTICLES_POKEBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -257,7 +257,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_GREATBALL, .paletteTag = TAG_PARTICLES_GREATBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -266,7 +266,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_SAFARIBALL, .paletteTag = TAG_PARTICLES_SAFARIBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -275,7 +275,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_ULTRABALL, .paletteTag = TAG_PARTICLES_ULTRABALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -284,7 +284,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_MASTERBALL, .paletteTag = TAG_PARTICLES_MASTERBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -293,7 +293,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_NETBALL, .paletteTag = TAG_PARTICLES_NETBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -302,7 +302,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_DIVEBALL, .paletteTag = TAG_PARTICLES_DIVEBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -311,7 +311,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_NESTBALL, .paletteTag = TAG_PARTICLES_NESTBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -320,7 +320,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_REPEATBALL, .paletteTag = TAG_PARTICLES_REPEATBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -329,7 +329,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_TIMERBALL, .paletteTag = TAG_PARTICLES_TIMERBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -338,7 +338,7 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_LUXURYBALL, .paletteTag = TAG_PARTICLES_LUXURYBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, @@ -347,14 +347,14 @@ const struct SpriteTemplate gBallParticlesSpriteTemplates[] = .tileTag = TAG_PARTICLES_PREMIERBALL, .paletteTag = TAG_PARTICLES_PREMIERBALL, .oam = &gOamData_AffineOff_ObjNormal_8x8, - .anims = gAnims_BallParticles, + .anims = sAnims_BallParticles, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy, }, }; -const u16 gBallOpenFadeColors[] = +static const u16 sBallOpenFadeColors[] = { [BALL_POKE] = RGB(31, 22, 30), [BALL_GREAT] = RGB(16, 23, 30), @@ -391,15 +391,15 @@ const struct SpriteTemplate gPokeblockSpriteTemplate = .callback = sub_80F1B3C, }; -static const union AnimCmd gUnknown_840C204[] = +static const union AnimCmd sUnknown_840C204[] = { ANIMCMD_FRAME(64, 1), ANIMCMD_END, }; -static const union AnimCmd *const gSpriteAnimTable_840C20C[] = +static const union AnimCmd *const sSpriteAnimTable_840C20C[] = { - gUnknown_840C204, + sUnknown_840C204, }; const struct SpriteTemplate gUnknown_840C210 = @@ -407,7 +407,7 @@ const struct SpriteTemplate gUnknown_840C210 = .tileTag = ANIM_TAG_ROCKS, .paletteTag = ANIM_TAG_ROCKS, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSpriteAnimTable_840C20C, + .anims = sSpriteAnimTable_840C20C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_80F1B3C, @@ -899,10 +899,10 @@ static void sub_80EFA0C(struct Sprite *sprite) case 0: PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); gTasks[taskId].data[10] = 256; - gUnknown_3005424 = 28; - gUnknown_300542C = (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y) - (sprite->pos1.y + sprite->pos2.y); - gUnknown_3005428 = (u32)(gUnknown_300542C * 256) / 28; - gTasks[taskId].data[2] = gUnknown_3005428; + sUnknown_3005424 = 28; + sUnknown_300542C = (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y) - (sprite->pos1.y + sprite->pos2.y); + sUnknown_3005428 = (u32)(sUnknown_300542C * 256) / 28; + gTasks[taskId].data[2] = sUnknown_3005428; gTasks[taskId].data[0]++; break; case 1: @@ -1293,7 +1293,7 @@ static void sub_80F01B8(struct Sprite *sprite) sub_80F05B4(4); for (i = 0; i < 3; i++) { - u8 spriteId = CreateSprite(&gBallParticlesSpriteTemplates[4], sprite->pos1.x, sprite->pos1.y, subpriority); + u8 spriteId = CreateSprite(&sBallParticlesSpriteTemplates[4], sprite->pos1.x, sprite->pos1.y, subpriority); if (spriteId != MAX_SPRITES) { gSprites[spriteId].data[0] = 24; @@ -1302,7 +1302,7 @@ static void sub_80F01B8(struct Sprite *sprite) gSprites[spriteId].data[5] = sBallCaptureSuccessStarData[i].unk2; InitAnimArcTranslation(&gSprites[spriteId]); gSprites[spriteId].callback = sub_80F0278; - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[4]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[4]); } } } @@ -1443,7 +1443,7 @@ u8 LaunchBallStarsTask(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId) u8 taskId; sub_80F05B4(ballId); - taskId = CreateTask(gBallParticleAnimationFuncs[ballId], 5); + taskId = CreateTask(sBallParticleAnimationFuncs[ballId], 5); gTasks[taskId].data[1] = x; gTasks[taskId].data[2] = y; gTasks[taskId].data[3] = priority; @@ -1475,11 +1475,11 @@ static void PokeBallOpenParticleAnimation(u8 taskId) priority = gTasks[taskId].data[3]; subpriority = gTasks[taskId].data[4]; - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = PokeBallOpenParticleAnimation_Step1; gSprites[spriteId].oam.priority = priority; @@ -1534,11 +1534,11 @@ static void TimerBallOpenParticleAnimation(u8 taskId) for (i = 0; i < 8; i++) { - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; gSprites[spriteId].oam.priority = priority; gSprites[spriteId].data[0] = i * 32; @@ -1568,11 +1568,11 @@ static void DiveBallOpenParticleAnimation(u8 taskId) for (i = 0; i < 8; i++) { - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; gSprites[spriteId].oam.priority = priority; gSprites[spriteId].data[0] = i * 32; @@ -1603,11 +1603,11 @@ static void SafariBallOpenParticleAnimation(u8 taskId) for (i = 0; i < 8; i++) { - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; gSprites[spriteId].oam.priority = priority; gSprites[spriteId].data[0] = i * 32; @@ -1638,11 +1638,11 @@ static void UltraBallOpenParticleAnimation(u8 taskId) for (i = 0; i < 10; i++) { - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; gSprites[spriteId].oam.priority = priority; gSprites[spriteId].data[0] = i * 25; @@ -1679,11 +1679,11 @@ static void GreatBallOpenParticleAnimation(u8 taskId) for (i = 0; i < 8; i++) { - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; gSprites[spriteId].oam.priority = priority; gSprites[spriteId].data[0] = i * 32; @@ -1729,11 +1729,11 @@ static void RepeatBallOpenParticleAnimation(u8 taskId) for (i = 0; i < POKEBALL_COUNT; i++) { - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = RepeatBallOpenParticleAnimation_Step1; gSprites[spriteId].oam.priority = priority; gSprites[spriteId].data[0] = i * 21; @@ -1773,11 +1773,11 @@ static void MasterBallOpenParticleAnimation(u8 taskId) { for (i = 0; i < 8; i++) { - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = FanOutBallOpenParticles_Step1; gSprites[spriteId].oam.priority = priority; gSprites[spriteId].data[0] = i * 32; @@ -1817,11 +1817,11 @@ static void PremierBallOpenParticleAnimation(u8 taskId) for (i = 0; i < 8; i++) { - spriteId = CreateSprite(&gBallParticlesSpriteTemplates[ballId], x, y, subpriority); + spriteId = CreateSprite(&sBallParticlesSpriteTemplates[ballId], x, y, subpriority); if (spriteId != MAX_SPRITES) { sub_80F0674(); - StartSpriteAnim(&gSprites[spriteId], gBallParticleAnimNums[ballId]); + StartSpriteAnim(&gSprites[spriteId], sBallParticleAnimNums[ballId]); gSprites[spriteId].callback = PremierBallOpenParticleAnimation_Step1; gSprites[spriteId].oam.priority = priority; gSprites[spriteId].data[0] = i * 32; @@ -1888,12 +1888,12 @@ u8 LaunchBallFadeMonTask(bool8 unfadeLater, u8 battler, u32 selectedPalettes, u8 if (!unfadeLater) { - BlendPalette(battler * 16 + 0x100, 16, 0, gBallOpenFadeColors[ballId]); + BlendPalette(battler * 16 + 0x100, 16, 0, sBallOpenFadeColors[ballId]); gTasks[taskId].data[1] = 1; } else { - BlendPalette(battler * 16 + 0x100, 16, 16, gBallOpenFadeColors[ballId]); + BlendPalette(battler * 16 + 0x100, 16, 16, sBallOpenFadeColors[ballId]); gTasks[taskId].data[0] = 16; gTasks[taskId].data[1] = -1; gTasks[taskId].func = sub_80F1370; @@ -1909,7 +1909,7 @@ static void sub_80F12E0(u8 taskId) if (gTasks[taskId].data[2] <= 16) { - BlendPalette(gTasks[taskId].data[3] * 16 + 0x100, 16, gTasks[taskId].data[0], gBallOpenFadeColors[ballId]); + BlendPalette(gTasks[taskId].data[3] * 16 + 0x100, 16, gTasks[taskId].data[0], sBallOpenFadeColors[ballId]); gTasks[taskId].data[0] += gTasks[taskId].data[1]; gTasks[taskId].data[2]++; } @@ -1937,7 +1937,7 @@ static void sub_80F13C0(u8 taskId) if (gTasks[taskId].data[2] <= 16) { - BlendPalette(gTasks[taskId].data[3] * 16 + 0x100, 16, gTasks[taskId].data[0], gBallOpenFadeColors[ballId]); + BlendPalette(gTasks[taskId].data[3] * 16 + 0x100, 16, gTasks[taskId].data[0], sBallOpenFadeColors[ballId]); gTasks[taskId].data[0] += gTasks[taskId].data[1]; gTasks[taskId].data[2]++; } diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c index afa0c5c42..2e7f30ff1 100644 --- a/src/battle_anim_status_effects.c +++ b/src/battle_anim_status_effects.c @@ -23,7 +23,7 @@ static void sub_807834C(struct Sprite *sprite); static void sub_8078380(struct Sprite *sprite); // Data -static const union AnimCmd gUnknown_83BF3E0[] = +static const union AnimCmd sUnknown_83BF3E0[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(4, 3), @@ -32,9 +32,9 @@ static const union AnimCmd gUnknown_83BF3E0[] = ANIMCMD_JUMP(0) }; -static const union AnimCmd *const gSpriteAnimTable_83BF3F4[] = +static const union AnimCmd *const sSpriteAnimTable_83BF3F4[] = { - gUnknown_83BF3E0 + sUnknown_83BF3E0 }; const struct SpriteTemplate gSpriteTemplate_83BF3F8 = @@ -42,7 +42,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF3F8 = .tileTag = ANIM_TAG_ORB, .paletteTag = ANIM_TAG_ORB, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gSpriteAnimTable_83BF3F4, + .anims = sSpriteAnimTable_83BF3F4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_8076F58, @@ -53,21 +53,21 @@ const struct SpriteTemplate gSpriteTemplate_83BF410 = .tileTag = ANIM_TAG_ORB, .paletteTag = ANIM_TAG_ORB, .oam = &gOamData_AffineOff_ObjNormal_16x16, - .anims = gSpriteAnimTable_83BF3F4, + .anims = sSpriteAnimTable_83BF3F4, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_8076ED8, }; -static const union AnimCmd gUnknown_83BF428[] = +static const union AnimCmd sUnknown_83BF428[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_JUMP(0) }; -static const union AnimCmd *const gSpriteAnimTable_83BF430[] = +static const union AnimCmd *const sSpriteAnimTable_83BF430[] = { - gUnknown_83BF428 + sUnknown_83BF428 }; const struct SpriteTemplate gSpriteTemplate_83BF434 = @@ -75,7 +75,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF434 = .tileTag = ANIM_TAG_WEATHER_BALL, .paletteTag = ANIM_TAG_WEATHER_BALL, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSpriteAnimTable_83BF430, + .anims = sSpriteAnimTable_83BF430, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_807729C, @@ -86,13 +86,13 @@ const struct SpriteTemplate gSpriteTemplate_83BF44C = .tileTag = ANIM_TAG_WEATHER_BALL, .paletteTag = ANIM_TAG_WEATHER_BALL, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSpriteAnimTable_83BF430, + .anims = sSpriteAnimTable_83BF430, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_8077350, }; -static const union AnimCmd gUnknown_83BF464[] = +static const union AnimCmd sUnknown_83BF464[] = { ANIMCMD_FRAME(0, 3), ANIMCMD_FRAME(16, 3), @@ -102,9 +102,9 @@ static const union AnimCmd gUnknown_83BF464[] = ANIMCMD_END }; -static const union AnimCmd *const gSpriteAnimTable_83BF47C[] = +static const union AnimCmd *const sSpriteAnimTable_83BF47C[] = { - gUnknown_83BF464 + sUnknown_83BF464 }; const struct SpriteTemplate gSpriteTemplate_83BF480 = @@ -112,7 +112,7 @@ const struct SpriteTemplate gSpriteTemplate_83BF480 = .tileTag = ANIM_TAG_SPARKLE_4, .paletteTag = ANIM_TAG_SPARKLE_4, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSpriteAnimTable_83BF47C, + .anims = sSpriteAnimTable_83BF47C, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_8076FD0, @@ -129,29 +129,29 @@ const struct SpriteTemplate gSpriteTemplate_83BF498 = .callback = sub_8076F58, }; -static const union AnimCmd gUnknown_83BF4B0[] = +static const union AnimCmd sUnknown_83BF4B0[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_JUMP(0) }; -static const union AnimCmd gUnknown_83BF4B8[] = +static const union AnimCmd sUnknown_83BF4B8[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_JUMP(0) }; -static const union AnimCmd gUnknown_83BF4C0[] = +static const union AnimCmd sUnknown_83BF4C0[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_JUMP(0) }; -static const union AnimCmd *const gSpriteAniimTable_83BF4C8[] = +static const union AnimCmd *const sSpriteAniimTable_83BF4C8[] = { - gUnknown_83BF4B0, - gUnknown_83BF4B8, - gUnknown_83BF4C0 + sUnknown_83BF4B0, + sUnknown_83BF4B8, + sUnknown_83BF4C0 }; const struct SpriteTemplate gSpriteTemplate_83BF4D4 = @@ -159,33 +159,33 @@ const struct SpriteTemplate gSpriteTemplate_83BF4D4 = .tileTag = ANIM_TAG_IMPACT, .paletteTag = ANIM_TAG_IMPACT, .oam = &gOamData_AffineOff_ObjNormal_32x32, - .anims = gSpriteAniimTable_83BF4C8, + .anims = sSpriteAniimTable_83BF4C8, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = sub_8076F58, }; -static const union AnimCmd gUnknown_83BF4EC[] = +static const union AnimCmd sUnknown_83BF4EC[] = { ANIMCMD_FRAME(0, 15), ANIMCMD_JUMP(0) }; -static const union AnimCmd *const gSpriteAnimTable_83BF4F4[] = +static const union AnimCmd *const sSpriteAnimTable_83BF4F4[] = { - gUnknown_83BF4EC + sUnknown_83BF4EC }; -static const union AffineAnimCmd gUnknown_83BF4F8[] = +static const union AffineAnimCmd sUnknown_83BF4F8[] = { AFFINEANIMCMD_FRAME(96, 96, 0, 0), AFFINEANIMCMD_FRAME(2, 2, 0, 1), AFFINEANIMCMD_JUMP(1) }; -static const union AffineAnimCmd *const gSpriteAffineAnimTable_83BF510[] = +static const union AffineAnimCmd *const sSpriteAffineAnimTable_83BF510[] = { - gUnknown_83BF4F8 + sUnknown_83BF4F8 }; const struct SpriteTemplate gSpriteTemplate_83BF514 = @@ -193,15 +193,15 @@ const struct SpriteTemplate gSpriteTemplate_83BF514 = .tileTag = ANIM_TAG_ORB, .paletteTag = ANIM_TAG_ORB, .oam = &gOamData_AffineDouble_ObjNormal_16x16, - .anims = gSpriteAnimTable_83BF4F4, + .anims = sSpriteAnimTable_83BF4F4, .images = NULL, - .affineAnims = gSpriteAffineAnimTable_83BF510, + .affineAnims = sSpriteAffineAnimTable_83BF510, .callback = sub_8076ED8, }; -const u8 gUnknown_83BF52C[] = _("TASK OVER\nタスクがオ-バ-しました"); +static const u8 sUnknown_83BF52C[] = _("TASK OVER\nタスクがオ-バ-しました"); -static const struct Subsprite gSubsprites_83BF544[] = +static const struct Subsprite sSubsprites_83BF544[] = { {.x = -16, .y = -16, .shape = SPRITE_SHAPE(8x8), .size = 3, .tileOffset = 0, .priority = 2}, {.x = -16, .y = 48, .shape = SPRITE_SHAPE(16x8), .size = 3, .tileOffset = 64, .priority = 2}, @@ -209,12 +209,12 @@ static const struct Subsprite gSubsprites_83BF544[] = {.x = 48, .y = 48, .shape = SPRITE_SHAPE(8x8), .size = 2, .tileOffset = 128, .priority = 2}, }; -static const struct SubspriteTable gUnknown_83BF554[] = +static const struct SubspriteTable sUnknown_83BF554[] = { - {NELEMS(gSubsprites_83BF544), gSubsprites_83BF544}, + {NELEMS(sSubsprites_83BF544), sSubsprites_83BF544}, }; -static const struct SpriteTemplate gUnknown_83BF55C = +static const struct SpriteTemplate sUnknown_83BF55C = { .tileTag = ANIM_TAG_ICE_CUBE, .paletteTag = ANIM_TAG_ICE_CUBE, @@ -225,7 +225,7 @@ static const struct SpriteTemplate gUnknown_83BF55C = .callback = SpriteCallbackDummy, }; -static const struct SpriteTemplate gUnknown_83BF574 = +static const struct SpriteTemplate sUnknown_83BF574 = { .tileTag = ANIM_TAG_CIRCLE_IMPACT, .paletteTag = ANIM_TAG_CIRCLE_IMPACT, @@ -252,7 +252,7 @@ static u8 sub_8078178(u8 battlerId, bool8 b) gTasks[taskId].data[1] = RGB_RED; for (i = 0; i < 10; i++) { - spriteId2 = CreateSprite(&gUnknown_83BF574, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y + 32, 0); + spriteId2 = CreateSprite(&sUnknown_83BF574, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y + 32, 0); gSprites[spriteId2].data[0] = i * 51; gSprites[spriteId2].data[1] = -256; gSprites[spriteId2].invisible = TRUE; @@ -265,7 +265,7 @@ static u8 sub_8078178(u8 battlerId, bool8 b) gTasks[taskId].data[1] = RGB_BLUE; for (i = 0; i < 10; i++) { - spriteId2 = CreateSprite(&gUnknown_83BF574, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y - 32, 0); + spriteId2 = CreateSprite(&sUnknown_83BF574, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y - 32, 0); gSprites[spriteId2].data[0] = i * 51; gSprites[spriteId2].data[1] = 256; gSprites[spriteId2].invisible = TRUE; @@ -356,11 +356,11 @@ void sub_80783FC(u8 taskId) SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); - spriteId = CreateSprite(&gUnknown_83BF55C, x, y, 4); + spriteId = CreateSprite(&sUnknown_83BF55C, x, y, 4); if (GetSpriteTileStartByTag(ANIM_TAG_ICE_CUBE) == SPRITE_INVALID_TAG) gSprites[spriteId].invisible = TRUE; - SetSubspriteTables(&gSprites[spriteId], gUnknown_83BF554); + SetSubspriteTables(&gSprites[spriteId], sUnknown_83BF554); gTasks[taskId].data[15] = spriteId; gTasks[taskId].func = sub_80784D8; } -- cgit v1.2.3