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

Rename battlerId to battler for consistency (#2126)

Browse Source
This commit is contained in:
Alex 2025-05-09 13:43:23 +02:00 committed by GitHub
parent 384b8f127e
commit 2044bea883
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
47 changed files with 1391 additions and 1390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/battle.h
View File

@ -465,11 +465,11 @@ STATIC_ASSERT(sizeof(((struct BattleStruct *)0)->palaceFlags) * 8 >= MAX_BATTLER
#define TARGET_TURN_DAMAGED ((gSpecialStatuses[gBattlerTarget].physicalDmg != 0 || gSpecialStatuses[gBattlerTarget].specialDmg != 0))
#define IS_BATTLER_OF_TYPE(battlerId, type) ((gBattleMons[battlerId].types[0] == type || gBattleMons[battlerId].types[1] == type))
#define SET_BATTLER_TYPE(battlerId, type) \
#define IS_BATTLER_OF_TYPE(battler, type) ((gBattleMons[battler].types[0] == type || gBattleMons[battler].types[1] == type))
#define SET_BATTLER_TYPE(battler, type) \
{ \
gBattleMons[battlerId].types[0] = type; \
gBattleMons[battlerId].types[1] = type; \
gBattleMons[battler].types[0] = type; \
gBattleMons[battler].types[1] = type; \
}
#define GET_STAT_BUFF_ID(n) ((n & 0xF)) // first four bits 0x1, 0x2, 0x4, 0x8

10
include/battle_ai_script_commands.h
View File

@ -9,10 +9,10 @@
void BattleAI_HandleItemUseBeforeAISetup(u8 defaultScoreMoves);
void BattleAI_SetupAIData(u8 defaultScoreMoves);
u8 BattleAI_ChooseMoveOrAction(void);
void ClearBattlerMoveHistory(u8 battlerId);
void RecordAbilityBattle(u8 battlerId, u8 abilityId);
void ClearBattlerAbilityHistory(u8 battlerId);
void RecordItemEffectBattle(u8 battlerId, u8 itemEffect);
void ClearBattlerItemEffectHistory(u8 battlerId);
void ClearBattlerMoveHistory(u8 battler);
void RecordAbilityBattle(u8 battler, u8 abilityId);
void ClearBattlerAbilityHistory(u8 battler);
void RecordItemEffectBattle(u8 battler, u8 itemEffect);
void ClearBattlerItemEffectHistory(u8 battler);
#endif // GUARD_BATTLE_AI_SCRIPT_COMMANDS_H

32
include/battle_anim.h
View File

@ -57,8 +57,8 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo
void DestroyAnimSprite(struct Sprite *sprite);
void DestroyAnimVisualTask(u8 taskId);
void DestroyAnimSoundTask(u8 taskId);
bool8 IsBattlerSpriteVisible(u8 battlerId);
void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible);
bool8 IsBattlerSpriteVisible(u8 battler);
void MoveBattlerSpriteToBG(u8 battler, bool8 toBG_2, bool8 setSpriteInvisible);
bool8 IsContest(void);
s8 BattleAnimAdjustPanning(s8 pan);
s8 BattleAnimAdjustPanning2(s8 pan);
@ -80,7 +80,7 @@ void AnimTranslateLinearAndFlicker_Flipped(struct Sprite *sprite);
void AnimWeatherBallUp(struct Sprite *sprite);
void AnimWeatherBallDown(struct Sprite *sprite);
void AnimSpinningSparkle(struct Sprite *sprite);
void SetAverageBattlerPositions(u8 battlerId, bool8 respectMonPicOffsets, s16 *x, s16 *y);
void SetAverageBattlerPositions(u8 battler, bool8 respectMonPicOffsets, s16 *x, s16 *y);
void DestroySpriteAndMatrix(struct Sprite *sprite);
void TranslateSpriteLinearFixedPoint(struct Sprite *sprite);
void InitSpritePosToAnimAttacker(struct Sprite *sprite, bool8 respectMonPicOffsets);
@ -89,7 +89,7 @@ void StartAnimLinearTranslation(struct Sprite *sprite);
void InitAnimArcTranslation(struct Sprite *sprite);
bool8 AnimTranslateLinear(struct Sprite *sprite);
void TranslateAnimSpriteToTargetMonLocation(struct Sprite *sprite);
u8 GetBattlerSpriteCoord2(u8 battlerId, u8 attributeId);
u8 GetBattlerSpriteCoord2(u8 battler, u8 attributeId);
void InitAnimLinearTranslationWithSpeed(struct Sprite *sprite);
u16 ArcTan2Neg(s16 x, s16 y);
void TrySetSpriteRotScale(struct Sprite *sprite, bool8 recalcCenterVector, s16 xScale, s16 yScale, u16 rotation);
@ -98,19 +98,19 @@ void TranslateSpriteLinearAndFlicker(struct Sprite *sprite);
void SetSpriteCoordsToAnimAttackerCoords(struct Sprite *sprite);
void RunStoredCallbackWhenAnimEnds(struct Sprite *sprite);
void SetAnimSpriteInitialXOffset(struct Sprite *sprite, s16 xOffset);
s16 GetBattlerSpriteCoordAttr(u8 battlerId, u8 attr);
u8 GetBattlerYCoordWithElevation(u8 battlerId);
s16 GetBattlerSpriteCoordAttr(u8 battler, u8 attr);
u8 GetBattlerYCoordWithElevation(u8 battler);
void WaitAnimForDuration(struct Sprite *sprite);
void AnimTravelDiagonally(struct Sprite *sprite);
void InitAnimLinearTranslation(struct Sprite *sprite);
void AnimTranslateLinear_WithFollowup(struct Sprite *sprite);
u8 GetBattlerSpriteBGPriority(u8 battlerId);
u8 GetBattlerSpriteBGPriority(u8 battler);
void *LoadPointerFromVars(s16 bottom, s16 top);
void StorePointerInVars(s16 *bottom, s16 *top, const void *ptr);
void InitPrioritiesForVisibleBattlers(void);
void GetBattleAnimBg1Data(struct BattleAnimBgData *);
void GetBattleAnimBgData(struct BattleAnimBgData *, u32 bgId);
u8 GetBattlerSpriteSubpriority(u8 battlerId);
u8 GetBattlerSpriteSubpriority(u8 battler);
bool8 TranslateAnimHorizontalArc(struct Sprite *sprite);
void TranslateSpriteLinearByIdFixedPoint(struct Sprite *sprite);
void ResetSpriteRotScale(u8 spriteId);
@ -145,8 +145,8 @@ void SetGrayscaleOrOriginalPalette(u16 palNum, bool8 restoreOriginal);
void PrepareAffineAnimInTaskData(struct Task *task, u8 spriteId, const union AffineAnimCmd *affineAnimCmds);
bool8 RunAffineAnimFromTaskData(struct Task *task);
void AnimThrowProjectile(struct Sprite *sprite);
void GetBgDataForTransform(struct BattleAnimBgData *dest, u8 battlerId);
u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16 x, s16 y, u8 subpriority, u32 personality, u32 trainerId, u32 battlerId, bool32 ignoreDeoxysForm);
void GetBgDataForTransform(struct BattleAnimBgData *dest, u8 battler);
u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16 x, s16 y, u8 subpriority, u32 personality, u32 trainerId, u32 battler, bool32 ignoreDeoxysForm);
void ResetSpriteRotScale_PreserveAffine(struct Sprite *sprite);
void Trade_MoveSelectedMonToTarget(struct Sprite *sprite);
void DestroyAnimVisualTaskAndDisableBlend(u8 taskId);
@ -178,18 +178,18 @@ enum
BATTLER_COORD_ATTR_RAW_BOTTOM,
};
u8 GetBattlerSpriteCoord(u8 battlerId, u8 attributeId);
u8 GetBattlerSpriteCoord(u8 battler, u8 attributeId);
bool8 IsBattlerSpritePresent(u8 battlerId);
bool8 IsBattlerSpritePresent(u8 battler);
void ClearBattleAnimBg(u32 bgId);
u8 GetAnimBattlerSpriteId(u8 wantedBattler);
bool8 IsDoubleBattle(void);
u8 GetBattleBgPaletteNum(void);
u8 GetBattlerSpriteBGPriorityRank(u8 battlerId);
u8 GetBattlerSpriteBGPriorityRank(u8 battler);
void StoreSpriteCallbackInData6(struct Sprite *sprite, void (*spriteCallback)(struct Sprite *));
void SetSpritePrimaryCoordsFromSecondaryCoords(struct Sprite *sprite);
u8 GetBattlerSpriteDefault_Y(u8 battlerId);
u8 GetSubstituteSpriteDefault_Y(u8 battlerId);
u8 GetBattlerSpriteDefault_Y(u8 battler);
u8 GetSubstituteSpriteDefault_Y(u8 battler);
// battle_anim_status_effects.c
#define STAT_ANIM_PLUS1 14
@ -212,7 +212,7 @@ enum {
STAT_ANIM_PAL_MULTIPLE = 0xFF
};
void LaunchStatusAnimation(u8 battlerId, u8 statusAnimId);
void LaunchStatusAnimation(u8 battler, u8 statusAnimId);
// battle_anim_ground.c
void AnimTask_HorizontalShake(u8 taskId);

66
include/battle_controllers.h
View File

