Leahnaya/pokeemerald
1
0
Fork 0
mirror of https://github.com/pret/pokeemerald.git synced 2026-03-21 17:54:57 -05:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Document battle_anim_normal.c

Browse Source
This commit is contained in:
Martin Griffin 2024-11-27 19:49:03 +00:00
parent 2ea4cf42cc
commit e09423fadf
5 changed files with 776 additions and 583 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
asm/macros/battle_anim_script.inc
View File

@ -283,3 +283,99 @@
.macro jumpretfalse ptr:req
jumpreteq FALSE, \ptr
.endm
@ createsprite wrappers
@ The arguments are based on the CMD_ARGS of the callback associated with the template.
.macro simple_palette_blend unused_anim_battler=ANIM_ATTACKER, unused_subpriority_offset=2, selector:req, delay:req, initial_blend_y:req, target_blend_y:req, color:req
createsprite gSimplePaletteBlendSpriteTemplate, \unused_anim_battler, \unused_subpriority_offset, \selector, \delay, \initial_blend_y, \target_blend_y, \color
.endm
.macro complex_palette_blend unused_anim_battler=ANIM_ATTACKER, unused_subpriority_offset=2, selector:req, delay:req, num_blends:req, color1:req, blend_y1:req, color2:req, blend_y2:req
createsprite gComplexPaletteBlendSpriteTemplate, \unused_anim_battler, \unused_subpriority_offset, \selector, \delay, \num_blends, \color1, \blend_y1, \color2, \blend_y2
.endm
.macro shake_mon_or_platform unused_anim_battler=ANIM_ATTACKER, unused_subpriority_offset=2, velocity:req, shake_timer:req, shake_duration:req, type:req, battler_selector
.if \type == SHAKE_MON_X || \type == SHAKE_MON_Y
.ifb \battler_selector
.error "battler_selector required for SHAKE_MON_X or SHAKE_MON_Y"
.endif
.else
.ifnb \battler_selector
.warning "unused battler_selector in shake_mon_or_platform"
.endif
.endif
.ifb \battler_selector
createsprite gShakeMonOrPlatformSpriteTemplate, \unused_anim_battler, \unused_subpriority_offset, \velocity, \shake_timer, \shake_duration, \type
.else
createsprite gShakeMonOrPlatformSpriteTemplate, \unused_anim_battler, \unused_subpriority_offset, \velocity, \shake_timer, \shake_duration, \type, \battler_selector
.endif
.endm
.macro create_confusion_duck_sprite anim_battler:req, subpriority_offset:req, x:req, y:req, wave_offset:req, wave_period:req, duration:req
createsprite gConfusionDuckSpriteTemplate, \anim_battler, \subpriority_offset, \x, \y, \wave_offset, \wave_period, \duration
.endm
.macro create_basic_hitsplat_sprite anim_battler:req, subpriority_offset:req, x:req, y:req, relative_to:req, animation:req
createsprite gBasicHitSplatSpriteTemplate, \anim_battler, \subpriority_offset, \x, \y, \relative_to, \animation
.endm
.macro create_persist_hitsplat_sprite anim_battler:req, subpriority_offset:req, x:req, y:req, relative_to:req, animation:req, duration:req
createsprite gPersistHitSplatSpriteTemplate, \anim_battler, \subpriority_offset, \x, \y, \relative_to, \animation, \duration
.endm
.macro create_handle_invert_hitsplat_sprite anim_battler:req, subpriority_offset:req, x:req, y:req, relative_to:req, animation:req
createsprite gHandleInvertHitSplatSpriteTemplate, \anim_battler, \subpriority_offset, \x, \y, \relative_to, \animation
.endm
.macro create_random_pos_hitsplat_sprite anim_battler:req, subpriority_offset:req, relative_to:req, animation
.ifnb \animation
createsprite gRandomPosHitSplatSpriteTemplate, \anim_battler, \subpriority_offset, \relative_to, \animation
.else
createsprite gRandomPosHitSplatSpriteTemplate, \anim_battler, \subpriority_offset, \relative_to, -1
.endif
.endm
.macro create_mon_edge_hitsplat_sprite anim_battler:req, subpriority_offset:req, relative_to:req, x:req, y:req, animation:req
createsprite gMonEdgeHitSplatSpriteTemplate, \anim_battler, \subpriority_offset, \relative_to, \x, \y, \animation
.endm
.macro create_cross_impact_sprite anim_battler:req, subpriority_offset:req, x:req, y:req, relative_to:req, duration:req
createsprite gCrossImpactSpriteTemplate, \anim_battler, \subpriority_offset, \x, \y, \relative_to, \duration
.endm
.macro create_flashing_hitsplat_sprite anim_battler:req, subpriority_offset:req, x:req, y:req, relative_to:req, animation:req
createsprite gFlashingHitSplatSpriteTemplate, \anim_battler, \subpriority_offset, \x, \y, \relative_to, \animation
.endm
@ createvisualtask wrappers
@ The arguments are based on the CMD_ARGS of the task.
.macro blend_color_cycle priority=2, selector:req, delay:req, num_blends:req, initial_blend_y:req, target_blend_y:req, color:req
createvisualtask AnimTask_BlendColorCycle, \priority, \selector, \delay, \num_blends, \initial_blend_y, \target_blend_y, \color
.endm
.macro blend_color_cycleexclude priority=2, unk0:req, delay:req, num_blends:req, initial_blend_y:req, target_blend_y:req, color:req
createvisualtask AnimTask_BlendColorCycleExclude, \priority, \unk0, \delay, \num_blends, \initial_blend_y, \target_blend_y, \color
.endm
.macro blend_color_cyclebytag priority=2, tag:req, delay:req, num_blends:req, initial_blend_y:req, target_blend_y:req, color:req
createvisualtask AnimTask_BlendColorCycleByTag, \priority, \tag, \delay, \num_blends, \initial_blend_y, \target_blend_y, \color
.endm
.macro flash_anim_tag_with_color priority=2, tag:req, delay:req, num_blends:req, color1:req, blend_y1:req, color2:req, blend_y2:req
createvisualtask AnimTask_FlashAnimTagWithColor, \priority, \tag, \delay, \num_blends, \color1, \blend_y1, \color2, \blend_y2
.endm
.macro invert_screen_color priority=2, scenery:req, attacker:req, target:req
@ NOTE: These generate 0x000 or 0x101 to match, but the code checks for '& 0x100'.
createvisualtask AnimTask_InvertScreenColor, \priority, (\scenery << 8) | \scenery, (\attacker << 8) | \attacker, (\target << 8) | \target
.endm
.macro tint_palettes priority=2, scenery:req, attacker:req, target:req, duration:req, color:req
createvisualtask AnimTask_TintPalettes, \priority, \scenery << 8, \attacker << 8, \target << 8, \duration, \color & 0x1F, (\color >> 5) & 0x1F, (\color >> 10) & 0x1F
.endm
.macro shake_battle_platforms priority=2, x_offset:req, y_offset:req, shakes:req, delay:req
createvisualtask AnimTask_ShakeBattlePlatforms, \priority, \x_offset, \y_offset, \shakes, \delay
.endm

