tumbledemerald-legacy/src/battle_anim_mons.c

2559 lines
74 KiB
C
Raw Normal View History

2022-05-19 19:14:13 +02:00
#include "global.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 "malloc.h"
#include "palette.h"
#include "pokemon_icon.h"
#include "sprite.h"
#include "task.h"
#include "trig.h"
#include "util.h"
#include "constants/battle_anim.h"
#define IS_DOUBLE_BATTLE() ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
extern const struct OamData gOamData_AffineNormal_ObjNormal_64x64;
static void AnimTranslateLinear_WithFollowup_SetCornerVecX(struct Sprite *sprite);
static void AnimFastTranslateLinearWaitEnd(struct Sprite *sprite);
static void AnimThrowProjectile_Step(struct Sprite *sprite);
static void AnimBattlerTrace(struct Sprite *sprite);
static void AnimWeatherBallUp_Step(struct Sprite *sprite);
static u16 GetBattlerYDeltaFromSpriteId(u8 spriteId);
static void AnimTask_BlendPalInAndOutSetup(struct Task *task);
static void AnimTask_AlphaFadeIn_Step(u8 taskId);
static void AnimTask_AttackerPunchWithTrace_Step(u8 taskId);
static void AnimTask_BlendMonInAndOut_Step(u8 taskId);
static bool8 ShouldRotScaleSpeciesBeFlipped(void);
static void CreateBattlerTrace(struct Task *task, u8 taskId);
EWRAM_DATA static union AffineAnimCmd *sAnimTaskAffineAnim = NULL;
static const struct UCoords8 sBattlerCoords[][MAX_BATTLERS_COUNT] =
{
{ // Single battle
{ 72, 80 },
{ 176, 40 },
{ 48, 40 },
{ 112, 80 },
},
{ // Double battle
{ 32, 80 },
{ 200, 40 },
{ 90, 88 },
{ 152, 32 },
},
};
// One entry for each of the four Castform forms.
const struct MonCoords gCastformFrontSpriteCoords[NUM_CASTFORM_FORMS] =
{
[CASTFORM_NORMAL] = { .size = MON_COORDS_SIZE(32, 32), .y_offset = 17 },
[CASTFORM_FIRE] = { .size = MON_COORDS_SIZE(48, 48), .y_offset = 9 },
[CASTFORM_WATER] = { .size = MON_COORDS_SIZE(32, 48), .y_offset = 9 },
[CASTFORM_ICE] = { .size = MON_COORDS_SIZE(64, 48), .y_offset = 8 },
};
static const u8 sCastformElevations[NUM_CASTFORM_FORMS] =
{
[CASTFORM_NORMAL] = 13,
[CASTFORM_FIRE] = 14,
[CASTFORM_WATER] = 13,
[CASTFORM_ICE] = 13,
};
// Y position of the backsprite for each of the four Castform forms.
static const u8 sCastformBackSpriteYCoords[NUM_CASTFORM_FORMS] =
{
[CASTFORM_NORMAL] = 0,
[CASTFORM_FIRE] = 0,
[CASTFORM_WATER] = 0,
[CASTFORM_ICE] = 0,
};
// Placeholders for pokemon sprites to be created for a move animation effect (e.g. Role Play / Snatch)
#define TAG_MOVE_EFFECT_MON_1 55125
#define TAG_MOVE_EFFECT_MON_2 55126
static const struct SpriteTemplate sSpriteTemplate_MoveEffectMons[] =
{
{
.tileTag = TAG_MOVE_EFFECT_MON_1,
.paletteTag = TAG_MOVE_EFFECT_MON_1,
.oam = &gOamData_AffineNormal_ObjNormal_64x64,
.anims = gDummySpriteAnimTable,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy,
},
{
.tileTag = TAG_MOVE_EFFECT_MON_2,
.paletteTag = TAG_MOVE_EFFECT_MON_2,
.oam = &gOamData_AffineNormal_ObjNormal_64x64,
.anims = gDummySpriteAnimTable,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy,
}
};
static const struct SpriteSheet sSpriteSheet_MoveEffectMons[] =
{
{ gMiscBlank_Gfx, MON_PIC_SIZE, TAG_MOVE_EFFECT_MON_1, },
{ gMiscBlank_Gfx, MON_PIC_SIZE, TAG_MOVE_EFFECT_MON_2, },
};
u8 GetBattlerSpriteCoord(u8 battlerId, u8 coordType)
{
u8 retVal;
u16 species;
struct BattleSpriteInfo *spriteInfo;
if (IsContest())
{
if (coordType == BATTLER_COORD_Y_PIC_OFFSET && battlerId == 3)
coordType = BATTLER_COORD_Y;
}
switch (coordType)
{
case BATTLER_COORD_X:
case BATTLER_COORD_X_2:
retVal = sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].x;
break;
case BATTLER_COORD_Y:
retVal = sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].y;
break;
case BATTLER_COORD_Y_PIC_OFFSET:
case BATTLER_COORD_Y_PIC_OFFSET_DEFAULT:
default:
if (IsContest())
{
if (gContestResources->moveAnim->hasTargetAnim)
species = gContestResources->moveAnim->targetSpecies;
else
species = gContestResources->moveAnim->species;
}
else
{
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
}
}
if (coordType == BATTLER_COORD_Y_PIC_OFFSET)
retVal = GetBattlerSpriteFinal_Y(battlerId, species, TRUE);
else
retVal = GetBattlerSpriteFinal_Y(battlerId, species, FALSE);
break;
}
return retVal;
}
u8 GetBattlerYDelta(u8 battlerId, u16 species)
{
u16 letter;
u32 personality;
struct BattleSpriteInfo *spriteInfo;
u8 ret;
u16 coordSpecies;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER || IsContest())
{
if (species == SPECIES_UNOWN)
{
if (IsContest())
{
if (gContestResources->moveAnim->hasTargetAnim)
personality = gContestResources->moveAnim->targetPersonality;
else
personality = gContestResources->moveAnim->personality;
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY);
else
personality = gTransformedPersonalities[battlerId];
}
letter = GET_UNOWN_LETTER(personality);
if (!letter)
coordSpecies = species;
else
coordSpecies = letter + SPECIES_UNOWN_B - 1;
ret = gMonBackPicCoords[coordSpecies].y_offset;
}
else if (species == SPECIES_CASTFORM)
{
ret = sCastformBackSpriteYCoords[gBattleMonForms[battlerId]];
}
else if (species > NUM_SPECIES)
{
ret = gMonBackPicCoords[0].y_offset;
}
else
{
ret = gMonBackPicCoords[species].y_offset;
}
}
else
{
if (species == SPECIES_UNOWN)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY);
else
personality = gTransformedPersonalities[battlerId];
letter = GET_UNOWN_LETTER(personality);
if (!letter)
coordSpecies = species;
else
coordSpecies = letter + SPECIES_UNOWN_B - 1;
ret = gMonFrontPicCoords[coordSpecies].y_offset;
}
else if (species == SPECIES_CASTFORM)
{
ret = gCastformFrontSpriteCoords[gBattleMonForms[battlerId]].y_offset;
}
else if (species > NUM_SPECIES)
{
ret = gMonFrontPicCoords[0].y_offset;
}
else
{
ret = gMonFrontPicCoords[species].y_offset;
}
}
return ret;
}
u8 GetBattlerElevation(u8 battlerId, u16 species)
{
u8 ret = 0;
if (GetBattlerSide(battlerId) == B_SIDE_OPPONENT)
{
if (!IsContest())
{
if (species == SPECIES_CASTFORM)
ret = sCastformElevations[gBattleMonForms[battlerId]];
else if (species > NUM_SPECIES)
ret = gEnemyMonElevation[0];
else
ret = gEnemyMonElevation[species];
}
}
return ret;
}
u8 GetBattlerSpriteFinal_Y(u8 battlerId, u16 species, bool8 a3)
{
u16 offset;
u8 y;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER || IsContest())
{
offset = GetBattlerYDelta(battlerId, species);
}
else
{
offset = GetBattlerYDelta(battlerId, species);
offset -= GetBattlerElevation(battlerId, species);
}
y = offset + sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].y;
if (a3)
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
y += 8;
if (y > DISPLAY_HEIGHT - MON_PIC_HEIGHT + 8)
y = DISPLAY_HEIGHT - MON_PIC_HEIGHT + 8;
}
return y;
}
u8 GetBattlerSpriteCoord2(u8 battlerId, u8 coordType)
{
u16 species;
struct BattleSpriteInfo *spriteInfo;
if (coordType == BATTLER_COORD_Y_PIC_OFFSET || coordType == BATTLER_COORD_Y_PIC_OFFSET_DEFAULT)
{
if (IsContest())
{
if (gContestResources->moveAnim->hasTargetAnim)
species = gContestResources->moveAnim->targetSpecies;
else
species = gContestResources->moveAnim->species;
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = gAnimBattlerSpecies[battlerId];
else
species = spriteInfo[battlerId].transformSpecies;
}
if (coordType == BATTLER_COORD_Y_PIC_OFFSET)
return GetBattlerSpriteFinal_Y(battlerId, species, TRUE);
else
return GetBattlerSpriteFinal_Y(battlerId, species, FALSE);
}
else
{
return GetBattlerSpriteCoord(battlerId, coordType);
}
}
u8 GetBattlerSpriteDefault_Y(u8 battlerId)
{
return GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y_PIC_OFFSET_DEFAULT);
}
u8 GetSubstituteSpriteDefault_Y(u8 battlerId)
{
u16 y;
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 16;
else
y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 17;
return y;
}
u8 GetBattlerYCoordWithElevation(u8 battlerId)
{
u16 species;
u8 y;
struct BattleSpriteInfo *spriteInfo;
y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y);
if (!IsContest())
{
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
}
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
y -= GetBattlerElevation(battlerId, species);
}
return y;
}
u8 GetAnimBattlerSpriteId(u8 animBattler)
{
u8 *sprites;
if (animBattler == ANIM_ATTACKER)
{
if (IsBattlerSpritePresent(gBattleAnimAttacker))
{
sprites = gBattlerSpriteIds;
return sprites[gBattleAnimAttacker];
}
else
{
return SPRITE_NONE;
}
}
else if (animBattler == ANIM_TARGET)
{
if (IsBattlerSpritePresent(gBattleAnimTarget))
{
sprites = gBattlerSpriteIds;
return sprites[gBattleAnimTarget];
}
else
{
return SPRITE_NONE;
}
}
else if (animBattler == ANIM_ATK_PARTNER)
{
if (!IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker)))
return SPRITE_NONE;
else
return gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimAttacker)];
}
else
{
if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget)))
return gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimTarget)];
else
return SPRITE_NONE;
}
}
void StoreSpriteCallbackInData6(struct Sprite *sprite, void (*callback)(struct Sprite*))
{
sprite->data[6] = (u32)(callback) & 0xffff;
sprite->data[7] = (u32)(callback) >> 16;
}
void SetCallbackToStoredInData6(struct Sprite *sprite)
{
u32 callback = (u16)sprite->data[6] | (sprite->data[7] << 16);
sprite->callback = (void (*)(struct Sprite *))callback;
}
// Sprite data for TranslateSpriteInCircle/Ellipse and related
#define sCirclePos data[0]
#define sAmplitude data[1]
#define sCircleSpeed data[2]
#define sDuration data[3]
// TranslateSpriteInGrowingCircle
#define sAmplitudeSpeed data[4]
#define sAmplitudeChange data[5]
// TranslateSpriteInEllipse
#define sAmplitudeX sAmplitude
#define sAmplitudeY data[4]
// TranslateSpriteInWavePattern
#define sCirclePosX sCirclePos
#define sCircleSpeedX sCircleSpeed
#define sCirclePosY data[4]
#define sCircleSpeedY data[5]
void TranslateSpriteInCircle(struct Sprite *sprite)
{
if (sprite->sDuration)
{
sprite->x2 = Sin(sprite->sCirclePos, sprite->sAmplitude);
sprite->y2 = Cos(sprite->sCirclePos, sprite->sAmplitude);
sprite->sCirclePos += sprite->sCircleSpeed;
if (sprite->sCirclePos >= 0x100)
sprite->sCirclePos -= 0x100;
else if (sprite->sCirclePos < 0)
sprite->sCirclePos += 0x100;
sprite->sDuration--;
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
void TranslateSpriteInGrowingCircle(struct Sprite *sprite)
{
if (sprite->sDuration)
{
sprite->x2 = Sin(sprite->sCirclePos, (sprite->sAmplitudeChange >> 8) + sprite->sAmplitude);
sprite->y2 = Cos(sprite->sCirclePos, (sprite->sAmplitudeChange >> 8) + sprite->sAmplitude);
sprite->sCirclePos += sprite->sCircleSpeed;
sprite->sAmplitudeChange += sprite->sAmplitudeSpeed;
if (sprite->sCirclePos >= 0x100)
sprite->sCirclePos -= 0x100;
else if (sprite->sCirclePos < 0)
sprite->sCirclePos += 0x100;
sprite->sDuration--;
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
// Unused
// Exact shape depends on arguments. Can move in a figure-8-like pattern, or circular, etc.
static void TranslateSpriteInWavePattern(struct Sprite *sprite)
{
if (sprite->sDuration)
{
sprite->x2 = Sin(sprite->sCirclePosX, sprite->sAmplitude);
sprite->y2 = Cos(sprite->sCirclePosY, sprite->sAmplitude);
sprite->sCirclePosX += sprite->sCircleSpeedX;
sprite->sCirclePosY += sprite->sCircleSpeedY;
if (sprite->sCirclePosX >= 0x100)
sprite->sCirclePosX -= 0x100;
else if (sprite->sCirclePosX < 0)
sprite->sCirclePosX += 0x100;
if (sprite->sCirclePosY >= 0x100)
sprite->sCirclePosY -= 0x100;
else if (sprite->sCirclePosY < 0)
sprite->sCirclePosY += 0x100;
sprite->sDuration--;
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
void TranslateSpriteInEllipse(struct Sprite *sprite)
{
if (sprite->sDuration)
{
sprite->x2 = Sin(sprite->sCirclePos, sprite->sAmplitudeX);
sprite->y2 = Cos(sprite->sCirclePos, sprite->sAmplitudeY);
sprite->sCirclePos += sprite->sCircleSpeed;
if (sprite->sCirclePos >= 0x100)
sprite->sCirclePos -= 0x100;
else if (sprite->sCirclePos < 0)
sprite->sCirclePos += 0x100;
sprite->sDuration--;
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
#undef sCirclePos
#undef sAmplitude
#undef sCircleSpeed
#undef sDuration
#undef sAmplitudeSpeed
#undef sAmplitudeChange
#undef sAmplitudeX
#undef sAmplitudeY
#undef sCirclePosX
#undef sCircleSpeedX
#undef sCirclePosY
#undef sCircleSpeedY
// Simply waits until the sprite's data[0] hits zero.
// This is used to let sprite anims or affine anims to run for a designated
// duration.
void WaitAnimForDuration(struct Sprite *sprite)
{
if (sprite->data[0] > 0)
sprite->data[0]--;
else
SetCallbackToStoredInData6(sprite);
}
// Sprite data for ConvertPosDataToTranslateLinearData
#define sStepsX data[0]
#define sStartX data[1]
#define sTargetX data[2]
#define sStartY data[3]
#define sTargetY data[4]
// Sprite data for TranslateSpriteLinear
#define sMoveSteps data[0]
#define sSpeedX data[1]
#define sSpeedY data[2]
// Functionally unused
static void AnimPosToTranslateLinear(struct Sprite *sprite)
{
ConvertPosDataToTranslateLinearData(sprite);
sprite->callback = TranslateSpriteLinear;
sprite->callback(sprite);
}
void ConvertPosDataToTranslateLinearData(struct Sprite *sprite)
{
s16 old;
int xDiff;
if (sprite->sStartX > sprite->sTargetX)
sprite->sStepsX = -sprite->sStepsX;
xDiff = sprite->sTargetX - sprite->sStartX;
old = sprite->sStepsX;
sprite->sMoveSteps = abs(xDiff / sprite->sStepsX);
sprite->sSpeedY = (sprite->sTargetY - sprite->sStartY) / sprite->sMoveSteps;
sprite->sSpeedX = old;
}
void TranslateSpriteLinear(struct Sprite *sprite)
{
if (sprite->sMoveSteps > 0)
{
sprite->sMoveSteps--;
sprite->x2 += sprite->sSpeedX;
sprite->y2 += sprite->sSpeedY;
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
void TranslateSpriteLinearFixedPoint(struct Sprite *sprite)
{
if (sprite->data[0] > 0)
{
sprite->data[0]--;
sprite->data[3] += sprite->data[1];
sprite->data[4] += sprite->data[2];
sprite->x2 = sprite->data[3] >> 8;
sprite->y2 = sprite->data[4] >> 8;
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
static void TranslateSpriteLinearFixedPointIconFrame(struct Sprite *sprite)
{
if (sprite->data[0] > 0)
{
sprite->data[0]--;
sprite->data[3] += sprite->data[1];
sprite->data[4] += sprite->data[2];
sprite->x2 = sprite->data[3] >> 8;
sprite->y2 = sprite->data[4] >> 8;
}
else
{
SetCallbackToStoredInData6(sprite);
}
UpdateMonIconFrame(sprite);
}
// Unused
static void TranslateSpriteToBattleTargetPos(struct Sprite *sprite)
{
sprite->sStartX = sprite->x + sprite->x2;
sprite->sStartY = sprite->y + sprite->y2;
sprite->sTargetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2);
sprite->sTargetY = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET);
sprite->callback = AnimPosToTranslateLinear;
}
// Same as TranslateSpriteLinear but takes an id to specify which sprite to move
void TranslateSpriteLinearById(struct Sprite *sprite)
{
if (sprite->data[0] > 0)
{
sprite->data[0]--;
gSprites[sprite->data[3]].x2 += sprite->data[1];
gSprites[sprite->data[3]].y2 += sprite->data[2];
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
void TranslateSpriteLinearByIdFixedPoint(struct Sprite *sprite)
{
if (sprite->data[0] > 0)
{
sprite->data[0]--;
sprite->data[3] += sprite->data[1];
sprite->data[4] += sprite->data[2];
gSprites[sprite->data[5]].x2 = sprite->data[3] >> 8;
gSprites[sprite->data[5]].y2 = sprite->data[4] >> 8;
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
void TranslateSpriteLinearAndFlicker(struct Sprite *sprite)
{
if (sprite->data[0] > 0)
{
sprite->data[0]--;
sprite->x2 = sprite->data[2] >> 8;
sprite->data[2] += sprite->data[1];
sprite->y2 = sprite->data[4] >> 8;
sprite->data[4] += sprite->data[3];
if (sprite->data[0] % sprite->data[5] == 0)
{
if (sprite->data[5])
sprite->invisible ^= 1;
}
}
else
{
SetCallbackToStoredInData6(sprite);
}
}
void DestroySpriteAndMatrix(struct Sprite *sprite)
{
FreeSpriteOamMatrix(sprite);
DestroyAnimSprite(sprite);
}
// Unused
static void TranslateSpriteToBattleAttackerPos(struct Sprite *sprite)
{
sprite->sStartX = sprite->x + sprite->x2;
sprite->sStartY = sprite->y + sprite->y2;
sprite->sTargetX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2);
sprite->sTargetY = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET);
sprite->callback = AnimPosToTranslateLinear;
}
#undef sStepsX
#undef sStartX
#undef sTargetX
#undef sStartY
#undef sTargetY
// Unused
static void EndUnkPaletteAnim(struct Sprite *sprite)
{
PaletteStruct_ResetById(sprite->data[5]);
DestroySpriteAndMatrix(sprite);
}
void RunStoredCallbackWhenAffineAnimEnds(struct Sprite *sprite)
{
if (sprite->affineAnimEnded)
SetCallbackToStoredInData6(sprite);
}
void RunStoredCallbackWhenAnimEnds(struct Sprite *sprite)
{
if (sprite->animEnded)
SetCallbackToStoredInData6(sprite);
}
void DestroyAnimSpriteAndDisableBlend(struct Sprite *sprite)
{
SetGpuReg(REG_OFFSET_BLDCNT, 0);
SetGpuReg(REG_OFFSET_BLDALPHA, 0);
DestroyAnimSprite(sprite);
}
void DestroyAnimVisualTaskAndDisableBlend(u8 taskId)
{
SetGpuReg(REG_OFFSET_BLDCNT, 0);
SetGpuReg(REG_OFFSET_BLDALPHA, 0);
DestroyAnimVisualTask(taskId);
}
void SetSpriteCoordsToAnimAttackerCoords(struct Sprite *sprite)
{
sprite->x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2);
sprite->y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET);
}
// Sets the initial x offset of the anim sprite depending on the horizontal orientation
// of the two involved mons.
void SetAnimSpriteInitialXOffset(struct Sprite *sprite, s16 xOffset)
{
u16 attackerX = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X);
u16 targetX = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X);
if (attackerX > targetX)
{
sprite->x -= xOffset;
}
else if (attackerX < targetX)
{
sprite->x += xOffset;
}
else
{
if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
sprite->x -= xOffset;
else
sprite->x += xOffset;
}
}
void InitAnimArcTranslation(struct Sprite *sprite)
{
sprite->data[1] = sprite->x;
sprite->data[3] = sprite->y;
InitAnimLinearTranslation(sprite);
sprite->data[6] = 0x8000 / sprite->data[0];
sprite->data[7] = 0;
}
bool8 TranslateAnimHorizontalArc(struct Sprite *sprite)
{
if (AnimTranslateLinear(sprite))
return TRUE;
sprite->data[7] += sprite->data[6];
sprite->y2 += Sin((u8)(sprite->data[7] >> 8), sprite->data[5]);
return FALSE;
}
bool8 TranslateAnimVerticalArc(struct Sprite *sprite)
{
if (AnimTranslateLinear(sprite))
return TRUE;
sprite->data[7] += sprite->data[6];
sprite->x2 += Sin((u8)(sprite->data[7] >> 8), sprite->data[5]);
return FALSE;
}
void SetSpritePrimaryCoordsFromSecondaryCoords(struct Sprite *sprite)
{
sprite->x += sprite->x2;
sprite->y += sprite->y2;
sprite->x2 = 0;
sprite->y2 = 0;
}
void InitSpritePosToAnimTarget(struct Sprite *sprite, bool8 respectMonPicOffsets)
{
// Battle anim sprites are automatically created at the anim target's center, which
// is why there is no else clause for the "respectMonPicOffsets" check.
if (!respectMonPicOffsets)
{
sprite->x = GetBattlerSpriteCoord2(gBattleAnimTarget, BATTLER_COORD_X);
sprite->y = GetBattlerSpriteCoord2(gBattleAnimTarget, BATTLER_COORD_Y);
}
SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]);
sprite->y += gBattleAnimArgs[1];
}
void InitSpritePosToAnimAttacker(struct Sprite *sprite, bool8 respectMonPicOffsets)
{
if (!respectMonPicOffsets)
{
sprite->x = GetBattlerSpriteCoord2(gBattleAnimAttacker, BATTLER_COORD_X);
sprite->y = GetBattlerSpriteCoord2(gBattleAnimAttacker, BATTLER_COORD_Y);
}
else
{
sprite->x = GetBattlerSpriteCoord2(gBattleAnimAttacker, BATTLER_COORD_X_2);
sprite->y = GetBattlerSpriteCoord2(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET);
}
SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]);
sprite->y += gBattleAnimArgs[1];
}
u8 GetBattlerSide(u8 battlerId)
{
return GET_BATTLER_SIDE2(battlerId);
}
u8 GetBattlerPosition(u8 battlerId)
{
return GET_BATTLER_POSITION(battlerId);
}
u8 GetBattlerAtPosition(u8 position)
{
u8 i;
for (i = 0; i < gBattlersCount; i++)
{
if (gBattlerPositions[i] == position)
break;
}
return i;
}
bool8 IsBattlerSpritePresent(u8 battlerId)
{
if (IsContest())
{
if (gBattleAnimAttacker == battlerId)
return TRUE;
else if (gBattleAnimTarget == battlerId)
return TRUE;
else
return FALSE;
}
else
{
if (gBattlerPositions[battlerId] == 0xff)
{
return FALSE;
}
else if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
{
if (GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_HP) != 0)
return TRUE;
}
else
{
if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_HP) != 0)
return TRUE;
}
}
return FALSE;
}
bool8 IsDoubleBattle(void)
{
return IS_DOUBLE_BATTLE();
}
void GetBattleAnimBg1Data(struct BattleAnimBgData *out)
{
if (IsContest())
{
out->bgTiles = gBattleAnimBgTileBuffer;
out->bgTilemap = (u16 *)gBattleAnimBgTilemapBuffer;
out->paletteId = 14;
out->bgId = 1;
out->tilesOffset = 0;
out->unused = 0;
}
else
{
out->bgTiles = gBattleAnimBgTileBuffer;
out->bgTilemap = (u16 *)gBattleAnimBgTilemapBuffer;
out->paletteId = 8;
out->bgId = 1;
out->tilesOffset = 0x200;
out->unused = 0;
}
}
void GetBattleAnimBgData(struct BattleAnimBgData *out, u32 bgId)
{
if (IsContest())
{
out->bgTiles = gBattleAnimBgTileBuffer;
out->bgTilemap = (u16 *)gBattleAnimBgTilemapBuffer;
out->paletteId = 14;
out->bgId = 1;
out->tilesOffset = 0;
out->unused = 0;
}
else if (bgId == 1)
{
GetBattleAnimBg1Data(out);
}
else
{
out->bgTiles = gBattleAnimBgTileBuffer;
out->bgTilemap = (u16 *)gBattleAnimBgTilemapBuffer;
out->paletteId = 9;
out->bgId = 2;
out->tilesOffset = 0x300;
out->unused = 0;
}
}
void GetBgDataForTransform(struct BattleAnimBgData *out, u8 battlerId)
{
out->bgTiles = gBattleAnimBgTileBuffer;
out->bgTilemap = (u16 *)gBattleAnimBgTilemapBuffer;
if (IsContest())
{
out->paletteId = 14;
out->bgId = 1;
out->tilesOffset = 0;
out->unused = 0;
}
else if (GetBattlerSpriteBGPriorityRank(gBattleAnimAttacker) == 1)
{
out->paletteId = 8;
out->bgId = 1;
out->tilesOffset = 0x200;
out->unused = 0;
}
else
{
out->paletteId = 9;
out->bgId = 2;
out->tilesOffset = 0x300;
out->unused = 0;
}
}
void ClearBattleAnimBg(u32 bgId)
{
struct BattleAnimBgData bgAnimData;
GetBattleAnimBgData(&bgAnimData, bgId);
CpuFill32(0, bgAnimData.bgTiles, 0x2000);
LoadBgTiles(bgAnimData.bgId, bgAnimData.bgTiles, 0x2000, bgAnimData.tilesOffset);
FillBgTilemapBufferRect(bgAnimData.bgId, 0, 0, 0, 32, 64, 17);
CopyBgTilemapBufferToVram(bgAnimData.bgId);
}
void AnimLoadCompressedBgGfx(u32 bgId, const u32 *src, u32 tilesOffset)
{
CpuFill32(0, gBattleAnimBgTileBuffer, 0x2000);
LZDecompressWram(src, gBattleAnimBgTileBuffer);
LoadBgTiles(bgId, gBattleAnimBgTileBuffer, 0x2000, tilesOffset);
}
static void InitAnimBgTilemapBuffer(u32 bgId, const void *src)
{
FillBgTilemapBufferRect(bgId, 0, 0, 0, 32, 64, 17);
CopyToBgTilemapBuffer(bgId, src, 0, 0);
}
void AnimLoadCompressedBgTilemap(u32 bgId, const void *src)
{
InitAnimBgTilemapBuffer(bgId, src);
CopyBgTilemapBufferToVram(bgId);
}
void AnimLoadCompressedBgTilemapHandleContest(struct BattleAnimBgData *data, const void *src, bool32 largeScreen)
{
InitAnimBgTilemapBuffer(data->bgId, src);
if (IsContest() == TRUE)
RelocateBattleBgPal(data->paletteId, data->bgTilemap, 0, largeScreen);
CopyBgTilemapBufferToVram(data->bgId);
}
u8 GetBattleBgPaletteNum(void)
{
if (IsContest())
return 1;
else
return 2;
}
void UpdateAnimBg3ScreenSize(bool8 largeScreenSize)
{
if (!largeScreenSize || IsContest())
{
SetAnimBgAttribute(3, BG_ANIM_SCREEN_SIZE, 0);
SetAnimBgAttribute(3, BG_ANIM_AREA_OVERFLOW_MODE, 1);
}
else
{
SetAnimBgAttribute(3, BG_ANIM_SCREEN_SIZE, 1);
SetAnimBgAttribute(3, BG_ANIM_AREA_OVERFLOW_MODE, 0);
}
}
void TradeMenuBouncePartySprites(struct Sprite *sprite)
{
sprite->data[1] = sprite->x;
sprite->data[3] = sprite->y;
InitSpriteDataForLinearTranslation(sprite);
sprite->callback = TranslateSpriteLinearFixedPointIconFrame;
sprite->callback(sprite);
}
void InitSpriteDataForLinearTranslation(struct Sprite *sprite)
{
s16 x = (sprite->data[2] - sprite->data[1]) << 8;
s16 y = (sprite->data[4] - sprite->data[3]) << 8;
sprite->data[1] = x / sprite->data[0];
sprite->data[2] = y / sprite->data[0];
sprite->data[4] = 0;
sprite->data[3] = 0;
}
void InitAnimLinearTranslation(struct Sprite *sprite)
{
int x = sprite->data[2] - sprite->data[1];
int y = sprite->data[4] - sprite->data[3];
bool8 movingLeft = x < 0;
bool8 movingUp = y < 0;
u16 xDelta = abs(x) << 8;
u16 yDelta = abs(y) << 8;
xDelta = xDelta / sprite->data[0];
yDelta = yDelta / sprite->data[0];
if (movingLeft)
xDelta |= 1;
else
xDelta &= ~1;
if (movingUp)
yDelta |= 1;
else
yDelta &= ~1;
sprite->data[1] = xDelta;
sprite->data[2] = yDelta;
sprite->data[4] = 0;
sprite->data[3] = 0;
}
void StartAnimLinearTranslation(struct Sprite *sprite)
{
sprite->data[1] = sprite->x;
sprite->data[3] = sprite->y;
InitAnimLinearTranslation(sprite);
sprite->callback = AnimTranslateLinear_WithFollowup;
sprite->callback(sprite);
}
// Unused
static void StartAnimLinearTranslation_SetCornerVecX(struct Sprite *sprite)
{
sprite->data[1] = sprite->x;
sprite->data[3] = sprite->y;
InitAnimLinearTranslation(sprite);
sprite->callback = AnimTranslateLinear_WithFollowup_SetCornerVecX;
sprite->callback(sprite);
}
bool8 AnimTranslateLinear(struct Sprite *sprite)
{
u16 v1, v2, x, y;
if (!sprite->data[0])
return TRUE;
v1 = sprite->data[1];
v2 = sprite->data[2];
x = sprite->data[3];
y = sprite->data[4];
x += v1;
y += v2;
if (v1 & 1)
sprite->x2 = -(x >> 8);
else
sprite->x2 = x >> 8;
if (v2 & 1)
sprite->y2 = -(y >> 8);
else
sprite->y2 = y >> 8;
sprite->data[3] = x;
sprite->data[4] = y;
sprite->data[0]--;
return FALSE;
}
void AnimTranslateLinear_WithFollowup(struct Sprite *sprite)
{
if (AnimTranslateLinear(sprite))
SetCallbackToStoredInData6(sprite);
}
// Functionally unused
static void AnimTranslateLinear_WithFollowup_SetCornerVecX(struct Sprite *sprite)
{
AnimSetCenterToCornerVecX(sprite);
if (AnimTranslateLinear(sprite))
SetCallbackToStoredInData6(sprite);
}
void InitAnimLinearTranslationWithSpeed(struct Sprite *sprite)
{
int v1 = abs(sprite->data[2] - sprite->data[1]) << 8;
sprite->data[0] = v1 / sprite->data[0];
InitAnimLinearTranslation(sprite);
}
void InitAnimLinearTranslationWithSpeedAndPos(struct Sprite *sprite)
{
sprite->data[1] = sprite->x;
sprite->data[3] = sprite->y;
InitAnimLinearTranslationWithSpeed(sprite);
sprite->callback = AnimTranslateLinear_WithFollowup;
sprite->callback(sprite);
}
static void InitAnimFastLinearTranslation(struct Sprite *sprite)
{
int xDiff = sprite->data[2] - sprite->data[1];
int yDiff = sprite->data[4] - sprite->data[3];
bool8 x_sign = xDiff < 0;
bool8 y_sign = yDiff < 0;
u16 x2 = abs(xDiff) << 4;
u16 y2 = abs(yDiff) << 4;
x2 /= sprite->data[0];
y2 /= sprite->data[0];
if (x_sign)
x2 |= 1;
else
x2 &= ~1;
if (y_sign)
y2 |= 1;
else
y2 &= ~1;
sprite->data[1] = x2;
sprite->data[2] = y2;
sprite->data[4] = 0;
sprite->data[3] = 0;
}
void InitAndRunAnimFastLinearTranslation(struct Sprite *sprite)
{
sprite->data[1] = sprite->x;
sprite->data[3] = sprite->y;
InitAnimFastLinearTranslation(sprite);
sprite->callback = AnimFastTranslateLinearWaitEnd;
sprite->callback(sprite);
}
bool8 AnimFastTranslateLinear(struct Sprite *sprite)
{
u16 v1, v2, x, y;
if (!sprite->data[0])
return TRUE;
v1 = sprite->data[1];
v2 = sprite->data[2];
x = sprite->data[3];
y = sprite->data[4];
x += v1;
y += v2;
if (v1 & 1)
sprite->x2 = -(x >> 4);
else
sprite->x2 = x >> 4;
if (v2 & 1)
sprite->y2 = -(y >> 4);
else
sprite->y2 = y >> 4;
sprite->data[3] = x;
sprite->data[4] = y;
sprite->data[0]--;
return FALSE;
}
static void AnimFastTranslateLinearWaitEnd(struct Sprite *sprite)
{
if (AnimFastTranslateLinear(sprite))
SetCallbackToStoredInData6(sprite);
}
void InitAnimFastLinearTranslationWithSpeed(struct Sprite *sprite)
{
int xDiff = abs(sprite->data[2] - sprite->data[1]) << 4;
sprite->data[0] = xDiff / sprite->data[0];
InitAnimFastLinearTranslation(sprite);
}
void InitAnimFastLinearTranslationWithSpeedAndPos(struct Sprite *sprite)
{
sprite->data[1] = sprite->x;
sprite->data[3] = sprite->y;
InitAnimFastLinearTranslationWithSpeed(sprite);
sprite->callback = AnimFastTranslateLinearWaitEnd;
sprite->callback(sprite);
}
void SetSpriteRotScale(u8 spriteId, s16 xScale, s16 yScale, u16 rotation)
{
int i;
struct ObjAffineSrcData src;
struct OamMatrix matrix;
src.xScale = xScale;
src.yScale = yScale;
src.rotation = rotation;
if (ShouldRotScaleSpeciesBeFlipped())
src.xScale = -src.xScale;
i = gSprites[spriteId].oam.matrixNum;
ObjAffineSet(&src, &matrix, 1, 2);
gOamMatrices[i].a = matrix.a;
gOamMatrices[i].b = matrix.b;
gOamMatrices[i].c = matrix.c;
gOamMatrices[i].d = matrix.d;
}
// Pokémon in Contests (except Unown) should be flipped.
static bool8 ShouldRotScaleSpeciesBeFlipped(void)
{
if (IsContest())
{
if (gSprites[GetAnimBattlerSpriteId(ANIM_ATTACKER)].data[2] == SPECIES_UNOWN)
return FALSE;
else
return TRUE;
}
else
{
return FALSE;
}
}
void PrepareBattlerSpriteForRotScale(u8 spriteId, u8 objMode)
{
u8 battlerId = gSprites[spriteId].data[0];
if (IsContest() || IsBattlerSpriteVisible(battlerId))
gSprites[spriteId].invisible = FALSE;
gSprites[spriteId].oam.objMode = objMode;
gSprites[spriteId].affineAnimPaused = TRUE;
if (!IsContest() && !gSprites[spriteId].oam.affineMode)
gSprites[spriteId].oam.matrixNum = gBattleSpritesDataPtr->healthBoxesData[battlerId].matrixNum;
gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_DOUBLE;
CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode);
}
void ResetSpriteRotScale(u8 spriteId)
{
SetSpriteRotScale(spriteId, 0x100, 0x100, 0);
gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_NORMAL;
gSprites[spriteId].oam.objMode = ST_OAM_OBJ_NORMAL;
gSprites[spriteId].affineAnimPaused = FALSE;
CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode);
}
// Sets the sprite's y offset equal to the y displacement caused by the
// matrix's rotation.
void SetBattlerSpriteYOffsetFromRotation(u8 spriteId)
{
u16 matrixNum = gSprites[spriteId].oam.matrixNum;
// The "c" component of the battler sprite matrix contains the sine of the rotation angle divided by some scale amount.
s16 c = gOamMatrices[matrixNum].c;
if (c < 0)
c = -c;
gSprites[spriteId].y2 = c >> 3;
}
void TrySetSpriteRotScale(struct Sprite *sprite, bool8 recalcCenterVector, s16 xScale, s16 yScale, u16 rotation)
{
int i;
struct ObjAffineSrcData src;
struct OamMatrix matrix;
if (sprite->oam.affineMode & 1)
{
sprite->affineAnimPaused = TRUE;
if (recalcCenterVector)
CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode);
src.xScale = xScale;
src.yScale = yScale;
src.rotation = rotation;
if (ShouldRotScaleSpeciesBeFlipped())
src.xScale = -src.xScale;
i = sprite->oam.matrixNum;
ObjAffineSet(&src, &matrix, 1, 2);
gOamMatrices[i].a = matrix.a;
gOamMatrices[i].b = matrix.b;
gOamMatrices[i].c = matrix.c;
gOamMatrices[i].d = matrix.d;
}
}
void ResetSpriteRotScale_PreserveAffine(struct Sprite *sprite)
{
TrySetSpriteRotScale(sprite, TRUE, 0x100, 0x100, 0);
sprite->affineAnimPaused = FALSE;
CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode);
}
static u16 ArcTan2_(s16 a, s16 b)
{
return ArcTan2(a, b);
}
u16 ArcTan2Neg(s16 a, s16 b)
{
u16 var = ArcTan2_(a, b);
return -var;
}
void SetGrayscaleOrOriginalPalette(u16 paletteNum, bool8 restoreOriginalColor)
{
int i;
struct PlttData *originalColor;
struct PlttData *destColor;
u16 average;
paletteNum *= 16;
if (!restoreOriginalColor)
{
for (i = 0; i < 16; i++)
{
originalColor = (struct PlttData *)&gPlttBufferUnfaded[paletteNum + i];
average = originalColor->r + originalColor->g + originalColor->b;
average /= 3;
destColor = (struct PlttData *)&gPlttBufferFaded[paletteNum + i];
destColor->r = average;
destColor->g = average;
destColor->b = average;
}
}
else
{
CpuCopy32(&gPlttBufferUnfaded[paletteNum], &gPlttBufferFaded[paletteNum], 32);
}
}
u32 GetBattleBgPalettesMask(u8 battleBackground, u8 attacker, u8 target, u8 attackerPartner, u8 targetPartner, u8 a6, u8 a7)
{
u32 selectedPalettes = 0;
u32 shift;
if (battleBackground)
{
if (!IsContest())
selectedPalettes = 0xe;
else
selectedPalettes = 1 << GetBattleBgPaletteNum();
}
if (attacker)
{
shift = gBattleAnimAttacker + 16;
selectedPalettes |= 1 << shift;
}
if (target)
{
shift = gBattleAnimTarget + 16;
selectedPalettes |= 1 << shift;
}
if (attackerPartner)
{
if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker)))
{
shift = BATTLE_PARTNER(gBattleAnimAttacker) + 16;
selectedPalettes |= 1 << shift;
}
}
if (targetPartner)
{
if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget)))
{
shift = BATTLE_PARTNER(gBattleAnimTarget) + 16;
selectedPalettes |= 1 << shift;
}
}
if (a6)
{
if (!IsContest())
selectedPalettes |= 0x100;
else
selectedPalettes |= 0x4000;
}
if (a7)
{
if (!IsContest())
selectedPalettes |= 0x200;
}
return selectedPalettes;
}
u32 GetBattleMonSpritePalettesMask(u8 playerLeft, u8 playerRight, u8 opponentLeft, u8 opponentRight)
{
u32 selectedPalettes = 0;
u32 shift;
if (IsContest())
{
if (playerLeft)
{
selectedPalettes |= 1 << 18;
return selectedPalettes;
}
}
else
{
if (playerLeft)
{
if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)))
{
selectedPalettes |= 1 << (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) + 16);
}
}
if (playerRight)
{
if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT)))
{
shift = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT) + 16;
selectedPalettes |= 1 << shift;
}
}
if (opponentLeft)
{
if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)))
{
shift = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT) + 16;
selectedPalettes |= 1 << shift;
}
}
if (opponentRight)
{
if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT)))
{
shift = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT) + 16;
selectedPalettes |= 1 << shift;
}
}
}
return selectedPalettes;
}
// Presumably something commented here, just returns arg
u8 AnimDummyReturnArg(u8 battler)
{
return battler;
}
static u8 GetBattlerAtPosition_(u8 position)
{
return GetBattlerAtPosition(position);
}
void AnimSpriteOnMonPos(struct Sprite *sprite)
{
bool8 var;
if (!sprite->data[0])
{
if (!gBattleAnimArgs[3])
var = TRUE;
else
var = FALSE;
if (!gBattleAnimArgs[2])
InitSpritePosToAnimAttacker(sprite, var);
else
InitSpritePosToAnimTarget(sprite, var);
sprite->data[0]++;
}
else if (sprite->animEnded || sprite->affineAnimEnded)
{
DestroySpriteAndMatrix(sprite);
}
}
// Linearly translates a sprite to a target position on the
// other mon's sprite.
// arg 0: initial x offset
// arg 1: initial y offset
// arg 2: target x offset
// arg 3: target y offset
// arg 4: duration
// arg 5: lower 8 bits = location on attacking mon, upper 8 bits = location on target mon pick to target
void TranslateAnimSpriteToTargetMonLocation(struct Sprite *sprite)
{
bool8 v1;
u8 coordType;
if (!(gBattleAnimArgs[5] & 0xff00))
v1 = TRUE;
else
v1 = FALSE;
if (!(gBattleAnimArgs[5] & 0xff))
coordType = BATTLER_COORD_Y_PIC_OFFSET;
else
coordType = BATTLER_COORD_Y;
InitSpritePosToAnimAttacker(sprite, v1);
if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
gBattleAnimArgs[2] = -gBattleAnimArgs[2];
sprite->data[0] = gBattleAnimArgs[4];
sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + gBattleAnimArgs[2];
sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, coordType) + gBattleAnimArgs[3];
sprite->callback = StartAnimLinearTranslation;
StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
}
void AnimThrowProjectile(struct Sprite *sprite)
{
InitSpritePosToAnimAttacker(sprite, 1);
if (GetBattlerSide(gBattleAnimAttacker))
gBattleAnimArgs[2] = -gBattleAnimArgs[2];
sprite->data[0] = gBattleAnimArgs[4];
sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + gBattleAnimArgs[2];
sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_Y_PIC_OFFSET) + gBattleAnimArgs[3];
sprite->data[5] = gBattleAnimArgs[5];
InitAnimArcTranslation(sprite);
sprite->callback = AnimThrowProjectile_Step;
}
static void AnimThrowProjectile_Step(struct Sprite *sprite)
{
if (TranslateAnimHorizontalArc(sprite))
DestroyAnimSprite(sprite);
}
void AnimTravelDiagonally(struct Sprite *sprite)
{
bool8 r4;
u8 battlerId, coordType;
if (!gBattleAnimArgs[6])
{
r4 = TRUE;
coordType = BATTLER_COORD_Y_PIC_OFFSET;
}
else
{
r4 = FALSE;
coordType = BATTLER_COORD_Y;
}
if (gBattleAnimArgs[5] == ANIM_ATTACKER)
{
InitSpritePosToAnimAttacker(sprite, r4);
battlerId = gBattleAnimAttacker;
}
else
{
InitSpritePosToAnimTarget(sprite, r4);
battlerId = gBattleAnimTarget;
}
if (GetBattlerSide(gBattleAnimAttacker))
gBattleAnimArgs[2] = -gBattleAnimArgs[2];
InitSpritePosToAnimTarget(sprite, r4);
sprite->data[0] = gBattleAnimArgs[4];
sprite->data[2] = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2) + gBattleAnimArgs[2];
sprite->data[4] = GetBattlerSpriteCoord(battlerId, coordType) + gBattleAnimArgs[3];
sprite->callback = StartAnimLinearTranslation;
StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
}
s16 CloneBattlerSpriteWithBlend(u8 animBattler)
{
u16 i;
u8 spriteId = GetAnimBattlerSpriteId(animBattler);
if (spriteId != SPRITE_NONE)
{
for (i = 0; i < MAX_SPRITES; i++)
{
if (!gSprites[i].inUse)
{
gSprites[i] = gSprites[spriteId];
gSprites[i].oam.objMode = ST_OAM_OBJ_BLEND;
gSprites[i].invisible = FALSE;
return i;
}
}
}
return -1;
}
void DestroySpriteWithActiveSheet(struct Sprite *sprite)
{
sprite->usingSheet = TRUE;
DestroySprite(sprite);
}
// Only used to fade Moonlight moon sprite in
void AnimTask_AlphaFadeIn(u8 taskId)
{
s16 v1 = 0;
s16 v2 = 0;
if (gBattleAnimArgs[2] > gBattleAnimArgs[0])
v2 = 1;
if (gBattleAnimArgs[2] < gBattleAnimArgs[0])
v2 = -1;
if (gBattleAnimArgs[3] > gBattleAnimArgs[1])
v1 = 1;
if (gBattleAnimArgs[3] < gBattleAnimArgs[1])
v1 = -1;
gTasks[taskId].data[0] = 0;
gTasks[taskId].data[1] = gBattleAnimArgs[4];
gTasks[taskId].data[2] = 0;
gTasks[taskId].data[3] = gBattleAnimArgs[0];
gTasks[taskId].data[4] = gBattleAnimArgs[1];
gTasks[taskId].data[5] = v2;
gTasks[taskId].data[6] = v1;
gTasks[taskId].data[7] = gBattleAnimArgs[2];
gTasks[taskId].data[8] = gBattleAnimArgs[3];
SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gBattleAnimArgs[0], gBattleAnimArgs[1]));
gTasks[taskId].func = AnimTask_AlphaFadeIn_Step;
}
static void AnimTask_AlphaFadeIn_Step(u8 taskId)
{
struct Task *task = &gTasks[taskId];
if (++task->data[0] > task->data[1])
{
task->data[0] = 0;
if (++task->data[2] & 1)
{
if (task->data[3] != task->data[7])
task->data[3] += task->data[5];
}
else
{
if (task->data[4] != task->data[8])
task->data[4] += task->data[6];
}
SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(task->data[3], task->data[4]));
if (task->data[3] == task->data[7] && task->data[4] == task->data[8])
{
DestroyAnimVisualTask(taskId);
return;
}
}
}
// Linearly blends a mon's sprite colors with a target color with increasing
// strength, and then blends out to the original color.
// arg 0: anim bank
// arg 1: blend color
// arg 2: target blend coefficient
// arg 3: initial delay
// arg 4: number of times to blend in and out
void AnimTask_BlendMonInAndOut(u8 task)
{
u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]);
if (spriteId == SPRITE_NONE)
{
DestroyAnimVisualTask(task);
return;
}
gTasks[task].data[0] = (gSprites[spriteId].oam.paletteNum * 0x10) + 0x101;
AnimTask_BlendPalInAndOutSetup(&gTasks[task]);
}
static void AnimTask_BlendPalInAndOutSetup(struct Task *task)
{
task->data[1] = gBattleAnimArgs[1];
task->data[2] = 0;
task->data[3] = gBattleAnimArgs[2];
task->data[4] = 0;
task->data[5] = gBattleAnimArgs[3];
task->data[6] = 0;
task->data[7] = gBattleAnimArgs[4];
task->func = AnimTask_BlendMonInAndOut_Step;
}
static void AnimTask_BlendMonInAndOut_Step(u8 taskId)
{
struct Task *task = &gTasks[taskId];
if (++task->data[4] >= task->data[5])
{
task->data[4] = 0;
if (!task->data[6])
{
task->data[2]++;
BlendPalette(task->data[0], 15, task->data[2], task->data[1]);
if (task->data[2] == task->data[3])
task->data[6] = 1;
}
else
{
task->data[2]--;
BlendPalette(task->data[0], 15, task->data[2], task->data[1]);
if (!task->data[2])
{
if (--task->data[7])
{
task->data[4] = 0;
task->data[6] = 0;
}
else
{
DestroyAnimVisualTask(taskId);
return;
}
}
}
}
}
// See AnimTask_BlendMonInAndOut. Same, but ANIM_TAG_* instead of mon
void AnimTask_BlendPalInAndOutByTag(u8 task)
{
u8 palette = IndexOfSpritePaletteTag(gBattleAnimArgs[0]);
if (palette == 0xff)
{
DestroyAnimVisualTask(task);
return;
}
gTasks[task].data[0] = (palette * 0x10) + 0x101;
AnimTask_BlendPalInAndOutSetup(&gTasks[task]);
}
void PrepareAffineAnimInTaskData(struct Task *task, u8 spriteId, const union AffineAnimCmd *affineAnimCmds)
{
task->data[7] = 0;
task->data[8] = 0;
task->data[9] = 0;
task->data[15] = spriteId;
task->data[10] = 0x100;
task->data[11] = 0x100;
task->data[12] = 0;
StorePointerInVars(&task->data[13], &task->data[14], affineAnimCmds);
PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL);
}
bool8 RunAffineAnimFromTaskData(struct Task *task)
{
sAnimTaskAffineAnim = &((union AffineAnimCmd *)LoadPointerFromVars(task->data[13], task->data[14]))[task->data[7]];
switch (sAnimTaskAffineAnim->type)
{
default:
if (!sAnimTaskAffineAnim->frame.duration)
{
task->data[10] = sAnimTaskAffineAnim->frame.xScale;
task->data[11] = sAnimTaskAffineAnim->frame.yScale;
task->data[12] = sAnimTaskAffineAnim->frame.rotation;
task->data[7]++;
sAnimTaskAffineAnim++;
}
task->data[10] += sAnimTaskAffineAnim->frame.xScale;
task->data[11] += sAnimTaskAffineAnim->frame.yScale;
task->data[12] += sAnimTaskAffineAnim->frame.rotation;
SetSpriteRotScale(task->data[15], task->data[10], task->data[11], task->data[12]);
SetBattlerSpriteYOffsetFromYScale(task->data[15]);
if (++task->data[8] >= sAnimTaskAffineAnim->frame.duration)
{
task->data[8] = 0;
task->data[7]++;
}
break;
case AFFINEANIMCMDTYPE_JUMP:
task->data[7] = sAnimTaskAffineAnim->jump.target;
break;
case AFFINEANIMCMDTYPE_LOOP:
if (sAnimTaskAffineAnim->loop.count)
{
if (task->data[9])
{
if (!--task->data[9])
{
task->data[7]++;
break;
}
}
else
{
task->data[9] = sAnimTaskAffineAnim->loop.count;
}
if (!task->data[7])
{
break;
}
for (;;)
{
task->data[7]--;
sAnimTaskAffineAnim--;
if (sAnimTaskAffineAnim->type == AFFINEANIMCMDTYPE_LOOP)
{
task->data[7]++;
return TRUE;
}
if (!task->data[7])
return TRUE;
}
}
task->data[7]++;
break;
case AFFINEANIMCMDTYPE_END:
gSprites[task->data[15]].y2 = 0;
ResetSpriteRotScale(task->data[15]);
return FALSE;
}
return TRUE;
}
// Sets the sprite's y offset equal to the y displacement caused by the
// matrix's scale in the y dimension.
void SetBattlerSpriteYOffsetFromYScale(u8 spriteId)
{
int var = MON_PIC_HEIGHT - GetBattlerYDeltaFromSpriteId(spriteId) * 2;
u16 matrix = gSprites[spriteId].oam.matrixNum;
int var2 = SAFE_DIV(var << 8, gOamMatrices[matrix].d);
if (var2 > MON_PIC_HEIGHT * 2)
var2 = MON_PIC_HEIGHT * 2;
gSprites[spriteId].y2 = (var - var2) / 2;
}
// Sets the sprite's y offset equal to the y displacement caused by another sprite
// matrix's scale in the y dimension.
void SetBattlerSpriteYOffsetFromOtherYScale(u8 spriteId, u8 otherSpriteId)
{
int var = MON_PIC_HEIGHT - GetBattlerYDeltaFromSpriteId(otherSpriteId) * 2;
u16 matrix = gSprites[spriteId].oam.matrixNum;
int var2 = SAFE_DIV(var << 8, gOamMatrices[matrix].d);
if (var2 > MON_PIC_HEIGHT * 2)
var2 = MON_PIC_HEIGHT * 2;
gSprites[spriteId].y2 = (var - var2) / 2;
}
static u16 GetBattlerYDeltaFromSpriteId(u8 spriteId)
{
struct BattleSpriteInfo *spriteInfo;
u8 battlerId = gSprites[spriteId].data[0];
u16 species;
u16 i;
for (i = 0; i < MAX_BATTLERS_COUNT; i++)
{
if (gBattlerSpriteIds[i] == spriteId)
{
if (IsContest())
{
species = gContestResources->moveAnim->species;
return gMonBackPicCoords[species].y_offset;
}
else
{
if (GetBattlerSide(i) == B_SIDE_PLAYER)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
if (species == SPECIES_CASTFORM)
return sCastformBackSpriteYCoords[gBattleMonForms[battlerId]];
else
return gMonBackPicCoords[species].y_offset;
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
if (species == SPECIES_CASTFORM)
return sCastformElevations[gBattleMonForms[battlerId]];
else
return gMonFrontPicCoords[species].y_offset;
}
}
}
}
return MON_PIC_HEIGHT;
}
void StorePointerInVars(s16 *lo, s16 *hi, const void *ptr)
{
*lo = ((intptr_t) ptr) & 0xffff;
*hi = (((intptr_t) ptr) >> 16) & 0xffff;
}
void *LoadPointerFromVars(s16 lo, s16 hi)
{
return (void *)((u16)lo | ((u16)hi << 16));
}
void PrepareEruptAnimTaskData(struct Task *task, u8 spriteId, s16 xScaleStart, s16 yScaleStart, s16 xScaleEnd, s16 yScaleEnd, u16 duration)
{
task->data[8] = duration;
task->data[15] = spriteId;
task->data[9] = xScaleStart;
task->data[10] = yScaleStart;
task->data[13] = xScaleEnd;
task->data[14] = yScaleEnd;
task->data[11] = (xScaleEnd - xScaleStart) / duration;
task->data[12] = (yScaleEnd - yScaleStart) / duration;
}
u8 UpdateEruptAnimTask(struct Task *task)
{
if (!task->data[8])
return 0;
if (--task->data[8] != 0)
{
task->data[9] += task->data[11];
task->data[10] += task->data[12];
}
else
{
task->data[9] = task->data[13];
task->data[10] = task->data[14];
}
SetSpriteRotScale(task->data[15], task->data[9], task->data[10], 0);
if (task->data[8])
SetBattlerSpriteYOffsetFromYScale(task->data[15]);
else
gSprites[task->data[15]].y2 = 0;
return task->data[8];
}
void AnimTask_GetFrustrationPowerLevel(u8 taskId)
{
u16 powerLevel;
if (gAnimFriendship <= 30)
powerLevel = 0;
else if (gAnimFriendship <= 100)
powerLevel = 1;
else if (gAnimFriendship <= 200)
powerLevel = 2;
else
powerLevel = 3;
gBattleAnimArgs[ARG_RET_ID] = powerLevel;
DestroyAnimVisualTask(taskId);
}
// Unused
static void SetPriorityForVisibleBattlers(u8 priority)
{
if (IsBattlerSpriteVisible(gBattleAnimTarget))
gSprites[gBattlerSpriteIds[gBattleAnimTarget]].oam.priority = priority;
if (IsBattlerSpriteVisible(gBattleAnimAttacker))
gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].oam.priority = priority;
if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget)))
gSprites[gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimTarget)]].oam.priority = priority;
if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker)))
gSprites[gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimAttacker)]].oam.priority = priority;
}
void InitPrioritiesForVisibleBattlers(void)
{
int i;
for (i = 0; i < gBattlersCount; i++)
{
if (IsBattlerSpriteVisible(i))
{
gSprites[gBattlerSpriteIds[i]].subpriority = GetBattlerSpriteSubpriority(i);
gSprites[gBattlerSpriteIds[i]].oam.priority = 2;
}
}
}
u8 GetBattlerSpriteSubpriority(u8 battlerId)
{
u8 position;
u8 subpriority;
if (IsContest())
{
if (battlerId == 2)
return 30;
else
return 40;
}
else
{
position = GetBattlerPosition(battlerId);
if (position == B_POSITION_PLAYER_LEFT)
subpriority = 30;
else if (position == B_POSITION_PLAYER_RIGHT)
subpriority = 20;
else if (position == B_POSITION_OPPONENT_LEFT)
subpriority = 40;
else
subpriority = 50;
}
return subpriority;
}
u8 GetBattlerSpriteBGPriority(u8 battlerId)
{
u8 position = GetBattlerPosition(battlerId);
if (IsContest())
return 2;
else if (position == B_POSITION_PLAYER_LEFT || position == B_POSITION_OPPONENT_RIGHT)
return GetAnimBgAttribute(2, BG_ANIM_PRIORITY);
else
return GetAnimBgAttribute(1, BG_ANIM_PRIORITY);
}
u8 GetBattlerSpriteBGPriorityRank(u8 battlerId)
{
if (!IsContest())
{
u8 position = GetBattlerPosition(battlerId);
if (position == B_POSITION_PLAYER_LEFT || position == B_POSITION_OPPONENT_RIGHT)
return 2;
else
return 1;
}
return 1;
}
// Create pokemon sprite to be used for a move animation effect (e.g. Role Play / Snatch)
u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16 x, s16 y, u8 subpriority, u32 personality, u32 trainerId, u32 battlerId, bool32 ignoreDeoxysForm)
{
u8 spriteId;
u16 sheet = LoadSpriteSheet(&sSpriteSheet_MoveEffectMons[id]);
u16 palette = AllocSpritePalette(sSpriteTemplate_MoveEffectMons[id].paletteTag);
if (gMonSpritesGfxPtr != NULL && gMonSpritesGfxPtr->buffer == NULL)
gMonSpritesGfxPtr->buffer = AllocZeroed(0x2000);
if (!isBackpic)
{
LoadCompressedPalette(GetMonSpritePalFromSpeciesAndPersonality(species, trainerId, personality), (palette * 0x10) + 0x100, 0x20);
if (ignoreDeoxysForm == TRUE || ShouldIgnoreDeoxysForm(5, battlerId) == TRUE || gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != 0)
LoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species],
gMonSpritesGfxPtr->buffer,
species,
personality,
TRUE);
else
LoadSpecialPokePic_2(&gMonFrontPicTable[species],
gMonSpritesGfxPtr->buffer,
species,
personality,
TRUE);
}
else
{
LoadCompressedPalette(GetMonSpritePalFromSpeciesAndPersonality(species, trainerId, personality), (palette * 0x10) + 0x100, 0x20);
if (ignoreDeoxysForm == TRUE || ShouldIgnoreDeoxysForm(5, battlerId) == TRUE || gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != 0)
LoadSpecialPokePic_DontHandleDeoxys(&gMonBackPicTable[species],
gMonSpritesGfxPtr->buffer,
species,
personality,
FALSE);
else
LoadSpecialPokePic_2(&gMonBackPicTable[species],
gMonSpritesGfxPtr->buffer,
species,
personality,
FALSE);
}
RequestDma3Copy(gMonSpritesGfxPtr->buffer, (void *)(OBJ_VRAM0 + (sheet * 0x20)), MON_PIC_SIZE, 1);
FREE_AND_SET_NULL(gMonSpritesGfxPtr->buffer);
if (!isBackpic)
spriteId = CreateSprite(&sSpriteTemplate_MoveEffectMons[id], x, y + gMonFrontPicCoords[species].y_offset, subpriority);
else
spriteId = CreateSprite(&sSpriteTemplate_MoveEffectMons[id], x, y + gMonBackPicCoords[species].y_offset, subpriority);
if (IsContest())
{
gSprites[spriteId].affineAnims = gAffineAnims_BattleSpriteContest;
StartSpriteAffineAnim(&gSprites[spriteId], BATTLER_AFFINE_NORMAL);
}
return spriteId;
}
void DestroySpriteAndFreeResources_(struct Sprite *sprite)
{
DestroySpriteAndFreeResources(sprite);
}
s16 GetBattlerSpriteCoordAttr(u8 battlerId, u8 attr)
{
u16 species;
u32 personality;
u16 letter;
u16 unownSpecies;
int ret;
const struct MonCoords *coords;
struct BattleSpriteInfo *spriteInfo;
if (IsContest())
{
if (gContestResources->moveAnim->hasTargetAnim)
{
species = gContestResources->moveAnim->targetSpecies;
personality = gContestResources->moveAnim->targetPersonality;
}
else
{
species = gContestResources->moveAnim->species;
personality = gContestResources->moveAnim->personality;
}
if (species == SPECIES_UNOWN)
{
letter = GET_UNOWN_LETTER(personality);
if (!letter)
unownSpecies = SPECIES_UNOWN;
else
unownSpecies = letter + SPECIES_UNOWN_B - 1;
coords = &gMonBackPicCoords[unownSpecies];
}
else if (species == SPECIES_CASTFORM)
{
coords = &gCastformFrontSpriteCoords[gBattleMonForms[battlerId]];
}
else if (species <= SPECIES_EGG)
{
coords = &gMonBackPicCoords[species];
}
else
{
coords = &gMonBackPicCoords[0];
}
}
else
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
{
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY);
}
else
{
species = spriteInfo[battlerId].transformSpecies;
personality = gTransformedPersonalities[battlerId];
}
if (species == SPECIES_UNOWN)
{
letter = GET_UNOWN_LETTER(personality);
if (!letter)
unownSpecies = SPECIES_UNOWN;
else
unownSpecies = letter + SPECIES_UNOWN_B - 1;
coords = &gMonBackPicCoords[unownSpecies];
}
else if (species > NUM_SPECIES)
{
coords = &gMonBackPicCoords[0];
}
else
{
coords = &gMonBackPicCoords[species];
}
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
{
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY);
}
else
{
species = spriteInfo[battlerId].transformSpecies;
personality = gTransformedPersonalities[battlerId];
}
if (species == SPECIES_UNOWN)
{
letter = GET_UNOWN_LETTER(personality);
if (!letter)
unownSpecies = SPECIES_UNOWN;
else
unownSpecies = letter + SPECIES_UNOWN_B - 1;
coords = &gMonFrontPicCoords[unownSpecies];
}
else if (species == SPECIES_CASTFORM)
{
coords = &gCastformFrontSpriteCoords[gBattleMonForms[battlerId]];
}
else if (species > NUM_SPECIES)
{
coords = &gMonFrontPicCoords[0];
}
else
{
coords = &gMonFrontPicCoords[species];
}
}
}
switch (attr)
{
case BATTLER_COORD_ATTR_HEIGHT:
return GET_MON_COORDS_HEIGHT(coords->size);
case BATTLER_COORD_ATTR_WIDTH:
return GET_MON_COORDS_WIDTH(coords->size);
case BATTLER_COORD_ATTR_LEFT:
return GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2) - (GET_MON_COORDS_WIDTH(coords->size) / 2);
case BATTLER_COORD_ATTR_RIGHT:
return GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2) + (GET_MON_COORDS_WIDTH(coords->size) / 2);
case BATTLER_COORD_ATTR_TOP:
return GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y_PIC_OFFSET) - (GET_MON_COORDS_HEIGHT(coords->size) / 2);
case BATTLER_COORD_ATTR_BOTTOM:
return GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y_PIC_OFFSET) + (GET_MON_COORDS_HEIGHT(coords->size) / 2);
case BATTLER_COORD_ATTR_RAW_BOTTOM:
ret = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 31;
return ret - coords->y_offset;
default:
return 0;
}
}
void SetAverageBattlerPositions(u8 battlerId, bool8 respectMonPicOffsets, s16 *x, s16 *y)
{
u8 xCoordType, yCoordType;
s16 battlerX, battlerY;
s16 partnerX, partnerY;
if (!respectMonPicOffsets)
{
xCoordType = BATTLER_COORD_X;
yCoordType = BATTLER_COORD_Y;
}
else
{
xCoordType = BATTLER_COORD_X_2;
yCoordType = BATTLER_COORD_Y_PIC_OFFSET;
}
battlerX = GetBattlerSpriteCoord(battlerId, xCoordType);
battlerY = GetBattlerSpriteCoord(battlerId, yCoordType);
if (IsDoubleBattle() && !IsContest())
{
partnerX = GetBattlerSpriteCoord(BATTLE_PARTNER(battlerId), xCoordType);
partnerY = GetBattlerSpriteCoord(BATTLE_PARTNER(battlerId), yCoordType);
}
else
{
partnerX = battlerX;
partnerY = battlerY;
}
*x = (battlerX + partnerX) / 2;
*y = (battlerY + partnerY) / 2;
}
u8 CreateInvisibleSpriteCopy(int battlerId, u8 spriteId, int species)
{
u8 newSpriteId = CreateInvisibleSpriteWithCallback(SpriteCallbackDummy);
gSprites[newSpriteId] = gSprites[spriteId];
gSprites[newSpriteId].usingSheet = TRUE;
gSprites[newSpriteId].oam.priority = 0;
gSprites[newSpriteId].oam.objMode = ST_OAM_OBJ_WINDOW;
gSprites[newSpriteId].oam.tileNum = gSprites[spriteId].oam.tileNum;
gSprites[newSpriteId].callback = SpriteCallbackDummy;
return newSpriteId;
}
void AnimTranslateLinearAndFlicker_Flipped(struct Sprite *sprite)
{
SetSpriteCoordsToAnimAttackerCoords(sprite);
if (GetBattlerSide(gBattleAnimAttacker))
{
sprite->x -= gBattleAnimArgs[0];
gBattleAnimArgs[3] = -gBattleAnimArgs[3];
sprite->hFlip = TRUE;
}
else
{
sprite->x += gBattleAnimArgs[0];
}
sprite->y += gBattleAnimArgs[1];
sprite->data[0] = gBattleAnimArgs[2];
sprite->data[1] = gBattleAnimArgs[3];
sprite->data[3] = gBattleAnimArgs[4];
sprite->data[5] = gBattleAnimArgs[5];
StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix);
sprite->callback = TranslateSpriteLinearAndFlicker;
}
// Used by three different unused battle anim sprite templates.
void AnimTranslateLinearAndFlicker(struct Sprite *sprite)
{
if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER)
{
sprite->x -= gBattleAnimArgs[0];
gBattleAnimArgs[3] *= -1;
}
else
{
sprite->x += gBattleAnimArgs[0];
}
sprite->y += gBattleAnimArgs[1];
sprite->data[0] = gBattleAnimArgs[2];
sprite->data[1] = gBattleAnimArgs[3];
sprite->data[3] = gBattleAnimArgs[4];
sprite->data[5] = gBattleAnimArgs[5];
StartSpriteAnim(sprite, gBattleAnimArgs[6]);
StoreSpriteCallbackInData6(sprite, DestroySpriteAndMatrix);
sprite->callback = TranslateSpriteLinearAndFlicker;
}
// Used by Detect/Disable
void AnimSpinningSparkle(struct Sprite *sprite)
{
SetSpriteCoordsToAnimAttackerCoords(sprite);
if (GetBattlerSide(gBattleAnimAttacker))
sprite->x -= gBattleAnimArgs[0];
else
sprite->x += gBattleAnimArgs[0];
sprite->y += gBattleAnimArgs[1];
sprite->callback = RunStoredCallbackWhenAnimEnds;
StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
}
// Task and sprite data for AnimTask_AttackerPunchWithTrace
#define tBattlerSpriteId data[0]
#define tMoveSpeed data[1]
#define tState data[2]
#define tCounter data[3]
#define tPaletteNum data[4]
#define tNumTracesActive data[5]
#define tPriority data[6]
#define sActiveTime data[0]
#define sTaskId data[1]
#define sSpriteId data[2]
// Slides attacker to right and back with a cloned trace of the specified color
// arg0: Trace palette blend color
// arg1: Trace palette blend coeff
void AnimTask_AttackerPunchWithTrace(u8 taskId)
{
u16 src;
u16 dest;
struct Task *task = &gTasks[taskId];
task->tBattlerSpriteId = GetAnimBattlerSpriteId(ANIM_ATTACKER);
task->tMoveSpeed = (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) ? -8 : 8;
task->tState = 0;
task->tCounter = 0;
gSprites[task->tBattlerSpriteId].x2 -= task->tBattlerSpriteId;
task->tPaletteNum = AllocSpritePalette(ANIM_TAG_BENT_SPOON);
task->tNumTracesActive = 0;
dest = (task->tPaletteNum + 16) * 16;
src = (gSprites[task->tBattlerSpriteId].oam.paletteNum + 0x10) * 0x10;
// Set trace's priority based on battler's subpriority
task->tPriority = GetBattlerSpriteSubpriority(gBattleAnimAttacker);
if (task->tPriority == 20 || task->tPriority == 40)
task->tPriority = 2;
else
task->tPriority = 3;
CpuCopy32(&gPlttBufferUnfaded[src], &gPlttBufferFaded[dest], 0x20);
BlendPalette(dest, 16, gBattleAnimArgs[1], gBattleAnimArgs[0]);
task->func = AnimTask_AttackerPunchWithTrace_Step;
}
static void AnimTask_AttackerPunchWithTrace_Step(u8 taskId)
{
struct Task *task = &gTasks[taskId];
switch (task->tState)
{
case 0:
// Move forward
CreateBattlerTrace(task, taskId);
gSprites[task->tBattlerSpriteId].x2 += task->tMoveSpeed;
if (++task->tCounter == 5)
{
task->tCounter--;
task->tState++;
}
break;
case 1:
// Move back (do same number of traces as before)
CreateBattlerTrace(task, taskId);
gSprites[task->tBattlerSpriteId].x2 -= task->tMoveSpeed;
if (--task->tCounter == 0)
{
gSprites[task->tBattlerSpriteId].x2 = 0;
task->tState++;
}
break;
case 2:
if (task->tNumTracesActive == 0)
{
FreeSpritePaletteByTag(ANIM_TAG_BENT_SPOON);
DestroyAnimVisualTask(taskId);
}
break;
}
}
static void CreateBattlerTrace(struct Task *task, u8 taskId)
{
s16 spriteId = CloneBattlerSpriteWithBlend(0);
if (spriteId >= 0)
{
gSprites[spriteId].oam.priority = task->tPriority;
gSprites[spriteId].oam.paletteNum = task->tPaletteNum;
gSprites[spriteId].sActiveTime = 8;
gSprites[spriteId].sTaskId = taskId;
gSprites[spriteId].sSpriteId = spriteId;
gSprites[spriteId].x2 = gSprites[task->tBattlerSpriteId].x2;
gSprites[spriteId].callback = AnimBattlerTrace;
task->tNumTracesActive++;
}
}
// Just waits until destroyed
static void AnimBattlerTrace(struct Sprite *sprite)
{
if (--sprite->sActiveTime == 0)
{
gTasks[sprite->sTaskId].tNumTracesActive--;
DestroySpriteWithActiveSheet(sprite);
}
}
#undef tBattlerSpriteId
#undef tMoveSpeed
#undef tState
#undef tCounter
#undef tPaletteNum
#undef tNumTracesActive
#undef tPriority
#undef sActiveTime
#undef sTaskId
#undef sSpriteId
void AnimWeatherBallUp(struct Sprite *sprite)
{
sprite->x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2);
sprite->y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_Y_PIC_OFFSET);
if (!GetBattlerSide(gBattleAnimAttacker))
sprite->data[0] = 5;
else
sprite->data[0] = -10;
sprite->data[1] = -40;
sprite->callback = AnimWeatherBallUp_Step;
}
static void AnimWeatherBallUp_Step(struct Sprite *sprite)
{
sprite->data[2] += sprite->data[0];
sprite->data[3] += sprite->data[1];
sprite->x2 = sprite->data[2] / 10;
sprite->y2 = sprite->data[3] / 10;
if (sprite->data[1] < -20)
sprite->data[1]++;
if (sprite->y + sprite->y2 < -32)
DestroyAnimSprite(sprite);
}
void AnimWeatherBallDown(struct Sprite *sprite)
{
int x;
sprite->data[0] = gBattleAnimArgs[2];
sprite->data[2] = sprite->x + gBattleAnimArgs[4];
sprite->data[4] = sprite->y + gBattleAnimArgs[5];
if (!GetBattlerSide(gBattleAnimTarget))
{
x = (u16)gBattleAnimArgs[4] + 30;
sprite->x += x;
sprite->y = gBattleAnimArgs[5] - 20;
}
else
{
x = (u16)gBattleAnimArgs[4] - 30;
sprite->x += x;
sprite->y = gBattleAnimArgs[5] - 80;
}
sprite->callback = StartAnimLinearTranslation;
StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
}