@ -66,46 +66,46 @@ enum {
// Accessors for gBattleControllerExecFlags.
//
// These are provided for documentation purposes, to make the battle
// controller internals and the link communication internals more
// legible. Several of these have functions that you should call
// (e.g. MarkBattlerForControllerExec) instead of using these macros
// These are provided for documentation purposes, to make the battle
// controller internals and the link communication internals more
// legible. Several of these have functions that you should call
// (e.g. MarkBattlerForControllerExec) instead of using these macros
// directly.
#define MARK_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battlerId) \
gBattleControllerExecFlags |= gBitTable[battlerId]
#define MARK_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battler) \
gBattleControllerExecFlags |= gBitTable[battler]
#define MARK_BATTLE_CONTROLLER_IDLE_ON_LOCAL(battlerId) \
gBattleControllerExecFlags &= ~gBitTable(battlerId)
#define MARK_BATTLE_CONTROLLER_IDLE_ON_LOCAL(battler) \
gBattleControllerExecFlags &= ~gBitTable(battler)
#define IS_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battlerId) \
(gBattleControllerExecFlags & gBitTable[battlerId])
#define IS_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battler) \
(gBattleControllerExecFlags & gBitTable[battler])
#define MARK_BATTLE_CONTROLLER_MESSAGE_OUTBOUND_OVER_LINK(battlerId) \
gBattleControllerExecFlags |= gBitTable[battlerId] << (32 - MAX_BATTLERS_COUNT)
#define MARK_BATTLE_CONTROLLER_MESSAGE_OUTBOUND_OVER_LINK(battler) \
gBattleControllerExecFlags |= gBitTable[battler] << (32 - MAX_BATTLERS_COUNT)
#define MARK_BATTLE_CONTROLLER_MESSAGE_SYNCHRONIZED_OVER_LINK(battlerId) \
gBattleControllerExecFlags &= ~((1 << 28) << (battlerId))
#define MARK_BATTLE_CONTROLLER_MESSAGE_SYNCHRONIZED_OVER_LINK(battler) \
gBattleControllerExecFlags &= ~((1 << 28) << (battler))
#define MARK_BATTLE_CONTROLLER_ACTIVE_FOR_PLAYER(battlerId, playerId) \
gBattleControllerExecFlags |= gBitTable[battlerId] << ((playerId) << 2)
#define MARK_BATTLE_CONTROLLER_ACTIVE_FOR_PLAYER(battler, playerId) \
gBattleControllerExecFlags |= gBitTable[battler] << ((playerId) << 2)
#define MARK_BATTLE_CONTROLLER_IDLE_FOR_PLAYER(battlerId, playerId) \
gBattleControllerExecFlags &= ~(gBitTable[battlerId] << ((playerId) * 4))
#define MARK_BATTLE_CONTROLLER_IDLE_FOR_PLAYER(battler, playerId) \
gBattleControllerExecFlags &= ~(gBitTable[battler] << ((playerId) * 4))
#define IS_BATTLE_CONTROLLER_ACTIVE_FOR_PLAYER(battlerId, playerId) \
(gBattleControllerExecFlags & (gBitTable[battlerId] << ((playerId) * 4)))
#define IS_BATTLE_CONTROLLER_ACTIVE_FOR_PLAYER(battler, playerId) \
(gBattleControllerExecFlags & (gBitTable[battler] << ((playerId) * 4)))
// This actually checks if a specific controller is active on any player or if
// *any* controller is pending sync over link communications, but the macro name
// This actually checks if a specific controller is active on any player or if
// *any* controller is pending sync over link communications, but the macro name
// can only be so specific before it just gets ridiculous.
#define IS_BATTLE_CONTROLLER_ACTIVE_OR_PENDING_SYNC_ANYWHERE(battlerId) \
#define IS_BATTLE_CONTROLLER_ACTIVE_OR_PENDING_SYNC_ANYWHERE(battler) \
(gBattleControllerExecFlags & ( \
(gBitTable[battlerId]) \
(gBitTable[battler]) \
| (0xF << 28) \
| (gBitTable[battlerId] << 4) \
| (gBitTable[battlerId] << 8) \
| (gBitTable[battlerId] << 12) \
| (gBitTable[battler] << 4) \
| (gBitTable[battler] << 8) \
| (gBitTable[battler] << 12) \
))
// Special arguments for Battle Controller functions.
@ -113,14 +113,14 @@ enum {
enum {
// For commands sent from the core battle engine to a controller.
B_COMM_TO_CONTROLLER, // gBattleBufferA
// For replies sent from a controller to the core battle engine.
B_COMM_TO_ENGINE, // gBattleBufferB
// During local play, a controller must directly mark itself as
// inactive when it's done processing, whether or not it sends
// a reply. During multiplayer, it must NOT directly mark itself
// as inactive, but instead send one of these, with the player's
// During local play, a controller must directly mark itself as
// inactive when it's done processing, whether or not it sends
// a reply. During multiplayer, it must NOT directly mark itself
// as inactive, but instead send one of these, with the player's
// multiplayer ID as data.
B_COMM_CONTROLLER_IS_DONE
};

30
include/battle_gfx_sfx_util.h
View File

@ -10,36 +10,36 @@ void InitAndLaunchChosenStatusAnimation(bool8 isStatus2, u32 status);
bool8 TryHandleLaunchBattleTableAnimation(u8 activeBattlerId, u8 attacker, u8 target, u8 tableId, u16 argument);
void InitAndLaunchSpecialAnimation(u8 activeBattlerId, u8 attacker, u8 target, u8 tableId);
bool8 IsMoveWithoutAnimation(u16 moveId, u8 animationTurn);
bool8 IsBattleSEPlaying(u8 battlerId);
void BattleLoadOpponentMonSpriteGfx(struct Pokemon *mon, u8 battlerId);
void BattleLoadPlayerMonSpriteGfx(struct Pokemon *mon, u8 battlerId);
bool8 IsBattleSEPlaying(u8 battler);
void BattleLoadOpponentMonSpriteGfx(struct Pokemon *mon, u8 battler);
void BattleLoadPlayerMonSpriteGfx(struct Pokemon *mon, u8 battler);
void BattleGfxSfxDummy2(u16 species);
void DecompressTrainerFrontPic(u16 frontPicId, u8 battlerId);
void DecompressTrainerBackPic(u16 backPicId, u8 battlerId);
void DecompressTrainerFrontPic(u16 frontPicId, u8 battler);
void DecompressTrainerBackPic(u16 backPicId, u8 battler);
void BattleGfxSfxDummy3(u8 gender);
void FreeTrainerFrontPicPalette(u16 frontPicId);
bool8 BattleLoadAllHealthBoxesGfx(u8 state);
void LoadBattleBarGfx(u8 unused);
bool8 BattleInitAllSprites(u8 *state1, u8 *battlerId);
bool8 BattleInitAllSprites(u8 *state1, u8 *battler);
void ClearSpritesHealthboxAnimData(void);
void CopyAllBattleSpritesInvisibilities(void);
void CopyBattleSpriteInvisibility(u8 battlerId);
void CopyBattleSpriteInvisibility(u8 battler);
void HandleSpeciesGfxDataChange(u8 attacker, u8 target, bool8 notTransform);
void BattleLoadSubstituteOrMonSpriteGfx(u8 battlerId, bool8 loadMonSprite);
void LoadBattleMonGfxAndAnimate(u8 battlerId, bool8 loadMonSprite, u8 spriteId);
void TrySetBehindSubstituteSpriteBit(u8 battlerId, u16 move);
void ClearBehindSubstituteBit(u8 battlerId);
void HandleLowHpMusicChange(struct Pokemon *mon, u8 battlerId);
void BattleLoadSubstituteOrMonSpriteGfx(u8 battler, bool8 loadMonSprite);
void LoadBattleMonGfxAndAnimate(u8 battler, bool8 loadMonSprite, u8 spriteId);
void TrySetBehindSubstituteSpriteBit(u8 battler, u16 move);
void ClearBehindSubstituteBit(u8 battler);
void HandleLowHpMusicChange(struct Pokemon *mon, u8 battler);
void BattleStopLowHpSound(void);
u8 GetMonHPBarLevel(struct Pokemon *mon);
void HandleBattleLowHpMusicChange(void);
void SetBattlerSpriteAffineMode(u8 affineMode);
void LoadAndCreateEnemyShadowSprites(void);
void SpriteCB_SetInvisible(struct Sprite *sprite);
void SetBattlerShadowSpriteCallback(u8 battlerId, u16 species);
void HideBattlerShadowSprite(u8 battlerId);
void SetBattlerShadowSpriteCallback(u8 battler, u16 species);
void HideBattlerShadowSprite(u8 battler);
void FillAroundBattleWindows(void);
void ClearTemporarySpeciesSpriteData(u8 battlerId, bool8 dontClearSubstitute);
void ClearTemporarySpeciesSpriteData(u8 battler, bool8 dontClearSubstitute);
void AllocateMonSpritesGfx(void);
void FreeMonSpritesGfx(void);
bool32 ShouldPlayNormalMonCry(struct Pokemon *mon);

4
include/battle_main.h
View File

@ -69,12 +69,12 @@ void SwitchInClearSetData(void);
void FaintClearSetData(void);
void BattleTurnPassed(void);
u8 IsRunningFromBattleImpossible(void);
void SwitchPartyOrder(u8 battlerId);
void SwitchPartyOrder(u8 battler);
void SwapTurnOrder(u8 id1, u8 id2);
u8 GetWhoStrikesFirst(u8 battlerId1, u8 battlerId2, bool8 ignoreChosenMoves);
void RunBattleScriptCommands_PopCallbacksStack(void);
void RunBattleScriptCommands(void);
bool8 TryRunFromBattle(u8 battlerId);
bool8 TryRunFromBattle(u8 battler);
void SpecialStatusesClear(void);
extern struct MultiPartnerMenuPokemon gMultiPartnerParty[MULTI_PARTY_SIZE];

2
include/battle_records.h
View File

@ -4,7 +4,7 @@
extern u8 gRecordsWindowId;
void ClearPlayerLinkBattleRecords(void);
void UpdatePlayerLinkBattleRecords(s32 battlerId);
void UpdatePlayerLinkBattleRecords(s32 battler);
void ShowLinkBattleRecords(void);
void RemoveRecordsWindow(void);
void ShowTrainerHillRecords(void);

4
include/battle_script_commands.h
View File

@ -13,13 +13,13 @@
void AI_CalcDmg(u8 battlerIdAtk, u8 battlerIdDef);
u8 TypeCalc(u16 move, u8 battlerIdAtk, u8 battlerIdDef);
u8 AI_TypeCalc(u16 move, u16 targetSpecies, u8 targetAbility);
u8 GetBattlerTurnOrderNum(u8 battlerId);
u8 GetBattlerTurnOrderNum(u8 battler);
void SetMoveEffect(bool8 primary, u8 certain);
void BattleDestroyYesNoCursorAt(u8 cursorPosition);
void BattleCreateYesNoCursorAt(u8 cursorPosition);
void BufferMoveToLearnIntoBattleTextBuff2(void);
void HandleBattleWindow(u8 xStart, u8 yStart, u8 xEnd, u8 yEnd, u8 flags);
bool8 UproarWakeUpCheck(u8 battlerId);
bool8 UproarWakeUpCheck(u8 battler);
extern void (* const gBattleScriptingCommandsTable[])(void);
extern const u8 gBattlePalaceNatureToMoveGroupLikelihood[NUM_NATURES][4];

2
include/battle_tv.h
View File

@ -6,6 +6,6 @@ void BattleTv_SetDataBasedOnMove(u16 move, u16 weatherFlags, struct DisableStruc
void BattleTv_SetDataBasedOnAnimation(u8 animationId);
void TryPutLinkBattleTvShowOnAir(void);
void BattleTv_ClearExplosionFaintCause(void);
u8 GetBattlerMoveSlotId(u8 battlerId, u16 moveId);
u8 GetBattlerMoveSlotId(u8 battler, u16 moveId);
#endif // GUARD_BATTLE_TV_H

30
include/battle_util.h
View File

@ -33,7 +33,7 @@
#define ABILITYEFFECT_WATER_SPORT 254
#define ABILITYEFFECT_SWITCH_IN_WEATHER 255
#define ABILITY_ON_OPPOSING_FIELD(battlerId, abilityId) (AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, battlerId, abilityId, 0, 0))
#define ABILITY_ON_OPPOSING_FIELD(battler, abilityId) (AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, battler, abilityId, 0, 0))
#define ABILITY_ON_FIELD(abilityId) (AbilityBattleEffects(ABILITYEFFECT_CHECK_ON_FIELD, 0, abilityId, 0, 0))
#define ABILITY_ON_FIELD2(abilityId) (AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, abilityId, 0, 0))
@ -64,34 +64,34 @@ u8 GetBattlerForBattleScript(u8 caseId);
void PressurePPLose(u8 target, u8 attacker, u16 move);
void PressurePPLoseOnUsingPerishSong(u8 attacker);
void PressurePPLoseOnUsingImprison(u8 attacker);
void MarkBattlerForControllerExec(u8 battlerId);
void MarkBattlerReceivedLinkData(u8 battlerId);
void CancelMultiTurnMoves(u8 battlerId);
bool8 WasUnableToUseMove(u8 battlerId);
void PrepareStringBattle(u16 stringId, u8 battlerId);
void MarkBattlerForControllerExec(u8 battler);
void MarkBattlerReceivedLinkData(u8 battler);
void CancelMultiTurnMoves(u8 battler);
bool8 WasUnableToUseMove(u8 battler);
void PrepareStringBattle(u16 stringId, u8 battler);
void ResetSentPokesToOpponentValue(void);
void OpponentSwitchInResetSentPokesToOpponentValue(u8 battlerId);
void UpdateSentPokesToOpponentValue(u8 battlerId);
void OpponentSwitchInResetSentPokesToOpponentValue(u8 battler);
void UpdateSentPokesToOpponentValue(u8 battler);
void BattleScriptPush(const u8 *bsPtr);
void BattleScriptPushCursor(void);
void BattleScriptPop(void);
u8 TrySetCantSelectMoveBattleScript(void);
u8 CheckMoveLimitations(u8 battlerId, u8 unusableMoves, u8 check);
u8 CheckMoveLimitations(u8 battler, u8 unusableMoves, u8 check);
bool8 AreAllMovesUnusable(void);
u8 GetImprisonedMovesCount(u8 battlerId, u16 move);
u8 GetImprisonedMovesCount(u8 battler, u16 move);
u8 DoFieldEndTurnEffects(void);
u8 DoBattlerEndTurnEffects(void);
bool8 HandleWishPerishSongOnTurnEnd(void);
bool8 HandleFaintedMonActions(void);
void TryClearRageStatuses(void);
u8 AtkCanceller_UnableToUseMove(void);
bool8 HasNoMonsToSwitch(u8 battlerId, u8 r1, u8 r2);
u8 CastformDataTypeChange(u8 battlerId);
u8 AbilityBattleEffects(u8 caseID, u8 battlerId, u8 ability, u8 special, u16 moveArg);
bool8 HasNoMonsToSwitch(u8 battler, u8 r1, u8 r2);
u8 CastformDataTypeChange(u8 battler);
u8 AbilityBattleEffects(u8 caseID, u8 battler, u8 ability, u8 special, u16 moveArg);
void BattleScriptExecute(const u8 *BS_ptr);
void BattleScriptPushCursorAndCallback(const u8 *BS_ptr);
u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn);
void ClearFuryCutterDestinyBondGrudge(u8 battlerId);
u8 ItemBattleEffects(u8 caseID, u8 battler, bool8 moveTurn);
void ClearFuryCutterDestinyBondGrudge(u8 battler);
void HandleAction_RunBattleScript(void);
u8 GetMoveTarget(u16 move, u8 setTarget);
u8 IsMonDisobedient(void);

4
include/party_menu.h
View File

@ -71,8 +71,8 @@ void ChooseMonForWirelessMinigame(void);
void OpenPartyMenuInBattle(u8 partyAction);
void ChooseMonForInBattleItem(void);
void BufferBattlePartyCurrentOrder(void);
void BufferBattlePartyCurrentOrderBySide(u8 battlerId, u8 flankId);
void SwitchPartyOrderLinkMulti(u8 battlerId, u8 slot, u8 arrayIndex);
void BufferBattlePartyCurrentOrderBySide(u8 battler, u8 flankId);
void SwitchPartyOrderLinkMulti(u8 battler, u8 slot, u8 arrayIndex);
void SwitchPartyMonSlots(u8 slot, u8 slot2);
u8 GetPartyIdFromBattlePartyId(u8 slot);
void ShowPartyMenuToShowcaseMultiBattleParty(void);

8
include/pokemon.h
View File

@ -408,7 +408,7 @@ void CreateBattleTowerMon_HandleLevel(struct Pokemon *mon, struct BattleTowerPok
void CreateApprenticeMon(struct Pokemon *mon, const struct Apprentice *src, u8 monId);
void CreateMonWithEVSpreadNatureOTID(struct Pokemon *mon, u16 species, u8 level, u8 nature, u8 fixedIV, u8 evSpread, u32 otId);
void ConvertPokemonToBattleTowerPokemon(struct Pokemon *mon, struct BattleTowerPokemon *dest);
bool8 ShouldIgnoreDeoxysForm(u8 caseId, u8 battlerId);
bool8 ShouldIgnoreDeoxysForm(u8 caseId, u8 battler);
void SetDeoxysStats(void);
u16 GetUnionRoomTrainerPic(void);
u16 GetUnionRoomTrainerClass(void);
@ -428,7 +428,7 @@ void DeleteFirstMoveAndGiveMoveToMon(struct Pokemon *mon, u16 move);
void DeleteFirstMoveAndGiveMoveToBoxMon(struct BoxPokemon *boxMon, u16 move);
s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *defender, u32 move, u16 sideStatus, u16 powerOverride, u8 typeOverride, u8 bankAtk, u8 bankDef);
u8 CountAliveMonsInBattle(u8 caseId);
u8 GetDefaultMoveTarget(u8 battlerId);
u8 GetDefaultMoveTarget(u8 battler);
u8 GetMonGender(struct Pokemon *mon);
u8 GetBoxMonGender(struct BoxPokemon *boxMon);
u8 GetGenderFromSpeciesAndPersonality(u16 species, u32 personality);
@ -467,10 +467,10 @@ void GetSpeciesName(u8 *name, u16 species);
u8 CalculatePPWithBonus(u16 move, u8 ppBonuses, u8 moveIndex);
void RemoveMonPPBonus(struct Pokemon *mon, u8 moveIndex);
void RemoveBattleMonPPBonus(struct BattlePokemon *mon, u8 moveIndex);
void CopyPlayerPartyMonToBattleData(u8 battlerId, u8 partyIndex);
void CopyPlayerPartyMonToBattleData(u8 battler, u8 partyIndex);
bool8 ExecuteTableBasedItemEffect(struct Pokemon *mon, u16 item, u8 partyIndex, u8 moveIndex);
bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 moveIndex, u8 e);
bool8 HealStatusConditions(struct Pokemon *mon, u32 battlePartyId, u32 healMask, u8 battlerId);
bool8 HealStatusConditions(struct Pokemon *mon, u32 battlePartyId, u32 healMask, u8 battler);
u8 GetItemEffectParamOffset(u16 itemId, u8 effectByte, u8 effectBit);
u8 *UseStatIncreaseItem(u16 itemId);
u8 GetNature(struct Pokemon *mon);

6
include/recorded_battle.h
View File

@ -10,9 +10,9 @@ extern u8 gRecordedBattleMultiplayerId;
void RecordedBattle_Init(u8 mode);
void RecordedBattle_SetTrainerInfo(void);
void RecordedBattle_SetBattlerAction(u8 battlerId, u8 action);
void RecordedBattle_ClearBattlerAction(u8 battlerId, u8 bytesToClear);
u8 RecordedBattle_GetBattlerAction(u8 battlerId);
void RecordedBattle_SetBattlerAction(u8 battler, u8 action);
void RecordedBattle_ClearBattlerAction(u8 battler, u8 bytesToClear);
u8 RecordedBattle_GetBattlerAction(u8 battler);
u8 RecordedBattle_BufferNewBattlerData(u8 *dst);
void RecordedBattle_RecordAllBattlerData(u8 *data);
bool32 CanCopyRecordedBattleSaveData(void);

326
src/battle_ai_script_commands.c
View File

@ -344,7 +344,7 @@ void BattleAI_SetupAIData(u8 defaultScoreMoves)
gBattleResources->AI_ScriptsStack->size = 0;
sBattler_AI = gActiveBattler;
// Decide a random target battlerId in doubles.
// Decide a random target battler in doubles.
if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
{
gBattlerTarget = (Random() & BIT_FLANK) + BATTLE_OPPOSITE(GetBattlerSide(gActiveBattler));
@ -632,32 +632,32 @@ static void RecordLastUsedMoveByTarget(void)
}
}
void ClearBattlerMoveHistory(u8 battlerId)
void ClearBattlerMoveHistory(u8 battler)
{
s32 i;
for (i = 0; i < MAX_MON_MOVES; i++)
BATTLE_HISTORY->usedMoves[battlerId].moves[i] = MOVE_NONE;
BATTLE_HISTORY->usedMoves[battler].moves[i] = MOVE_NONE;
}
void RecordAbilityBattle(u8 battlerId, u8 abilityId)
void RecordAbilityBattle(u8 battler, u8 abilityId)
{
BATTLE_HISTORY->abilities[battlerId] = abilityId;
BATTLE_HISTORY->abilities[battler] = abilityId;
}
void ClearBattlerAbilityHistory(u8 battlerId)
void ClearBattlerAbilityHistory(u8 battler)
{
BATTLE_HISTORY->abilities[battlerId] = ABILITY_NONE;
BATTLE_HISTORY->abilities[battler] = ABILITY_NONE;
}
void RecordItemEffectBattle(u8 battlerId, u8 itemEffect)
void RecordItemEffectBattle(u8 battler, u8 itemEffect)
{
BATTLE_HISTORY->itemEffects[battlerId] = itemEffect;
BATTLE_HISTORY->itemEffects[battler] = itemEffect;
}
void ClearBattlerItemEffectHistory(u8 battlerId)
void ClearBattlerItemEffectHistory(u8 battler)
{
BATTLE_HISTORY->itemEffects[battlerId] = 0;
BATTLE_HISTORY->itemEffects[battler] = 0;
}
static void Cmd_if_random_less_than(void)
@ -712,14 +712,14 @@ static void Cmd_score(void)
static void Cmd_if_hp_less_than(void)
{
u16 battlerId;
u16 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if ((u32)(100 * gBattleMons[battlerId].hp / gBattleMons[battlerId].maxHP) < gAIScriptPtr[2])
if ((u32)(100 * gBattleMons[battler].hp / gBattleMons[battler].maxHP) < gAIScriptPtr[2])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
@ -727,14 +727,14 @@ static void Cmd_if_hp_less_than(void)
static void Cmd_if_hp_more_than(void)
{
u16 battlerId;
u16 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if ((u32)(100 * gBattleMons[battlerId].hp / gBattleMons[battlerId].maxHP) > gAIScriptPtr[2])
if ((u32)(100 * gBattleMons[battler].hp / gBattleMons[battler].maxHP) > gAIScriptPtr[2])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
@ -742,14 +742,14 @@ static void Cmd_if_hp_more_than(void)
static void Cmd_if_hp_equal(void)
{
u16 battlerId;
u16 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if ((u32)(100 * gBattleMons[battlerId].hp / gBattleMons[battlerId].maxHP) == gAIScriptPtr[2])
if ((u32)(100 * gBattleMons[battler].hp / gBattleMons[battler].maxHP) == gAIScriptPtr[2])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
@ -757,14 +757,14 @@ static void Cmd_if_hp_equal(void)
static void Cmd_if_hp_not_equal(void)
{
u16 battlerId;
u16 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if ((u32)(100 * gBattleMons[battlerId].hp / gBattleMons[battlerId].maxHP) != gAIScriptPtr[2])
if ((u32)(100 * gBattleMons[battler].hp / gBattleMons[battler].maxHP) != gAIScriptPtr[2])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
@ -772,17 +772,17 @@ static void Cmd_if_hp_not_equal(void)
static void Cmd_if_status(void)
{
u16 battlerId;
u16 battler;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (gBattleMons[battlerId].status1 & status)
if (gBattleMons[battler].status1 & status)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
@ -790,17 +790,17 @@ static void Cmd_if_status(void)
static void Cmd_if_not_status(void)
{
u16 battlerId;
u16 battler;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (!(gBattleMons[battlerId].status1 & status))
if (!(gBattleMons[battler].status1 & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
@ -808,17 +808,17 @@ static void Cmd_if_not_status(void)
static void Cmd_if_status2(void)
{
u16 battlerId;
u16 battler;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if ((gBattleMons[battlerId].status2 & status))
if ((gBattleMons[battler].status2 & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
@ -826,17 +826,17 @@ static void Cmd_if_status2(void)
static void Cmd_if_not_status2(void)
{
u16 battlerId;
u16 battler;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (!(gBattleMons[battlerId].status2 & status))
if (!(gBattleMons[battler].status2 & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
@ -844,17 +844,17 @@ static void Cmd_if_not_status2(void)
static void Cmd_if_status3(void)
{
u16 battlerId;
u16 battler;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (gStatuses3[battlerId] & status)
if (gStatuses3[battler] & status)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
@ -862,17 +862,17 @@ static void Cmd_if_status3(void)
static void Cmd_if_not_status3(void)
{
u16 battlerId;
u16 battler;
u32 status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
status = T1_READ_32(gAIScriptPtr + 2);
if (!(gStatuses3[battlerId] & status))
if (!(gStatuses3[battler] & status))
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 6);
else
gAIScriptPtr += 10;
@ -880,15 +880,15 @@ static void Cmd_if_not_status3(void)
static void Cmd_if_side_affecting(void)
{
u16 battlerId;
u16 battler;
u32 side, status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
side = GET_BATTLER_SIDE(battlerId);
side = GET_BATTLER_SIDE(battler);
status = T1_READ_32(gAIScriptPtr + 2);
if (gSideStatuses[side] & status)
@ -899,15 +899,15 @@ static void Cmd_if_side_affecting(void)
static void Cmd_if_not_side_affecting(void)
{
u16 battlerId;
u16 battler;
u32 side, status;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
side = GET_BATTLER_SIDE(battlerId);
side = GET_BATTLER_SIDE(battler);
status = T1_READ_32(gAIScriptPtr + 2);
if (!(gSideStatuses[side] & status))
@ -1155,9 +1155,9 @@ static u8 BattleAI_GetWantedBattler(u8 wantedBattler)
static void Cmd_is_of_type(void)
{
u8 battlerId = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
u8 battler = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
if (IS_BATTLER_OF_TYPE(battlerId, gAIScriptPtr[2]))
if (IS_BATTLER_OF_TYPE(battler, gAIScriptPtr[2]))
AI_THINKING_STRUCT->funcResult = TRUE;
else
AI_THINKING_STRUCT->funcResult = FALSE;
@ -1291,7 +1291,7 @@ static void Cmd_nop_2B(void)
static void Cmd_count_usable_party_mons(void)
{
u8 battlerId;
u8 battler;
u8 battlerOnField1, battlerOnField2;
struct Pokemon *party;
s32 i;
@ -1299,11 +1299,11 @@ static void Cmd_count_usable_party_mons(void)
AI_THINKING_STRUCT->funcResult = 0;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
party = gPlayerParty;
else
party = gEnemyParty;
@ -1311,14 +1311,14 @@ static void Cmd_count_usable_party_mons(void)
if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
{
u32 position;
battlerOnField1 = gBattlerPartyIndexes[battlerId];
position = BATTLE_PARTNER(GetBattlerPosition(battlerId));
battlerOnField1 = gBattlerPartyIndexes[battler];
position = BATTLE_PARTNER(GetBattlerPosition(battler));
battlerOnField2 = gBattlerPartyIndexes[GetBattlerAtPosition(position)];
}
else // In singles there's only one battlerId by side.
else // In singles there's only one battler by side.
{
battlerOnField1 = gBattlerPartyIndexes[battlerId];
battlerOnField2 = gBattlerPartyIndexes[battlerId];
battlerOnField1 = gBattlerPartyIndexes[battler];
battlerOnField2 = gBattlerPartyIndexes[battler];
}
for (i = 0; i < PARTY_SIZE; i++)
@ -1349,56 +1349,56 @@ static void Cmd_get_considered_move_effect(void)
static void Cmd_get_ability(void)
{
u8 battlerId;
u8 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if (gActiveBattler != battlerId)
if (gActiveBattler != battler)
{
if (BATTLE_HISTORY->abilities[battlerId] != 0)
if (BATTLE_HISTORY->abilities[battler] != 0)
{
AI_THINKING_STRUCT->funcResult = BATTLE_HISTORY->abilities[battlerId];
AI_THINKING_STRUCT->funcResult = BATTLE_HISTORY->abilities[battler];
gAIScriptPtr += 2;
return;
}
// abilities that prevent fleeing.
if (gBattleMons[battlerId].ability == ABILITY_SHADOW_TAG
|| gBattleMons[battlerId].ability == ABILITY_MAGNET_PULL
|| gBattleMons[battlerId].ability == ABILITY_ARENA_TRAP)
if (gBattleMons[battler].ability == ABILITY_SHADOW_TAG
|| gBattleMons[battler].ability == ABILITY_MAGNET_PULL
|| gBattleMons[battler].ability == ABILITY_ARENA_TRAP)
{
AI_THINKING_STRUCT->funcResult = gBattleMons[battlerId].ability;
AI_THINKING_STRUCT->funcResult = gBattleMons[battler].ability;
gAIScriptPtr += 2;
return;
}
if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[0] != ABILITY_NONE)
if (gSpeciesInfo[gBattleMons[battler].species].abilities[0] != ABILITY_NONE)
{
if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[1] != ABILITY_NONE)
if (gSpeciesInfo[gBattleMons[battler].species].abilities[1] != ABILITY_NONE)
{
// AI has no knowledge of opponent, so it guesses which ability.
if (Random() & 1)
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battlerId].species].abilities[0];
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battler].species].abilities[0];
else
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battlerId].species].abilities[1];
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battler].species].abilities[1];
}
else
{
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battlerId].species].abilities[0]; // It's definitely ability 1.
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battler].species].abilities[0]; // It's definitely ability 1.
}
}
else
{
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battlerId].species].abilities[1]; // AI can't actually reach this part since no Pokémon has ability 2 and no ability 1.
AI_THINKING_STRUCT->funcResult = gSpeciesInfo[gBattleMons[battler].species].abilities[1]; // AI can't actually reach this part since no Pokémon has ability 2 and no ability 1.
}
}
else
{
// The AI knows its own ability.
AI_THINKING_STRUCT->funcResult = gBattleMons[battlerId].ability;
AI_THINKING_STRUCT->funcResult = gBattleMons[battler].ability;
}
gAIScriptPtr += 2;
@ -1406,32 +1406,32 @@ static void Cmd_get_ability(void)
static void Cmd_check_ability(void)
{
u32 battlerId = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
u32 battler = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
u32 ability = gAIScriptPtr[2];
if (gAIScriptPtr[1] == AI_TARGET || gAIScriptPtr[1] == AI_TARGET_PARTNER)
{
if (BATTLE_HISTORY->abilities[battlerId] != ABILITY_NONE)
if (BATTLE_HISTORY->abilities[battler] != ABILITY_NONE)
{
ability = BATTLE_HISTORY->abilities[battlerId];
ability = BATTLE_HISTORY->abilities[battler];
AI_THINKING_STRUCT->funcResult = ability;
}
// Abilities that prevent fleeing.
else if (gBattleMons[battlerId].ability == ABILITY_SHADOW_TAG
|| gBattleMons[battlerId].ability == ABILITY_MAGNET_PULL
|| gBattleMons[battlerId].ability == ABILITY_ARENA_TRAP)
else if (gBattleMons[battler].ability == ABILITY_SHADOW_TAG
|| gBattleMons[battler].ability == ABILITY_MAGNET_PULL
|| gBattleMons[battler].ability == ABILITY_ARENA_TRAP)
{
ability = gBattleMons[battlerId].ability;
ability = gBattleMons[battler].ability;
}
else if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[0] != ABILITY_NONE)
else if (gSpeciesInfo[gBattleMons[battler].species].abilities[0] != ABILITY_NONE)
{
if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[1] != ABILITY_NONE)
if (gSpeciesInfo[gBattleMons[battler].species].abilities[1] != ABILITY_NONE)
{
u8 abilityDummyVariable = ability; // Needed to match.
if (gSpeciesInfo[gBattleMons[battlerId].species].abilities[0] != abilityDummyVariable
&& gSpeciesInfo[gBattleMons[battlerId].species].abilities[1] != abilityDummyVariable)
if (gSpeciesInfo[gBattleMons[battler].species].abilities[0] != abilityDummyVariable
&& gSpeciesInfo[gBattleMons[battler].species].abilities[1] != abilityDummyVariable)
{
ability = gSpeciesInfo[gBattleMons[battlerId].species].abilities[0];
ability = gSpeciesInfo[gBattleMons[battler].species].abilities[0];
}
else
{
@ -1440,18 +1440,18 @@ static void Cmd_check_ability(void)
}
else
{
ability = gSpeciesInfo[gBattleMons[battlerId].species].abilities[0];
ability = gSpeciesInfo[gBattleMons[battler].species].abilities[0];
}
}
else
{
ability = gSpeciesInfo[gBattleMons[battlerId].species].abilities[1]; // AI can't actually reach this part since no Pokémon has ability 2 and no ability 1.
ability = gSpeciesInfo[gBattleMons[battler].species].abilities[1]; // AI can't actually reach this part since no Pokémon has ability 2 and no ability 1.
}
}
else
{
// The AI knows its own or partner's ability.
ability = gBattleMons[battlerId].ability;
ability = gBattleMons[battler].ability;
}
if (ability == 0)
@ -1570,19 +1570,19 @@ static void Cmd_if_status_in_party(void)
struct Pokemon *party;
s32 i;
u32 statusToCompareTo;
u8 battlerId;
u8 battler;
switch (gAIScriptPtr[1])
{
case AI_USER:
battlerId = sBattler_AI;
battler = sBattler_AI;
break;
default:
battlerId = gBattlerTarget;
battler = gBattlerTarget;
break;
}
party = (GetBattlerSide(battlerId) == B_SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
party = (GetBattlerSide(battler) == B_SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
statusToCompareTo = T1_READ_32(gAIScriptPtr + 2);
@ -1607,19 +1607,19 @@ static void Cmd_if_status_not_in_party(void)
struct Pokemon *party;
s32 i;
u32 statusToCompareTo;
u8 battlerId;
u8 battler;
switch(gAIScriptPtr[1])
{
case 1:
battlerId = sBattler_AI;
battler = sBattler_AI;
break;
default:
battlerId = gBattlerTarget;
battler = gBattlerTarget;
break;
}
party = (GetBattlerSide(battlerId) == B_SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
party = (GetBattlerSide(battler) == B_SIDE_PLAYER) ? gPlayerParty : gEnemyParty;
statusToCompareTo = T1_READ_32(gAIScriptPtr + 2);
@ -1673,14 +1673,14 @@ static void Cmd_if_not_effect(void)
static void Cmd_if_stat_level_less_than(void)
{
u32 battlerId;
u32 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if (gBattleMons[battlerId].statStages[gAIScriptPtr[2]] < gAIScriptPtr[3])
if (gBattleMons[battler].statStages[gAIScriptPtr[2]] < gAIScriptPtr[3])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
@ -1688,14 +1688,14 @@ static void Cmd_if_stat_level_less_than(void)
static void Cmd_if_stat_level_more_than(void)
{
u32 battlerId;
u32 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if (gBattleMons[battlerId].statStages[gAIScriptPtr[2]] > gAIScriptPtr[3])
if (gBattleMons[battler].statStages[gAIScriptPtr[2]] > gAIScriptPtr[3])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
@ -1703,14 +1703,14 @@ static void Cmd_if_stat_level_more_than(void)
static void Cmd_if_stat_level_equal(void)
{
u32 battlerId;
u32 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if (gBattleMons[battlerId].statStages[gAIScriptPtr[2]] == gAIScriptPtr[3])
if (gBattleMons[battler].statStages[gAIScriptPtr[2]] == gAIScriptPtr[3])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
@ -1718,14 +1718,14 @@ static void Cmd_if_stat_level_equal(void)
static void Cmd_if_stat_level_not_equal(void)
{
u32 battlerId;
u32 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if (gBattleMons[battlerId].statStages[gAIScriptPtr[2]] != gAIScriptPtr[3])
if (gBattleMons[battler].statStages[gAIScriptPtr[2]] != gAIScriptPtr[3])
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4);
else
gAIScriptPtr += 8;
@ -1951,16 +1951,16 @@ static void Cmd_if_doesnt_have_move_with_effect(void)
static void Cmd_if_any_move_disabled_or_encored(void)
{
u8 battlerId;
u8 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if (gAIScriptPtr[2] == 0)
{
if (gDisableStructs[battlerId].disabledMove == MOVE_NONE)
if (gDisableStructs[battler].disabledMove == MOVE_NONE)
gAIScriptPtr += 7;
else
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
@ -1971,7 +1971,7 @@ static void Cmd_if_any_move_disabled_or_encored(void)
}
else
{
if (gDisableStructs[battlerId].encoredMove != MOVE_NONE)
if (gDisableStructs[battler].encoredMove != MOVE_NONE)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
else
gAIScriptPtr += 7;
@ -2022,31 +2022,31 @@ static void Cmd_watch(void)
static void Cmd_get_hold_effect(void)
{
u8 battlerId;
u8 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
if (gActiveBattler != battlerId)
AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(BATTLE_HISTORY->itemEffects[battlerId]);
if (gActiveBattler != battler)
AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(BATTLE_HISTORY->itemEffects[battler]);
else
AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(gBattleMons[battlerId].item);
AI_THINKING_STRUCT->funcResult = ItemId_GetHoldEffect(gBattleMons[battler].item);
gAIScriptPtr += 2;
}
static void Cmd_if_holds_item(void)
{
u8 battlerId = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
u8 battler = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
u16 item;
u8 itemLo, itemHi;
if ((battlerId & BIT_SIDE) == (sBattler_AI & BIT_SIDE))
item = gBattleMons[battlerId].item;
if ((battler & BIT_SIDE) == (sBattler_AI & BIT_SIDE))
item = gBattleMons[battler].item;
else
item = BATTLE_HISTORY->itemEffects[battlerId];
item = BATTLE_HISTORY->itemEffects[battler];
itemHi = gAIScriptPtr[2];
itemLo = gAIScriptPtr[3];
@ -2066,42 +2066,42 @@ static void Cmd_if_holds_item(void)
static void Cmd_get_gender(void)
{
u8 battlerId;
u8 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = GetGenderFromSpeciesAndPersonality(gBattleMons[battlerId].species, gBattleMons[battlerId].personality);
AI_THINKING_STRUCT->funcResult = GetGenderFromSpeciesAndPersonality(gBattleMons[battler].species, gBattleMons[battler].personality);
gAIScriptPtr += 2;
}
static void Cmd_is_first_turn_for(void)
{
u8 battlerId;
u8 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battlerId].isFirstTurn;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battler].isFirstTurn;
gAIScriptPtr += 2;
}
static void Cmd_get_stockpile_count(void)
{
u8 battlerId;
u8 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battlerId].stockpileCounter;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battler].stockpileCounter;
gAIScriptPtr += 2;
}
@ -2115,14 +2115,14 @@ static void Cmd_is_double_battle(void)
static void Cmd_get_used_held_item(void)
{
u8 battlerId;
u8 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = *(u8 *)&gBattleStruct->usedHeldItems[battlerId];
AI_THINKING_STRUCT->funcResult = *(u8 *)&gBattleStruct->usedHeldItems[battler];
gAIScriptPtr += 2;
}
@ -2150,14 +2150,14 @@ static void Cmd_get_move_effect_from_result(void)
static void Cmd_get_protect_count(void)
{
u8 battlerId;
u8 battler;
if (gAIScriptPtr[1] == AI_USER)
battlerId = sBattler_AI;
battler = sBattler_AI;
else
battlerId = gBattlerTarget;
battler = gBattlerTarget;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battlerId].protectUses;
AI_THINKING_STRUCT->funcResult = gDisableStructs[battler].protectUses;
gAIScriptPtr += 2;
}
@ -2254,9 +2254,9 @@ static void Cmd_if_target_is_ally(void)
static void Cmd_if_flash_fired(void)
{
u8 battlerId = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
u8 battler = BattleAI_GetWantedBattler(gAIScriptPtr[1]);
if (gBattleResources->flags->flags[battlerId] & RESOURCE_FLAG_FLASH_FIRE)
if (gBattleResources->flags->flags[battler] & RESOURCE_FLAG_FLASH_FIRE)
gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
else
gAIScriptPtr += 6;

134
src/battle_anim.c
View File

@ -592,30 +592,30 @@ static void Cmd_monbg(void)
{
bool8 toBG_2;
u8 taskId;
u8 battlerId;
u8 battler;
u8 animBattler;
sBattleAnimScriptPtr++;
animBattler = sBattleAnimScriptPtr[0];
if (animBattler & ANIM_TARGET)
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
else
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
// Move designated battler to background
if (IsBattlerSpriteVisible(battlerId))
if (IsBattlerSpriteVisible(battler))
{
u8 position = GetBattlerPosition(battlerId);
u8 position = GetBattlerPosition(battler);
if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
toBG_2 = FALSE;
else
toBG_2 = TRUE;
MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE);
MoveBattlerSpriteToBG(battler, toBG_2, FALSE);
taskId = CreateTask(Task_InitUpdateMonBg, 10);
gAnimVisualTaskCount++;
gTasks[taskId].tBattlerId = battlerId;
gTasks[taskId].tBattlerId = battler;
gTasks[taskId].tInBg2 = toBG_2;
gTasks[taskId].tActive = TRUE;
gTasks[taskId].tIsPartner = FALSE;
@ -623,19 +623,19 @@ static void Cmd_monbg(void)
}
// Move battler's partner to background
battlerId ^= BIT_FLANK;
if (IsBattlerSpriteVisible(battlerId))
battler ^= BIT_FLANK;
if (IsBattlerSpriteVisible(battler))
{
u8 position = GetBattlerPosition(battlerId);
u8 position = GetBattlerPosition(battler);
if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
toBG_2 = FALSE;
else
toBG_2 = TRUE;
MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE);
MoveBattlerSpriteToBG(battler, toBG_2, FALSE);
taskId = CreateTask(Task_InitUpdateMonBg, 10);
gAnimVisualTaskCount++;
gTasks[taskId].tBattlerId = battlerId;
gTasks[taskId].tBattlerId = battler;
gTasks[taskId].tInBg2 = toBG_2;
gTasks[taskId].tActive = TRUE;
gTasks[taskId].tIsPartner = TRUE;
@ -646,26 +646,26 @@ static void Cmd_monbg(void)
gAnimScriptCallback = WaitAnimFrameCount;
}
bool8 IsBattlerSpriteVisible(u8 battlerId)
bool8 IsBattlerSpriteVisible(u8 battler)
{
if (IsContest())
{
if (battlerId == gBattleAnimAttacker)
if (battler == gBattleAnimAttacker)
return TRUE;
else
return FALSE;
}
if (!IsBattlerSpritePresent(battlerId))
if (!IsBattlerSpritePresent(battler))
return FALSE;
if (IsContest())
return TRUE; // This line won't ever be reached.
if (!gBattleSpritesDataPtr->battlerData[battlerId].invisible || !gSprites[gBattlerSpriteIds[battlerId]].invisible)
if (!gBattleSpritesDataPtr->battlerData[battler].invisible || !gSprites[gBattlerSpriteIds[battler]].invisible)
return TRUE;
return FALSE;
}
void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible)
void MoveBattlerSpriteToBG(u8 battler, bool8 toBG_2, bool8 setSpriteInvisible)
{
struct BattleAnimBgData animBg;
u8 battlerSpriteId;
@ -693,7 +693,7 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible)
SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 1);
SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0);
battlerSpriteId = gBattlerSpriteIds[battlerId];
battlerSpriteId = gBattlerSpriteIds[battler];
gBattle_BG1_X = -(gSprites[battlerSpriteId].x + gSprites[battlerSpriteId].x2) + 0x20;
if (IsContest() && IsSpeciesNotUnown(gContestResources->moveAnim->species))
@ -701,18 +701,18 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible)
gBattle_BG1_Y = -(gSprites[battlerSpriteId].y + gSprites[battlerSpriteId].y2) + 0x20;
if (setSpriteInvisible)
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X);
SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y);
LoadPalette(&gPlttBufferUnfaded[OBJ_PLTT_ID(battlerId)], BG_PLTT_ID(animBg.paletteId), PLTT_SIZE_4BPP);
CpuCopy32(&gPlttBufferUnfaded[OBJ_PLTT_ID(battlerId)], (void *)(BG_PLTT + PLTT_OFFSET_4BPP(animBg.paletteId)), PLTT_SIZE_4BPP);
LoadPalette(&gPlttBufferUnfaded[OBJ_PLTT_ID(battler)], BG_PLTT_ID(animBg.paletteId), PLTT_SIZE_4BPP);
CpuCopy32(&gPlttBufferUnfaded[OBJ_PLTT_ID(battler)], (void *)(BG_PLTT + PLTT_OFFSET_4BPP(animBg.paletteId)), PLTT_SIZE_4BPP);
if (IsContest())
battlerPosition = 0;
else
battlerPosition = GetBattlerPosition(battlerId);
battlerPosition = GetBattlerPosition(battler);
DrawBattlerOnBg(1, 0, 0, battlerPosition, animBg.paletteId, animBg.bgTiles, animBg.bgTilemap, animBg.tilesOffset);
@ -730,21 +730,21 @@ void MoveBattlerSpriteToBG(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible)
SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1);
SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0);
battlerSpriteId = gBattlerSpriteIds[battlerId];
battlerSpriteId = gBattlerSpriteIds[battler];
gBattle_BG2_X = -(gSprites[battlerSpriteId].x + gSprites[battlerSpriteId].x2) + 0x20;
gBattle_BG2_Y = -(gSprites[battlerSpriteId].y + gSprites[battlerSpriteId].y2) + 0x20;
if (setSpriteInvisible)
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X);
SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y);
LoadPalette(&gPlttBufferUnfaded[OBJ_PLTT_ID(battlerId)], BG_PLTT_ID(9), PLTT_SIZE_4BPP);
CpuCopy32(&gPlttBufferUnfaded[OBJ_PLTT_ID(battlerId)], (void *)(BG_PLTT + PLTT_OFFSET_4BPP(9)), PLTT_SIZE_4BPP);
LoadPalette(&gPlttBufferUnfaded[OBJ_PLTT_ID(battler)], BG_PLTT_ID(9), PLTT_SIZE_4BPP);
CpuCopy32(&gPlttBufferUnfaded[OBJ_PLTT_ID(battler)], (void *)(BG_PLTT + PLTT_OFFSET_4BPP(9)), PLTT_SIZE_4BPP);
DrawBattlerOnBg(2, 0, 0, GetBattlerPosition(battlerId), animBg.paletteId, animBg.bgTiles + 0x1000, animBg.bgTilemap + 0x400, animBg.tilesOffset);
DrawBattlerOnBg(2, 0, 0, GetBattlerPosition(battler), animBg.paletteId, animBg.bgTiles + 0x1000, animBg.bgTilemap + 0x400, animBg.tilesOffset);
}
}
@ -812,12 +812,12 @@ void ResetBattleAnimBg(bool8 toBG2)
static void Task_UpdateMonBg(u8 taskId)
{
u8 spriteId, battlerId;
u8 spriteId, battler;
s16 x, y;
struct BattleAnimBgData animBg;
spriteId = gTasks[taskId].t2_SpriteId;
battlerId = gTasks[taskId].t2_BattlerId;
battler = gTasks[taskId].t2_BattlerId;
GetBattleAnimBg1Data(&animBg);
x = gTasks[taskId].t2_SpriteX - (gSprites[spriteId].x + gSprites[spriteId].x2);
y = gTasks[taskId].t2_SpriteY - (gSprites[spriteId].y + gSprites[spriteId].y2);
@ -826,13 +826,13 @@ static void Task_UpdateMonBg(u8 taskId)
{
gBattle_BG1_X = x + gTasks[taskId].t2_BgX;
gBattle_BG1_Y = y + gTasks[taskId].t2_BgY;
CpuCopy32(&gPlttBufferFaded[OBJ_PLTT_ID(battlerId)], &gPlttBufferFaded[BG_PLTT_ID(animBg.paletteId)], PLTT_SIZE_4BPP);
CpuCopy32(&gPlttBufferFaded[OBJ_PLTT_ID(battler)], &gPlttBufferFaded[BG_PLTT_ID(animBg.paletteId)], PLTT_SIZE_4BPP);
}
else
{
gBattle_BG2_X = x + gTasks[taskId].t2_BgX;
gBattle_BG2_Y = y + gTasks[taskId].t2_BgY;
CpuCopy32(&gPlttBufferFaded[OBJ_PLTT_ID(battlerId)], &gPlttBufferFaded[BG_PLTT_ID(9)], PLTT_SIZE_4BPP);
CpuCopy32(&gPlttBufferFaded[OBJ_PLTT_ID(battler)], &gPlttBufferFaded[BG_PLTT_ID(9)], PLTT_SIZE_4BPP);
}
}
@ -852,7 +852,7 @@ static void Task_UpdateMonBg(u8 taskId)
static void Cmd_clearmonbg(void)
{
u8 animBattlerId;
u8 battlerId;
u8 battler;
u8 taskId;
sBattleAnimScriptPtr++;
@ -864,20 +864,20 @@ static void Cmd_clearmonbg(void)
animBattlerId = ANIM_DEF_PARTNER;
if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER)
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
else
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
if (sMonAnimTaskIdArray[0] != TASK_NONE)
gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE;
gSprites[gBattlerSpriteIds[battler]].invisible = FALSE;
if (animBattlerId > 1 && sMonAnimTaskIdArray[1] != TASK_NONE)
gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battlerId)]].invisible = FALSE;
gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler)]].invisible = FALSE;
else
animBattlerId = 0;
taskId = CreateTask(Task_ClearMonBg, 5);
gTasks[taskId].data[0] = animBattlerId;
gTasks[taskId].data[2] = battlerId;
gTasks[taskId].data[2] = battler;
sBattleAnimScriptPtr++;
}
@ -914,7 +914,7 @@ static void Task_ClearMonBg(u8 taskId)
static void Cmd_monbg_static(void)
{
bool8 toBG_2;
u8 battlerId;
u8 battler;
u8 animBattlerId;
sBattleAnimScriptPtr++;
@ -927,31 +927,31 @@ static void Cmd_monbg_static(void)
animBattlerId = ANIM_DEF_PARTNER;
if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER)
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
else
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
if (IsBattlerSpriteVisible(battlerId))
if (IsBattlerSpriteVisible(battler))
{
u8 position = GetBattlerPosition(battlerId);
u8 position = GetBattlerPosition(battler);
if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
toBG_2 = FALSE;
else
toBG_2 = TRUE;
MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE);
MoveBattlerSpriteToBG(battler, toBG_2, FALSE);
}
battlerId ^= BIT_FLANK;
if (animBattlerId > 1 && IsBattlerSpriteVisible(battlerId))
battler ^= BIT_FLANK;
if (animBattlerId > 1 && IsBattlerSpriteVisible(battler))
{
u8 position = GetBattlerPosition(battlerId);
u8 position = GetBattlerPosition(battler);
if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
toBG_2 = FALSE;
else
toBG_2 = TRUE;
MoveBattlerSpriteToBG(battlerId, toBG_2, FALSE);
MoveBattlerSpriteToBG(battler, toBG_2, FALSE);
}
sBattleAnimScriptPtr++;
@ -960,7 +960,7 @@ static void Cmd_monbg_static(void)
static void Cmd_clearmonbg_static(void)
{
u8 animBattlerId;
u8 battlerId;
u8 battler;
u8 taskId;
sBattleAnimScriptPtr++;
@ -972,20 +972,20 @@ static void Cmd_clearmonbg_static(void)
animBattlerId = ANIM_DEF_PARTNER;
if (animBattlerId == ANIM_ATTACKER || animBattlerId == ANIM_ATK_PARTNER)
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
else
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
if (IsBattlerSpriteVisible(battlerId))
gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE;
if (animBattlerId > 1 && IsBattlerSpriteVisible(BATTLE_PARTNER(battlerId)))
gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battlerId)]].invisible = FALSE;
if (IsBattlerSpriteVisible(battler))
gSprites[gBattlerSpriteIds[battler]].invisible = FALSE;
if (animBattlerId > 1 && IsBattlerSpriteVisible(BATTLE_PARTNER(battler)))
gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler)]].invisible = FALSE;
else
animBattlerId = 0;
taskId = CreateTask(Task_ClearMonBgStatic, 5);
gTasks[taskId].data[0] = animBattlerId;
gTasks[taskId].data[2] = battlerId;
gTasks[taskId].data[2] = battler;
sBattleAnimScriptPtr++;
}
@ -996,16 +996,16 @@ static void Task_ClearMonBgStatic(u8 taskId)
if (gTasks[taskId].data[1] != 1)
{
bool8 toBG_2;
u8 battlerId = gTasks[taskId].data[2];
u8 position = GetBattlerPosition(battlerId);
u8 battler = gTasks[taskId].data[2];
u8 position = GetBattlerPosition(battler);
if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest())
toBG_2 = FALSE;
else
toBG_2 = TRUE;
if (IsBattlerSpriteVisible(battlerId))
if (IsBattlerSpriteVisible(battler))
ResetBattleAnimBg(toBG_2);
if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(BATTLE_PARTNER(battlerId)))
if (gTasks[taskId].data[0] > 1 && IsBattlerSpriteVisible(BATTLE_PARTNER(battler)))
ResetBattleAnimBg(toBG_2 ^ 1);
DestroyTask(taskId);
@ -1687,19 +1687,19 @@ static void Cmd_jumpifcontest(void)
static void Cmd_splitbgprio(void)
{
u8 wantedBattler;
u8 battlerId;
u8 battler;
u8 battlerPosition;
wantedBattler = sBattleAnimScriptPtr[1];
sBattleAnimScriptPtr += 2;
if (wantedBattler != ANIM_ATTACKER)
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
else
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
// Apply only if the given battler is the lead (on left from team's perspective)
battlerPosition = GetBattlerPosition(battlerId);
battlerPosition = GetBattlerPosition(battler);
if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT))
{
SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
@ -1721,7 +1721,7 @@ static void Cmd_splitbgprio_foes(void)
{
u8 wantedBattler;
u8 battlerPosition;
u8 battlerId;
u8 battler;
wantedBattler = sBattleAnimScriptPtr[1];
sBattleAnimScriptPtr += 2;
@ -1730,12 +1730,12 @@ static void Cmd_splitbgprio_foes(void)
if (GetBattlerSide(gBattleAnimAttacker) != GetBattlerSide(gBattleAnimTarget))
{
if (wantedBattler != ANIM_ATTACKER)
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
else
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
// Apply only if the given battler is the lead (on left from team's perspective)
battlerPosition = GetBattlerPosition(battlerId);
battlerPosition = GetBattlerPosition(battler);
if (!IsContest() && (battlerPosition == B_POSITION_PLAYER_LEFT || battlerPosition == B_POSITION_OPPONENT_RIGHT))
{
SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);

24
src/battle_anim_mon_movement.c
View File

@ -156,7 +156,7 @@ void AnimTask_ShakeMon2(u8 taskId)
{
u8 spriteId;
bool8 abort = FALSE;
u8 battlerId;
u8 battler;
if (gBattleAnimArgs[0] < MAX_BATTLERS_COUNT)
{
@ -169,24 +169,24 @@ void AnimTask_ShakeMon2(u8 taskId)
switch (gBattleAnimArgs[0])
{
case ANIM_PLAYER_LEFT:
battlerId = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
break;
case ANIM_PLAYER_RIGHT:
battlerId = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
battler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
break;
case ANIM_OPPONENT_LEFT:
battlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
break;
case ANIM_OPPONENT_RIGHT:
default:
battlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
battler = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
break;
}
if (IsBattlerSpriteVisible(battlerId) == FALSE)
if (IsBattlerSpriteVisible(battler) == FALSE)
abort = TRUE;
spriteId = gBattlerSpriteIds[battlerId];
spriteId = gBattlerSpriteIds[battler];
}
else
{
@ -578,16 +578,16 @@ static void SlideMonToOffset(struct Sprite *sprite)
static void SlideMonToOffsetAndBack(struct Sprite *sprite)
{
u8 spriteId;
u8 battlerId;
u8 battler;
sprite->invisible = TRUE;
if (gBattleAnimArgs[0] == ANIM_ATTACKER)
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
else
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
spriteId = gBattlerSpriteIds[battlerId];
if (GetBattlerSide(battlerId))
spriteId = gBattlerSpriteIds[battler];
if (GetBattlerSide(battler))
{
gBattleAnimArgs[1] = -gBattleAnimArgs[1];
if (gBattleAnimArgs[3] == 1)

238
src/battle_anim_mons.c
View File

@ -109,7 +109,7 @@ static const struct SpriteSheet sSpriteSheets_MoveEffectMons[] =
{ gMiscBlank_Gfx, MON_PIC_SIZE, TAG_MOVE_EFFECT_MON_2, },
};
u8 GetBattlerSpriteCoord(u8 battlerId, u8 coordType)
u8 GetBattlerSpriteCoord(u8 battler, u8 coordType)
{
u8 retVal;
u16 species;
@ -117,7 +117,7 @@ u8 GetBattlerSpriteCoord(u8 battlerId, u8 coordType)
if (IsContest())
{
if (coordType == BATTLER_COORD_Y_PIC_OFFSET && battlerId == 3)
if (coordType == BATTLER_COORD_Y_PIC_OFFSET && battler == 3)
coordType = BATTLER_COORD_Y;
}
@ -125,10 +125,10 @@ u8 GetBattlerSpriteCoord(u8 battlerId, u8 coordType)
{
case BATTLER_COORD_X:
case BATTLER_COORD_X_2:
retVal = sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].x;
retVal = sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battler)].x;
break;
case BATTLER_COORD_Y:
retVal = sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].y;
retVal = sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battler)].y;
break;
case BATTLER_COORD_Y_PIC_OFFSET:
case BATTLER_COORD_Y_PIC_OFFSET_DEFAULT:
@ -142,34 +142,34 @@ u8 GetBattlerSpriteCoord(u8 battlerId, u8 coordType)
}
else
{
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
if (!spriteInfo[battler].transformSpecies)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
species = spriteInfo[battler].transformSpecies;
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
if (!spriteInfo[battler].transformSpecies)
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
species = spriteInfo[battler].transformSpecies;
}
}
if (coordType == BATTLER_COORD_Y_PIC_OFFSET)
retVal = GetBattlerSpriteFinal_Y(battlerId, species, TRUE);
retVal = GetBattlerSpriteFinal_Y(battler, species, TRUE);
else
retVal = GetBattlerSpriteFinal_Y(battlerId, species, FALSE);
retVal = GetBattlerSpriteFinal_Y(battler, species, FALSE);
break;
}
return retVal;
}
u8 GetBattlerYDelta(u8 battlerId, u16 species)
u8 GetBattlerYDelta(u8 battler, u16 species)
{
u16 letter;
u32 personality;
@ -177,7 +177,7 @@ u8 GetBattlerYDelta(u8 battlerId, u16 species)
u8 ret;
u16 coordSpecies;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER || IsContest())
if (GetBattlerSide(battler) == B_SIDE_PLAYER || IsContest())
{
if (species == SPECIES_UNOWN)
{
@ -191,10 +191,10 @@ u8 GetBattlerYDelta(u8 battlerId, u16 species)
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY);
if (!spriteInfo[battler].transformSpecies)
personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PERSONALITY);
else
personality = gTransformedPersonalities[battlerId];
personality = gTransformedPersonalities[battler];
}
letter = GET_UNOWN_LETTER(personality);
if (!letter)
@ -205,7 +205,7 @@ u8 GetBattlerYDelta(u8 battlerId, u16 species)
}
else if (species == SPECIES_CASTFORM)
{
ret = sCastformBackSpriteYCoords[gBattleMonForms[battlerId]];
ret = sCastformBackSpriteYCoords[gBattleMonForms[battler]];
}
else if (species > NUM_SPECIES)
{
@ -221,10 +221,10 @@ u8 GetBattlerYDelta(u8 battlerId, u16 species)
if (species == SPECIES_UNOWN)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY);
if (!spriteInfo[battler].transformSpecies)
personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_PERSONALITY);
else
personality = gTransformedPersonalities[battlerId];
personality = gTransformedPersonalities[battler];
letter = GET_UNOWN_LETTER(personality);
if (!letter)
coordSpecies = species;
@ -234,7 +234,7 @@ u8 GetBattlerYDelta(u8 battlerId, u16 species)
}
else if (species == SPECIES_CASTFORM)
{
ret = gCastformFrontSpriteCoords[gBattleMonForms[battlerId]].y_offset;
ret = gCastformFrontSpriteCoords[gBattleMonForms[battler]].y_offset;
}
else if (species > NUM_SPECIES)
{
@ -248,15 +248,15 @@ u8 GetBattlerYDelta(u8 battlerId, u16 species)
return ret;
}
u8 GetBattlerElevation(u8 battlerId, u16 species)
u8 GetBattlerElevation(u8 battler, u16 species)
{
u8 ret = 0;
if (GetBattlerSide(battlerId) == B_SIDE_OPPONENT)
if (GetBattlerSide(battler) == B_SIDE_OPPONENT)
{
if (!IsContest())
{
if (species == SPECIES_CASTFORM)
ret = sCastformElevations[gBattleMonForms[battlerId]];
ret = sCastformElevations[gBattleMonForms[battler]];
else if (species > NUM_SPECIES)
ret = gEnemyMonElevation[0];
else
@ -266,24 +266,24 @@ u8 GetBattlerElevation(u8 battlerId, u16 species)
return ret;
}
u8 GetBattlerSpriteFinal_Y(u8 battlerId, u16 species, bool8 a3)
u8 GetBattlerSpriteFinal_Y(u8 battler, u16 species, bool8 a3)
{
u16 offset;
u8 y;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER || IsContest())
if (GetBattlerSide(battler) == B_SIDE_PLAYER || IsContest())
{
offset = GetBattlerYDelta(battlerId, species);
offset = GetBattlerYDelta(battler, species);
}
else
{
offset = GetBattlerYDelta(battlerId, species);
offset -= GetBattlerElevation(battlerId, species);
offset = GetBattlerYDelta(battler, species);
offset -= GetBattlerElevation(battler, species);
}
y = offset + sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].y;
y = offset + sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battler)].y;
if (a3)
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
y += 8;
if (y > DISPLAY_HEIGHT - MON_PIC_HEIGHT + 8)
y = DISPLAY_HEIGHT - MON_PIC_HEIGHT + 8;
@ -291,7 +291,7 @@ u8 GetBattlerSpriteFinal_Y(u8 battlerId, u16 species, bool8 a3)
return y;
}
u8 GetBattlerSpriteCoord2(u8 battlerId, u8 coordType)
u8 GetBattlerSpriteCoord2(u8 battler, u8 coordType)
{
u16 species;
struct BattleSpriteInfo *spriteInfo;
@ -308,64 +308,64 @@ u8 GetBattlerSpriteCoord2(u8 battlerId, u8 coordType)
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = gAnimBattlerSpecies[battlerId];
if (!spriteInfo[battler].transformSpecies)
species = gAnimBattlerSpecies[battler];
else
species = spriteInfo[battlerId].transformSpecies;
species = spriteInfo[battler].transformSpecies;
}
if (coordType == BATTLER_COORD_Y_PIC_OFFSET)
return GetBattlerSpriteFinal_Y(battlerId, species, TRUE);
return GetBattlerSpriteFinal_Y(battler, species, TRUE);
else
return GetBattlerSpriteFinal_Y(battlerId, species, FALSE);
return GetBattlerSpriteFinal_Y(battler, species, FALSE);
}
else
{
return GetBattlerSpriteCoord(battlerId, coordType);
return GetBattlerSpriteCoord(battler, coordType);
}
}
u8 GetBattlerSpriteDefault_Y(u8 battlerId)
u8 GetBattlerSpriteDefault_Y(u8 battler)
{
return GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y_PIC_OFFSET_DEFAULT);
return GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET_DEFAULT);
}
u8 GetSubstituteSpriteDefault_Y(u8 battlerId)
u8 GetSubstituteSpriteDefault_Y(u8 battler)
{
u16 y;
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 16;
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y) + 16;
else
y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 17;
y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y) + 17;
return y;
}
u8 GetBattlerYCoordWithElevation(u8 battlerId)
u8 GetBattlerYCoordWithElevation(u8 battler)
{
u16 species;
u8 y;
struct BattleSpriteInfo *spriteInfo;
y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y);
y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y);
if (!IsContest())
{
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
if (!spriteInfo[battler].transformSpecies)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
species = spriteInfo[battler].transformSpecies;
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
if (!spriteInfo[battler].transformSpecies)
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
species = spriteInfo[battler].transformSpecies;
}
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
y -= GetBattlerElevation(battlerId, species);
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
y -= GetBattlerElevation(battler, species);
}
return y;
}
@ -846,14 +846,14 @@ void InitSpritePosToAnimAttacker(struct Sprite *sprite, bool8 respectMonPicOffse
sprite->y += gBattleAnimArgs[1];
}
u8 GetBattlerSide(u8 battlerId)
u8 GetBattlerSide(u8 battler)
{
return GET_BATTLER_SIDE2(battlerId);
return GET_BATTLER_SIDE2(battler);
}
u8 GetBattlerPosition(u8 battlerId)
u8 GetBattlerPosition(u8 battler)
{
return gBattlerPositions[battlerId];
return gBattlerPositions[battler];
}
u8 GetBattlerAtPosition(u8 position)
@ -868,31 +868,31 @@ u8 GetBattlerAtPosition(u8 position)
return i;
}
bool8 IsBattlerSpritePresent(u8 battlerId)
bool8 IsBattlerSpritePresent(u8 battler)
{
if (IsContest())
{
if (gBattleAnimAttacker == battlerId)
if (gBattleAnimAttacker == battler)
return TRUE;
else if (gBattleAnimTarget == battlerId)
else if (gBattleAnimTarget == battler)
return TRUE;
else
return FALSE;
}
else
{
if (gBattlerPositions[battlerId] == 0xff)
if (gBattlerPositions[battler] == 0xff)
{
return FALSE;
}
else if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
else if (GetBattlerSide(battler) != B_SIDE_PLAYER)
{
if (GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_HP) != 0)
if (GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_HP) != 0)
return TRUE;
}
else
{
if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_HP) != 0)
if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_HP) != 0)
return TRUE;
}
}
@ -956,7 +956,7 @@ void GetBattleAnimBgData(struct BattleAnimBgData *out, u32 bgId)
}
}
void GetBgDataForTransform(struct BattleAnimBgData *out, u8 battlerId)
void GetBgDataForTransform(struct BattleAnimBgData *out, u8 battler)
{
out->bgTiles = gBattleAnimBgTileBuffer;
out->bgTilemap = (u16 *)gBattleAnimBgTilemapBuffer;
@ -1294,14 +1294,14 @@ static bool8 ShouldRotScaleSpeciesBeFlipped(void)
void PrepareBattlerSpriteForRotScale(u8 spriteId, u8 objMode)
{
u8 battlerId = gSprites[spriteId].data[0];
u8 battler = gSprites[spriteId].data[0];
if (IsContest() || IsBattlerSpriteVisible(battlerId))
if (IsContest() || IsBattlerSpriteVisible(battler))
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.matrixNum = gBattleSpritesDataPtr->healthBoxesData[battler].matrixNum;
gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_DOUBLE;
CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode);
}
@ -1591,7 +1591,7 @@ static void AnimThrowProjectile_Step(struct Sprite *sprite)
void AnimTravelDiagonally(struct Sprite *sprite)
{
bool8 respectMonPicOffsets;
u8 battlerId, coordType;
u8 battler, coordType;
if (!gBattleAnimArgs[6])
{
@ -1606,19 +1606,19 @@ void AnimTravelDiagonally(struct Sprite *sprite)
if (gBattleAnimArgs[5] == ANIM_ATTACKER)
{
InitSpritePosToAnimAttacker(sprite, respectMonPicOffsets);
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
}
else
{
InitSpritePosToAnimTarget(sprite, respectMonPicOffsets);
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
}
if (GetBattlerSide(gBattleAnimAttacker))
gBattleAnimArgs[2] = -gBattleAnimArgs[2];
InitSpritePosToAnimTarget(sprite, respectMonPicOffsets);
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->data[2] = GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2) + gBattleAnimArgs[2];
sprite->data[4] = GetBattlerSpriteCoord(battler, coordType) + gBattleAnimArgs[3];
sprite->callback = StartAnimLinearTranslation;
StoreSpriteCallbackInData6(sprite, DestroyAnimSprite);
}
@ -1897,7 +1897,7 @@ void SetBattlerSpriteYOffsetFromOtherYScale(u8 spriteId, u8 otherSpriteId)
static u16 GetBattlerYDeltaFromSpriteId(u8 spriteId)
{
struct BattleSpriteInfo *spriteInfo;
u8 battlerId = gSprites[spriteId].data[0];
u8 battler = gSprites[spriteId].data[0];
u16 species;
u16 i;
@ -1915,26 +1915,26 @@ static u16 GetBattlerYDeltaFromSpriteId(u8 spriteId)
if (GetBattlerSide(i) == B_SIDE_PLAYER)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
if (!spriteInfo[battler].transformSpecies)
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
species = spriteInfo[battler].transformSpecies;
if (species == SPECIES_CASTFORM)
return sCastformBackSpriteYCoords[gBattleMonForms[battlerId]];
return sCastformBackSpriteYCoords[gBattleMonForms[battler]];
else
return gMonBackPicCoords[species].y_offset;
}
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
if (!spriteInfo[battler].transformSpecies)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES);
else
species = spriteInfo[battlerId].transformSpecies;
species = spriteInfo[battler].transformSpecies;
if (species == SPECIES_CASTFORM)
return sCastformElevations[gBattleMonForms[battlerId]];
return sCastformElevations[gBattleMonForms[battler]];
else
return gMonFrontPicCoords[species].y_offset;
}
@ -2032,21 +2032,21 @@ void InitPrioritiesForVisibleBattlers(void)
}
}
u8 GetBattlerSpriteSubpriority(u8 battlerId)
u8 GetBattlerSpriteSubpriority(u8 battler)
{
u8 position;
u8 subpriority;
if (IsContest())
{
if (battlerId == 2)
if (battler == 2)
return 30;
else
return 40;
}
else
{
position = GetBattlerPosition(battlerId);
position = GetBattlerPosition(battler);
if (position == B_POSITION_PLAYER_LEFT)
subpriority = 30;
else if (position == B_POSITION_PLAYER_RIGHT)
@ -2060,9 +2060,9 @@ u8 GetBattlerSpriteSubpriority(u8 battlerId)
return subpriority;
}
u8 GetBattlerSpriteBGPriority(u8 battlerId)
u8 GetBattlerSpriteBGPriority(u8 battler)
{
u8 position = GetBattlerPosition(battlerId);
u8 position = GetBattlerPosition(battler);
if (IsContest())
return 2;
@ -2072,11 +2072,11 @@ u8 GetBattlerSpriteBGPriority(u8 battlerId)
return GetAnimBgAttribute(1, BG_ANIM_PRIORITY);
}
u8 GetBattlerSpriteBGPriorityRank(u8 battlerId)
u8 GetBattlerSpriteBGPriorityRank(u8 battler)
{
if (!IsContest())
{
u8 position = GetBattlerPosition(battlerId);
u8 position = GetBattlerPosition(battler);
if (position == B_POSITION_PLAYER_LEFT || position == B_POSITION_OPPONENT_RIGHT)
return 2;
else
@ -2086,7 +2086,7 @@ u8 GetBattlerSpriteBGPriorityRank(u8 battlerId)
}
// Create Pokémon 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 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16 x, s16 y, u8 subpriority, u32 personality, u32 trainerId, u32 battler, bool32 ignoreDeoxysForm)
{
u8 spriteId;
u16 sheet = LoadSpriteSheet(&sSpriteSheets_MoveEffectMons[id]);
@ -2097,7 +2097,7 @@ u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16
if (!isBackpic)
{
LoadCompressedPalette(GetMonSpritePalFromSpeciesAndPersonality(species, trainerId, personality), OBJ_PLTT_ID(palette), PLTT_SIZE_4BPP);
if (ignoreDeoxysForm == TRUE || ShouldIgnoreDeoxysForm(5, battlerId) == TRUE || gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != 0)
if (ignoreDeoxysForm == TRUE || ShouldIgnoreDeoxysForm(5, battler) == TRUE || gBattleSpritesDataPtr->battlerData[battler].transformSpecies != 0)
LoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species],
gMonSpritesGfxPtr->buffer,
species,
@ -2113,7 +2113,7 @@ u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16
else
{
LoadCompressedPalette(GetMonSpritePalFromSpeciesAndPersonality(species, trainerId, personality), OBJ_PLTT_ID(palette), PLTT_SIZE_4BPP);
if (ignoreDeoxysForm == TRUE || ShouldIgnoreDeoxysForm(5, battlerId) == TRUE || gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != 0)
if (ignoreDeoxysForm == TRUE || ShouldIgnoreDeoxysForm(5, battler) == TRUE || gBattleSpritesDataPtr->battlerData[battler].transformSpecies != 0)
LoadSpecialPokePic_DontHandleDeoxys(&gMonBackPicTable[species],
gMonSpritesGfxPtr->buffer,
species,
@ -2148,7 +2148,7 @@ void DestroySpriteAndFreeResources_(struct Sprite *sprite)
DestroySpriteAndFreeResources(sprite);
}
s16 GetBattlerSpriteCoordAttr(u8 battlerId, u8 attr)
s16 GetBattlerSpriteCoordAttr(u8 battler, u8 attr)
{
u16 species;
u32 personality;
@ -2181,7 +2181,7 @@ s16 GetBattlerSpriteCoordAttr(u8 battlerId, u8 attr)
}
else if (species == SPECIES_CASTFORM)
{
coords = &gCastformFrontSpriteCoords[gBattleMonForms[battlerId]];
coords = &gCastformFrontSpriteCoords[gBattleMonForms[battler]];
}
else if (species <= SPECIES_EGG)
{
@ -2194,18 +2194,18 @@ s16 GetBattlerSpriteCoordAttr(u8 battlerId, u8 attr)
}
else
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
if (!spriteInfo[battler].transformSpecies)
{
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY);
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PERSONALITY);
}
else
{
species = spriteInfo[battlerId].transformSpecies;
personality = gTransformedPersonalities[battlerId];
species = spriteInfo[battler].transformSpecies;
personality = gTransformedPersonalities[battler];
}
if (species == SPECIES_UNOWN)
@ -2229,15 +2229,15 @@ s16 GetBattlerSpriteCoordAttr(u8 battlerId, u8 attr)
else
{
spriteInfo = gBattleSpritesDataPtr->battlerData;
if (!spriteInfo[battlerId].transformSpecies)
if (!spriteInfo[battler].transformSpecies)
{
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY);
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_PERSONALITY);
}
else
{
species = spriteInfo[battlerId].transformSpecies;
personality = gTransformedPersonalities[battlerId];
species = spriteInfo[battler].transformSpecies;
personality = gTransformedPersonalities[battler];
}
if (species == SPECIES_UNOWN)
@ -2251,7 +2251,7 @@ s16 GetBattlerSpriteCoordAttr(u8 battlerId, u8 attr)
}
else if (species == SPECIES_CASTFORM)
{
coords = &gCastformFrontSpriteCoords[gBattleMonForms[battlerId]];
coords = &gCastformFrontSpriteCoords[gBattleMonForms[battler]];
}
else if (species > NUM_SPECIES)
{
@ -2271,22 +2271,22 @@ s16 GetBattlerSpriteCoordAttr(u8 battlerId, u8 attr)
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);
return GetBattlerSpriteCoord(battler, 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);
return GetBattlerSpriteCoord(battler, 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);
return GetBattlerSpriteCoord(battler, 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);
return GetBattlerSpriteCoord(battler, 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;
ret = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y) + 31;
return ret - coords->y_offset;
default:
return 0;
}
}
void SetAverageBattlerPositions(u8 battlerId, bool8 respectMonPicOffsets, s16 *x, s16 *y)
void SetAverageBattlerPositions(u8 battler, bool8 respectMonPicOffsets, s16 *x, s16 *y)
{
u8 xCoordType, yCoordType;
s16 battlerX, battlerY;
@ -2303,12 +2303,12 @@ void SetAverageBattlerPositions(u8 battlerId, bool8 respectMonPicOffsets, s16 *x
yCoordType = BATTLER_COORD_Y_PIC_OFFSET;
}
battlerX = GetBattlerSpriteCoord(battlerId, xCoordType);
battlerY = GetBattlerSpriteCoord(battlerId, yCoordType);
battlerX = GetBattlerSpriteCoord(battler, xCoordType);
battlerY = GetBattlerSpriteCoord(battler, yCoordType);
if (IsDoubleBattle() && !IsContest())
{
partnerX = GetBattlerSpriteCoord(BATTLE_PARTNER(battlerId), xCoordType);
partnerY = GetBattlerSpriteCoord(BATTLE_PARTNER(battlerId), yCoordType);
partnerX = GetBattlerSpriteCoord(BATTLE_PARTNER(battler), xCoordType);
partnerY = GetBattlerSpriteCoord(BATTLE_PARTNER(battler), yCoordType);
}
else
{
@ -2320,7 +2320,7 @@ void SetAverageBattlerPositions(u8 battlerId, bool8 respectMonPicOffsets, s16 *x
*y = (battlerY + partnerY) / 2;
}
u8 CreateInvisibleSpriteCopy(int battlerId, u8 spriteId, int species)
u8 CreateInvisibleSpriteCopy(int battler, u8 spriteId, int species)
{
u8 newSpriteId = CreateInvisibleSpriteWithCallback(SpriteCallbackDummy);
gSprites[newSpriteId] = gSprites[spriteId];

36
src/battle_anim_sound_tasks.c
View File

@ -144,29 +144,29 @@ void SoundTask_PlayCryHighPitch(u8 taskId)
}
else
{
u8 battlerId;
u8 battler;
// Get wanted battler.
if (gBattleAnimArgs[0] == ANIM_ATTACKER)
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
else if (gBattleAnimArgs[0] == ANIM_TARGET)
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
else if (gBattleAnimArgs[0] == ANIM_ATK_PARTNER)
battlerId = BATTLE_PARTNER(gBattleAnimAttacker);
battler = BATTLE_PARTNER(gBattleAnimAttacker);
else
battlerId = BATTLE_PARTNER(gBattleAnimTarget);
battler = BATTLE_PARTNER(gBattleAnimTarget);
// Check if battler is visible.
if ((gBattleAnimArgs[0] == ANIM_TARGET || gBattleAnimArgs[0] == ANIM_DEF_PARTNER) && !IsBattlerSpriteVisible(battlerId))
if ((gBattleAnimArgs[0] == ANIM_TARGET || gBattleAnimArgs[0] == ANIM_DEF_PARTNER) && !IsBattlerSpriteVisible(battler))
{
DestroyAnimVisualTask(taskId);
return;
}
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
else
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
}
if (species != SPECIES_NONE)
@ -192,29 +192,29 @@ void SoundTask_PlayDoubleCry(u8 taskId)
}
else
{
u8 battlerId;
u8 battler;
// Get wanted battler.
if (gBattleAnimArgs[0] == ANIM_ATTACKER)
battlerId = gBattleAnimAttacker;
battler = gBattleAnimAttacker;
else if (gBattleAnimArgs[0] == ANIM_TARGET)
battlerId = gBattleAnimTarget;
battler = gBattleAnimTarget;
else if (gBattleAnimArgs[0] == ANIM_ATK_PARTNER)
battlerId = BATTLE_PARTNER(gBattleAnimAttacker);
battler = BATTLE_PARTNER(gBattleAnimAttacker);
else
battlerId = BATTLE_PARTNER(gBattleAnimTarget);
battler = BATTLE_PARTNER(gBattleAnimTarget);
// Check if battler is visible.
if ((gBattleAnimArgs[0] == ANIM_TARGET || gBattleAnimArgs[0] == ANIM_DEF_PARTNER) && !IsBattlerSpriteVisible(battlerId))
if ((gBattleAnimArgs[0] == ANIM_TARGET || gBattleAnimArgs[0] == ANIM_DEF_PARTNER) && !IsBattlerSpriteVisible(battler))
{
DestroyAnimVisualTask(taskId);
return;
}
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
else
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
}
gTasks[taskId].data[0] = gBattleAnimArgs[1];

14
src/battle_anim_status_effects.c
View File

@ -270,16 +270,16 @@ static const struct SpriteTemplate sFlashingCircleImpactSpriteTemplate =
.callback = AnimFlashingCircleImpact,
};
static u8 UNUSED Task_FlashingCircleImpacts(u8 battlerId, bool8 red)
static u8 UNUSED Task_FlashingCircleImpacts(u8 battler, bool8 red)
{
u8 battlerSpriteId = gBattlerSpriteIds[battlerId];
u8 battlerSpriteId = gBattlerSpriteIds[battler];
u8 taskId = CreateTask(Task_UpdateFlashingCircleImpacts, 10);
u8 spriteId;
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;
gTasks[taskId].data[0] = battler;
if (red)
{
gTasks[taskId].data[1] = RGB_RED;
@ -540,15 +540,15 @@ void AnimTask_StatsChange(u8 taskId)
#undef CASE
void LaunchStatusAnimation(u8 battlerId, u8 statusAnimId)
void LaunchStatusAnimation(u8 battler, u8 statusAnimId)
{
u8 taskId;
gBattleAnimAttacker = battlerId;
gBattleAnimTarget = battlerId;
gBattleAnimAttacker = battler;
gBattleAnimTarget = battler;
LaunchBattleAnimation(gBattleAnims_StatusConditions, statusAnimId, FALSE);
taskId = CreateTask(Task_DoStatusAnimation, 10);
gTasks[taskId].data[0] = battlerId;
gTasks[taskId].data[0] = battler;
}
static void Task_DoStatusAnimation(u8 taskId)

50
src/battle_controller_link_opponent.c
View File

@ -92,7 +92,7 @@ static void LinkOpponentBufferExecCompleted(void);
static void SwitchIn_HandleSoundAndEnd(void);
static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst);
static void SetLinkOpponentMonData(u8 monId);
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit);
static void DoSwitchOutAnimation(void);
static void LinkOpponentDoMoveAnimation(void);
static void Task_StartSendOutAnim(u8 taskId);
@ -1141,36 +1141,36 @@ static void LinkOpponentHandleSwitchInAnim(void)
gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnim;
}
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit)
{
u16 species;
ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit);
gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battlerId]], battlerId);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
ClearTemporarySpeciesSpriteData(battler, dontClearSubstituteBit);
gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battler]], battler);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
gBattlerSpriteIds[battlerId] = CreateSprite(
gBattlerSpriteIds[battler] = CreateSprite(
&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battlerId),
GetBattlerSpriteSubpriority(battlerId));
GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battler),
GetBattlerSpriteSubpriority(battler));
gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
gSprites[gBattleControllerData[battlerId]].data[2] = battlerId;
gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
gSprites[gBattleControllerData[battler]].data[2] = battler;
gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
gSprites[gBattlerSpriteIds[battler]].data[2] = species;
gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_OPPONENT_SENDOUT);
gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_OPPONENT_SENDOUT);
}
static void LinkOpponentHandleReturnMonToBall(void)
@ -1321,7 +1321,7 @@ static void LinkOpponentHandleTrainerSlide(void)
gSprites[gBattlerSpriteIds[gActiveBattler]].oam.affineParam = trainerPicId;
gSprites[gBattlerSpriteIds[gActiveBattler]].callback = SpriteCB_TrainerSlideIn;
gBattlerControllerFuncs[gActiveBattler] = CompleteOnBankSpriteCallbackDummy2; // this line is redundant, because LinkOpponentBufferExecCompleted changes the battle battlerId function
gBattlerControllerFuncs[gActiveBattler] = CompleteOnBankSpriteCallbackDummy2; // this line is redundant, because LinkOpponentBufferExecCompleted changes the battle battler function
LinkOpponentBufferExecCompleted();
}
@ -1534,11 +1534,11 @@ static void LinkOpponentHandleStatusIconUpdate(void)
{
if (!IsBattleSEPlaying(gActiveBattler))
{
u8 battlerId;
u8 battler;
UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON);
battlerId = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = 0;
battler = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive = 0;
gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
}
}