858
data/battle_anim_scripts.s
View File

File diff suppressed because it is too large Load Diff

18
include/battle_anim_internal.h Normal file
View File

@ -0,0 +1,18 @@
#ifndef GUARD_BATTLE_ANIM_INTERNAL_H
#define GUARD_BATTLE_ANIM_INTERNAL_H
/* CMD_ARGS provides a way to locally name the members of gBattleAnimArgs.
*
* For example:
* {
* CMD_ARGS(x, y);
* // cmd->x is gBattleAnimArgs[0] and cmd->y is gBattleAnimArgs[1]
* } */
#if MODERN
#define CMD_ARGS(...) struct { s16 __VA_ARGS__; } *cmd = (void *)gBattleAnimArgs
#else
#define CMD_ARGS(...) struct CMD_ARGS { s16 __VA_ARGS__; }
#define cmd ((struct CMD_ARGS *)gBattleAnimArgs)
#endif
#endif

2
include/constants/battle_anim.h
View File

@ -436,5 +436,7 @@
// It's redundant with F_PAL_BATTLERS, because they're only ever used together to refer to all the battlers at once.
#define F_PAL_BATTLERS_2 (1 << 7 | 1 << 8 | 1 << 9 | 1 << 10)
enum { SHAKE_BG_X, SHAKE_BG_Y, SHAKE_MON_X, SHAKE_MON_Y };
enum { SHAKE_MON_ATTACKER, SHAKE_MON_TARGET, SHAKE_MON_BOTH };
#endif // GUARD_CONSTANTS_BATTLE_ANIM_H

383
src/battle_anim_normal.c
View File