46
src/battle_controller_link_partner.c
View File

@ -92,7 +92,7 @@ static void LinkPartnerBufferExecCompleted(void);
static void SwitchIn_WaitAndEnd(void);
static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst);
static void SetLinkPartnerMonData(u8 monId);
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit);
static void DoSwitchOutAnimation(void);
static void LinkPartnerDoMoveAnimation(void);
static void Task_StartSendOutAnim(u8 taskId);
@ -1036,35 +1036,35 @@ static void LinkPartnerHandleSwitchInAnim(void)
gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnim;
}
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit)
{
u16 species;
ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit);
gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
ClearTemporarySpeciesSpriteData(battler, dontClearSubstituteBit);
gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
gBattlerSpriteIds[battlerId] = CreateSprite(
gBattlerSpriteIds[battler] = CreateSprite(
&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battlerId),
GetBattlerSpriteSubpriority(battlerId));
GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battler),
GetBattlerSpriteSubpriority(battler));
gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
gSprites[gBattleControllerData[battlerId]].data[2] = battlerId;
gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
gSprites[gBattleControllerData[battler]].data[2] = battler;
gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
gSprites[gBattlerSpriteIds[battler]].data[2] = species;
gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
}
static void LinkPartnerHandleReturnMonToBall(void)
@ -1373,11 +1373,11 @@ static void LinkPartnerHandleStatusIconUpdate(void)
{
if (!IsBattleSEPlaying(gActiveBattler))
{
u8 battlerId;
u8 battler;
UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON);
battlerId = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = 0;
battler = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive = 0;
gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
}
}

48
src/battle_controller_opponent.c
View File

@ -97,7 +97,7 @@ static void OpponentBufferExecCompleted(void);
static void SwitchIn_HandleSoundAndEnd(void);
static u32 GetOpponentMonData(u8 monId, u8 *dst);
static void SetOpponentMonData(u8 monId);
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit);
static void DoSwitchOutAnimation(void);
static void OpponentDoMoveAnimation(void);
static void SpriteCB_FreeOpponentSprite(struct Sprite *sprite);
@ -1165,36 +1165,36 @@ static void OpponentHandleSwitchInAnim(void)
gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnim;
}
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit)
{
u16 species;
ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit);
gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battlerId]], battlerId);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
ClearTemporarySpeciesSpriteData(battler, dontClearSubstituteBit);
gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battler]], battler);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
gBattlerSpriteIds[battlerId] = CreateSprite(&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battlerId),
GetBattlerSpriteSubpriority(battlerId));
gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battler),
GetBattlerSpriteSubpriority(battler));
gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
gSprites[gBattlerSpriteIds[battler]].data[2] = species;
gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
gSprites[gBattleControllerData[battlerId]].data[2] = battlerId;
gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
gSprites[gBattleControllerData[battler]].data[2] = battler;
gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_OPPONENT_SENDOUT);
gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_OPPONENT_SENDOUT);
}
static void OpponentHandleReturnMonToBall(void)
@ -1713,11 +1713,11 @@ static void OpponentHandleStatusIconUpdate(void)
{
if (!IsBattleSEPlaying(gActiveBattler))
{
u8 battlerId;
u8 battler;
UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON);
battlerId = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = 0;
battler = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive = 0;
gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
}
}

98
src/battle_controller_player.c
View File

@ -1154,10 +1154,10 @@ static void CompleteOnInactiveTextPrinter(void)
static void Task_GiveExpToMon(u8 taskId)
{
u32 monId = (u8)(gTasks[taskId].tExpTask_monId);
u8 battlerId = gTasks[taskId].tExpTask_battler;
u8 battler = gTasks[taskId].tExpTask_battler;
s16 gainedExp = gTasks[taskId].tExpTask_gainedExp;
if (IsDoubleBattle() == TRUE || monId != gBattlerPartyIndexes[battlerId]) // Give exp without moving the expbar.
if (IsDoubleBattle() == TRUE || monId != gBattlerPartyIndexes[battler]) // Give exp without moving the expbar.
{
struct Pokemon *mon = &gPlayerParty[monId];
u16 species = GetMonData(mon, MON_DATA_SPECIES);
@ -1173,12 +1173,12 @@ static void Task_GiveExpToMon(u8 taskId)
CalculateMonStats(mon);
gainedExp -= nextLvlExp - currExp;
savedActiveBattler = gActiveBattler;
gActiveBattler = battlerId;
gActiveBattler = battler;
BtlController_EmitTwoReturnValues(B_COMM_TO_ENGINE, RET_VALUE_LEVELED_UP, gainedExp);
gActiveBattler = savedActiveBattler;
if (IsDoubleBattle() == TRUE
&& ((u16)(monId) == gBattlerPartyIndexes[battlerId] || (u16)(monId) == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)]))
&& ((u16)(monId) == gBattlerPartyIndexes[battler] || (u16)(monId) == gBattlerPartyIndexes[BATTLE_PARTNER(battler)]))
gTasks[taskId].func = Task_LaunchLvlUpAnim;
else
gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter;
@ -1187,7 +1187,7 @@ static void Task_GiveExpToMon(u8 taskId)
{
currExp += gainedExp;
SetMonData(mon, MON_DATA_EXP, &currExp);
gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter;
gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter;
DestroyTask(taskId);
}
}
@ -1201,7 +1201,7 @@ static void Task_PrepareToGiveExpWithExpBar(u8 taskId)
{
u8 monIndex = gTasks[taskId].tExpTask_monId;
s32 gainedExp = gTasks[taskId].tExpTask_gainedExp;
u8 battlerId = gTasks[taskId].tExpTask_battler;
u8 battler = gTasks[taskId].tExpTask_battler;
struct Pokemon *mon = &gPlayerParty[monIndex];
u8 level = GetMonData(mon, MON_DATA_LEVEL);
u16 species = GetMonData(mon, MON_DATA_SPECIES);
@ -1211,7 +1211,7 @@ static void Task_PrepareToGiveExpWithExpBar(u8 taskId)
exp -= currLvlExp;
expToNextLvl = gExperienceTables[gSpeciesInfo[species].growthRate][level + 1] - currLvlExp;
SetBattleBarStruct(battlerId, gHealthboxSpriteIds[battlerId], expToNextLvl, exp, -gainedExp);
SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], expToNextLvl, exp, -gainedExp);
PlaySE(SE_EXP);
gTasks[taskId].func = Task_GiveExpWithExpBar;
}
@ -1226,11 +1226,11 @@ static void Task_GiveExpWithExpBar(u8 taskId)
{
u8 monId = gTasks[taskId].tExpTask_monId;
s16 gainedExp = gTasks[taskId].tExpTask_gainedExp;
u8 battlerId = gTasks[taskId].tExpTask_battler;
u8 battler = gTasks[taskId].tExpTask_battler;
s16 newExpPoints;
newExpPoints = MoveBattleBar(battlerId, gHealthboxSpriteIds[battlerId], EXP_BAR, 0);
SetHealthboxSpriteVisible(gHealthboxSpriteIds[battlerId]);
newExpPoints = MoveBattleBar(battler, gHealthboxSpriteIds[battler], EXP_BAR, 0);
SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]);
if (newExpPoints == -1) // The bar has been filled with given exp points.
{
u8 level;
@ -1252,7 +1252,7 @@ static void Task_GiveExpWithExpBar(u8 taskId)
CalculateMonStats(&gPlayerParty[monId]);
gainedExp -= expOnNextLvl - currExp;
savedActiveBattler = gActiveBattler;
gActiveBattler = battlerId;
gActiveBattler = battler;
BtlController_EmitTwoReturnValues(B_COMM_TO_ENGINE, RET_VALUE_LEVELED_UP, gainedExp);
gActiveBattler = savedActiveBattler;
gTasks[taskId].func = Task_LaunchLvlUpAnim;
@ -1261,7 +1261,7 @@ static void Task_GiveExpWithExpBar(u8 taskId)
{
currExp += gainedExp;
SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &currExp);
gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter;
gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter;
DestroyTask(taskId);
}
}
@ -1270,30 +1270,30 @@ static void Task_GiveExpWithExpBar(u8 taskId)
static void Task_LaunchLvlUpAnim(u8 taskId)
{
u8 battlerId = gTasks[taskId].tExpTask_battler;
u8 battler = gTasks[taskId].tExpTask_battler;
u8 monIndex = gTasks[taskId].tExpTask_monId;
if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)])
battlerId ^= BIT_FLANK;
if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battler)])
battler ^= BIT_FLANK;
InitAndLaunchSpecialAnimation(battlerId, battlerId, battlerId, B_ANIM_LVL_UP);
InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_LVL_UP);
gTasks[taskId].func = Task_UpdateLvlInHealthbox;
}
static void Task_UpdateLvlInHealthbox(u8 taskId)
{
u8 battlerId = gTasks[taskId].tExpTask_battler;
u8 battler = gTasks[taskId].tExpTask_battler;
if (!gBattleSpritesDataPtr->healthBoxesData[battlerId].specialAnimActive)
if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive)
{
u8 monIndex = gTasks[taskId].tExpTask_monId;
GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value.
if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)])
UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battlerId)], &gPlayerParty[monIndex], HEALTHBOX_ALL);
if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battler)])
UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gPlayerParty[monIndex], HEALTHBOX_ALL);
else
UpdateHealthboxAttribute(gHealthboxSpriteIds[battlerId], &gPlayerParty[monIndex], HEALTHBOX_ALL);
UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[monIndex], HEALTHBOX_ALL);
gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter;
}
@ -1302,12 +1302,12 @@ static void Task_UpdateLvlInHealthbox(u8 taskId)
static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId)
{
u8 monIndex;
u8 battlerId;
u8 battler;
monIndex = gTasks[taskId].tExpTask_monId;
GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value.
battlerId = gTasks[taskId].tExpTask_battler;
gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter;
battler = gTasks[taskId].tExpTask_battler;
gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter;
DestroyTask(taskId);
}
@ -2193,35 +2193,35 @@ static void PlayerHandleSwitchInAnim(void)
gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnimShowHealthbox;
}
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit)
{
u16 species;
ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit);
gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
ClearTemporarySpeciesSpriteData(battler, dontClearSubstituteBit);
gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
gBattlerSpriteIds[battlerId] = CreateSprite(
gBattlerSpriteIds[battler] = CreateSprite(
&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battlerId),
GetBattlerSpriteSubpriority(battlerId));
GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battler),
GetBattlerSpriteSubpriority(battler));
gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
gSprites[gBattleControllerData[battlerId]].data[2] = battlerId;
gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
gSprites[gBattleControllerData[battler]].data[2] = battler;
gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
gSprites[gBattlerSpriteIds[battler]].data[2] = species;
gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
}
static void PlayerHandleReturnMonToBall(void)
@ -2756,11 +2756,11 @@ static void PlayerHandleStatusIconUpdate(void)
{
if (!IsBattleSEPlaying(gActiveBattler))
{
u8 battlerId;
u8 battler;
UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON);
battlerId = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = 0;
battler = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive = 0;
gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
}
}
@ -2975,7 +2975,7 @@ static void PlayerHandleIntroTrainerBallThrow(void)
void SpriteCB_FreePlayerSpriteLoadMonSprite(struct Sprite *sprite)
{
u8 battlerId = sprite->sBattlerId;
u8 battler = sprite->sBattlerId;
// Free player trainer sprite
FreeSpriteOamMatrix(sprite);
@ -2983,8 +2983,8 @@ void SpriteCB_FreePlayerSpriteLoadMonSprite(struct Sprite *sprite)
DestroySprite(sprite);
// Load mon sprite
BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battlerId]], battlerId);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], 0);
BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 0);
}
#undef sBattlerId

94
src/battle_controller_player_partner.c
View File

@ -95,7 +95,7 @@ static void Task_UpdateLvlInHealthbox(u8 taskId);
static void SwitchIn_WaitAndEnd(void);
static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst);
static void SetPlayerPartnerMonData(u8 monId);
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit);
static void DoSwitchOutAnimation(void);
static void PlayerPartnerDoMoveAnimation(void);
static void Task_StartSendOutAnim(u8 taskId);
@ -312,10 +312,10 @@ static void CompleteOnInactiveTextPrinter(void)
static void Task_GiveExpToMon(u8 taskId)
{
u32 monId = (u8)(gTasks[taskId].tExpTask_monId);
u8 battlerId = gTasks[taskId].tExpTask_bank;
u8 battler = gTasks[taskId].tExpTask_bank;
s16 gainedExp = gTasks[taskId].tExpTask_gainedExp;
if (IsDoubleBattle() == TRUE || monId != gBattlerPartyIndexes[battlerId]) // give exp without the expbar
if (IsDoubleBattle() == TRUE || monId != gBattlerPartyIndexes[battler]) // give exp without the expbar
{
struct Pokemon *mon = &gPlayerParty[monId];
u16 species = GetMonData(mon, MON_DATA_SPECIES);
@ -331,12 +331,12 @@ static void Task_GiveExpToMon(u8 taskId)
CalculateMonStats(mon);
gainedExp -= nextLvlExp - currExp;
savedActiveBank = gActiveBattler;
gActiveBattler = battlerId;
gActiveBattler = battler;
BtlController_EmitTwoReturnValues(B_COMM_TO_ENGINE, RET_VALUE_LEVELED_UP, gainedExp);
gActiveBattler = savedActiveBank;
if (IsDoubleBattle() == TRUE
&& ((u16)(monId) == gBattlerPartyIndexes[battlerId] || (u16)(monId) == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)]))
&& ((u16)(monId) == gBattlerPartyIndexes[battler] || (u16)(monId) == gBattlerPartyIndexes[BATTLE_PARTNER(battler)]))
gTasks[taskId].func = Task_LaunchLvlUpAnim;
else
gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter;
@ -345,7 +345,7 @@ static void Task_GiveExpToMon(u8 taskId)
{
currExp += gainedExp;
SetMonData(mon, MON_DATA_EXP, &currExp);
gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter;
gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter;
DestroyTask(taskId);
}
}
@ -359,7 +359,7 @@ static void Task_PrepareToGiveExpWithExpBar(u8 taskId)
{
u8 monIndex = gTasks[taskId].tExpTask_monId;
s32 gainedExp = gTasks[taskId].tExpTask_gainedExp;
u8 battlerId = gTasks[taskId].tExpTask_bank;
u8 battler = gTasks[taskId].tExpTask_bank;
struct Pokemon *mon = &gPlayerParty[monIndex];
u8 level = GetMonData(mon, MON_DATA_LEVEL);
u16 species = GetMonData(mon, MON_DATA_SPECIES);
@ -369,7 +369,7 @@ static void Task_PrepareToGiveExpWithExpBar(u8 taskId)
exp -= currLvlExp;
expToNextLvl = gExperienceTables[gSpeciesInfo[species].growthRate][level + 1] - currLvlExp;
SetBattleBarStruct(battlerId, gHealthboxSpriteIds[battlerId], expToNextLvl, exp, -gainedExp);
SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], expToNextLvl, exp, -gainedExp);
PlaySE(SE_EXP);
gTasks[taskId].func = Task_GiveExpWithExpBar;
}
@ -384,11 +384,11 @@ static void Task_GiveExpWithExpBar(u8 taskId)
{
u8 monId = gTasks[taskId].tExpTask_monId;
s16 gainedExp = gTasks[taskId].tExpTask_gainedExp;
u8 battlerId = gTasks[taskId].tExpTask_bank;
u8 battler = gTasks[taskId].tExpTask_bank;
s16 r4;
r4 = MoveBattleBar(battlerId, gHealthboxSpriteIds[battlerId], EXP_BAR, 0);
SetHealthboxSpriteVisible(gHealthboxSpriteIds[battlerId]);
r4 = MoveBattleBar(battler, gHealthboxSpriteIds[battler], EXP_BAR, 0);
SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]);
if (r4 == -1)
{
u8 level;
@ -410,7 +410,7 @@ static void Task_GiveExpWithExpBar(u8 taskId)
CalculateMonStats(&gPlayerParty[monId]);
gainedExp -= expOnNextLvl - currExp;
savedActiveBank = gActiveBattler;
gActiveBattler = battlerId;
gActiveBattler = battler;
BtlController_EmitTwoReturnValues(B_COMM_TO_ENGINE, RET_VALUE_LEVELED_UP, gainedExp);
gActiveBattler = savedActiveBank;
gTasks[taskId].func = Task_LaunchLvlUpAnim;
@ -419,7 +419,7 @@ static void Task_GiveExpWithExpBar(u8 taskId)
{
currExp += gainedExp;
SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &currExp);
gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter;
gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter;
DestroyTask(taskId);
}
}
@ -428,30 +428,30 @@ static void Task_GiveExpWithExpBar(u8 taskId)
static void Task_LaunchLvlUpAnim(u8 taskId)
{
u8 battlerId = gTasks[taskId].tExpTask_bank;
u8 battler = gTasks[taskId].tExpTask_bank;
u8 monIndex = gTasks[taskId].tExpTask_monId;
if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)])
battlerId ^= BIT_FLANK;
if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battler)])
battler ^= BIT_FLANK;
InitAndLaunchSpecialAnimation(battlerId, battlerId, battlerId, B_ANIM_LVL_UP);
InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_LVL_UP);
gTasks[taskId].func = Task_UpdateLvlInHealthbox;
}
static void Task_UpdateLvlInHealthbox(u8 taskId)
{
u8 battlerId = gTasks[taskId].tExpTask_bank;
u8 battler = gTasks[taskId].tExpTask_bank;
if (!gBattleSpritesDataPtr->healthBoxesData[battlerId].specialAnimActive)
if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive)
{
u8 monIndex = gTasks[taskId].tExpTask_monId;
GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value
if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)])
UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battlerId)], &gPlayerParty[monIndex], HEALTHBOX_ALL);
if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battler)])
UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gPlayerParty[monIndex], HEALTHBOX_ALL);
else
UpdateHealthboxAttribute(gHealthboxSpriteIds[battlerId], &gPlayerParty[monIndex], HEALTHBOX_ALL);
UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[monIndex], HEALTHBOX_ALL);
gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter;
}
@ -460,12 +460,12 @@ static void Task_UpdateLvlInHealthbox(u8 taskId)
static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId)
{
u8 monIndex;
u8 battlerId;
u8 battler;
monIndex = gTasks[taskId].tExpTask_monId;
GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value
battlerId = gTasks[taskId].tExpTask_bank;
gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter;
battler = gTasks[taskId].tExpTask_bank;
gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter;
DestroyTask(taskId);
}
@ -1220,35 +1220,35 @@ static void PlayerPartnerHandleSwitchInAnim(void)
gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnim;
}
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit)
{
u16 species;
ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit);
gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
ClearTemporarySpeciesSpriteData(battler, dontClearSubstituteBit);
gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
gBattlerSpriteIds[battlerId] = CreateSprite(
gBattlerSpriteIds[battler] = CreateSprite(
&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battlerId),
GetBattlerSpriteSubpriority(battlerId));
GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battler),
GetBattlerSpriteSubpriority(battler));
gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
gSprites[gBattleControllerData[battlerId]].data[2] = battlerId;
gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
gSprites[gBattleControllerData[battler]].data[2] = battler;
gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
gSprites[gBattlerSpriteIds[battler]].data[2] = species;
gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
}
static void PlayerPartnerHandleReturnMonToBall(void)
@ -1623,11 +1623,11 @@ static void PlayerPartnerHandleStatusIconUpdate(void)
{
if (!IsBattleSEPlaying(gActiveBattler))
{
u8 battlerId;
u8 battler;
UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON);
battlerId = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = 0;
battler = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive = 0;
gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
}
}

48
src/battle_controller_recorded_opponent.c
View File

@ -92,7 +92,7 @@ static void RecordedOpponentBufferExecCompleted(void);
static void SwitchIn_HandleSoundAndEnd(void);
static u32 CopyRecordedOpponentMonData(u8 monId, u8 *dst);
static void SetRecordedOpponentMonData(u8 monId);
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit);
static void DoSwitchOutAnimation(void);
static void RecordedOpponentDoMoveAnimation(void);
static void Task_StartSendOutAnim(u8 taskId);
@ -1127,35 +1127,35 @@ static void RecordedOpponentHandleSwitchInAnim(void)
gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnim;
}
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit)
{
u16 species;
ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit);
gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battlerId]], battlerId);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
ClearTemporarySpeciesSpriteData(battler, dontClearSubstituteBit);
gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battler]], battler);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
gBattlerSpriteIds[battlerId] = CreateSprite(&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battlerId),
GetBattlerSpriteSubpriority(battlerId));
gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battler),
GetBattlerSpriteSubpriority(battler));
gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
gSprites[gBattleControllerData[battlerId]].data[2] = battlerId;
gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
gSprites[gBattleControllerData[battler]].data[2] = battler;
gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
gSprites[gBattlerSpriteIds[battler]].data[2] = species;
gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_OPPONENT_SENDOUT);
gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_OPPONENT_SENDOUT);
}
static void RecordedOpponentHandleReturnMonToBall(void)
@ -1477,11 +1477,11 @@ static void RecordedOpponentHandleStatusIconUpdate(void)
{
if (!IsBattleSEPlaying(gActiveBattler))
{
u8 battlerId;
u8 battler;
UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON);
battlerId = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = 0;
battler = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive = 0;
gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
}
}

46
src/battle_controller_recorded_player.c
View File

@ -88,7 +88,7 @@ static void RecordedPlayerBufferExecCompleted(void);
static void SwitchIn_WaitAndEnd(void);
static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst);
static void SetRecordedPlayerMonData(u8 monId);
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit);
static void DoSwitchOutAnimation(void);
static void RecordedPlayerDoMoveAnimation(void);
static void Task_StartSendOutAnim(u8 taskId);
@ -1111,35 +1111,35 @@ static void RecordedPlayerHandleSwitchInAnim(void)
gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnim;
}
static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
static void StartSendOutAnim(u8 battler, bool8 dontClearSubstituteBit)
{
u16 species;
ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit);
gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
ClearTemporarySpeciesSpriteData(battler, dontClearSubstituteBit);
gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
gBattlerSpriteIds[battlerId] = CreateSprite(
gBattlerSpriteIds[battler] = CreateSprite(
&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battlerId),
GetBattlerSpriteSubpriority(battlerId));
GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battler),
GetBattlerSpriteSubpriority(battler));
gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
gSprites[gBattleControllerData[battlerId]].data[2] = battlerId;
gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
gSprites[gBattleControllerData[battler]].data[2] = battler;
gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
gSprites[gBattlerSpriteIds[battler]].data[2] = species;
gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
}
static void RecordedPlayerHandleReturnMonToBall(void)
@ -1504,11 +1504,11 @@ static void RecordedPlayerHandleStatusIconUpdate(void)
{
if (!IsBattleSEPlaying(gActiveBattler))
{
u8 battlerId;
u8 battler;
UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON);
battlerId = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = 0;
battler = gActiveBattler;
gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive = 0;
gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
}
}

38
src/battle_controller_wally.c
View File

@ -1458,31 +1458,31 @@ static void WallyHandleIntroTrainerBallThrow(void)
gBattlerControllerFuncs[gActiveBattler] = BattleControllerDummy;
}
static void StartSendOutAnim(u8 battlerId)
static void StartSendOutAnim(u8 battler)
{
u16 species;
gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies = 0;
gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
gBattlerSpriteIds[battlerId] = CreateSprite(&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battlerId),
GetBattlerSpriteSubpriority(battlerId));
gBattleSpritesDataPtr->battlerData[battler].transformSpecies = 0;
gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate,
GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
GetBattlerSpriteDefault_Y(battler),
GetBattlerSpriteSubpriority(battler));
gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
gSprites[gBattleControllerData[battlerId]].data[2] = battlerId;
gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
gSprites[gBattleControllerData[battler]].data[2] = battler;
gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
gSprites[gBattlerSpriteIds[battler]].data[2] = species;
gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
}
static void Task_StartSendOutAnim(u8 taskId)

26
src/battle_controllers.c
View File

@ -736,10 +736,10 @@ void PrepareBufferDataTransferLink(u8 bufferId, u16 size, u8 *data)
gTasks[sLinkSendTaskId].tCurrentBlock_WrapFrom = gTasks[sLinkSendTaskId].tCurrentBlock_End;
gTasks[sLinkSendTaskId].tCurrentBlock_End = 0;
}
#define BYTE_TO_SEND(offset) \
gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].tCurrentBlock_End + offset]
BYTE_TO_SEND(LINK_BUFF_BUFFER_ID) = bufferId;
BYTE_TO_SEND(LINK_BUFF_ACTIVE_BATTLER) = gActiveBattler;
BYTE_TO_SEND(LINK_BUFF_ATTACKER) = gBattlerAttacker;
@ -770,7 +770,7 @@ static void Task_HandleSendLinkBuffersData(u8 taskId)
{
u16 numPlayers;
u16 blockSize;
#define BYTE_TO_SEND(offset) \
gLinkBattleSendBuffer[gTasks[taskId].tCurrentBlock_Start + offset]
@ -850,7 +850,7 @@ static void Task_HandleSendLinkBuffersData(u8 taskId)
}
break;
}
#undef BYTE_TO_SEND
}
@ -903,9 +903,9 @@ void TryReceiveLinkBattleData(void)
static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
{
u16 blockSize;
u8 battlerId;
u8 battler;
u8 playerId;
#define BYTE_TO_RECEIVE(offset) \
gLinkBattleRecvBuffer[gTasks[taskId].tCurrentBlock_Start + offset]
@ -917,17 +917,17 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
gTasks[taskId].tCurrentBlock_WrapFrom = 0;
gTasks[taskId].tCurrentBlock_Start = 0;
}
battlerId = BYTE_TO_RECEIVE(LINK_BUFF_ACTIVE_BATTLER);
battler = BYTE_TO_RECEIVE(LINK_BUFF_ACTIVE_BATTLER);
blockSize = BYTE_TO_RECEIVE(LINK_BUFF_SIZE_LO) | (BYTE_TO_RECEIVE(LINK_BUFF_SIZE_HI) << 8);
switch (BYTE_TO_RECEIVE(0))
{
case B_COMM_TO_CONTROLLER:
if (IS_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battlerId))
if (IS_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battler))
return;
memcpy(gBattleBufferA[battlerId], &BYTE_TO_RECEIVE(LINK_BUFF_DATA), blockSize);
MarkBattlerReceivedLinkData(battlerId);
memcpy(gBattleBufferA[battler], &BYTE_TO_RECEIVE(LINK_BUFF_DATA), blockSize);
MarkBattlerReceivedLinkData(battler);
if (!(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER))
{
@ -938,17 +938,17 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
}
break;
case B_COMM_TO_ENGINE:
memcpy(gBattleBufferB[battlerId], &gLinkBattleRecvBuffer[gTasks[taskId].tCurrentBlock_Start + LINK_BUFF_DATA], blockSize);
memcpy(gBattleBufferB[battler], &gLinkBattleRecvBuffer[gTasks[taskId].tCurrentBlock_Start + LINK_BUFF_DATA], blockSize);
break;
case B_COMM_CONTROLLER_IS_DONE:
playerId = BYTE_TO_RECEIVE(LINK_BUFF_DATA);
MARK_BATTLE_CONTROLLER_IDLE_FOR_PLAYER(battlerId, playerId);
MARK_BATTLE_CONTROLLER_IDLE_FOR_PLAYER(battler, playerId);
break;
}
gTasks[taskId].tCurrentBlock_Start = gTasks[taskId].tCurrentBlock_Start + blockSize + LINK_BUFF_DATA;
}
#undef BYTE_TO_RECEIVE
}

216
src/battle_gfx_sfx_util.c
View File

@ -551,13 +551,13 @@ bool8 IsMoveWithoutAnimation(u16 moveId, u8 animationTurn)
}
// Check if SE has finished or 30 calls, whichever comes first
bool8 IsBattleSEPlaying(u8 battlerId)
bool8 IsBattleSEPlaying(u8 battler)
{
u8 zero = 0;
if (IsSEPlaying())
{
gBattleSpritesDataPtr->healthBoxesData[battlerId].soundTimer++;
gBattleSpritesDataPtr->healthBoxesData[battler].soundTimer++;
if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].soundTimer < 30)
return TRUE;
@ -566,7 +566,7 @@ bool8 IsBattleSEPlaying(u8 battlerId)
}
if (zero == 0)
{
gBattleSpritesDataPtr->healthBoxesData[battlerId].soundTimer = 0;
gBattleSpritesDataPtr->healthBoxesData[battler].soundTimer = 0;
return FALSE;
}
@ -574,7 +574,7 @@ bool8 IsBattleSEPlaying(u8 battlerId)
return TRUE;
}
void BattleLoadOpponentMonSpriteGfx(struct Pokemon *mon, u8 battlerId)
void BattleLoadOpponentMonSpriteGfx(struct Pokemon *mon, u8 battler)
{
u32 monsPersonality, currentPersonality, otId;
u16 species;
@ -584,50 +584,50 @@ void BattleLoadOpponentMonSpriteGfx(struct Pokemon *mon, u8 battlerId)
monsPersonality = GetMonData(mon, MON_DATA_PERSONALITY);
if (gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies == SPECIES_NONE)
if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies == SPECIES_NONE)
{
species = GetMonData(mon, MON_DATA_SPECIES);
currentPersonality = monsPersonality;
}
else
{
species = gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies;
currentPersonality = gTransformedPersonalities[battlerId];
species = gBattleSpritesDataPtr->battlerData[battler].transformSpecies;
currentPersonality = gTransformedPersonalities[battler];
}
otId = GetMonData(mon, MON_DATA_OT_ID);
position = GetBattlerPosition(battlerId);
position = GetBattlerPosition(battler);
HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species],
gMonSpritesGfxPtr->sprites.ptr[position],
species, currentPersonality);
paletteOffset = OBJ_PLTT_ID(battlerId);
paletteOffset = OBJ_PLTT_ID(battler);
if (gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies == SPECIES_NONE)
if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies == SPECIES_NONE)
lzPaletteData = GetMonFrontSpritePal(mon);
else
lzPaletteData = GetMonSpritePalFromSpeciesAndPersonality(species, otId, monsPersonality);
LZDecompressWram(lzPaletteData, gDecompressionBuffer);
LoadPalette(gDecompressionBuffer, paletteOffset, PLTT_SIZE_4BPP);
LoadPalette(gDecompressionBuffer, BG_PLTT_ID(8) + BG_PLTT_ID(battlerId), PLTT_SIZE_4BPP);
LoadPalette(gDecompressionBuffer, BG_PLTT_ID(8) + BG_PLTT_ID(battler), PLTT_SIZE_4BPP);
if (species == SPECIES_CASTFORM)
{
paletteOffset = OBJ_PLTT_ID(battlerId);
paletteOffset = OBJ_PLTT_ID(battler);
LZDecompressWram(lzPaletteData, gBattleStruct->castformPalette);
LoadPalette(gBattleStruct->castformPalette[gBattleMonForms[battlerId]], paletteOffset, PLTT_SIZE_4BPP);
LoadPalette(gBattleStruct->castformPalette[gBattleMonForms[battler]], paletteOffset, PLTT_SIZE_4BPP);
}
// transform's white color
if (gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != SPECIES_NONE)
if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies != SPECIES_NONE)
{
BlendPalette(paletteOffset, 16, 6, RGB_WHITE);
CpuCopy32(&gPlttBufferFaded[paletteOffset], &gPlttBufferUnfaded[paletteOffset], PLTT_SIZEOF(16));
}
}
void BattleLoadPlayerMonSpriteGfx(struct Pokemon *mon, u8 battlerId)
void BattleLoadPlayerMonSpriteGfx(struct Pokemon *mon, u8 battler)
{
u32 monsPersonality, currentPersonality, otId;
u16 species;
@ -637,21 +637,21 @@ void BattleLoadPlayerMonSpriteGfx(struct Pokemon *mon, u8 battlerId)
monsPersonality = GetMonData(mon, MON_DATA_PERSONALITY);
if (gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies == SPECIES_NONE)
if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies == SPECIES_NONE)
{
species = GetMonData(mon, MON_DATA_SPECIES);
currentPersonality = monsPersonality;
}
else
{
species = gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies;
currentPersonality = gTransformedPersonalities[battlerId];
species = gBattleSpritesDataPtr->battlerData[battler].transformSpecies;
currentPersonality = gTransformedPersonalities[battler];
}
otId = GetMonData(mon, MON_DATA_OT_ID);
position = GetBattlerPosition(battlerId);
position = GetBattlerPosition(battler);
if (ShouldIgnoreDeoxysForm(1, battlerId) == TRUE || gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != SPECIES_NONE)
if (ShouldIgnoreDeoxysForm(1, battler) == TRUE || gBattleSpritesDataPtr->battlerData[battler].transformSpecies != SPECIES_NONE)
{
HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonBackPicTable[species],
gMonSpritesGfxPtr->sprites.ptr[position],
@ -664,26 +664,26 @@ void BattleLoadPlayerMonSpriteGfx(struct Pokemon *mon, u8 battlerId)
species, currentPersonality);
}
paletteOffset = OBJ_PLTT_ID(battlerId);
paletteOffset = OBJ_PLTT_ID(battler);
if (gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies == SPECIES_NONE)
if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies == SPECIES_NONE)
lzPaletteData = GetMonFrontSpritePal(mon);
else
lzPaletteData = GetMonSpritePalFromSpeciesAndPersonality(species, otId, monsPersonality);
LZDecompressWram(lzPaletteData, gDecompressionBuffer);
LoadPalette(gDecompressionBuffer, paletteOffset, PLTT_SIZE_4BPP);
LoadPalette(gDecompressionBuffer, BG_PLTT_ID(8) + BG_PLTT_ID(battlerId), PLTT_SIZE_4BPP);
LoadPalette(gDecompressionBuffer, BG_PLTT_ID(8) + BG_PLTT_ID(battler), PLTT_SIZE_4BPP);
if (species == SPECIES_CASTFORM)
{
paletteOffset = OBJ_PLTT_ID(battlerId);
paletteOffset = OBJ_PLTT_ID(battler);
LZDecompressWram(lzPaletteData, gBattleStruct->castformPalette);
LoadPalette(gBattleStruct->castformPalette[gBattleMonForms[battlerId]], paletteOffset, PLTT_SIZE_4BPP);
LoadPalette(gBattleStruct->castformPalette[gBattleMonForms[battler]], paletteOffset, PLTT_SIZE_4BPP);
}
// transform's pink color
if (gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != SPECIES_NONE)
if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies != SPECIES_NONE)
{
BlendPalette(paletteOffset, 16, 6, RGB_WHITE);
CpuCopy32(&gPlttBufferFaded[paletteOffset], &gPlttBufferUnfaded[paletteOffset], PLTT_SIZEOF(16));
@ -698,23 +698,23 @@ void BattleGfxSfxDummy2(u16 species)
{
}
void DecompressTrainerFrontPic(u16 frontPicId, u8 battlerId)
void DecompressTrainerFrontPic(u16 frontPicId, u8 battler)
{
u8 position = GetBattlerPosition(battlerId);
u8 position = GetBattlerPosition(battler);
DecompressPicFromTable_2(&gTrainerFrontPicTable[frontPicId],
gMonSpritesGfxPtr->sprites.ptr[position],
SPECIES_NONE);
LoadCompressedSpritePalette(&gTrainerFrontPicPaletteTable[frontPicId]);
}
void DecompressTrainerBackPic(u16 backPicId, u8 battlerId)
void DecompressTrainerBackPic(u16 backPicId, u8 battler)
{
u8 position = GetBattlerPosition(battlerId);
u8 position = GetBattlerPosition(battler);
DecompressPicFromTable_2(&gTrainerBackPicTable[backPicId],
gMonSpritesGfxPtr->sprites.ptr[position],
SPECIES_NONE);
LoadCompressedPalette(gTrainerBackPicPaletteTable[backPicId].data,
OBJ_PLTT_ID(battlerId), PLTT_SIZE_4BPP);
OBJ_PLTT_ID(battler), PLTT_SIZE_4BPP);
}
void BattleGfxSfxDummy3(u8 gender)
@ -820,7 +820,7 @@ void LoadBattleBarGfx(u8 unused)
LZDecompressWram(gBattleInterfaceGfx_BattleBar, gMonSpritesGfxPtr->barFontGfx);
}
bool8 BattleInitAllSprites(u8 *state1, u8 *battlerId)
bool8 BattleInitAllSprites(u8 *state1, u8 *battler)
{
bool8 retVal = FALSE;
@ -831,13 +831,13 @@ bool8 BattleInitAllSprites(u8 *state1, u8 *battlerId)
(*state1)++;
break;
case 1:
if (!BattleLoadAllHealthBoxesGfx(*battlerId))
if (!BattleLoadAllHealthBoxesGfx(*battler))
{
(*battlerId)++;
(*battler)++;
}
else
{
*battlerId = 0;
*battler = 0;
(*state1)++;
}
break;
@ -845,47 +845,47 @@ bool8 BattleInitAllSprites(u8 *state1, u8 *battlerId)
(*state1)++;
break;
case 3:
if ((gBattleTypeFlags & BATTLE_TYPE_SAFARI) && *battlerId == 0)
gHealthboxSpriteIds[*battlerId] = CreateSafariPlayerHealthboxSprites();
if ((gBattleTypeFlags & BATTLE_TYPE_SAFARI) && *battler == 0)
gHealthboxSpriteIds[*battler] = CreateSafariPlayerHealthboxSprites();
else
gHealthboxSpriteIds[*battlerId] = CreateBattlerHealthboxSprites(*battlerId);
gHealthboxSpriteIds[*battler] = CreateBattlerHealthboxSprites(*battler);
(*battlerId)++;
if (*battlerId == gBattlersCount)
(*battler)++;
if (*battler == gBattlersCount)
{
*battlerId = 0;
*battler = 0;
(*state1)++;
}
break;
case 4:
InitBattlerHealthboxCoords(*battlerId);
if (gBattlerPositions[*battlerId] <= B_POSITION_OPPONENT_LEFT)
DummyBattleInterfaceFunc(gHealthboxSpriteIds[*battlerId], FALSE);
InitBattlerHealthboxCoords(*battler);
if (gBattlerPositions[*battler] <= B_POSITION_OPPONENT_LEFT)
DummyBattleInterfaceFunc(gHealthboxSpriteIds[*battler], FALSE);
else
DummyBattleInterfaceFunc(gHealthboxSpriteIds[*battlerId], TRUE);
DummyBattleInterfaceFunc(gHealthboxSpriteIds[*battler], TRUE);
(*battlerId)++;
if (*battlerId == gBattlersCount)
(*battler)++;
if (*battler == gBattlersCount)
{
*battlerId = 0;
*battler = 0;
(*state1)++;
}
break;
case 5:
if (GetBattlerSide(*battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(*battler) == B_SIDE_PLAYER)
{
if (!(gBattleTypeFlags & BATTLE_TYPE_SAFARI))
UpdateHealthboxAttribute(gHealthboxSpriteIds[*battlerId], &gPlayerParty[gBattlerPartyIndexes[*battlerId]], HEALTHBOX_ALL);
UpdateHealthboxAttribute(gHealthboxSpriteIds[*battler], &gPlayerParty[gBattlerPartyIndexes[*battler]], HEALTHBOX_ALL);
}
else
{
UpdateHealthboxAttribute(gHealthboxSpriteIds[*battlerId], &gEnemyParty[gBattlerPartyIndexes[*battlerId]], HEALTHBOX_ALL);
UpdateHealthboxAttribute(gHealthboxSpriteIds[*battler], &gEnemyParty[gBattlerPartyIndexes[*battler]], HEALTHBOX_ALL);
}
SetHealthboxSpriteInvisible(gHealthboxSpriteIds[*battlerId]);
(*battlerId)++;
if (*battlerId == gBattlersCount)
SetHealthboxSpriteInvisible(gHealthboxSpriteIds[*battler]);
(*battler)++;
if (*battler == gBattlersCount)
{
*battlerId = 0;
*battler = 0;
(*state1)++;
}
break;
@ -919,9 +919,9 @@ void CopyAllBattleSpritesInvisibilities(void)
gBattleSpritesDataPtr->battlerData[i].invisible = gSprites[gBattlerSpriteIds[i]].invisible;
}
void CopyBattleSpriteInvisibility(u8 battlerId)
void CopyBattleSpriteInvisibility(u8 battler)
{
gBattleSpritesDataPtr->battlerData[battlerId].invisible = gSprites[gBattlerSpriteIds[battlerId]].invisible;
gBattleSpritesDataPtr->battlerData[battler].invisible = gSprites[gBattlerSpriteIds[battler]].invisible;
}
void HandleSpeciesGfxDataChange(u8 battlerAtk, u8 battlerDef, bool8 castform)
@ -1023,7 +1023,7 @@ void HandleSpeciesGfxDataChange(u8 battlerAtk, u8 battlerDef, bool8 castform)
}
}
void BattleLoadSubstituteOrMonSpriteGfx(u8 battlerId, bool8 loadMonSprite)
void BattleLoadSubstituteOrMonSpriteGfx(u8 battler, bool8 loadMonSprite)
{
s32 i, position, palOffset;
@ -1032,11 +1032,11 @@ void BattleLoadSubstituteOrMonSpriteGfx(u8 battlerId, bool8 loadMonSprite)
if (IsContest())
position = B_POSITION_PLAYER_LEFT;
else
position = GetBattlerPosition(battlerId);
position = GetBattlerPosition(battler);
if (IsContest())
LZDecompressVram(gSubstituteDollBackGfx, gMonSpritesGfxPtr->sprites.ptr[position]);
else if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
else if (GetBattlerSide(battler) != B_SIDE_PLAYER)
LZDecompressVram(gSubstituteDollFrontGfx, gMonSpritesGfxPtr->sprites.ptr[position]);
else
LZDecompressVram(gSubstituteDollBackGfx, gMonSpritesGfxPtr->sprites.ptr[position]);
@ -1046,66 +1046,66 @@ void BattleLoadSubstituteOrMonSpriteGfx(u8 battlerId, bool8 loadMonSprite)
Dma3CopyLarge32_(gMonSpritesGfxPtr->sprites.ptr[position], &gMonSpritesGfxPtr->sprites.byte[position][MON_PIC_SIZE * i], MON_PIC_SIZE);
}
palOffset = OBJ_PLTT_ID(battlerId);
palOffset = OBJ_PLTT_ID(battler);
LoadCompressedPalette(gSubstituteDollPal, palOffset, PLTT_SIZE_4BPP);
}
else
{
if (!IsContest())
{
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battlerId]], battlerId);
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battler]], battler);
else
BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battlerId]], battlerId);
BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
}
}
}
void LoadBattleMonGfxAndAnimate(u8 battlerId, bool8 loadMonSprite, u8 spriteId)
void LoadBattleMonGfxAndAnimate(u8 battler, bool8 loadMonSprite, u8 spriteId)
{
BattleLoadSubstituteOrMonSpriteGfx(battlerId, loadMonSprite);
StartSpriteAnim(&gSprites[spriteId], gBattleMonForms[battlerId]);
BattleLoadSubstituteOrMonSpriteGfx(battler, loadMonSprite);
StartSpriteAnim(&gSprites[spriteId], gBattleMonForms[battler]);
if (!loadMonSprite)
gSprites[spriteId].y = GetSubstituteSpriteDefault_Y(battlerId);
gSprites[spriteId].y = GetSubstituteSpriteDefault_Y(battler);
else
gSprites[spriteId].y = GetBattlerSpriteDefault_Y(battlerId);
gSprites[spriteId].y = GetBattlerSpriteDefault_Y(battler);
}
void TrySetBehindSubstituteSpriteBit(u8 battlerId, u16 move)
void TrySetBehindSubstituteSpriteBit(u8 battler, u16 move)
{
if (move == MOVE_SUBSTITUTE)
gBattleSpritesDataPtr->battlerData[battlerId].behindSubstitute = 1;
gBattleSpritesDataPtr->battlerData[battler].behindSubstitute = 1;
}
void ClearBehindSubstituteBit(u8 battlerId)
void ClearBehindSubstituteBit(u8 battler)
{
gBattleSpritesDataPtr->battlerData[battlerId].behindSubstitute = 0;
gBattleSpritesDataPtr->battlerData[battler].behindSubstitute = 0;
}
void HandleLowHpMusicChange(struct Pokemon *mon, u8 battlerId)
void HandleLowHpMusicChange(struct Pokemon *mon, u8 battler)
{
u16 hp = GetMonData(mon, MON_DATA_HP);
u16 maxHP = GetMonData(mon, MON_DATA_MAX_HP);
if (GetHPBarLevel(hp, maxHP) == HP_BAR_RED)
{
if (!gBattleSpritesDataPtr->battlerData[battlerId].lowHpSong)
if (!gBattleSpritesDataPtr->battlerData[battler].lowHpSong)
{
if (!gBattleSpritesDataPtr->battlerData[BATTLE_PARTNER(battlerId)].lowHpSong)
if (!gBattleSpritesDataPtr->battlerData[BATTLE_PARTNER(battler)].lowHpSong)
PlaySE(SE_LOW_HEALTH);
gBattleSpritesDataPtr->battlerData[battlerId].lowHpSong = 1;
gBattleSpritesDataPtr->battlerData[battler].lowHpSong = 1;
}
}
else
{
gBattleSpritesDataPtr->battlerData[battlerId].lowHpSong = 0;
gBattleSpritesDataPtr->battlerData[battler].lowHpSong = 0;
if (!IsDoubleBattle())
{
m4aSongNumStop(SE_LOW_HEALTH);
return;
}
if (IsDoubleBattle() && !gBattleSpritesDataPtr->battlerData[BATTLE_PARTNER(battlerId)].lowHpSong)
if (IsDoubleBattle() && !gBattleSpritesDataPtr->battlerData[BATTLE_PARTNER(battler)].lowHpSong)
{
m4aSongNumStop(SE_LOW_HEALTH);
return;
@ -1174,46 +1174,46 @@ void SetBattlerSpriteAffineMode(u8 affineMode)
void LoadAndCreateEnemyShadowSprites(void)
{
u8 battlerId;
u8 battler;
LoadCompressedSpriteSheet(&gSpriteSheet_EnemyShadow);
battlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
gBattleSpritesDataPtr->healthBoxesData[battlerId].shadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X),
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 29,
battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow,
GetBattlerSpriteCoord(battler, BATTLER_COORD_X),
GetBattlerSpriteCoord(battler, BATTLER_COORD_Y) + 29,
0xC8);
gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerId].shadowSpriteId].data[0] = battlerId;
gSprites[gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteId].data[0] = battler;
if (IsDoubleBattle())
{
battlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
gBattleSpritesDataPtr->healthBoxesData[battlerId].shadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow,
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X),
GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 29,
battler = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow,
GetBattlerSpriteCoord(battler, BATTLER_COORD_X),
GetBattlerSpriteCoord(battler, BATTLER_COORD_Y) + 29,
0xC8);
gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerId].shadowSpriteId].data[0] = battlerId;
gSprites[gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteId].data[0] = battler;
}
}
void SpriteCB_EnemyShadow(struct Sprite *shadowSprite)
{
bool8 invisible = FALSE;
u8 battlerId = shadowSprite->tBattlerId;
struct Sprite *battlerSprite = &gSprites[gBattlerSpriteIds[battlerId]];
u8 battler = shadowSprite->tBattlerId;
struct Sprite *battlerSprite = &gSprites[gBattlerSpriteIds[battler]];
if (!battlerSprite->inUse || !IsBattlerSpritePresent(battlerId))
if (!battlerSprite->inUse || !IsBattlerSpritePresent(battler))
{
shadowSprite->callback = SpriteCB_SetInvisible;
return;
}
if (gAnimScriptActive || battlerSprite->invisible)
invisible = TRUE;
else if (gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != SPECIES_NONE
&& gEnemyMonElevation[gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies] == 0)
else if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies != SPECIES_NONE
&& gEnemyMonElevation[gBattleSpritesDataPtr->battlerData[battler].transformSpecies] == 0)
invisible = TRUE;
if (gBattleSpritesDataPtr->battlerData[battlerId].behindSubstitute)
if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute)
invisible = TRUE;
shadowSprite->x = battlerSprite->x;
@ -1228,24 +1228,24 @@ void SpriteCB_SetInvisible(struct Sprite *sprite)
sprite->invisible = TRUE;
}
void SetBattlerShadowSpriteCallback(u8 battlerId, u16 species)
void SetBattlerShadowSpriteCallback(u8 battler, u16 species)
{
// The player's shadow is never seen.
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
return;
if (gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != SPECIES_NONE)
species = gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies;
if (gBattleSpritesDataPtr->battlerData[battler].transformSpecies != SPECIES_NONE)
species = gBattleSpritesDataPtr->battlerData[battler].transformSpecies;
if (gEnemyMonElevation[species] != 0)
gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerId].shadowSpriteId].callback = SpriteCB_EnemyShadow;
gSprites[gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteId].callback = SpriteCB_EnemyShadow;
else
gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerId].shadowSpriteId].callback = SpriteCB_SetInvisible;
gSprites[gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteId].callback = SpriteCB_SetInvisible;
}
void HideBattlerShadowSprite(u8 battlerId)
void HideBattlerShadowSprite(u8 battler)
{
gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerId].shadowSpriteId].callback = SpriteCB_SetInvisible;
gSprites[gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteId].callback = SpriteCB_SetInvisible;
}
// Color the background tiles surrounding the action selection and move windows
@ -1272,12 +1272,12 @@ void FillAroundBattleWindows(void)
}
}
void ClearTemporarySpeciesSpriteData(u8 battlerId, bool8 dontClearSubstitute)
void ClearTemporarySpeciesSpriteData(u8 battler, bool8 dontClearSubstitute)
{
gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies = SPECIES_NONE;
gBattleMonForms[battlerId] = 0;
gBattleSpritesDataPtr->battlerData[battler].transformSpecies = SPECIES_NONE;
gBattleMonForms[battler] = 0;
if (!dontClearSubstitute)
ClearBehindSubstituteBit(battlerId);
ClearBehindSubstituteBit(battler);
}
void AllocateMonSpritesGfx(void)