@ -1,5 +1,6 @@
#include "global.h"
#include "battle_anim.h"
#include "battle_anim_internal.h"
#include "palette.h"
#include "random.h"
#include "task.h"
@ -254,29 +255,26 @@ const struct SpriteTemplate gPersistHitSplatSpriteTemplate =
};
// Moves a spinning duck around the mon's head.
// arg 0: initial x pixel offset
// arg 1: initial y pixel offset
// arg 2: initial wave offset
// arg 3: wave period (higher means faster wave)
// arg 4: duration
static void AnimConfusionDuck(struct Sprite *sprite)
{
sprite->x += gBattleAnimArgs[0];
sprite->y += gBattleAnimArgs[1];
sprite->data[0] = gBattleAnimArgs[2];
CMD_ARGS(x, y, waveOffset, wavePeriod, duration);
sprite->x += cmd->x;
sprite->y += cmd->y;
sprite->data[0] = cmd->waveOffset;
if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
{
sprite->data[1] = -gBattleAnimArgs[3];
sprite->data[1] = -cmd->wavePeriod;
sprite->data[4] = 1;
}
else
{
sprite->data[1] = gBattleAnimArgs[3];
sprite->data[1] = cmd->wavePeriod;
sprite->data[4] = 0;
StartSpriteAnim(sprite, 1);
}
sprite->data[3] = gBattleAnimArgs[4];
sprite->data[3] = cmd->duration;
sprite->callback = AnimConfusionDuck_Step;
sprite->callback(sprite);
}
@ -297,15 +295,12 @@ static void AnimConfusionDuck_Step(struct Sprite *sprite)
}
// Performs a simple color blend on a specified sprite.
// arg 0: palette selector
// arg 1: delay
// arg 2: start blend amount
// arg 3: end blend amount
// arg 4: blend color
static void AnimSimplePaletteBlend(struct Sprite *sprite)
{
u32 selectedPalettes = UnpackSelectedBattlePalettes(gBattleAnimArgs[0]);
BeginNormalPaletteFade(selectedPalettes, gBattleAnimArgs[1], gBattleAnimArgs[2], gBattleAnimArgs[3], gBattleAnimArgs[4]);
CMD_ARGS(selector, delay, initialBlendY, targetBlendY, color);
u32 selectedPalettes = UnpackSelectedBattlePalettes(cmd->selector);
BeginNormalPaletteFade(selectedPalettes, cmd->delay, cmd->initialBlendY, cmd->targetBlendY, cmd->color);
sprite->invisible = TRUE;
sprite->callback = AnimSimplePaletteBlend_Step;
}
@ -337,21 +332,32 @@ static void AnimSimplePaletteBlend_Step(struct Sprite *sprite)
DestroyAnimSprite(sprite);
}
#define sTimer data[0]
#define sDelay data[1]
#define sNumBlends data[2]
#define sColor1 data[3]
#define sBlendY1 data[4]
#define sColor2 data[5]
#define sBlendY2 data[6]
#define sPaletteSelector data[7]
static void AnimComplexPaletteBlend(struct Sprite *sprite)
{
CMD_ARGS(selector, delay, numBlends, color1, blendY1, color2, blendY2);
u32 selectedPalettes;
sprite->data[0] = gBattleAnimArgs[1];
sprite->data[1] = gBattleAnimArgs[1];
sprite->data[2] = gBattleAnimArgs[2];
sprite->data[3] = gBattleAnimArgs[3];
sprite->data[4] = gBattleAnimArgs[4];
sprite->data[5] = gBattleAnimArgs[5];
sprite->data[6] = gBattleAnimArgs[6];
sprite->data[7] = gBattleAnimArgs[0];
sprite->sTimer = cmd->delay;
sprite->sDelay = cmd->delay;
sprite->sNumBlends = cmd->numBlends;
sprite->sColor1 = cmd->color1;
sprite->sBlendY1 = cmd->blendY1;
sprite->sColor2 = cmd->color2;
sprite->sBlendY2 = cmd->blendY2;
sprite->sPaletteSelector = cmd->selector;
selectedPalettes = UnpackSelectedBattlePalettes(sprite->data[7]);
BlendPalettes(selectedPalettes, gBattleAnimArgs[4], gBattleAnimArgs[3]);
selectedPalettes = UnpackSelectedBattlePalettes(sprite->sPaletteSelector);
BlendPalettes(selectedPalettes, cmd->blendY1, cmd->color1);
sprite->invisible = TRUE;
sprite->callback = AnimComplexPaletteBlend_Step1;
}
@ -360,30 +366,30 @@ static void AnimComplexPaletteBlend_Step1(struct Sprite *sprite)
{
u32 selectedPalettes;
if (sprite->data[0] > 0)
if (sprite->sTimer > 0)
{
sprite->data[0]--;
sprite->sTimer--;
return;
}
if (gPaletteFade.active)
return;
if (sprite->data[2] == 0)
if (sprite->sNumBlends == 0)
{
sprite->callback = AnimComplexPaletteBlend_Step2;
return;
}
selectedPalettes = UnpackSelectedBattlePalettes(sprite->data[7]);
if (sprite->data[1] & 0x100)
BlendPalettes(selectedPalettes, sprite->data[4], sprite->data[3]);
selectedPalettes = UnpackSelectedBattlePalettes(sprite->sPaletteSelector);
if (sprite->sDelay & 0x100)
BlendPalettes(selectedPalettes, sprite->sBlendY1, sprite->sColor1);
else
BlendPalettes(selectedPalettes, sprite->data[6], sprite->data[5]);
BlendPalettes(selectedPalettes, sprite->sBlendY2, sprite->sColor2);
sprite->data[1] ^= 0x100;
sprite->data[0] = sprite->data[1] & 0xFF;
sprite->data[2]--;
sprite->sDelay ^= 0x100;
sprite->sTimer = sprite->sDelay & 0xFF;
sprite->sNumBlends--;
}
static void AnimComplexPaletteBlend_Step2(struct Sprite *sprite)
@ -392,16 +398,27 @@ static void AnimComplexPaletteBlend_Step2(struct Sprite *sprite)
if (!gPaletteFade.active)
{
selectedPalettes = UnpackSelectedBattlePalettes(sprite->data[7]);
selectedPalettes = UnpackSelectedBattlePalettes(sprite->sPaletteSelector);
BlendPalettes(selectedPalettes, 0, 0);
DestroyAnimSprite(sprite);
}
}
#undef sTimer
#undef sDelay
#undef sNumBlends
#undef sColor1
#undef sBlendY1
#undef sColor2
#undef sBlendY2
#undef sPaletteSelector
static void AnimCirclingSparkle(struct Sprite *sprite)
{
sprite->x += gBattleAnimArgs[0];
sprite->y += gBattleAnimArgs[1];
CMD_ARGS(x, y);
sprite->x += cmd->x;
sprite->y += cmd->y;
sprite->data[0] = 0;
sprite->data[1] = 10;
sprite->data[2] = 8;
@ -429,12 +446,14 @@ static void AnimCirclingSparkle(struct Sprite *sprite)
// Many uses of this task only set a tNumBlends of 2, which has the effect of blending to a color and back once
void AnimTask_BlendColorCycle(u8 taskId)
{
gTasks[taskId].tPalSelector = gBattleAnimArgs[0];
gTasks[taskId].tDelay = gBattleAnimArgs[1];
gTasks[taskId].tNumBlends = gBattleAnimArgs[2];
gTasks[taskId].tInitialBlendY = gBattleAnimArgs[3];
gTasks[taskId].tTargetBlendY = gBattleAnimArgs[4];
gTasks[taskId].tBlendColor = gBattleAnimArgs[5];
CMD_ARGS(selector, delay, numBlends, initialBlendY, targetBlendY, color);
gTasks[taskId].tPalSelector = cmd->selector;
gTasks[taskId].tDelay = cmd->delay;
gTasks[taskId].tNumBlends = cmd->numBlends;
gTasks[taskId].tInitialBlendY = cmd->initialBlendY;
gTasks[taskId].tTargetBlendY = cmd->targetBlendY;
gTasks[taskId].tBlendColor = cmd->color;
gTasks[taskId].tRestoreBlend = FALSE;
BlendColorCycle(taskId, 0, gTasks[taskId].tTargetBlendY);
gTasks[taskId].func = AnimTask_BlendColorCycleLoop;
@ -489,15 +508,17 @@ static void AnimTask_BlendColorCycleLoop(u8 taskId)
// See AnimTask_BlendColorCycle. Same, but excludes Attacker and Target
void AnimTask_BlendColorCycleExclude(u8 taskId)
{
CMD_ARGS(unk0, delay, numBlends, initialBlendY, targetBlendY, color);
int battler;
u32 selectedPalettes = 0;
gTasks[taskId].data[0] = gBattleAnimArgs[0];
gTasks[taskId].tDelay = gBattleAnimArgs[1];
gTasks[taskId].tNumBlends = gBattleAnimArgs[2];
gTasks[taskId].tInitialBlendY = gBattleAnimArgs[3];
gTasks[taskId].tTargetBlendY = gBattleAnimArgs[4];
gTasks[taskId].tBlendColor = gBattleAnimArgs[5];
gTasks[taskId].data[0] = cmd->unk0;
gTasks[taskId].tDelay = cmd->delay;
gTasks[taskId].tNumBlends = cmd->numBlends;
gTasks[taskId].tInitialBlendY = cmd->initialBlendY;
gTasks[taskId].tTargetBlendY = cmd->targetBlendY;
gTasks[taskId].tBlendColor = cmd->color;
gTasks[taskId].tRestoreBlend = 0;
for (battler = 0; battler < gBattlersCount; battler++)
@ -506,7 +527,7 @@ void AnimTask_BlendColorCycleExclude(u8 taskId)
selectedPalettes |= 1 << (battler + 16);
}
if (gBattleAnimArgs[0] == 1)
if (cmd->unk0 == 1)
selectedPalettes |= 0xE;
gTasks[taskId].tPalSelectorHi = selectedPalettes >> 16;
@ -564,12 +585,14 @@ static void AnimTask_BlendColorCycleExcludeLoop(u8 taskId)
// See AnimTask_BlendColorCycle. Same, but selects palette by ANIM_TAG_*
void AnimTask_BlendColorCycleByTag(u8 taskId)
{
gTasks[taskId].tPalTag = gBattleAnimArgs[0];
gTasks[taskId].tDelay = gBattleAnimArgs[1];
gTasks[taskId].tNumBlends = gBattleAnimArgs[2];
gTasks[taskId].tInitialBlendY = gBattleAnimArgs[3];
gTasks[taskId].tTargetBlendY = gBattleAnimArgs[4];
gTasks[taskId].tBlendColor = gBattleAnimArgs[5];
CMD_ARGS(tag, delay, numBlends, initialBlendY, targetBlendY, color);
gTasks[taskId].tPalTag = cmd->tag;
gTasks[taskId].tDelay = cmd->delay;
gTasks[taskId].tNumBlends = cmd->numBlends;
gTasks[taskId].tInitialBlendY = cmd->initialBlendY;
gTasks[taskId].tTargetBlendY = cmd->targetBlendY;
gTasks[taskId].tBlendColor = cmd->color;
gTasks[taskId].tRestoreBlend = FALSE;
BlendColorCycleByTag(taskId, 0, gTasks[taskId].tTargetBlendY);
@ -634,26 +657,36 @@ static void AnimTask_BlendColorCycleByTagLoop(u8 taskId)
#undef tPalSelectorLo
// Flashes the specified anim tag with given color. Used e.g. to flash the particles red in Hyper Beam
#define tTimer data[0]
#define tDelay data[1]
#define tNumBlends data[2]
#define tColor1 data[3]
#define tBlendY1 data[4]
#define tColor2 data[5]
#define tBlendY2 data[6]
#define tAnimTag data[7]
void AnimTask_FlashAnimTagWithColor(u8 taskId)
{
CMD_ARGS(tag, delay, numBlends, color1, blendY1, color2, blendY2);
u8 paletteIndex;
gTasks[taskId].data[0] = gBattleAnimArgs[1];
gTasks[taskId].data[1] = gBattleAnimArgs[1];
gTasks[taskId].data[2] = gBattleAnimArgs[2];
gTasks[taskId].data[3] = gBattleAnimArgs[3];
gTasks[taskId].data[4] = gBattleAnimArgs[4];
gTasks[taskId].data[5] = gBattleAnimArgs[5];
gTasks[taskId].data[6] = gBattleAnimArgs[6];
gTasks[taskId].data[7] = gBattleAnimArgs[0];
gTasks[taskId].tTimer = cmd->delay;
gTasks[taskId].tDelay = cmd->delay;
gTasks[taskId].tNumBlends = cmd->numBlends;
gTasks[taskId].tColor1 = cmd->color1;
gTasks[taskId].tBlendY1 = cmd->blendY1;
gTasks[taskId].tColor2 = cmd->color2;
gTasks[taskId].tBlendY2 = cmd->blendY2;
gTasks[taskId].tAnimTag = cmd->tag;
paletteIndex = IndexOfSpritePaletteTag(gBattleAnimArgs[0]);
paletteIndex = IndexOfSpritePaletteTag(cmd->tag);
BeginNormalPaletteFade(
1 << (paletteIndex + 16),
0,
gBattleAnimArgs[4],
gBattleAnimArgs[4],
gBattleAnimArgs[3]);
cmd->blendY1,
cmd->blendY1,
cmd->color1);
gTasks[taskId].func = AnimTask_FlashAnimTagWithColor_Step1;
}
@ -662,44 +695,44 @@ static void AnimTask_FlashAnimTagWithColor_Step1(u8 taskId)
{
u32 selectedPalettes;
if (gTasks[taskId].data[0] > 0)
if (gTasks[taskId].tTimer > 0)
{
gTasks[taskId].data[0]--;
gTasks[taskId].tTimer--;
return;
}
if (gPaletteFade.active)
return;
if (gTasks[taskId].data[2] == 0)
if (gTasks[taskId].tNumBlends == 0)
{
gTasks[taskId].func = AnimTask_FlashAnimTagWithColor_Step2;
return;
}
selectedPalettes = 1 << (IndexOfSpritePaletteTag(gTasks[taskId].data[7]) + 16);
if (gTasks[taskId].data[1] & 0x100)
selectedPalettes = 1 << (IndexOfSpritePaletteTag(gTasks[taskId].tAnimTag) + 16);
if (gTasks[taskId].tDelay & 0x100)
{
BeginNormalPaletteFade(
selectedPalettes,
0,
gTasks[taskId].data[4],
gTasks[taskId].data[4],
gTasks[taskId].data[3]);
gTasks[taskId].tBlendY1,
gTasks[taskId].tBlendY1,
gTasks[taskId].tColor1);
}
else
{
BeginNormalPaletteFade(
selectedPalettes,
0,
gTasks[taskId].data[6],
gTasks[taskId].data[6],
gTasks[taskId].data[5]);
gTasks[taskId].tBlendY2,
gTasks[taskId].tBlendY2,
gTasks[taskId].tColor2);
}
gTasks[taskId].data[1] ^= 0x100;
gTasks[taskId].data[0] = gTasks[taskId].data[1] & 0xFF;
gTasks[taskId].data[2]--;
gTasks[taskId].tDelay ^= 0x100;
gTasks[taskId].tTimer = gTasks[taskId].tDelay & 0xFF;
gTasks[taskId].tNumBlends--;
}
static void AnimTask_FlashAnimTagWithColor_Step2(u8 taskId)
@ -708,25 +741,36 @@ static void AnimTask_FlashAnimTagWithColor_Step2(u8 taskId)
if (!gPaletteFade.active)
{
selectedPalettes = 1 << (IndexOfSpritePaletteTag(gTasks[taskId].data[7]) + 16);
selectedPalettes = 1 << (IndexOfSpritePaletteTag(gTasks[taskId].tAnimTag) + 16);
BeginNormalPaletteFade(selectedPalettes, 0, 0, 0, RGB_BLACK);
DestroyAnimVisualTask(taskId);
}
}
#undef tTimer
#undef tDelay
#undef tNumBlends
#undef tColor1
#undef tBlendY1
#undef tColor2
#undef tBlendY2
#undef tAnimTag
void AnimTask_InvertScreenColor(u8 taskId)
{
CMD_ARGS(flagsScenery, flagsAttacker, flagsTarget);
u32 selectedPalettes = 0;
u8 attackerBattler = gBattleAnimAttacker;
u8 targetBattler = gBattleAnimTarget;
if (gBattleAnimArgs[0] & 0x100)
if (cmd->flagsScenery & (1 << 8))
selectedPalettes = GetBattlePalettesMask(TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE);
if (gBattleAnimArgs[1] & 0x100)
if (cmd->flagsAttacker & (1 << 8))
selectedPalettes |= (0x10000 << attackerBattler);
if (gBattleAnimArgs[2] & 0x100)
if (cmd->flagsTarget & (1 << 8))
selectedPalettes |= (0x10000 << targetBattler);
InvertPlttBuffer(selectedPalettes);
@ -744,6 +788,8 @@ void AnimTask_InvertScreenColor(u8 taskId)
#define tColorB data[7]
void AnimTask_TintPalettes(u8 taskId)
{
CMD_ARGS(flagsScenery, flagsAttacker, flagsTarget, duration, r, g, b);
u8 attackerBattler;
u8 targetBattler;
u8 paletteIndex;
@ -751,13 +797,13 @@ void AnimTask_TintPalettes(u8 taskId)
if (gTasks[taskId].tTimer == 0)
{
gTasks[taskId].tFlagsScenery = gBattleAnimArgs[0];
gTasks[taskId].tFlagsAttacker = gBattleAnimArgs[1];
gTasks[taskId].tFlagsTarget = gBattleAnimArgs[2];
gTasks[taskId].tLength = gBattleAnimArgs[3];
gTasks[taskId].tColorR = gBattleAnimArgs[4];
gTasks[taskId].tColorG = gBattleAnimArgs[5];
gTasks[taskId].tColorB = gBattleAnimArgs[6];
gTasks[taskId].tFlagsScenery = cmd->flagsScenery;
gTasks[taskId].tFlagsAttacker = cmd->flagsAttacker;
gTasks[taskId].tFlagsTarget = cmd->flagsTarget;
gTasks[taskId].tLength = cmd->duration;
gTasks[taskId].tColorR = cmd->r;
gTasks[taskId].tColorG = cmd->g;
gTasks[taskId].tColorB = cmd->b;
}
gTasks[taskId].tTimer++;
@ -795,25 +841,34 @@ void AnimTask_TintPalettes(u8 taskId)
#undef tColorG
#undef tColorB
#define sShakeVelocity data[0]
#define sShakeTimer data[1]
#define sShakeDuration data[2]
#define sTimer data[3]
#define sOriginalValue data[4]
#define sType data[5]
#define sShakePtrLo data[6]
#define sShakePtrHi data[7]
static void AnimShakeMonOrBattlePlatforms(struct Sprite *sprite)
{
u16 var0;
CMD_ARGS(velocity, shakeTimer, shakeDuration, type, battlerSelector);
sprite->invisible = TRUE;
sprite->data[0] = -gBattleAnimArgs[0];
sprite->data[1] = gBattleAnimArgs[1];
sprite->data[2] = gBattleAnimArgs[1];
sprite->data[3] = gBattleAnimArgs[2];
sprite->sShakeVelocity = -cmd->velocity;
sprite->sShakeTimer = cmd->shakeTimer;
sprite->sShakeDuration = cmd->shakeTimer;
sprite->sTimer = cmd->shakeDuration;
switch (gBattleAnimArgs[3])
switch (cmd->type)
{
case 0:
case SHAKE_BG_X:
StoreSpriteCallbackInData6(sprite, (void *)&gBattle_BG3_X);
break;
case 1:
case SHAKE_BG_Y:
StoreSpriteCallbackInData6(sprite, (void *)&gBattle_BG3_Y);
break;
case 2:
case SHAKE_MON_X:
StoreSpriteCallbackInData6(sprite, (void *)&gSpriteCoordOffsetX);
break;
default:
@ -821,10 +876,9 @@ static void AnimShakeMonOrBattlePlatforms(struct Sprite *sprite)
break;
}
sprite->data[4] = *(u16 *)(sprite->data[6] | (sprite->data[7] << 16));
sprite->data[5] = gBattleAnimArgs[3];
var0 = sprite->data[5] - 2;
if (var0 < 2)
sprite->sOriginalValue = *(u16 *)(sprite->sShakePtrLo | (sprite->sShakePtrHi << 16));
sprite->sType = cmd->type;
if (sprite->sType == SHAKE_MON_X || sprite->sType == SHAKE_MON_Y)
AnimShakeMonOrBattlePlatforms_UpdateCoordOffsetEnabled();
sprite->callback = AnimShakeMonOrBattlePlatforms_Step;
@ -833,27 +887,25 @@ static void AnimShakeMonOrBattlePlatforms(struct Sprite *sprite)
static void AnimShakeMonOrBattlePlatforms_Step(struct Sprite *sprite)
{
u8 i;
u16 var0;
if (sprite->data[3] > 0)
if (sprite->sTimer > 0)
{
sprite->data[3]--;
if (sprite->data[1] > 0)
sprite->sTimer--;
if (sprite->sShakeTimer > 0)
{
sprite->data[1]--;
sprite->sShakeTimer--;
}
else
{
sprite->data[1] = sprite->data[2];
*(u16 *)(sprite->data[6] | (sprite->data[7] << 16)) += sprite->data[0];
sprite->data[0] = -sprite->data[0];
sprite->sShakeTimer = sprite->sShakeDuration;
*(u16 *)(sprite->sShakePtrLo | (sprite->sShakePtrHi << 16)) += sprite->sShakeVelocity;
sprite->sShakeVelocity = -sprite->sShakeVelocity;
}
}
else
{
*(u16 *)(sprite->data[6] | (sprite->data[7] << 16)) = sprite->data[4];
var0 = sprite->data[5] - 2;
if (var0 < 2)
*(u16 *)(sprite->sShakePtrLo | (sprite->sShakePtrHi << 16)) = sprite->sOriginalValue;
if (sprite->sType == SHAKE_MON_X || sprite->sType == SHAKE_MON_Y)
{
for (i = 0; i < gBattlersCount; i++)
gSprites[gBattlerSpriteIds[i]].coordOffsetEnabled = FALSE;
@ -865,23 +917,35 @@ static void AnimShakeMonOrBattlePlatforms_Step(struct Sprite *sprite)
static void AnimShakeMonOrBattlePlatforms_UpdateCoordOffsetEnabled(void)
{
// Matches AnimShakeMonOrBattlePlatforms.
CMD_ARGS(velocity, shakeDuration, duration, type, battlerSelector);
gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].coordOffsetEnabled = FALSE;
gSprites[gBattlerSpriteIds[gBattleAnimTarget]].coordOffsetEnabled = FALSE;
if (gBattleAnimArgs[4] == 2)
if (cmd->battlerSelector == 2)
{
gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].coordOffsetEnabled = TRUE;
gSprites[gBattlerSpriteIds[gBattleAnimTarget]].coordOffsetEnabled = TRUE;
}
else
{
if (gBattleAnimArgs[4] == 0)
if (cmd->battlerSelector == 0)
gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].coordOffsetEnabled = TRUE;
else
gSprites[gBattlerSpriteIds[gBattleAnimTarget]].coordOffsetEnabled = TRUE;
}
}
#undef sShakeVelocity
#undef sShakeTimer
#undef sShakeDuration
#undef sTimer
#undef sOriginalValue
#undef sType
#undef sShakePtrLo
#undef sShakePtrHi
// Task data for AnimTask_ShakeBattlePlatforms
#define tXOffset data[0]
#define tYOffset data[1]
@ -890,19 +954,17 @@ static void AnimShakeMonOrBattlePlatforms_UpdateCoordOffsetEnabled(void)
#define tShakeDelay data[8]
// Can shake battle platforms back and forth on the X or down and back to original pos on Y (cant shake up from orig pos)
// arg0: x offset of shake
// arg1: y offset of shake
// arg2: number of shakes
// arg3: time between shakes
void AnimTask_ShakeBattlePlatforms(u8 taskId)
{
gTasks[taskId].tXOffset = gBattleAnimArgs[0];
gTasks[taskId].tYOffset = gBattleAnimArgs[1];
gTasks[taskId].tNumShakes = gBattleAnimArgs[2];
gTasks[taskId].tTimer = gBattleAnimArgs[3];
gTasks[taskId].tShakeDelay = gBattleAnimArgs[3];
gBattle_BG3_X = gBattleAnimArgs[0];
gBattle_BG3_Y = gBattleAnimArgs[1];
CMD_ARGS(xOffset, yOffset, shakes, delay);
gTasks[taskId].tXOffset = cmd->xOffset;
gTasks[taskId].tYOffset = cmd->yOffset;
gTasks[taskId].tNumShakes = cmd->shakes;
gTasks[taskId].tTimer = cmd->delay;
gTasks[taskId].tShakeDelay = cmd->delay;
gBattle_BG3_X = cmd->xOffset;
gBattle_BG3_Y = cmd->yOffset;
gTasks[taskId].func = AnimTask_ShakeBattlePlatforms_Step;
gTasks[taskId].func(taskId);
}
@ -943,8 +1005,10 @@ static void AnimTask_ShakeBattlePlatforms_Step(u8 taskId)
static void AnimHitSplatBasic(struct Sprite *sprite)
{
StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
if (gBattleAnimArgs[2] == ANIM_ATTACKER)
CMD_ARGS(x, y, relativeTo, animation);
StartSpriteAffineAnim(sprite, cmd->animation);
if (cmd->relativeTo == ANIM_ATTACKER)
InitSpritePosToAnimAttacker(sprite, TRUE);
else
InitSpritePosToAnimTarget(sprite, TRUE);
@ -953,16 +1017,18 @@ static void AnimHitSplatBasic(struct Sprite *sprite)
StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
}
// Same as basic hit splat but takes a length of time to persist for (arg4)
// Same as basic hit splat but takes a length of time to persist for.
static void AnimHitSplatPersistent(struct Sprite *sprite)
{
StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
if (gBattleAnimArgs[2] == ANIM_ATTACKER)
CMD_ARGS(x, y, relativeTo, animation, duration);
StartSpriteAffineAnim(sprite, cmd->animation);
if (cmd->relativeTo == ANIM_ATTACKER)
InitSpritePosToAnimAttacker(sprite, TRUE);
else
InitSpritePosToAnimTarget(sprite, TRUE);
sprite->data[0] = gBattleAnimArgs[4];
sprite->data[0] = cmd->duration;
sprite->callback = RunStoredCallbackWhenAffineAnimEnds;
StoreSpriteCallbackInData6(sprite, DestroyAnimSpriteAfterTimer);
}
@ -971,19 +1037,24 @@ static void AnimHitSplatPersistent(struct Sprite *sprite)
// Used by Twineedle and Spike Cannon
static void AnimHitSplatHandleInvert(struct Sprite *sprite)
{
// Matches AnimHitSplatBasic.
CMD_ARGS(x, y, relativeTo, animation);
if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER && !IsContest())
gBattleAnimArgs[1] = -gBattleAnimArgs[1];
cmd->y = -cmd->y;
AnimHitSplatBasic(sprite);
}
static void AnimHitSplatRandom(struct Sprite *sprite)
{
if (gBattleAnimArgs[1] == -1)
gBattleAnimArgs[1] = Random2() & 3;
CMD_ARGS(relativeTo, animation);
StartSpriteAffineAnim(sprite, gBattleAnimArgs[1]);
if (gBattleAnimArgs[0] == ANIM_ATTACKER)
if (cmd->animation == -1)
cmd->animation = Random2() & 3;
StartSpriteAffineAnim(sprite, cmd->animation);
if (cmd->relativeTo == ANIM_ATTACKER)
InitSpritePosToAnimAttacker(sprite, FALSE);
else
InitSpritePosToAnimTarget(sprite, FALSE);
@ -997,32 +1068,38 @@ static void AnimHitSplatRandom(struct Sprite *sprite)
static void AnimHitSplatOnMonEdge(struct Sprite *sprite)
{
sprite->data[0] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]);
CMD_ARGS(relativeTo, x, y, animation);
sprite->data[0] = GetAnimBattlerSpriteId(cmd->relativeTo);
sprite->x = gSprites[sprite->data[0]].x + gSprites[sprite->data[0]].x2;
sprite->y = gSprites[sprite->data[0]].y + gSprites[sprite->data[0]].y2;
sprite->x2 = gBattleAnimArgs[1];
sprite->y2 = gBattleAnimArgs[2];
StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
sprite->x2 = cmd->x;
sprite->y2 = cmd->y;
StartSpriteAffineAnim(sprite, cmd->animation);
StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix);
sprite->callback = RunStoredCallbackWhenAffineAnimEnds;
}
static void AnimCrossImpact(struct Sprite *sprite)
{
if (gBattleAnimArgs[2] == ANIM_ATTACKER)
CMD_ARGS(x, y, relativeTo, duration);
if (cmd->relativeTo == ANIM_ATTACKER)
InitSpritePosToAnimAttacker(sprite, TRUE);
else
InitSpritePosToAnimTarget(sprite, TRUE);
sprite->data[0] = gBattleAnimArgs[3];
sprite->data[0] = cmd->duration;
StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
sprite->callback = WaitAnimForDuration;
}
static void AnimFlashingHitSplat(struct Sprite *sprite)
{
StartSpriteAffineAnim(sprite, gBattleAnimArgs[3]);
if (gBattleAnimArgs[2] == ANIM_ATTACKER)
CMD_ARGS(x, y, relativeTo, animation);
StartSpriteAffineAnim(sprite, cmd->animation);
if (cmd->relativeTo == ANIM_ATTACKER)
InitSpritePosToAnimAttacker(sprite, TRUE);
else
InitSpritePosToAnimTarget(sprite, TRUE);