206
src/battle_interface.c
View File

@ -866,7 +866,7 @@ static void UNUSED Debug_DrawNumberPair(s16 number1, s16 number2, u16 *dest)
#define hBar_HealthBoxSpriteId data[5]
#define hBar_Data6 data[6]
u8 CreateBattlerHealthboxSprites(u8 battlerId)
u8 CreateBattlerHealthboxSprites(u8 battler)
{
s16 data6 = 0;
u8 healthboxLeftSpriteId, healthboxRightSpriteId;
@ -875,7 +875,7 @@ u8 CreateBattlerHealthboxSprites(u8 battlerId)
if (!IsDoubleBattle())
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
{
healthboxLeftSpriteId = CreateSprite(&sHealthboxPlayerSpriteTemplates[0], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
healthboxRightSpriteId = CreateSpriteAtEnd(&sHealthboxPlayerSpriteTemplates[0], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
@ -901,10 +901,10 @@ u8 CreateBattlerHealthboxSprites(u8 battlerId)
}
else
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
{
healthboxLeftSpriteId = CreateSprite(&sHealthboxPlayerSpriteTemplates[GetBattlerPosition(battlerId) / 2], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
healthboxRightSpriteId = CreateSpriteAtEnd(&sHealthboxPlayerSpriteTemplates[GetBattlerPosition(battlerId) / 2], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
healthboxLeftSpriteId = CreateSprite(&sHealthboxPlayerSpriteTemplates[GetBattlerPosition(battler) / 2], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
healthboxRightSpriteId = CreateSpriteAtEnd(&sHealthboxPlayerSpriteTemplates[GetBattlerPosition(battler) / 2], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
gSprites[healthboxLeftSpriteId].oam.affineParam = healthboxRightSpriteId;
@ -916,8 +916,8 @@ u8 CreateBattlerHealthboxSprites(u8 battlerId)
}
else
{
healthboxLeftSpriteId = CreateSprite(&sHealthboxOpponentSpriteTemplates[GetBattlerPosition(battlerId) / 2], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
healthboxRightSpriteId = CreateSpriteAtEnd(&sHealthboxOpponentSpriteTemplates[GetBattlerPosition(battlerId) / 2], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
healthboxLeftSpriteId = CreateSprite(&sHealthboxOpponentSpriteTemplates[GetBattlerPosition(battler) / 2], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
healthboxRightSpriteId = CreateSpriteAtEnd(&sHealthboxOpponentSpriteTemplates[GetBattlerPosition(battler) / 2], DISPLAY_WIDTH, DISPLAY_HEIGHT, 1);
gSprites[healthboxLeftSpriteId].oam.affineParam = healthboxRightSpriteId;
@ -929,16 +929,16 @@ u8 CreateBattlerHealthboxSprites(u8 battlerId)
}
}
healthbarSpriteId = CreateSpriteAtEnd(&sHealthbarSpriteTemplates[gBattlerPositions[battlerId]], 140, 60, 0);
healthbarSpriteId = CreateSpriteAtEnd(&sHealthbarSpriteTemplates[gBattlerPositions[battler]], 140, 60, 0);
healthBarSpritePtr = &gSprites[healthbarSpriteId];
SetSubspriteTables(healthBarSpritePtr, &sHealthBar_SubspriteTables[GetBattlerSide(battlerId)]);
SetSubspriteTables(healthBarSpritePtr, &sHealthBar_SubspriteTables[GetBattlerSide(battler)]);
healthBarSpritePtr->subspriteMode = SUBSPRITES_IGNORE_PRIORITY;
healthBarSpritePtr->oam.priority = 1;
CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_1), (void *)(OBJ_VRAM0 + healthBarSpritePtr->oam.tileNum * TILE_SIZE_4BPP), 64);
gSprites[healthboxLeftSpriteId].hMain_HealthBarSpriteId = healthbarSpriteId;
gSprites[healthboxLeftSpriteId].hMain_Battler = battlerId;
gSprites[healthboxLeftSpriteId].hMain_Battler = battler;
gSprites[healthboxLeftSpriteId].invisible = TRUE;
gSprites[healthboxRightSpriteId].invisible = TRUE;
@ -1012,13 +1012,13 @@ static void SpriteCB_HealthBoxOther(struct Sprite *sprite)
sprite->y2 = gSprites[healthboxMainSpriteId].y2;
}
void SetBattleBarStruct(u8 battlerId, u8 healthboxSpriteId, s32 maxVal, s32 oldVal, s32 receivedValue)
void SetBattleBarStruct(u8 battler, u8 healthboxSpriteId, s32 maxVal, s32 oldVal, s32 receivedValue)
{
gBattleSpritesDataPtr->battleBars[battlerId].healthboxSpriteId = healthboxSpriteId;
gBattleSpritesDataPtr->battleBars[battlerId].maxValue = maxVal;
gBattleSpritesDataPtr->battleBars[battlerId].oldValue = oldVal;
gBattleSpritesDataPtr->battleBars[battlerId].receivedValue = receivedValue;
gBattleSpritesDataPtr->battleBars[battlerId].currValue = -32768;
gBattleSpritesDataPtr->battleBars[battler].healthboxSpriteId = healthboxSpriteId;
gBattleSpritesDataPtr->battleBars[battler].maxValue = maxVal;
gBattleSpritesDataPtr->battleBars[battler].oldValue = oldVal;
gBattleSpritesDataPtr->battleBars[battler].receivedValue = receivedValue;
gBattleSpritesDataPtr->battleBars[battler].currValue = -32768;
}
void SetHealthboxSpriteInvisible(u8 healthboxSpriteId)
@ -1251,12 +1251,12 @@ static void UpdateHpTextInHealthboxInDoubles(u8 healthboxSpriteId, s16 value, u8
}
else
{
u8 battlerId;
u8 battler;
memcpy(text, sEmptyWhiteText_TransparentHighlight, sizeof(sEmptyWhiteText_TransparentHighlight));
battlerId = gSprites[healthboxSpriteId].hMain_Battler;
battler = gSprites[healthboxSpriteId].hMain_Battler;
if (gBattleSpritesDataPtr->battlerData[battlerId].hpNumbersNoBars) // don't print text if only bars are visible
if (gBattleSpritesDataPtr->battlerData[battler].hpNumbersNoBars) // don't print text if only bars are visible
{
u8 var = 4;
u8 r7;
@ -1297,7 +1297,7 @@ static void UpdateHpTextInHealthboxInDoubles(u8 healthboxSpriteId, s16 value, u8
}
else
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER) // Impossible to reach part, because the battlerId is from the opponent's side.
if (GetBattlerSide(battler) == B_SIDE_PLAYER) // Impossible to reach part, because the battler is from the opponent's side.
{
CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_FRAME_END),
(void *)(OBJ_VRAM0) + ((gSprites[healthboxSpriteId].oam.tileNum + 52) * TILE_SIZE_4BPP),
@ -1447,7 +1447,7 @@ void SwapHpBarsWithHpText(void)
#define tIsBattleStart data[10]
#define tBlend data[15]
u8 CreatePartyStatusSummarySprites(u8 battlerId, struct HpAndStatus *partyInfo, bool8 skipPlayer, bool8 isBattleStart)
u8 CreatePartyStatusSummarySprites(u8 battler, struct HpAndStatus *partyInfo, bool8 skipPlayer, bool8 isBattleStart)
{
bool8 isOpponent;
s16 bar_X, bar_Y, bar_pos2_X, bar_data0;
@ -1456,9 +1456,9 @@ u8 CreatePartyStatusSummarySprites(u8 battlerId, struct HpAndStatus *partyInfo,
u8 ballIconSpritesIds[PARTY_SIZE];
u8 taskId;
if (!skipPlayer || GetBattlerPosition(battlerId) != B_POSITION_OPPONENT_RIGHT)
if (!skipPlayer || GetBattlerPosition(battler) != B_POSITION_OPPONENT_RIGHT)
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
{
isOpponent = FALSE;
bar_X = 136, bar_Y = 96;
@ -1537,7 +1537,7 @@ u8 CreatePartyStatusSummarySprites(u8 battlerId, struct HpAndStatus *partyInfo,
gSprites[ballIconSpritesIds[i]].data[2] = isOpponent;
}
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
{
if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
{
@ -1650,7 +1650,7 @@ u8 CreatePartyStatusSummarySprites(u8 battlerId, struct HpAndStatus *partyInfo,
}
taskId = CreateTask(TaskDummy, 5);
gTasks[taskId].tBattler = battlerId;
gTasks[taskId].tBattler = battler;
gTasks[taskId].tSummaryBarSpriteId = summaryBarSpriteId;
for (i = 0; i < PARTY_SIZE; i++)
@ -1673,12 +1673,12 @@ void Task_HidePartyStatusSummary(u8 taskId)
u8 ballIconSpriteIds[PARTY_SIZE];
bool8 isBattleStart;
u8 summaryBarSpriteId;
u8 battlerId;
u8 battler;
s32 i;
isBattleStart = gTasks[taskId].tIsBattleStart;
summaryBarSpriteId = gTasks[taskId].tSummaryBarSpriteId;
battlerId = gTasks[taskId].tBattler;
battler = gTasks[taskId].tBattler;
for (i = 0; i < PARTY_SIZE; i++)
ballIconSpriteIds[i] = gTasks[taskId].tBallIconSpriteId(i);
@ -1697,7 +1697,7 @@ void Task_HidePartyStatusSummary(u8 taskId)
{
for (i = 0; i < PARTY_SIZE; i++)
{
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
{
gSprites[ballIconSpriteIds[PARTY_SIZE - 1 - i]].data[1] = 7 * i;
gSprites[ballIconSpriteIds[PARTY_SIZE - 1 - i]].data[3] = 0;
@ -1742,7 +1742,7 @@ static void Task_HidePartyStatusSummary_BattleStart_2(u8 taskId)
u8 ballIconSpriteIds[PARTY_SIZE];
s32 i;
u8 battlerId = gTasks[taskId].tBattler;
u8 battler = gTasks[taskId].tBattler;
if (--gTasks[taskId].tBlend == -1)
{
u8 summaryBarSpriteId = gTasks[taskId].tSummaryBarSpriteId;
@ -1769,7 +1769,7 @@ static void Task_HidePartyStatusSummary_BattleStart_2(u8 taskId)
}
else if (gTasks[taskId].tBlend == -3)
{
gBattleSpritesDataPtr->healthBoxesData[battlerId].partyStatusSummaryShown = 0;
gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusSummaryShown = 0;
SetGpuReg(REG_OFFSET_BLDCNT, 0);
SetGpuReg(REG_OFFSET_BLDALPHA, 0);
DestroyTask(taskId);
@ -1780,7 +1780,7 @@ static void Task_HidePartyStatusSummary_DuringBattle(u8 taskId)
{
u8 ballIconSpriteIds[PARTY_SIZE];
s32 i;
u8 battlerId = gTasks[taskId].tBattler;
u8 battler = gTasks[taskId].tBattler;
if (--gTasks[taskId].tBlend >= 0)
{
@ -1801,7 +1801,7 @@ static void Task_HidePartyStatusSummary_DuringBattle(u8 taskId)
}
else if (gTasks[taskId].tBlend == -3)
{
gBattleSpritesDataPtr->healthBoxesData[battlerId].partyStatusSummaryShown = 0;
gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusSummaryShown = 0;
SetGpuReg(REG_OFFSET_BLDCNT, 0);
SetGpuReg(REG_OFFSET_BLDALPHA, 0);
DestroyTask(taskId);
@ -1969,17 +1969,17 @@ static void UpdateNickInHealthbox(u8 healthboxSpriteId, struct Pokemon *mon)
static void TryAddPokeballIconToHealthbox(u8 healthboxSpriteId, bool8 noStatus)
{
u8 battlerId, healthBarSpriteId;
u8 battler, healthBarSpriteId;
if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL)
return;
if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
return;
battlerId = gSprites[healthboxSpriteId].hMain_Battler;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
battler = gSprites[healthboxSpriteId].hMain_Battler;
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
return;
if (!GetSetPokedexFlag(SpeciesToNationalPokedexNum(GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES)), FLAG_GET_CAUGHT))
if (!GetSetPokedexFlag(SpeciesToNationalPokedexNum(GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES)), FLAG_GET_CAUGHT))
return;
healthBarSpriteId = gSprites[healthboxSpriteId].hMain_HealthBarSpriteId;
@ -1993,17 +1993,17 @@ static void TryAddPokeballIconToHealthbox(u8 healthboxSpriteId, bool8 noStatus)
static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
{
s32 i;
u8 battlerId, healthBarSpriteId;
u8 battler, healthBarSpriteId;
u32 status, pltAdder;
const u8 *statusGfxPtr;
s16 tileNumAdder;
u8 statusPalId;
battlerId = gSprites[healthboxSpriteId].hMain_Battler;
battler = gSprites[healthboxSpriteId].hMain_Battler;
healthBarSpriteId = gSprites[healthboxSpriteId].hMain_HealthBarSpriteId;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
{
status = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_STATUS);
status = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_STATUS);
if (!IsDoubleBattle())
tileNumAdder = 0x1A;
else
@ -2011,33 +2011,33 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
}
else
{
status = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_STATUS);
status = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_STATUS);
tileNumAdder = 0x11;
}
if (status & STATUS1_SLEEP)
{
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_SLP_BATTLER0, battlerId));
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_SLP_BATTLER0, battler));
statusPalId = PAL_STATUS_SLP;
}
else if (status & STATUS1_PSN_ANY)
{
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_PSN_BATTLER0, battlerId));
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_PSN_BATTLER0, battler));
statusPalId = PAL_STATUS_PSN;
}
else if (status & STATUS1_BURN)
{
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_BRN_BATTLER0, battlerId));
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_BRN_BATTLER0, battler));
statusPalId = PAL_STATUS_BRN;
}
else if (status & STATUS1_FREEZE)
{
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_FRZ_BATTLER0, battlerId));
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_FRZ_BATTLER0, battler));
statusPalId = PAL_STATUS_FRZ;
}
else if (status & STATUS1_PARALYSIS)
{
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_PRZ_BATTLER0, battlerId));
statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBattlerId(HEALTHBOX_GFX_STATUS_PRZ_BATTLER0, battler));
statusPalId = PAL_STATUS_PAR;
}
else
@ -2047,7 +2047,7 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
for (i = 0; i < 3; i++)
CpuCopy32(statusGfxPtr, (void *)(OBJ_VRAM0 + (gSprites[healthboxSpriteId].oam.tileNum + tileNumAdder + i) * TILE_SIZE_4BPP), 32);
if (!gBattleSpritesDataPtr->battlerData[battlerId].hpNumbersNoBars)
if (!gBattleSpritesDataPtr->battlerData[battler].hpNumbersNoBars)
CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_1), (void *)(OBJ_VRAM0 + gSprites[healthBarSpriteId].oam.tileNum * TILE_SIZE_4BPP), 64);
TryAddPokeballIconToHealthbox(healthboxSpriteId, TRUE);
@ -2055,14 +2055,14 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
}
pltAdder = PLTT_ID(gSprites[healthboxSpriteId].oam.paletteNum);
pltAdder += battlerId + 12;
pltAdder += battler + 12;
FillPalette(sStatusIconColors[statusPalId], OBJ_PLTT_OFFSET + pltAdder, PLTT_SIZEOF(1));
CpuCopy16(&gPlttBufferUnfaded[OBJ_PLTT_OFFSET + pltAdder], (u16 *)OBJ_PLTT + pltAdder, PLTT_SIZEOF(1));
CpuCopy32(statusGfxPtr, (void *)(OBJ_VRAM0 + (gSprites[healthboxSpriteId].oam.tileNum + tileNumAdder) * TILE_SIZE_4BPP), 96);
if (IsDoubleBattle() == TRUE || GetBattlerSide(battlerId) == B_SIDE_OPPONENT)
if (IsDoubleBattle() == TRUE || GetBattlerSide(battler) == B_SIDE_OPPONENT)
{
if (!gBattleSpritesDataPtr->battlerData[battlerId].hpNumbersNoBars)
if (!gBattleSpritesDataPtr->battlerData[battler].hpNumbersNoBars)
{
CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_0), (void *)(OBJ_VRAM0 + gSprites[healthBarSpriteId].oam.tileNum * TILE_SIZE_4BPP), 32);
CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_65), (void *)(OBJ_VRAM0 + (gSprites[healthBarSpriteId].oam.tileNum + 1) * TILE_SIZE_4BPP), 32);
@ -2071,58 +2071,58 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
TryAddPokeballIconToHealthbox(healthboxSpriteId, FALSE);
}
static u8 GetStatusIconForBattlerId(u8 statusElementId, u8 battlerId)
static u8 GetStatusIconForBattlerId(u8 statusElementId, u8 battler)
{
u8 ret = statusElementId;
switch (statusElementId)
{
case HEALTHBOX_GFX_STATUS_PSN_BATTLER0:
if (battlerId == 0)
if (battler == 0)
ret = HEALTHBOX_GFX_STATUS_PSN_BATTLER0;
else if (battlerId == 1)
else if (battler == 1)
ret = HEALTHBOX_GFX_STATUS_PSN_BATTLER1;
else if (battlerId == 2)
else if (battler == 2)
ret = HEALTHBOX_GFX_STATUS_PSN_BATTLER2;
else
ret = HEALTHBOX_GFX_STATUS_PSN_BATTLER3;
break;
case HEALTHBOX_GFX_STATUS_PRZ_BATTLER0:
if (battlerId == 0)
if (battler == 0)
ret = HEALTHBOX_GFX_STATUS_PRZ_BATTLER0;
else if (battlerId == 1)
else if (battler == 1)
ret = HEALTHBOX_GFX_STATUS_PRZ_BATTLER1;
else if (battlerId == 2)
else if (battler == 2)
ret = HEALTHBOX_GFX_STATUS_PRZ_BATTLER2;
else
ret = HEALTHBOX_GFX_STATUS_PRZ_BATTLER3;
break;
case HEALTHBOX_GFX_STATUS_SLP_BATTLER0:
if (battlerId == 0)
if (battler == 0)
ret = HEALTHBOX_GFX_STATUS_SLP_BATTLER0;
else if (battlerId == 1)
else if (battler == 1)
ret = HEALTHBOX_GFX_STATUS_SLP_BATTLER1;
else if (battlerId == 2)
else if (battler == 2)
ret = HEALTHBOX_GFX_STATUS_SLP_BATTLER2;
else
ret = HEALTHBOX_GFX_STATUS_SLP_BATTLER3;
break;
case HEALTHBOX_GFX_STATUS_FRZ_BATTLER0:
if (battlerId == 0)
if (battler == 0)
ret = HEALTHBOX_GFX_STATUS_FRZ_BATTLER0;
else if (battlerId == 1)
else if (battler == 1)
ret = HEALTHBOX_GFX_STATUS_FRZ_BATTLER1;
else if (battlerId == 2)
else if (battler == 2)
ret = HEALTHBOX_GFX_STATUS_FRZ_BATTLER2;
else
ret = HEALTHBOX_GFX_STATUS_FRZ_BATTLER3;
break;
case HEALTHBOX_GFX_STATUS_BRN_BATTLER0:
if (battlerId == 0)
if (battler == 0)
ret = HEALTHBOX_GFX_STATUS_BRN_BATTLER0;
else if (battlerId == 1)
else if (battler == 1)
ret = HEALTHBOX_GFX_STATUS_BRN_BATTLER1;
else if (battlerId == 2)
else if (battler == 2)
ret = HEALTHBOX_GFX_STATUS_BRN_BATTLER2;
else
ret = HEALTHBOX_GFX_STATUS_BRN_BATTLER3;
@ -2163,10 +2163,10 @@ static void UpdateLeftNoOfBallsTextOnHealthbox(u8 healthboxSpriteId)
void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elementId)
{
s32 maxHp, currHp;
u8 battlerId = gSprites[healthboxSpriteId].hMain_Battler;
u8 battler = gSprites[healthboxSpriteId].hMain_Battler;
if (elementId == HEALTHBOX_ALL && !IsDoubleBattle())
GetBattlerSide(battlerId); // Pointless function call.
GetBattlerSide(battler); // Pointless function call.
if (GetBattlerSide(gSprites[healthboxSpriteId].hMain_Battler) == B_SIDE_PLAYER)
{
@ -2183,8 +2183,8 @@ void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elem
LoadBattleBarGfx(0);
maxHp = GetMonData(mon, MON_DATA_MAX_HP);
currHp = GetMonData(mon, MON_DATA_HP);
SetBattleBarStruct(battlerId, healthboxSpriteId, maxHp, currHp, 0);
MoveBattleBar(battlerId, healthboxSpriteId, HEALTH_BAR, 0);
SetBattleBarStruct(battler, healthboxSpriteId, maxHp, currHp, 0);
MoveBattleBar(battler, healthboxSpriteId, HEALTH_BAR, 0);
}
isDoubles = IsDoubleBattle();
if (!isDoubles && (elementId == HEALTHBOX_EXP_BAR || elementId == HEALTHBOX_ALL))
@ -2201,8 +2201,8 @@ void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elem
currLevelExp = gExperienceTables[gSpeciesInfo[species].growthRate][level];
currExpBarValue = exp - currLevelExp;
maxExpBarValue = gExperienceTables[gSpeciesInfo[species].growthRate][level + 1] - currLevelExp;
SetBattleBarStruct(battlerId, healthboxSpriteId, maxExpBarValue, currExpBarValue, isDoubles);
MoveBattleBar(battlerId, healthboxSpriteId, EXP_BAR, 0);
SetBattleBarStruct(battler, healthboxSpriteId, maxExpBarValue, currExpBarValue, isDoubles);
MoveBattleBar(battler, healthboxSpriteId, EXP_BAR, 0);
}
if (elementId == HEALTHBOX_NICK || elementId == HEALTHBOX_ALL)
UpdateNickInHealthbox(healthboxSpriteId, mon);
@ -2222,8 +2222,8 @@ void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elem
LoadBattleBarGfx(0);
maxHp = GetMonData(mon, MON_DATA_MAX_HP);
currHp = GetMonData(mon, MON_DATA_HP);
SetBattleBarStruct(battlerId, healthboxSpriteId, maxHp, currHp, 0);
MoveBattleBar(battlerId, healthboxSpriteId, HEALTH_BAR, 0);
SetBattleBarStruct(battler, healthboxSpriteId, maxHp, currHp, 0);
MoveBattleBar(battler, healthboxSpriteId, HEALTH_BAR, 0);
}
if (elementId == HEALTHBOX_NICK || elementId == HEALTHBOX_ALL)
UpdateNickInHealthbox(healthboxSpriteId, mon);
@ -2235,44 +2235,44 @@ void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elem
#define B_EXPBAR_PIXELS 64
#define B_HEALTHBAR_PIXELS 48
s32 MoveBattleBar(u8 battlerId, u8 healthboxSpriteId, u8 whichBar, u8 unused)
s32 MoveBattleBar(u8 battler, u8 healthboxSpriteId, u8 whichBar, u8 unused)
{
s32 currentBarValue;
if (whichBar == HEALTH_BAR) // health bar
{
currentBarValue = CalcNewBarValue(gBattleSpritesDataPtr->battleBars[battlerId].maxValue,
gBattleSpritesDataPtr->battleBars[battlerId].oldValue,
gBattleSpritesDataPtr->battleBars[battlerId].receivedValue,
&gBattleSpritesDataPtr->battleBars[battlerId].currValue,
currentBarValue = CalcNewBarValue(gBattleSpritesDataPtr->battleBars[battler].maxValue,
gBattleSpritesDataPtr->battleBars[battler].oldValue,
gBattleSpritesDataPtr->battleBars[battler].receivedValue,
&gBattleSpritesDataPtr->battleBars[battler].currValue,
B_HEALTHBAR_PIXELS / 8, 1);
}
else // exp bar
{
u16 expFraction = GetScaledExpFraction(gBattleSpritesDataPtr->battleBars[battlerId].oldValue,
gBattleSpritesDataPtr->battleBars[battlerId].receivedValue,
gBattleSpritesDataPtr->battleBars[battlerId].maxValue, 8);
u16 expFraction = GetScaledExpFraction(gBattleSpritesDataPtr->battleBars[battler].oldValue,
gBattleSpritesDataPtr->battleBars[battler].receivedValue,
gBattleSpritesDataPtr->battleBars[battler].maxValue, 8);
if (expFraction == 0)
expFraction = 1;
expFraction = abs(gBattleSpritesDataPtr->battleBars[battlerId].receivedValue / expFraction);
expFraction = abs(gBattleSpritesDataPtr->battleBars[battler].receivedValue / expFraction);
currentBarValue = CalcNewBarValue(gBattleSpritesDataPtr->battleBars[battlerId].maxValue,
gBattleSpritesDataPtr->battleBars[battlerId].oldValue,
gBattleSpritesDataPtr->battleBars[battlerId].receivedValue,
&gBattleSpritesDataPtr->battleBars[battlerId].currValue,
currentBarValue = CalcNewBarValue(gBattleSpritesDataPtr->battleBars[battler].maxValue,
gBattleSpritesDataPtr->battleBars[battler].oldValue,
gBattleSpritesDataPtr->battleBars[battler].receivedValue,
&gBattleSpritesDataPtr->battleBars[battler].currValue,
B_EXPBAR_PIXELS / 8, expFraction);
}
if (whichBar == EXP_BAR || (whichBar == HEALTH_BAR && !gBattleSpritesDataPtr->battlerData[battlerId].hpNumbersNoBars))
MoveBattleBarGraphically(battlerId, whichBar);
if (whichBar == EXP_BAR || (whichBar == HEALTH_BAR && !gBattleSpritesDataPtr->battlerData[battler].hpNumbersNoBars))
MoveBattleBarGraphically(battler, whichBar);
if (currentBarValue == -1)
gBattleSpritesDataPtr->battleBars[battlerId].currValue = 0;
gBattleSpritesDataPtr->battleBars[battler].currValue = 0;
return currentBarValue;
}
static void MoveBattleBarGraphically(u8 battlerId, u8 whichBar)
static void MoveBattleBarGraphically(u8 battler, u8 whichBar)
{
u8 array[8];
u8 filledPixelsCount, level;
@ -2282,10 +2282,10 @@ static void MoveBattleBarGraphically(u8 battlerId, u8 whichBar)
switch (whichBar)
{
case HEALTH_BAR:
filledPixelsCount = CalcBarFilledPixels(gBattleSpritesDataPtr->battleBars[battlerId].maxValue,
gBattleSpritesDataPtr->battleBars[battlerId].oldValue,
gBattleSpritesDataPtr->battleBars[battlerId].receivedValue,
&gBattleSpritesDataPtr->battleBars[battlerId].currValue,
filledPixelsCount = CalcBarFilledPixels(gBattleSpritesDataPtr->battleBars[battler].maxValue,
gBattleSpritesDataPtr->battleBars[battler].oldValue,
gBattleSpritesDataPtr->battleBars[battler].receivedValue,
&gBattleSpritesDataPtr->battleBars[battler].currValue,
array, B_HEALTHBAR_PIXELS / 8);
if (filledPixelsCount > (B_HEALTHBAR_PIXELS * 50 / 100)) // more than 50 % hp
@ -2297,7 +2297,7 @@ static void MoveBattleBarGraphically(u8 battlerId, u8 whichBar)
for (i = 0; i < 6; i++)
{
u8 healthbarSpriteId = gSprites[gBattleSpritesDataPtr->battleBars[battlerId].healthboxSpriteId].hMain_HealthBarSpriteId;
u8 healthbarSpriteId = gSprites[gBattleSpritesDataPtr->battleBars[battler].healthboxSpriteId].hMain_HealthBarSpriteId;
if (i < 2)
CpuCopy32(GetHealthboxElementGfxPtr(barElementId) + array[i] * 32,
(void *)(OBJ_VRAM0 + (gSprites[healthbarSpriteId].oam.tileNum + 2 + i) * TILE_SIZE_4BPP), 32);
@ -2307,12 +2307,12 @@ static void MoveBattleBarGraphically(u8 battlerId, u8 whichBar)
}
break;
case EXP_BAR:
CalcBarFilledPixels(gBattleSpritesDataPtr->battleBars[battlerId].maxValue,
gBattleSpritesDataPtr->battleBars[battlerId].oldValue,
gBattleSpritesDataPtr->battleBars[battlerId].receivedValue,
&gBattleSpritesDataPtr->battleBars[battlerId].currValue,
CalcBarFilledPixels(gBattleSpritesDataPtr->battleBars[battler].maxValue,
gBattleSpritesDataPtr->battleBars[battler].oldValue,
gBattleSpritesDataPtr->battleBars[battler].receivedValue,
&gBattleSpritesDataPtr->battleBars[battler].currValue,
array, B_EXPBAR_PIXELS / 8);
level = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_LEVEL);
level = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_LEVEL);
if (level == MAX_LEVEL)
{
for (i = 0; i < 8; i++)
@ -2322,10 +2322,10 @@ static void MoveBattleBarGraphically(u8 battlerId, u8 whichBar)
{
if (i < 4)
CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_12) + array[i] * 32,
(void *)(OBJ_VRAM0 + (gSprites[gBattleSpritesDataPtr->battleBars[battlerId].healthboxSpriteId].oam.tileNum + 0x24 + i) * TILE_SIZE_4BPP), 32);
(void *)(OBJ_VRAM0 + (gSprites[gBattleSpritesDataPtr->battleBars[battler].healthboxSpriteId].oam.tileNum + 0x24 + i) * TILE_SIZE_4BPP), 32);
else
CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_12) + array[i] * 32,
(void *)(OBJ_VRAM0 + 0xB80 + (i + gSprites[gBattleSpritesDataPtr->battleBars[battlerId].healthboxSpriteId].oam.tileNum) * TILE_SIZE_4BPP), 32);
(void *)(OBJ_VRAM0 + 0xB80 + (i + gSprites[gBattleSpritesDataPtr->battleBars[battler].healthboxSpriteId].oam.tileNum) * TILE_SIZE_4BPP), 32);
}
break;
}

18
src/battle_main.c
View File

@ -839,7 +839,7 @@ static void SetAllPlayersBerryData(void)
{
s32 numPlayers;
struct BattleEnigmaBerry *src;
u8 battlerId;
u8 battler;
if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
{
@ -851,17 +851,17 @@ static void SetAllPlayersBerryData(void)
for (i = 0; i < numPlayers; i++)
{
src = (struct BattleEnigmaBerry *)(gBlockRecvBuffer[i] + 2);
battlerId = gLinkPlayers[i].id;
battler = gLinkPlayers[i].id;
for (j = 0; j < BERRY_NAME_LENGTH; j++)
gEnigmaBerries[battlerId].name[j] = src->name[j];
gEnigmaBerries[battlerId].name[j] = EOS;
gEnigmaBerries[battler].name[j] = src->name[j];
gEnigmaBerries[battler].name[j] = EOS;
for (j = 0; j < BERRY_ITEM_EFFECT_COUNT; j++)
gEnigmaBerries[battlerId].itemEffect[j] = src->itemEffect[j];
gEnigmaBerries[battler].itemEffect[j] = src->itemEffect[j];
gEnigmaBerries[battlerId].holdEffect = src->holdEffect;
gEnigmaBerries[battlerId].holdEffectParam = src->holdEffectParam;
gEnigmaBerries[battler].holdEffect = src->holdEffect;
gEnigmaBerries[battler].holdEffectParam = src->holdEffectParam;
}
}
else
@ -4653,7 +4653,7 @@ u8 GetWhoStrikesFirst(u8 battler1, u8 battler2, bool8 ignoreChosenMoves)
if (holdEffect == HOLD_EFFECT_QUICK_CLAW && gRandomTurnNumber < (0xFFFF * holdEffectParam) / 100)
speedBattler1 = UINT_MAX;
// check second battlerId's speed
// check second battler's speed
speedBattler2 = (gBattleMons[battler2].speed * speedMultiplierBattler2)
* (gStatStageRatios[gBattleMons[battler2].statStages[STAT_SPEED]][0])
@ -4949,7 +4949,7 @@ static void RunTurnActionsFunctions(void)
}
else
{
if (gBattleStruct->savedTurnActionNumber != gCurrentTurnActionNumber) // action turn has been done, clear hitmarker bits for another battlerId
if (gBattleStruct->savedTurnActionNumber != gCurrentTurnActionNumber) // action turn has been done, clear hitmarker bits for another battler
{
gHitMarker &= ~HITMARKER_NO_ATTACKSTRING;
gHitMarker &= ~HITMARKER_UNABLE_TO_USE_MOVE;

14
src/battle_message.c
View File

@ -2283,8 +2283,8 @@ static const u8 *TryGetStatusString(u8 *src)
return NULL;
}
#define HANDLE_NICKNAME_STRING_CASE(battlerId, monIndex) \
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER) \
#define HANDLE_NICKNAME_STRING_CASE(battler, monIndex) \
if (GetBattlerSide(battler) != B_SIDE_PLAYER) \
{ \
if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) \
toCpy = sText_FoePkmnPrefix; \
@ -2422,7 +2422,7 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst)
StringGet_Nickname(text);
toCpy = text;
break;
case B_TXT_ATK_NAME_WITH_PREFIX_MON1: // attacker name with prefix, only battlerId 0/1
case B_TXT_ATK_NAME_WITH_PREFIX_MON1: // attacker name with prefix, only battler 0/1
HANDLE_NICKNAME_STRING_CASE(gBattlerAttacker,
gBattlerPartyIndexes[GetBattlerAtPosition(GET_BATTLER_SIDE(gBattlerAttacker))])
break;
@ -2441,13 +2441,13 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst)
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
case B_TXT_EFF_NAME_WITH_PREFIX: // effect battler name with prefix
HANDLE_NICKNAME_STRING_CASE(gEffectBattler, gBattlerPartyIndexes[gEffectBattler])
break;
case B_TXT_ACTIVE_NAME_WITH_PREFIX: // active battlerId name with prefix
case B_TXT_ACTIVE_NAME_WITH_PREFIX: // active battler 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
case B_TXT_SCR_ACTIVE_NAME_WITH_PREFIX: // scripting active battler name with prefix
HANDLE_NICKNAME_STRING_CASE(gBattleScripting.battler, gBattlerPartyIndexes[gBattleScripting.battler])
break;
case B_TXT_CURRENT_MOVE: // current move name
@ -2519,7 +2519,7 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst)
case B_TXT_SCR_ACTIVE_ABILITY: // scripting active ability
toCpy = gAbilityNames[sBattlerAbilities[gBattleScripting.battler]];
break;
case B_TXT_EFF_ABILITY: // effect battlerId ability
case B_TXT_EFF_ABILITY: // effect battler ability
toCpy = gAbilityNames[sBattlerAbilities[gEffectBattler]];
break;
case B_TXT_TRAINER1_CLASS: // trainer class name

32
src/battle_records.c
View File

@ -201,7 +201,7 @@ static void UpdateLinkBattleGameStats(s32 battleOutcome)
IncrementGameStat(stat);
}
static void UpdateLinkBattleRecords(struct LinkBattleRecords *records, const u8 *name, u16 trainerId, s32 battleOutcome, u8 battlerId)
static void UpdateLinkBattleRecords(struct LinkBattleRecords *records, const u8 *name, u16 trainerId, s32 battleOutcome, u8 battler)
{
s32 index;
@ -214,7 +214,7 @@ static void UpdateLinkBattleRecords(struct LinkBattleRecords *records, const u8
ClearLinkBattleRecord(&records->entries[index]);
StringCopyN(records->entries[index].name, name, PLAYER_NAME_LENGTH);
records->entries[index].trainerId = trainerId;
records->languages[index] = gLinkPlayers[battlerId].language;
records->languages[index] = gLinkPlayers[battler].language;
}
UpdateLinkBattleRecord(&records->entries[index], battleOutcome);
SortLinkBattleRecords(records);
@ -225,48 +225,48 @@ void ClearPlayerLinkBattleRecords(void)
ClearLinkBattleRecords(gSaveBlock1Ptr->linkBattleRecords.entries);
}
static void IncTrainerCardWins(s32 battlerId)
static void IncTrainerCardWins(s32 battler)
{
u16 *wins = &gTrainerCards[battlerId].linkBattleWins;
u16 *wins = &gTrainerCards[battler].linkBattleWins;
(*wins)++;
if (*wins > 9999)
*wins = 9999;
}
static void IncTrainerCardLosses(s32 battlerId)
static void IncTrainerCardLosses(s32 battler)
{
u16 *losses = &gTrainerCards[battlerId].linkBattleLosses;
u16 *losses = &gTrainerCards[battler].linkBattleLosses;
(*losses)++;
if (*losses > 9999)
*losses = 9999;
}
static void UpdateTrainerCardWinsLosses(s32 battlerId)
static void UpdateTrainerCardWinsLosses(s32 battler)
{
switch (gBattleOutcome)
{
case B_OUTCOME_WON:
IncTrainerCardWins(BATTLE_OPPOSITE(battlerId));
IncTrainerCardLosses(battlerId);
IncTrainerCardWins(BATTLE_OPPOSITE(battler));
IncTrainerCardLosses(battler);
break;
case B_OUTCOME_LOST:
IncTrainerCardLosses(BATTLE_OPPOSITE(battlerId));
IncTrainerCardWins(battlerId);
IncTrainerCardLosses(BATTLE_OPPOSITE(battler));
IncTrainerCardWins(battler);
break;
}
}
void UpdatePlayerLinkBattleRecords(s32 battlerId)
void UpdatePlayerLinkBattleRecords(s32 battler)
{
if (InUnionRoom() != TRUE)
{
UpdateTrainerCardWinsLosses(battlerId);
UpdateTrainerCardWinsLosses(battler);
UpdateLinkBattleRecords(
&gSaveBlock1Ptr->linkBattleRecords,
gTrainerCards[battlerId].playerName,
gTrainerCards[battlerId].trainerId,
gTrainerCards[battler].playerName,
gTrainerCards[battler].trainerId,
gBattleOutcome,
battlerId);
battler);
}
}

104
src/battle_script_commands.c
View File

@ -63,7 +63,7 @@ extern const u8 *const gBattleScriptsForMoveEffects[];
static bool8 IsTwoTurnsMove(u16 move);
static void TrySetDestinyBondToHappen(void);
static u8 AttacksThisTurn(u8 battlerId, u16 move); // Note: returns 1 if it's a charging turn, otherwise 2.
static u8 AttacksThisTurn(u8 battler, u16 move); // Note: returns 1 if it's a charging turn, otherwise 2.
static void CheckWonderGuardAndLevitate(void);
static u8 ChangeStatBuffs(s8 statValue, u8 statId, u8, const u8 *BS_ptr);
static bool32 IsMonGettingExpSentOut(void);
@ -2207,12 +2207,12 @@ static void Cmd_printselectionstringfromtable(void)
}
}
u8 GetBattlerTurnOrderNum(u8 battlerId)
u8 GetBattlerTurnOrderNum(u8 battler)
{
s32 i;
for (i = 0; i < gBattlersCount; i++)
{
if (gBattlerByTurnOrder[i] == battlerId)
if (gBattlerByTurnOrder[i] == battler)
break;
}
return i;
@ -2239,7 +2239,7 @@ void SetMoveEffect(bool8 primary, u8 certain)
if (gBattleCommunication[MOVE_EFFECT_BYTE] & MOVE_EFFECT_AFFECTS_USER)
{
gEffectBattler = gBattlerAttacker; // battlerId that effects get applied on
gEffectBattler = gBattlerAttacker; // battler that effects get applied on
gBattleCommunication[MOVE_EFFECT_BYTE] &= ~MOVE_EFFECT_AFFECTS_USER;
affectsUser = MOVE_EFFECT_AFFECTS_USER;
gBattleScripting.battler = gBattlerTarget; // theoretically the attacker
@ -2984,18 +2984,18 @@ static void Cmd_tryfaintmon(void)
}
else
{
u8 battlerId;
u8 battler;
if (gBattlescriptCurrInstr[1] == BS_ATTACKER)
{
gActiveBattler = gBattlerAttacker;
battlerId = gBattlerTarget;
battler = gBattlerTarget;
BS_ptr = BattleScript_FaintAttacker;
}
else
{
gActiveBattler = gBattlerTarget;
battlerId = gBattlerAttacker;
battler = gBattlerAttacker;
BS_ptr = BattleScript_FaintTarget;
}
if (!(gAbsentBattlerFlags & gBitTable[gActiveBattler])
@ -3021,7 +3021,7 @@ static void Cmd_tryfaintmon(void)
{
gHitMarker &= ~HITMARKER_DESTINYBOND;
BattleScriptPush(gBattlescriptCurrInstr);
gBattleMoveDamage = gBattleMons[battlerId].hp;
gBattleMoveDamage = gBattleMons[battler].hp;
gBattlescriptCurrInstr = BattleScript_DestinyBondTakesLife;
}
if ((gStatuses3[gBattlerTarget] & STATUS3_GRUDGE)
@ -3080,11 +3080,11 @@ static void Cmd_cleareffectsonfaint(void)
static void Cmd_jumpifstatus(void)
{
u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u8 battler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u32 flags = T2_READ_32(gBattlescriptCurrInstr + 2);
const u8 *jumpPtr = T2_READ_PTR(gBattlescriptCurrInstr + 6);
if (gBattleMons[battlerId].status1 & flags && gBattleMons[battlerId].hp != 0)
if (gBattleMons[battler].status1 & flags && gBattleMons[battler].hp != 0)
gBattlescriptCurrInstr = jumpPtr;
else
gBattlescriptCurrInstr += 10;
@ -3092,11 +3092,11 @@ static void Cmd_jumpifstatus(void)
static void Cmd_jumpifstatus2(void)
{
u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u8 battler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u32 flags = T2_READ_32(gBattlescriptCurrInstr + 2);
const u8 *jumpPtr = T2_READ_PTR(gBattlescriptCurrInstr + 6);
if (gBattleMons[battlerId].status2 & flags && gBattleMons[battlerId].hp != 0)
if (gBattleMons[battler].status2 & flags && gBattleMons[battler].hp != 0)
gBattlescriptCurrInstr = jumpPtr;
else
gBattlescriptCurrInstr += 10;
@ -3104,19 +3104,19 @@ static void Cmd_jumpifstatus2(void)
static void Cmd_jumpifability(void)
{
u8 battlerId;
u8 battler;
u8 ability = gBattlescriptCurrInstr[2];
const u8 *jumpPtr = T2_READ_PTR(gBattlescriptCurrInstr + 3);
if (gBattlescriptCurrInstr[1] == BS_ATTACKER_SIDE)
{
battlerId = AbilityBattleEffects(ABILITYEFFECT_CHECK_BATTLER_SIDE, gBattlerAttacker, ability, 0, 0);
if (battlerId)
battler = AbilityBattleEffects(ABILITYEFFECT_CHECK_BATTLER_SIDE, gBattlerAttacker, ability, 0, 0);
if (battler)
{
gLastUsedAbility = ability;
gBattlescriptCurrInstr = jumpPtr;
RecordAbilityBattle(battlerId - 1, gLastUsedAbility);
gBattleScripting.battlerWithAbility = battlerId - 1;
RecordAbilityBattle(battler - 1, gLastUsedAbility);
gBattleScripting.battlerWithAbility = battler - 1;
}
else
{
@ -3125,13 +3125,13 @@ static void Cmd_jumpifability(void)
}
else if (gBattlescriptCurrInstr[1] == BS_NOT_ATTACKER_SIDE)
{
battlerId = AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gBattlerAttacker, ability, 0, 0);
if (battlerId)
battler = AbilityBattleEffects(ABILITYEFFECT_CHECK_OTHER_SIDE, gBattlerAttacker, ability, 0, 0);
if (battler)
{
gLastUsedAbility = ability;
gBattlescriptCurrInstr = jumpPtr;
RecordAbilityBattle(battlerId - 1, gLastUsedAbility);
gBattleScripting.battlerWithAbility = battlerId - 1;
RecordAbilityBattle(battler - 1, gLastUsedAbility);
gBattleScripting.battlerWithAbility = battler - 1;
}
else
{
@ -3140,13 +3140,13 @@ static void Cmd_jumpifability(void)
}
else
{
battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
if (gBattleMons[battlerId].ability == ability)
battler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
if (gBattleMons[battler].ability == ability)
{
gLastUsedAbility = ability;
gBattlescriptCurrInstr = jumpPtr;
RecordAbilityBattle(battlerId, gLastUsedAbility);
gBattleScripting.battlerWithAbility = battlerId;
RecordAbilityBattle(battler, gLastUsedAbility);
gBattleScripting.battlerWithAbility = battler;
}
else
{
@ -3178,8 +3178,8 @@ static void Cmd_jumpifsideaffecting(void)
static void Cmd_jumpifstat(void)
{
u8 ret = 0;
u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u8 value = gBattleMons[battlerId].statStages[gBattlescriptCurrInstr[3]];
u8 battler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u8 value = gBattleMons[battler].statStages[gBattlescriptCurrInstr[3]];
switch (gBattlescriptCurrInstr[2])
{
@ -3242,11 +3242,11 @@ static void Cmd_jumpifstatus3condition(void)
static void Cmd_jumpiftype(void)
{
u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u8 battler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u8 type = gBattlescriptCurrInstr[2];
const u8 *jumpPtr = T2_READ_PTR(gBattlescriptCurrInstr + 3);
if (IS_BATTLER_OF_TYPE(battlerId, type))
if (IS_BATTLER_OF_TYPE(battler, type))
gBattlescriptCurrInstr = jumpPtr;
else
gBattlescriptCurrInstr += 7;
@ -3396,7 +3396,7 @@ static void Cmd_getexp(void)
i = STRINGID_EMPTYSTRING4;
}
// get exp getter battlerId
// get exp getter battler
if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
{
if (gBattlerPartyIndexes[2] == gBattleStruct->expGetterMonId && !(gAbsentBattlerFlags & gBitTable[2]))
@ -3980,9 +3980,9 @@ static void Cmd_call(void)
static void Cmd_jumpiftype2(void)
{
u8 battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
u8 battler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1]);
if (gBattlescriptCurrInstr[2] == gBattleMons[battlerId].types[0] || gBattlescriptCurrInstr[2] == gBattleMons[battlerId].types[1])
if (gBattlescriptCurrInstr[2] == gBattleMons[battler].types[0] || gBattlescriptCurrInstr[2] == gBattleMons[battler].types[1])
gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 3);
else
gBattlescriptCurrInstr += 7;
@ -4464,10 +4464,10 @@ static void Cmd_moveend(void)
&& !gProtectStructs[gBattlerAttacker].chargingTurn && gBattleMoves[gCurrentMove].target == MOVE_TARGET_BOTH
&& !(gHitMarker & HITMARKER_NO_ATTACKSTRING))
{
u8 battlerId = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerTarget)));
if (gBattleMons[battlerId].hp != 0)
u8 battler = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerTarget)));
if (gBattleMons[battler].hp != 0)
{
gBattlerTarget = battlerId;
gBattlerTarget = battler;
gHitMarker |= HITMARKER_NO_ATTACKSTRING;
gBattleScripting.moveendState = 0;
MoveValuesCleanUp();
@ -4866,10 +4866,10 @@ static void Cmd_openpartyscreen(void)
{
u32 flags;
u8 hitmarkerFaintBits;
u8 battlerId;
u8 battler;
const u8 *jumpPtr;
battlerId = 0;
battler = 0;
flags = 0;
jumpPtr = T1_READ_PTR(gBattlescriptCurrInstr + 2);
@ -5098,21 +5098,21 @@ static void Cmd_openpartyscreen(void)
else
hitmarkerFaintBits = PARTY_ACTION_SEND_OUT;
battlerId = GetBattlerForBattleScript(gBattlescriptCurrInstr[1] & ~PARTY_SCREEN_OPTIONAL);
if (gSpecialStatuses[battlerId].faintedHasReplacement)
battler = GetBattlerForBattleScript(gBattlescriptCurrInstr[1] & ~PARTY_SCREEN_OPTIONAL);
if (gSpecialStatuses[battler].faintedHasReplacement)
{
gBattlescriptCurrInstr += 6;
}
else if (HasNoMonsToSwitch(battlerId, PARTY_SIZE, PARTY_SIZE))
else if (HasNoMonsToSwitch(battler, PARTY_SIZE, PARTY_SIZE))
{
gActiveBattler = battlerId;
gActiveBattler = battler;
gAbsentBattlerFlags |= gBitTable[gActiveBattler];
gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler);
gBattlescriptCurrInstr = jumpPtr;
}
else
{
gActiveBattler = battlerId;
gActiveBattler = battler;
*(gBattleStruct->battlerPartyIndexes + gActiveBattler) = gBattlerPartyIndexes[gActiveBattler];
*(gBattleStruct->monToSwitchIntoId + gActiveBattler) = PARTY_SIZE;
gBattleStruct->field_93 &= ~(gBitTable[gActiveBattler]);
@ -5129,7 +5129,7 @@ static void Cmd_openpartyscreen(void)
{
for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++)
{
if (gActiveBattler != battlerId)
if (gActiveBattler != battler)
{
BtlController_EmitLinkStandbyMsg(B_COMM_TO_CONTROLLER, LINK_STANDBY_MSG_ONLY, FALSE);
MarkBattlerForControllerExec(gActiveBattler);
@ -5138,7 +5138,7 @@ static void Cmd_openpartyscreen(void)
}
else
{
gActiveBattler = GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(battlerId)));
gActiveBattler = GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(battler)));
if (gAbsentBattlerFlags & gBitTable[gActiveBattler])
gActiveBattler ^= BIT_FLANK;
@ -6798,13 +6798,13 @@ static void Cmd_nop(void)
gBattlescriptCurrInstr++;
}
bool8 UproarWakeUpCheck(u8 battlerId)
bool8 UproarWakeUpCheck(u8 battler)
{
s32 i;
for (i = 0; i < gBattlersCount; i++)
{
if (!(gBattleMons[i].status2 & STATUS2_UPROAR) || gBattleMons[battlerId].ability == ABILITY_SOUNDPROOF)
if (!(gBattleMons[i].status2 & STATUS2_UPROAR) || gBattleMons[battler].ability == ABILITY_SOUNDPROOF)
continue;
gBattleScripting.battler = i;
@ -8241,7 +8241,7 @@ static bool8 IsInvalidForSleepTalkOrAssist(u16 move)
return FALSE;
}
static u8 AttacksThisTurn(u8 battlerId, u16 move) // Note: returns 1 if it's a charging turn, otherwise 2
static u8 AttacksThisTurn(u8 battler, u16 move) // Note: returns 1 if it's a charging turn, otherwise 2
{
// first argument is unused
if (gBattleMoves[move].effect == EFFECT_SOLAR_BEAM
@ -9440,13 +9440,13 @@ static void Cmd_tryimprison(void)
}
else
{
u8 battlerId, sideAttacker;
u8 battler, sideAttacker;
sideAttacker = GetBattlerSide(gBattlerAttacker);
PressurePPLoseOnUsingImprison(gBattlerAttacker);
for (battlerId = 0; battlerId < gBattlersCount; battlerId++)
for (battler = 0; battler < gBattlersCount; battler++)
{
if (sideAttacker != GetBattlerSide(battlerId))
if (sideAttacker != GetBattlerSide(battler))
{
s32 attackerMoveId;
for (attackerMoveId = 0; attackerMoveId < MAX_MON_MOVES; attackerMoveId++)
@ -9454,7 +9454,7 @@ static void Cmd_tryimprison(void)
s32 i;
for (i = 0; i < MAX_MON_MOVES; i++)
{
if (gBattleMons[gBattlerAttacker].moves[attackerMoveId] == gBattleMons[battlerId].moves[i]
if (gBattleMons[gBattlerAttacker].moves[attackerMoveId] == gBattleMons[battler].moves[i]
&& gBattleMons[gBattlerAttacker].moves[attackerMoveId] != MOVE_NONE)
break;
}
@ -9469,7 +9469,7 @@ static void Cmd_tryimprison(void)
}
}
}
if (battlerId == gBattlersCount) // In Generation 3 games, Imprison fails if the user doesn't share any moves with any of the foes
if (battler == gBattlersCount) // In Generation 3 games, Imprison fails if the user doesn't share any moves with any of the foes
gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1);
}
}

6
src/battle_tv.c
View File

@ -1568,12 +1568,12 @@ void BattleTv_ClearExplosionFaintCause(void)
}
}
u8 GetBattlerMoveSlotId(u8 battlerId, u16 moveId)
u8 GetBattlerMoveSlotId(u8 battler, u16 moveId)
{
s32 i;
struct Pokemon *party;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
party = gPlayerParty;
else
party = gEnemyParty;
@ -1583,7 +1583,7 @@ u8 GetBattlerMoveSlotId(u8 battlerId, u16 moveId)
{
if (i >= MAX_MON_MOVES)
break;
if (GetMonData(&party[gBattlerPartyIndexes[battlerId]], MON_DATA_MOVE1 + i, NULL) == moveId)
if (GetMonData(&party[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + i, NULL) == moveId)
break;
i++;
}

292
src/battle_util.c
View File

@ -851,27 +851,27 @@ static void UNUSED MarkAllBattlersForControllerExec(void)
// set a bit indicating that we're sending a message over the link. That
// message will be received by all other players... *and* by us, the player
// sending it, at which point we'll invoke MarkBattlerReceivedLinkData,
// below, to clear the "we're sending a message" bit and set the "controller
// below, to clear the "we're sending a message" bit and set the "controller
// is now active" bit.
void MarkBattlerForControllerExec(u8 battlerId)
void MarkBattlerForControllerExec(u8 battler)
{
if (gBattleTypeFlags & BATTLE_TYPE_LINK)
MARK_BATTLE_CONTROLLER_MESSAGE_OUTBOUND_OVER_LINK(battlerId);
MARK_BATTLE_CONTROLLER_MESSAGE_OUTBOUND_OVER_LINK(battler);
else
MARK_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battlerId);
MARK_BATTLE_CONTROLLER_ACTIVE_ON_LOCAL(battler);
}
// Called when a message dispatched from the battle engine to a battle
// Called when a message dispatched from the battle engine to a battle
// controller is received over link communications. All players assume
// that if they've received the message, everyone else has as well.
void MarkBattlerReceivedLinkData(u8 battlerId)
void MarkBattlerReceivedLinkData(u8 battler)
{
s32 i;
for (i = 0; i < GetLinkPlayerCount(); i++)
MARK_BATTLE_CONTROLLER_ACTIVE_FOR_PLAYER(battlerId, i);
MARK_BATTLE_CONTROLLER_ACTIVE_FOR_PLAYER(battler, i);
MARK_BATTLE_CONTROLLER_MESSAGE_SYNCHRONIZED_OVER_LINK(battlerId);
MARK_BATTLE_CONTROLLER_MESSAGE_SYNCHRONIZED_OVER_LINK(battler);
}
void CancelMultiTurnMoves(u8 battler)
@ -1079,44 +1079,44 @@ u8 TrySetCantSelectMoveBattleScript(void)
return limitations;
}
u8 CheckMoveLimitations(u8 battlerId, u8 unusableMoves, u8 check)
u8 CheckMoveLimitations(u8 battler, u8 unusableMoves, u8 check)
{
u8 holdEffect;
u16 *choicedMove = &gBattleStruct->choicedMove[battlerId];
u16 *choicedMove = &gBattleStruct->choicedMove[battler];
s32 i;
if (gBattleMons[battlerId].item == ITEM_ENIGMA_BERRY)
holdEffect = gEnigmaBerries[battlerId].holdEffect;
if (gBattleMons[battler].item == ITEM_ENIGMA_BERRY)
holdEffect = gEnigmaBerries[battler].holdEffect;
else
holdEffect = ItemId_GetHoldEffect(gBattleMons[battlerId].item);
holdEffect = ItemId_GetHoldEffect(gBattleMons[battler].item);
gPotentialItemEffectBattler = battlerId;
gPotentialItemEffectBattler = battler;
for (i = 0; i < MAX_MON_MOVES; i++)
{
// No move
if (gBattleMons[battlerId].moves[i] == MOVE_NONE && check & MOVE_LIMITATION_ZEROMOVE)
if (gBattleMons[battler].moves[i] == MOVE_NONE && check & MOVE_LIMITATION_ZEROMOVE)
unusableMoves |= gBitTable[i];
// No PP
if (gBattleMons[battlerId].pp[i] == 0 && check & MOVE_LIMITATION_PP)
if (gBattleMons[battler].pp[i] == 0 && check & MOVE_LIMITATION_PP)
unusableMoves |= gBitTable[i];
// Disable
if (gBattleMons[battlerId].moves[i] == gDisableStructs[battlerId].disabledMove && check & MOVE_LIMITATION_DISABLED)
if (gBattleMons[battler].moves[i] == gDisableStructs[battler].disabledMove && check & MOVE_LIMITATION_DISABLED)
unusableMoves |= gBitTable[i];
// Torment
if (gBattleMons[battlerId].moves[i] == gLastMoves[battlerId] && check & MOVE_LIMITATION_TORMENTED && gBattleMons[battlerId].status2 & STATUS2_TORMENT)
if (gBattleMons[battler].moves[i] == gLastMoves[battler] && check & MOVE_LIMITATION_TORMENTED && gBattleMons[battler].status2 & STATUS2_TORMENT)
unusableMoves |= gBitTable[i];
// Taunt
if (gDisableStructs[battlerId].tauntTimer && check & MOVE_LIMITATION_TAUNT && gBattleMoves[gBattleMons[battlerId].moves[i]].power == 0)
if (gDisableStructs[battler].tauntTimer && check & MOVE_LIMITATION_TAUNT && gBattleMoves[gBattleMons[battler].moves[i]].power == 0)
unusableMoves |= gBitTable[i];
// Imprison
if (GetImprisonedMovesCount(battlerId, gBattleMons[battlerId].moves[i]) && check & MOVE_LIMITATION_IMPRISON)
if (GetImprisonedMovesCount(battler, gBattleMons[battler].moves[i]) && check & MOVE_LIMITATION_IMPRISON)
unusableMoves |= gBitTable[i];
// Encore
if (gDisableStructs[battlerId].encoreTimer && gDisableStructs[battlerId].encoredMove != gBattleMons[battlerId].moves[i])
if (gDisableStructs[battler].encoreTimer && gDisableStructs[battler].encoredMove != gBattleMons[battler].moves[i])
unusableMoves |= gBitTable[i];
// Choice Band
if (holdEffect == HOLD_EFFECT_CHOICE_BAND && *choicedMove != MOVE_NONE && *choicedMove != MOVE_UNAVAILABLE && *choicedMove != gBattleMons[battlerId].moves[i])
if (holdEffect == HOLD_EFFECT_CHOICE_BAND && *choicedMove != MOVE_NONE && *choicedMove != MOVE_UNAVAILABLE && *choicedMove != gBattleMons[battler].moves[i])
unusableMoves |= gBitTable[i];
}
return unusableMoves;
@ -1139,11 +1139,11 @@ bool8 AreAllMovesUnusable(void)
return (unusable == ALL_MOVES_MASK);
}
u8 GetImprisonedMovesCount(u8 battlerId, u16 move)
u8 GetImprisonedMovesCount(u8 battler, u16 move)
{
s32 i;
u8 imprisonedMoves = 0;
u8 battlerSide = GetBattlerSide(battlerId);
u8 battlerSide = GetBattlerSide(battler);
for (i = 0; i < gBattlersCount; i++)
{
@ -3225,16 +3225,16 @@ enum
};
#define TRY_EAT_CONFUSE_BERRY(flavor) \
if (gBattleMons[battlerId].hp <= gBattleMons[battlerId].maxHP / 2 && !moveTurn) \
if (gBattleMons[battler].hp <= gBattleMons[battler].maxHP / 2 && !moveTurn) \
{ \
PREPARE_FLAVOR_BUFFER(gBattleTextBuff1, flavor); \
gBattleMoveDamage = gBattleMons[battlerId].maxHP / battlerHoldEffectParam; \
gBattleMoveDamage = gBattleMons[battler].maxHP / battlerHoldEffectParam; \
if (gBattleMoveDamage == 0) \
gBattleMoveDamage = 1; \
if (gBattleMons[battlerId].hp + gBattleMoveDamage > gBattleMons[battlerId].maxHP) \
gBattleMoveDamage = gBattleMons[battlerId].maxHP - gBattleMons[battlerId].hp; \
if (gBattleMons[battler].hp + gBattleMoveDamage > gBattleMons[battler].maxHP) \
gBattleMoveDamage = gBattleMons[battler].maxHP - gBattleMons[battler].hp; \
gBattleMoveDamage *= -1; \
if (GetFlavorRelationByPersonality(gBattleMons[battlerId].personality, flavor) < 0) \
if (GetFlavorRelationByPersonality(gBattleMons[battler].personality, flavor) < 0) \
BattleScriptExecute(BattleScript_BerryConfuseHealEnd2); \
else \
BattleScriptExecute(BattleScript_ItemHealHP_RemoveItem); \
@ -3242,11 +3242,11 @@ enum
}
#define TRY_EAT_STAT_UP_BERRY(stat) \
if (gBattleMons[battlerId].hp <= gBattleMons[battlerId].maxHP / battlerHoldEffectParam \
&& !moveTurn && gBattleMons[battlerId].statStages[stat] < MAX_STAT_STAGE) \
if (gBattleMons[battler].hp <= gBattleMons[battler].maxHP / battlerHoldEffectParam \
&& !moveTurn && gBattleMons[battler].statStages[stat] < MAX_STAT_STAGE) \
{ \
PREPARE_STAT_BUFFER(gBattleTextBuff1, stat); \
gEffectBattler = battlerId; \
gEffectBattler = battler; \
SET_STATCHANGER(stat, 1, FALSE); \
gBattleScripting.animArg1 = STAT_ANIM_PLUS1 + (stat); \
gBattleScripting.animArg2 = 0; \
@ -3254,7 +3254,7 @@ enum
effect = ITEM_STATS_CHANGE; \
}
u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
u8 ItemBattleEffects(u8 caseID, u8 battler, bool8 moveTurn)
{
int i = 0;
u8 effect = ITEM_NO_EFFECT;
@ -3263,11 +3263,11 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
u8 battlerHoldEffectParam, atkHoldEffectParam, UNUSED defHoldEffectParam;
u16 atkItem, defItem;
gLastUsedItem = gBattleMons[battlerId].item;
gLastUsedItem = gBattleMons[battler].item;
if (gLastUsedItem == ITEM_ENIGMA_BERRY)
{
battlerHoldEffect = gEnigmaBerries[battlerId].holdEffect;
battlerHoldEffectParam = gEnigmaBerries[battlerId].holdEffectParam;
battlerHoldEffect = gEnigmaBerries[battler].holdEffect;
battlerHoldEffectParam = gEnigmaBerries[battler].holdEffectParam;
}
else
{
@ -3306,39 +3306,39 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
switch (battlerHoldEffect)
{
case HOLD_EFFECT_DOUBLE_PRIZE:
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
gBattleStruct->moneyMultiplier = 2;
break;
case HOLD_EFFECT_RESTORE_STATS:
for (i = 0; i < NUM_BATTLE_STATS; i++)
{
if (gBattleMons[battlerId].statStages[i] < DEFAULT_STAT_STAGE)
if (gBattleMons[battler].statStages[i] < DEFAULT_STAT_STAGE)
{
gBattleMons[battlerId].statStages[i] = DEFAULT_STAT_STAGE;
gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE;
effect = ITEM_STATS_CHANGE;
}
}
if (effect != 0)
{
gBattleScripting.battler = battlerId;
gPotentialItemEffectBattler = battlerId;
gActiveBattler = gBattlerAttacker = battlerId;
gBattleScripting.battler = battler;
gPotentialItemEffectBattler = battler;
gActiveBattler = gBattlerAttacker = battler;
BattleScriptExecute(BattleScript_WhiteHerbEnd2);
}
break;
}
break;
case ITEMEFFECT_NORMAL:
if (gBattleMons[battlerId].hp)
if (gBattleMons[battler].hp)
{
switch (battlerHoldEffect)
{
case HOLD_EFFECT_RESTORE_HP:
if (gBattleMons[battlerId].hp <= gBattleMons[battlerId].maxHP / 2 && !moveTurn)
if (gBattleMons[battler].hp <= gBattleMons[battler].maxHP / 2 && !moveTurn)
{
gBattleMoveDamage = battlerHoldEffectParam;
if (gBattleMons[battlerId].hp + battlerHoldEffectParam > gBattleMons[battlerId].maxHP)
gBattleMoveDamage = gBattleMons[battlerId].maxHP - gBattleMons[battlerId].hp;
if (gBattleMons[battler].hp + battlerHoldEffectParam > gBattleMons[battler].maxHP)
gBattleMoveDamage = gBattleMons[battler].maxHP - gBattleMons[battler].hp;
gBattleMoveDamage *= -1;
BattleScriptExecute(BattleScript_ItemHealHP_RemoveItem);
effect = ITEM_HP_CHANGE;
@ -3351,10 +3351,10 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
u8 ppBonuses;
u16 move;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
mon = &gPlayerParty[gBattlerPartyIndexes[battlerId]];
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
mon = &gPlayerParty[gBattlerPartyIndexes[battler]];
else
mon = &gEnemyParty[gBattlerPartyIndexes[battlerId]];
mon = &gEnemyParty[gBattlerPartyIndexes[battler]];
for (i = 0; i < MAX_MON_MOVES; i++)
{
move = GetMonData(mon, MON_DATA_MOVE1 + i);
@ -3383,32 +3383,32 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
case HOLD_EFFECT_RESTORE_STATS:
for (i = 0; i < NUM_BATTLE_STATS; i++)
{
if (gBattleMons[battlerId].statStages[i] < DEFAULT_STAT_STAGE)
if (gBattleMons[battler].statStages[i] < DEFAULT_STAT_STAGE)
{
gBattleMons[battlerId].statStages[i] = DEFAULT_STAT_STAGE;
gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE;
effect = ITEM_STATS_CHANGE;
}
}
if (effect != 0)
{
gBattleScripting.battler = battlerId;
gPotentialItemEffectBattler = battlerId;
gActiveBattler = gBattlerAttacker = battlerId;
gBattleScripting.battler = battler;
gPotentialItemEffectBattler = battler;
gActiveBattler = gBattlerAttacker = battler;
BattleScriptExecute(BattleScript_WhiteHerbEnd2);
}
break;
case HOLD_EFFECT_LEFTOVERS:
if (gBattleMons[battlerId].hp < gBattleMons[battlerId].maxHP && !moveTurn)
if (gBattleMons[battler].hp < gBattleMons[battler].maxHP && !moveTurn)
{
gBattleMoveDamage = gBattleMons[battlerId].maxHP / 16;
gBattleMoveDamage = gBattleMons[battler].maxHP / 16;
if (gBattleMoveDamage == 0)
gBattleMoveDamage = 1;
if (gBattleMons[battlerId].hp + gBattleMoveDamage > gBattleMons[battlerId].maxHP)
gBattleMoveDamage = gBattleMons[battlerId].maxHP - gBattleMons[battlerId].hp;
if (gBattleMons[battler].hp + gBattleMoveDamage > gBattleMons[battler].maxHP)
gBattleMoveDamage = gBattleMons[battler].maxHP - gBattleMons[battler].hp;
gBattleMoveDamage *= -1;
BattleScriptExecute(BattleScript_ItemHealHP_End2);
effect = ITEM_HP_CHANGE;
RecordItemEffectBattle(battlerId, battlerHoldEffect);
RecordItemEffectBattle(battler, battlerHoldEffect);
}
break;
case HOLD_EFFECT_CONFUSE_SPICY:
@ -3427,12 +3427,12 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
TRY_EAT_CONFUSE_BERRY(FLAVOR_SOUR);
break;
case HOLD_EFFECT_ATTACK_UP:
if (gBattleMons[battlerId].hp <= gBattleMons[battlerId].maxHP / battlerHoldEffectParam
&& !moveTurn && gBattleMons[battlerId].statStages[STAT_ATK] < MAX_STAT_STAGE)
if (gBattleMons[battler].hp <= gBattleMons[battler].maxHP / battlerHoldEffectParam
&& !moveTurn && gBattleMons[battler].statStages[STAT_ATK] < MAX_STAT_STAGE)
{
PREPARE_STAT_BUFFER(gBattleTextBuff1, STAT_ATK);
PREPARE_STRING_BUFFER(gBattleTextBuff2, STRINGID_STATROSE); // Only the Attack stat-up berry has this
gEffectBattler = battlerId;
gEffectBattler = battler;
SET_STATCHANGER(STAT_ATK, 1, FALSE);
gBattleScripting.animArg1 = STAT_ANIM_PLUS1 + STAT_ATK;
gBattleScripting.animArg2 = 0;
@ -3453,20 +3453,20 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
TRY_EAT_STAT_UP_BERRY(STAT_SPDEF);
break;
case HOLD_EFFECT_CRITICAL_UP:
if (gBattleMons[battlerId].hp <= gBattleMons[battlerId].maxHP / battlerHoldEffectParam && !moveTurn
&& !(gBattleMons[battlerId].status2 & STATUS2_FOCUS_ENERGY))
if (gBattleMons[battler].hp <= gBattleMons[battler].maxHP / battlerHoldEffectParam && !moveTurn
&& !(gBattleMons[battler].status2 & STATUS2_FOCUS_ENERGY))
{
gBattleMons[battlerId].status2 |= STATUS2_FOCUS_ENERGY;
gBattleMons[battler].status2 |= STATUS2_FOCUS_ENERGY;
BattleScriptExecute(BattleScript_BerryFocusEnergyEnd2);
effect = ITEM_EFFECT_OTHER;
}
break;
case HOLD_EFFECT_RANDOM_STAT_UP:
if (!moveTurn && gBattleMons[battlerId].hp <= gBattleMons[battlerId].maxHP / battlerHoldEffectParam)
if (!moveTurn && gBattleMons[battler].hp <= gBattleMons[battler].maxHP / battlerHoldEffectParam)
{
for (i = 0; i < NUM_STATS - 1; i++)
{
if (gBattleMons[battlerId].statStages[STAT_ATK + i] < MAX_STAT_STAGE)
if (gBattleMons[battler].statStages[STAT_ATK + i] < MAX_STAT_STAGE)
break;
}
if (i != NUM_STATS - 1)
@ -3474,7 +3474,7 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
do
{
i = Random() % (NUM_STATS - 1);
} while (gBattleMons[battlerId].statStages[STAT_ATK + i] == MAX_STAT_STAGE);
} while (gBattleMons[battler].statStages[STAT_ATK + i] == MAX_STAT_STAGE);
PREPARE_STAT_BUFFER(gBattleTextBuff1, i + 1);
@ -3487,7 +3487,7 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
gBattleTextBuff2[6] = STRINGID_STATROSE >> 8;
gBattleTextBuff2[7] = EOS;
gEffectBattler = battlerId;
gEffectBattler = battler;
SET_STATCHANGER(i + 1, 2, FALSE);
gBattleScripting.animArg1 = STAT_ANIM_PLUS2 + (i + 1);
gBattleScripting.animArg2 = 0;
@ -3497,85 +3497,85 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
}
break;
case HOLD_EFFECT_CURE_PAR:
if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS)
if (gBattleMons[battler].status1 & STATUS1_PARALYSIS)
{
gBattleMons[battlerId].status1 &= ~STATUS1_PARALYSIS;
gBattleMons[battler].status1 &= ~STATUS1_PARALYSIS;
BattleScriptExecute(BattleScript_BerryCurePrlzEnd2);
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_PSN:
if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY)
if (gBattleMons[battler].status1 & STATUS1_PSN_ANY)
{
gBattleMons[battlerId].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER);
gBattleMons[battler].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER);
BattleScriptExecute(BattleScript_BerryCurePsnEnd2);
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_BRN:
if (gBattleMons[battlerId].status1 & STATUS1_BURN)
if (gBattleMons[battler].status1 & STATUS1_BURN)
{
gBattleMons[battlerId].status1 &= ~STATUS1_BURN;
gBattleMons[battler].status1 &= ~STATUS1_BURN;
BattleScriptExecute(BattleScript_BerryCureBrnEnd2);
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_FRZ:
if (gBattleMons[battlerId].status1 & STATUS1_FREEZE)
if (gBattleMons[battler].status1 & STATUS1_FREEZE)
{
gBattleMons[battlerId].status1 &= ~STATUS1_FREEZE;
gBattleMons[battler].status1 &= ~STATUS1_FREEZE;
BattleScriptExecute(BattleScript_BerryCureFrzEnd2);
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_SLP:
if (gBattleMons[battlerId].status1 & STATUS1_SLEEP)
if (gBattleMons[battler].status1 & STATUS1_SLEEP)
{
gBattleMons[battlerId].status1 &= ~STATUS1_SLEEP;
gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE;
gBattleMons[battler].status1 &= ~STATUS1_SLEEP;
gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE;
BattleScriptExecute(BattleScript_BerryCureSlpEnd2);
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_CONFUSION:
if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION)
if (gBattleMons[battler].status2 & STATUS2_CONFUSION)
{
gBattleMons[battlerId].status2 &= ~STATUS2_CONFUSION;
gBattleMons[battler].status2 &= ~STATUS2_CONFUSION;
BattleScriptExecute(BattleScript_BerryCureConfusionEnd2);
effect = ITEM_EFFECT_OTHER;
}
break;
case HOLD_EFFECT_CURE_STATUS:
if (gBattleMons[battlerId].status1 & STATUS1_ANY || gBattleMons[battlerId].status2 & STATUS2_CONFUSION)
if (gBattleMons[battler].status1 & STATUS1_ANY || gBattleMons[battler].status2 & STATUS2_CONFUSION)
{
i = 0;
if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY)
if (gBattleMons[battler].status1 & STATUS1_PSN_ANY)
{
StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn);
i++;
}
if (gBattleMons[battlerId].status1 & STATUS1_SLEEP)
if (gBattleMons[battler].status1 & STATUS1_SLEEP)
{
gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE;
gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE;
StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn);
i++;
}
if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS)
if (gBattleMons[battler].status1 & STATUS1_PARALYSIS)
{
StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn);
i++;
}
if (gBattleMons[battlerId].status1 & STATUS1_BURN)
if (gBattleMons[battler].status1 & STATUS1_BURN)
{
StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn);
i++;
}
if (gBattleMons[battlerId].status1 & STATUS1_FREEZE)
if (gBattleMons[battler].status1 & STATUS1_FREEZE)
{
StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn);
i++;
}
if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION)
if (gBattleMons[battler].status2 & STATUS2_CONFUSION)
{
StringCopy(gBattleTextBuff1, gStatusConditionString_ConfusionJpn);
i++;
@ -3584,16 +3584,16 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_CURED_PROBLEM;
else
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_NORMALIZED_STATUS;
gBattleMons[battlerId].status1 = 0;
gBattleMons[battlerId].status2 &= ~STATUS2_CONFUSION;
gBattleMons[battler].status1 = 0;
gBattleMons[battler].status2 &= ~STATUS2_CONFUSION;
BattleScriptExecute(BattleScript_BerryCureChosenStatusEnd2);
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_ATTRACT:
if (gBattleMons[battlerId].status2 & STATUS2_INFATUATION)
if (gBattleMons[battler].status2 & STATUS2_INFATUATION)
{
gBattleMons[battlerId].status2 &= ~STATUS2_INFATUATION;
gBattleMons[battler].status2 &= ~STATUS2_INFATUATION;
StringCopy(gBattleTextBuff1, gStatusConditionString_LoveJpn);
BattleScriptExecute(BattleScript_BerryCureChosenStatusEnd2);
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_CURED_PROBLEM;
@ -3603,18 +3603,18 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
}
if (effect != 0)
{
gBattleScripting.battler = battlerId;
gPotentialItemEffectBattler = battlerId;
gActiveBattler = gBattlerAttacker = battlerId;
gBattleScripting.battler = battler;
gPotentialItemEffectBattler = battler;
gActiveBattler = gBattlerAttacker = battler;
switch (effect)
{
case ITEM_STATUS_CHANGE:
BtlController_EmitSetMonData(B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battlerId].status1);
BtlController_EmitSetMonData(B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1);
MarkBattlerForControllerExec(gActiveBattler);
break;
case ITEM_PP_CHANGE:
if (MOVE_IS_PERMANENT(battlerId, i))
gBattleMons[battlerId].pp[i] = changedPP;
if (MOVE_IS_PERMANENT(battler, i))
gBattleMons[battler].pp[i] = changedPP;
break;
}
}
@ -3623,13 +3623,13 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
case ITEMEFFECT_DUMMY:
break;
case ITEMEFFECT_MOVE_END:
for (battlerId = 0; battlerId < gBattlersCount; battlerId++)
for (battler = 0; battler < gBattlersCount; battler++)
{
gLastUsedItem = gBattleMons[battlerId].item;
if (gBattleMons[battlerId].item == ITEM_ENIGMA_BERRY)
gLastUsedItem = gBattleMons[battler].item;
if (gBattleMons[battler].item == ITEM_ENIGMA_BERRY)
{
battlerHoldEffect = gEnigmaBerries[battlerId].holdEffect;
battlerHoldEffectParam = gEnigmaBerries[battlerId].holdEffectParam;
battlerHoldEffect = gEnigmaBerries[battler].holdEffect;
battlerHoldEffectParam = gEnigmaBerries[battler].holdEffectParam;
}
else
{
@ -3639,64 +3639,64 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
switch (battlerHoldEffect)
{
case HOLD_EFFECT_CURE_PAR:
if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS)
if (gBattleMons[battler].status1 & STATUS1_PARALYSIS)
{
gBattleMons[battlerId].status1 &= ~STATUS1_PARALYSIS;
gBattleMons[battler].status1 &= ~STATUS1_PARALYSIS;
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_BerryCureParRet;
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_PSN:
if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY)
if (gBattleMons[battler].status1 & STATUS1_PSN_ANY)
{
gBattleMons[battlerId].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER);
gBattleMons[battler].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER);
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_BerryCurePsnRet;
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_BRN:
if (gBattleMons[battlerId].status1 & STATUS1_BURN)
if (gBattleMons[battler].status1 & STATUS1_BURN)
{
gBattleMons[battlerId].status1 &= ~STATUS1_BURN;
gBattleMons[battler].status1 &= ~STATUS1_BURN;
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_BerryCureBrnRet;
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_FRZ:
if (gBattleMons[battlerId].status1 & STATUS1_FREEZE)
if (gBattleMons[battler].status1 & STATUS1_FREEZE)
{
gBattleMons[battlerId].status1 &= ~STATUS1_FREEZE;
gBattleMons[battler].status1 &= ~STATUS1_FREEZE;
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_BerryCureFrzRet;
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_SLP:
if (gBattleMons[battlerId].status1 & STATUS1_SLEEP)
if (gBattleMons[battler].status1 & STATUS1_SLEEP)
{
gBattleMons[battlerId].status1 &= ~STATUS1_SLEEP;
gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE;
gBattleMons[battler].status1 &= ~STATUS1_SLEEP;
gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE;
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_BerryCureSlpRet;
effect = ITEM_STATUS_CHANGE;
}
break;
case HOLD_EFFECT_CURE_CONFUSION:
if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION)
if (gBattleMons[battler].status2 & STATUS2_CONFUSION)
{
gBattleMons[battlerId].status2 &= ~STATUS2_CONFUSION;
gBattleMons[battler].status2 &= ~STATUS2_CONFUSION;
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_BerryCureConfusionRet;
effect = ITEM_EFFECT_OTHER;
}
break;
case HOLD_EFFECT_CURE_ATTRACT:
if (gBattleMons[battlerId].status2 & STATUS2_INFATUATION)
if (gBattleMons[battler].status2 & STATUS2_INFATUATION)
{
gBattleMons[battlerId].status2 &= ~STATUS2_INFATUATION;
gBattleMons[battler].status2 &= ~STATUS2_INFATUATION;
StringCopy(gBattleTextBuff1, gStatusConditionString_LoveJpn);
BattleScriptPushCursor();
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_CURED_PROBLEM;
@ -3705,31 +3705,31 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
}
break;
case HOLD_EFFECT_CURE_STATUS:
if (gBattleMons[battlerId].status1 & STATUS1_ANY || gBattleMons[battlerId].status2 & STATUS2_CONFUSION)
if (gBattleMons[battler].status1 & STATUS1_ANY || gBattleMons[battler].status2 & STATUS2_CONFUSION)
{
if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY)
if (gBattleMons[battler].status1 & STATUS1_PSN_ANY)
StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn);
if (gBattleMons[battlerId].status1 & STATUS1_SLEEP)
if (gBattleMons[battler].status1 & STATUS1_SLEEP)
{
gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE;
gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE;
StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn);
}
if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS)
if (gBattleMons[battler].status1 & STATUS1_PARALYSIS)
StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn);
if (gBattleMons[battlerId].status1 & STATUS1_BURN)
if (gBattleMons[battler].status1 & STATUS1_BURN)
StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn);
if (gBattleMons[battlerId].status1 & STATUS1_FREEZE)
if (gBattleMons[battler].status1 & STATUS1_FREEZE)
StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn);
if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION)
if (gBattleMons[battler].status2 & STATUS2_CONFUSION)
StringCopy(gBattleTextBuff1, gStatusConditionString_ConfusionJpn);
gBattleMons[battlerId].status1 = 0;
gBattleMons[battlerId].status2 &= ~STATUS2_CONFUSION;
gBattleMons[battler].status1 = 0;
gBattleMons[battler].status2 &= ~STATUS2_CONFUSION;
BattleScriptPushCursor();
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_CURED_PROBLEM;
gBattlescriptCurrInstr = BattleScript_BerryCureChosenStatusRet;
@ -3739,16 +3739,16 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
case HOLD_EFFECT_RESTORE_STATS:
for (i = 0; i < NUM_BATTLE_STATS; i++)
{
if (gBattleMons[battlerId].statStages[i] < DEFAULT_STAT_STAGE)
if (gBattleMons[battler].statStages[i] < DEFAULT_STAT_STAGE)
{
gBattleMons[battlerId].statStages[i] = DEFAULT_STAT_STAGE;
gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE;
effect = ITEM_STATS_CHANGE;
}
}
if (effect != 0)
{
gBattleScripting.battler = battlerId;
gPotentialItemEffectBattler = battlerId;
gBattleScripting.battler = battler;
gPotentialItemEffectBattler = battler;
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_WhiteHerbRet;
return effect;
@ -3757,9 +3757,9 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
}
if (effect != 0)
{
gBattleScripting.battler = battlerId;
gPotentialItemEffectBattler = battlerId;
gActiveBattler = battlerId;
gBattleScripting.battler = battler;
gPotentialItemEffectBattler = battler;
gActiveBattler = battler;
BtlController_EmitSetMonData(B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1);
MarkBattlerForControllerExec(gActiveBattler);
break;
@ -3812,11 +3812,11 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn)
return effect;
}
void ClearFuryCutterDestinyBondGrudge(u8 battlerId)
void ClearFuryCutterDestinyBondGrudge(u8 battler)
{
gDisableStructs[battlerId].furyCutterCounter = 0;
gBattleMons[battlerId].status2 &= ~STATUS2_DESTINY_BOND;
gStatuses3[battlerId] &= ~STATUS3_GRUDGE;
gDisableStructs[battler].furyCutterCounter = 0;
gBattleMons[battler].status2 &= ~STATUS2_DESTINY_BOND;
gStatuses3[battler] &= ~STATUS3_GRUDGE;
}
void HandleAction_RunBattleScript(void) // identical to RunBattleScriptCommands
@ -3910,14 +3910,14 @@ u8 GetMoveTarget(u16 move, u8 setTarget)
return targetBattler;
}
static bool32 IsBattlerModernFatefulEncounter(u8 battlerId)
static bool32 IsBattlerModernFatefulEncounter(u8 battler)
{
if (GetBattlerSide(battlerId) == B_SIDE_OPPONENT)
if (GetBattlerSide(battler) == B_SIDE_OPPONENT)
return TRUE;
if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES, NULL) != SPECIES_DEOXYS
&& GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES, NULL) != SPECIES_MEW)
if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES, NULL) != SPECIES_DEOXYS
&& GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES, NULL) != SPECIES_MEW)
return TRUE;
return GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_MODERN_FATEFUL_ENCOUNTER, NULL);
return GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MODERN_FATEFUL_ENCOUNTER, NULL);
}
u8 IsMonDisobedient(void)

46
src/battle_util2.c
View File

@ -71,7 +71,7 @@ void FreeBattleResources(void)
}
}
void AdjustFriendshipOnBattleFaint(u8 battlerId)
void AdjustFriendshipOnBattleFaint(u8 battler)
{
u8 opposingBattlerId;
@ -90,28 +90,28 @@ void AdjustFriendshipOnBattleFaint(u8 battlerId)
opposingBattlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT);
}
if (gBattleMons[opposingBattlerId].level > gBattleMons[battlerId].level)
if (gBattleMons[opposingBattlerId].level > gBattleMons[battler].level)
{
if (gBattleMons[opposingBattlerId].level - gBattleMons[battlerId].level > 29)
AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battlerId]], FRIENDSHIP_EVENT_FAINT_LARGE);
if (gBattleMons[opposingBattlerId].level - gBattleMons[battler].level > 29)
AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battler]], FRIENDSHIP_EVENT_FAINT_LARGE);
else
AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battlerId]], FRIENDSHIP_EVENT_FAINT_SMALL);
AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battler]], FRIENDSHIP_EVENT_FAINT_SMALL);
}
else
{
AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battlerId]], FRIENDSHIP_EVENT_FAINT_SMALL);
AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battler]], FRIENDSHIP_EVENT_FAINT_SMALL);
}
}
void SwitchPartyOrderInGameMulti(u8 battlerId, u8 arg1)
void SwitchPartyOrderInGameMulti(u8 battler, u8 arg1)
{
if (GetBattlerSide(battlerId) != B_SIDE_OPPONENT)
if (GetBattlerSide(battler) != B_SIDE_OPPONENT)
{
s32 i;
for (i = 0; i < (int)ARRAY_COUNT(gBattlePartyCurrentOrder); i++)
gBattlePartyCurrentOrder[i] = *(i + (u8 *)(gBattleStruct->battlerPartyOrders));
SwitchPartyMonSlots(GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[battlerId]), GetPartyIdFromBattlePartyId(arg1));
SwitchPartyMonSlots(GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[battler]), GetPartyIdFromBattlePartyId(arg1));
for (i = 0; i < (int)ARRAY_COUNT(gBattlePartyCurrentOrder); i++)
*(i + (u8 *)(gBattleStruct->battlerPartyOrders)) = gBattlePartyCurrentOrder[i];
@ -120,7 +120,7 @@ void SwitchPartyOrderInGameMulti(u8 battlerId, u8 arg1)
// Called when a Pokémon is unable to attack during a Battle Palace battle.
// Check if it was because they are frozen/asleep, and if so try to cure the status.
u32 BattlePalace_TryEscapeStatus(u8 battlerId)
u32 BattlePalace_TryEscapeStatus(u8 battler)
{
u32 effect = 0;
@ -129,13 +129,13 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId)
switch (gBattleCommunication[MULTIUSE_STATE])
{
case 0:
if (gBattleMons[battlerId].status1 & STATUS1_SLEEP)
if (gBattleMons[battler].status1 & STATUS1_SLEEP)
{
if (UproarWakeUpCheck(battlerId))
if (UproarWakeUpCheck(battler))
{
// Wake up from Uproar
gBattleMons[battlerId].status1 &= ~(STATUS1_SLEEP);
gBattleMons[battlerId].status2 &= ~(STATUS2_NIGHTMARE);
gBattleMons[battler].status1 &= ~(STATUS1_SLEEP);
gBattleMons[battler].status2 &= ~(STATUS2_NIGHTMARE);
BattleScriptPushCursor();
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_WOKE_UP_UPROAR;
gBattlescriptCurrInstr = BattleScript_MoveUsedWokeUp;
@ -145,18 +145,18 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId)
{
u32 toSub;
if (gBattleMons[battlerId].ability == ABILITY_EARLY_BIRD)
if (gBattleMons[battler].ability == ABILITY_EARLY_BIRD)
toSub = 2;
else
toSub = 1;
// Reduce number of sleep turns
if ((gBattleMons[battlerId].status1 & STATUS1_SLEEP) < toSub)
gBattleMons[battlerId].status1 &= ~(STATUS1_SLEEP);
if ((gBattleMons[battler].status1 & STATUS1_SLEEP) < toSub)
gBattleMons[battler].status1 &= ~(STATUS1_SLEEP);
else
gBattleMons[battlerId].status1 -= toSub;
gBattleMons[battler].status1 -= toSub;
if (gBattleMons[battlerId].status1 & STATUS1_SLEEP)
if (gBattleMons[battler].status1 & STATUS1_SLEEP)
{
// Still asleep
gBattlescriptCurrInstr = BattleScript_MoveUsedIsAsleep;
@ -165,7 +165,7 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId)
else
{
// Wake up
gBattleMons[battlerId].status2 &= ~(STATUS2_NIGHTMARE);
gBattleMons[battler].status2 &= ~(STATUS2_NIGHTMARE);
BattleScriptPushCursor();
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_WOKE_UP;
gBattlescriptCurrInstr = BattleScript_MoveUsedWokeUp;
@ -176,7 +176,7 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId)
gBattleCommunication[MULTIUSE_STATE]++;
break;
case 1:
if (gBattleMons[battlerId].status1 & STATUS1_FREEZE)
if (gBattleMons[battler].status1 & STATUS1_FREEZE)
{
if (Random() % 5 != 0)
{
@ -186,7 +186,7 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId)
else
{
// Unfreeze
gBattleMons[battlerId].status1 &= ~(STATUS1_FREEZE);
gBattleMons[battler].status1 &= ~(STATUS1_FREEZE);
BattleScriptPushCursor();
gBattlescriptCurrInstr = BattleScript_MoveUsedUnfroze;
gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_DEFROSTED;
@ -203,7 +203,7 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId)
if (effect == 2)
{
gActiveBattler = battlerId;
gActiveBattler = battler;
BtlController_EmitSetMonData(B_COMM_TO_CONTROLLER, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1);
MarkBattlerForControllerExec(gActiveBattler);
}

1
src/data/map_group_count.h Normal file
View File

@ -0,0 +1 @@
static const u8 MAP_GROUP_COUNT[] = {57, 5, 5, 6, 7, 8, 9, 7, 7, 14, 8, 17, 10, 23, 13, 15, 15, 2, 2, 2, 3, 1, 1, 1, 108, 61, 89, 2, 1, 13, 1, 1, 3, 1, 0};

14
src/party_menu.c
View File

@ -5915,20 +5915,20 @@ static void BufferBattlePartyOrder(u8 *partyBattleOrder, u8 flankId)
partyBattleOrder[i] = (partyIds[0 + (i * 2)] << 4) | partyIds[1 + (i * 2)];
}
void BufferBattlePartyCurrentOrderBySide(u8 battlerId, u8 flankId)
void BufferBattlePartyCurrentOrderBySide(u8 battler, u8 flankId)
{
BufferBattlePartyOrderBySide(gBattleStruct->battlerPartyOrders[battlerId], flankId, battlerId);
BufferBattlePartyOrderBySide(gBattleStruct->battlerPartyOrders[battler], flankId, battler);
}
// when GetBattlerSide(battlerId) == B_SIDE_PLAYER, this function is identical the one above
static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battlerId)
// when GetBattlerSide(battler) == B_SIDE_PLAYER, this function is identical the one above
static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battler)
{
u8 partyIndexes[PARTY_SIZE];
int i, j;
u8 leftBattler;
u8 rightBattler;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
{
leftBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT);
rightBattler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT);
@ -5987,7 +5987,7 @@ static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 ba
partyBattleOrder[i] = (partyIndexes[0 + (i * 2)] << 4) | partyIndexes[1 + (i * 2)];
}
void SwitchPartyOrderLinkMulti(u8 battlerId, u8 slot, u8 slot2)
void SwitchPartyOrderLinkMulti(u8 battler, u8 slot, u8 slot2)
{
u8 partyIds[PARTY_SIZE];
u8 tempSlot = 0;
@ -5997,7 +5997,7 @@ void SwitchPartyOrderLinkMulti(u8 battlerId, u8 slot, u8 slot2)
if (IsMultiBattle())
{
partyBattleOrder = gBattleStruct->battlerPartyOrders[battlerId];
partyBattleOrder = gBattleStruct->battlerPartyOrders[battler];
for (i = j = 0; i < PARTY_SIZE / 2; j++, i++)
{
partyIds[j] = partyBattleOrder[i] >> 4;

86
src/pokeball.c
View File

@ -40,7 +40,7 @@ static void SpriteCB_TradePokeballEnd(struct Sprite *sprite);
static void SpriteCB_HealthboxSlideInDelayed(struct Sprite *sprite);
static void SpriteCB_HealthboxSlideIn(struct Sprite *sprite);
static void SpriteCB_HitAnimHealthoxEffect(struct Sprite *sprite);
static u16 GetBattlerPokeballItemId(u8 battlerId);
static u16 GetBattlerPokeballItemId(u8 battler);
// rom const data
@ -352,7 +352,7 @@ u8 DoPokeballSendOutAnimation(s16 pan, u8 kindOfThrow)
static void Task_DoPokeballSendOutAnim(u8 taskId)
{
u16 throwCaseId;
u8 battlerId;
u8 battler;
u16 itemId, ballId;
u8 ballSpriteId;
bool8 notSendOut = FALSE;
@ -364,12 +364,12 @@ static void Task_DoPokeballSendOutAnim(u8 taskId)
}
throwCaseId = gTasks[taskId].tThrowId;
battlerId = gTasks[taskId].tBattler;
battler = gTasks[taskId].tBattler;
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
itemId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_POKEBALL);
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
itemId = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_POKEBALL);
else
itemId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_POKEBALL);
itemId = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_POKEBALL);
ballId = ItemIdToBallId(itemId);
LoadBallGfx(ballId);
@ -381,15 +381,15 @@ static void Task_DoPokeballSendOutAnim(u8 taskId)
switch (throwCaseId)
{
case POKEBALL_PLAYER_SENDOUT:
gBattlerTarget = battlerId;
gBattlerTarget = battler;
gSprites[ballSpriteId].x = 24;
gSprites[ballSpriteId].y = 68;
gSprites[ballSpriteId].callback = SpriteCB_PlayerMonSendOut_1;
break;
case POKEBALL_OPPONENT_SENDOUT:
gSprites[ballSpriteId].x = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X);
gSprites[ballSpriteId].y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 24;
gBattlerTarget = battlerId;
gSprites[ballSpriteId].x = GetBattlerSpriteCoord(battler, BATTLER_COORD_X);
gSprites[ballSpriteId].y = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y) + 24;
gBattlerTarget = battler;
gSprites[ballSpriteId].data[0] = 0;
gSprites[ballSpriteId].callback = SpriteCB_OpponentMonSendOut;
break;
@ -667,7 +667,7 @@ static void Task_PlayCryWhenReleasedFromBall(u8 taskId)
u8 wantedCry = gTasks[taskId].tCryTaskWantedCry;
s8 pan = gTasks[taskId].tCryTaskPan;
u16 species = gTasks[taskId].tCryTaskSpecies;
u8 battlerId = gTasks[taskId].tCryTaskBattler;
u8 battler = gTasks[taskId].tCryTaskBattler;
u8 monSpriteId = gTasks[taskId].tCryTaskMonSpriteId;
struct Pokemon *mon = (void *)(u32)((gTasks[taskId].tCryTaskMonPtr1 << 16) | (u16)(gTasks[taskId].tCryTaskMonPtr2));
@ -684,7 +684,7 @@ static void Task_PlayCryWhenReleasedFromBall(u8 taskId)
PlayCry_ByMode(species, pan, CRY_MODE_NORMAL);
else
PlayCry_ByMode(species, pan, CRY_MODE_WEAK);
gBattleSpritesDataPtr->healthBoxesData[battlerId].waitForCry = FALSE;
gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry = FALSE;
DestroyTask(taskId);
break;
case 2:
@ -701,7 +701,7 @@ static void Task_PlayCryWhenReleasedFromBall(u8 taskId)
else
PlayCry_ReleaseDouble(species, pan, CRY_MODE_WEAK_DOUBLES);
gBattleSpritesDataPtr->healthBoxesData[battlerId].waitForCry = FALSE;
gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry = FALSE;
DestroyTask(taskId);
}
else
@ -741,7 +741,7 @@ static void Task_PlayCryWhenReleasedFromBall(u8 taskId)
else
PlayCry_ReleaseDouble(species, pan, CRY_MODE_WEAK);
gBattleSpritesDataPtr->healthBoxesData[battlerId].waitForCry = FALSE;
gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry = FALSE;
DestroyTask(taskId);
break;
}
@ -749,11 +749,11 @@ static void Task_PlayCryWhenReleasedFromBall(u8 taskId)
static void SpriteCB_ReleaseMonFromBall(struct Sprite *sprite)
{
u8 battlerId = sprite->sBattler;
u8 battler = sprite->sBattler;
u32 ballId;
StartSpriteAnim(sprite, 1);
ballId = ItemIdToBallId(GetBattlerPokeballItemId(battlerId));
ballId = ItemIdToBallId(GetBattlerPokeballItemId(battler));
AnimateBallOpenParticles(sprite->x, sprite->y - 5, 1, 28, ballId);
sprite->data[0] = LaunchBallFadeMonTask(TRUE, sprite->sBattler, 14, ballId);
sprite->callback = HandleBallAnimEnd;
@ -766,19 +766,19 @@ static void SpriteCB_ReleaseMonFromBall(struct Sprite *sprite)
u16 wantedCryCase;
u8 taskId;
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
{
mon = &gEnemyParty[gBattlerPartyIndexes[battlerId]];
mon = &gEnemyParty[gBattlerPartyIndexes[battler]];
pan = 25;
}
else
{
mon = &gPlayerParty[gBattlerPartyIndexes[battlerId]];
mon = &gPlayerParty[gBattlerPartyIndexes[battler]];
pan = -25;
}
species = GetMonData(mon, MON_DATA_SPECIES);
if ((battlerId == GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) || battlerId == GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))
if ((battler == GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) || battler == GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))
&& IsDoubleBattle() && gBattleSpritesDataPtr->animationData->introAnimActive)
{
if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK)
@ -794,18 +794,18 @@ static void SpriteCB_ReleaseMonFromBall(struct Sprite *sprite)
if (!IsDoubleBattle() || !gBattleSpritesDataPtr->animationData->introAnimActive)
wantedCryCase = 0;
else if (battlerId == GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) || battlerId == GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))
else if (battler == GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) || battler == GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))
wantedCryCase = 1;
else
wantedCryCase = 2;
gBattleSpritesDataPtr->healthBoxesData[battlerId].waitForCry = TRUE;
gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry = TRUE;
taskId = CreateTask(Task_PlayCryWhenReleasedFromBall, 3);
gTasks[taskId].tCryTaskSpecies = species;
gTasks[taskId].tCryTaskPan = pan;
gTasks[taskId].tCryTaskWantedCry = wantedCryCase;
gTasks[taskId].tCryTaskBattler = battlerId;
gTasks[taskId].tCryTaskBattler = battler;
gTasks[taskId].tCryTaskMonSpriteId = gBattlerSpriteIds[sprite->sBattler];
gTasks[taskId].tCryTaskMonPtr1 = (u32)(mon) >> 16;
gTasks[taskId].tCryTaskMonPtr2 = (u32)(mon);
@ -845,28 +845,28 @@ static void SpriteCB_BallThrow_StartCaptureMon(struct Sprite *sprite)
static void HandleBallAnimEnd(struct Sprite *sprite)
{
bool8 affineAnimEnded = FALSE;
u8 battlerId = sprite->sBattler;
u8 battler = sprite->sBattler;
gSprites[gBattlerSpriteIds[battlerId]].invisible = FALSE;
gSprites[gBattlerSpriteIds[battler]].invisible = FALSE;
if (sprite->animEnded)
sprite->invisible = TRUE;
if (gSprites[gBattlerSpriteIds[battlerId]].affineAnimEnded)
if (gSprites[gBattlerSpriteIds[battler]].affineAnimEnded)
{
StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[battlerId]], BATTLER_AFFINE_NORMAL);
StartSpriteAffineAnim(&gSprites[gBattlerSpriteIds[battler]], BATTLER_AFFINE_NORMAL);
affineAnimEnded = TRUE;
}
else
{
gSprites[gBattlerSpriteIds[battlerId]].data[1] -= 288;
gSprites[gBattlerSpriteIds[battlerId]].y2 = gSprites[gBattlerSpriteIds[battlerId]].data[1] >> 8;
gSprites[gBattlerSpriteIds[battler]].data[1] -= 288;
gSprites[gBattlerSpriteIds[battler]].y2 = gSprites[gBattlerSpriteIds[battler]].data[1] >> 8;
}
if (sprite->animEnded && affineAnimEnded)
{
s32 i, doneBattlers;
gSprites[gBattlerSpriteIds[battlerId]].y2 = 0;
gSprites[gBattlerSpriteIds[battler]].y2 = 0;
gDoingBattleAnim = FALSE;
gBattleSpritesDataPtr->healthBoxesData[battlerId].ballAnimActive = FALSE;
gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive = FALSE;
FreeSpriteOamMatrix(sprite);
DestroySprite(sprite);
@ -885,7 +885,7 @@ static void HandleBallAnimEnd(struct Sprite *sprite)
static void SpriteCB_BallThrow_CaptureMon(struct Sprite *sprite)
{
u8 battlerId = sprite->sBattler;
u8 battler = sprite->sBattler;
sprite->data[4]++;
if (sprite->data[4] == 40)
@ -904,7 +904,7 @@ static void SpriteCB_BallThrow_CaptureMon(struct Sprite *sprite)
DestroySprite(&gSprites[gBattlerSpriteIds[sprite->sBattler]]);
DestroySpriteAndFreeResources(sprite);
if (gMain.inBattle)
gBattleSpritesDataPtr->healthBoxesData[battlerId].ballAnimActive = FALSE;
gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive = FALSE;
}
}
@ -1238,16 +1238,16 @@ static void UNUSED DestroySpriteAndFreeResources_Ball(struct Sprite *sprite)
#define sDelayTimer data[1]
void StartHealthboxSlideIn(u8 battlerId)
void StartHealthboxSlideIn(u8 battler)
{
struct Sprite *healthboxSprite = &gSprites[gHealthboxSpriteIds[battlerId]];
struct Sprite *healthboxSprite = &gSprites[gHealthboxSpriteIds[battler]];
healthboxSprite->sSpeedX = 5;
healthboxSprite->sSpeedY = 0;
healthboxSprite->x2 = 0x73;
healthboxSprite->y2 = 0;
healthboxSprite->callback = SpriteCB_HealthboxSlideIn;
if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
if (GetBattlerSide(battler) != B_SIDE_PLAYER)
{
healthboxSprite->sSpeedX = -healthboxSprite->sSpeedX;
healthboxSprite->sSpeedY = -healthboxSprite->sSpeedY;
@ -1255,7 +1255,7 @@ void StartHealthboxSlideIn(u8 battlerId)
healthboxSprite->y2 = -healthboxSprite->y2;
}
gSprites[healthboxSprite->data[5]].callback(&gSprites[healthboxSprite->data[5]]);
if (GetBattlerPosition(battlerId) == B_POSITION_PLAYER_RIGHT)
if (GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT)
healthboxSprite->callback = SpriteCB_HealthboxSlideInDelayed;
}
@ -1281,13 +1281,13 @@ static void SpriteCB_HealthboxSlideIn(struct Sprite *sprite)
#undef sSpeedY
#undef sDelayTimer
void DoHitAnimHealthboxEffect(u8 battlerId)
void DoHitAnimHealthboxEffect(u8 battler)
{
u8 spriteId;
spriteId = CreateInvisibleSpriteWithCallback(SpriteCB_HitAnimHealthoxEffect);
gSprites[spriteId].data[0] = 1;
gSprites[spriteId].data[1] = gHealthboxSpriteIds[battlerId];
gSprites[spriteId].data[1] = gHealthboxSpriteIds[battler];
gSprites[spriteId].callback = SpriteCB_HitAnimHealthoxEffect;
}
@ -1335,10 +1335,10 @@ void FreeBallGfx(u8 ballId)
FreeSpritePaletteByTag(gBallSpritePalettes[ballId].tag);
}
static u16 GetBattlerPokeballItemId(u8 battlerId)
static u16 GetBattlerPokeballItemId(u8 battler)
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
return GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_POKEBALL);
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
return GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_POKEBALL);
else
return GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_POKEBALL);
return GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_POKEBALL);
}

168
src/pokemon.c
View File

@ -67,7 +67,7 @@ static union PokemonSubstruct *GetSubstruct(struct BoxPokemon *boxMon, u32 perso
static void EncryptBoxMon(struct BoxPokemon *boxMon);
static void DecryptBoxMon(struct BoxPokemon *boxMon);
static void Task_PlayMapChosenOrBattleBGM(u8 taskId);
static bool8 ShouldGetStatBadgeBoost(u16 flagId, u8 battlerId);
static bool8 ShouldGetStatBadgeBoost(u16 flagId, u8 battler);
static u16 GiveMoveToBoxMon(struct BoxPokemon *boxMon, u16 move);
static bool8 ShouldSkipFriendshipChange(void);
static u8 CopyMonToPC(struct Pokemon *mon);
@ -2639,7 +2639,7 @@ static void CreateEventMon(struct Pokemon *mon, u16 species, u8 level, u8 fixedI
}
// If FALSE, should load this game's Deoxys form. If TRUE, should load normal Deoxys form
bool8 ShouldIgnoreDeoxysForm(u8 caseId, u8 battlerId)
bool8 ShouldIgnoreDeoxysForm(u8 caseId, u8 battler)
{
switch (caseId)
{
@ -2651,7 +2651,7 @@ bool8 ShouldIgnoreDeoxysForm(u8 caseId, u8 battlerId)
return FALSE;
if (!gMain.inBattle)
return FALSE;
if (gLinkPlayers[GetMultiplayerId()].id == battlerId)
if (gLinkPlayers[GetMultiplayerId()].id == battler)
return FALSE;
break;
case 2:
@ -2661,7 +2661,7 @@ bool8 ShouldIgnoreDeoxysForm(u8 caseId, u8 battlerId)
return FALSE;
if (!gMain.inBattle)
return FALSE;
if (battlerId == 1 || battlerId == 4 || battlerId == 5)
if (battler == 1 || battler == 4 || battler == 5)
return TRUE;
return FALSE;
case 4:
@ -2673,12 +2673,12 @@ bool8 ShouldIgnoreDeoxysForm(u8 caseId, u8 battlerId)
return FALSE;
if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
{
if (gLinkPlayers[GetMultiplayerId()].id == battlerId)
if (gLinkPlayers[GetMultiplayerId()].id == battler)
return FALSE;
}
else
{
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
return FALSE;
}
}
@ -2686,7 +2686,7 @@ bool8 ShouldIgnoreDeoxysForm(u8 caseId, u8 battlerId)
{
if (!gMain.inBattle)
return FALSE;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
if (GetBattlerSide(battler) == B_SIDE_PLAYER)
return FALSE;
}
break;
@ -3404,11 +3404,11 @@ u8 CountAliveMonsInBattle(u8 caseId)
return retVal;
}
static bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 battlerId)
static bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 battler)
{
if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_FRONTIER))
return FALSE;
else if (GetBattlerSide(battlerId) != B_SIDE_PLAYER)
else if (GetBattlerSide(battler) != B_SIDE_PLAYER)
return FALSE;
else if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && gTrainerBattleOpponent_A == TRAINER_SECRET_BASE)
return FALSE;
@ -3418,9 +3418,9 @@ static bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 battlerId)
return FALSE;
}
u8 GetDefaultMoveTarget(u8 battlerId)
u8 GetDefaultMoveTarget(u8 battler)
{
u8 opposing = BATTLE_OPPOSITE(GET_BATTLER_SIDE(battlerId));
u8 opposing = BATTLE_OPPOSITE(GET_BATTLER_SIDE(battler));
if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
return GetBattlerAtPosition(opposing);
@ -4638,59 +4638,59 @@ void RemoveBattleMonPPBonus(struct BattlePokemon *mon, u8 moveIndex)
mon->ppBonuses &= gPPUpClearMask[moveIndex];
}
void CopyPlayerPartyMonToBattleData(u8 battlerId, u8 partyIndex)
void CopyPlayerPartyMonToBattleData(u8 battler, u8 partyIndex)
{
u16 *hpSwitchout;
s32 i;
u8 nickname[POKEMON_NAME_BUFFER_SIZE];
gBattleMons[battlerId].species = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPECIES, NULL);
gBattleMons[battlerId].item = GetMonData(&gPlayerParty[partyIndex], MON_DATA_HELD_ITEM, NULL);
gBattleMons[battler].species = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPECIES, NULL);
gBattleMons[battler].item = GetMonData(&gPlayerParty[partyIndex], MON_DATA_HELD_ITEM, NULL);
for (i = 0; i < MAX_MON_MOVES; i++)
{
gBattleMons[battlerId].moves[i] = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MOVE1 + i, NULL);
gBattleMons[battlerId].pp[i] = GetMonData(&gPlayerParty[partyIndex], MON_DATA_PP1 + i, NULL);
gBattleMons[battler].moves[i] = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MOVE1 + i, NULL);
gBattleMons[battler].pp[i] = GetMonData(&gPlayerParty[partyIndex], MON_DATA_PP1 + i, NULL);
}
gBattleMons[battlerId].ppBonuses = GetMonData(&gPlayerParty[partyIndex], MON_DATA_PP_BONUSES, NULL);
gBattleMons[battlerId].friendship = GetMonData(&gPlayerParty[partyIndex], MON_DATA_FRIENDSHIP, NULL);
gBattleMons[battlerId].experience = GetMonData(&gPlayerParty[partyIndex], MON_DATA_EXP, NULL);
gBattleMons[battlerId].hpIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_HP_IV, NULL);
gBattleMons[battlerId].attackIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_ATK_IV, NULL);
gBattleMons[battlerId].defenseIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_DEF_IV, NULL);
gBattleMons[battlerId].speedIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPEED_IV, NULL);
gBattleMons[battlerId].spAttackIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPATK_IV, NULL);
gBattleMons[battlerId].spDefenseIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPDEF_IV, NULL);
gBattleMons[battlerId].personality = GetMonData(&gPlayerParty[partyIndex], MON_DATA_PERSONALITY, NULL);
gBattleMons[battlerId].status1 = GetMonData(&gPlayerParty[partyIndex], MON_DATA_STATUS, NULL);
gBattleMons[battlerId].level = GetMonData(&gPlayerParty[partyIndex], MON_DATA_LEVEL, NULL);
gBattleMons[battlerId].hp = GetMonData(&gPlayerParty[partyIndex], MON_DATA_HP, NULL);
gBattleMons[battlerId].maxHP = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MAX_HP, NULL);
gBattleMons[battlerId].attack = GetMonData(&gPlayerParty[partyIndex], MON_DATA_ATK, NULL);
gBattleMons[battlerId].defense = GetMonData(&gPlayerParty[partyIndex], MON_DATA_DEF, NULL);
gBattleMons[battlerId].speed = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPEED, NULL);
gBattleMons[battlerId].spAttack = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPATK, NULL);
gBattleMons[battlerId].spDefense = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPDEF, NULL);
gBattleMons[battlerId].isEgg = GetMonData(&gPlayerParty[partyIndex], MON_DATA_IS_EGG, NULL);
gBattleMons[battlerId].abilityNum = GetMonData(&gPlayerParty[partyIndex], MON_DATA_ABILITY_NUM, NULL);
gBattleMons[battlerId].otId = GetMonData(&gPlayerParty[partyIndex], MON_DATA_OT_ID, NULL);
gBattleMons[battlerId].types[0] = gSpeciesInfo[gBattleMons[battlerId].species].types[0];
gBattleMons[battlerId].types[1] = gSpeciesInfo[gBattleMons[battlerId].species].types[1];
gBattleMons[battlerId].ability = GetAbilityBySpecies(gBattleMons[battlerId].species, gBattleMons[battlerId].abilityNum);
gBattleMons[battler].ppBonuses = GetMonData(&gPlayerParty[partyIndex], MON_DATA_PP_BONUSES, NULL);
gBattleMons[battler].friendship = GetMonData(&gPlayerParty[partyIndex], MON_DATA_FRIENDSHIP, NULL);
gBattleMons[battler].experience = GetMonData(&gPlayerParty[partyIndex], MON_DATA_EXP, NULL);
gBattleMons[battler].hpIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_HP_IV, NULL);
gBattleMons[battler].attackIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_ATK_IV, NULL);
gBattleMons[battler].defenseIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_DEF_IV, NULL);
gBattleMons[battler].speedIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPEED_IV, NULL);
gBattleMons[battler].spAttackIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPATK_IV, NULL);
gBattleMons[battler].spDefenseIV = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPDEF_IV, NULL);
gBattleMons[battler].personality = GetMonData(&gPlayerParty[partyIndex], MON_DATA_PERSONALITY, NULL);
gBattleMons[battler].status1 = GetMonData(&gPlayerParty[partyIndex], MON_DATA_STATUS, NULL);
gBattleMons[battler].level = GetMonData(&gPlayerParty[partyIndex], MON_DATA_LEVEL, NULL);
gBattleMons[battler].hp = GetMonData(&gPlayerParty[partyIndex], MON_DATA_HP, NULL);
gBattleMons[battler].maxHP = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MAX_HP, NULL);
gBattleMons[battler].attack = GetMonData(&gPlayerParty[partyIndex], MON_DATA_ATK, NULL);
gBattleMons[battler].defense = GetMonData(&gPlayerParty[partyIndex], MON_DATA_DEF, NULL);
gBattleMons[battler].speed = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPEED, NULL);
gBattleMons[battler].spAttack = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPATK, NULL);
gBattleMons[battler].spDefense = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPDEF, NULL);
gBattleMons[battler].isEgg = GetMonData(&gPlayerParty[partyIndex], MON_DATA_IS_EGG, NULL);
gBattleMons[battler].abilityNum = GetMonData(&gPlayerParty[partyIndex], MON_DATA_ABILITY_NUM, NULL);
gBattleMons[battler].otId = GetMonData(&gPlayerParty[partyIndex], MON_DATA_OT_ID, NULL);
gBattleMons[battler].types[0] = gSpeciesInfo[gBattleMons[battler].species].types[0];
gBattleMons[battler].types[1] = gSpeciesInfo[gBattleMons[battler].species].types[1];
gBattleMons[battler].ability = GetAbilityBySpecies(gBattleMons[battler].species, gBattleMons[battler].abilityNum);
GetMonData(&gPlayerParty[partyIndex], MON_DATA_NICKNAME, nickname);
StringCopy_Nickname(gBattleMons[battlerId].nickname, nickname);
GetMonData(&gPlayerParty[partyIndex], MON_DATA_OT_NAME, gBattleMons[battlerId].otName);
StringCopy_Nickname(gBattleMons[battler].nickname, nickname);
GetMonData(&gPlayerParty[partyIndex], MON_DATA_OT_NAME, gBattleMons[battler].otName);
hpSwitchout = &gBattleStruct->hpOnSwitchout[GetBattlerSide(battlerId)];
*hpSwitchout = gBattleMons[battlerId].hp;
hpSwitchout = &gBattleStruct->hpOnSwitchout[GetBattlerSide(battler)];
*hpSwitchout = gBattleMons[battler].hp;
for (i = 0; i < NUM_BATTLE_STATS; i++)
gBattleMons[battlerId].statStages[i] = DEFAULT_STAT_STAGE;
gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE;
gBattleMons[battlerId].status2 = 0;
UpdateSentPokesToOpponentValue(battlerId);
ClearTemporarySpeciesSpriteData(battlerId, FALSE);
gBattleMons[battler].status2 = 0;
UpdateSentPokesToOpponentValue(battler);
ClearTemporarySpeciesSpriteData(battler, FALSE);
}
bool8 ExecuteTableBasedItemEffect(struct Pokemon *mon, u16 item, u8 partyIndex, u8 moveIndex)
@ -4737,7 +4737,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
u32 temp1, temp2;
s8 friendshipChange = 0;
u8 holdEffect;
u8 battlerId = MAX_BATTLERS_COUNT;
u8 battler = MAX_BATTLERS_COUNT;
u32 friendshipOnly = FALSE;
u16 heldItem;
u8 effectFlags;
@ -4768,7 +4768,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
{
if (gBattlerPartyIndexes[i] == partyIndex)
{
battlerId = i;
battler = i;
break;
}
i += 2;
@ -4777,7 +4777,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
else
{
gActiveBattler = 0;
battlerId = MAX_BATTLERS_COUNT;
battler = MAX_BATTLERS_COUNT;
}
// Skip using the item if it won't do anything
@ -4809,9 +4809,9 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
case 0:
// Cure infatuation
if ((itemEffect[i] & ITEM0_INFATUATION)
&& gMain.inBattle && battlerId != MAX_BATTLERS_COUNT && (gBattleMons[battlerId].status2 & STATUS2_INFATUATION))
&& gMain.inBattle && battler != MAX_BATTLERS_COUNT && (gBattleMons[battler].status2 & STATUS2_INFATUATION))
{
gBattleMons[battlerId].status2 &= ~STATUS2_INFATUATION;
gBattleMons[battler].status2 &= ~STATUS2_INFATUATION;
retVal = FALSE;
}
@ -4901,24 +4901,24 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
// Cure status
if ((itemEffect[i] & ITEM3_SLEEP)
&& HealStatusConditions(mon, partyIndex, STATUS1_SLEEP, battlerId) == 0)
&& HealStatusConditions(mon, partyIndex, STATUS1_SLEEP, battler) == 0)
{
if (battlerId != MAX_BATTLERS_COUNT)
gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE;
if (battler != MAX_BATTLERS_COUNT)
gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE;
retVal = FALSE;
}
if ((itemEffect[i] & ITEM3_POISON) && HealStatusConditions(mon, partyIndex, STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER, battlerId) == 0)
if ((itemEffect[i] & ITEM3_POISON) && HealStatusConditions(mon, partyIndex, STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER, battler) == 0)
retVal = FALSE;
if ((itemEffect[i] & ITEM3_BURN) && HealStatusConditions(mon, partyIndex, STATUS1_BURN, battlerId) == 0)
if ((itemEffect[i] & ITEM3_BURN) && HealStatusConditions(mon, partyIndex, STATUS1_BURN, battler) == 0)
retVal = FALSE;
if ((itemEffect[i] & ITEM3_FREEZE) && HealStatusConditions(mon, partyIndex, STATUS1_FREEZE, battlerId) == 0)
if ((itemEffect[i] & ITEM3_FREEZE) && HealStatusConditions(mon, partyIndex, STATUS1_FREEZE, battler) == 0)
retVal = FALSE;
if ((itemEffect[i] & ITEM3_PARALYSIS) && HealStatusConditions(mon, partyIndex, STATUS1_PARALYSIS, battlerId) == 0)
if ((itemEffect[i] & ITEM3_PARALYSIS) && HealStatusConditions(mon, partyIndex, STATUS1_PARALYSIS, battler) == 0)
retVal = FALSE;
if ((itemEffect[i] & ITEM3_CONFUSION) // heal confusion
&& gMain.inBattle && battlerId != MAX_BATTLERS_COUNT && (gBattleMons[battlerId].status2 & STATUS2_CONFUSION))
&& gMain.inBattle && battler != MAX_BATTLERS_COUNT && (gBattleMons[battler].status2 & STATUS2_CONFUSION))
{
gBattleMons[battlerId].status2 &= ~STATUS2_CONFUSION;
gBattleMons[battler].status2 &= ~STATUS2_CONFUSION;
retVal = FALSE;
}
break;
@ -5011,10 +5011,10 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
}
if (gMain.inBattle)
{
if (battlerId != MAX_BATTLERS_COUNT)
if (battler != MAX_BATTLERS_COUNT)
{
gAbsentBattlerFlags &= ~gBitTable[battlerId];
CopyPlayerPartyMonToBattleData(battlerId, GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[battlerId]));
gAbsentBattlerFlags &= ~gBitTable[battler];
CopyPlayerPartyMonToBattleData(battler, GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[battler]));
if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER && gBattleResults.numRevivesUsed < 255)
gBattleResults.numRevivesUsed++;
}
@ -5064,16 +5064,16 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
SetMonData(mon, MON_DATA_HP, &dataUnsigned);
// Update battler (if applicable)
if (gMain.inBattle && battlerId != MAX_BATTLERS_COUNT)
if (gMain.inBattle && battler != MAX_BATTLERS_COUNT)
{
gBattleMons[battlerId].hp = dataUnsigned;
gBattleMons[battler].hp = dataUnsigned;
if (!(effectFlags & (ITEM4_REVIVE >> 2)) && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
{
if (gBattleResults.numHealingItemsUsed < 255)
gBattleResults.numHealingItemsUsed++;
temp2 = gActiveBattler;
gActiveBattler = battlerId;
gActiveBattler = battler;
BtlController_EmitGetMonData(B_COMM_TO_CONTROLLER, REQUEST_ALL_BATTLE, 0);
MarkBattlerForControllerExec(gActiveBattler);
gActiveBattler = temp2;
@ -5110,8 +5110,8 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
SetMonData(mon, MON_DATA_PP1 + temp2, &dataUnsigned);
// Heal battler PP too (if applicable)
if (gMain.inBattle && battlerId != MAX_BATTLERS_COUNT && MOVE_IS_PERMANENT(battlerId, temp2))
gBattleMons[battlerId].pp[temp2] = dataUnsigned;
if (gMain.inBattle && battler != MAX_BATTLERS_COUNT && MOVE_IS_PERMANENT(battler, temp2))
gBattleMons[battler].pp[temp2] = dataUnsigned;
retVal = FALSE;
}
@ -5136,8 +5136,8 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
SetMonData(mon, MON_DATA_PP1 + moveIndex, &dataUnsigned);
// Heal battler PP too (if applicable)
if (gMain.inBattle && battlerId != MAX_BATTLERS_COUNT && MOVE_IS_PERMANENT(battlerId, moveIndex))
gBattleMons[battlerId].pp[moveIndex] = dataUnsigned;
if (gMain.inBattle && battler != MAX_BATTLERS_COUNT && MOVE_IS_PERMANENT(battler, moveIndex))
gBattleMons[battler].pp[moveIndex] = dataUnsigned;
retVal = FALSE;
}
@ -5276,7 +5276,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, u16 item, u8 partyIndex, u8 mov
return retVal;
}
bool8 HealStatusConditions(struct Pokemon *mon, u32 battlePartyId, u32 healMask, u8 battlerId)
bool8 HealStatusConditions(struct Pokemon *mon, u32 battlePartyId, u32 healMask, u8 battler)
{
u32 status = GetMonData(mon, MON_DATA_STATUS, 0);
@ -5284,8 +5284,8 @@ bool8 HealStatusConditions(struct Pokemon *mon, u32 battlePartyId, u32 healMask,
{
status &= ~healMask;
SetMonData(mon, MON_DATA_STATUS, &status);
if (gMain.inBattle && battlerId != MAX_BATTLERS_COUNT)
gBattleMons[battlerId].status1 &= ~healMask;
if (gMain.inBattle && battler != MAX_BATTLERS_COUNT)
gBattleMons[battler].status1 &= ~healMask;
return FALSE;
}
else
@ -6874,22 +6874,22 @@ void BattleAnimateBackSprite(struct Sprite *sprite, u16 species)
static u8 UNUSED GetOwnOpposingLinkMultiBattlerId(bool8 rightSide)
{
s32 i;
s32 battlerId = 0;
s32 battler = 0;
u8 multiplayerId = GetMultiplayerId();
switch (gLinkPlayers[multiplayerId].id)
{
case 0:
case 2:
battlerId = rightSide ? 1 : 3;
battler = rightSide ? 1 : 3;
break;
case 1:
case 3:
battlerId = rightSide ? 2 : 0;
battler = rightSide ? 2 : 0;
break;
}
for (i = 0; i < MAX_LINK_PLAYERS; i++)
{
if (gLinkPlayers[i].id == (s16)battlerId)
if (gLinkPlayers[i].id == (s16)battler)
break;
}
return i;
@ -6898,21 +6898,21 @@ static u8 UNUSED GetOwnOpposingLinkMultiBattlerId(bool8 rightSide)
u8 GetOpposingLinkMultiBattlerId(bool8 rightSide, u8 multiplayerId)
{
s32 i;
s32 battlerId = 0;
s32 battler = 0;
switch (gLinkPlayers[multiplayerId].id)
{
case 0:
case 2:
battlerId = rightSide ? 1 : 3;
battler = rightSide ? 1 : 3;
break;
case 1:
case 3:
battlerId = rightSide ? 2 : 0;
battler = rightSide ? 2 : 0;
break;
}
for (i = 0; i < MAX_LINK_PLAYERS; i++)
{
if (gLinkPlayers[i].id == (s16)battlerId)
if (gLinkPlayers[i].id == (s16)battler)
break;
}
return i;

6
src/pokemon_animation.c
View File

@ -955,14 +955,14 @@ void StartMonSummaryAnimation(struct Sprite *sprite, u8 frontAnimId)
void LaunchAnimationTaskForBackSprite(struct Sprite *sprite, u8 backAnimSet)
{
u8 nature, taskId, animId, battlerId;
u8 nature, taskId, animId, battler;
taskId = CreateTask(Task_HandleMonAnimation, 128);
gTasks[taskId].tPtrHi = (u32)(sprite) >> 16;
gTasks[taskId].tPtrLo = (u32)(sprite);
battlerId = sprite->data[0];
nature = GetNature(&gPlayerParty[gBattlerPartyIndexes[battlerId]]);
battler = sprite->data[0];
nature = GetNature(&gPlayerParty[gBattlerPartyIndexes[battler]]);
// * 3 below because each back anim has 3 variants depending on nature
animId = 3 * backAnimSet + sBackAnimNatureModTable[nature];

94
src/recorded_battle.c
View File

@ -27,7 +27,7 @@ struct PlayerInfo
u32 trainerId;
u8 name[PLAYER_NAME_LENGTH + 1];
u8 gender;
u16 battlerId;
u16 battler;
u16 language;
};
@ -152,7 +152,7 @@ void RecordedBattle_SetTrainerInfo(void)
{
sPlayers[i].trainerId = gLinkPlayers[i].trainerId;
sPlayers[i].gender = gLinkPlayers[i].gender;
sPlayers[i].battlerId = gLinkPlayers[i].id;
sPlayers[i].battler = gLinkPlayers[i].id;
sPlayers[i].language = gLinkPlayers[i].language;
// Record names
@ -178,7 +178,7 @@ void RecordedBattle_SetTrainerInfo(void)
| (gSaveBlock2Ptr->playerTrainerId[3] << 24);
sPlayers[0].gender = gSaveBlock2Ptr->playerGender;
sPlayers[0].battlerId = 0;
sPlayers[0].battler = 0;
sPlayers[0].language = gGameLanguage;
for (i = 0; i < PLAYER_NAME_LENGTH + 1; i++)
@ -186,29 +186,29 @@ void RecordedBattle_SetTrainerInfo(void)
}
}
void RecordedBattle_SetBattlerAction(u8 battlerId, u8 action)
void RecordedBattle_SetBattlerAction(u8 battler, u8 action)
{
if (sBattlerRecordSizes[battlerId] < BATTLER_RECORD_SIZE && sRecordMode != B_RECORD_MODE_PLAYBACK)
sBattleRecords[battlerId][sBattlerRecordSizes[battlerId]++] = action;
if (sBattlerRecordSizes[battler] < BATTLER_RECORD_SIZE && sRecordMode != B_RECORD_MODE_PLAYBACK)
sBattleRecords[battler][sBattlerRecordSizes[battler]++] = action;
}
void RecordedBattle_ClearBattlerAction(u8 battlerId, u8 bytesToClear)
void RecordedBattle_ClearBattlerAction(u8 battler, u8 bytesToClear)
{
s32 i;
for (i = 0; i < bytesToClear; i++)
{
sBattlerRecordSizes[battlerId]--;
sBattleRecords[battlerId][sBattlerRecordSizes[battlerId]] = 0xFF;
if (sBattlerRecordSizes[battlerId] == 0)
sBattlerRecordSizes[battler]--;
sBattleRecords[battler][sBattlerRecordSizes[battler]] = 0xFF;
if (sBattlerRecordSizes[battler] == 0)
break;
}
}
u8 RecordedBattle_GetBattlerAction(u8 battlerId)
u8 RecordedBattle_GetBattlerAction(u8 battler)
{
// Trying to read past array or invalid action byte, battle is over.
if (sBattlerRecordSizes[battlerId] >= BATTLER_RECORD_SIZE || sBattleRecords[battlerId][sBattlerRecordSizes[battlerId]] == 0xFF)
if (sBattlerRecordSizes[battler] >= BATTLER_RECORD_SIZE || sBattleRecords[battler][sBattlerRecordSizes[battler]] == 0xFF)
{
gSpecialVar_Result = gBattleOutcome = B_OUTCOME_PLAYER_TELEPORTED; // hah
ResetPaletteFadeControl();
@ -218,7 +218,7 @@ u8 RecordedBattle_GetBattlerAction(u8 battlerId)
}
else
{
return sBattleRecords[battlerId][sBattlerRecordSizes[battlerId]++];
return sBattleRecords[battler][sBattlerRecordSizes[battler]++];
}
}
@ -268,11 +268,11 @@ void RecordedBattle_RecordAllBattlerData(u8 *src)
{
for (size = *src; size != 0;)
{
u8 battlerId = GetNextRecordedDataByte(src, &idx, &size);
u8 battler = GetNextRecordedDataByte(src, &idx, &size);
u8 numActions = GetNextRecordedDataByte(src, &idx, &size);
for (i = 0; i < numActions; i++)
sBattleRecords[battlerId][sBattlerSavedRecordSizes[battlerId]++] = GetNextRecordedDataByte(src, &idx, &size);
sBattleRecords[battler][sBattlerSavedRecordSizes[battler]++] = GetNextRecordedDataByte(src, &idx, &size);
}
}
}
@ -339,7 +339,7 @@ bool32 MoveRecordedBattleToSaveData(void)
battleSave->playersName[i][j] = sPlayers[i].name[j];
battleSave->playersGender[i] = sPlayers[i].gender;
battleSave->playersLanguage[i] = sPlayers[i].language;
battleSave->playersBattlers[i] = sPlayers[i].battlerId;
battleSave->playersBattlers[i] = sPlayers[i].battler;
battleSave->playersTrainerId[i] = sPlayers[i].trainerId;
}
@ -358,16 +358,16 @@ bool32 MoveRecordedBattleToSaveData(void)
}
else if (sBattleFlags & BATTLE_TYPE_MULTI)
{
switch (sPlayers[0].battlerId)
switch (sPlayers[0].battler)
{
case 0:
case 2:
if (!(sPlayers[gRecordedBattleMultiplayerId].battlerId & 1))
if (!(sPlayers[gRecordedBattleMultiplayerId].battler & 1))
battleSave->battleFlags |= BATTLE_TYPE_RECORDED_IS_MASTER;
break;
case 1:
case 3:
if ((sPlayers[gRecordedBattleMultiplayerId].battlerId & 1))
if ((sPlayers[gRecordedBattleMultiplayerId].battler & 1))
battleSave->battleFlags |= BATTLE_TYPE_RECORDED_IS_MASTER;
break;
}
@ -707,35 +707,35 @@ void RecordedBattle_CopyBattlerMoves(void)
void RecordedBattle_CheckMovesetChanges(u8 mode)
{
s32 battlerId, j, k;
s32 battler, j, k;
if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED_LINK))
return;
for (battlerId = 0; battlerId < gBattlersCount; battlerId++)
for (battler = 0; battler < gBattlersCount; battler++)
{
// Player's side only
if (GetBattlerSide(battlerId) != B_SIDE_OPPONENT)
if (GetBattlerSide(battler) != B_SIDE_OPPONENT)
{
if (mode == B_RECORD_MODE_RECORDING)
{
// Check if any of the battler's moves have changed.
for (j = 0; j < MAX_MON_MOVES; j++)
{
if (gBattleMons[battlerId].moves[j] != sPlayerMonMoves[battlerId / 2][j])
if (gBattleMons[battler].moves[j] != sPlayerMonMoves[battler / 2][j])
break;
}
if (j != MAX_MON_MOVES)
{
// At least one of the moves has been changed
RecordedBattle_SetBattlerAction(battlerId, ACTION_MOVE_CHANGE);
RecordedBattle_SetBattlerAction(battler, ACTION_MOVE_CHANGE);
for (j = 0; j < MAX_MON_MOVES; j++)
{
for (k = 0; k < MAX_MON_MOVES; k++)
{
if (gBattleMons[battlerId].moves[j] == sPlayerMonMoves[battlerId / 2][k])
if (gBattleMons[battler].moves[j] == sPlayerMonMoves[battler / 2][k])
{
RecordedBattle_SetBattlerAction(battlerId, k);
RecordedBattle_SetBattlerAction(battler, k);
break;
}
}
@ -744,7 +744,7 @@ void RecordedBattle_CheckMovesetChanges(u8 mode)
}
else // B_RECORD_MODE_PLAYBACK
{
if (sBattleRecords[battlerId][sBattlerRecordSizes[battlerId]] == ACTION_MOVE_CHANGE)
if (sBattleRecords[battler][sBattlerRecordSizes[battler]] == ACTION_MOVE_CHANGE)
{
u8 ppBonuses[MAX_MON_MOVES];
u8 moveSlots[MAX_MON_MOVES];
@ -754,55 +754,55 @@ void RecordedBattle_CheckMovesetChanges(u8 mode)
// We know the current action is ACTION_MOVE_CHANGE, retrieve
// it without saving it to move on to the next action.
RecordedBattle_GetBattlerAction(battlerId);
RecordedBattle_GetBattlerAction(battler);
for (j = 0; j < MAX_MON_MOVES; j++)
ppBonuses[j] = ((gBattleMons[battlerId].ppBonuses & (3 << (j << 1))) >> (j << 1));
ppBonuses[j] = ((gBattleMons[battler].ppBonuses & (3 << (j << 1))) >> (j << 1));
for (j = 0; j < MAX_MON_MOVES; j++)
{
moveSlots[j] = RecordedBattle_GetBattlerAction(battlerId);
movePp.moves[j] = gBattleMons[battlerId].moves[moveSlots[j]];
movePp.currentPp[j] = gBattleMons[battlerId].pp[moveSlots[j]];
moveSlots[j] = RecordedBattle_GetBattlerAction(battler);
movePp.moves[j] = gBattleMons[battler].moves[moveSlots[j]];
movePp.currentPp[j] = gBattleMons[battler].pp[moveSlots[j]];
movePp.maxPp[j] = ppBonuses[moveSlots[j]];
mimickedMoveSlots[j] = (gDisableStructs[battlerId].mimickedMoves & gBitTable[j]) >> j;
mimickedMoveSlots[j] = (gDisableStructs[battler].mimickedMoves & gBitTable[j]) >> j;
}
for (j = 0; j < MAX_MON_MOVES; j++)
{
gBattleMons[battlerId].moves[j] = movePp.moves[j];
gBattleMons[battlerId].pp[j] = movePp.currentPp[j];
gBattleMons[battler].moves[j] = movePp.moves[j];
gBattleMons[battler].pp[j] = movePp.currentPp[j];
}
gBattleMons[battlerId].ppBonuses = 0;
gDisableStructs[battlerId].mimickedMoves = 0;
gBattleMons[battler].ppBonuses = 0;
gDisableStructs[battler].mimickedMoves = 0;
for (j = 0; j < MAX_MON_MOVES; j++)
{
gBattleMons[battlerId].ppBonuses |= movePp.maxPp[j] << (j << 1);
gDisableStructs[battlerId].mimickedMoves |= mimickedMoveSlots[j] << j;
gBattleMons[battler].ppBonuses |= movePp.maxPp[j] << (j << 1);
gDisableStructs[battler].mimickedMoves |= mimickedMoveSlots[j] << j;
}
if (!(gBattleMons[battlerId].status2 & STATUS2_TRANSFORMED))
if (!(gBattleMons[battler].status2 & STATUS2_TRANSFORMED))
{
for (j = 0; j < MAX_MON_MOVES; j++)
ppBonuses[j] = (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PP_BONUSES, NULL) & ((3 << (j << 1)))) >> (j << 1);
ppBonuses[j] = (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP_BONUSES, NULL) & ((3 << (j << 1)))) >> (j << 1);
for (j = 0; j < MAX_MON_MOVES; j++)
{
movePp.moves[j] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_MOVE1 + moveSlots[j], NULL);
movePp.currentPp[j] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PP1 + moveSlots[j], NULL);
movePp.moves[j] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + moveSlots[j], NULL);
movePp.currentPp[j] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP1 + moveSlots[j], NULL);
movePp.maxPp[j] = ppBonuses[moveSlots[j]];
}
for (j = 0; j < MAX_MON_MOVES; j++)
{
SetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_MOVE1 + j, &movePp.moves[j]);
SetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PP1 + j, &movePp.currentPp[j]);
SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + j, &movePp.moves[j]);
SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP1 + j, &movePp.currentPp[j]);
}
ppBonusSet = 0;
for (j = 0; j < MAX_MON_MOVES; j++)
ppBonusSet |= movePp.maxPp[j] << (j << 1);
SetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PP_BONUSES, &ppBonusSet);
SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP_BONUSES, &ppBonusSet);
}
gChosenMoveByBattler[battlerId] = gBattleMons[battlerId].moves[*(gBattleStruct->chosenMovePositions + battlerId)];
gChosenMoveByBattler[battler] = gBattleMons[battler].moves[*(gBattleStruct->chosenMovePositions + battler)];
}
}
}

6
src/reshow_battle_screen.c
View File

@ -18,9 +18,9 @@
// this file's functions
static void CB2_ReshowBattleScreenAfterMenu(void);
static bool8 LoadBattlerSpriteGfx(u8 battlerId);
static void CreateBattlerSprite(u8 battlerId);
static void CreateHealthboxSprite(u8 battlerId);
static bool8 LoadBattlerSpriteGfx(u8 battler);
static void CreateBattlerSprite(u8 battler);
static void CreateHealthboxSprite(u8 battler);
static void ClearBattleBgCntBaseBlocks(void);
void ReshowBattleScreenDummy(void)

BIN
tools/mgba-rom-test-hydra/mgba-rom-test-hydra Executable file
View File

Binary file not shown.

BIN
tools/patchelf/patchelf Executable file
View File

Binary file not shown.

BIN
tools/trainerproc/trainerproc Executable file
View File

Binary file not shown.