summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/battle_2.c7
-rw-r--r--src/battle_ai_switch_items.c18
-rw-r--r--src/battle_anim.c1850
-rw-r--r--src/battle_controllers.c1551
-rw-r--r--src/battle_interface.c2632
-rw-r--r--src/battle_script_commands.c34
-rwxr-xr-xsrc/clear_save_data_screen.c209
-rw-r--r--src/decompress.c2
-rw-r--r--src/decoration.c2781
-rw-r--r--src/decoration_inventory.c189
-rw-r--r--src/egg_hatch.c2
-rw-r--r--src/international_string_util.c8
-rw-r--r--src/librfu_intr.c4
-rw-r--r--src/librfu_rfu.c109
-rw-r--r--src/librfu_stwi.c687
-rw-r--r--src/mail.c577
-rw-r--r--src/reshow_battle_screen.c4
-rw-r--r--src/safari_zone.c2
-rw-r--r--src/sprite.c2
-rw-r--r--src/start_menu.c2
-rw-r--r--src/tv.c2
-rw-r--r--src/walda_phrase.c257
22 files changed, 10886 insertions, 43 deletions
diff --git a/src/battle_2.c b/src/battle_2.c
index aeba69213..16c07114a 100644
--- a/src/battle_2.c
+++ b/src/battle_2.c
@@ -204,9 +204,6 @@ extern const u8 BattleScript_ActionSwitch[];
extern const u8 BattleScript_PrintFailedToRunString[];
// functions
-extern void HandleLinkBattleSetup(void); // rom_3
-extern void SetUpBattleVarsAndBirchZigzagoon(void); // rom_3
-extern void sub_8032768(void); // rom_3
extern void dp12_8087EA4(void);
extern void sub_80356D0(void);
extern void GetFrontierTrainerName(u8* dst, u16 trainerId); // battle tower
@@ -4083,7 +4080,7 @@ static void HandleTurnActionSelectionState(void)
if (gBattleMons[GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON)].status2 & STATUS2_MULTIPLETURNS
|| gBattleMons[GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON)].status2 & STATUS2_RECHARGE)
{
- Emit_x32(0);
+ EmitCmd50(0);
MarkBufferBankForExecution(gActiveBank);
return;
}
@@ -4111,7 +4108,7 @@ static void HandleTurnActionSelectionState(void)
{
RecordedBattle_ClearBankAction(GetBankByIdentity(GetBankIdentity(gActiveBank) ^ BIT_MON), 3);
}
- Emit_x32(0);
+ EmitCmd50(0);
MarkBufferBankForExecution(gActiveBank);
return;
}
diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c
index 661759a98..d86be6fad 100644
--- a/src/battle_ai_switch_items.c
+++ b/src/battle_ai_switch_items.c
@@ -39,7 +39,7 @@ static bool8 ShouldSwitchIfPerishSong(void)
&& gDisableStructs[gActiveBank].perishSong1 == 0)
{
*(gBattleStruct->field_294 + gActiveBank) = 6;
- EmitCmd_x21(1, 2, 0);
+ EmitCmd33(1, 2, 0);
return TRUE;
}
@@ -121,7 +121,7 @@ static bool8 ShouldSwitchIfWonderGuard(void)
{
// we found a mon
*(gBattleStruct->field_294 + gActiveBank) = i;
- EmitCmd_x21(1, 2, 0);
+ EmitCmd33(1, 2, 0);
return TRUE;
}
}
@@ -221,7 +221,7 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void)
{
// we found a mon
*(gBattleStruct->field_294 + gActiveBank) = i;
- EmitCmd_x21(1, 2, 0);
+ EmitCmd33(1, 2, 0);
return TRUE;
}
}
@@ -241,13 +241,13 @@ static bool8 ShouldSwitchIfNaturalCure(void)
if ((gUnknown_02024250[gActiveBank] == 0 || gUnknown_02024250[gActiveBank] == 0xFFFF) && Random() & 1)
{
*(gBattleStruct->field_294 + gActiveBank) = 6;
- EmitCmd_x21(1, 2, 0);
+ EmitCmd33(1, 2, 0);
return TRUE;
}
else if (gBattleMoves[gUnknown_02024250[gActiveBank]].power == 0 && Random() & 1)
{
*(gBattleStruct->field_294 + gActiveBank) = 6;
- EmitCmd_x21(1, 2, 0);
+ EmitCmd33(1, 2, 0);
return TRUE;
}
@@ -258,7 +258,7 @@ static bool8 ShouldSwitchIfNaturalCure(void)
if (Random() & 1)
{
*(gBattleStruct->field_294 + gActiveBank) = 6;
- EmitCmd_x21(1, 2, 0);
+ EmitCmd33(1, 2, 0);
return TRUE;
}
@@ -426,7 +426,7 @@ static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent)
if (moveFlags & MOVESTATUS_SUPEREFFECTIVE && Random() % moduloPercent == 0)
{
*(gBattleStruct->field_294 + gActiveBank) = i;
- EmitCmd_x21(1, 2, 0);
+ EmitCmd33(1, 2, 0);
return TRUE;
}
}
@@ -611,7 +611,7 @@ void AI_TrySwitchOrUseItem(void)
}
}
- EmitCmd_x21(1, 0, (gActiveBank ^ BIT_SIDE) << 8);
+ EmitCmd33(1, 0, (gActiveBank ^ BIT_SIDE) << 8);
}
#define TYPE_FORESIGHT 0xFE
@@ -940,7 +940,7 @@ static bool8 ShouldUseItem(void)
if (shouldUse)
{
- EmitCmd_x21(1, 1, 0);
+ EmitCmd33(1, 1, 0);
*(gBattleStruct->field_C0 + (gActiveBank / 2) * 2) = item;
gBattleResources->battleHistory->trainerItems[i] = 0;
return shouldUse;
diff --git a/src/battle_anim.c b/src/battle_anim.c
new file mode 100644
index 000000000..023272017
--- /dev/null
+++ b/src/battle_anim.c
@@ -0,0 +1,1850 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_anim.h"
+#include "sprite.h"
+#include "contest.h"
+#include "m4a.h"
+#include "pokemon.h"
+#include "battle_interface.h"
+#include "task.h"
+#include "decompress.h"
+#include "sound.h"
+#include "dma3.h"
+#include "bg.h"
+#include "gpu_regs.h"
+#include "palette.h"
+#include "main.h"
+
+// sprites start at 10000 and thus must be subtracted of 10000 to account for the true index.
+#define GET_TRUE_SPRITE_INDEX(i) ((i - 10000))
+
+#define SCRIPT_READ_16(ptr) ((ptr)[0] | ((ptr)[1] << 8))
+#define SCRIPT_READ_32(ptr) (((ptr)[0]) + ((ptr)[1] << 8) + ((ptr)[2] << 16) + ((ptr)[3] << 24))
+#define SCRIPT_READ_PTR(ptr) ((const u8*)(SCRIPT_READ_32(ptr)))
+
+#define ANIM_SPRITE_INDEX_COUNT 8
+
+extern u8 gBankAttacker;
+extern u8 gBankTarget;
+extern u16 gBattle_WIN0H;
+extern u16 gBattle_WIN0V;
+extern u16 gBattle_WIN1H;
+extern u16 gBattle_WIN1V;
+extern u16 gBattle_BG1_X;
+extern u16 gBattle_BG1_Y;
+extern u16 gBattle_BG2_X;
+extern u16 gBattle_BG2_Y;
+extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
+extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT];
+extern struct MusicPlayerInfo gMPlay_BGM;
+extern struct MusicPlayerInfo gMPlay_SE1;
+extern struct MusicPlayerInfo gMPlay_SE2;
+extern u8 gDecompressionBuffer[];
+
+extern const u16 gUnknown_082C8D64[];
+extern const u8 * const gBattleAnims_Moves[];
+extern const struct CompressedSpriteSheet gBattleAnimPicTable[];
+extern const struct CompressedSpritePalette gBattleAnimPaletteTable[];
+extern const struct BattleAnimBackground gBattleAnimBackgroundTable[];
+
+extern void sub_80A8278(void); // rom_80A5C6C.s
+extern void sub_80A6B30(struct UnknownAnimStruct2*); // rom_80A5C6C.s
+extern void sub_80A6B90(struct UnknownAnimStruct2*, u32 arg1); // rom_80A5C6C.s
+extern u8 sub_80A82E4(u8 bank); // rom_80A5C6C.s
+extern u8 sub_80A5C6C(u8 bank, u8 attributeId); // rom_80A5C6C.s
+extern bool8 AnimBankSpriteExists(u8 bank); // rom_80A5C6C.s
+extern void sub_80A6C68(u8 arg0); // rom_80A5C6C.s
+extern u8 GetAnimBankSpriteId(u8 wantedBank); // rom_80A5C6C.s
+extern u8 sub_80A6D94(void);
+extern u8 sub_80A8364(u8);
+extern bool8 IsDoubleBattle(void);
+
+// this file's functions
+static void ScriptCmd_loadspritegfx(void);
+static void ScriptCmd_unloadspritegfx(void);
+static void ScriptCmd_createsprite(void);
+static void ScriptCmd_createvisualtask(void);
+static void ScriptCmd_delay(void);
+static void ScriptCmd_waitforvisualfinish(void);
+static void ScriptCmd_hang1(void);
+static void ScriptCmd_hang2(void);
+static void ScriptCmd_end(void);
+static void ScriptCmd_playse(void);
+static void ScriptCmd_monbg(void);
+static void ScriptCmd_clearmonbg(void);
+static void ScriptCmd_setalpha(void);
+static void ScriptCmd_blendoff(void);
+static void ScriptCmd_call(void);
+static void ScriptCmd_return(void);
+static void ScriptCmd_setarg(void);
+static void ScriptCmd_choosetwoturnanim(void);
+static void ScriptCmd_jumpifmoveturn(void);
+static void ScriptCmd_jump(void);
+static void ScriptCmd_fadetobg(void);
+static void ScriptCmd_restorebg(void);
+static void ScriptCmd_waitbgfadeout(void);
+static void ScriptCmd_waitbgfadein(void);
+static void ScriptCmd_changebg(void);
+static void ScriptCmd_playsewithpan(void);
+static void ScriptCmd_setpan(void);
+static void ScriptCmd_panse_1B(void);
+static void ScriptCmd_loopsewithpan(void);
+static void ScriptCmd_waitplaysewithpan(void);
+static void ScriptCmd_setbldcnt(void);
+static void ScriptCmd_createsoundtask(void);
+static void ScriptCmd_waitsound(void);
+static void ScriptCmd_jumpargeq(void);
+static void ScriptCmd_monbg_22(void);
+static void ScriptCmd_clearmonbg_23(void);
+static void ScriptCmd_jumpifcontest(void);
+static void ScriptCmd_fadetobgfromset(void);
+static void ScriptCmd_panse_26(void);
+static void ScriptCmd_panse_27(void);
+static void ScriptCmd_monbgprio_28(void);
+static void ScriptCmd_monbgprio_29(void);
+static void ScriptCmd_monbgprio_2A(void);
+static void ScriptCmd_invisible(void);
+static void ScriptCmd_visible(void);
+static void ScriptCmd_doublebattle_2D(void);
+static void ScriptCmd_doublebattle_2E(void);
+static void ScriptCmd_stopsound(void);
+
+static void RunAnimScriptCommand(void);
+static void task_pA_ma0A_obj_to_bg_pal(u8 taskId);
+static void sub_80A46A0(void);
+static void sub_80A4980(u8 taskId);
+static void sub_80A4BB0(u8 taskId);
+static void Task_FadeToBg(u8 taskId);
+static void Task_PanFromInitialToTarget(u8 taskId);
+static void Task_LoopAndPlaySE(u8 taskId);
+static void Task_WaitAndPlaySE(u8 taskId);
+static void LoadDefaultBg(void);
+static void LoadMoveBg(u16 bgId);
+
+// ewram
+EWRAM_DATA static const u8 *sBattleAnimScriptPtr = NULL;
+EWRAM_DATA static const u8 *sBattleAnimScriptRetAddr = NULL;
+EWRAM_DATA void (*gAnimScriptCallback)(void) = NULL;
+EWRAM_DATA static s8 gAnimFramesToWait = 0;
+EWRAM_DATA bool8 gAnimScriptActive = FALSE;
+EWRAM_DATA u8 gAnimVisualTaskCount = 0;
+EWRAM_DATA u8 gAnimSoundTaskCount = 0;
+EWRAM_DATA struct DisableStruct *gAnimDisableStructPtr = NULL;
+EWRAM_DATA u32 gAnimMoveDmg = 0;
+EWRAM_DATA u16 gAnimMovePower = 0;
+EWRAM_DATA static u16 sAnimSpriteIndexArray[ANIM_SPRITE_INDEX_COUNT] = {0};
+EWRAM_DATA u8 gAnimFriendship = 0;
+EWRAM_DATA u16 gWeatherMoveAnim = 0;
+EWRAM_DATA s16 gBattleAnimArgs[ANIM_ARGS_COUNT] = {0};
+EWRAM_DATA static u16 sSoundAnimFramesToWait = 0;
+EWRAM_DATA static u8 sMonAnimTaskIdArray[2] = {0};
+EWRAM_DATA u8 gAnimMoveTurn = 0;
+EWRAM_DATA static u8 sAnimBackgroundFadeState = 0;
+EWRAM_DATA static u16 sAnimMoveIndex = 0; // set but unused.
+EWRAM_DATA u8 gAnimBankAttacker = 0;
+EWRAM_DATA u8 gAnimBankTarget = 0;
+EWRAM_DATA u16 gAnimSpeciesByBanks[BATTLE_BANKS_COUNT] = {0};
+EWRAM_DATA u8 gUnknown_02038440 = 0;
+
+// const rom data
+static void (* const sScriptCmdTable[])(void) =
+{
+ ScriptCmd_loadspritegfx,
+ ScriptCmd_unloadspritegfx,
+ ScriptCmd_createsprite,
+ ScriptCmd_createvisualtask,
+ ScriptCmd_delay,
+ ScriptCmd_waitforvisualfinish,
+ ScriptCmd_hang1,
+ ScriptCmd_hang2,
+ ScriptCmd_end,
+ ScriptCmd_playse,
+ ScriptCmd_monbg,
+ ScriptCmd_clearmonbg,
+ ScriptCmd_setalpha,
+ ScriptCmd_blendoff,
+ ScriptCmd_call,
+ ScriptCmd_return,
+ ScriptCmd_setarg,
+ ScriptCmd_choosetwoturnanim,
+ ScriptCmd_jumpifmoveturn,
+ ScriptCmd_jump,
+ ScriptCmd_fadetobg,
+ ScriptCmd_restorebg,
+ ScriptCmd_waitbgfadeout,
+ ScriptCmd_waitbgfadein,
+ ScriptCmd_changebg,
+ ScriptCmd_playsewithpan,
+ ScriptCmd_setpan,
+ ScriptCmd_panse_1B,
+ ScriptCmd_loopsewithpan,
+ ScriptCmd_waitplaysewithpan,
+ ScriptCmd_setbldcnt,
+ ScriptCmd_createsoundtask,
+ ScriptCmd_waitsound,
+ ScriptCmd_jumpargeq,
+ ScriptCmd_monbg_22,
+ ScriptCmd_clearmonbg_23,
+ ScriptCmd_jumpifcontest,
+ ScriptCmd_fadetobgfromset,
+ ScriptCmd_panse_26,
+ ScriptCmd_panse_27,
+ ScriptCmd_monbgprio_28,
+ ScriptCmd_monbgprio_29,
+ ScriptCmd_monbgprio_2A,
+ ScriptCmd_invisible,
+ ScriptCmd_visible,
+ ScriptCmd_doublebattle_2D,
+ ScriptCmd_doublebattle_2E,
+ ScriptCmd_stopsound
+};
+
+void ClearBattleAnimationVars(void)
+{
+ s32 i;
+
+ gAnimFramesToWait = 0;
+ gAnimScriptActive = FALSE;
+ gAnimVisualTaskCount = 0;
+ gAnimSoundTaskCount = 0;
+ gAnimDisableStructPtr = NULL;
+ gAnimMoveDmg = 0;
+ gAnimMovePower = 0;
+ gAnimFriendship = 0;
+
+ // clear index array.
+ for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++)
+ sAnimSpriteIndexArray[i] |= 0xFFFF;
+
+ // clear anim args.
+ for (i = 0; i < ANIM_ARGS_COUNT; i++)
+ gBattleAnimArgs[i] = 0;
+
+ sMonAnimTaskIdArray[0] = 0xFF;
+ sMonAnimTaskIdArray[1] = 0xFF;
+ gAnimMoveTurn = 0;
+ sAnimBackgroundFadeState = 0;
+ sAnimMoveIndex = 0;
+ gAnimBankAttacker = 0;
+ gAnimBankTarget = 0;
+ gUnknown_02038440 = 0;
+}
+
+void DoMoveAnim(u16 move)
+{
+ gAnimBankAttacker = gBankAttacker;
+ gAnimBankTarget = gBankTarget;
+ DoBattleAnim(gBattleAnims_Moves, move, TRUE);
+}
+
+void DoBattleAnim(const u8 *const animsTable[], u16 tableId, bool8 isMoveAnim)
+{
+ s32 i;
+
+ if (!IsContest())
+ {
+ sub_80A8278();
+ UpdateOamPriorityInAllHealthboxes(0);
+ for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+ {
+ if (GetBankSide(i) != 0)
+ gAnimSpeciesByBanks[i] = GetMonData(&gEnemyParty[gBattlePartyID[i]], MON_DATA_SPECIES);
+ else
+ gAnimSpeciesByBanks[i] = GetMonData(&gPlayerParty[gBattlePartyID[i]], MON_DATA_SPECIES);
+ }
+ }
+ else
+ {
+ for (i = 0; i < 4; i++)
+ gAnimSpeciesByBanks[i] = gContestResources->field_18->field_0;
+ }
+
+ if (!isMoveAnim)
+ sAnimMoveIndex = 0;
+ else
+ sAnimMoveIndex = tableId;
+
+ for (i = 0; i < ANIM_ARGS_COUNT; i++)
+ gBattleAnimArgs[i] = 0;
+
+ sMonAnimTaskIdArray[0] = 0xFF;
+ sMonAnimTaskIdArray[1] = 0xFF;
+ sBattleAnimScriptPtr = animsTable[tableId];
+ gAnimScriptActive = TRUE;
+ gAnimFramesToWait = 0;
+ gAnimScriptCallback = RunAnimScriptCommand;
+
+ for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++)
+ sAnimSpriteIndexArray[i] |= 0xFFFF;
+
+ if (isMoveAnim)
+ {
+ for (i = 0; gUnknown_082C8D64[i] != 0xFFFF; i++)
+ {
+ if (tableId == gUnknown_082C8D64[i])
+ {
+ m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 128);
+ break;
+ }
+ }
+ }
+
+ gBattle_WIN0H = 0;
+ gBattle_WIN0V = 0;
+ gBattle_WIN1H = 0;
+ gBattle_WIN1V = 0;
+}
+
+void DestroyAnimSprite(struct Sprite *sprite)
+{
+ FreeSpriteOamMatrix(sprite);
+ DestroySprite(sprite);
+ gAnimVisualTaskCount--;
+}
+
+void DestroyAnimVisualTask(u8 taskId)
+{
+ DestroyTask(taskId);
+ gAnimVisualTaskCount--;
+}
+
+void DestroyAnimSoundTask(u8 taskId)
+{
+ DestroyTask(taskId);
+ gAnimSoundTaskCount--;
+}
+
+static void AddSpriteIndex(u16 index)
+{
+ s32 i;
+
+ for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++)
+ {
+ if (sAnimSpriteIndexArray[i] == 0xFFFF)
+ {
+ sAnimSpriteIndexArray[i] = index;
+ return;
+ }
+ }
+}
+
+static void ClearSpriteIndex(u16 index)
+{
+ s32 i;
+
+ for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++)
+ {
+ if (sAnimSpriteIndexArray[i] == index)
+ {
+ sAnimSpriteIndexArray[i] |= 0xFFFF;
+ return;
+ }
+ }
+}
+
+static void WaitAnimFrameCount(void)
+{
+ if (gAnimFramesToWait <= 0)
+ {
+ gAnimScriptCallback = RunAnimScriptCommand;
+ gAnimFramesToWait = 0;
+ }
+ else
+ {
+ gAnimFramesToWait--;
+ }
+}
+
+static void RunAnimScriptCommand(void)
+{
+ do
+ {
+ sScriptCmdTable[sBattleAnimScriptPtr[0]]();
+ } while (gAnimFramesToWait == 0 && gAnimScriptActive);
+}
+
+static void ScriptCmd_loadspritegfx(void)
+{
+ u16 index;
+
+ sBattleAnimScriptPtr++;
+ index = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ LoadCompressedObjectPicUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)]);
+ LoadCompressedObjectPaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(index)]);
+ sBattleAnimScriptPtr += 2;
+ AddSpriteIndex(GET_TRUE_SPRITE_INDEX(index));
+ gAnimFramesToWait = 1;
+ gAnimScriptCallback = WaitAnimFrameCount;
+}
+
+static void ScriptCmd_unloadspritegfx(void)
+{
+ u16 index;
+
+ sBattleAnimScriptPtr++;
+ index = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ FreeSpriteTilesByTag(gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)].tag);
+ FreeSpritePaletteByTag(gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(index)].tag);
+ sBattleAnimScriptPtr += 2;
+ ClearSpriteIndex(GET_TRUE_SPRITE_INDEX(index));
+}
+
+static void ScriptCmd_createsprite(void)
+{
+ s32 i;
+ const struct SpriteTemplate *template;
+ u8 argVar;
+ u8 argsCount;
+ s16 subpriority;
+
+ sBattleAnimScriptPtr++;
+ template = (const struct SpriteTemplate *)(SCRIPT_READ_32(sBattleAnimScriptPtr));
+ sBattleAnimScriptPtr += 4;
+
+ argVar = sBattleAnimScriptPtr[0];
+ sBattleAnimScriptPtr++;
+
+ argsCount = sBattleAnimScriptPtr[0];
+ sBattleAnimScriptPtr++;
+ for (i = 0; i < argsCount; i++)
+ {
+ gBattleAnimArgs[i] = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ sBattleAnimScriptPtr += 2;
+ }
+
+ if (argVar & 0x80)
+ {
+ argVar ^= 0x80;
+ if (argVar >= 0x40)
+ argVar -= 0x40;
+ else
+ argVar *= -1;
+
+ subpriority = sub_80A82E4(gAnimBankTarget) + (s8)(argVar);
+ }
+ else
+ {
+ if (argVar >= 0x40)
+ argVar -= 0x40;
+ else
+ argVar *= -1;
+
+ subpriority = sub_80A82E4(gAnimBankAttacker) + (s8)(argVar);
+ }
+
+ if (subpriority < 3)
+ subpriority = 3;
+
+ CreateSpriteAndAnimate(template, sub_80A5C6C(gAnimBankTarget, 2), sub_80A5C6C(gAnimBankTarget, 3), subpriority);
+ gAnimVisualTaskCount++;
+}
+
+static void ScriptCmd_createvisualtask(void)
+{
+ TaskFunc taskFunc;
+ u8 taskPriority;
+ u8 taskId;
+ u8 numArgs;
+ s32 i;
+
+ sBattleAnimScriptPtr++;
+
+ taskFunc = (TaskFunc)SCRIPT_READ_32(sBattleAnimScriptPtr);
+ sBattleAnimScriptPtr += 4;
+
+ taskPriority = sBattleAnimScriptPtr[0];
+ sBattleAnimScriptPtr++;
+
+ numArgs = sBattleAnimScriptPtr[0];
+ sBattleAnimScriptPtr++;
+
+ for (i = 0; i < numArgs; i++)
+ {
+ gBattleAnimArgs[i] = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ sBattleAnimScriptPtr += 2;
+ }
+
+ taskId = CreateTask(taskFunc, taskPriority);
+ taskFunc(taskId);
+ gAnimVisualTaskCount++;
+}
+
+static void ScriptCmd_delay(void)
+{
+ sBattleAnimScriptPtr++;
+ gAnimFramesToWait = sBattleAnimScriptPtr[0];
+ if (gAnimFramesToWait == 0)
+ gAnimFramesToWait = -1;
+ sBattleAnimScriptPtr++;
+ gAnimScriptCallback = WaitAnimFrameCount;
+}
+
+// wait for visual tasks to finish.
+static void ScriptCmd_waitforvisualfinish(void)
+{
+ if (gAnimVisualTaskCount == 0)
+ {
+ sBattleAnimScriptPtr++;
+ gAnimFramesToWait = 0;
+ }
+ else
+ {
+ gAnimFramesToWait = 1;
+ }
+}
+
+static void ScriptCmd_hang1(void)
+{
+}
+
+static void ScriptCmd_hang2(void)
+{
+}
+
+static void ScriptCmd_end(void)
+{
+ s32 i;
+ bool32 continuousAnim = FALSE;
+
+ // keep waiting as long as there is animations to be done.
+ if (gAnimVisualTaskCount != 0 || gAnimSoundTaskCount != 0
+ || sMonAnimTaskIdArray[0] != 0xFF || sMonAnimTaskIdArray[1] != 0xFF)
+ {
+ sSoundAnimFramesToWait = 0;
+ gAnimFramesToWait = 1;
+ return;
+ }
+
+ // finish the sound effects.
+ if (IsSEPlaying())
+ {
+ if (++sSoundAnimFramesToWait <= 90) // wait 90 frames, then halt the sound effect.
+ {
+ gAnimFramesToWait = 1;
+ return;
+ }
+ else
+ {
+ m4aMPlayStop(&gMPlay_SE1);
+ m4aMPlayStop(&gMPlay_SE2);
+ }
+ }
+
+ // the SE has halted, so set the SE Frame Counter to 0 and continue.
+ sSoundAnimFramesToWait = 0;
+
+ for (i = 0; i < ANIM_SPRITE_INDEX_COUNT; i++)
+ {
+ if (sAnimSpriteIndexArray[i] != 0xFFFF)
+ {
+ FreeSpriteTilesByTag(gBattleAnimPicTable[sAnimSpriteIndexArray[i]].tag);
+ FreeSpritePaletteByTag(gBattleAnimPicTable[sAnimSpriteIndexArray[i]].tag);
+ sAnimSpriteIndexArray[i] |= 0xFFFF; // set terminator.
+ }
+ }
+
+ if (!continuousAnim) // may have been used for debug?
+ {
+ m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 256);
+ if (!IsContest())
+ {
+ sub_80A8278();
+ UpdateOamPriorityInAllHealthboxes(1);
+ }
+ gAnimScriptActive = FALSE;
+ }
+}
+
+static void ScriptCmd_playse(void)
+{
+ sBattleAnimScriptPtr++;
+ PlaySE(SCRIPT_READ_16(sBattleAnimScriptPtr));
+ sBattleAnimScriptPtr += 2;
+}
+
+#define t1_MONBG_BANK 0
+#define t1_MON_IN_BG2 1
+#define t1_CREATE_ANOTHER_TASK 2
+#define t1_IS_SECONDMON_BG 3
+
+#define t2_BANK_SPRITE_ID 0
+#define t2_MON_IN_BG2 5
+#define t2_MONBG_BANK 6
+
+static void sub_80A40F4(u8 taskId)
+{
+ u8 newTaskId;
+
+ s16 *selfData = gTasks[taskId].data;
+ u8 bankSpriteId = gBankSpriteIds[selfData[t1_MONBG_BANK]];
+ gSprites[bankSpriteId].invisible = 1;
+
+ if (!selfData[t1_CREATE_ANOTHER_TASK])
+ {
+ DestroyAnimVisualTask(taskId);
+ return;
+ }
+
+ newTaskId = CreateTask(task_pA_ma0A_obj_to_bg_pal, 10);
+ gTasks[newTaskId].data[t2_BANK_SPRITE_ID] = bankSpriteId;
+ gTasks[newTaskId].data[1] = gSprites[bankSpriteId].pos1.x + gSprites[bankSpriteId].pos2.x;
+ gTasks[newTaskId].data[2] = gSprites[bankSpriteId].pos1.y + gSprites[bankSpriteId].pos2.y;
+
+ if (!selfData[t1_MON_IN_BG2])
+ {
+ gTasks[newTaskId].data[3] = gBattle_BG1_X;
+ gTasks[newTaskId].data[4] = gBattle_BG1_Y;
+ }
+ else
+ {
+ gTasks[newTaskId].data[3] = gBattle_BG2_X;
+ gTasks[newTaskId].data[4] = gBattle_BG2_Y;
+ }
+
+ gTasks[newTaskId].data[t2_MON_IN_BG2] = selfData[t1_MON_IN_BG2];
+ gTasks[newTaskId].data[t2_MONBG_BANK] = selfData[t1_MONBG_BANK];
+ sMonAnimTaskIdArray[selfData[t1_IS_SECONDMON_BG]] = newTaskId;
+ DestroyAnimVisualTask(taskId);
+}
+
+static void ScriptCmd_monbg(void)
+{
+ bool8 toBG_2;
+ u8 taskId;
+ u8 bank;
+ u8 animBank;
+
+ sBattleAnimScriptPtr++;
+
+ animBank = sBattleAnimScriptPtr[0];
+ if (animBank & ANIM_BANK_TARGET)
+ bank = gAnimBankTarget;
+ else
+ bank = gAnimBankAttacker;
+
+ if (IsAnimBankSpriteVisible(bank))
+ {
+ u8 identity = GetBankIdentity(bank);
+ if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+ toBG_2 = FALSE;
+ else
+ toBG_2 = TRUE;
+
+ sub_80A438C(bank, toBG_2, FALSE);
+ taskId = CreateTask(sub_80A40F4, 10);
+ gAnimVisualTaskCount++;
+ gTasks[taskId].data[t1_MONBG_BANK] = bank;
+ gTasks[taskId].data[t1_MON_IN_BG2] = toBG_2;
+ gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE;
+ gTasks[taskId].data[t1_IS_SECONDMON_BG] = 0;
+
+ }
+
+ bank ^= BIT_MON;
+ if (IsAnimBankSpriteVisible(bank))
+ {
+ u8 identity = GetBankIdentity(bank);
+ if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+ toBG_2 = FALSE;
+ else
+ toBG_2 = TRUE;
+
+ sub_80A438C(bank, toBG_2, FALSE);
+ taskId = CreateTask(sub_80A40F4, 10);
+ gAnimVisualTaskCount++;
+ gTasks[taskId].data[0] = bank;
+ gTasks[taskId].data[1] = toBG_2;
+ gTasks[taskId].data[t1_CREATE_ANOTHER_TASK] = TRUE;
+ gTasks[taskId].data[t1_IS_SECONDMON_BG] = 1;
+ }
+
+ sBattleAnimScriptPtr++;
+ gAnimFramesToWait = 1;
+ gAnimScriptCallback = WaitAnimFrameCount;
+}
+
+bool8 IsAnimBankSpriteVisible(u8 bank)
+{
+ if (IsContest())
+ {
+ if (bank == gAnimBankAttacker)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ if (!AnimBankSpriteExists(bank))
+ return FALSE;
+ if (IsContest())
+ return TRUE; // this line wont ever be reached.
+ if (!gBattleSpritesDataPtr->bankData[bank].invisible || !gSprites[gBankSpriteIds[bank]].invisible)
+ return TRUE;
+
+ return FALSE;
+}
+
+void sub_80A438C(u8 bank, bool8 toBG_2, bool8 setSpriteInvisible)
+{
+ struct UnknownAnimStruct2 unknownStruct;
+ u8 bankSpriteId;
+
+ if (!toBG_2)
+ {
+ u8 bankIdentity;
+
+ if (IsContest() == TRUE)
+ {
+ RequestDma3Fill(0, (void*)(VRAM + 0x8000), 0x2000, 1);
+ RequestDma3Fill(0xFF, (void*)(VRAM + 0xF000), 0x1000, 0);
+ }
+ else
+ {
+ RequestDma3Fill(0, (void*)(VRAM + 0x4000), 0x2000, 1);
+ RequestDma3Fill(0xFF, (void*)(VRAM + 0xe000), 0x1000, 0);
+ }
+
+ sub_80A6B30(&unknownStruct);
+ CpuFill16(0, unknownStruct.unk0, 0x1000);
+ CpuFill16(0xFF, unknownStruct.unk4, 0x800);
+
+ SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 2);
+ SetAnimBgAttribute(1, BG_ANIM_SCREEN_SIZE, 1);
+ SetAnimBgAttribute(1, BG_ANIM_AREA_OVERFLOW_MODE, 0);
+
+ bankSpriteId = gBankSpriteIds[bank];
+
+ gBattle_BG1_X = -(gSprites[bankSpriteId].pos1.x + gSprites[bankSpriteId].pos2.x) + 0x20;
+ if (IsContest() && IsSpeciesNotUnown(gContestResources->field_18->field_0))
+ gBattle_BG1_X--;
+
+ gBattle_BG1_Y = -(gSprites[bankSpriteId].pos1.y + gSprites[bankSpriteId].pos2.y) + 0x20;
+ if (setSpriteInvisible)
+ gSprites[gBankSpriteIds[bank]].invisible = 1;
+
+ SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X);
+ SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y);
+
+ LoadPalette(&gPlttBufferUnfaded[0x100 + bank * 16], unknownStruct.unk8 * 16, 0x20);
+ CpuCopy32(&gPlttBufferUnfaded[0x100 + bank * 16], (void*)(BG_PLTT + unknownStruct.unk8 * 32), 0x20);
+
+ if (IsContest())
+ bankIdentity = 0;
+ else
+ bankIdentity = GetBankIdentity(bank);
+
+ sub_8118FBC(1, 0, 0, bankIdentity, unknownStruct.unk8, unknownStruct.unk0, unknownStruct.unk4, unknownStruct.unkA);
+
+ if (IsContest())
+ sub_80A46A0();
+ }
+ else
+ {
+ RequestDma3Fill(0, (void*)(VRAM + 0x6000), 0x2000, 1);
+ RequestDma3Fill(0, (void*)(VRAM + 0xF000), 0x1000, 1);
+ sub_80A6B90(&unknownStruct, 2);
+ CpuFill16(0, unknownStruct.unk0 + 0x1000, 0x1000);
+ CpuFill16(0, unknownStruct.unk4 + 0x400, 0x800);
+ SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
+ SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1);
+ SetAnimBgAttribute(2, BG_ANIM_AREA_OVERFLOW_MODE, 0);
+
+ bankSpriteId = gBankSpriteIds[bank];
+
+ gBattle_BG2_X = -(gSprites[bankSpriteId].pos1.x + gSprites[bankSpriteId].pos2.x) + 0x20;
+ gBattle_BG2_Y = -(gSprites[bankSpriteId].pos1.y + gSprites[bankSpriteId].pos2.y) + 0x20;
+
+ if (setSpriteInvisible)
+ gSprites[gBankSpriteIds[bank]].invisible = 1;
+
+ SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X);
+ SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y);
+
+ LoadPalette(&gPlttBufferUnfaded[0x100 + bank * 16], 0x90, 0x20);
+ CpuCopy32(&gPlttBufferUnfaded[0x100 + bank * 16], (void*)(BG_PLTT + 0x120), 0x20);
+
+ sub_8118FBC(2, 0, 0, GetBankIdentity(bank), unknownStruct.unk8, unknownStruct.unk0 + 0x1000, unknownStruct.unk4 + 0x400, unknownStruct.unkA);
+ }
+}
+
+static void sub_80A46A0(void)
+{
+ s32 i, j;
+ struct UnknownAnimStruct2 unknownStruct;
+ u16 *ptr;
+
+ if (IsSpeciesNotUnown(gContestResources->field_18->field_0))
+ {
+ sub_80A6B30(&unknownStruct);
+ ptr = unknownStruct.unk4;
+ for (i = 0; i < 8; i++)
+ {
+ for (j = 0; j < 4; j++)
+ {
+ u16 temp = ptr[j + i * 32];
+
+ ptr[j + i * 32] = ptr[7 - j + i * 32];
+ ptr[7 - j + i * 32] = temp;
+ }
+ }
+ for (i = 0; i < 8; i++)
+ {
+ for (j = 0; j < 8; j++)
+ ptr[j + i * 32] ^= 0x400;
+ }
+ }
+}
+
+void sub_80A4720(u16 a, u16 *b, u32 c, u8 d)
+{
+ s32 i, j;
+ s32 var;
+
+ if (d == 0)
+ var = 32;
+ else
+ var = 64;
+ a <<= 12;
+ for (i = 0; i < var; i++)
+ {
+ for (j = 0; j < 32; j++)
+ b[j + i * 32] = ((b[j + i * 32] & 0xFFF) | a) + c;
+ }
+}
+
+void sub_80A477C(bool8 to_BG2)
+{
+ struct UnknownAnimStruct2 unknownStruct;
+ sub_80A6B30(&unknownStruct);
+
+ if (!to_BG2 || IsContest())
+ {
+ sub_80A6C68(1);
+ gBattle_BG1_X = 0;
+ gBattle_BG1_Y = 0;
+ }
+ else
+ {
+ sub_80A6C68(2);
+ gBattle_BG2_X = 0;
+ gBattle_BG2_Y = 0;
+ }
+}
+
+static void task_pA_ma0A_obj_to_bg_pal(u8 taskId)
+{
+ u8 spriteId, palIndex;
+ s16 x, y;
+ struct UnknownAnimStruct2 unknownStruct;
+
+ spriteId = gTasks[taskId].data[0];
+ palIndex = gTasks[taskId].data[6];
+ sub_80A6B30(&unknownStruct);
+ x = gTasks[taskId].data[1] - (gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x);
+ y = gTasks[taskId].data[2] - (gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y);
+
+ if (gTasks[taskId].data[5] == 0)
+ {
+ u16 *src;
+ u16 *dst;
+
+ gBattle_BG1_X = x + gTasks[taskId].data[3];
+ gBattle_BG1_Y = y + gTasks[taskId].data[4];
+ src = gPlttBufferFaded + 0x100 + palIndex * 16;
+ dst = gPlttBufferFaded + 0x100 + unknownStruct.unk8 * 16 - 256;
+ CpuCopy32(src, dst, 0x20);
+ }
+ else
+ {
+ u16 *src;
+ u16 *dst;
+
+ gBattle_BG2_X = x + gTasks[taskId].data[3];
+ gBattle_BG2_Y = y + gTasks[taskId].data[4];
+ src = gPlttBufferFaded + 0x100 + palIndex * 16;
+ dst = gPlttBufferFaded + 0x100 - 112;
+ CpuCopy32(src, dst, 0x20);
+ }
+}
+
+static void ScriptCmd_clearmonbg(void)
+{
+ u8 animBankId;
+ u8 bank;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ animBankId = sBattleAnimScriptPtr[0];
+
+ if (animBankId == ANIM_BANK_ATTACKER)
+ animBankId = ANIM_BANK_ATK_PARTNER;
+ else if (animBankId == ANIM_BANK_TARGET)
+ animBankId = ANIM_BANK_DEF_PARTNER;
+
+ if (animBankId == ANIM_BANK_ATTACKER || animBankId == ANIM_BANK_ATK_PARTNER)
+ bank = gAnimBankAttacker;
+ else
+ bank = gAnimBankTarget;
+
+ if (sMonAnimTaskIdArray[0] != 0xFF)
+ gSprites[gBankSpriteIds[bank]].invisible = 0;
+ if (animBankId > 1 && sMonAnimTaskIdArray[1] != 0xFF)
+ gSprites[gBankSpriteIds[bank ^ BIT_MON]].invisible = 0;
+ else
+ animBankId = 0;
+
+ taskId = CreateTask(sub_80A4980, 5);
+ gTasks[taskId].data[0] = animBankId;
+ gTasks[taskId].data[2] = bank;
+
+ sBattleAnimScriptPtr++;
+}
+
+static void sub_80A4980(u8 taskId)
+{
+ gTasks[taskId].data[1]++;
+ if (gTasks[taskId].data[1] != 1)
+ {
+ u8 to_BG2;
+ u8 identity = GetBankIdentity(gTasks[taskId].data[2]);
+ if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+ to_BG2 = FALSE;
+ else
+ to_BG2 = TRUE;
+
+ if (sMonAnimTaskIdArray[0] != 0xFF)
+ {
+ sub_80A477C(to_BG2);
+ DestroyTask(sMonAnimTaskIdArray[0]);
+ sMonAnimTaskIdArray[0] = 0xFF;
+ }
+ if (gTasks[taskId].data[0] > 1)
+ {
+ sub_80A477C(to_BG2 ^ 1);
+ DestroyTask(sMonAnimTaskIdArray[1]);
+ sMonAnimTaskIdArray[1] = 0xFF;
+ }
+ DestroyTask(taskId);
+ }
+}
+
+static void ScriptCmd_monbg_22(void)
+{
+ bool8 toBG_2;
+ u8 bank;
+ u8 animBankId;
+
+ sBattleAnimScriptPtr++;
+
+ animBankId = sBattleAnimScriptPtr[0];
+
+ if (animBankId == ANIM_BANK_ATTACKER)
+ animBankId = ANIM_BANK_ATK_PARTNER;
+ else if (animBankId == ANIM_BANK_TARGET)
+ animBankId = ANIM_BANK_DEF_PARTNER;
+
+ if (animBankId == ANIM_BANK_ATTACKER || animBankId == ANIM_BANK_ATK_PARTNER)
+ bank = gAnimBankAttacker;
+ else
+ bank = gAnimBankTarget;
+
+ if (IsAnimBankSpriteVisible(bank))
+ {
+ u8 identity = GetBankIdentity(bank);
+ if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+ toBG_2 = FALSE;
+ else
+ toBG_2 = TRUE;
+
+ sub_80A438C(bank, toBG_2, FALSE);
+ }
+
+ bank ^= BIT_MON;
+ if (animBankId > 1 && IsAnimBankSpriteVisible(bank))
+ {
+ u8 identity = GetBankIdentity(bank);
+ if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+ toBG_2 = FALSE;
+ else
+ toBG_2 = TRUE;
+
+ sub_80A438C(bank, toBG_2, FALSE);
+ }
+
+ sBattleAnimScriptPtr++;
+}
+
+static void ScriptCmd_clearmonbg_23(void)
+{
+ u8 animBankId;
+ u8 bank;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ animBankId = sBattleAnimScriptPtr[0];
+
+ if (animBankId == ANIM_BANK_ATTACKER)
+ animBankId = ANIM_BANK_ATK_PARTNER;
+ else if (animBankId == ANIM_BANK_TARGET)
+ animBankId = ANIM_BANK_DEF_PARTNER;
+
+ if (animBankId == ANIM_BANK_ATTACKER || animBankId == ANIM_BANK_ATK_PARTNER)
+ bank = gAnimBankAttacker;
+ else
+ bank = gAnimBankTarget;
+
+ if (IsAnimBankSpriteVisible(bank))
+ gSprites[gBankSpriteIds[bank]].invisible = 0;
+ if (animBankId > 1 && IsAnimBankSpriteVisible(bank ^ BIT_MON))
+ gSprites[gBankSpriteIds[bank ^ BIT_MON]].invisible = 0;
+ else
+ animBankId = 0;
+
+ taskId = CreateTask(sub_80A4BB0, 5);
+ gTasks[taskId].data[0] = animBankId;
+ gTasks[taskId].data[2] = bank;
+
+ sBattleAnimScriptPtr++;
+}
+
+static void sub_80A4BB0(u8 taskId)
+{
+ gTasks[taskId].data[1]++;
+ if (gTasks[taskId].data[1] != 1)
+ {
+ bool8 toBG_2;
+ u8 bank = gTasks[taskId].data[2];
+ u8 identity = GetBankIdentity(bank);
+ if (identity == IDENTITY_OPPONENT_MON1 || identity == IDENTITY_PLAYER_MON2 || IsContest())
+ toBG_2 = FALSE;
+ else
+ toBG_2 = TRUE;
+
+ if (IsAnimBankSpriteVisible(bank))
+ sub_80A477C(toBG_2);
+ if (gTasks[taskId].data[0] > 1 && IsAnimBankSpriteVisible(bank ^ BIT_MON))
+ sub_80A477C(toBG_2 ^ 1);
+
+ DestroyTask(taskId);
+ }
+}
+
+#undef t1_MONBG_BANK
+#undef t1_MON_IN_BG2
+#undef t1_CREATE_ANOTHER_TASK
+#undef t1_IS_SECONDMON_BG
+
+#undef t2_BANK_SPRITE_ID
+#undef t2_MON_IN_BG2
+#undef t2_MONBG_BANK
+
+static void ScriptCmd_setalpha(void)
+{
+ u16 half1, half2;
+
+ sBattleAnimScriptPtr++;
+ half1 = *(sBattleAnimScriptPtr++);
+ half2 = *(sBattleAnimScriptPtr++) << 8;
+ SetGpuReg(REG_OFFSET_BLDCNT, 0x3F40);
+ SetGpuReg(REG_OFFSET_BLDALPHA, half1 | half2);
+}
+
+static void ScriptCmd_setbldcnt(void)
+{
+ u16 half1, half2;
+
+ sBattleAnimScriptPtr++;
+ half1 = *(sBattleAnimScriptPtr++);
+ half2 = *(sBattleAnimScriptPtr++) << 8;
+ SetGpuReg(REG_OFFSET_BLDCNT, half1 | half2);
+}
+
+static void ScriptCmd_blendoff(void)
+{
+ sBattleAnimScriptPtr++;
+ SetGpuReg(REG_OFFSET_BLDCNT, 0);
+ SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+}
+
+static void ScriptCmd_call(void)
+{
+ sBattleAnimScriptPtr++;
+ sBattleAnimScriptRetAddr = sBattleAnimScriptPtr + 4;
+ sBattleAnimScriptPtr = SCRIPT_READ_PTR(sBattleAnimScriptPtr);
+}
+
+static void ScriptCmd_return(void)
+{
+ sBattleAnimScriptPtr = sBattleAnimScriptRetAddr;
+}
+
+static void ScriptCmd_setarg(void)
+{
+ const u8 *addr = sBattleAnimScriptPtr;
+ u16 value;
+ u8 argId;
+
+ sBattleAnimScriptPtr++;
+ argId = sBattleAnimScriptPtr[0];
+ sBattleAnimScriptPtr++;
+ value = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ sBattleAnimScriptPtr = addr + 4;
+ gBattleAnimArgs[argId] = value;
+}
+
+static void ScriptCmd_choosetwoturnanim(void)
+{
+ sBattleAnimScriptPtr++;
+ if (gAnimMoveTurn & 1)
+ sBattleAnimScriptPtr += 4;
+ sBattleAnimScriptPtr = SCRIPT_READ_PTR(sBattleAnimScriptPtr);
+}
+
+static void ScriptCmd_jumpifmoveturn(void)
+{
+ u8 toCheck;
+ sBattleAnimScriptPtr++;
+ toCheck = sBattleAnimScriptPtr[0];
+ sBattleAnimScriptPtr++;
+
+ if (toCheck == gAnimMoveTurn)
+ sBattleAnimScriptPtr = SCRIPT_READ_PTR(sBattleAnimScriptPtr);
+ else
+ sBattleAnimScriptPtr += 4;
+}
+
+static void ScriptCmd_jump(void)
+{
+ sBattleAnimScriptPtr++;
+ sBattleAnimScriptPtr = SCRIPT_READ_PTR(sBattleAnimScriptPtr);
+}
+
+// Uses of this function that rely on a TRUE return are expecting inBattle to not be ticked as defined in contest behavior. As a result, if misused, this function cannot reliably discern between field and contest status and could result in undefined behavior.
+bool8 IsContest(void)
+{
+ if (!gMain.inBattle)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+#define tBackgroundId data[0]
+#define tState data[10]
+
+static void ScriptCmd_fadetobg(void)
+{
+ u8 backgroundId;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ backgroundId = sBattleAnimScriptPtr[0];
+ sBattleAnimScriptPtr++;
+ taskId = CreateTask(Task_FadeToBg, 5);
+ gTasks[taskId].tBackgroundId = backgroundId;
+ sAnimBackgroundFadeState = 1;
+}
+
+static void ScriptCmd_fadetobgfromset(void)
+{
+ u8 bg1, bg2, bg3;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ bg1 = sBattleAnimScriptPtr[0];
+ bg2 = sBattleAnimScriptPtr[1];
+ bg3 = sBattleAnimScriptPtr[2];
+ sBattleAnimScriptPtr += 3;
+ taskId = CreateTask(Task_FadeToBg, 5);
+
+ if (IsContest())
+ gTasks[taskId].tBackgroundId = bg3;
+ else if (GetBankSide(gAnimBankTarget) == SIDE_PLAYER)
+ gTasks[taskId].tBackgroundId = bg2;
+ else
+ gTasks[taskId].tBackgroundId = bg1;
+
+ sAnimBackgroundFadeState = 1;
+}
+
+static void Task_FadeToBg(u8 taskId)
+{
+ if (gTasks[taskId].tState == 0)
+ {
+ BeginHardwarePaletteFade(0xE8, 0, 0, 16, 0);
+ gTasks[taskId].tState++;
+ return;
+ }
+ if (gPaletteFade.active)
+ return;
+ if (gTasks[taskId].tState == 1)
+ {
+ gTasks[taskId].tState++;
+ sAnimBackgroundFadeState = 2;
+ }
+ else if (gTasks[taskId].tState == 2)
+ {
+ s16 bgId = gTasks[taskId].tBackgroundId;
+
+ if (bgId == -1)
+ LoadDefaultBg();
+ else
+ LoadMoveBg(bgId);
+
+ BeginHardwarePaletteFade(0xE8, 0, 16, 0, 1);
+ gTasks[taskId].tState++;
+ return;
+ }
+ if (gPaletteFade.active)
+ return;
+ if (gTasks[taskId].tState == 3)
+ {
+ DestroyTask(taskId);
+ sAnimBackgroundFadeState = 0;
+ }
+}
+
+static void LoadMoveBg(u16 bgId)
+{
+ if (IsContest())
+ {
+ const void *tilemap = gBattleAnimBackgroundTable[bgId].tilemap;
+ void *dmaSrc;
+ void *dmaDest;
+
+ LZDecompressWram(tilemap, gDecompressionBuffer);
+ sub_80A4720(sub_80A6D94(), (void*)(gDecompressionBuffer), 0x100, 0);
+ dmaSrc = gDecompressionBuffer;
+ dmaDest = (void *)(VRAM + 0xD000);
+ DmaCopy32(3, dmaSrc, dmaDest, 0x800);
+ LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(VRAM + 0x2000));
+ LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, sub_80A6D94() * 16, 32);
+ }
+ else
+ {
+ LZDecompressVram(gBattleAnimBackgroundTable[bgId].tilemap, (void *)(VRAM + 0xD000));
+ LZDecompressVram(gBattleAnimBackgroundTable[bgId].image, (void *)(VRAM + 0x8000));
+ LoadCompressedPalette(gBattleAnimBackgroundTable[bgId].palette, 32, 32);
+ }
+}
+
+static void LoadDefaultBg(void)
+{
+ if (IsContest())
+ LoadContestBgAfterMoveAnim();
+ else
+ DrawMainBattleBackground();
+}
+
+static void ScriptCmd_restorebg(void)
+{
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ taskId = CreateTask(Task_FadeToBg, 5);
+ gTasks[taskId].tBackgroundId = -1;
+ sAnimBackgroundFadeState = 1;
+}
+
+#undef tBackgroundId
+#undef tState
+
+static void ScriptCmd_waitbgfadeout(void)
+{
+ if (sAnimBackgroundFadeState == 2)
+ {
+ sBattleAnimScriptPtr++;
+ gAnimFramesToWait = 0;
+ }
+ else
+ {
+ gAnimFramesToWait = 1;
+ }
+}
+
+static void ScriptCmd_waitbgfadein(void)
+{
+ if (sAnimBackgroundFadeState == 0)
+ {
+ sBattleAnimScriptPtr++;
+ gAnimFramesToWait = 0;
+ }
+ else
+ {
+ gAnimFramesToWait = 1;
+ }
+}
+
+static void ScriptCmd_changebg(void)
+{
+ sBattleAnimScriptPtr++;
+ LoadMoveBg(sBattleAnimScriptPtr[0]);
+ sBattleAnimScriptPtr++;
+}
+
+s8 BattleAnimAdjustPanning(s8 pan)
+{
+ if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gAnimBankAttacker].flag_x10)
+ {
+ if (GetBankSide(gAnimBankAttacker) != SIDE_PLAYER)
+ pan = PAN_SIDE_OPPONENT;
+ else
+ pan = PAN_SIDE_PLAYER;
+ }
+ else if (IsContest())
+ {
+ if (gAnimBankAttacker != gAnimBankTarget || gAnimBankAttacker != 2 || pan != PAN_SIDE_OPPONENT)
+ pan *= -1;
+ }
+ else if (GetBankSide(gAnimBankAttacker) == SIDE_PLAYER)
+ {
+ if (GetBankSide(gAnimBankTarget) == SIDE_PLAYER)
+ {
+ if (pan == PAN_SIDE_OPPONENT)
+ pan = PAN_SIDE_PLAYER;
+ else if (pan != PAN_SIDE_PLAYER)
+ pan *= -1;
+ }
+ }
+ else if (GetBankSide(gAnimBankTarget) == SIDE_OPPONENT)
+ {
+ if (pan == PAN_SIDE_PLAYER)
+ pan = PAN_SIDE_OPPONENT;
+ }
+ else
+ {
+ pan *= -1;
+ }
+
+ if (pan > PAN_SIDE_OPPONENT)
+ pan = PAN_SIDE_OPPONENT;
+ else if (pan < PAN_SIDE_PLAYER)
+ pan = PAN_SIDE_PLAYER;
+
+ return pan;
+}
+
+s8 BattleAnimAdjustPanning2(s8 pan)
+{
+ if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gAnimBankAttacker].flag_x10)
+ {
+ if (GetBankSide(gAnimBankAttacker) != SIDE_PLAYER)
+ pan = PAN_SIDE_OPPONENT;
+ else
+ pan = PAN_SIDE_PLAYER;
+ }
+ else
+ {
+ if (GetBankSide(gAnimBankAttacker) != SIDE_PLAYER || IsContest())
+ pan = -pan;
+ }
+ return pan;
+}
+
+s16 sub_80A52EC(s16 a)
+{
+ s16 var = a;
+
+ if (var > 63)
+ var = 63;
+ else if (var < -64)
+ var = -64;
+
+ return var;
+}
+
+s16 CalculatePanIncrement(s16 sourcePan, s16 targetPan, s16 incrementPan)
+{
+ s16 ret;
+
+ if (sourcePan < targetPan)
+ ret = ((incrementPan < 0) ? -incrementPan : incrementPan);
+ else if (sourcePan > targetPan)
+ ret = -((incrementPan < 0) ? -incrementPan : incrementPan);
+ else
+ ret = 0;
+
+ return ret;
+}
+
+static void ScriptCmd_playsewithpan(void)
+{
+ u16 songId;
+ s8 pan;
+
+ sBattleAnimScriptPtr++;
+ songId = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ pan = sBattleAnimScriptPtr[2];
+ PlaySE12WithPanning(songId, BattleAnimAdjustPanning(pan));
+ sBattleAnimScriptPtr += 3;
+}
+
+static void ScriptCmd_setpan(void)
+{
+ s8 pan;
+
+ sBattleAnimScriptPtr++;
+ pan = sBattleAnimScriptPtr[0];
+ SE12PanpotControl(BattleAnimAdjustPanning(pan));
+ sBattleAnimScriptPtr++;
+}
+
+#define tInitialPan data[0]
+#define tTargetPan data[1]
+#define tIncrementPan data[2]
+#define tFramesToWait data[3]
+#define tCurrentPan data[4]
+#define tFrameCounter data[8]
+
+static void ScriptCmd_panse_1B(void)
+{
+ u16 songNum;
+ s8 currentPanArg, incrementPan, incrementPanArg, currentPan, targetPan;
+ u8 framesToWait;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ songNum = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ currentPanArg = sBattleAnimScriptPtr[2];
+ incrementPan = sBattleAnimScriptPtr[3];
+ incrementPanArg = sBattleAnimScriptPtr[4];
+ framesToWait = sBattleAnimScriptPtr[5];
+
+ currentPan = BattleAnimAdjustPanning(currentPanArg);
+ targetPan = BattleAnimAdjustPanning(incrementPan);
+ incrementPan = CalculatePanIncrement(currentPan, targetPan, incrementPanArg);
+ taskId = CreateTask(Task_PanFromInitialToTarget, 1);
+ gTasks[taskId].tInitialPan = currentPan;
+ gTasks[taskId].tTargetPan = targetPan;
+ gTasks[taskId].tIncrementPan = incrementPan;
+ gTasks[taskId].tFramesToWait = framesToWait;
+ gTasks[taskId].tCurrentPan = currentPan;
+
+ PlaySE12WithPanning(songNum, currentPan);
+
+ gAnimSoundTaskCount++;
+ sBattleAnimScriptPtr += 6;
+}
+
+void Task_PanFromInitialToTarget(u8 taskId)
+{
+ bool32 destroyTask = FALSE;
+ if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait)
+ {
+ s16 pan;
+ s16 initialPanning, targetPanning, currentPan, incrementPan;
+
+ gTasks[taskId].tFrameCounter = 0;
+ initialPanning = gTasks[taskId].tInitialPan;
+ targetPanning = gTasks[taskId].tTargetPan;
+ currentPan = gTasks[taskId].tCurrentPan;
+ incrementPan = gTasks[taskId].tIncrementPan;
+ pan = currentPan + incrementPan;
+ gTasks[taskId].tCurrentPan = pan;
+
+ if (incrementPan == 0) // If we're not incrementing, just cancel the task immediately
+ {
+ destroyTask = TRUE;
+ }
+ else if (initialPanning < targetPanning) // Panning increasing
+ {
+ if (pan >= targetPanning) // Target reached
+ destroyTask = TRUE;
+ }
+ else // Panning decreasing
+ {
+ if (pan <= targetPanning) // Target reached
+ destroyTask = TRUE;
+ }
+
+ if (destroyTask)
+ {
+ pan = targetPanning;
+ DestroyTask(taskId);
+ gAnimSoundTaskCount--;
+ }
+
+ SE12PanpotControl(pan);
+ }
+}
+
+static void ScriptCmd_panse_26(void)
+{
+ u16 songId;
+ s8 currentPan, targetPan, incrementPan;
+ u8 framesToWait;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ songId = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ currentPan = sBattleAnimScriptPtr[2];
+ targetPan = sBattleAnimScriptPtr[3];
+ incrementPan = sBattleAnimScriptPtr[4];
+ framesToWait = sBattleAnimScriptPtr[5];
+
+ taskId = CreateTask(Task_PanFromInitialToTarget, 1);
+ gTasks[taskId].tInitialPan = currentPan;
+ gTasks[taskId].tTargetPan = targetPan;
+ gTasks[taskId].tIncrementPan = incrementPan;
+ gTasks[taskId].tFramesToWait = framesToWait;
+ gTasks[taskId].tCurrentPan = currentPan;
+
+ PlaySE12WithPanning(songId, currentPan);
+
+ gAnimSoundTaskCount++;
+ sBattleAnimScriptPtr += 6;
+}
+
+static void ScriptCmd_panse_27(void)
+{
+ u16 songId;
+ s8 targetPanArg, incrementPanArg, currentPanArg, currentPan, targetPan, incrementPan;
+ u8 framesToWait;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ songId = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ currentPanArg = sBattleAnimScriptPtr[2];
+ targetPanArg = sBattleAnimScriptPtr[3];
+ incrementPanArg = sBattleAnimScriptPtr[4];
+ framesToWait = sBattleAnimScriptPtr[5];
+
+ currentPan = BattleAnimAdjustPanning2(currentPanArg);
+ targetPan = BattleAnimAdjustPanning2(targetPanArg);
+ incrementPan = BattleAnimAdjustPanning2(incrementPanArg);
+
+ taskId = CreateTask(Task_PanFromInitialToTarget, 1);
+ gTasks[taskId].tInitialPan = currentPan;
+ gTasks[taskId].tTargetPan = targetPan;
+ gTasks[taskId].tIncrementPan = incrementPan;
+ gTasks[taskId].tFramesToWait = framesToWait;
+ gTasks[taskId].tCurrentPan = currentPan;
+
+ PlaySE12WithPanning(songId, currentPan);
+
+ gAnimSoundTaskCount++;
+ sBattleAnimScriptPtr += 6;
+}
+
+#undef tInitialPan
+#undef tTargetPan
+#undef tIncrementPan
+#undef tFramesToWait
+#undef tCurrentPan
+#undef tFrameCounter
+
+#define tSongId data[0]
+#define tPanning data[1]
+#define tFramesToWait data[2]
+#define tNumberOfPlays data[3]
+#define tFrameCounter data[8]
+
+static void ScriptCmd_loopsewithpan(void)
+{
+ u16 songId;
+ s8 panningArg, panning;
+ u8 framesToWait, numberOfPlays;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ songId = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ panningArg = sBattleAnimScriptPtr[2];
+ framesToWait = sBattleAnimScriptPtr[3];
+ numberOfPlays = sBattleAnimScriptPtr[4];
+ panning = BattleAnimAdjustPanning(panningArg);
+
+ taskId = CreateTask(Task_LoopAndPlaySE, 1);
+ gTasks[taskId].tSongId = songId;
+ gTasks[taskId].tPanning = panning;
+ gTasks[taskId].tFramesToWait = framesToWait;
+ gTasks[taskId].tNumberOfPlays = numberOfPlays;
+ gTasks[taskId].tFrameCounter = framesToWait;
+ gTasks[taskId].func(taskId);
+
+ gAnimSoundTaskCount++;
+ sBattleAnimScriptPtr += 5;
+}
+
+static void Task_LoopAndPlaySE(u8 taskId)
+{
+ if (gTasks[taskId].tFrameCounter++ >= gTasks[taskId].tFramesToWait)
+ {
+ u16 songId;
+ s8 panning;
+ u8 numberOfPlays;
+
+ gTasks[taskId].tFrameCounter = 0;
+ songId = gTasks[taskId].tSongId;
+ panning = gTasks[taskId].tPanning;
+ numberOfPlays = --gTasks[taskId].tNumberOfPlays;
+ PlaySE12WithPanning(songId, panning);
+ if (numberOfPlays == 0)
+ {
+ DestroyTask(taskId);
+ gAnimSoundTaskCount--;
+ }
+ }
+}
+
+#undef tSongId
+#undef tPanning
+#undef tFramesToWait
+#undef tNumberOfPlays
+#undef tFrameCounter
+
+#define tSongId data[0]
+#define tPanning data[1]
+#define tFramesToWait data[2]
+
+static void ScriptCmd_waitplaysewithpan(void)
+{
+ u16 songId;
+ s8 panningArg, panning;
+ u8 framesToWait;
+ u8 taskId;
+
+ sBattleAnimScriptPtr++;
+ songId = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ panningArg = sBattleAnimScriptPtr[2];
+ framesToWait = sBattleAnimScriptPtr[3];
+ panning = BattleAnimAdjustPanning(panningArg);
+
+ taskId = CreateTask(Task_WaitAndPlaySE, 1);
+ gTasks[taskId].tSongId = songId;
+ gTasks[taskId].tPanning = panning;
+ gTasks[taskId].tFramesToWait = framesToWait;
+
+ gAnimSoundTaskCount++;
+ sBattleAnimScriptPtr += 4;
+}
+
+static void Task_WaitAndPlaySE(u8 taskId)
+{
+ if (gTasks[taskId].tFramesToWait-- <= 0)
+ {
+ PlaySE12WithPanning(gTasks[taskId].tSongId, gTasks[taskId].tPanning);
+ DestroyTask(taskId);
+ gAnimSoundTaskCount--;
+ }
+}
+
+#undef tSongId
+#undef tPanning
+#undef tFramesToWait
+
+static void ScriptCmd_createsoundtask(void)
+{
+ TaskFunc func;
+ u8 numArgs, taskId;
+ s32 i;
+
+ sBattleAnimScriptPtr++;
+ func = (TaskFunc)SCRIPT_READ_32(sBattleAnimScriptPtr);
+ sBattleAnimScriptPtr += 4;
+ numArgs = sBattleAnimScriptPtr[0];
+ sBattleAnimScriptPtr++;
+ for (i = 0; i < numArgs; i++)
+ {
+ gBattleAnimArgs[i] = SCRIPT_READ_16(sBattleAnimScriptPtr);
+ sBattleAnimScriptPtr += 2;
+ }
+ taskId = CreateTask(func, 1);
+ func(taskId);
+ gAnimSoundTaskCount++;
+}
+
+static void ScriptCmd_waitsound(void)
+{
+ if (gAnimSoundTaskCount != 0)
+ {
+ sSoundAnimFramesToWait = 0;
+ gAnimFramesToWait = 1;
+ }
+ else if (IsSEPlaying())
+ {
+ if (++sSoundAnimFramesToWait > 90)
+ {
+ m4aMPlayStop(&gMPlay_SE1);
+ m4aMPlayStop(&gMPlay_SE2);
+ sSoundAnimFramesToWait = 0;
+ }
+ else
+ {
+ gAnimFramesToWait = 1;
+ }
+ }
+ else
+ {
+ sSoundAnimFramesToWait = 0;
+ sBattleAnimScriptPtr++;
+ gAnimFramesToWait = 0;
+ }
+}
+
+static void ScriptCmd_jumpargeq(void)
+{
+ u8 argId;
+ s16 valueToCheck;
+
+ sBattleAnimScriptPtr++;
+ argId = sBattleAnimScriptPtr[0];
+ valueToCheck = SCRIPT_READ_16(sBattleAnimScriptPtr + 1);
+
+ if (valueToCheck == gBattleAnimArgs[argId])
+ sBattleAnimScriptPtr = SCRIPT_READ_PTR(sBattleAnimScriptPtr + 3);
+ else
+ sBattleAnimScriptPtr += 7;
+}
+
+static void ScriptCmd_jumpifcontest(void)
+{
+ sBattleAnimScriptPtr++;
+ if (IsContest())
+ sBattleAnimScriptPtr = SCRIPT_READ_PTR(sBattleAnimScriptPtr);
+ else
+ sBattleAnimScriptPtr += 4;
+}
+
+static void ScriptCmd_monbgprio_28(void)
+{
+ u8 wantedBank;
+ u8 bank;
+ u8 bankIdentity;
+
+ wantedBank = sBattleAnimScriptPtr[1];
+ sBattleAnimScriptPtr += 2;
+
+ if (wantedBank != ANIM_BANK_ATTACKER)
+ bank = gAnimBankTarget;
+ else
+ bank = gAnimBankAttacker;
+
+ bankIdentity = GetBankIdentity(bank);
+ if (!IsContest() && (bankIdentity == IDENTITY_PLAYER_MON1 || bankIdentity == IDENTITY_OPPONENT_MON2))
+ {
+ SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
+ SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
+ }
+}
+
+static void ScriptCmd_monbgprio_29(void)
+{
+ sBattleAnimScriptPtr++;
+ if (!IsContest())
+ {
+ SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
+ SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
+ }
+}
+
+static void ScriptCmd_monbgprio_2A(void)
+{
+ u8 wantedBank;
+ u8 bankIdentity;
+ u8 bank;
+
+ wantedBank = sBattleAnimScriptPtr[1];
+ sBattleAnimScriptPtr += 2;
+ if (GetBankSide(gAnimBankAttacker) != GetBankSide(gAnimBankTarget))
+ {
+ if (wantedBank != ANIM_BANK_ATTACKER)
+ bank = gAnimBankTarget;
+ else
+ bank = gAnimBankAttacker;
+
+ bankIdentity = GetBankIdentity(bank);
+ if (!IsContest() && (bankIdentity == IDENTITY_PLAYER_MON1 || bankIdentity == IDENTITY_OPPONENT_MON2))
+ {
+ SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 1);
+ SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2);
+ }
+ }
+}
+
+static void ScriptCmd_invisible(void)
+{
+ u8 spriteId;
+
+ spriteId = GetAnimBankSpriteId(sBattleAnimScriptPtr[1]);
+ if (spriteId != 0xFF)
+ gSprites[spriteId].invisible = 1;
+
+ sBattleAnimScriptPtr += 2;
+}
+
+static void ScriptCmd_visible(void)
+{
+ u8 spriteId;
+
+ spriteId = GetAnimBankSpriteId(sBattleAnimScriptPtr[1]);
+ if (spriteId != 0xFF)
+ gSprites[spriteId].invisible = 0;
+
+ sBattleAnimScriptPtr += 2;
+}
+
+static void ScriptCmd_doublebattle_2D(void)
+{
+ u8 wantedBank;
+ u8 r4;
+ u8 spriteId;
+
+ wantedBank = sBattleAnimScriptPtr[1];
+ sBattleAnimScriptPtr += 2;
+ if (!IsContest() && IsDoubleBattle()
+ && GetBankSide(gAnimBankAttacker) == GetBankSide(gAnimBankTarget))
+ {
+ if (wantedBank == ANIM_BANK_ATTACKER)
+ {
+ r4 = sub_80A8364(gAnimBankAttacker);
+ spriteId = GetAnimBankSpriteId(0);
+ }
+ else
+ {
+ r4 = sub_80A8364(gAnimBankTarget);
+ spriteId = GetAnimBankSpriteId(1);
+ }
+ if (spriteId != 0xFF)
+ {
+ gSprites[spriteId].invisible = FALSE;
+ if (r4 == 2)
+ gSprites[spriteId].oam.priority = 3;
+
+ if (r4 == 1)
+ sub_80A477C(FALSE);
+ else
+ sub_80A477C(TRUE);
+ }
+ }
+}
+
+static void ScriptCmd_doublebattle_2E(void)
+{
+ u8 wantedBank;
+ u8 r4;
+ u8 spriteId;
+
+ wantedBank = sBattleAnimScriptPtr[1];
+ sBattleAnimScriptPtr += 2;
+ if (!IsContest() && IsDoubleBattle()
+ && GetBankSide(gAnimBankAttacker) == GetBankSide(gAnimBankTarget))
+ {
+ if (wantedBank == ANIM_BANK_ATTACKER)
+ {
+ r4 = sub_80A8364(gAnimBankAttacker);
+ spriteId = GetAnimBankSpriteId(0);
+ }
+ else
+ {
+ r4 = sub_80A8364(gAnimBankTarget);
+ spriteId = GetAnimBankSpriteId(1);
+ }
+
+ if (spriteId != 0xFF && r4 == 2)
+ gSprites[spriteId].oam.priority = 2;
+ }
+}
+
+static void ScriptCmd_stopsound(void)
+{
+ m4aMPlayStop(&gMPlay_SE1);
+ m4aMPlayStop(&gMPlay_SE2);
+ sBattleAnimScriptPtr++;
+}
diff --git a/src/battle_controllers.c b/src/battle_controllers.c
new file mode 100644
index 000000000..9ac18c72f
--- /dev/null
+++ b/src/battle_controllers.c
@@ -0,0 +1,1551 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_controllers.h"
+#include "link.h"
+#include "task.h"
+#include "battle_ai_script_commands.h"
+#include "battle_anim.h"
+#include "pokemon.h"
+#include "species.h"
+#include "recorded_battle.h"
+#include "util.h"
+#include "abilities.h"
+#include "battle_message.h"
+
+extern u32 gBattleTypeFlags;
+extern u32 gBattleExecBuffer;
+extern void (*gBattleMainFunc)(void);
+extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void);
+extern u8 gBanksByIdentity[BATTLE_BANKS_COUNT];
+extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT];
+extern u8 gMoveSelectionCursor[BATTLE_BANKS_COUNT];
+extern u8 gNoOfAllBanks;
+extern u8 gActiveBank;
+extern u8 gUnknown_0202428C;
+extern u32 gUnknown_02022FF4;
+extern u8 gUnknown_0203C7B4;
+extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
+extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200];
+extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200];
+extern u8 gBattleBuffersTransferData[0x100];
+extern u8 gUnknown_02022D08;
+extern u8 gUnknown_02022D09;
+extern u8 gUnknown_02022D0A;
+extern u8 gBankAttacker;
+extern u8 gBankTarget;
+extern u8 gAbsentBankFlags;
+extern u8 gEffectBank;
+extern u16 gBattleWeather;
+extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
+extern u16 gCurrentMove;
+extern u16 gLastUsedMove;
+extern u16 gLastUsedItem;
+extern u8 gBattleOutcome;
+extern u8 gLastUsedAbility;
+extern u8 gStringBank;
+
+extern const struct BattleMove gBattleMoves[];
+
+extern void task00_08081A90(u8 taskId); // cable_club
+extern void sub_81B8D64(u8 bank, u8 arg1); // party_menu
+
+// this file's funcionts
+static void CreateTasksForSendRecvLinkBuffers(void);
+static void SetControllersVariablesInLinkBattle(void);
+static void SetControllersVariables(void);
+static void SetBattlePartyIds(void);
+static void Task_HandleSendLinkBuffersData(u8 taskId);
+static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId);
+
+void HandleLinkBattleSetup(void)
+{
+ if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+ {
+ if (gLinkVSyncDisabled)
+ sub_800B488();
+ if (!gReceivedRemoteLinkPlayers)
+ sub_8009734();
+ CreateTask(task00_08081A90, 0);
+ CreateTasksForSendRecvLinkBuffers();
+ }
+}
+
+void SetUpBattleVarsAndBirchZigzagoon(void)
+{
+ s32 i;
+
+ gBattleMainFunc = nullsub_20;
+
+ for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+ {
+ gBattleBankFunc[i] = nullsub_21;
+ gBanksByIdentity[i] = 0xFF;
+ gActionSelectionCursor[i] = 0;
+ gMoveSelectionCursor[i] = 0;
+ }
+
+ HandleLinkBattleSetup();
+ gBattleExecBuffer = 0;
+ ClearBattleAnimationVars();
+ ClearBattleMonForms();
+ BattleAI_HandleItemUseBeforeAISetup(0xF);
+
+ if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
+ {
+ ZeroEnemyPartyMons();
+ CreateMon(&gEnemyParty[0], SPECIES_ZIGZAGOON, 2, 32, 0, 0, 0, 0);
+ i = 0;
+ SetMonData(&gEnemyParty[0], MON_DATA_HELD_ITEM, &i);
+ }
+
+ gUnknown_02022FF4 = 0;
+ gUnknown_0202428C = 0;
+}
+
+void sub_8032768(void)
+{
+ s32 i;
+ u8 *data;
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_RECORDED))
+ sub_8184DA4(1);
+ else
+ sub_8184DA4(2);
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_RECORDED))
+ sub_8185EB8();
+
+ if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+ SetControllersVariablesInLinkBattle();
+ else
+ SetControllersVariables();
+
+ SetBattlePartyIds();
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+ {
+ for (i = 0; i < gNoOfAllBanks; i++)
+ sub_81B8D64(i, 0);
+ }
+
+ for (i = 0; i < sizeof(gBattleStruct->field_1A4); i++)
+ *(gBattleStruct->field_1A4 + i) = 0;
+
+ for (i = 0; i < sizeof(gBattleStruct->field_204); i++)
+ *(gBattleStruct->field_204 + i) = 0;
+}
+
+static void SetControllersVariables(void)
+{
+ s32 i;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER)
+ {
+ gBattleMainFunc = BeginBattleIntro;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
+ {
+ gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToPlayerPartnerBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+
+ gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+ }
+ else
+ {
+ gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToPlayerPartnerBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+
+ gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+ }
+
+ gNoOfAllBanks = 4;
+
+ sub_81B8D64(0, 0);
+ sub_81B8D64(1, 0);
+ sub_81B8D64(2, 1);
+ sub_81B8D64(3, 1);
+
+ gBattlePartyID[0] = 0;
+ gBattlePartyID[1] = 0;
+ gBattlePartyID[2] = 3;
+ gBattlePartyID[3] = 3;
+ }
+ else if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+ {
+ gBattleMainFunc = BeginBattleIntro;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+ gBattleBankFunc[0] = SetBankFuncToSafariBufferRunCommand;
+ else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL)
+ gBattleBankFunc[0] = SetBankFuncToWallyBufferRunCommand;
+ else
+ gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand;
+
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gNoOfAllBanks = 2;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_x2000000)
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_x80000000)
+ {
+ gBattleMainFunc = BeginBattleIntro;
+
+ gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToRecordedOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gNoOfAllBanks = 2;
+ }
+ else // see how the banks are switched
+ {
+ gBattleBankFunc[1] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[0] = SetBankFuncToRecordedOpponentBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+
+ gNoOfAllBanks = 2;
+ }
+ }
+ else
+ {
+ gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+ }
+ }
+ }
+ else
+ {
+ gBattleMainFunc = BeginBattleIntro;
+
+ gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+
+ gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+
+ gNoOfAllBanks = 4;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
+ {
+ gBattleMainFunc = BeginBattleIntro;
+
+ gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[0] = 0;
+
+ gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[1] = 1;
+
+ gBattleBankFunc[2] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[2] = 2;
+
+ gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[3] = 3;
+
+ gNoOfAllBanks = 4;
+
+ sub_81B8D64(0, 0);
+ sub_81B8D64(1, 0);
+ sub_81B8D64(2, 1);
+ sub_81B8D64(3, 1);
+
+ gBattlePartyID[0] = 0;
+ gBattlePartyID[1] = 0;
+ gBattlePartyID[2] = 3;
+ gBattlePartyID[3] = 3;
+ }
+ else if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+ {
+ u8 var; // multiplayer Id in a recorded battle?
+
+ for (var = gUnknown_0203C7B4, i = 0; i < BATTLE_BANKS_COUNT; i++)
+ {
+ switch (gLinkPlayers[i].lp_field_18)
+ {
+ case 0:
+ case 3:
+ sub_81B8D64(gLinkPlayers[i].lp_field_18, 0);
+ break;
+ case 1:
+ case 2:
+ sub_81B8D64(gLinkPlayers[i].lp_field_18, 1);
+ break;
+ }
+
+ if (i == var)
+ {
+ gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ switch (gLinkPlayers[i].lp_field_18)
+ {
+ case 0:
+ case 3:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_PLAYER_MON1;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+ break;
+ case 1:
+ case 2:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_PLAYER_MON2;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+ break;
+ }
+ }
+ else if ((!(gLinkPlayers[i].lp_field_18 & 1) && !(gLinkPlayers[var].lp_field_18 & 1))
+ || ((gLinkPlayers[i].lp_field_18 & 1) && (gLinkPlayers[var].lp_field_18 & 1)))
+ {
+ gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ switch (gLinkPlayers[i].lp_field_18)
+ {
+ case 0:
+ case 3:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_PLAYER_MON1;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+ break;
+ case 1:
+ case 2:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_PLAYER_MON2;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+ break;
+ }
+ }
+ else
+ {
+ gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToRecordedOpponentBufferRunCommand;
+ switch (gLinkPlayers[i].lp_field_18)
+ {
+ case 0:
+ case 3:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_OPPONENT_MON1;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+ break;
+ case 1:
+ case 2:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_OPPONENT_MON2;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+ break;
+ }
+ }
+ }
+ }
+ else if (gBattleTypeFlags & BATTLE_TYPE_WILD)
+ {
+ gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_x2000000)
+ {
+ gBattleBankFunc[1] = SetBankFuncToRecordedOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[3] = SetBankFuncToRecordedOpponentBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+ }
+ else
+ {
+ gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+ }
+ }
+ else
+ {
+ gBattleBankFunc[1] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[3] = SetBankFuncToRecordedPlayerBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_PLAYER_MON2;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_x2000000)
+ {
+ gBattleBankFunc[0] = SetBankFuncToRecordedOpponentBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToRecordedOpponentBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2;
+ }
+ else
+ {
+ gBattleBankFunc[0] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2;
+ }
+ }
+ }
+ }
+}
+
+static void SetControllersVariablesInLinkBattle(void)
+{
+ s32 i;
+ u8 multiplayerId;
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_WILD)
+ {
+ gBattleMainFunc = BeginBattleIntro;
+
+ gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToLinkOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gNoOfAllBanks = 2;
+ }
+ else
+ {
+ gBattleBankFunc[1] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[0] = SetBankFuncToLinkOpponentBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+
+ gNoOfAllBanks = 2;
+ }
+ }
+ else if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_WILD)
+ {
+ gBattleMainFunc = BeginBattleIntro;
+
+ gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToLinkOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+
+ gBattleBankFunc[3] = SetBankFuncToLinkOpponentBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+
+ gNoOfAllBanks = 4;
+ }
+ else
+ {
+ gBattleBankFunc[1] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[0] = SetBankFuncToLinkOpponentBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[3] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_PLAYER_MON2;
+
+ gBattleBankFunc[2] = SetBankFuncToLinkOpponentBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2;
+
+ gNoOfAllBanks = 4;
+ }
+ }
+ else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_WILD)
+ {
+ gBattleMainFunc = BeginBattleIntro;
+
+ gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToLinkPartnerBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+
+ gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+
+ gNoOfAllBanks = 4;
+ }
+ else
+ {
+ gBattleBankFunc[0] = SetBankFuncToLinkPartnerBufferRunCommand;
+ gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+
+ gBattleBankFunc[1] = SetBankFuncToLinkOpponentBufferRunCommand;
+ gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+
+ gBattleBankFunc[2] = SetBankFuncToPlayerBufferRunCommand;
+ gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+
+ gBattleBankFunc[3] = SetBankFuncToLinkOpponentBufferRunCommand;
+ gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+
+ gNoOfAllBanks = 4;
+ }
+
+ sub_81B8D64(0, 0);
+ sub_81B8D64(1, 0);
+ sub_81B8D64(2, 1);
+ sub_81B8D64(3, 1);
+ gBattlePartyID[0] = 0;
+ gBattlePartyID[1] = 0;
+ gBattlePartyID[2] = 3;
+ gBattlePartyID[3] = 3;
+ }
+ else
+ {
+ multiplayerId = GetMultiplayerId();
+
+ if (gBattleTypeFlags & BATTLE_TYPE_WILD)
+ gBattleMainFunc = BeginBattleIntro;
+
+ for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+ {
+ switch (gLinkPlayers[i].lp_field_18)
+ {
+ case 0:
+ case 3:
+ sub_81B8D64(gLinkPlayers[i].lp_field_18, 0);
+ break;
+ case 1:
+ case 2:
+ sub_81B8D64(gLinkPlayers[i].lp_field_18, 1);
+ break;
+ }
+
+ if (i == multiplayerId)
+ {
+ gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToPlayerBufferRunCommand;
+ switch (gLinkPlayers[i].lp_field_18)
+ {
+ case 0:
+ case 3:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 0;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+ break;
+ case 1:
+ case 2:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 2;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+ break;
+ }
+ }
+ else
+ {
+ if ((!(gLinkPlayers[i].lp_field_18 & 1) && !(gLinkPlayers[multiplayerId].lp_field_18 & 1))
+ || ((gLinkPlayers[i].lp_field_18 & 1) && (gLinkPlayers[multiplayerId].lp_field_18 & 1)))
+ {
+ gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToLinkPartnerBufferRunCommand;
+ switch (gLinkPlayers[i].lp_field_18)
+ {
+ case 0:
+ case 3:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 0;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+ break;
+ case 1:
+ case 2:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 2;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+ break;
+ }
+ }
+ else
+ {
+ gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToLinkOpponentBufferRunCommand;
+ switch (gLinkPlayers[i].lp_field_18)
+ {
+ case 0:
+ case 3:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 1;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+ break;
+ case 1:
+ case 2:
+ gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 3;
+ gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+ break;
+ }
+ }
+ }
+ }
+
+ gNoOfAllBanks = 4;
+ }
+}
+
+static void SetBattlePartyIds(void)
+{
+ s32 i, j;
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+ {
+ for (i = 0; i < gNoOfAllBanks; i++)
+ {
+ for (j = 0; j < 6; j++)
+ {
+ if (i < 2)
+ {
+ if (GET_BANK_SIDE2(i) == SIDE_PLAYER)
+ {
+ if (GetMonData(&gPlayerParty[j], MON_DATA_HP) != 0
+ && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
+ && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+ && GetMonData(&gPlayerParty[j], MON_DATA_IS_EGG) == 0)
+ {
+ gBattlePartyID[i] = j;
+ break;
+ }
+ }
+ else
+ {
+ if (GetMonData(&gEnemyParty[j], MON_DATA_HP) != 0
+ && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
+ && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+ && GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG) == 0)
+ {
+ gBattlePartyID[i] = j;
+ break;
+ }
+ }
+ }
+ else
+ {
+ if (GET_BANK_SIDE2(i) == SIDE_PLAYER)
+ {
+ if (GetMonData(&gPlayerParty[j], MON_DATA_HP) != 0
+ && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES) != SPECIES_NONE // Probably a typo by Game Freak. The rest use SPECIES2.
+ && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+ && GetMonData(&gPlayerParty[j], MON_DATA_IS_EGG) == 0
+ && gBattlePartyID[i - 2] != j)
+ {
+ gBattlePartyID[i] = j;
+ break;
+ }
+ }
+ else
+ {
+ if (GetMonData(&gEnemyParty[j], MON_DATA_HP) != 0
+ && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
+ && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+ && GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG) == 0
+ && gBattlePartyID[i - 2] != j)
+ {
+ gBattlePartyID[i] = j;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)
+ gBattlePartyID[1] = 0, gBattlePartyID[3] = 3;
+ }
+}
+
+static void PrepareBufferDataTransfer(u8 bufferId, u8 *data, u16 size)
+{
+ s32 i;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+ {
+ PrepareBufferDataTransferLink(bufferId, size, data);
+ }
+ else
+ {
+ switch (bufferId)
+ {
+ case 0:
+ for (i = 0; i < size; i++)
+ {
+ gBattleBufferA[gActiveBank][i] = *data;
+ data++;
+ }
+ break;
+ case 1:
+ for (i = 0; i < size; i++)
+ {
+ gBattleBufferB[gActiveBank][i] = *data;
+ data++;
+ }
+ break;
+ }
+ }
+}
+
+static void CreateTasksForSendRecvLinkBuffers(void)
+{
+ gUnknown_02022D08 = CreateTask(Task_HandleSendLinkBuffersData, 0);
+ gTasks[gUnknown_02022D08].data[11] = 0;
+ gTasks[gUnknown_02022D08].data[12] = 0;
+ gTasks[gUnknown_02022D08].data[13] = 0;
+ gTasks[gUnknown_02022D08].data[14] = 0;
+ gTasks[gUnknown_02022D08].data[15] = 0;
+
+ gUnknown_02022D09 = CreateTask(Task_HandleCopyReceivedLinkBuffersData, 0);
+ gTasks[gUnknown_02022D09].data[12] = 0;
+ gTasks[gUnknown_02022D09].data[13] = 0;
+ gTasks[gUnknown_02022D09].data[14] = 0;
+ gTasks[gUnknown_02022D09].data[15] = 0;
+
+ gUnknown_02022D0A = 0;
+}
+
+enum
+{
+ LINK_BUFF_BUFFER_ID,
+ LINK_BUFF_ACTIVE_BANK,
+ LINK_BUFF_ATTACKER,
+ LINK_BUFF_TARGET,
+ LINK_BUFF_SIZE_LO,
+ LINK_BUFF_SIZE_HI,
+ LINK_BUFF_ABSENT_BANK_FLAGS,
+ LINK_BUFF_EFFECT_BANK,
+ LINK_BUFF_DATA
+};
+
+void PrepareBufferDataTransferLink(u8 bufferId, u16 size, u8 *data)
+{
+ s32 alignedSize;
+ s32 i;
+
+ alignedSize = size - size % 4 + 4;
+ if (gTasks[gUnknown_02022D08].data[14] + alignedSize + LINK_BUFF_DATA + 1 > BATTLE_BUFFER_LINK_SIZE)
+ {
+ gTasks[gUnknown_02022D08].data[12] = gTasks[gUnknown_02022D08].data[14];
+ gTasks[gUnknown_02022D08].data[14] = 0;
+ }
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_BUFFER_ID] = bufferId;
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ACTIVE_BANK] = gActiveBank;
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ATTACKER] = gBankAttacker;
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_TARGET] = gBankTarget;
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_SIZE_LO] = alignedSize;
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_SIZE_HI] = (alignedSize & 0x0000FF00) >> 8;
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ABSENT_BANK_FLAGS] = gAbsentBankFlags;
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_EFFECT_BANK] = gEffectBank;
+
+ for (i = 0; i < size; i++)
+ gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_DATA + i] = data[i];
+
+ gTasks[gUnknown_02022D08].data[14] = gTasks[gUnknown_02022D08].data[14] + alignedSize + LINK_BUFF_DATA;
+}
+
+static void Task_HandleSendLinkBuffersData(u8 taskId)
+{
+ u16 var;
+ u16 blockSize;
+
+ switch (gTasks[taskId].data[11])
+ {
+ case 0:
+ gTasks[taskId].data[10] = 100;
+ gTasks[taskId].data[11]++;
+ break;
+ case 1:
+ gTasks[taskId].data[10]--;
+ if (gTasks[taskId].data[10] == 0)
+ gTasks[taskId].data[11]++;
+ break;
+ case 2:
+ if (gLinkVSyncDisabled)
+ {
+ gTasks[taskId].data[11]++;
+ }
+ else
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
+ var = 2;
+ else
+ var = (gBattleTypeFlags & BATTLE_TYPE_MULTI) ? 4 : 2;
+
+ if (sub_800ABAC() >= var)
+ {
+ if (sub_800ABBC())
+ {
+ sub_800A620();
+ gTasks[taskId].data[11]++;
+ }
+ else
+ {
+ gTasks[taskId].data[11]++;
+ }
+ }
+ }
+ break;
+ case 3:
+ if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
+ {
+ if (gTasks[taskId].data[13] == 0)
+ {
+ if (gTasks[taskId].data[15] > gTasks[taskId].data[14]
+ && gTasks[taskId].data[15] == gTasks[taskId].data[12])
+ {
+ gTasks[taskId].data[12] = 0;
+ gTasks[taskId].data[15] = 0;
+ }
+ blockSize = (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8)) + LINK_BUFF_DATA;
+ SendBlock(bitmask_all_link_players_but_self(), &gLinkBattleSendBuffer[gTasks[taskId].data[15]], blockSize);
+ gTasks[taskId].data[11]++;
+ }
+ else
+ {
+ gTasks[taskId].data[13]--;
+ break;
+ }
+ }
+ break;
+ case 4:
+ if (sub_800A520())
+ {
+ blockSize = gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8);
+ gTasks[taskId].data[13] = 1;
+ gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + LINK_BUFF_DATA;
+ gTasks[taskId].data[11] = 3;
+ }
+ break;
+ case 5:
+ gTasks[taskId].data[13]--;
+ if (gTasks[taskId].data[13] == 0)
+ {
+ gTasks[taskId].data[13] = 1;
+ gTasks[taskId].data[11] = 3;
+ }
+ break;
+ }
+}
+
+// fix me
+void sub_8033648(void)
+{
+ u8 i;
+ s32 j;
+ u16 r6;
+ u8 *recvBuffer;
+ u8 *dest;
+ u8 *src;
+
+ if (gReceivedRemoteLinkPlayers != 0 && (gBattleTypeFlags & BATTLE_TYPE_20))
+ {
+ sub_8011BD0();
+ for (i = 0; i < GetLinkPlayerCount(); i++)
+ {
+ if (GetBlockReceivedStatus() & gBitTable[i])
+ {
+ ResetBlockReceivedFlag(i);
+ recvBuffer = (u8 *)gBlockRecvBuffer[i];
+ #ifndef NONMATCHING
+ asm("");
+ recvBuffer = (u8 *)&gBlockRecvBuffer[i];
+ #endif
+ r6 = gBlockRecvBuffer[i][2];
+
+ if (gTasks[gUnknown_02022D09].data[14] + 9 + r6 > 0x1000)
+ {
+ gTasks[gUnknown_02022D09].data[12] = gTasks[gUnknown_02022D09].data[14];
+ gTasks[gUnknown_02022D09].data[14] = 0;
+ }
+
+ dest = &gLinkBattleRecvBuffer[gTasks[gUnknown_02022D09].data[14]];
+ src = recvBuffer;
+
+ for (j = 0; j < r6 + 8; j++)
+ dest[j] = src[j];
+
+ gTasks[gUnknown_02022D09].data[14] = gTasks[gUnknown_02022D09].data[14] + r6 + 8;
+ }
+ }
+ }
+}
+
+static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
+{
+ u16 blockSize;
+ u8 bank;
+ u8 var;
+
+ if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
+ {
+ if (gTasks[taskId].data[15] > gTasks[taskId].data[14]
+ && gTasks[taskId].data[15] == gTasks[taskId].data[12])
+ {
+ gTasks[taskId].data[12] = 0;
+ gTasks[taskId].data[15] = 0;
+ }
+ bank = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_ACTIVE_BANK];
+ blockSize = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8);
+
+ switch (gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 0])
+ {
+ case 0:
+ if (gBattleExecBuffer & gBitTable[bank])
+ return;
+
+ memcpy(gBattleBufferA[bank], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 8], blockSize);
+ sub_803F850(bank);
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_WILD))
+ {
+ gBankAttacker = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 2];
+ gBankTarget = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 3];
+ gAbsentBankFlags = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 6];
+ gEffectBank = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 7];
+ }
+ break;
+ case 1:
+ memcpy(gBattleBufferB[bank], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 8], blockSize);
+ break;
+ case 2:
+ var = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA];
+ gBattleExecBuffer &= ~(gBitTable[bank] << (var * 4));
+ break;
+ }
+
+ gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + LINK_BUFF_DATA;
+ }
+}
+
+void EmitGetMonData(u8 bufferId, u8 arg1, u8 arg2)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_GETMONDATA;
+ gBattleBuffersTransferData[1] = arg1;
+ gBattleBuffersTransferData[2] = arg2;
+ gBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_GETRAWMONDATA;
+ gBattleBuffersTransferData[1] = monId;
+ gBattleBuffersTransferData[2] = bytes;
+ gBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitSetMonData(u8 bufferId, u8 request, u8 c, u8 bytes, void *data)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_SETMONDATA;
+ gBattleBuffersTransferData[1] = request;
+ gBattleBuffersTransferData[2] = c;
+ for (i = 0; i < bytes; i++)
+ gBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 3 + bytes);
+}
+
+void EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_SETRAWMONDATA;
+ gBattleBuffersTransferData[1] = monId;
+ gBattleBuffersTransferData[2] = bytes;
+ for (i = 0; i < bytes; i++)
+ gBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, bytes + 3);
+}
+
+void EmitLoadMonSprite(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_LOADMONSPRITE;
+ gBattleBuffersTransferData[1] = 4;
+ gBattleBuffersTransferData[2] = 4;
+ gBattleBuffersTransferData[3] = 4;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_SWITCHINANIM;
+ gBattleBuffersTransferData[1] = partyId;
+ gBattleBuffersTransferData[2] = dontClearSubstituteBit;
+ gBattleBuffersTransferData[3] = 5;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitReturnMonToBall(u8 bufferId, u8 arg1)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_RETURNMONTOBALL;
+ gBattleBuffersTransferData[1] = arg1;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
+}
+
+void EmitDrawTrainerPic(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_DRAWTRAINERPIC;
+ gBattleBuffersTransferData[1] = 7;
+ gBattleBuffersTransferData[2] = 7;
+ gBattleBuffersTransferData[3] = 7;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitTrainerSlide(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDE;
+ gBattleBuffersTransferData[1] = 8;
+ gBattleBuffersTransferData[2] = 8;
+ gBattleBuffersTransferData[3] = 8;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitTrainerSlideBack(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDEBACK;
+ gBattleBuffersTransferData[1] = 9;
+ gBattleBuffersTransferData[2] = 9;
+ gBattleBuffersTransferData[3] = 9;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitFaintAnimation(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_FAINTANIMATION;
+ gBattleBuffersTransferData[1] = 10;
+ gBattleBuffersTransferData[2] = 10;
+ gBattleBuffersTransferData[3] = 10;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd11(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_11;
+ gBattleBuffersTransferData[1] = 11;
+ gBattleBuffersTransferData[2] = 11;
+ gBattleBuffersTransferData[3] = 11;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd12(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_12;
+ gBattleBuffersTransferData[1] = 12;
+ gBattleBuffersTransferData[2] = 12;
+ gBattleBuffersTransferData[3] = 12;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitBallThrow(u8 bufferId, u8 caseId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_BALLTHROW;
+ gBattleBuffersTransferData[1] = caseId;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
+}
+
+void EmitPause(u8 bufferId, u8 toWait, void *data)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_PAUSE;
+ gBattleBuffersTransferData[1] = toWait;
+ for (i = 0; i < toWait * 3; i++)
+ gBattleBuffersTransferData[2 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, toWait * 3 + 2);
+}
+
+void EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr, u8 multihit)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_MOVEANIMATION;
+ gBattleBuffersTransferData[1] = move;
+ gBattleBuffersTransferData[2] = (move & 0xFF00) >> 8;
+ gBattleBuffersTransferData[3] = turnOfMove;
+ gBattleBuffersTransferData[4] = movePower;
+ gBattleBuffersTransferData[5] = (movePower & 0xFF00) >> 8;
+ gBattleBuffersTransferData[6] = dmg;
+ gBattleBuffersTransferData[7] = (dmg & 0x0000FF00) >> 8;
+ gBattleBuffersTransferData[8] = (dmg & 0x00FF0000) >> 16;
+ gBattleBuffersTransferData[9] = (dmg & 0xFF000000) >> 24;
+ gBattleBuffersTransferData[10] = friendship;
+ gBattleBuffersTransferData[11] = multihit;
+ if (WEATHER_HAS_EFFECT2)
+ {
+ gBattleBuffersTransferData[12] = gBattleWeather;
+ gBattleBuffersTransferData[13] = (gBattleWeather & 0xFF00) >> 8;
+ }
+ else
+ {
+ gBattleBuffersTransferData[12] = 0;
+ gBattleBuffersTransferData[13] = 0;
+ }
+ gBattleBuffersTransferData[14] = 0;
+ gBattleBuffersTransferData[15] = 0;
+ memcpy(&gBattleBuffersTransferData[16], disableStructPtr, sizeof(struct DisableStruct));
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 16 + sizeof(struct DisableStruct));
+}
+
+void EmitPrintString(u8 bufferId, u16 stringID)
+{
+ s32 i;
+ struct StringInfoBattle* stringInfo;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRING;
+ gBattleBuffersTransferData[1] = gBattleOutcome;
+ gBattleBuffersTransferData[2] = stringID;
+ gBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8;
+
+ stringInfo = (struct StringInfoBattle*)(&gBattleBuffersTransferData[4]);
+ stringInfo->currentMove = gCurrentMove;
+ stringInfo->lastMove = gLastUsedMove;
+ stringInfo->lastItem = gLastUsedItem;
+ stringInfo->lastAbility = gLastUsedAbility;
+ stringInfo->scrActive = gBattleScripting.bank;
+ stringInfo->unk1605E = gBattleStruct->field_52;
+ stringInfo->hpScale = gBattleStruct->hpScale;
+ stringInfo->StringBank = gStringBank;
+ stringInfo->moveType = gBattleMoves[gCurrentMove].type;
+
+ for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+ stringInfo->abilities[i] = gBattleMons[i].ability;
+ for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; i++)
+ {
+ stringInfo->textBuffs[0][i] = gBattleTextBuff1[i];
+ stringInfo->textBuffs[1][i] = gBattleTextBuff2[i];
+ stringInfo->textBuffs[2][i] = gBattleTextBuff3[i];
+ }
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(struct StringInfoBattle) + 4);
+}
+
+void EmitPrintStringPlayerOnly(u8 bufferId, u16 stringID)
+{
+ s32 i;
+ struct StringInfoBattle* stringInfo;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRINGPLAYERONLY;
+ gBattleBuffersTransferData[1] = 17;
+ gBattleBuffersTransferData[2] = stringID;
+ gBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8;
+
+ stringInfo = (struct StringInfoBattle*)(&gBattleBuffersTransferData[4]);
+ stringInfo->currentMove = gCurrentMove;
+ stringInfo->lastMove = gLastUsedMove;
+ stringInfo->lastItem = gLastUsedItem;
+ stringInfo->lastAbility = gLastUsedAbility;
+ stringInfo->scrActive = gBattleScripting.bank;
+ stringInfo->unk1605E = gBattleStruct->field_52;
+
+ for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+ stringInfo->abilities[i] = gBattleMons[i].ability;
+ for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; i++)
+ {
+ stringInfo->textBuffs[0][i] = gBattleTextBuff1[i];
+ stringInfo->textBuffs[1][i] = gBattleTextBuff2[i];
+ stringInfo->textBuffs[2][i] = gBattleTextBuff3[i];
+ }
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(struct StringInfoBattle) + 4);
+}
+
+void EmitChooseAction(u8 bufferId, u8 arg1, u16 arg2)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_CHOOSEACTION;
+ gBattleBuffersTransferData[1] = arg1;
+ gBattleBuffersTransferData[2] = arg2;
+ gBattleBuffersTransferData[3] = (arg2 & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd19(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_19;
+ gBattleBuffersTransferData[1] = 19;
+ gBattleBuffersTransferData[2] = 19;
+ gBattleBuffersTransferData[3] = 19;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_CHOOSEMOVE;
+ gBattleBuffersTransferData[1] = isDoubleBattle;
+ gBattleBuffersTransferData[2] = NoPpNumber;
+ gBattleBuffersTransferData[3] = 0;
+ for (i = 0; i < sizeof(*movePpData); i++)
+ gBattleBuffersTransferData[4 + i] = *((u8*)(movePpData) + i);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(*movePpData) + 4);
+}
+
+void EmitOpenBag(u8 bufferId, u8 *arg1)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_OPENBAG;
+ for (i = 0; i < 3; i++)
+ gBattleBuffersTransferData[1 + i] = arg1[i];
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitChoosePokemon(u8 bufferId, u8 caseId, u8 arg2, u8 abilityId, u8* arg4)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_CHOOSEPOKEMON;
+ gBattleBuffersTransferData[1] = caseId;
+ gBattleBuffersTransferData[2] = arg2;
+ gBattleBuffersTransferData[3] = abilityId;
+ for (i = 0; i < 3; i++)
+ gBattleBuffersTransferData[4 + i] = arg4[i];
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 8); // but only 7 bytes were written
+}
+
+void EmitCmd23(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_23;
+ gBattleBuffersTransferData[1] = 23;
+ gBattleBuffersTransferData[2] = 23;
+ gBattleBuffersTransferData[3] = 23;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+// why is the argument u16 if it's being cast to s16 anyway?
+void EmitHealthBarUpdate(u8 bufferId, u16 hpValue)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_HEALTHBARUPDATE;
+ gBattleBuffersTransferData[1] = 0;
+ gBattleBuffersTransferData[2] = (s16)hpValue;
+ gBattleBuffersTransferData[3] = ((s16)hpValue & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+// why is the argument u16 if it's being cast to s16 anyway?
+void EmitExpUpdate(u8 bufferId, u8 partyId, u16 expPoints)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_EXPUPDATE;
+ gBattleBuffersTransferData[1] = partyId;
+ gBattleBuffersTransferData[2] = (s16)expPoints;
+ gBattleBuffersTransferData[3] = ((s16)expPoints & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitStatusIconUpdate(u8 bufferId, u32 status1, u32 status2)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_STATUSICONUPDATE;
+ gBattleBuffersTransferData[1] = status1;
+ gBattleBuffersTransferData[2] = (status1 & 0x0000FF00) >> 8;
+ gBattleBuffersTransferData[3] = (status1 & 0x00FF0000) >> 16;
+ gBattleBuffersTransferData[4] = (status1 & 0xFF000000) >> 24;
+ gBattleBuffersTransferData[5] = status2;
+ gBattleBuffersTransferData[6] = (status2 & 0x0000FF00) >> 8;
+ gBattleBuffersTransferData[7] = (status2 & 0x00FF0000) >> 16;
+ gBattleBuffersTransferData[8] = (status2 & 0xFF000000) >> 24;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 9);
+}
+
+void EmitStatusAnimation(u8 bufferId, bool8 status2, u32 status)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_STATUSANIMATION;
+ gBattleBuffersTransferData[1] = status2;
+ gBattleBuffersTransferData[2] = status;
+ gBattleBuffersTransferData[3] = (status & 0x0000FF00) >> 8;
+ gBattleBuffersTransferData[4] = (status & 0x00FF0000) >> 16;
+ gBattleBuffersTransferData[5] = (status & 0xFF000000) >> 24;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 6);
+}
+
+void EmitStatusXor(u8 bufferId, u8 b)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_STATUSXOR;
+ gBattleBuffersTransferData[1] = b;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
+}
+
+void EmitDataTransfer(u8 bufferId, u16 size, void *data)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_DATATRANSFER;
+ gBattleBuffersTransferData[1] = 29;
+ gBattleBuffersTransferData[2] = size;
+ gBattleBuffersTransferData[3] = (size & 0xFF00) >> 8;
+ for (i = 0; i < size; i++)
+ gBattleBuffersTransferData[4 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, size + 4);
+}
+
+void EmitDMA3Transfer(u8 bufferId, void *dst, u16 size, void *data)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_DMA3TRANSFER;
+ gBattleBuffersTransferData[1] = (u32)(dst);
+ gBattleBuffersTransferData[2] = ((u32)(dst) & 0x0000FF00) >> 8;
+ gBattleBuffersTransferData[3] = ((u32)(dst) & 0x00FF0000) >> 16;
+ gBattleBuffersTransferData[4] = ((u32)(dst) & 0xFF000000) >> 24;
+ gBattleBuffersTransferData[5] = size;
+ gBattleBuffersTransferData[6] = (size & 0xFF00) >> 8;
+ for (i = 0; i < size; i++)
+ gBattleBuffersTransferData[7 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, size + 7);
+}
+
+void EmitPlayBGM(u8 bufferId, u16 songId, void *unusedDumbDataParameter)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_31;
+ gBattleBuffersTransferData[1] = songId;
+ gBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+ for (i = 0; i < songId; i++) // ????
+ gBattleBuffersTransferData[3 + i] = *(u8*)(unusedDumbDataParameter++);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, songId + 3);
+}
+
+void EmitCmd32(u8 bufferId, u16 size, void *data)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_32;
+ gBattleBuffersTransferData[1] = size;
+ gBattleBuffersTransferData[2] = (size & 0xFF00) >> 8;
+ for (i = 0; i < size; i++)
+ gBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, size + 3);
+}
+
+void EmitCmd33(u8 bufferId, u8 arg1, u16 arg2)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_33;
+ gBattleBuffersTransferData[1] = arg1;
+ gBattleBuffersTransferData[2] = arg2;
+ gBattleBuffersTransferData[3] = (arg2 & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd34(u8 bufferId, u8 b, u8 *c)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_34;
+ gBattleBuffersTransferData[1] = b;
+ for (i = 0; i < 3; i++)
+ gBattleBuffersTransferData[2 + i] = c[i];
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 5);
+}
+
+void EmitCmd35(u8 bufferId, u16 b)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_35;
+ gBattleBuffersTransferData[1] = b;
+ gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8;
+ gBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd36(u8 bufferId, u16 b)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_36;
+ gBattleBuffersTransferData[1] = b;
+ gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8;
+ gBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd37(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_37;
+ gBattleBuffersTransferData[1] = 37;
+ gBattleBuffersTransferData[2] = 37;
+ gBattleBuffersTransferData[3] = 37;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd38(u8 bufferId, u8 b)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_38;
+ gBattleBuffersTransferData[1] = b;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
+}
+
+void EmitCmd39(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_39;
+ gBattleBuffersTransferData[1] = 39;
+ gBattleBuffersTransferData[2] = 39;
+ gBattleBuffersTransferData[3] = 39;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd40(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_40;
+ gBattleBuffersTransferData[1] = 40;
+ gBattleBuffersTransferData[2] = 40;
+ gBattleBuffersTransferData[3] = 40;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitHitAnimation(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_HITANIMATION;
+ gBattleBuffersTransferData[1] = 41;
+ gBattleBuffersTransferData[2] = 41;
+ gBattleBuffersTransferData[3] = 41;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd42(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_42;
+ gBattleBuffersTransferData[1] = 42;
+ gBattleBuffersTransferData[2] = 42;
+ gBattleBuffersTransferData[3] = 42;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitEffectivenessSound(u8 bufferId, u16 songId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_EFFECTIVENESSSOUND;
+ gBattleBuffersTransferData[1] = songId;
+ gBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+ gBattleBuffersTransferData[3] = 0;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitPlayFanfareOrBGM(u8 bufferId, u16 songId, bool8 playBGM)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_PLAYFANFAREORBGM;
+ gBattleBuffersTransferData[1] = songId;
+ gBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+ gBattleBuffersTransferData[3] = playBGM;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitFaintingCry(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_FAINTINGCRY;
+ gBattleBuffersTransferData[1] = 45;
+ gBattleBuffersTransferData[2] = 45;
+ gBattleBuffersTransferData[3] = 45;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitIntroSlide(u8 bufferId, u8 terrainId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_INTROSLIDE;
+ gBattleBuffersTransferData[1] = terrainId;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
+}
+
+void EmitIntroTrainerBallThrow(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_INTROTRAINERBALLTHROW;
+ gBattleBuffersTransferData[1] = 47;
+ gBattleBuffersTransferData[2] = 47;
+ gBattleBuffersTransferData[3] = 47;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 arg2)
+{
+ s32 i;
+
+ gBattleBuffersTransferData[0] = CONTROLLER_DRAWPARTYSTATUSSUMMARY;
+ gBattleBuffersTransferData[1] = arg2 & 0x7F;
+ gBattleBuffersTransferData[2] = (arg2 & 0x80) >> 7;
+ gBattleBuffersTransferData[3] = 48;
+ for (i = 0; i < (s32)(sizeof(struct HpAndStatus) * 6); i++)
+ gBattleBuffersTransferData[4 + i] = *(i + (u8*)(hpAndStatus));
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(struct HpAndStatus) * 6 + 4);
+}
+
+void EmitCmd49(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_49;
+ gBattleBuffersTransferData[1] = 49;
+ gBattleBuffersTransferData[2] = 49;
+ gBattleBuffersTransferData[3] = 49;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitCmd50(u8 bufferId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_50;
+ gBattleBuffersTransferData[1] = 50;
+ gBattleBuffersTransferData[2] = 50;
+ gBattleBuffersTransferData[3] = 50;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_SPRITEINVISIBILITY;
+ gBattleBuffersTransferData[1] = isInvisible;
+ gBattleBuffersTransferData[2] = 51;
+ gBattleBuffersTransferData[3] = 51;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitBattleAnimation(u8 bufferId, u8 animationId, u16 argument)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_BATTLEANIMATION;
+ gBattleBuffersTransferData[1] = animationId;
+ gBattleBuffersTransferData[2] = argument;
+ gBattleBuffersTransferData[3] = (argument & 0xFF00) >> 8;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
+}
+
+void EmitLinkStandbyMsg(u8 bufferId, u8 arg1, bool32 arg2)
+{
+ bool8 arg2_ = arg2;
+ gBattleBuffersTransferData[0] = CONTROLLER_LINKSTANDBYMSG;
+ gBattleBuffersTransferData[1] = arg1;
+
+ if (arg2_)
+ gBattleBuffersTransferData[3] = gBattleBuffersTransferData[2] = sub_81850DC(&gBattleBuffersTransferData[4]);
+ else
+ gBattleBuffersTransferData[3] = gBattleBuffersTransferData[2] = 0;
+
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, gBattleBuffersTransferData[2] + 4);
+}
+
+void EmitResetActionMoveSelection(u8 bufferId, u8 caseId)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_RESETACTIONMOVESELECTION;
+ gBattleBuffersTransferData[1] = caseId;
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
+}
+
+void EmitCmd55(u8 bufferId, u8 arg1)
+{
+ gBattleBuffersTransferData[0] = CONTROLLER_55;
+ gBattleBuffersTransferData[1] = arg1;
+ gBattleBuffersTransferData[2] = gSaveBlock2Ptr->field_CA9_b;
+ gBattleBuffersTransferData[3] = gSaveBlock2Ptr->field_CA9_b;
+ gBattleBuffersTransferData[5] = gBattleBuffersTransferData[4] = sub_81850DC(&gBattleBuffersTransferData[6]);
+ PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, gBattleBuffersTransferData[4] + 6);
+}
diff --git a/src/battle_interface.c b/src/battle_interface.c
new file mode 100644
index 000000000..9241db1d9
--- /dev/null
+++ b/src/battle_interface.c
@@ -0,0 +1,2632 @@
+#include "global.h"
+#include "battle.h"
+#include "pokemon.h"
+#include "battle_controllers.h"
+#include "battle_interface.h"
+#include "sprite.h"
+#include "window.h"
+#include "string_util.h"
+#include "text.h"
+#include "sound.h"
+#include "songs.h"
+#include "decompress.h"
+#include "task.h"
+#include "util.h"
+#include "gpu_regs.h"
+#include "battle_message.h"
+#include "species.h"
+#include "pokedex.h"
+#include "palette.h"
+#include "international_string_util.h"
+#include "safari_zone.h"
+#include "battle_anim.h"
+
+enum
+{
+ HEALTH_BAR,
+ EXP_BAR
+};
+
+enum
+{
+ HP_CURRENT,
+ HP_MAX
+};
+
+struct TestingBar
+{
+ s32 maxValue;
+ s32 currValue;
+ s32 field_8;
+ u32 unkC_0:5;
+ u32 unk10;
+};
+
+enum
+{
+ HEALTHBOX_GFX_0,
+ HEALTHBOX_GFX_1,
+ HEALTHBOX_GFX_2,
+ HEALTHBOX_GFX_3,
+ HEALTHBOX_GFX_4,
+ HEALTHBOX_GFX_5,
+ HEALTHBOX_GFX_6,
+ HEALTHBOX_GFX_7,
+ HEALTHBOX_GFX_8,
+ HEALTHBOX_GFX_9,
+ HEALTHBOX_GFX_10,
+ HEALTHBOX_GFX_11,
+ HEALTHBOX_GFX_12,
+ HEALTHBOX_GFX_13,
+ HEALTHBOX_GFX_14,
+ HEALTHBOX_GFX_15,
+ HEALTHBOX_GFX_16,
+ HEALTHBOX_GFX_17,
+ HEALTHBOX_GFX_18,
+ HEALTHBOX_GFX_19,
+ HEALTHBOX_GFX_20,
+ HEALTHBOX_GFX_STATUS_PSN_BANK0,
+ HEALTHBOX_GFX_22,
+ HEALTHBOX_GFX_23,
+ HEALTHBOX_GFX_STATUS_PRZ_BANK0,
+ HEALTHBOX_GFX_25,
+ HEALTHBOX_GFX_26,
+ HEALTHBOX_GFX_STATUS_SLP_BANK0,
+ HEALTHBOX_GFX_28,
+ HEALTHBOX_GFX_29,
+ HEALTHBOX_GFX_STATUS_FRZ_BANK0,
+ HEALTHBOX_GFX_31,
+ HEALTHBOX_GFX_32,
+ HEALTHBOX_GFX_STATUS_BRN_BANK0,
+ HEALTHBOX_GFX_34,
+ HEALTHBOX_GFX_35,
+ HEALTHBOX_GFX_36,
+ HEALTHBOX_GFX_37,
+ HEALTHBOX_GFX_38,
+ HEALTHBOX_GFX_39,
+ HEALTHBOX_GFX_40,
+ HEALTHBOX_GFX_41,
+ HEALTHBOX_GFX_42,
+ HEALTHBOX_GFX_43,
+ HEALTHBOX_GFX_44,
+ HEALTHBOX_GFX_45,
+ HEALTHBOX_GFX_46,
+ HEALTHBOX_GFX_47,
+ HEALTHBOX_GFX_48,
+ HEALTHBOX_GFX_49,
+ HEALTHBOX_GFX_50,
+ HEALTHBOX_GFX_51,
+ HEALTHBOX_GFX_52,
+ HEALTHBOX_GFX_53,
+ HEALTHBOX_GFX_54,
+ HEALTHBOX_GFX_55,
+ HEALTHBOX_GFX_56,
+ HEALTHBOX_GFX_57,
+ HEALTHBOX_GFX_58,
+ HEALTHBOX_GFX_59,
+ HEALTHBOX_GFX_60,
+ HEALTHBOX_GFX_61,
+ HEALTHBOX_GFX_62,
+ HEALTHBOX_GFX_63,
+ HEALTHBOX_GFX_64,
+ HEALTHBOX_GFX_65,
+ HEALTHBOX_GFX_66,
+ HEALTHBOX_GFX_67,
+ HEALTHBOX_GFX_68,
+ HEALTHBOX_GFX_69,
+ HEALTHBOX_GFX_70,
+ HEALTHBOX_GFX_STATUS_PSN_BANK1,
+ HEALTHBOX_GFX_72,
+ HEALTHBOX_GFX_73,
+ HEALTHBOX_GFX_STATUS_PRZ_BANK1,
+ HEALTHBOX_GFX_75,
+ HEALTHBOX_GFX_76,
+ HEALTHBOX_GFX_STATUS_SLP_BANK1,
+ HEALTHBOX_GFX_78,
+ HEALTHBOX_GFX_79,
+ HEALTHBOX_GFX_STATUS_FRZ_BANK1,
+ HEALTHBOX_GFX_81,
+ HEALTHBOX_GFX_82,
+ HEALTHBOX_GFX_STATUS_BRN_BANK1,
+ HEALTHBOX_GFX_84,
+ HEALTHBOX_GFX_85,
+ HEALTHBOX_GFX_STATUS_PSN_BANK2,
+ HEALTHBOX_GFX_87,
+ HEALTHBOX_GFX_88,
+ HEALTHBOX_GFX_STATUS_PRZ_BANK2,
+ HEALTHBOX_GFX_90,
+ HEALTHBOX_GFX_91,
+ HEALTHBOX_GFX_STATUS_SLP_BANK2,
+ HEALTHBOX_GFX_93,
+ HEALTHBOX_GFX_94,
+ HEALTHBOX_GFX_STATUS_FRZ_BANK2,
+ HEALTHBOX_GFX_96,
+ HEALTHBOX_GFX_97,
+ HEALTHBOX_GFX_STATUS_BRN_BANK2,
+ HEALTHBOX_GFX_99,
+ HEALTHBOX_GFX_100,
+ HEALTHBOX_GFX_STATUS_PSN_BANK3,
+ HEALTHBOX_GFX_102,
+ HEALTHBOX_GFX_103,
+ HEALTHBOX_GFX_STATUS_PRZ_BANK3,
+ HEALTHBOX_GFX_105,
+ HEALTHBOX_GFX_106,
+ HEALTHBOX_GFX_STATUS_SLP_BANK3,
+ HEALTHBOX_GFX_108,
+ HEALTHBOX_GFX_109,
+ HEALTHBOX_GFX_STATUS_FRZ_BANK3,
+ HEALTHBOX_GFX_111,
+ HEALTHBOX_GFX_112,
+ HEALTHBOX_GFX_STATUS_BRN_BANK3,
+ HEALTHBOX_GFX_114,
+ HEALTHBOX_GFX_115,
+ HEALTHBOX_GFX_116,
+ HEALTHBOX_GFX_117,
+};
+
+extern u8 gBanksByIdentity[BATTLE_BANKS_COUNT];
+extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
+extern u8 gNoOfAllBanks;
+extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT];
+
+extern const u8 * const gNatureNamePointers[];
+extern const u8 gSpeciesNames[][POKEMON_NAME_LENGTH + 1];
+
+// strings
+extern const u8 gText_Slash[];
+extern const u8 gText_HighlightDarkGrey[];
+extern const u8 gText_DynColor2[];
+extern const u8 gText_DynColor2Male[];
+extern const u8 gText_DynColor1Female[];
+extern const u8 gText_SafariBalls[];
+extern const u8 gText_SafariBallLeft[];
+
+// graphics
+extern const u8 gBattleInterface_BallStatusBarGfx[];
+extern const u8 gBattleInterface_BallDisplayGfx[];
+extern const u16 gBattleInterface_BallStatusBarPal[];
+extern const u16 gBattleInterface_BallDisplayPal[];
+extern const u8 gHealthboxElementsGfxTable[][32];
+
+// functions
+extern bool8 IsDoubleBattle(void);
+extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor *color, s8 speed, const u8 *str); // menu.h
+extern void LoadBattleBarGfx(u8 arg0);
+
+// this file's functions
+
+static const u8 *GetHealthboxElementGfxPtr(u8 elementId);
+static u8* AddTextPrinterAndCreateWindowOnHealthbox(const u8 *str, u32 x, u32 y, u32 arg3, u32 *windowId);
+
+static void RemoveWindowOnHealthbox(u32 windowId);
+static void UpdateHpTextInHealthboxInDoubles(u8 healthboxSpriteId, s16 value, u8 maxOrCurrent);
+static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId);
+
+static void sub_8075198(void *dest, u8 *windowTileData, s32 arg2);
+static void sub_80751E4(void *dest, u8 *windowTileData, u32 arg2);
+static void sub_8075170(void *dest, u8 *windowTileData, u32 arg2);
+static void sub_807513C(void *dest, u32 arg1, u32 arg2);
+
+static void sub_8073E08(u8 taskId);
+static void sub_8073F98(u8 taskId);
+static void sub_8073E64(u8 taskId);
+
+static void sub_8072924(struct Sprite *sprite);
+static void sub_80728B4(struct Sprite *sprite);
+static void sub_8074158(struct Sprite *sprite);
+static void sub_8074090(struct Sprite *sprite);
+static void SpriteCB_StatusSummaryBar(struct Sprite *sprite);
+static void SpriteCB_StatusSummaryBallsOnBattleStart(struct Sprite *sprite);
+static void SpriteCB_StatusSummaryBallsOnSwitchout(struct Sprite *sprite);
+
+static u8 GetStatusIconForBankId(u8 statusElementId, u8 bank);
+static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 arg4, u16 arg5);
+static u8 GetScaledExpFraction(s32 currValue, s32 arg1, s32 maxValue, u8 scale);
+static void sub_8074B9C(u8 bank, u8 whichBar);
+static u8 sub_8074E8C(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 *arg4, u8 arg5);
+static void sub_8074F88(struct TestingBar *barInfo, s32 *arg1, u16 *arg2);
+
+// const rom data
+static const struct OamData sUnknown_0832C138 =
+{
+ .y = 0,
+ .affineMode = 0,
+ .objMode = 0,
+ .mosaic = 0,
+ .bpp = 0,
+ .shape = 1,
+ .x = 0,
+ .matrixNum = 0,
+ .size = 3,
+ .tileNum = 0,
+ .priority = 1,
+ .paletteNum = 0,
+ .affineParam = 0,
+};
+
+static const struct SpriteTemplate sHealthboxPlayerSpriteTemplates[2] =
+{
+ {
+ .tileTag = TAG_HEALTHBOX_PLAYER1_TILE,
+ .paletteTag = TAG_HEALTHBOX_PAL,
+ .oam = &sUnknown_0832C138,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCallbackDummy
+ },
+ {
+ .tileTag = TAG_HEALTHBOX_PLAYER2_TILE,
+ .paletteTag = TAG_HEALTHBOX_PAL,
+ .oam = &sUnknown_0832C138,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCallbackDummy
+ }
+};
+
+static const struct SpriteTemplate sHealthboxOpponentSpriteTemplates[2] =
+{
+ {
+ .tileTag = TAG_HEALTHBOX_OPPONENT1_TILE,
+ .paletteTag = TAG_HEALTHBOX_PAL,
+ .oam = &sUnknown_0832C138,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCallbackDummy
+ },
+ {
+ .tileTag = TAG_HEALTHBOX_OPPONENT2_TILE,
+ .paletteTag = TAG_HEALTHBOX_PAL,
+ .oam = &sUnknown_0832C138,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCallbackDummy
+ }
+};
+
+static const struct SpriteTemplate sHealthboxSafariSpriteTemplate =
+{
+ .tileTag = TAG_HEALTHBOX_SAFARI_TILE,
+ .paletteTag = TAG_HEALTHBOX_PAL,
+ .oam = &sUnknown_0832C138,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCallbackDummy
+};
+
+static const struct OamData sUnknown_0832C1B8 =
+{
+ .y = 0,
+ .affineMode = 0,
+ .objMode = 0,
+ .mosaic = 0,
+ .bpp = 0,
+ .shape = 1,
+ .x = 0,
+ .matrixNum = 0,
+ .size = 1,
+ .tileNum = 0,
+ .priority = 1,
+ .paletteNum = 0,
+ .affineParam = 0,
+};
+
+static const struct SpriteTemplate sUnknown_0832C1C0[4] =
+{
+ {
+ .tileTag = 0xd704,
+ .paletteTag = 0xd704,
+ .oam = &sUnknown_0832C1B8,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = sub_80728B4
+ },
+ {
+ .tileTag = 0xd705,
+ .paletteTag = 0xd704,
+ .oam = &sUnknown_0832C1B8,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = sub_80728B4
+ },
+ {
+ .tileTag = 0xd706,
+ .paletteTag = 0xd704,
+ .oam = &sUnknown_0832C1B8,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = sub_80728B4
+ },
+ {
+ .tileTag = 0xd707,
+ .paletteTag = 0xd704,
+ .oam = &sUnknown_0832C1B8,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = sub_80728B4
+ }
+};
+
+static const struct Subsprite sUnknown_0832C220[] =
+{
+ {240, 0, 1, 3, 0, 1},
+ {48, 0, 0, 2, 32, 1},
+ {240, 32, 1, 1, 48, 1},
+ {16, 32, 1, 1, 52, 1},
+ {48, 32, 1, 1, 56, 1}
+};
+
+static const struct Subsprite sUnknown_0832C234[] =
+{
+ {240, 0, 1, 3, 64, 1},
+ {48, 0, 0, 2, 96, 1},
+ {240, 32, 1, 1, 112, 1},
+ {16, 32, 1, 1, 116, 1},
+ {48, 32, 1, 1, 120, 1}
+};
+
+static const struct Subsprite sUnknown_0832C248[] =
+{
+ {240, 0, 1, 3, 0, 1},
+ {48, 0, 0, 2, 32, 1}
+};
+
+static const struct Subsprite sUnknown_0832C250[] =
+{
+ {240, 0, 1, 3, 0, 1},
+ {48, 0, 0, 2, 32, 1}
+};
+
+static const struct Subsprite sUnknown_0832C258[] =
+{
+ {240, 0, 1, 1, 0, 1},
+ {16, 0, 1, 1, 4, 1}
+};
+
+static const struct Subsprite sUnknown_0832C260[] =
+{
+ {240, 0, 1, 1, 0, 1},
+ {16, 0, 1, 1, 4, 1},
+ {224, 0, 0, 0, 8, 1}
+};
+
+// unused subsprite table
+static const struct SubspriteTable sUnknown_0832C26C[] =
+{
+ {ARRAY_COUNT(sUnknown_0832C220), sUnknown_0832C220},
+ {ARRAY_COUNT(sUnknown_0832C248), sUnknown_0832C248},
+ {ARRAY_COUNT(sUnknown_0832C234), sUnknown_0832C234},
+ {ARRAY_COUNT(sUnknown_0832C250), sUnknown_0832C250}
+};
+
+static const struct SubspriteTable sUnknown_0832C28C[] =
+{
+ {ARRAY_COUNT(sUnknown_0832C258), sUnknown_0832C258},
+ {ARRAY_COUNT(sUnknown_0832C260), sUnknown_0832C260}
+};
+
+static const struct Subsprite sStatusSummaryBar_Subsprites_0[] =
+{
+ {160, 0, 1, 1, 0, 1},
+ {192, 0, 1, 1, 4, 1},
+ {224, 0, 1, 1, 8, 1},
+ {0, 0, 1, 1, 12, 1}
+};
+
+static const struct Subsprite sUnknown_0832C2AC[] =
+{
+ {160, 0, 1, 1, 0, 1},
+ {192, 0, 1, 1, 4, 1},
+ {224, 0, 1, 1, 8, 1},
+ {0, 0, 1, 1, 8, 1},
+ {32, 0, 1, 1, 8, 1},
+ {64, 0, 1, 1, 12, 1}
+};
+
+static const struct SubspriteTable sStatusSummaryBar_SubspriteTable[] =
+{
+ {ARRAY_COUNT(sStatusSummaryBar_Subsprites_0), sStatusSummaryBar_Subsprites_0}
+};
+
+static const struct SubspriteTable sUnknown_0832C2CC[] =
+{
+ {ARRAY_COUNT(sUnknown_0832C2AC), sUnknown_0832C2AC}
+};
+
+// unused unknown image
+static const u8 sUnknown_0832C2D4[] = INCBIN_U8("graphics/battle_interface/unknown_32C2D4.4bpp");
+
+static const struct CompressedSpriteSheet sStatusSummaryBarSpriteSheet =
+{
+ gBattleInterface_BallStatusBarGfx, 0x200, TAG_STATUS_SUMMARY_BAR_TILE
+};
+
+static const struct SpritePalette sStatusSummaryBarSpritePal =
+{
+ gBattleInterface_BallStatusBarPal, TAG_STATUS_SUMMARY_BAR_PAL
+};
+
+static const struct SpritePalette sStatusSummaryBallsSpritePal =
+{
+ gBattleInterface_BallDisplayPal, TAG_STATUS_SUMMARY_BALLS_PAL
+};
+
+static const struct SpriteSheet sStatusSummaryBallsSpriteSheet =
+{
+ gBattleInterface_BallDisplayGfx, 0x80, TAG_STATUS_SUMMARY_BALLS_TILE
+};
+
+// unused oam data
+static const struct OamData sUnknown_0832C354 =
+{
+ .y = 0,
+ .affineMode = 0,
+ .objMode = 0,
+ .mosaic = 0,
+ .bpp = 0,
+ .shape = 1,
+ .x = 0,
+ .matrixNum = 0,
+ .size = 3,
+ .tileNum = 0,
+ .priority = 1,
+ .paletteNum = 0,
+ .affineParam = 0,
+};
+
+static const struct OamData sOamData_StatusSummaryBalls =
+{
+ .y = 0,
+ .affineMode = 0,
+ .objMode = 0,
+ .mosaic = 0,
+ .bpp = 0,
+ .shape = 0,
+ .x = 0,
+ .matrixNum = 0,
+ .size = 0,
+ .tileNum = 0,
+ .priority = 1,
+ .paletteNum = 0,
+ .affineParam = 0,
+};
+
+static const struct SpriteTemplate sStatusSummaryBarSpriteTemplates[2] =
+{
+ {
+ .tileTag = TAG_STATUS_SUMMARY_BAR_TILE,
+ .paletteTag = TAG_STATUS_SUMMARY_BAR_PAL,
+ .oam = &sUnknown_0832C138,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCB_StatusSummaryBar
+ },
+ {
+ .tileTag = TAG_STATUS_SUMMARY_BAR_TILE,
+ .paletteTag = TAG_STATUS_SUMMARY_BAR_PAL,
+ .oam = &sUnknown_0832C138,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCB_StatusSummaryBar
+ }
+};
+
+static const struct SpriteTemplate sStatusSummaryBallsSpriteTemplates[2] =
+{
+ {
+ .tileTag = TAG_STATUS_SUMMARY_BALLS_TILE,
+ .paletteTag = TAG_STATUS_SUMMARY_BALLS_PAL,
+ .oam = &sOamData_StatusSummaryBalls,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCB_StatusSummaryBallsOnBattleStart
+ },
+ {
+ .tileTag = TAG_STATUS_SUMMARY_BALLS_TILE,
+ .paletteTag = TAG_STATUS_SUMMARY_BALLS_PAL,
+ .oam = &sOamData_StatusSummaryBalls,
+ .anims = gDummySpriteAnimTable,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCB_StatusSummaryBallsOnBattleStart
+ }
+};
+
+// possibly text
+static const u8 sUnknown_0832C3C4[] =
+{
+ 0xfc, 0x01, 0x01, 0xfc, 0x02, 0x02, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+};
+
+// possibly text
+static const u8 sUnknown_0832C3D8[] =
+{
+ 0xfc, 0x01, 0x01, 0xfc, 0x02, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+};
+
+enum
+{
+ PAL_STATUS_PSN,
+ PAL_STATUS_PAR,
+ PAL_STATUS_SLP,
+ PAL_STATUS_FRZ,
+ PAL_STATUS_BRN
+};
+
+static const u16 sStatusIconPalettes[] =
+{
+ 0x6198, // PAL_STATUS_PSN
+ 0xEF7, // PAL_STATUS_PAR
+ 0x4694, // PAL_STATUS_SLP
+ 0x72D1, // PAL_STATUS_FRZ
+ 0x29DC // PAL_STATUS_BRN
+};
+
+static const struct WindowTemplate sHealthboxWindowTemplate = {0, 0, 0, 8, 2, 0, 0}; // width = 8, height = 2
+
+// code
+
+static s32 DummiedOutFunction(s16 unused1, s16 unused2, s32 unused3)
+{
+ return 9;
+}
+
+#ifdef NONMATCHING
+static void sub_8072308(s16 arg0, u16 *arg1, u8 arg2)
+{
+ s8 i, j;
+ u8 array[4];
+ u8 *arrayPtr;
+ s32 r9, vaaa;
+
+ for (i = 0; i < 4; i++)
+ array[i] = 0;
+
+ i = 3;
+ r9 = -1;
+ arrayPtr = array;
+ while (1)
+ {
+ if (arg0 > 0)
+ {
+ array[i] = arg0 % 10;
+ arg0 = arg0 / 10;
+ i--;
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ for (; i > -1; i--)
+ {
+ array[i] = 0xFF;
+ }
+
+ if (arrayPtr[3] == 0xFF)
+ arrayPtr[3] = 0;
+
+ if (arg2 == 0)
+ {
+ for (i = 0, j = 0; i < 4; i++)
+ {
+ if (array[j] == 0xFF)
+ {
+ arg1[j] &= 0xFC00;
+ arg1[j] |= 0x1E;
+
+ arg1[i + 0x20] &= 0xFC00;
+ arg1[i + 0x20] |= 0x1E;
+ }
+ else
+ {
+ arg1[j] &= 0xFC00;
+ arg1[j] |= array[j] + 0x14;
+
+ arg1[i + 0x20] &= 0xFC00;
+ arg1[i + 0x20] |= array[i] + 0x34;
+ }
+ j++;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 4; i++)
+ {
+ if (array[i] == 0xFF)
+ {
+ arg1[i] &= 0xFC00;
+ arg1[i] |= 0x1E;
+
+ arg1[i + 0x20] &= 0xFC00;
+ arg1[i + 0x20] |= 0x1E;
+ }
+ else
+ {
+ arg1[i] &= 0xFC00;
+ arg1[i] |= array[i] + 0x14;
+
+ arg1[i + 0x20] &= 0xFC00;
+ arg1[i + 0x20] |= array[i] + 0x34;
+ }
+ }
+ }
+}
+
+#else
+__attribute__((naked))
+static void sub_8072308(s16 arg0, u16 *arg1, u8 arg2)
+{
+ asm(".syntax unified\n\
+ push {r4-r7,lr}\n\
+ mov r7, r10\n\
+ mov r6, r9\n\
+ mov r5, r8\n\
+ push {r5-r7}\n\
+ sub sp, 0x4\n\
+ adds r7, r1, 0\n\
+ lsls r0, 16\n\
+ lsrs r5, r0, 16\n\
+ lsls r2, 24\n\
+ lsrs r2, 24\n\
+ mov r10, r2\n\
+ movs r3, 0\n\
+ movs r2, 0\n\
+_08072324:\n\
+ lsls r0, r3, 24\n\
+ asrs r0, 24\n\
+ mov r3, sp\n\
+ adds r1, r3, r0\n\
+ strb r2, [r1]\n\
+ adds r0, 0x1\n\
+ lsls r0, 24\n\
+ lsrs r3, r0, 24\n\
+ asrs r0, 24\n\
+ cmp r0, 0x3\n\
+ ble _08072324\n\
+ movs r3, 0x3\n\
+ movs r0, 0x1\n\
+ negs r0, r0\n\
+ mov r9, r0\n\
+ mov r8, sp\n\
+_08072344:\n\
+ lsls r0, r5, 16\n\
+ asrs r6, r0, 16\n\
+ cmp r6, 0\n\
+ ble _08072372\n\
+ lsls r4, r3, 24\n\
+ asrs r4, 24\n\
+ mov r1, sp\n\
+ adds r5, r1, r4\n\
+ adds r0, r6, 0\n\
+ movs r1, 0xA\n\
+ bl __modsi3\n\
+ strb r0, [r5]\n\
+ adds r0, r6, 0\n\
+ movs r1, 0xA\n\
+ bl __divsi3\n\
+ lsls r0, 16\n\
+ lsrs r5, r0, 16\n\
+ subs r4, 0x1\n\
+ lsls r4, 24\n\
+ lsrs r3, r4, 24\n\
+ b _08072344\n\
+_08072372:\n\
+ lsls r1, r3, 24\n\
+ asrs r0, r1, 24\n\
+ cmp r0, r9\n\
+ ble _08072396\n\
+ movs r4, 0xFF\n\
+ movs r3, 0x1\n\
+ negs r3, r3\n\
+_08072380:\n\
+ asrs r2, r1, 24\n\
+ mov r5, sp\n\
+ adds r1, r5, r2\n\
+ ldrb r0, [r1]\n\
+ orrs r0, r4\n\
+ strb r0, [r1]\n\
+ subs r2, 0x1\n\
+ lsls r1, r2, 24\n\
+ asrs r0, r1, 24\n\
+ cmp r0, r3\n\
+ bgt _08072380\n\
+_08072396:\n\
+ mov r1, r8\n\
+ ldrb r0, [r1, 0x3]\n\
+ cmp r0, 0xFF\n\
+ bne _080723A2\n\
+ movs r0, 0\n\
+ strb r0, [r1, 0x3]\n\
+_080723A2:\n\
+ mov r2, r10\n\
+ cmp r2, 0\n\
+ bne _08072432\n\
+ movs r3, 0\n\
+ movs r1, 0\n\
+ movs r6, 0xFC\n\
+ lsls r6, 8\n\
+ movs r5, 0x1E\n\
+ mov r12, r5\n\
+_080723B4:\n\
+ lsls r1, 24\n\
+ asrs r2, r1, 24\n\
+ mov r0, sp\n\
+ adds r5, r0, r2\n\
+ ldrb r0, [r5]\n\
+ mov r8, r1\n\
+ cmp r0, 0xFF\n\
+ bne _080723EA\n\
+ lsls r1, r2, 1\n\
+ adds r1, r7\n\
+ ldrh r2, [r1]\n\
+ adds r0, r6, 0\n\
+ ands r0, r2\n\
+ mov r2, r12\n\
+ orrs r0, r2\n\
+ strh r0, [r1]\n\
+ lsls r3, 24\n\
+ asrs r1, r3, 23\n\
+ adds r1, r7\n\
+ adds r1, 0x40\n\
+ ldrh r2, [r1]\n\
+ adds r0, r6, 0\n\
+ ands r0, r2\n\
+ mov r5, r12\n\
+ orrs r0, r5\n\
+ strh r0, [r1]\n\
+ b _0807241A\n\
+_080723EA:\n\
+ lsls r2, 1\n\
+ adds r2, r7\n\
+ ldrh r0, [r2]\n\
+ adds r1, r6, 0\n\
+ ands r1, r0\n\
+ ldrb r0, [r5]\n\
+ adds r0, 0x14\n\
+ orrs r1, r0\n\
+ strh r1, [r2]\n\
+ lsls r4, r3, 24\n\
+ asrs r3, r4, 24\n\
+ lsls r2, r3, 1\n\
+ adds r2, r7\n\
+ adds r2, 0x40\n\
+ ldrh r0, [r2]\n\
+ adds r1, r6, 0\n\
+ ands r1, r0\n\
+ mov r5, sp\n\
+ adds r0, r5, r3\n\
+ ldrb r0, [r0]\n\
+ adds r0, 0x34\n\
+ orrs r1, r0\n\
+ strh r1, [r2]\n\
+ adds r3, r4, 0\n\
+_0807241A:\n\
+ movs r0, 0x80\n\
+ lsls r0, 17\n\
+ add r0, r8\n\
+ lsrs r1, r0, 24\n\
+ movs r2, 0x80\n\
+ lsls r2, 17\n\
+ adds r0, r3, r2\n\
+ lsrs r3, r0, 24\n\
+ asrs r0, 24\n\
+ cmp r0, 0x3\n\
+ ble _080723B4\n\
+ b _08072496\n\
+_08072432:\n\
+ movs r3, 0\n\
+ movs r4, 0xFC\n\
+ lsls r4, 8\n\
+ movs r6, 0x1E\n\
+_0807243A:\n\
+ lsls r1, r3, 24\n\
+ asrs r2, r1, 24\n\
+ mov r3, sp\n\
+ adds r5, r3, r2\n\
+ ldrb r0, [r5]\n\
+ adds r3, r1, 0\n\
+ cmp r0, 0xFF\n\
+ bne _08072466\n\
+ lsls r1, r2, 1\n\
+ adds r1, r7\n\
+ ldrh r2, [r1]\n\
+ adds r0, r4, 0\n\
+ ands r0, r2\n\
+ orrs r0, r6\n\
+ strh r0, [r1]\n\
+ adds r1, 0x40\n\
+ ldrh r2, [r1]\n\
+ adds r0, r4, 0\n\
+ ands r0, r2\n\
+ orrs r0, r6\n\
+ strh r0, [r1]\n\
+ b _08072488\n\
+_08072466:\n\
+ lsls r2, 1\n\
+ adds r2, r7\n\
+ ldrh r0, [r2]\n\
+ adds r1, r4, 0\n\
+ ands r1, r0\n\
+ ldrb r0, [r5]\n\
+ adds r0, 0x14\n\
+ orrs r1, r0\n\
+ strh r1, [r2]\n\
+ adds r2, 0x40\n\
+ ldrh r0, [r2]\n\
+ adds r1, r4, 0\n\
+ ands r1, r0\n\
+ ldrb r0, [r5]\n\
+ adds r0, 0x34\n\
+ orrs r1, r0\n\
+ strh r1, [r2]\n\
+_08072488:\n\
+ movs r5, 0x80\n\
+ lsls r5, 17\n\
+ adds r0, r3, r5\n\
+ lsrs r3, r0, 24\n\
+ asrs r0, 24\n\
+ cmp r0, 0x3\n\
+ ble _0807243A\n\
+_08072496:\n\
+ add sp, 0x4\n\
+ pop {r3-r5}\n\
+ mov r8, r3\n\
+ mov r9, r4\n\
+ mov r10, r5\n\
+ pop {r4-r7}\n\
+ pop {r0}\n\
+ bx r0\n\
+ .syntax divided");
+}
+
+#endif // NONMATCHING
+
+void sub_80724A8(s16 arg0, s16 arg1, u16 *arg2)
+{
+ arg2[4] = 0x1E;
+ sub_8072308(arg1, arg2, 0);
+ sub_8072308(arg0, arg2 + 5, 1);
+}
+
+// because the healthbox is too large to fit into one sprite, it is divided into two sprites
+// healthboxSpriteId_1 or healthboxSpriteId refers to the 'main' healthbox
+// healthboxSpriteId_2 refers to the other part
+// there's also one other sprite that appears to be a black square? dont fully understand its role
+
+u8 CreateBankHealthboxSprites(u8 bank)
+{
+ s16 data6 = 0;
+ u8 healthboxSpriteId_1, healthboxSpriteId_2;
+ u8 unkSpriteId;
+ struct Sprite *unkSpritePtr;
+
+ if (!IsDoubleBattle())
+ {
+ if (GetBankSide(bank) == SIDE_PLAYER)
+ {
+ healthboxSpriteId_1 = CreateSprite(&sHealthboxPlayerSpriteTemplates[0], 240, 160, 1);
+ healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxPlayerSpriteTemplates[0], 240, 160, 1);
+
+ gSprites[healthboxSpriteId_1].oam.shape = 0;
+
+ gSprites[healthboxSpriteId_2].oam.shape = 0;
+ gSprites[healthboxSpriteId_2].oam.tileNum += 64;
+ }
+ else
+ {
+ healthboxSpriteId_1 = CreateSprite(&sHealthboxOpponentSpriteTemplates[0], 240, 160, 1);
+ healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxOpponentSpriteTemplates[0], 240, 160, 1);
+
+ gSprites[healthboxSpriteId_2].oam.tileNum += 32;
+
+ data6 = 2;
+ }
+ gSprites[healthboxSpriteId_1].oam.affineParam = healthboxSpriteId_2;
+ gSprites[healthboxSpriteId_2].data5 = healthboxSpriteId_1;
+ gSprites[healthboxSpriteId_2].callback = sub_8072924;
+ }
+ else
+ {
+ if (GetBankSide(bank) == SIDE_PLAYER)
+ {
+ healthboxSpriteId_1 = CreateSprite(&sHealthboxPlayerSpriteTemplates[GetBankIdentity(bank) / 2], 240, 160, 1);
+ healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxPlayerSpriteTemplates[GetBankIdentity(bank) / 2], 240, 160, 1);
+
+ gSprites[healthboxSpriteId_1].oam.affineParam = healthboxSpriteId_2;
+
+ gSprites[healthboxSpriteId_2].data5 = healthboxSpriteId_1;
+ gSprites[healthboxSpriteId_2].oam.tileNum += 32;
+ gSprites[healthboxSpriteId_2].callback = sub_8072924;
+
+ data6 = 1;
+ }
+ else
+ {
+ healthboxSpriteId_1 = CreateSprite(&sHealthboxOpponentSpriteTemplates[GetBankIdentity(bank) / 2], 240, 160, 1);
+ healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxOpponentSpriteTemplates[GetBankIdentity(bank) / 2], 240, 160, 1);
+
+ gSprites[healthboxSpriteId_1].oam.affineParam = healthboxSpriteId_2;
+
+ gSprites[healthboxSpriteId_2].data5 = healthboxSpriteId_1;
+ gSprites[healthboxSpriteId_2].oam.tileNum += 32;
+ gSprites[healthboxSpriteId_2].callback = sub_8072924;
+
+ data6 = 2;
+ }
+ }
+
+ unkSpriteId = CreateSpriteAtEnd(&sUnknown_0832C1C0[gBanksByIdentity[bank]], 140, 60, 0);
+ unkSpritePtr = &gSprites[unkSpriteId];
+ SetSubspriteTables(unkSpritePtr, &sUnknown_0832C28C[GetBankSide(bank)]);
+ unkSpritePtr->subspriteMode = 2;
+ unkSpritePtr->oam.priority = 1;
+
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_1), (void*)(OBJ_VRAM0 + unkSpritePtr->oam.tileNum * 32), 64);
+
+ gSprites[healthboxSpriteId_1].data5 = unkSpriteId;
+ gSprites[healthboxSpriteId_1].data6 = bank;
+ gSprites[healthboxSpriteId_1].invisible = 1;
+
+ gSprites[healthboxSpriteId_2].invisible = 1;
+
+ unkSpritePtr->data5 = healthboxSpriteId_1;
+ unkSpritePtr->data6 = data6;
+ unkSpritePtr->invisible = 1;
+
+ return healthboxSpriteId_1;
+}
+
+u8 CreateSafariPlayerHealthboxSprites(void)
+{
+ u8 healthboxSpriteId_1, healthboxSpriteId_2;
+
+ healthboxSpriteId_1 = CreateSprite(&sHealthboxSafariSpriteTemplate, 240, 160, 1);
+ healthboxSpriteId_2 = CreateSpriteAtEnd(&sHealthboxSafariSpriteTemplate, 240, 160, 1);
+
+ gSprites[healthboxSpriteId_1].oam.shape = 0;
+ gSprites[healthboxSpriteId_2].oam.shape = 0;
+
+ gSprites[healthboxSpriteId_2].oam.tileNum += 64;
+
+ gSprites[healthboxSpriteId_1].oam.affineParam = healthboxSpriteId_2;
+ gSprites[healthboxSpriteId_2].data5 = healthboxSpriteId_1;
+
+ gSprites[healthboxSpriteId_2].callback = sub_8072924;
+
+ return healthboxSpriteId_1;
+}
+
+static const u8 *GetHealthboxElementGfxPtr(u8 elementId)
+{
+ return gHealthboxElementsGfxTable[elementId];
+}
+
+static void sub_80728B4(struct Sprite *sprite)
+{
+ u8 var = sprite->data5;
+
+ switch (sprite->data6)
+ {
+ case 0:
+ sprite->pos1.x = gSprites[var].pos1.x + 16;
+ sprite->pos1.y = gSprites[var].pos1.y;
+ break;
+ case 1:
+ sprite->pos1.x = gSprites[var].pos1.x + 16;
+ sprite->pos1.y = gSprites[var].pos1.y;
+ break;
+ case 2:
+ default:
+ sprite->pos1.x = gSprites[var].pos1.x + 8;
+ sprite->pos1.y = gSprites[var].pos1.y;
+ break;
+ }
+
+ sprite->pos2.x = gSprites[var].pos2.x;
+ sprite->pos2.y = gSprites[var].pos2.y;
+}
+
+static void sub_8072924(struct Sprite *sprite)
+{
+ u8 otherSpriteId = sprite->data5;
+
+ sprite->pos1.x = gSprites[otherSpriteId].pos1.x + 64;
+ sprite->pos1.y = gSprites[otherSpriteId].pos1.y;
+
+ sprite->pos2.x = gSprites[otherSpriteId].pos2.x;
+ sprite->pos2.y = gSprites[otherSpriteId].pos2.y;
+}
+
+void SetBattleBarStruct(u8 bank, u8 healthboxSpriteId, s32 maxVal, s32 currVal, s32 field_C)
+{
+ gBattleSpritesDataPtr->battleBars[bank].healthboxSpriteId = healthboxSpriteId;
+ gBattleSpritesDataPtr->battleBars[bank].maxValue = maxVal;
+ gBattleSpritesDataPtr->battleBars[bank].currentValue = currVal;
+ gBattleSpritesDataPtr->battleBars[bank].field_C = field_C;
+ gBattleSpritesDataPtr->battleBars[bank].field_10 = -32768;
+}
+
+void SetHealthboxSpriteInvisible(u8 healthboxSpriteId)
+{
+ gSprites[healthboxSpriteId].invisible = 1;
+ gSprites[gSprites[healthboxSpriteId].data5].invisible = 1;
+ gSprites[gSprites[healthboxSpriteId].oam.affineParam].invisible = 1;
+}
+
+void SetHealthboxSpriteVisible(u8 healthboxSpriteId)
+{
+ gSprites[healthboxSpriteId].invisible = 0;
+ gSprites[gSprites[healthboxSpriteId].data5].invisible = 0;
+ gSprites[gSprites[healthboxSpriteId].oam.affineParam].invisible = 0;
+}
+
+static void UpdateSpritePos(u8 spriteId, s16 x, s16 y)
+{
+ gSprites[spriteId].pos1.x = x;
+ gSprites[spriteId].pos1.y = y;
+}
+
+void DestoryHealthboxSprite(u8 healthboxSpriteId)
+{
+ DestroySprite(&gSprites[gSprites[healthboxSpriteId].oam.affineParam]);
+ DestroySprite(&gSprites[gSprites[healthboxSpriteId].data5]);
+ DestroySprite(&gSprites[healthboxSpriteId]);
+}
+
+void DummyBattleInterfaceFunc(u8 healthboxSpriteId, bool8 isDoubleBattleBankOnly)
+{
+
+}
+
+void UpdateOamPriorityInAllHealthboxes(u8 priority)
+{
+ s32 i;
+
+ for (i = 0; i < gNoOfAllBanks; i++)
+ {
+ u8 healthboxSpriteId_1 = gHealthBoxesIds[i];
+ u8 healthboxSpriteId_2 = gSprites[gHealthBoxesIds[i]].oam.affineParam;
+ u8 healthboxSpriteId_3 = gSprites[gHealthBoxesIds[i]].data5;
+
+ gSprites[healthboxSpriteId_1].oam.priority = priority;
+ gSprites[healthboxSpriteId_2].oam.priority = priority;
+ gSprites[healthboxSpriteId_3].oam.priority = priority;
+ }
+}
+
+void SetBankHealthboxSpritePos(u8 bank)
+{
+ s16 x = 0, y = 0;
+
+ if (!IsDoubleBattle())
+ {
+ if (GetBankSide(bank) != SIDE_PLAYER)
+ x = 44, y = 30;
+ else
+ x = 158, y = 88;
+ }
+ else
+ {
+ switch (GetBankIdentity(bank))
+ {
+ case IDENTITY_PLAYER_MON1:
+ x = 159, y = 76;
+ break;
+ case IDENTITY_PLAYER_MON2:
+ x = 171, y = 101;
+ break;
+ case IDENTITY_OPPONENT_MON1:
+ x = 44, y = 19;
+ break;
+ case IDENTITY_OPPONENT_MON2:
+ x = 32, y = 44;
+ break;
+ }
+ }
+
+ UpdateSpritePos(gHealthBoxesIds[bank], x, y);
+}
+
+static void UpdateLvlInHealthbox(u8 healthboxSpriteId, u8 lvl)
+{
+ u32 windowId, spriteTileNum;
+ u8 *windowTileData;
+ u8 text[16];
+ u32 xPos, var1;
+ void *objVram;
+
+ text[0] = 0xF9;
+ text[1] = 5;
+
+ xPos = (u32) ConvertIntToDecimalStringN(text + 2, lvl, STR_CONV_MODE_LEFT_ALIGN, 3);
+ // Alright, that part was unmatchable. It's basically doing:
+ // xPos = 5 * (3 - (u32)(&text[2]));
+ xPos--;
+ xPos--;
+ xPos -= ((u32)(text));
+ var1 = (3 - xPos);
+ xPos = 4 * var1;
+ xPos += var1;
+
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(text, xPos, 3, 2, &windowId);
+ spriteTileNum = gSprites[healthboxSpriteId].oam.tileNum * 32;
+
+ if (GetBankSide(gSprites[healthboxSpriteId].data6) == SIDE_PLAYER)
+ {
+ objVram = (void*)(OBJ_VRAM0);
+ if (!IsDoubleBattle())
+ objVram += spriteTileNum + 0x820;
+ else
+ objVram += spriteTileNum + 0x420;
+ }
+ else
+ {
+ objVram = (void*)(OBJ_VRAM0);
+ objVram += spriteTileNum + 0x400;
+ }
+ sub_8075198(objVram, windowTileData, 3);
+ RemoveWindowOnHealthbox(windowId);
+}
+
+void UpdateHpTextInHealthbox(u8 healthboxSpriteId, s16 value, u8 maxOrCurrent)
+{
+ u32 windowId, spriteTileNum;
+ u8 *windowTileData;
+ u8 text[32];
+ void *objVram;
+
+ if (GetBankSide(gSprites[healthboxSpriteId].data6) == SIDE_PLAYER && !IsDoubleBattle())
+ {
+ spriteTileNum = gSprites[healthboxSpriteId].oam.tileNum * 32;
+ if (maxOrCurrent != HP_CURRENT) // singles, max
+ {
+ ConvertIntToDecimalStringN(text, value, STR_CONV_MODE_RIGHT_ALIGN, 3);
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(text, 0, 5, 2, &windowId);
+ objVram = (void*)(OBJ_VRAM0);
+ objVram += spriteTileNum + 0xB40;
+ sub_8075170(objVram, windowTileData, 2);
+ RemoveWindowOnHealthbox(windowId);
+ }
+ else // singles, current
+ {
+ ConvertIntToDecimalStringN(text, value, STR_CONV_MODE_RIGHT_ALIGN, 3);
+ text[3] = CHAR_SLASH;
+ text[4] = EOS;
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(text, 4, 5, 2, &windowId);
+ objVram = (void*)(OBJ_VRAM0);
+ objVram += spriteTileNum + 0x3E0;
+ sub_8075170(objVram, windowTileData, 1);
+ objVram = (void*)(OBJ_VRAM0);
+ objVram += spriteTileNum + 0xB00;
+ sub_8075170(objVram, windowTileData + 0x20, 2);
+ RemoveWindowOnHealthbox(windowId);
+ }
+
+ }
+ else
+ {
+ u8 bank;
+
+ memcpy(text, sUnknown_0832C3C4, sizeof(sUnknown_0832C3C4));
+ bank = gSprites[healthboxSpriteId].data6;
+ if (IsDoubleBattle() == TRUE || GetBankSide(bank) == SIDE_OPPONENT)
+ {
+ UpdateHpTextInHealthboxInDoubles(healthboxSpriteId, value, maxOrCurrent);
+ }
+ else
+ {
+ u32 var;
+ u8 i;
+
+ if (GetBankSide(gSprites[healthboxSpriteId].data6) == SIDE_PLAYER)
+ {
+ if (maxOrCurrent == HP_CURRENT)
+ var = 29;
+ else
+ var = 89;
+ }
+ else
+ {
+ if (maxOrCurrent == HP_CURRENT)
+ var = 20;
+ else
+ var = 48;
+ }
+
+ ConvertIntToDecimalStringN(text + 6, value, STR_CONV_MODE_RIGHT_ALIGN, 3);
+ RenderTextFont9(gMonSpritesGfxPtr->fontPixels, 9, text);
+
+ for (i = 0; i < 3; i++)
+ {
+ CpuCopy32(&gMonSpritesGfxPtr->fontPixels[i * 64 + 32],
+ (void*)((OBJ_VRAM0) + 32 * (gSprites[healthboxSpriteId].oam.tileNum + var + i)),
+ 0x20);
+ }
+ }
+ }
+}
+
+static void UpdateHpTextInHealthboxInDoubles(u8 healthboxSpriteId, s16 value, u8 maxOrCurrent)
+{
+ u32 windowId, spriteTileNum;
+ u8 *windowTileData;
+ u8 text[32];
+ void *objVram;
+
+ if (GetBankSide(gSprites[healthboxSpriteId].data6) == SIDE_PLAYER)
+ {
+ if (gBattleSpritesDataPtr->bankData[gSprites[healthboxSpriteId].data6].hpNumbersNoBars) // don't print text if only bars are visible
+ {
+ spriteTileNum = gSprites[gSprites[healthboxSpriteId].data5].oam.tileNum * 32;
+ objVram = (void*)(OBJ_VRAM0) + spriteTileNum;
+
+ if (maxOrCurrent != HP_CURRENT) // doubles, max hp
+ {
+ ConvertIntToDecimalStringN(text, value, STR_CONV_MODE_RIGHT_ALIGN, 3);
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(text, 0, 5, 0, &windowId);
+ sub_8075170((void*)(OBJ_VRAM0) + spriteTileNum + 0xC0, windowTileData, 2);
+ RemoveWindowOnHealthbox(windowId);
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_116),
+ (void*)(OBJ_VRAM0 + 0x680) + (gSprites[healthboxSpriteId].oam.tileNum * 32),
+ 0x20);
+ }
+ else
+ {
+ ConvertIntToDecimalStringN(text, value, STR_CONV_MODE_RIGHT_ALIGN, 3);
+ text[3] = CHAR_SLASH;
+ text[4] = EOS;
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(text, 4, 5, 0, &windowId);
+ sub_807513C(objVram, 0, 3);
+ sub_8075170((void*)(OBJ_VRAM0 + 0x60) + spriteTileNum, windowTileData, 3);
+ RemoveWindowOnHealthbox(windowId);
+ }
+ }
+ }
+ else
+ {
+ u8 bank;
+
+ memcpy(text, sUnknown_0832C3D8, sizeof(sUnknown_0832C3D8));
+ bank = gSprites[healthboxSpriteId].data6;
+
+ if (gBattleSpritesDataPtr->bankData[bank].hpNumbersNoBars) // don't print text if only bars are visible
+ {
+ u8 var = 4;
+ u8 r7;
+ u8 *txtPtr;
+ u8 i;
+
+ if (maxOrCurrent == HP_CURRENT)
+ var = 0;
+
+ r7 = gSprites[healthboxSpriteId].data5;
+ txtPtr = ConvertIntToDecimalStringN(text + 6, value, STR_CONV_MODE_RIGHT_ALIGN, 3);
+ if (!maxOrCurrent)
+ StringCopy(txtPtr, gText_Slash);
+ RenderTextFont9(gMonSpritesGfxPtr->fontPixels, 9, text);
+
+ for (i = var; i < var + 3; i++)
+ {
+ if (i < 3)
+ {
+ CpuCopy32(&gMonSpritesGfxPtr->fontPixels[((i - var) * 64) + 32],
+ (void*)((OBJ_VRAM0) + 32 * (1 + gSprites[r7].oam.tileNum + i)),
+ 0x20);
+ }
+ else
+ {
+ CpuCopy32(&gMonSpritesGfxPtr->fontPixels[((i - var) * 64) + 32],
+ (void*)((OBJ_VRAM0 + 0x20) + 32 * (i + gSprites[r7].oam.tileNum)),
+ 0x20);
+ }
+ }
+
+ if (maxOrCurrent == HP_CURRENT)
+ {
+ CpuCopy32(&gMonSpritesGfxPtr->fontPixels[224],
+ (void*)((OBJ_VRAM0) + ((gSprites[r7].oam.tileNum + 4) * 32)),
+ 0x20);
+ CpuFill32(0, (void*)((OBJ_VRAM0) + (gSprites[r7].oam.tileNum * 32)), 0x20);
+ }
+ else
+ {
+ if (GetBankSide(bank) == SIDE_PLAYER) // impossible to reach part, because the bank is from the opponent's side
+ {
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_116),
+ (void*)(OBJ_VRAM0) + ((gSprites[healthboxSpriteId].oam.tileNum + 52) * 32),
+ 0x20);
+ }
+ }
+ }
+ }
+}
+
+static void sub_80730D4(u8 healthboxSpriteId, struct Pokemon *mon)
+{
+ u8 text[20];
+ s32 j, var2;
+ u8 *fontPixels;
+ u8 i, var, nature, healthboxSpriteId_2;
+
+ memcpy(text, sUnknown_0832C3C4, sizeof(sUnknown_0832C3C4));
+ fontPixels = &gMonSpritesGfxPtr->fontPixels[0x520 + (GetBankIdentity(gSprites[healthboxSpriteId].data6) * 384)];
+ var = 5;
+ nature = GetNature(mon);
+ StringCopy(text + 6, gNatureNamePointers[nature]);
+ RenderTextFont9(fontPixels, 9, text);
+
+ for (j = 6, i = 0; i < var; i++, j++)
+ {
+ u8 elementId;
+
+ if ((text[j] >= 55 && text[j] <= 74) || (text[j] >= 135 && text[j] <= 154))
+ elementId = 44;
+ else if ((text[j] >= 75 && text[j] <= 79) || (text[j] >= 155 && text[j] <= 159))
+ elementId = 45;
+ else
+ elementId = 43;
+
+ CpuCopy32(GetHealthboxElementGfxPtr(elementId), fontPixels + (i * 64), 0x20);
+ }
+
+ for (j = 1; j < var + 1; j++)
+ {
+ var2 = (gSprites[healthboxSpriteId].oam.tileNum + (j - (j / 8 * 8)) + (j / 8 * 64)) * 32;
+ CpuCopy32(fontPixels, (void*)(OBJ_VRAM0) + (var2), 0x20);
+ fontPixels += 0x20;
+
+ var2 = (8 + gSprites[healthboxSpriteId].oam.tileNum + (j - (j / 8 * 8)) + (j / 8 * 64)) * 32;
+ CpuCopy32(fontPixels, (void*)(OBJ_VRAM0) + (var2), 0x20);
+ fontPixels += 0x20;
+ }
+
+ healthboxSpriteId_2 = gSprites[healthboxSpriteId].data5;
+ ConvertIntToDecimalStringN(text + 6, gBattleStruct->field_7C, STR_CONV_MODE_RIGHT_ALIGN, 2);
+ ConvertIntToDecimalStringN(text + 9, gBattleStruct->field_7B, STR_CONV_MODE_RIGHT_ALIGN, 2);
+ text[5] = CHAR_SPACE;
+ text[8] = CHAR_SLASH;
+ RenderTextFont9(gMonSpritesGfxPtr->fontPixels, 9, text);
+
+ j = healthboxSpriteId_2; // needed to match for some reason
+ for (j = 0; j < 5; j++)
+ {
+ if (j <= 1)
+ {
+ CpuCopy32(&gMonSpritesGfxPtr->fontPixels[0x40 * j + 0x20],
+ (void*)(OBJ_VRAM0) + (gSprites[healthboxSpriteId_2].oam.tileNum + 2 + j) * 32,
+ 32);
+ }
+ else
+ {
+ CpuCopy32(&gMonSpritesGfxPtr->fontPixels[0x40 * j + 0x20],
+ (void*)(OBJ_VRAM0 + 0xC0) + (j + gSprites[healthboxSpriteId_2].oam.tileNum) * 32,
+ 32);
+ }
+ }
+}
+
+void SwapHpBarsWithHpText(void)
+{
+ s32 i;
+ u8 spriteId;
+
+ for (i = 0; i < gNoOfAllBanks; i++)
+ {
+ if (gSprites[gHealthBoxesIds[i]].callback == SpriteCallbackDummy
+ && GetBankSide(i) != SIDE_OPPONENT
+ && (IsDoubleBattle() || GetBankSide(i) != SIDE_PLAYER))
+ {
+ bool8 noBars;
+
+ gBattleSpritesDataPtr->bankData[i].hpNumbersNoBars ^= 1;
+ noBars = gBattleSpritesDataPtr->bankData[i].hpNumbersNoBars;
+ if (GetBankSide(i) == SIDE_PLAYER)
+ {
+ if (!IsDoubleBattle())
+ continue;
+ if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+ continue;
+
+ if (noBars == TRUE) // bars to text
+ {
+ spriteId = gSprites[gHealthBoxesIds[i]].data5;
+
+ CpuFill32(0, (void*)(OBJ_VRAM0 + gSprites[spriteId].oam.tileNum * 32), 0x100);
+ UpdateHpTextInHealthboxInDoubles(gHealthBoxesIds[i], GetMonData(&gPlayerParty[gBattlePartyID[i]], MON_DATA_HP), HP_CURRENT);
+ UpdateHpTextInHealthboxInDoubles(gHealthBoxesIds[i], GetMonData(&gPlayerParty[gBattlePartyID[i]], MON_DATA_MAX_HP), HP_MAX);
+ }
+ else // text to bars
+ {
+ UpdateStatusIconInHealthbox(gHealthBoxesIds[i]);
+ UpdateHealthboxAttribute(gHealthBoxesIds[i], &gPlayerParty[gBattlePartyID[i]], HEALTHBOX_HEALTH_BAR);
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_117), (void*)(OBJ_VRAM0 + 0x680 + gSprites[gHealthBoxesIds[i]].oam.tileNum * 32), 32);
+ }
+ }
+ else
+ {
+ if (noBars == TRUE) // bars to text
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+ {
+ sub_80730D4(gHealthBoxesIds[i], &gEnemyParty[gBattlePartyID[i]]);
+ }
+ else
+ {
+ spriteId = gSprites[gHealthBoxesIds[i]].data5;
+
+ CpuFill32(0, (void *)(OBJ_VRAM0 + gSprites[spriteId].oam.tileNum * 32), 0x100);
+ UpdateHpTextInHealthboxInDoubles(gHealthBoxesIds[i], GetMonData(&gEnemyParty[gBattlePartyID[i]], MON_DATA_HP), HP_CURRENT);
+ UpdateHpTextInHealthboxInDoubles(gHealthBoxesIds[i], GetMonData(&gEnemyParty[gBattlePartyID[i]], MON_DATA_MAX_HP), HP_MAX);
+ }
+ }
+ else // text to bars
+ {
+ UpdateStatusIconInHealthbox(gHealthBoxesIds[i]);
+ UpdateHealthboxAttribute(gHealthBoxesIds[i], &gEnemyParty[gBattlePartyID[i]], HEALTHBOX_HEALTH_BAR);
+ if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+ UpdateHealthboxAttribute(gHealthBoxesIds[i], &gEnemyParty[gBattlePartyID[i]], HEALTHBOX_NICK);
+ }
+ }
+ gSprites[gHealthBoxesIds[i]].data7 ^= 1;
+ }
+ }
+}
+
+u8 CreatePartyStatusSummarySprites(u8 bank, struct HpAndStatus *partyInfo, u8 arg2, bool8 isBattleStart)
+{
+ bool8 isOpponent;
+ s16 bar_X, bar_Y, bar_pos2_X, bar_data0;
+ s32 i, j, var;
+ u8 barSpriteId;
+ u8 ballIconSpritesIds[6];
+ u8 taskId;
+
+ if (!arg2 || GetBankIdentity(bank) != IDENTITY_OPPONENT_MON2)
+ {
+ if (GetBankSide(bank) == SIDE_PLAYER)
+ {
+ isOpponent = FALSE;
+ bar_X = 136, bar_Y = 96;
+ bar_pos2_X = 100;
+ bar_data0 = -5;
+ }
+ else
+ {
+ isOpponent = TRUE;
+
+ if (!arg2 || !IsDoubleBattle())
+ bar_X = 104, bar_Y = 40;
+ else
+ bar_X = 104, bar_Y = 16;
+
+ bar_pos2_X = -100;
+ bar_data0 = 5;
+ }
+ }
+ else
+ {
+ isOpponent = TRUE;
+ bar_X = 104, bar_Y = 40;
+ bar_pos2_X = -100;
+ bar_data0 = 5;
+ }
+
+ LoadCompressedObjectPicUsingHeap(&sStatusSummaryBarSpriteSheet);
+ LoadSpriteSheet(&sStatusSummaryBallsSpriteSheet);
+ LoadSpritePalette(&sStatusSummaryBarSpritePal);
+ LoadSpritePalette(&sStatusSummaryBallsSpritePal);
+
+ barSpriteId = CreateSprite(&sStatusSummaryBarSpriteTemplates[isOpponent], bar_X, bar_Y, 10);
+ SetSubspriteTables(&gSprites[barSpriteId], sStatusSummaryBar_SubspriteTable);
+ gSprites[barSpriteId].pos2.x = bar_pos2_X;
+ gSprites[barSpriteId].data0 = bar_data0;
+
+ if (isOpponent)
+ {
+ gSprites[barSpriteId].pos1.x -= 96;
+ gSprites[barSpriteId].oam.matrixNum = 8;
+ }
+ else
+ {
+ gSprites[barSpriteId].pos1.x += 96;
+ }
+
+ for (i = 0; i < 6; i++)
+ {
+ ballIconSpritesIds[i] = CreateSpriteAtEnd(&sStatusSummaryBallsSpriteTemplates[isOpponent], bar_X, bar_Y - 4, 9);
+
+ if (!isBattleStart)
+ gSprites[ballIconSpritesIds[i]].callback = SpriteCB_StatusSummaryBallsOnSwitchout;
+
+ if (!isOpponent)
+ {
+ gSprites[ballIconSpritesIds[i]].pos2.x = 0;
+ gSprites[ballIconSpritesIds[i]].pos2.y = 0;
+ }
+
+ gSprites[ballIconSpritesIds[i]].data0 = barSpriteId;
+
+ if (!isOpponent)
+ {
+ gSprites[ballIconSpritesIds[i]].pos1.x += 10 * i + 24;
+ gSprites[ballIconSpritesIds[i]].data1 = i * 7 + 10;
+ gSprites[ballIconSpritesIds[i]].pos2.x = 120;
+ }
+ else
+ {
+ gSprites[ballIconSpritesIds[i]].pos1.x -= 10 * (5 - i) + 24;
+ gSprites[ballIconSpritesIds[i]].data1 = (6 - i) * 7 + 10;
+ gSprites[ballIconSpritesIds[i]].pos2.x = -120;
+ }
+
+ gSprites[ballIconSpritesIds[i]].data2 = isOpponent;
+ }
+
+ if (GetBankSide(bank) == SIDE_PLAYER)
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+ {
+ for (i = 0; i < 6; i++)
+ {
+ if (partyInfo[i].hp == 0xFFFF) // empty slot or an egg
+ {
+ gSprites[ballIconSpritesIds[i]].oam.tileNum += 1;
+ gSprites[ballIconSpritesIds[i]].data7 = 1;
+ }
+ else if (partyInfo[i].hp == 0) // fainted mon
+ {
+ gSprites[ballIconSpritesIds[i]].oam.tileNum += 3;
+ }
+ else if (partyInfo[i].status != 0) // mon with major status
+ {
+ gSprites[ballIconSpritesIds[i]].oam.tileNum += 2;
+ }
+ }
+ }
+ else
+ {
+ for (i = 0, var = 5, j = 0; j < 6; j++)
+ {
+ if (partyInfo[j].hp == 0xFFFF) // empty slot or an egg
+ {
+ gSprites[ballIconSpritesIds[var]].oam.tileNum += 1;
+ gSprites[ballIconSpritesIds[var]].data7 = 1;
+ var--;
+ continue;
+ }
+ else if (partyInfo[j].hp == 0) // fainted mon
+ {
+ gSprites[ballIconSpritesIds[i]].oam.tileNum += 3;
+ }
+ else if (gBattleTypeFlags & BATTLE_TYPE_ARENA && gBattleStruct->field_2A0 & gBitTable[j]) // hmm...?
+ {
+ gSprites[ballIconSpritesIds[i]].oam.tileNum += 3;
+ }
+ else if (partyInfo[j].status != 0) // mon with major status
+ {
+ gSprites[ballIconSpritesIds[i]].oam.tileNum += 2;
+ }
+ i++;
+ }
+ }
+ }
+ else
+ {
+ if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS))
+ {
+ for (var = 5, i = 0; i < 6; i++)
+ {
+ if (partyInfo[i].hp == 0xFFFF) // empty slot or an egg
+ {
+ gSprites[ballIconSpritesIds[var]].oam.tileNum += 1;
+ gSprites[ballIconSpritesIds[var]].data7 = 1;
+ }
+ else if (partyInfo[i].hp == 0) // fainted mon
+ {
+ gSprites[ballIconSpritesIds[var]].oam.tileNum += 3;
+ }
+ else if (partyInfo[i].status != 0) // mon with major status
+ {
+ gSprites[ballIconSpritesIds[var]].oam.tileNum += 2;
+ }
+ var--;
+ }
+ }
+ else
+ {
+ for (var = 0, i = 0, j = 0; j < 6; j++)
+ {
+ if (partyInfo[j].hp == 0xFFFF) // empty slot or an egg
+ {
+ gSprites[ballIconSpritesIds[i]].oam.tileNum += 1;
+ gSprites[ballIconSpritesIds[i]].data7 = 1;
+ i++;
+ continue;
+ }
+ else if (partyInfo[j].hp == 0) // fainted mon
+ {
+ gSprites[ballIconSpritesIds[5 - var]].oam.tileNum += 3;
+ }
+ else if (gBattleTypeFlags & BATTLE_TYPE_ARENA && gBattleStruct->field_2A1 & gBitTable[j]) // hmm...?
+ {
+ gSprites[ballIconSpritesIds[5 - var]].oam.tileNum += 3;
+ }
+ else if (partyInfo[j].status != 0) // mon with major status
+ {
+ gSprites[ballIconSpritesIds[5 - var]].oam.tileNum += 2;
+ }
+ var++;
+ }
+ }
+ }
+
+ taskId = CreateTask(TaskDummy, 5);
+ gTasks[taskId].data[0] = bank;
+ gTasks[taskId].data[1] = barSpriteId;
+
+ for (i = 0; i < 6; i++)
+ gTasks[taskId].data[3 + i] = ballIconSpritesIds[i];
+
+ gTasks[taskId].data[10] = isBattleStart;
+
+ if (isBattleStart)
+ {
+ gBattleSpritesDataPtr->animationData->field_9_x1C++;
+ }
+
+ PlaySE12WithPanning(SE_TB_START, 0);
+ return taskId;
+}
+
+void sub_8073C30(u8 taskId)
+{
+ u8 sp[6];
+ u8 r7;
+ u8 r10;
+ u8 bank;
+ s32 i;
+
+ r7 = gTasks[taskId].data[10];
+ r10 = gTasks[taskId].data[1];
+ bank = gTasks[taskId].data[0];
+
+ for (i = 0; i < 6; i++)
+ sp[i] = gTasks[taskId].data[3 + i];
+
+ SetGpuReg(REG_OFFSET_BLDCNT, 0x3F40);
+ SetGpuReg(REG_OFFSET_BLDALPHA, 0x10);
+
+ gTasks[taskId].data[15] = 16;
+
+ for (i = 0; i < 6; i++)
+ gSprites[sp[i]].oam.objMode = 1;
+
+ gSprites[r10].oam.objMode = 1;
+
+ if (r7 != 0)
+ {
+ for (i = 0; i < 6; i++)
+ {
+ if (GetBankSide(bank) != SIDE_PLAYER)
+ {
+ gSprites[sp[5 - i]].data1 = 7 * i;
+ gSprites[sp[5 - i]].data3 = 0;
+ gSprites[sp[5 - i]].data4 = 0;
+ gSprites[sp[5 - i]].callback = sub_8074158;
+ }
+ else
+ {
+ gSprites[sp[i]].data1 = 7 * i;
+ gSprites[sp[i]].data3 = 0;
+ gSprites[sp[i]].data4 = 0;
+ gSprites[sp[i]].callback = sub_8074158;
+ }
+ }
+ gSprites[r10].data0 /= 2;
+ gSprites[r10].data1 = 0;
+ gSprites[r10].callback = sub_8074090;
+ SetSubspriteTables(&gSprites[r10], sUnknown_0832C2CC);
+ gTasks[taskId].func = sub_8073E08;
+ }
+ else
+ {
+ gTasks[taskId].func = sub_8073F98;
+ }
+}
+
+static void sub_8073E08(u8 taskId)
+{
+ u16 temp = gTasks[taskId].data[11]++;
+
+ if (!(temp & 1))
+ {
+ gTasks[taskId].data[15]--;
+ if (gTasks[taskId].data[15] < 0)
+ return;
+
+ SetGpuReg(REG_OFFSET_BLDALPHA, (gTasks[taskId].data[15]) | ((16 - gTasks[taskId].data[15]) << 8));
+ }
+ if (gTasks[taskId].data[15] == 0)
+ gTasks[taskId].func = sub_8073E64;
+}
+
+static void sub_8073E64(u8 taskId)
+{
+ u8 sp[6];
+ s32 i;
+
+ u8 bank = gTasks[taskId].data[0];
+ gTasks[taskId].data[15]--;
+ if (gTasks[taskId].data[15] == -1)
+ {
+ u8 var = gTasks[taskId].data[1];
+
+ for (i = 0; i < 6; i++)
+ sp[i] = gTasks[taskId].data[3 + i];
+
+ gBattleSpritesDataPtr->animationData->field_9_x1C--;
+ if (!gBattleSpritesDataPtr->animationData->field_9_x1C)
+ {
+ DestroySpriteAndFreeResources(&gSprites[var]);
+ DestroySpriteAndFreeResources(&gSprites[sp[0]]);
+ }
+ else
+ {
+ FreeSpriteOamMatrix(&gSprites[var]);
+ DestroySprite(&gSprites[var]);
+ FreeSpriteOamMatrix(&gSprites[sp[0]]);
+ DestroySprite(&gSprites[sp[0]]);
+ }
+
+ for (i = 1; i < 6; i++)
+ DestroySprite(&gSprites[sp[i]]);
+ }
+ else if (gTasks[taskId].data[15] == -3)
+ {
+ gBattleSpritesDataPtr->healthBoxesData[bank].flag_x1 = 0;
+ SetGpuReg(REG_OFFSET_BLDCNT, 0);
+ SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+ DestroyTask(taskId);
+ }
+}
+
+static void sub_8073F98(u8 taskId)
+{
+ u8 sp[6];
+ s32 i;
+
+ u8 bank = gTasks[taskId].data[0];
+ gTasks[taskId].data[15]--;
+ if (gTasks[taskId].data[15] >= 0)
+ {
+ SetGpuReg(REG_OFFSET_BLDALPHA, (gTasks[taskId].data[15]) | ((16 - gTasks[taskId].data[15]) << 8));
+ }
+ else if (gTasks[taskId].data[15] == -1)
+ {
+ u8 var = gTasks[taskId].data[1];
+
+ for (i = 0; i < 6; i++)
+ sp[i] = gTasks[taskId].data[3 + i];
+
+ DestroySpriteAndFreeResources(&gSprites[var]);
+ DestroySpriteAndFreeResources(&gSprites[sp[0]]);
+
+ for (i = 1; i < 6; i++)
+ DestroySprite(&gSprites[sp[i]]);
+ }
+ else if (gTasks[taskId].data[15] == -3)
+ {
+ gBattleSpritesDataPtr->healthBoxesData[bank].flag_x1 = 0;
+ SetGpuReg(REG_OFFSET_BLDCNT, 0);
+ SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+ DestroyTask(taskId);
+ }
+}
+
+static void SpriteCB_StatusSummaryBar(struct Sprite *sprite)
+{
+ if (sprite->pos2.x != 0)
+ sprite->pos2.x += sprite->data0;
+}
+
+static void sub_8074090(struct Sprite *sprite)
+{
+ sprite->data1 += 32;
+ if (sprite->data0 > 0)
+ sprite->pos2.x += sprite->data1 >> 4;
+ else
+ sprite->pos2.x -= sprite->data1 >> 4;
+ sprite->data1 &= 0xF;
+}
+
+static void SpriteCB_StatusSummaryBallsOnBattleStart(struct Sprite *sprite)
+{
+ u8 var1;
+ u16 var2;
+ s8 pan;
+
+ if (sprite->data1 > 0)
+ {
+ sprite->data1--;
+ return;
+ }
+
+ var1 = sprite->data2;
+ var2 = sprite->data3;
+ var2 += 56;
+ sprite->data3 = var2 & 0xFFF0;
+
+ if (var1 != 0)
+ {
+ sprite->pos2.x += var2 >> 4;
+ if (sprite->pos2.x > 0)
+ sprite->pos2.x = 0;
+ }
+ else
+ {
+ sprite->pos2.x -= var2 >> 4;
+ if (sprite->pos2.x < 0)
+ sprite->pos2.x = 0;
+ }
+
+ if (sprite->pos2.x == 0)
+ {
+ pan = PAN_SIDE_OPPONENT;
+ if (var1 != 0)
+ pan = PAN_SIDE_PLAYER;
+
+ if (sprite->data7 != 0)
+ PlaySE2WithPanning(SE_TB_KARA, pan);
+ else
+ PlaySE1WithPanning(SE_TB_KON, pan);
+
+ sprite->callback = SpriteCallbackDummy;
+ }
+}
+
+static void sub_8074158(struct Sprite *sprite)
+{
+ u8 var1;
+ u16 var2;
+
+ if (sprite->data1 > 0)
+ {
+ sprite->data1--;
+ return;
+ }
+ var1 = sprite->data2;
+ var2 = sprite->data3;
+ var2 += 56;
+ sprite->data3 = var2 & 0xFFF0;
+ if (var1 != 0)
+ sprite->pos2.x += var2 >> 4;
+ else
+ sprite->pos2.x -= var2 >> 4;
+ if (sprite->pos2.x + sprite->pos1.x > 248
+ || sprite->pos2.x + sprite->pos1.x < -8)
+ {
+ sprite->invisible = TRUE;
+ sprite->callback = SpriteCallbackDummy;
+ }
+}
+
+static void SpriteCB_StatusSummaryBallsOnSwitchout(struct Sprite *sprite)
+{
+ u8 barSpriteId = sprite->data0;
+
+ sprite->pos2.x = gSprites[barSpriteId].pos2.x;
+ sprite->pos2.y = gSprites[barSpriteId].pos2.y;
+}
+
+static void UpdateNickInHealthbox(u8 healthboxSpriteId, struct Pokemon *mon)
+{
+ u8 nickname[POKEMON_NAME_LENGTH + 1];
+ void *ptr;
+ const u8 *genderTxt;
+ u32 windowId, spriteTileNum;
+ u8 *windowTileData;
+ u16 species;
+ u8 gender;
+
+ StringCopy(gDisplayedStringBattle, gText_HighlightDarkGrey);
+ GetMonData(mon, MON_DATA_NICKNAME, nickname);
+ StringGetEnd10(nickname);
+ ptr = StringAppend(gDisplayedStringBattle, nickname);
+
+ gender = GetMonGender(mon);
+ species = GetMonData(mon, MON_DATA_SPECIES);
+
+ if ((species == SPECIES_NIDORAN_F || species == SPECIES_NIDORAN_M) && StringCompare(nickname, gSpeciesNames[species]) == 0)
+ gender = 100;
+
+ // AddTextPrinterAndCreateWindowOnHealthbox's arguments are the same in all 3 cases.
+ // It's possible they may have been different in early development phases.
+ switch (gender)
+ {
+ default:
+ StringCopy(ptr, gText_DynColor2);
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(gDisplayedStringBattle, 0, 3, 2, &windowId);
+ break;
+ case MON_MALE:
+ StringCopy(ptr, gText_DynColor2Male);
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(gDisplayedStringBattle, 0, 3, 2, &windowId);
+ break;
+ case MON_FEMALE:
+ StringCopy(ptr, gText_DynColor1Female);
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(gDisplayedStringBattle, 0, 3, 2, &windowId);
+ break;
+ }
+
+ spriteTileNum = gSprites[healthboxSpriteId].oam.tileNum * 32;
+
+ if (GetBankSide(gSprites[healthboxSpriteId].data6) == SIDE_PLAYER)
+ {
+ sub_8075198((void*)(0x6010040 + spriteTileNum), windowTileData, 6);
+ ptr = (void*)(OBJ_VRAM0);
+ if (!IsDoubleBattle())
+ ptr += spriteTileNum + 0x800;
+ else
+ ptr += spriteTileNum + 0x400;
+ sub_8075198(ptr, windowTileData + 0xC0, 1);
+ }
+ else
+ {
+ sub_8075198((void*)(0x6010020 + spriteTileNum), windowTileData, 7);
+ }
+
+ RemoveWindowOnHealthbox(windowId);
+}
+
+static void TryAddPokeballIconToHealthbox(u8 healthboxSpriteId, bool8 noStatus)
+{
+ u8 bank, healthboxSpriteId_2;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL)
+ return;
+ if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
+ return;
+
+ bank = gSprites[healthboxSpriteId].data6;
+ if (GetBankSide(bank) == SIDE_PLAYER)
+ return;
+ if (!GetSetPokedexFlag(SpeciesToNationalPokedexNum(GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES)), FLAG_GET_CAUGHT))
+ return;
+
+ healthboxSpriteId_2 = gSprites[healthboxSpriteId].data5;
+
+ if (noStatus)
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_70), (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId_2].oam.tileNum + 8) * 32), 32);
+ else
+ CpuFill32(0, (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId_2].oam.tileNum + 8) * 32), 32);
+}
+
+static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId)
+{
+ s32 i;
+ u8 bank, healthboxSpriteId_2;
+ u32 status, pltAdder;
+ const u8 *statusGfxPtr;
+ s16 tileNumAdder;
+ u8 statusPalId;
+
+ bank = gSprites[healthboxSpriteId].data6;
+ healthboxSpriteId_2 = gSprites[healthboxSpriteId].data5;
+ if (GetBankSide(bank) == SIDE_PLAYER)
+ {
+ status = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_STATUS);
+ if (!IsDoubleBattle())
+ tileNumAdder = 0x1A;
+ else
+ tileNumAdder = 0x12;
+ }
+ else
+ {
+ status = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_STATUS);
+ tileNumAdder = 0x11;
+ }
+
+ if (status & STATUS_SLEEP)
+ {
+ statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_SLP_BANK0, bank));
+ statusPalId = PAL_STATUS_SLP;
+ }
+ else if (status & STATUS_PSN_ANY)
+ {
+ statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_PSN_BANK0, bank));
+ statusPalId = PAL_STATUS_PSN;
+ }
+ else if (status & STATUS_BURN)
+ {
+ statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_BRN_BANK0, bank));
+ statusPalId = PAL_STATUS_BRN;
+ }
+ else if (status & STATUS_FREEZE)
+ {
+ statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_FRZ_BANK0, bank));
+ statusPalId = PAL_STATUS_FRZ;
+ }
+ else if (status & STATUS_PARALYSIS)
+ {
+ statusGfxPtr = GetHealthboxElementGfxPtr(GetStatusIconForBankId(HEALTHBOX_GFX_STATUS_PRZ_BANK0, bank));
+ statusPalId = PAL_STATUS_PAR;
+ }
+ else
+ {
+ statusGfxPtr = GetHealthboxElementGfxPtr(HEALTHBOX_GFX_39);
+
+ for (i = 0; i < 3; i++)
+ CpuCopy32(statusGfxPtr, (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId].oam.tileNum + tileNumAdder + i) * 32), 32);
+
+ if (!gBattleSpritesDataPtr->bankData[bank].hpNumbersNoBars)
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_1), (void *)(OBJ_VRAM0 + gSprites[healthboxSpriteId_2].oam.tileNum * 32), 64);
+
+ TryAddPokeballIconToHealthbox(healthboxSpriteId, TRUE);
+ return;
+ }
+
+ pltAdder = gSprites[healthboxSpriteId].oam.paletteNum * 16;
+ pltAdder += bank + 12;
+
+ FillPalette(sStatusIconPalettes[statusPalId], pltAdder + 0x100, 2);
+ CpuCopy16(gPlttBufferUnfaded + 0x100 + pltAdder, (void*)(OBJ_PLTT + pltAdder * 2), 2);
+ CpuCopy32(statusGfxPtr, (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId].oam.tileNum + tileNumAdder) * 32), 96);
+ if (IsDoubleBattle() == TRUE || GetBankSide(bank) == SIDE_OPPONENT)
+ {
+ if (!gBattleSpritesDataPtr->bankData[bank].hpNumbersNoBars)
+ {
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_0), (void*)(OBJ_VRAM0 + gSprites[healthboxSpriteId_2].oam.tileNum * 32), 32);
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_65), (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId_2].oam.tileNum + 1) * 32), 32);
+ }
+ }
+ TryAddPokeballIconToHealthbox(healthboxSpriteId, FALSE);
+}
+
+static u8 GetStatusIconForBankId(u8 statusElementId, u8 bank)
+{
+ u8 ret = statusElementId;
+
+ switch (statusElementId)
+ {
+ case HEALTHBOX_GFX_STATUS_PSN_BANK0:
+ if (bank == 0)
+ ret = HEALTHBOX_GFX_STATUS_PSN_BANK0;
+ else if (bank == 1)
+ ret = HEALTHBOX_GFX_STATUS_PSN_BANK1;
+ else if (bank == 2)
+ ret = HEALTHBOX_GFX_STATUS_PSN_BANK2;
+ else
+ ret = HEALTHBOX_GFX_STATUS_PSN_BANK3;
+ break;
+ case HEALTHBOX_GFX_STATUS_PRZ_BANK0:
+ if (bank == 0)
+ ret = HEALTHBOX_GFX_STATUS_PRZ_BANK0;
+ else if (bank == 1)
+ ret = HEALTHBOX_GFX_STATUS_PRZ_BANK1;
+ else if (bank == 2)
+ ret = HEALTHBOX_GFX_STATUS_PRZ_BANK2;
+ else
+ ret = HEALTHBOX_GFX_STATUS_PRZ_BANK3;
+ break;
+ case HEALTHBOX_GFX_STATUS_SLP_BANK0:
+ if (bank == 0)
+ ret = HEALTHBOX_GFX_STATUS_SLP_BANK0;
+ else if (bank == 1)
+ ret = HEALTHBOX_GFX_STATUS_SLP_BANK1;
+ else if (bank == 2)
+ ret = HEALTHBOX_GFX_STATUS_SLP_BANK2;
+ else
+ ret = HEALTHBOX_GFX_STATUS_SLP_BANK3;
+ break;
+ case HEALTHBOX_GFX_STATUS_FRZ_BANK0:
+ if (bank == 0)
+ ret = HEALTHBOX_GFX_STATUS_FRZ_BANK0;
+ else if (bank == 1)
+ ret = HEALTHBOX_GFX_STATUS_FRZ_BANK1;
+ else if (bank == 2)
+ ret = HEALTHBOX_GFX_STATUS_FRZ_BANK2;
+ else
+ ret = HEALTHBOX_GFX_STATUS_FRZ_BANK3;
+ break;
+ case HEALTHBOX_GFX_STATUS_BRN_BANK0:
+ if (bank == 0)
+ ret = HEALTHBOX_GFX_STATUS_BRN_BANK0;
+ else if (bank == 1)
+ ret = HEALTHBOX_GFX_STATUS_BRN_BANK1;
+ else if (bank == 2)
+ ret = HEALTHBOX_GFX_STATUS_BRN_BANK2;
+ else
+ ret = HEALTHBOX_GFX_STATUS_BRN_BANK3;
+ break;
+ }
+ return ret;
+}
+
+static void UpdateSafariBallsTextOnHealthbox(u8 healthboxSpriteId)
+{
+ u32 windowId, spriteTileNum;
+ u8 *windowTileData;
+
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(gText_SafariBalls, 0, 3, 2, &windowId);
+ spriteTileNum = gSprites[healthboxSpriteId].oam.tileNum * 32;
+ sub_8075198((void*)(OBJ_VRAM0 + 0x40) + spriteTileNum, windowTileData, 6);
+ sub_8075198((void*)(OBJ_VRAM0 + 0x800) + spriteTileNum, windowTileData + 0xC0, 2);
+ RemoveWindowOnHealthbox(windowId);
+}
+
+static void UpdateLeftNoOfBallsTextOnHealthbox(u8 healthboxSpriteId)
+{
+ u8 text[16];
+ u8 *txtPtr;
+ u32 windowId, spriteTileNum;
+ u8 *windowTileData;
+
+ txtPtr = StringCopy(text, gText_SafariBallLeft);
+ ConvertIntToDecimalStringN(txtPtr, gNumSafariBalls, STR_CONV_MODE_LEFT_ALIGN, 2);
+
+ windowTileData = AddTextPrinterAndCreateWindowOnHealthbox(text, GetStringRightAlignXOffset(0, text, 0x2F), 3, 2, &windowId);
+ spriteTileNum = gSprites[healthboxSpriteId].oam.tileNum * 32;
+ sub_80751E4((void*)(OBJ_VRAM0 + 0x2C0) + spriteTileNum, windowTileData, 2);
+ sub_80751E4((void*)(OBJ_VRAM0 + 0xA00) + spriteTileNum, windowTileData + 0x40, 4);
+ RemoveWindowOnHealthbox(windowId);
+}
+
+void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elementId)
+{
+ s32 maxHp, currHp;
+ u8 bank = gSprites[healthboxSpriteId].data6;
+
+ if (elementId == HEALTHBOX_ALL && !IsDoubleBattle())
+ GetBankSide(bank); // pointless function call
+
+ if (GetBankSide(gSprites[healthboxSpriteId].data6) == SIDE_PLAYER)
+ {
+ u8 isDoubles;
+
+ if (elementId == HEALTHBOX_LEVEL || elementId == HEALTHBOX_ALL)
+ UpdateLvlInHealthbox(healthboxSpriteId, GetMonData(mon, MON_DATA_LEVEL));
+ if (elementId == HEALTHBOX_CURRENT_HP || elementId == HEALTHBOX_ALL)
+ UpdateHpTextInHealthbox(healthboxSpriteId, GetMonData(mon, MON_DATA_HP), HP_CURRENT);
+ if (elementId == HEALTHBOX_MAX_HP || elementId == HEALTHBOX_ALL)
+ UpdateHpTextInHealthbox(healthboxSpriteId, GetMonData(mon, MON_DATA_MAX_HP), HP_MAX);
+ if (elementId == HEALTHBOX_HEALTH_BAR || elementId == HEALTHBOX_ALL)
+ {
+ LoadBattleBarGfx(0);
+ maxHp = GetMonData(mon, MON_DATA_MAX_HP);
+ currHp = GetMonData(mon, MON_DATA_HP);
+ SetBattleBarStruct(bank, healthboxSpriteId, maxHp, currHp, 0);
+ sub_8074AA0(bank, healthboxSpriteId, HEALTH_BAR, 0);
+ }
+ isDoubles = IsDoubleBattle();
+ if (!isDoubles && (elementId == HEALTHBOX_EXP_BAR || elementId == HEALTHBOX_ALL))
+ {
+ u16 species;
+ u32 exp, currLevelExp;
+ s32 currExpBarValue, maxExpBarValue;
+ u8 level;
+
+ LoadBattleBarGfx(3);
+ species = GetMonData(mon, MON_DATA_SPECIES);
+ level = GetMonData(mon, MON_DATA_LEVEL);
+ exp = GetMonData(mon, MON_DATA_EXP);
+ currLevelExp = gExperienceTables[gBaseStats[species].growthRate][level];
+ currExpBarValue = exp - currLevelExp;
+ maxExpBarValue = gExperienceTables[gBaseStats[species].growthRate][level + 1] - currLevelExp;
+ SetBattleBarStruct(bank, healthboxSpriteId, maxExpBarValue, currExpBarValue, isDoubles);
+ sub_8074AA0(bank, healthboxSpriteId, EXP_BAR, 0);
+ }
+ if (elementId == HEALTHBOX_NICK || elementId == HEALTHBOX_ALL)
+ UpdateNickInHealthbox(healthboxSpriteId, mon);
+ if (elementId == HEALTHBOX_STATUS_ICON || elementId == HEALTHBOX_ALL)
+ UpdateStatusIconInHealthbox(healthboxSpriteId);
+ if (elementId == HEALTHBOX_SAFARI_ALL_TEXT)
+ UpdateSafariBallsTextOnHealthbox(healthboxSpriteId);
+ if (elementId == HEALTHBOX_SAFARI_ALL_TEXT || elementId == HEALTHBOX_SAFARI_BALLS_TEXT)
+ UpdateLeftNoOfBallsTextOnHealthbox(healthboxSpriteId);
+ }
+ else
+ {
+ if (elementId == HEALTHBOX_LEVEL || elementId == HEALTHBOX_ALL)
+ UpdateLvlInHealthbox(healthboxSpriteId, GetMonData(mon, MON_DATA_LEVEL));
+ if (elementId == HEALTHBOX_HEALTH_BAR || elementId == HEALTHBOX_ALL)
+ {
+ LoadBattleBarGfx(0);
+ maxHp = GetMonData(mon, MON_DATA_MAX_HP);
+ currHp = GetMonData(mon, MON_DATA_HP);
+ SetBattleBarStruct(bank, healthboxSpriteId, maxHp, currHp, 0);
+ sub_8074AA0(bank, healthboxSpriteId, HEALTH_BAR, 0);
+ }
+ if (elementId == HEALTHBOX_NICK || elementId == HEALTHBOX_ALL)
+ UpdateNickInHealthbox(healthboxSpriteId, mon);
+ if (elementId == HEALTHBOX_STATUS_ICON || elementId == HEALTHBOX_ALL)
+ UpdateStatusIconInHealthbox(healthboxSpriteId);
+ }
+}
+
+s32 sub_8074AA0(u8 bank, u8 healthboxSpriteId, u8 whichBar, u8 arg3)
+{
+ s32 var;
+
+ if (whichBar == HEALTH_BAR) // health bar
+ {
+ var = sub_8074DB8(gBattleSpritesDataPtr->battleBars[bank].maxValue,
+ gBattleSpritesDataPtr->battleBars[bank].currentValue,
+ gBattleSpritesDataPtr->battleBars[bank].field_C,
+ &gBattleSpritesDataPtr->battleBars[bank].field_10,
+ 6, 1);
+ }
+ else // exp bar
+ {
+ u16 expFraction = GetScaledExpFraction(gBattleSpritesDataPtr->battleBars[bank].currentValue,
+ gBattleSpritesDataPtr->battleBars[bank].field_C,
+ gBattleSpritesDataPtr->battleBars[bank].maxValue, 8);
+ if (expFraction == 0)
+ expFraction = 1;
+ expFraction = abs(gBattleSpritesDataPtr->battleBars[bank].field_C / expFraction);
+
+ var = sub_8074DB8(gBattleSpritesDataPtr->battleBars[bank].maxValue,
+ gBattleSpritesDataPtr->battleBars[bank].currentValue,
+ gBattleSpritesDataPtr->battleBars[bank].field_C,
+ &gBattleSpritesDataPtr->battleBars[bank].field_10,
+ 8, expFraction);
+ }
+
+ if (whichBar == EXP_BAR || (whichBar == HEALTH_BAR && !gBattleSpritesDataPtr->bankData[bank].hpNumbersNoBars))
+ sub_8074B9C(bank, whichBar);
+
+ if (var == -1)
+ gBattleSpritesDataPtr->battleBars[bank].field_10 = 0;
+
+ return var;
+}
+
+static void sub_8074B9C(u8 bank, u8 whichBar)
+{
+ u8 array[7];
+ u8 subRet, level;
+ u8 barElementId;
+ u8 i;
+
+ switch (whichBar)
+ {
+ case HEALTH_BAR:
+ subRet = sub_8074E8C(gBattleSpritesDataPtr->battleBars[bank].maxValue,
+ gBattleSpritesDataPtr->battleBars[bank].currentValue,
+ gBattleSpritesDataPtr->battleBars[bank].field_C,
+ &gBattleSpritesDataPtr->battleBars[bank].field_10,
+ array, 6);
+ barElementId = 3;
+ if (subRet <= 0x18)
+ {
+ barElementId = 0x38;
+ if (subRet > 9)
+ barElementId = 0x2F;
+ }
+ for (i = 0; i < 6; i++)
+ {
+ u8 healthboxSpriteId_2 = gSprites[gBattleSpritesDataPtr->battleBars[bank].healthboxSpriteId].data5;
+ if (i < 2)
+ CpuCopy32(GetHealthboxElementGfxPtr(barElementId) + array[i] * 32,
+ (void*)(OBJ_VRAM0 + (gSprites[healthboxSpriteId_2].oam.tileNum + 2 + i) * 32), 32);
+ else
+ CpuCopy32(GetHealthboxElementGfxPtr(barElementId) + array[i] * 32,
+ (void*)(OBJ_VRAM0 + 64 + (i + gSprites[healthboxSpriteId_2].oam.tileNum) * 32), 32);
+ }
+ break;
+ case EXP_BAR:
+ sub_8074E8C(gBattleSpritesDataPtr->battleBars[bank].maxValue,
+ gBattleSpritesDataPtr->battleBars[bank].currentValue,
+ gBattleSpritesDataPtr->battleBars[bank].field_C,
+ &gBattleSpritesDataPtr->battleBars[bank].field_10,
+ array, 8);
+ level = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_LEVEL);
+ if (level == MAX_MON_LEVEL)
+ {
+ for (i = 0; i < 8; i++)
+ array[i] = 0;
+ }
+ for (i = 0; i < 8; i++)
+ {
+ if (i < 4)
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_12) + array[i] * 32,
+ (void*)(OBJ_VRAM0 + (gSprites[gBattleSpritesDataPtr->battleBars[bank].healthboxSpriteId].oam.tileNum + 0x24 + i) * 32), 32);
+ else
+ CpuCopy32(GetHealthboxElementGfxPtr(HEALTHBOX_GFX_12) + array[i] * 32,
+ (void*)(OBJ_VRAM0 + 0xB80 + (i + gSprites[gBattleSpritesDataPtr->battleBars[bank].healthboxSpriteId].oam.tileNum) * 32), 32);
+ }
+ break;
+ }
+}
+
+static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 arg4, u16 arg5)
+{
+ s32 r6;
+ s32 ret;
+ arg4 <<= 3;
+
+ if (*arg3 == -32768)
+ {
+ if (maxValue < arg4)
+ *arg3 = currValue << 8;
+ else
+ *arg3 = currValue;
+ }
+
+ currValue -= arg2;
+ if (currValue < 0)
+ currValue = 0;
+ else if (currValue > maxValue)
+ currValue = maxValue;
+
+ if (maxValue < arg4)
+ {
+ s32 var = *arg3 >> 8;
+
+ r6 = *arg3;
+ if (currValue == var && (r6 & 0xFF) == 0)
+ return -1;
+ }
+ else
+ {
+ r6 = *arg3;
+ if (currValue == r6)
+ return -1;
+ }
+
+ if (maxValue < arg4)
+ {
+ s32 var = (maxValue << 8) / arg4;
+
+ if (arg2 < 0)
+ {
+ *arg3 = r6 + var;
+ ret = *arg3 >> 8;
+ if (ret >= currValue)
+ {
+ *arg3 = currValue << 8;
+ ret = currValue;
+ }
+ }
+ else
+ {
+ *arg3 = r6 - var;
+ ret = *arg3 >> 8;
+ if ((*arg3 & 0xFF) > 0)
+ ret++;
+ if (ret <= currValue)
+ {
+ *arg3 = currValue << 8;
+ ret = currValue;
+ }
+ }
+ }
+ else
+ {
+ if (arg2 < 0)
+ {
+ *arg3 += arg5;
+ if (*arg3 > currValue)
+ *arg3 = currValue;
+ ret = *arg3;
+ }
+ else
+ {
+ *arg3 -= arg5;
+ if (*arg3 < currValue)
+ *arg3 = currValue;
+ ret = *arg3;
+ }
+ }
+
+ return ret;
+}
+
+static u8 sub_8074E8C(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 *arg4, u8 arg5)
+{
+ s32 r5 = currValue - arg2;
+ u8 ret;
+ u8 i;
+ u8 r2;
+
+ if (r5 < 0)
+ r5 = 0;
+ else if (r5 > maxValue)
+ r5 = maxValue;
+
+ ret = arg5 << 3;
+
+ for (i = 0; i < arg5; i++)
+ arg4[i] = 0;
+
+ if (maxValue < ret)
+ r2 = (*arg3 * ret / maxValue) >> 8;
+ else
+ r2 = *arg3 * ret / maxValue;
+
+ ret = r2;
+
+ if (ret == 0 && r5 > 0)
+ {
+ arg4[0] = 1;
+ ret = 1;
+ }
+ else
+ {
+ for (i = 0; i < arg5; i++)
+ {
+ if (r2 >= 8)
+ {
+ arg4[i] = 8;
+ }
+ else
+ {
+ arg4[i] = r2;
+ break;
+ }
+ r2 -= 8;
+ }
+ }
+
+ return ret;
+}
+
+static s16 sub_8074F28(struct TestingBar *barInfo, s32 *arg1, u16 *arg2, s32 arg3)
+{
+ s16 ret, var;
+
+ ret = sub_8074DB8(barInfo->maxValue,
+ barInfo->currValue,
+ barInfo->field_8,
+ arg1, 6, 1);
+ sub_8074F88(barInfo, arg1, arg2);
+
+ if (barInfo->maxValue < 0x30)
+ var = *arg1 >> 8;
+ else
+ var = *arg1;
+
+ DummiedOutFunction(barInfo->maxValue, var, arg3);
+
+ return ret;
+}
+
+static void sub_8074F88(struct TestingBar *barInfo, s32 *arg1, u16 *arg2)
+{
+ u8 sp8[6];
+ u16 sp10[6];
+ u8 i;
+
+ sub_8074E8C(barInfo->maxValue, barInfo->currValue,
+ barInfo->field_8, arg1, sp8, 6);
+
+ for (i = 0; i < 6; i++)
+ sp10[i] = (barInfo->unkC_0 << 12) | (barInfo->unk10 + sp8[i]);
+
+ CpuCopy16(sp10, arg2, sizeof(sp10));
+}
+
+static u8 GetScaledExpFraction(s32 currValue, s32 arg1, s32 maxValue, u8 scale)
+{
+ s32 r5, result;
+ s8 r4, r0;
+
+ scale *= 8;
+ r5 = currValue - arg1;
+
+ if (r5 < 0)
+ r5 = 0;
+ else if (r5 > maxValue)
+ r5 = maxValue;
+
+ r4 = currValue * scale / maxValue;
+ r0 = r5 * scale / maxValue;
+ result = r4 - r0;
+
+ return abs(result);
+}
+
+u8 GetScaledHPFraction(s16 hp, s16 maxhp, u8 scale)
+{
+ u8 result = hp * scale / maxhp;
+
+ if (result == 0 && hp > 0)
+ return 1;
+
+ return result;
+}
+
+u8 GetHPBarLevel(s16 hp, s16 maxhp)
+{
+ s32 result;
+
+ if (hp == maxhp)
+ {
+ result = 4;
+ }
+ else
+ {
+ u8 fraction = GetScaledHPFraction(hp, maxhp, 48);
+ if (fraction > 24)
+ result = 3;
+ else if (fraction > 9)
+ result = 2;
+ else if (fraction > 0)
+ result = 1;
+ else
+ result = 0;
+ }
+
+ return result;
+}
+
+static u8* AddTextPrinterAndCreateWindowOnHealthbox(const u8 *str, u32 x, u32 y, u32 arg3, u32 *windowId)
+{
+ u16 winId;
+ struct TextColor color;
+ struct WindowTemplate winTemplate = sHealthboxWindowTemplate;
+
+ winId = AddWindow(&winTemplate);
+ FillWindowPixelBuffer(winId, (arg3 << 4) | (arg3));
+
+ color.fgColor = arg3;
+ color.bgColor = 1;
+ color.shadowColor = 3;
+
+ AddTextPrinterParametrized2(winId, 0, x, y, 0, 0, &color, -1, str);
+
+ *windowId = winId;
+ return (u8*)(GetWindowAttribute(winId, WINDOW_TILE_DATA));
+}
+
+static void RemoveWindowOnHealthbox(u32 windowId)
+{
+ RemoveWindow(windowId);
+}
+
+static void sub_807513C(void *dest, u32 arg1, u32 arg2)
+{
+ CpuFill32(0x11111111 * arg1, dest, arg2 * 32);
+}
+
+static void sub_8075170(void *dest, u8 *windowTileData, u32 arg2)
+{
+ CpuCopy32(windowTileData + 256, dest, arg2 * 32);
+}
+
+static void sub_8075198(void *dest, u8 *windowTileData, s32 arg2)
+{
+ CpuCopy32(windowTileData + 256, dest + 256, arg2 * 32);
+
+ if (arg2 > 0)
+ {
+ do
+ {
+ CpuCopy32(windowTileData + 20, dest + 20, 12);
+ dest += 32, windowTileData+= 32;
+ arg2--;
+ } while (arg2 != 0);
+ }
+}
+
+static void sub_80751E4(void *dest, u8 *windowTileData, u32 arg2)
+{
+ CpuCopy32(windowTileData, dest, arg2 * 32);
+ CpuCopy32(windowTileData + 256, dest + 256, arg2 * 32);
+}
diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index fb6a8272b..a1e5767ad 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -349,7 +349,7 @@ static void atk51_switch_handle_order(void);
static void atk52_switch_in_effects(void);
static void atk53_trainer_slide(void);
static void atk54_effectiveness_sound(void);
-static void atk55_play_sound(void);
+static void atk55_play_fanfare(void);
static void atk56_fainting_cry(void);
static void atk57(void);
static void atk58_return_to_ball(void);
@@ -601,7 +601,7 @@ void (* const gBattleScriptingCommandsTable[])(void) =
atk52_switch_in_effects,
atk53_trainer_slide,
atk54_effectiveness_sound,
- atk55_play_sound,
+ atk55_play_fanfare,
atk56_fainting_cry,
atk57,
atk58_return_to_ball,
@@ -5308,7 +5308,7 @@ static void atk4B_return_atk_to_ball(void)
gActiveBank = gBankAttacker;
if (!(gHitMarker & HITMARKER_FAINTED(gActiveBank)))
{
- EmitReturnPokeToBall(0, 0);
+ EmitReturnMonToBall(0, 0);
MarkBufferBankForExecution(gActiveBank);
}
gBattlescriptCurrInstr++;
@@ -5627,7 +5627,7 @@ static void atk50_openpartyscreen(void)
{
gAbsentBankFlags |= gBitTable[gActiveBank];
gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
- Emit_x2A(0);
+ EmitCmd42(0);
MarkBufferBankForExecution(gActiveBank);
}
else if (!gSpecialStatuses[gActiveBank].flag40)
@@ -5649,7 +5649,7 @@ static void atk50_openpartyscreen(void)
{
gAbsentBankFlags |= gBitTable[gActiveBank];
gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
- Emit_x2A(0);
+ EmitCmd42(0);
MarkBufferBankForExecution(gActiveBank);
}
else if (!gSpecialStatuses[gActiveBank].flag40)
@@ -5670,7 +5670,7 @@ static void atk50_openpartyscreen(void)
{
gAbsentBankFlags |= gBitTable[gActiveBank];
gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
- Emit_x2A(0);
+ EmitCmd42(0);
MarkBufferBankForExecution(gActiveBank);
}
else if (!gSpecialStatuses[gActiveBank].flag40)
@@ -5692,7 +5692,7 @@ static void atk50_openpartyscreen(void)
{
gAbsentBankFlags |= gBitTable[gActiveBank];
gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
- Emit_x2A(0);
+ EmitCmd42(0);
MarkBufferBankForExecution(gActiveBank);
}
else if (!gSpecialStatuses[gActiveBank].flag40)
@@ -5755,7 +5755,7 @@ static void atk50_openpartyscreen(void)
{
gAbsentBankFlags |= gBitTable[gActiveBank];
gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
- Emit_x2A(0);
+ EmitCmd42(0);
MarkBufferBankForExecution(gActiveBank);
}
else if (!gSpecialStatuses[gActiveBank].flag40)
@@ -5771,7 +5771,7 @@ static void atk50_openpartyscreen(void)
{
gAbsentBankFlags |= gBitTable[gActiveBank];
gHitMarker &= ~(HITMARKER_FAINTED(gActiveBank));
- Emit_x2A(0);
+ EmitCmd42(0);
MarkBufferBankForExecution(gActiveBank);
}
else if (!gSpecialStatuses[gActiveBank].flag40)
@@ -6031,10 +6031,10 @@ static void atk54_effectiveness_sound(void)
gBattlescriptCurrInstr += 3;
}
-static void atk55_play_sound(void)
+static void atk55_play_fanfare(void)
{
gActiveBank = gBankAttacker;
- EmitPlaySound(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1), 0);
+ EmitPlayFanfareOrBGM(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1), FALSE);
MarkBufferBankForExecution(gActiveBank);
gBattlescriptCurrInstr += 3;
@@ -6052,7 +6052,7 @@ static void atk56_fainting_cry(void)
static void atk57(void)
{
gActiveBank = GetBankByIdentity(0);
- Emit_x37(0, gBattleOutcome);
+ EmitCmd55(0, gBattleOutcome);
MarkBufferBankForExecution(gActiveBank);
gBattlescriptCurrInstr += 1;
@@ -6061,7 +6061,7 @@ static void atk57(void)
static void atk58_return_to_ball(void)
{
gActiveBank = GetBattleBank(gBattlescriptCurrInstr[1]);
- EmitReturnPokeToBall(0, 1);
+ EmitReturnMonToBall(0, 1);
MarkBufferBankForExecution(gActiveBank);
gBattlescriptCurrInstr += 2;
@@ -7137,7 +7137,7 @@ static void atk76_various(void)
gDisableStructs[1].truantUnknownBit = 1;
break;
case 13:
- EmitCmd13(0);
+ EmitCmd19(0);
MarkBufferBankForExecution(gActiveBank);
break;
case 14:
@@ -7162,7 +7162,7 @@ static void atk76_various(void)
gActiveBank = 1;
if (gBattleMons[gActiveBank].hp != 0)
{
- EmitReturnPokeToBall(0, 0);
+ EmitReturnMonToBall(0, 0);
MarkBufferBankForExecution(gActiveBank);
}
break;
@@ -7172,7 +7172,7 @@ static void atk76_various(void)
gActiveBank = 3;
if (gBattleMons[gActiveBank].hp != 0)
{
- EmitReturnPokeToBall(0, 0);
+ EmitReturnMonToBall(0, 0);
MarkBufferBankForExecution(gActiveBank);
}
}
@@ -7197,7 +7197,7 @@ static void atk76_various(void)
gBattleOutcome = BATTLE_OPPONENT_TELEPORTED;
break;
case VARIOUS_PLAY_TRAINER_DEFEATED_MUSIC:
- EmitPlaySound(0, BGM_KACHI1, 1);
+ EmitPlayFanfareOrBGM(0, BGM_KACHI1, TRUE);
MarkBufferBankForExecution(gActiveBank);
break;
}
diff --git a/src/clear_save_data_screen.c b/src/clear_save_data_screen.c
new file mode 100755
index 000000000..3192e0e11
--- /dev/null
+++ b/src/clear_save_data_screen.c
@@ -0,0 +1,209 @@
+#include "global.h"
+#include "task.h"
+#include "menu.h"
+#include "text.h"
+#include "sound.h"
+#include "main.h"
+#include "save.h"
+#include "palette.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "text_window.h"
+#include "songs.h"
+
+extern u8 gText_ClearAllSaveData[];
+extern u8 gText_ClearingData[];
+
+extern u16 gUnknown_0860F074[];
+
+static void Task_DoClearSaveDataScreenYesNo(u8);
+static void Task_ClearSaveDataScreenYesNoChoice(u8);
+static void Task_ClearSaveData(u8);
+static bool8 SetupClearSaveDataScreen(void);
+static void CB2_FadeAndDoReset(void);
+static void InitClearSaveDataScreenWindows(void);
+
+static const struct BgTemplate sClearSaveBgTemplates[2] =
+{
+ {
+ .bg = 0,
+ .charBaseIndex = 0,
+ .mapBaseIndex = 31,
+ .screenSize = 0,
+ .paletteMode = 0,
+ .priority = 0,
+ .baseTile = 0,
+ },
+ {
+ .bg = 3,
+ .charBaseIndex = 0,
+ .mapBaseIndex = 30,
+ .screenSize = 0,
+ .paletteMode = 0,
+ .priority = 1,
+ .baseTile = 0,
+ },
+};
+
+static const struct WindowTemplate sClearSaveTextWindow[] =
+{
+ {
+ .priority = 0,
+ .tilemapLeft = 3,
+ .tilemapTop = 15,
+ .width = 26,
+ .height = 4,
+ .paletteNum = 15,
+ .baseBlock = 11,
+ },
+ DUMMY_WIN_TEMPLATE
+};
+
+static const struct WindowTemplate sClearSaveYesNo[] =
+{
+ {
+ .priority = 0,
+ .tilemapLeft = 3,
+ .tilemapTop = 2,
+ .width = 5,
+ .height = 4,
+ .paletteNum = 15,
+ .baseBlock = 115,
+ }
+};
+
+void CB2_InitClearSaveDataScreen(void)
+{
+ if(SetupClearSaveDataScreen())
+ CreateTask(Task_DoClearSaveDataScreenYesNo, 0);
+}
+
+static void Task_DoClearSaveDataScreenYesNo(u8 taskId)
+{
+ SetWindowBorderStyle(0, 0, 2, 14);
+ PrintTextOnWindow(0, 1, gText_ClearAllSaveData, 0, 1, 0, 0);
+ CreateYesNoMenu(sClearSaveYesNo, 2, 14, 1);
+ gTasks[taskId].func = Task_ClearSaveDataScreenYesNoChoice;
+}
+
+static void Task_ClearSaveDataScreenYesNoChoice(u8 taskId)
+{
+ switch(sub_8198C58())
+ {
+ case 0:
+ FillWindowPixelBuffer(0, 17);
+ PrintTextOnWindow(0, 1, gText_ClearingData, 0, 1, 0, 0);
+ gTasks[taskId].func = Task_ClearSaveData;
+ break;
+ case 1:
+ case -1:
+ PlaySE(SE_SELECT);
+ DestroyTask(taskId);
+ SetMainCallback2(CB2_FadeAndDoReset);
+ }
+}
+
+static void Task_ClearSaveData(u8 taskId)
+{
+ ClearSaveData();
+ DestroyTask(taskId);
+ SetMainCallback2(CB2_FadeAndDoReset);
+}
+
+static void MainCB(void)
+{
+ RunTasks();
+ UpdatePaletteFade();
+}
+
+static void VBlankCB(void)
+{
+ TransferPlttBuffer();
+}
+
+static bool8 SetupClearSaveDataScreen(void)
+{
+ u16 i;
+
+ switch(gMain.state)
+ {
+ case 0:
+ default:
+ SetVBlankCallback(NULL);
+ SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0);
+ SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+ SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+ SetGpuReg(REG_OFFSET_BG3HOFS, 0);
+ SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+ SetGpuReg(REG_OFFSET_WIN0H, 0);
+ SetGpuReg(REG_OFFSET_WIN0V, 0);
+ SetGpuReg(REG_OFFSET_WININ, 0);
+ SetGpuReg(REG_OFFSET_WINOUT, 0);
+ SetGpuReg(REG_OFFSET_BLDCNT, 0);
+ SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+ SetGpuReg(REG_OFFSET_BLDY, 0);
+ DmaFill16(3, 0, (void *)VRAM, VRAM_SIZE);
+ DmaFill32(3, 0, (void *)OAM, OAM_SIZE);
+ DmaFill16(3, 0, (void *)(PLTT + 2), PLTT_SIZE - 2);
+ ResetPaletteFade();
+ gPlttBufferUnfaded[0] = 0x7fff;
+ gPlttBufferFaded[0] = 0x7fff;
+ gPlttBufferUnfaded[1] = 0x3945;
+ gPlttBufferFaded[1] = 0x3945;
+ for (i = 0; i < 0x10; i++)
+ ((u16 *)(VRAM + 0x20))[i] = 0x1111;
+
+ for (i = 0; i < 0x400; i++)
+ ((u16 *)(VRAM + 0xF000))[i] = 0x0001;
+ ResetTasks();
+ ResetSpriteData();
+ ResetBgsAndClearDma3BusyFlags(0);
+ InitBgsFromTemplates(0, sClearSaveBgTemplates, ARRAY_COUNT(sClearSaveBgTemplates));
+ SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+ ShowBg(0);
+ ShowBg(3);
+ SetGpuReg(REG_OFFSET_BLDCNT, 0);
+ InitClearSaveDataScreenWindows();
+ BeginNormalPaletteFade(0x0000FFFF, 0, 0x10, 0, 0xFFFF);
+ EnableInterrupts(1);
+ SetVBlankCallback(VBlankCB);
+ gMain.state = 1;
+ break;
+ case 1:
+ UpdatePaletteFade();
+ if(!gPaletteFade.active)
+ {
+ SetMainCallback2(MainCB);
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+static void CB2_FadeAndDoReset(void)
+{
+ switch(gMain.state)
+ {
+ case 0:
+ default:
+ BeginNormalPaletteFade(0x0000FFFF, 0, 0, 0x10, 0xFFFF);
+ gMain.state = 1;
+ break;
+ case 1:
+ UpdatePaletteFade();
+ if(!gPaletteFade.active)
+ {
+ FreeAllWindowBuffers();
+ DoSoftReset();
+ }
+ }
+}
+
+static void InitClearSaveDataScreenWindows(void)
+{
+ InitWindows(sClearSaveTextWindow);
+ DeactivateAllTextPrinters();
+ FillWindowPixelBuffer(0, 0);
+ sub_80987D4(0, 0, 2, 224);
+ LoadPalette(gUnknown_0860F074, 0xF0, 0x20);
+}
diff --git a/src/decompress.c b/src/decompress.c
index 2863ff1f5..9210799ec 100644
--- a/src/decompress.c
+++ b/src/decompress.c
@@ -465,7 +465,7 @@ u32 sub_8034974(void* ptr)
return (ptr_[3] << 16) | (ptr_[2] << 8) | (ptr_[1]);
}
-bool8 LoadCompressedObjectPicUsingHeap(struct CompressedSpriteSheet* src)
+bool8 LoadCompressedObjectPicUsingHeap(const struct CompressedSpriteSheet* src)
{
struct SpriteSheet dest;
void* buffer;
diff --git a/src/decoration.c b/src/decoration.c
new file mode 100644
index 000000000..0179d36a1
--- /dev/null
+++ b/src/decoration.c
@@ -0,0 +1,2781 @@
+
+// Includes
+#include "global.h"
+#include "decompress.h"
+#include "malloc.h"
+#include "string_util.h"
+#include "international_string_util.h"
+#include "script.h"
+#include "task.h"
+#include "main.h"
+#include "palette.h"
+#include "songs.h"
+#include "overworld.h"
+#include "fieldmap.h"
+#include "metatile_behavior.h"
+#include "field_weather.h"
+#include "field_player_avatar.h"
+#include "field_camera.h"
+#include "field_screen.h"
+#include "field_map_obj.h"
+#include "list_menu.h"
+#include "menu_helpers.h"
+#include "new_menu_helpers.h"
+#include "menu_indicators.h"
+#include "sound.h"
+#include "event_scripts.h"
+#include "event_data.h"
+#include "region_map.h"
+#include "player_pc.h"
+#include "strings.h"
+#include "tv.h"
+#include "secret_base.h"
+#include "tilesets.h"
+#include "item_icon.h"
+#include "trader.h"
+#include "map_object_constants.h"
+#include "decoration_inventory.h"
+#include "decoration.h"
+#include "graphics.h"
+
+// Static type declarations
+
+#define OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG 0xbe5
+#define OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG 0x008
+
+struct DecorPCBuffer {
+ struct ListMenuItem items[41];
+ u8 names[41][24];
+ u8 unk_520;
+ u8 unk_521;
+ u8 unk_522;
+};
+
+struct PlaceDecorationGraphicsDataBuffer {
+ /*0x000; 0x0203a190*/ const struct Decoration *decoration;
+ /*0x004; 0x0203a194*/ u16 tiles[0x40];
+ /*0x084; 0x0203a214*/ u8 image[0x800];
+ /*0x884; 0x0203aa14*/ u16 palette[16];
+};
+
+struct DecorRearrangementDataBuffer {
+ u8 idx;
+ u8 width;
+ u8 height;
+ u16 flagId;
+};
+
+// Static RAM declarations
+
+EWRAM_DATA u8 *gCurDecorInventoryItems = NULL;
+EWRAM_DATA u8 sSecretBasePCMenuCursorPos = 0;
+EWRAM_DATA u8 sCurDecorCatCount = 0;
+EWRAM_DATA u8 sSecretBaseItemsIndicesBuffer[16] = {};
+EWRAM_DATA u8 sPlayerRoomItemsIndicesBuffer[12] = {};
+EWRAM_DATA u16 sSecretBasePCSelectDecorLineNo = 0;
+EWRAM_DATA u16 sSecretBasePCSelectDecorPageNo = 0;
+EWRAM_DATA u8 gCurDecorationIndex = 0;
+EWRAM_DATA u8 sCurDecorationCategory = DECORCAT_DESK;
+EWRAM_DATA u32 filler_0203a174[2] = {};
+EWRAM_DATA struct DecorPCPointers gUnknown_0203A17C = {};
+EWRAM_DATA u8 sDecorMenuWindowIndices[4] = {};
+EWRAM_DATA struct DecorPCBuffer *sDecorPCBuffer = NULL;
+EWRAM_DATA struct PlaceDecorationGraphicsDataBuffer sPlaceDecorationGraphicsDataBuffer = {};
+EWRAM_DATA u16 sCurDecorMapX = 0;
+EWRAM_DATA u16 sCurDecorMapY = 0;
+EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx1 = 0;
+EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx2 = 0;
+EWRAM_DATA u8 sDecorationLastDirectionMoved = 0;
+EWRAM_DATA struct OamData sDecorSelectorOam = {};
+EWRAM_DATA struct DecorRearrangementDataBuffer sDecorRearrangementDataBuffer[16] = {};
+EWRAM_DATA u8 sCurDecorSelectedInRearrangement = 0;
+
+// Static ROM declarations
+
+void sub_8126B80(u8 taskId);
+void sub_8126C08(void);
+void SecretBasePC_Decorate(u8 taskId);
+void SecretBasePC_PutAway(u8 taskId);
+void SecretBasePC_Toss(u8 taskId);
+void sub_8126DA4(u8 taskId);
+void SecretBasePC_Cancel(u8 taskId);
+void SecretBasePC_PrepMenuForSelectingStoredDecors(u8 taskId);
+void sub_8126DFC(u8 taskId);
+void sub_8126E8C(u8 taskId);
+void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed);
+void sub_8127058(u8 *str, bool8 flag);
+void sub_8127088(u8 taskId);
+void sub_81270E8(u8 taskId);
+void sub_8127180(u8 taskId);
+void sub_812719C(u8 taskId);
+void sub_81271CC(u8 taskId);
+void sub_8127268(u8 taskId);
+void sub_8127454(u8 *dest, u16 decorId);
+void sub_8127480(u32 a0, bool8 flag, struct ListMenu *menu);
+void sub_81274A0(u8 a0, s32 a1, u8 a2);
+void sub_8127620(u8 taskId);
+void sub_812764C(u8 taskId);
+void sub_8127744(u32 a0);
+void sub_81277A8(void);
+bool8 sub_81277BC(u8 idx);
+bool8 sub_81277E8(u8 idx);
+void IdentifyOwnedDecorationsCurrentlyInUse(u8 taskId);
+void sub_812759C(u8 taskId);
+void sub_8127718(u8 decorCat);
+void sub_8127A30(u8 taskId);
+void sub_8127A8C(u8 taskId);
+void sub_8127F68(u8 taskId);
+void sub_8128060(u8 taskId);
+void ConfigureCameraObjectForPlacingDecoration(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor);
+void SetUpPlacingDecorationPlayerAvatar(u8 taskId, struct PlaceDecorationGraphicsDataBuffer *data);
+void sub_812826C(u8 taskId);
+void sub_81283BC(u8 taskId);
+void sub_8128414(u8 taskId);
+void sub_8128950(u8 taskId);
+void sub_81289D0(u8 taskId);
+void sub_81289F0(u8 taskId);
+void sub_8128AAC(u8 taskId);
+void sub_8128B80(u8 taskId);
+void sub_8128BA0(u8 taskId);
+void sub_8128BBC(u8 taskId);
+void c1_overworld_prev_quest(u8 taskId);
+void sub_8128CD4(void);
+void sub_8128DE0(void);
+void sub_8128FD8(u8 taskId);
+void sub_8129020(u8 taskId);
+void sub_81292D0(struct Sprite *sprite);
+void sub_81292E8(struct Sprite *sprite);
+u8 gpu_pal_decompress_alloc_tag_and_upload(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor);
+const u8 *GetDecorationIconPicOrPalette(u16 decor, u8 mode);
+bool8 sub_81299AC(u8 taskId);
+void sub_8129ABC(u8 taskId);
+void sub_8129B34(u8 taskId);
+void sub_8129BCC(u8 taskId);
+void sub_8129BF8(u8 taskId);
+void sub_8129C74(u8 taskId);
+void sub_8129D64(u8 taskId);
+void sub_812A0E8(u8 taskId);
+void sub_812A1A0(u8 taskId);
+void sub_812A1C0(u8 taskId);
+void sub_812A1F0(u8 taskId);
+void sub_812A210(u8 taskId);
+void sub_812A22C(u8 taskId);
+void sub_812A25C(u8 taskId);
+void sub_812A334(void);
+void sub_812A36C(struct Sprite *sprite);
+void sub_812A39C(void);
+void sub_812A3C8(void);
+void sub_812A3D4(u8 taskId);
+void sub_812A458(u8 taskId);
+void sub_812A478(u8 taskId);
+
+// .rodata
+
+#include "data/decoration/tiles.h"
+#include "data/decoration/description.h"
+#include "data/decoration/header.h"
+
+const u8 *const sDecorCatNames[] = {
+ gText_Desk,
+ gText_Chair,
+ gText_Plant,
+ gText_Ornament,
+ gText_Mat,
+ gText_Poster,
+ gText_Doll,
+ gText_Cushion
+};
+
+const struct MenuAction sSecretBasePCMenuActions[] = {
+ {
+ gText_Decorate, {.void_u8=SecretBasePC_Decorate}
+ }, {
+ gText_PutAway, {.void_u8=SecretBasePC_PutAway}
+ }, {
+ gText_Toss2, {.void_u8=SecretBasePC_Toss}
+ }, {
+ gText_Cancel, {.void_u8=SecretBasePC_Cancel}
+ }
+};
+
+const u8 *const sSecretBasePCMenuItemDescriptions[] = {
+ gText_PutOutSelectedDecorItem,
+ gText_StoreChosenDecorInPC,
+ gText_ThrowAwayUnwantedDecors,
+ gText_GoBackPrevMenu
+};
+
+void (*const SecretBasePC_SelectedDecorActions[][2])(u8 taskId) = {
+ {
+ sub_8127F68, sub_8127A8C
+ }, {
+ sub_812A3D4, sub_8127A8C
+ }, {
+ sub_8133DA0, sub_8127A8C
+ }
+};
+
+const struct WindowTemplate gUnknown_085A6B90[4] = {
+ { 0, 1, 1, 18, 8, 15, 0x0001 },
+ { 0, 1, 1, 13, 18, 13, 0x0091 },
+ { 0, 17, 1, 12, 2, 15, 0x017b },
+ { 0, 16, 13, 13, 6, 15, 0x0193 }
+};
+
+const u16 gUnknown_085A6BB0[] = INCBIN_U16("graphics/decorations/unk_85a6bb0.gbapal");
+
+const struct ListMenuTemplate gUnknown_085A6BD0 = {
+ NULL,
+ sub_8127480,
+ sub_81274A0,
+ 0, 0,
+ 0, 0, 8, 0,
+ 9, 2, 1, 3, FALSE, 0, FALSE, 7
+};
+
+#include "data/decoration/icon.h"
+#include "data/decoration/tilemaps.h"
+
+const struct {
+ u8 shape;
+ u8 size;
+ u8 x;
+ u8 y;
+} gUnknown_085A7250[] = {
+ {0, 1, 0x78, 0x4e},
+ {1, 2, 0x80, 0x4e},
+ {1, 3, 0x90, 0x56},
+ {1, 3, 0x90, 0x46},
+ {0, 2, 0x80, 0x46},
+ {2, 2, 0x78, 0x46},
+ {2, 3, 0x80, 0x56},
+ {2, 3, 0x80, 0x36},
+ {0, 3, 0x90, 0x46},
+ {1, 3, 0x90, 0x46}
+};
+
+const union AnimCmd gUnknown_085A7278[] = {
+ ANIMCMD_FRAME(0, 0, FALSE, FALSE),
+ ANIMCMD_END
+};
+
+const union AnimCmd *const sDecorSelectorAnims[] = {
+ gUnknown_085A7278
+};
+
+const struct SpriteFrameImage sDecorSelectorSpriteFrameImages = {
+ (const u8 *)&sPlaceDecorationGraphicsDataBuffer.image, 0x800
+};
+
+const struct SpriteTemplate sDecorSelectorSpriteTemplate = {
+ 0xffff,
+ OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG,
+ &sDecorSelectorOam,
+ sDecorSelectorAnims,
+ &sDecorSelectorSpriteFrameImages,
+ gDummySpriteAffineAnimTable,
+ SpriteCallbackDummy
+};
+
+const struct SpriteTemplate sDecorWhilePlacingSpriteTemplate = {
+ 0x0000,
+ 0x0000,
+ &sDecorSelectorOam,
+ sDecorSelectorAnims,
+ NULL,
+ gDummySpriteAffineAnimTable,
+ SpriteCallbackDummy
+};
+
+const struct SpritePalette gUnknown_085A72BC = {
+ (const u16 *)&sPlaceDecorationGraphicsDataBuffer.palette, OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG
+};
+
+const struct YesNoFuncTable gUnknown_085A72C4 = {
+ sub_81289F0,
+ sub_8128FD8
+};
+
+const struct YesNoFuncTable gUnknown_085A72CC = {
+ sub_8128BA0,
+ sub_8128FD8
+};
+
+const struct YesNoFuncTable gUnknown_085A72D4[] = {
+ {
+ sub_81283BC,
+ sub_8128414
+ }, {
+ sub_8129BCC,
+ sub_8129BF8
+ }
+};
+
+const u8 gUnknown_085A72E4[] = {
+ 0x04, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x00
+};
+
+const u8 gUnknown_085A72EC[] = {
+ 0x04, 0x04, 0x04, 0x04, 0x00, 0x04, 0x03, 0x00
+};
+
+const u16 gUnknown_085A72F4[] = {
+ 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x10, 0x20, 0x40, 0x20
+};
+
+const u16 Unknown_085A7308[] = INCBIN_U16("graphics/decorations/unk_85a7308.gbapal");
+
+const u16 Unknown_085A7328[] = INCBIN_U16("graphics/decorations/unk_85a7328.gbapal");
+
+const struct YesNoFuncTable gUnknown_085A7348 = {
+ sub_812A1C0,
+ sub_8129B34
+};
+
+const struct YesNoFuncTable gUnknown_085A7350 = {
+ sub_812A210,
+ sub_8129B34
+};
+
+const u8 Unknown_085A7358[] = INCBIN_U8("graphics/misc/decoration_unk_85a7358.4bpp");
+
+const struct SpritePalette gUnknown_085A73D8 = {
+ Unknown_085A7308, OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG
+};
+
+const struct SpritePalette gUnknown_085A73E0 = {
+ Unknown_085A7328, OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG
+};
+
+const struct OamData Unknown_085A73E8 = {
+ .size = 1, .priority = 1
+};
+
+const union AnimCmd Unknown_085A73F0[] = {
+ ANIMCMD_FRAME(0, 0, 0),
+ ANIMCMD_END
+};
+
+const union AnimCmd *const Unknown_085A73F8[] = {
+ Unknown_085A73F0
+};
+
+const struct SpriteFrameImage Unknown_085A73FC = {
+ Unknown_085A7358, 0x80
+};
+
+const struct SpriteTemplate gUnknown_085A7404 = {
+ 0xFFFF,
+ OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG,
+ &Unknown_085A73E8,
+ Unknown_085A73F8,
+ &Unknown_085A73FC,
+ gDummySpriteAffineAnimTable,
+ sub_812A36C
+};
+
+const struct YesNoFuncTable gUnknown_085A741C = {
+ sub_812A478,
+ sub_8127A30
+};
+
+// .text
+
+void sub_8126968(void)
+{
+ if (sCurDecorationCategory < 8)
+ {
+ gCurDecorInventoryItems = gDecorationInventories[sCurDecorationCategory].items;
+ }
+ if (gUnknown_0203A17C.isPlayerRoom == FALSE)
+ {
+ gUnknown_0203A17C.items = gSaveBlock1Ptr->secretBases[0].decorations;
+ gUnknown_0203A17C.pos = gSaveBlock1Ptr->secretBases[0].decorationPos;
+ }
+ if (gUnknown_0203A17C.isPlayerRoom == TRUE)
+ {
+ gUnknown_0203A17C.items = gSaveBlock1Ptr->playerRoomDecor;
+ gUnknown_0203A17C.pos = gSaveBlock1Ptr->playerRoomDecorPos;
+ }
+}
+
+u8 sub_81269D4(u8 idx)
+{
+ u8 *winidx;
+ struct WindowTemplate template;
+
+ winidx = &sDecorMenuWindowIndices[idx];
+ if (idx == 0)
+ {
+ template = gUnknown_085A6B90[0];
+ template.width = GetMaxWidthInMenuTable(sSecretBasePCMenuActions, 4);
+ if (template.width > 18)
+ {
+ template.width = 18;
+ }
+ *winidx = AddWindow(&template);
+ }
+ else
+ {
+ *winidx = AddWindow(&gUnknown_085A6B90[idx]);
+ }
+ SetWindowBorderStyle(*winidx, 0, 0x214, 0xe);
+ schedule_bg_copy_tilemap_to_vram(0);
+ return *winidx;
+}
+
+void sub_8126A58(u8 idx)
+{
+ sub_8198070(sDecorMenuWindowIndices[idx], FALSE);
+ ClearWindowTilemap(sDecorMenuWindowIndices[idx]);
+ RemoveWindow(sDecorMenuWindowIndices[idx]);
+ schedule_bg_copy_tilemap_to_vram(0);
+}
+
+void sub_8126A88(void)
+{
+ u8 idx;
+
+ idx = sub_81269D4(0);
+ PrintMenuTable(idx, 4, sSecretBasePCMenuActions);
+ InitMenuInUpperLeftCornerPlaySoundWhenAPressed(idx, 4, sSecretBasePCMenuCursorPos);
+}
+
+void sub_8126ABC(void)
+{
+ sSecretBasePCMenuCursorPos = 0;
+ ScriptContext2_Enable();
+ sub_8126A88();
+ sub_8126C08();
+}
+
+void sub_8126AD8(u8 taskId)
+{
+ sub_8126ABC();
+ gUnknown_0203A17C.items = gSaveBlock1Ptr->secretBases[0].decorations;
+ gUnknown_0203A17C.pos = gSaveBlock1Ptr->secretBases[0].decorationPos;
+ gUnknown_0203A17C.size = sizeof(gSaveBlock1Ptr->secretBases[0].decorations);
+ gUnknown_0203A17C.isPlayerRoom = FALSE;
+ gTasks[taskId].func = sub_8126B80;
+}
+
+void sub_8126B2C(u8 taskId)
+{
+ sub_8126ABC();
+ gUnknown_0203A17C.items = gSaveBlock1Ptr->playerRoomDecor;
+ gUnknown_0203A17C.pos = gSaveBlock1Ptr->playerRoomDecorPos;
+ gUnknown_0203A17C.size = sizeof(gSaveBlock1Ptr->playerRoomDecor);
+ gUnknown_0203A17C.isPlayerRoom = TRUE;
+ gTasks[taskId].func = sub_8126B80;
+}
+
+void sub_8126B80(u8 taskId)
+{
+ u8 menuPos;
+
+ if (!gPaletteFade.active)
+ {
+ menuPos = GetMenuCursorPos();
+ switch (ProcessMenuInput())
+ {
+ default:
+ PlaySE(SE_SELECT);
+ sSecretBasePCMenuActions[sSecretBasePCMenuCursorPos].func.void_u8(taskId);
+ break;
+ case -2:
+ sSecretBasePCMenuCursorPos = GetMenuCursorPos();
+ if ((s8)menuPos != sSecretBasePCMenuCursorPos)
+ {
+ sub_8126C08();
+ }
+ break;
+ case -1:
+ PlaySE(SE_SELECT);
+ SecretBasePC_Cancel(taskId);
+ break;
+ }
+ }
+}
+
+void sub_8126C08(void)
+{
+ FillWindowPixelBuffer(0, 0x11);
+ AddTextPrinterParametrized(0, 1, sSecretBasePCMenuItemDescriptions[sSecretBasePCMenuCursorPos], 0, 0, 2, 1, 3);
+}
+
+void SecretBasePC_Decorate(u8 taskId)
+{
+ if (CountDecorations() == 0)
+ {
+ StringExpandPlaceholders(gStringVar4, gText_NoDecorations);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4);
+ }
+ else
+ {
+ gTasks[taskId].data[11] = 0;
+ sCurDecorationCategory = DECORCAT_DESK;
+ SecretBasePC_PrepMenuForSelectingStoredDecors(taskId);
+ }
+}
+
+void SecretBasePC_PutAway(u8 taskId)
+{
+ if (!sub_81299AC(taskId))
+ {
+ StringExpandPlaceholders(gStringVar4, gText_NoDecorationsInUse);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4);
+ }
+ else
+ {
+ sub_8126A58(0);
+ sub_8197434(0, 0);
+ fade_screen(1, 0);
+ gTasks[taskId].data[2] = 0;
+ gTasks[taskId].func = sub_8129ABC;
+ }
+}
+
+void SecretBasePC_Toss(u8 taskId)
+{
+ if (CountDecorations() == 0)
+ {
+ StringExpandPlaceholders(gStringVar4, gText_NoDecorations);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4);
+ }
+ else
+ {
+ gTasks[taskId].data[11] = 1;
+ sCurDecorationCategory = DECORCAT_DESK;
+ SecretBasePC_PrepMenuForSelectingStoredDecors(taskId);
+ }
+}
+
+void SecretBasePC_Cancel(u8 taskId)
+{
+ sub_8126A58(0);
+ if (!gUnknown_0203A17C.isPlayerRoom)
+ {
+ ScriptContext1_SetupScript(gUnknown_0823B4E8);
+ DestroyTask(taskId);
+ }
+ else
+ {
+ sub_816B060(taskId);
+ }
+}
+
+void sub_8126DA4(u8 taskId)
+{
+ sub_8126C08();
+ gTasks[taskId].func = sub_8126B80;
+}
+
+void SecretBasePC_PrepMenuForSelectingStoredDecors(u8 taskId)
+{
+ LoadPalette(gUnknown_085A6BB0, 0xd0, 0x20);
+ sub_8197434(0, 0);
+ sub_8126A58(0);
+ sub_8126DFC(taskId);
+}
+
+void sub_8126DFC(u8 taskId)
+{
+ u8 winIdx;
+
+ winIdx = sub_81269D4(1);
+ sub_8126E8C(taskId);
+ InitMenuInUpperLeftCornerPlaySoundWhenAPressed(winIdx, 9, sCurDecorationCategory);
+ gTasks[taskId].func = sub_8127088;
+}
+
+void sub_8126E44(u8 taskId)
+{
+ FillWindowPixelBuffer(sDecorMenuWindowIndices[1], 0x11);
+ sub_8126E8C(taskId);
+ InitMenuInUpperLeftCornerPlaySoundWhenAPressed(sDecorMenuWindowIndices[1], 9, sCurDecorationCategory);
+ gTasks[taskId].func = sub_8127088;
+}
+
+void sub_8126E8C(u8 taskId)
+{
+ s16 *data;
+ u8 r5;
+ bool8 r8;
+ u8 i;
+ bool8 fl;
+
+ data = gTasks[taskId].data;
+ r5 = sDecorMenuWindowIndices[1];
+ fl = gUnknown_0203A17C.isPlayerRoom;
+ r8 = FALSE;
+ if (fl == TRUE && data[11] == 0)
+ {
+ r8 = TRUE;
+ }
+ for (i = 0; i < 8; i ++)
+ {
+ if (r8 == TRUE && i != DECORCAT_DOLL && i != DECORCAT_CUSHION)
+ {
+ sub_8126F68(r5, i, 8, i << 4, TRUE, 0xFF);
+ }
+ else
+ {
+ sub_8126F68(r5, i, 8, i << 4, FALSE, 0xFF);
+ }
+ }
+ PrintTextOnWindow(r5, 1, gTasks[taskId].data[11] == 2 ? gText_Exit : gText_Cancel, 8, (i << 4) + 1, 0, 0);
+ schedule_bg_copy_tilemap_to_vram(0);
+}
+
+void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed)
+{
+ u8 width;
+ u8 *strbuf;
+
+ width = x == 8 ? 0x68 : 0x60;
+ y ++;
+ sub_8127058(gStringVar4, flag);
+ strbuf = StringLength(gStringVar4) + gStringVar4;
+ StringCopy(strbuf, sDecorCatNames[decorCat]);
+ PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL);
+ strbuf = ConvertIntToDecimalStringN(strbuf, CountDecorationCategoryN(decorCat), STR_CONV_MODE_RIGHT_ALIGN, 2);
+ *strbuf++ = CHAR_SLASH;
+ ConvertIntToDecimalStringN(strbuf, gDecorationInventories[decorCat].size, STR_CONV_MODE_RIGHT_ALIGN, 2);
+ x = GetStringRightAlignXOffset(1, gStringVar4, width);
+ PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL);
+}
+
+void sub_8127058(u8 *str, bool8 flag)
+{
+ StringCopy(str, gText_Color161Shadow161);
+ if (flag == TRUE)
+ {
+ str[2] = 0x04; // RED
+ str[5] = 0x05; // LIGHT_RED
+ }
+ else
+ {
+ str[2] = 0x02; // DARK_GREY
+ str[5] = 0x03; // LIGHT_GREY
+ }
+}
+
+void sub_8127088(u8 taskId)
+{
+ s8 input;
+
+ if (!gPaletteFade.active)
+ {
+ input = ProcessMenuInput();
+ switch (input)
+ {
+ case -1:
+ case 8:
+ PlaySE(SE_SELECT);
+ sub_812719C(taskId);
+ break;
+ case -2:
+ break;
+ default:
+ PlaySE(SE_SELECT);
+ sCurDecorationCategory = input;
+ sub_81270E8(taskId);
+ break;
+ }
+ }
+}
+
+void sub_81270E8(u8 taskId)
+{
+ sCurDecorCatCount = CountDecorationCategoryN(sCurDecorationCategory);
+ if (sCurDecorCatCount != 0)
+ {
+ CondenseDecorationCategoryN(sCurDecorationCategory);
+ gCurDecorInventoryItems = gDecorationInventories[sCurDecorationCategory].items;
+ IdentifyOwnedDecorationsCurrentlyInUse(taskId);
+ sSecretBasePCSelectDecorPageNo = 0;
+ sSecretBasePCSelectDecorLineNo = 0;
+ gTasks[taskId].func = sub_8127620;
+ }
+ else
+ {
+ sub_8126A58(1);
+ StringExpandPlaceholders(gStringVar4, gText_NoDecorations);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8127180);
+ }
+}
+
+void sub_8127180(u8 taskId)
+{
+ sub_8197434(0, 0);
+ sub_8126DFC(taskId);
+}
+
+void sub_812719C(u8 taskId)
+{
+ if (gTasks[taskId].data[11] != 2)
+ {
+ sub_81271CC(taskId);
+ }
+ else
+ {
+ sub_8127268(taskId);
+ }
+}
+
+void sub_81271CC(u8 taskId)
+{
+ sub_8126A58(1);
+ sub_8126A88();
+ sub_81973C4(0, 0);
+ sub_8126C08();
+ gTasks[taskId].func = sub_8126B80;
+}
+
+void sub_8127208(u8 taskId)
+{
+ LoadPalette(gUnknown_085A6BB0, 0xd0, 0x20);
+ sub_8197434(0, 0);
+ gTasks[taskId].data[11] = 2;
+ sCurDecorationCategory = DECORCAT_DESK;
+ sub_8126DFC(taskId);
+}
+
+void sub_8127250(u8 *dest, u8 decorCat)
+{
+ StringCopy(dest, sDecorCatNames[decorCat]);
+}
+
+void sub_8127268(u8 taskId)
+{
+ sub_8126A58(1);
+ sub_8133E1C(taskId);
+}
+
+void sub_8127284(void)
+{
+ sDecorPCBuffer->unk_520 = sCurDecorCatCount + 1;
+ if (sDecorPCBuffer->unk_520 > 8)
+ {
+ sDecorPCBuffer->unk_521 = 8;
+ }
+ else
+ {
+ sDecorPCBuffer->unk_521 = sDecorPCBuffer->unk_520;
+ }
+}
+
+void sub_81272C8(void)
+{
+ sub_812225C(&sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo, sDecorPCBuffer->unk_521, sDecorPCBuffer->unk_520);
+}
+
+void sub_81272F8(void)
+{
+ sub_8122298(&sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo, sDecorPCBuffer->unk_521, sDecorPCBuffer->unk_520, 8);
+}
+
+void sub_8127330(u8 taskId)
+{
+ s16 *data;
+ u16 i;
+
+ data = gTasks[taskId].data;
+ if ((sCurDecorationCategory < DECORCAT_DOLL || sCurDecorationCategory > DECORCAT_CUSHION) && gUnknown_0203A17C.isPlayerRoom == TRUE && data[11] == 0)
+ {
+ sub_8127058(gStringVar1, TRUE);
+ }
+ else
+ {
+ sub_8127058(gStringVar1, FALSE);
+ }
+ for (i = 0; i < sDecorPCBuffer->unk_520 - 1; i ++)
+ {
+ sub_8127454(sDecorPCBuffer->names[i], gCurDecorInventoryItems[i]);
+ sDecorPCBuffer->items[i].unk_00 = sDecorPCBuffer->names[i];
+ sDecorPCBuffer->items[i].unk_04 = i;
+ }
+ StringCopy(sDecorPCBuffer->names[i], gText_Cancel);
+ sDecorPCBuffer->items[i].unk_00 = sDecorPCBuffer->names[i];
+ sDecorPCBuffer->items[i].unk_04 = -2;
+ gUnknown_03006310 = gUnknown_085A6BD0;
+ gUnknown_03006310.unk_10 = sDecorMenuWindowIndices[1];
+ gUnknown_03006310.unk_0c = sDecorPCBuffer->unk_520;
+ gUnknown_03006310.unk_00 = sDecorPCBuffer->items;
+ gUnknown_03006310.unk_0e = sDecorPCBuffer->unk_521;
+}
+
+void sub_8127454(u8 *dest, u16 decorId)
+{
+ StringCopy(dest, gStringVar1);
+ StringAppend(dest, gDecorations[decorId].name);
+}
+
+void sub_8127480(u32 a0, bool8 flag, struct ListMenu *menu)
+{
+ if (flag != TRUE)
+ {
+ PlaySE(SE_SELECT);
+ }
+ sub_8127744(a0);
+}
+
+void sub_81274A0(u8 a0, s32 a1, u8 a2)
+{
+ if (a1 != -2)
+ {
+ if (sub_81277BC(a1 + 1) == TRUE)
+ {
+ blit_move_info_icon(a0, 0x18, 0x5c, a2 + 2);
+ }
+ else if (sub_81277E8(a1 + 1) == TRUE)
+ {
+ blit_move_info_icon(a0, 0x19, 0x5c, a2 + 2);
+ }
+ }
+}
+
+void sub_8127500(void)
+{
+ if (sDecorPCBuffer->unk_522 == 0xFF)
+ {
+ sDecorPCBuffer->unk_522 = AddScrollIndicatorArrowPairParametrized(0x02, 0x3c, 0x0c, 0x94, sDecorPCBuffer->unk_520 - sDecorPCBuffer->unk_521, 0x6e, 0x6e, &sSecretBasePCSelectDecorPageNo);
+ }
+}
+
+void sub_8127554(void)
+{
+ if (sDecorPCBuffer->unk_522 != 0xFF)
+ {
+ RemoveScrollIndicatorArrowPair(sDecorPCBuffer->unk_522);
+ sDecorPCBuffer->unk_522 = 0xFF;
+ }
+}
+
+void sub_8127580(u8 taskId)
+{
+ sub_81269D4(1);
+ sub_812759C(taskId);
+}
+
+void sub_812759C(u8 taskId)
+{
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ sub_81269D4(3);
+ sub_8127718(sCurDecorationCategory);
+ sDecorPCBuffer = calloc(1, sizeof(struct DecorPCBuffer));
+ sDecorPCBuffer->unk_522 = 0xFF;
+ sub_8127284();
+ sub_81272C8();
+ sub_81272F8();
+ sub_8127330(taskId);
+ data[13] = ListMenuInit(&gUnknown_03006310, sSecretBasePCSelectDecorPageNo, sSecretBasePCSelectDecorLineNo);
+ sub_8127500();
+}
+
+void sub_8127620(u8 taskId)
+{
+ sub_812759C(taskId);
+ gTasks[taskId].func = sub_812764C;
+}
+
+void sub_812764C(u8 taskId)
+{
+ s16 *data;
+ s32 input;
+
+ data = gTasks[taskId].data;
+ if (!gPaletteFade.active)
+ {
+ input = ListMenuHandleInput(data[13]);
+ get_coro_args_x18_x1A(data[13], &sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo);
+ switch (input)
+ {
+ case -1:
+ break;
+ case -2:
+ PlaySE(SE_SELECT);
+ SecretBasePC_SelectedDecorActions[data[11]][1](taskId);
+ break;
+ default:
+ PlaySE(SE_SELECT);
+ gCurDecorationIndex = input;
+ sub_8127554();
+ sub_81AE6C8(data[13], &sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo);
+ sub_8126A58(1);
+ sub_81277A8();
+ free(sDecorPCBuffer);
+ SecretBasePC_SelectedDecorActions[data[11]][0](taskId);
+ break;
+ }
+ }
+}
+
+void sub_8127718(u8 decorCat)
+{
+ sub_8126F68(sub_81269D4(2), decorCat, 0, 0, 0, 0);
+}
+
+void sub_8127744(u32 a0)
+{
+ u8 winidx;
+ const u8 *txt;
+
+ winidx = sDecorMenuWindowIndices[3];
+ FillWindowPixelBuffer(winidx, 0x11);
+ if (a0 >= sCurDecorCatCount)
+ {
+ txt = gText_GoBackPrevMenu;
+ }
+ else
+ {
+ txt = gDecorations[gCurDecorInventoryItems[a0]].description;
+ }
+ PrintTextOnWindow(winidx, 1, txt, 0, 1, 0, 0);
+}
+
+void sub_81277A8(void)
+{
+ sub_8126A58(3);
+ sub_8126A58(2);
+}
+
+bool8 sub_81277BC(u8 idx)
+{
+ u8 i;
+
+ for (i = 0; i < 16; i ++)
+ {
+ if (sSecretBaseItemsIndicesBuffer[i] == idx)
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+bool8 sub_81277E8(u8 idx)
+{
+ u8 i;
+
+ for (i = 0; i < 12; i ++)
+ {
+ if (sPlayerRoomItemsIndicesBuffer[i] == idx)
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+void IdentifyOwnedDecorationsCurrentlyInUseInternal(u8 taskId)
+{
+ u16 i;
+ u16 j;
+ u16 k;
+ u16 cnt;
+
+ cnt = 0;
+ memset(sSecretBaseItemsIndicesBuffer, 0, 16);
+ memset(sPlayerRoomItemsIndicesBuffer, 0, 12);
+ for (i = 0; i < 16; i ++)
+ {
+ if (gSaveBlock1Ptr->secretBases[0].decorations[i] != DECOR_NONE)
+ {
+ for (j = 0; j < gDecorationInventories[sCurDecorationCategory].size; j ++)
+ {
+ if (gCurDecorInventoryItems[j] == gSaveBlock1Ptr->secretBases[0].decorations[i])
+ {
+ for (k = 0; k < cnt && sSecretBaseItemsIndicesBuffer[k] != j + 1; k ++);
+ if (k == cnt)
+ {
+ sSecretBaseItemsIndicesBuffer[cnt] = j + 1;
+ cnt ++;
+ break;
+ }
+ }
+ }
+ }
+ }
+ cnt = 0;
+ for (i = 0; i < 12; i ++)
+ {
+ if (gSaveBlock1Ptr->playerRoomDecor[i] != DECOR_NONE)
+ {
+ for (j = 0; j < gDecorationInventories[sCurDecorationCategory].size; j ++)
+ {
+ if (gCurDecorInventoryItems[j] == gSaveBlock1Ptr->playerRoomDecor[i] && sub_81277BC(j + 1) != TRUE)
+ {
+ for (k = 0; k < cnt && sPlayerRoomItemsIndicesBuffer[k] != j + 1; k ++);
+ if (k == cnt)
+ {
+ sPlayerRoomItemsIndicesBuffer[cnt] = j + 1;
+ cnt ++;
+ break;
+ }
+ }
+ }
+ }
+ }
+}
+
+void IdentifyOwnedDecorationsCurrentlyInUse(u8 taskId)
+{
+ IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId);
+}
+
+bool8 IsSelectedDecorInThePC(void)
+{
+ u16 i;
+ for (i = 0; i < 16; i ++)
+ {
+ if (sSecretBaseItemsIndicesBuffer[i] == sSecretBasePCSelectDecorPageNo + sSecretBasePCSelectDecorLineNo + 1)
+ {
+ return FALSE;
+ }
+ if (i < 12 && sPlayerRoomItemsIndicesBuffer[i] == sSecretBasePCSelectDecorPageNo + sSecretBasePCSelectDecorLineNo + 1)
+ {
+ return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+void sub_8127A14(u8 taskId)
+{
+ sub_81269D4(1);
+ sub_8127620(taskId);
+}
+
+void sub_8127A30(u8 taskId)
+{
+ sub_8197434(0, 0);
+ gTasks[taskId].func = sub_8127A14;
+}
+
+void sub_8127A5C(u8 taskId)
+{
+ if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+ {
+ sub_8197434(0, 0);
+ sub_81269D4(1);
+ sub_8127620(taskId);
+ }
+}
+
+void sub_8127A8C(u8 taskId)
+{
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ sub_8127554();
+ sub_81277A8();
+ sub_81AE6C8(data[13], NULL, NULL);
+ free(sDecorPCBuffer);
+ sub_8126E44(taskId);
+}
+
+void sub_8127ACC(u8 taskId)
+{
+ gTasks[taskId].data[3] = gSaveBlock1Ptr->pos.x;
+ gTasks[taskId].data[4] = gSaveBlock1Ptr->pos.y;
+ PlayerGetDestCoords(&gTasks[taskId].data[0], &gTasks[taskId].data[1]);
+}
+
+void sub_8127B04(u8 taskId)
+{
+ DrawWholeMapView();
+ Overworld_SetWarpDestination(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, gTasks[taskId].data[3], gTasks[taskId].data[4]);
+ warp_in();
+}
+
+u16 sub_8127B54(u8 decor, u8 a1)
+{
+ u16 resp;
+
+ resp = -1;
+ switch (decor)
+ {
+ case DECOR_STAND:
+ resp = gUnknown_085A72E4[a1] << 12;
+ return resp;
+ case DECOR_SLIDE:
+ resp = gUnknown_085A72EC[a1] << 12;
+ return resp;
+ default:
+ return resp;
+ }
+}
+
+void sub_8127B90(u16 mapX, u16 mapY, u8 decWidth, u8 decHeight, u16 decor)
+{
+ u16 i;
+ u16 j;
+ u16 behavior;
+ u16 flags;
+ u16 v0;
+ u16 v1;
+ s16 decLeft;
+ s16 decBottom;
+
+ for (i = 0; i < decHeight; i ++)
+ {
+ decBottom = mapY - decHeight + 1 + i;
+ for (j = 0; j < decWidth; j ++)
+ {
+ decLeft = mapX + j;
+ behavior = GetBehaviorByMetatileId(0x200 + gDecorations[decor].tiles[i * decWidth + j]);
+ if (MetatileBehavior_IsMB_B9(behavior) == TRUE || (gDecorations[decor].permission != DECORPERM_PASS_FLOOR && (behavior >> 12)))
+ {
+ flags = 0xc00;
+ }
+ else
+ {
+ flags = 0x000;
+ }
+ if (gDecorations[decor].permission != DECORPERM_NA_WALL && MetatileBehavior_IsMB_B7(MapGridGetMetatileBehaviorAt(decLeft, decBottom)) == TRUE)
+ {
+ v0 = 1;
+ }
+ else
+ {
+ v0 = 0;
+ }
+ v1 = sub_8127B54(gDecorations[decor].id, i * decWidth + j);
+ if (v1 != 0xFFFF)
+ {
+ MapGridSetMetatileEntryAt(decLeft, decBottom, (gDecorations[decor].tiles[i * decWidth + j] + (0x200 | v0)) | flags | v1);
+ }
+ else
+ {
+ MapGridSetMetatileIdAt(decLeft, decBottom, (gDecorations[decor].tiles[i * decWidth + j] + (0x200 | v0)) | flags);
+ }
+ }
+ }
+}
+
+void sub_8127D38(u16 mapX, u16 mapY, u16 decor)
+{
+ switch (gDecorations[decor].shape)
+ {
+ case DECORSHAPE_1x1:
+ sub_8127B90(mapX, mapY, 1, 1, decor);
+ break;
+ case DECORSHAPE_2x1:
+ sub_8127B90(mapX, mapY, 2, 1, decor);
+ break;
+ case DECORSHAPE_3x1: // unused
+ sub_8127B90(mapX, mapY, 3, 1, decor);
+ break;
+ case DECORSHAPE_4x2:
+ sub_8127B90(mapX, mapY, 4, 2, decor);
+ break;
+ case DECORSHAPE_2x2:
+ sub_8127B90(mapX, mapY, 2, 2, decor);
+ break;
+ case DECORSHAPE_1x2:
+ sub_8127B90(mapX, mapY, 1, 2, decor);
+ break;
+ case DECORSHAPE_1x3: // unused
+ sub_8127B90(mapX, mapY, 1, 3, decor);
+ break;
+ case DECORSHAPE_2x4:
+ sub_8127B90(mapX, mapY, 2, 4, decor);
+ break;
+ case DECORSHAPE_3x3:
+ sub_8127B90(mapX, mapY, 3, 3, decor);
+ break;
+ case DECORSHAPE_3x2:
+ sub_8127B90(mapX, mapY, 3, 2, decor);
+ break;
+ }
+}
+
+void sub_8127E18(void)
+{
+ u8 i;
+ u8 j;
+
+ for (i = 0; i < 14; i ++)
+ {
+ if (FlagGet(0xAE + i) == TRUE)
+ {
+ FlagClear(0xAE + i);
+ for (j = 0; j < gMapHeader.events->mapObjectCount; j ++)
+ {
+ if (gMapHeader.events->mapObjects[j].flagId == 0xAE + i)
+ {
+ break;
+ }
+ }
+ VarSet(0x3F20 + gMapHeader.events->mapObjects[j].graphicsId, sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0]);
+ gSpecialVar_0x8005 = gMapHeader.events->mapObjects[j].localId;
+ gSpecialVar_0x8006 = sCurDecorMapX;
+ gSpecialVar_0x8007 = sCurDecorMapY;
+ show_sprite(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
+ sub_808EBA8(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, gSpecialVar_0x8006, gSpecialVar_0x8007);
+ sub_808F254(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
+ break;
+ }
+ }
+}
+
+bool8 sub_8127F38(void)
+{
+ u16 i;
+
+ for (i = 0; i < gUnknown_0203A17C.size; i ++)
+ {
+ if (gUnknown_0203A17C.items[i] == DECOR_NONE)
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+void sub_8127F68(u8 taskId)
+{
+ if (gUnknown_0203A17C.isPlayerRoom == TRUE && sCurDecorationCategory != DECORCAT_DOLL && sCurDecorationCategory != DECORCAT_CUSHION)
+ {
+ StringExpandPlaceholders(gStringVar4, gText_CantPlaceInRoom);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+ }
+ else if (IsSelectedDecorInThePC() == TRUE)
+ {
+ if (sub_8127F38() == TRUE)
+ {
+ fade_screen(1, 0);
+ gTasks[taskId].data[2] = 0;
+ gTasks[taskId].func = sub_8128060;
+ }
+ else
+ {
+ ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203A17C.size, STR_CONV_MODE_RIGHT_ALIGN, 2);
+ if (gUnknown_0203A17C.isPlayerRoom == FALSE) {
+ StringExpandPlaceholders(gStringVar4, gText_NoMoreDecorations);
+ }
+ else
+ {
+ StringExpandPlaceholders(gStringVar4, gText_NoMoreDecorations2);
+ }
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+ }
+ }
+ else
+ {
+ StringExpandPlaceholders(gStringVar4, gText_InUseAlready);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+ }
+}
+
+void sub_8128060(u8 taskId)
+{
+ switch (gTasks[taskId].data[2])
+ {
+ case 0:
+ if (!gPaletteFade.active)
+ {
+ sub_8127ACC(taskId);
+ gTasks[taskId].data[2] = 1;
+ }
+ break;
+ case 1:
+ gPaletteFade.bufferTransferDisabled = TRUE;
+ ConfigureCameraObjectForPlacingDecoration(&sPlaceDecorationGraphicsDataBuffer, gCurDecorInventoryItems[gCurDecorationIndex]);
+ sub_812826C(taskId);
+ SetUpPlacingDecorationPlayerAvatar(taskId, &sPlaceDecorationGraphicsDataBuffer);
+ pal_fill_black();
+ gPaletteFade.bufferTransferDisabled = FALSE;
+ gTasks[taskId].data[2] = 2;
+ break;
+ case 2:
+ if (sub_80ABDFC() == TRUE)
+ {
+ gTasks[taskId].data[12] = 0;
+ sub_8128FD8(taskId);
+ }
+ break;
+ }
+}
+
+void ConfigureCameraObjectForPlacingDecoration(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor)
+{
+ sDecor_CameraSpriteObjectIdx1 = gSprites[gUnknown_03005DD0.unk4].data0;
+ gUnknown_03005DD0.unk4 = gpu_pal_decompress_alloc_tag_and_upload(data, decor);
+ gSprites[gUnknown_03005DD0.unk4].oam.priority = 1;
+ gSprites[gUnknown_03005DD0.unk4].callback = sub_81292D0;
+ gSprites[gUnknown_03005DD0.unk4].pos1.x = gUnknown_085A7250[data->decoration->shape].x;
+ gSprites[gUnknown_03005DD0.unk4].pos1.y = gUnknown_085A7250[data->decoration->shape].y;
+}
+
+void SetUpPlacingDecorationPlayerAvatar(u8 taskId, struct PlaceDecorationGraphicsDataBuffer *data)
+{
+ u8 v0;
+
+ v0 = 16 * (u8)gTasks[taskId].data[5] + gUnknown_085A7250[data->decoration->shape].x - 8 * ((u8)gTasks[taskId].data[5] - 1);
+ if (data->decoration->shape == DECORSHAPE_3x1 || data->decoration->shape == DECORSHAPE_3x3 || data->decoration->shape == DECORSHAPE_3x2)
+ {
+ v0 -= 8;
+ }
+ if (gSaveBlock2Ptr->playerGender == MALE)
+ {
+ sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC1, SpriteCallbackDummy, v0, 0x48, 0);
+ }
+ else
+ {
+ sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC2, SpriteCallbackDummy, v0, 0x48, 0);
+ }
+ gSprites[sDecor_CameraSpriteObjectIdx2].oam.priority = 1;
+ DestroySprite(&gSprites[sDecor_CameraSpriteObjectIdx1]);
+ sDecor_CameraSpriteObjectIdx1 = gUnknown_03005DD0.unk4;
+}
+
+void sub_812826C(u8 taskId)
+{
+ switch (gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].shape)
+ {
+ case DECORSHAPE_1x1:
+ gTasks[taskId].data[5] = 1;
+ gTasks[taskId].data[6] = 1;
+ break;
+ case DECORSHAPE_2x1:
+ gTasks[taskId].data[5] = 2;
+ gTasks[taskId].data[6] = 1;
+ break;
+ case DECORSHAPE_3x1:
+ gTasks[taskId].data[5] = 3;
+ gTasks[taskId].data[6] = 1;
+ break;
+ case DECORSHAPE_4x2:
+ gTasks[taskId].data[5] = 4;
+ gTasks[taskId].data[6] = 2;
+ break;
+ case DECORSHAPE_2x2:
+ gTasks[taskId].data[5] = 2;
+ gTasks[taskId].data[6] = 2;
+ break;
+ case DECORSHAPE_1x2:
+ gTasks[taskId].data[5] = 1;
+ gTasks[taskId].data[6] = 2;
+ break;
+ case DECORSHAPE_1x3:
+ gTasks[taskId].data[5] = 1;
+ gTasks[taskId].data[6] = 3;
+ gTasks[taskId].data[1]++;
+ break;
+ case DECORSHAPE_2x4:
+ gTasks[taskId].data[5] = 2;
+ gTasks[taskId].data[6] = 4;
+ break;
+ case DECORSHAPE_3x3:
+ gTasks[taskId].data[5] = 3;
+ gTasks[taskId].data[6] = 3;
+ break;
+ case DECORSHAPE_3x2:
+ gTasks[taskId].data[5] = 3;
+ gTasks[taskId].data[6] = 2;
+ break;
+ }
+}
+
+void sub_81283BC(u8 taskId)
+{
+ gTasks[taskId].data[10] = 0;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 1;
+ gSprites[sDecor_CameraSpriteObjectIdx2].data7 = 1;
+ sub_8128DE0();
+ sub_8128950(taskId);
+}
+
+void sub_8128414(u8 taskId)
+{
+ gTasks[taskId].data[10] = 0;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 1;
+ gSprites[sDecor_CameraSpriteObjectIdx2].data7 = 1;
+ sub_8128DE0();
+ StringExpandPlaceholders(gStringVar4, gText_CancelDecorating);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8128B80);
+}
+
+bool8 sub_8128484(u8 behaviorAt, u16 behaviorBy)
+{
+ if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE || behaviorBy != 0)
+ {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+bool8 sub_81284AC(u8 taskId, s16 x, s16 y, u16 decor)
+{
+ if (x == gTasks[taskId].data[3] + 7 && y == gTasks[taskId].data[4] + 7 && decor != DECOR_NONE)
+ {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+bool8 sub_81284F4(u16 behaviorAt, const struct Decoration *decoration)
+{
+ if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE)
+ {
+ if (decoration->id == DECOR_SOLID_BOARD && MetatileBehavior_IsMB_C2(behaviorAt) == TRUE)
+ {
+ return TRUE;
+ }
+ if (MetatileBehavior_IsNormal(behaviorAt))
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+bool8 sub_812853C(u8 taskId, const struct Decoration *decoration)
+{
+ u8 i;
+ u8 j;
+ u8 behaviorAt;
+ u16 behaviorBy;
+ u8 mapY;
+ u8 mapX;
+ s16 curY;
+ s16 curX;
+ mapY = gTasks[taskId].data[6];
+ mapX = gTasks[taskId].data[5];
+
+ switch (decoration->permission)
+ {
+ case DECORPERM_SOLID_FLOOR:
+ case DECORPERM_PASS_FLOOR:
+ for (i=0; i<mapY; i++)
+ {
+ curY = gTasks[taskId].data[1] - i;
+ for (j=0; j<mapX; j++)
+ {
+ curX = gTasks[taskId].data[0] + j;
+ behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY);
+ behaviorBy = GetBehaviorByMetatileId(0x200 + decoration->tiles[(mapY - 1 - i) * mapX + j]) & 0xf000;
+ if (!sub_81284F4(behaviorAt, decoration))
+ {
+ return FALSE;
+ }
+ if (!sub_81284AC(taskId, curX, curY, behaviorBy))
+ {
+ return FALSE;
+ }
+ behaviorAt = GetFieldObjectIdByXYZ(curX, curY, 0);
+ if (behaviorAt != 0 && behaviorAt != 16)
+ {
+ return FALSE;
+ }
+ }
+ }
+ break;
+ case DECORPERM_BEHIND_FLOOR:
+ for (i=0; i<mapY-1; i++)
+ {
+ curY = gTasks[taskId].data[1] - i;
+ for (j=0; j<mapX; j++)
+ {
+ curX = gTasks[taskId].data[0] + j;
+ behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY);
+ behaviorBy = GetBehaviorByMetatileId(0x200 + decoration->tiles[(mapY - 1 - i) * mapX + j]) & 0xf000;
+ if (!MetatileBehavior_IsNormal(behaviorAt) && !sub_8128484(behaviorAt, behaviorBy))
+ {
+ return FALSE;
+ }
+ if (!sub_81284AC(taskId, curX, curY, behaviorBy))
+ {
+ return FALSE;
+ }
+ if (GetFieldObjectIdByXYZ(curX, curY, 0) != 16)
+ {
+ return FALSE;
+ }
+ }
+ }
+ curY = gTasks[taskId].data[1] - mapY + 1;
+ for (j=0; j<mapX; j++)
+ {
+ curX = gTasks[taskId].data[0] + j;
+ behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY);
+ behaviorBy = GetBehaviorByMetatileId(0x200 + decoration->tiles[j]) & 0xf000;
+ if (!MetatileBehavior_IsNormal(behaviorAt) && !MetatileBehavior_IsMB_B7(behaviorAt))
+ {
+ return FALSE;
+ }
+ if (!sub_81284AC(taskId, curX, curY, behaviorBy))
+ {
+ return FALSE;
+ }
+ behaviorAt = GetFieldObjectIdByXYZ(curX, curY, 0);
+ if (behaviorAt != 0 && behaviorAt != 16)
+ {
+ return FALSE;
+ }
+ }
+ break;
+ case DECORPERM_NA_WALL:
+ for (i=0; i<mapY; i++)
+ {
+ curY = gTasks[taskId].data[1] - i;
+ for (j=0; j<mapX; j++)
+ {
+ curX = gTasks[taskId].data[0] + j;
+ if (!MetatileBehavior_IsMB_B7(MapGridGetMetatileBehaviorAt(curX, curY)))
+ {
+ return FALSE;
+ }
+ if (MapGridGetMetatileIdAt(curX, curY + 1) == 0x28c)
+ {
+ return FALSE;
+ }
+ }
+ }
+ break;
+ case DECORPERM_SOLID_MAT:
+ curY = gTasks[taskId].data[1];
+ for (j=0; j<mapX; j++)
+ {
+ curX = gTasks[taskId].data[0] + j;
+ behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY);
+ if (decoration->shape == DECORSHAPE_1x2)
+ {
+ if (!MetatileBehavior_IsMB_C3(behaviorAt))
+ {
+ return FALSE;
+ }
+ }
+ else if (!MetatileBehavior_IsMB_B5(behaviorAt))
+ {
+ if (!MetatileBehavior_IsMB_C3(behaviorAt))
+ {
+ return FALSE;
+ }
+ }
+ if (GetFieldObjectIdByXYZ(curX, curY, 0) != 16)
+ {
+ return FALSE;
+ }
+ }
+ break;
+ }
+ return TRUE;
+}
+
+void sub_8128950(u8 taskId)
+{
+ if (sub_812853C(taskId, &gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]]) == TRUE)
+ {
+ StringExpandPlaceholders(gStringVar4, gText_PlaceItHere);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_81289D0);
+ }
+ else
+ {
+ PlaySE(SE_HAZURE);
+ StringExpandPlaceholders(gStringVar4, gText_CantBePlacedHere);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8129020);
+ }
+}
+
+void sub_81289D0(u8 taskId)
+{
+ sub_8197930();
+ sub_8121F68(taskId, &gUnknown_085A72C4);
+}
+
+void sub_81289F0(u8 taskId)
+{
+ sub_8197434(0, 0);
+ sub_8128AAC(taskId);
+ if (gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].permission != DECORPERM_SOLID_MAT)
+ {
+ sub_8127D38(gTasks[taskId].data[0], gTasks[taskId].data[1], gCurDecorInventoryItems[gCurDecorationIndex]);
+ }
+ else
+ {
+ sCurDecorMapX = gTasks[taskId].data[0] - 7;
+ sCurDecorMapY = gTasks[taskId].data[1] - 7;
+ ScriptContext1_SetupScript(gUnknown_08275D1F);
+ }
+ gSprites[sDecor_CameraSpriteObjectIdx1].pos1.y += 2;
+ if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE)
+ {
+ TV_PutSecretBaseVisitOnTheAir();
+ }
+ sub_8128BBC(taskId);
+}
+
+void sub_8128AAC(u8 taskId)
+{
+ u16 i;
+
+ for (i = 0; i < gUnknown_0203A17C.size; i ++)
+ {
+ if (gUnknown_0203A17C.items[i] == DECOR_NONE)
+ {
+ gUnknown_0203A17C.items[i] = gCurDecorInventoryItems[gCurDecorationIndex];
+ gUnknown_0203A17C.pos[i] = ((gTasks[taskId].data[0] - 7) << 4) + (gTasks[taskId].data[1] - 7);
+ break;
+ }
+ }
+ if (!gUnknown_0203A17C.isPlayerRoom)
+ {
+ for (i = 0; i < 16; i ++)
+ {
+ if (sSecretBaseItemsIndicesBuffer[i] == 0)
+ {
+ sSecretBaseItemsIndicesBuffer[i] = gCurDecorationIndex + 1;
+ break;
+ }
+ }
+ }
+ else
+ {
+ for (i = 0; i < 12; i ++)
+ {
+ if (sPlayerRoomItemsIndicesBuffer[i] == 0)
+ {
+ sPlayerRoomItemsIndicesBuffer[i] = gCurDecorationIndex + 1;
+ break;
+ }
+ }
+ }
+}
+
+void sub_8128B80(u8 taskId)
+{
+ sub_8197930();
+ sub_8121F68(taskId, &gUnknown_085A72CC);
+}
+
+void sub_8128BA0(u8 taskId)
+{
+ sub_8197434(0, 0);
+ sub_8128BBC(taskId);
+}
+
+void sub_8128BBC(u8 taskId)
+{
+ fade_screen(1, 0);
+ gTasks[taskId].data[2] = 0;
+ gTasks[taskId].func = c1_overworld_prev_quest;
+}
+
+void c1_overworld_prev_quest(u8 taskId)
+{
+ switch (gTasks[taskId].data[2])
+ {
+ case 0:
+ ScriptContext2_Enable();
+ if (!gPaletteFade.active)
+ {
+ sub_8127B04(taskId);
+ gTasks[taskId].data[2] = 1;
+ }
+ break;
+ case 1:
+ sub_812A3C8();
+ FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG);
+ gFieldCallback = sub_8128CD4;
+ SetMainCallback2(c2_exit_to_overworld_2_switch);
+ DestroyTask(taskId);
+ break;
+ }
+}
+
+void sub_8128C64(u8 taskId)
+{
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ switch (data[2])
+ {
+ case 0:
+ sub_80E9578();
+ data[2] ++;
+ break;
+ case 1:
+ ScriptContext1_SetupScript(gUnknown_08275D0C);
+ data[2] ++;
+ break;
+ case 2:
+ ScriptContext2_Enable();
+ data[2] ++;
+ break;
+ case 3:
+ if (sub_80ABDFC() == TRUE)
+ {
+ gTasks[taskId].func = sub_812764C;
+ }
+ break;
+ }
+}
+
+void sub_8128CD4(void)
+{
+ u8 taskId;
+
+ ScriptContext2_Enable();
+ pal_fill_black();
+ taskId = CreateTask(sub_8128C64, 8);
+ sub_8127580(taskId);
+ gTasks[taskId].data[2] = 0;
+}
+
+bool8 sub_8128D10(u8 taskId)
+{
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ if (sDecorationLastDirectionMoved == DIR_SOUTH && data[1] - data[6] - 6 < 0)
+ {
+ data[1] ++;
+ return FALSE;
+ }
+ if (sDecorationLastDirectionMoved == DIR_NORTH && data[1] - 7 >= gMapHeader.mapData->height)
+ {
+ data[1] --;
+ return FALSE;
+ }
+ if (sDecorationLastDirectionMoved == DIR_WEST && data[0] - 7 < 0)
+ {
+ data[0] ++;
+ return FALSE;
+ }
+ if (sDecorationLastDirectionMoved == DIR_EAST && data[0] + data[5] - 8 >= gMapHeader.mapData->width)
+ {
+ data[0] --;
+ return FALSE;
+ }
+ return TRUE;
+}
+
+bool8 sub_8128DB4(void)
+{
+ u16 heldKeys;
+
+ heldKeys = gMain.heldKeys & 0x0F0;
+ if (heldKeys != DPAD_UP && heldKeys != DPAD_DOWN && heldKeys != DPAD_LEFT && heldKeys != DPAD_RIGHT)
+ {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+void sub_8128DE0(void)
+{
+ sDecorationLastDirectionMoved = 0;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0;
+}
+
+void sub_8128E18(u8 taskId)
+{
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ if (!gSprites[sDecor_CameraSpriteObjectIdx1].data4)
+ {
+ if (data[10] == 1)
+ {
+ gUnknown_085A72D4[data[12]].yesFunc(taskId);
+ return;
+ } else if (data[10] == 2)
+ {
+ gUnknown_085A72D4[data[12]].noFunc(taskId);
+ return;
+ }
+ if ((gMain.heldKeys & 0x0F0) == DPAD_UP)
+ {
+ sDecorationLastDirectionMoved = DIR_SOUTH;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data3 = -2;
+ data[1]--;
+ }
+ if ((gMain.heldKeys & 0x0F0) == DPAD_DOWN)
+ {
+ sDecorationLastDirectionMoved = DIR_NORTH;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 2;
+ data[1]++;
+ }
+ if ((gMain.heldKeys & 0x0F0) == DPAD_LEFT)
+ {
+ sDecorationLastDirectionMoved = DIR_WEST;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data2 = -2;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0;
+ data[0]--;
+ }
+ if ((gMain.heldKeys & 0x0F0) == DPAD_RIGHT)
+ {
+ sDecorationLastDirectionMoved = DIR_EAST;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 2;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0;
+ data[0]++;
+ }
+ if (!sub_8128DB4() || !sub_8128D10(taskId))
+ {
+ sub_8128DE0();
+ }
+ }
+ if (sDecorationLastDirectionMoved)
+ {
+ gSprites[sDecor_CameraSpriteObjectIdx1].data4++;
+ gSprites[sDecor_CameraSpriteObjectIdx1].data4 &= 7;
+ }
+ if (!data[10])
+ {
+ if (gMain.newKeys & A_BUTTON)
+ {
+ data[10] = A_BUTTON;
+ }
+ if (gMain.newKeys & B_BUTTON)
+ {
+ data[10] = B_BUTTON;
+ }
+ }
+}
+
+void sub_8128FD8(u8 taskId)
+{
+ sub_8197434(0, 1);
+ gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 0;
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].func = sub_8128E18;
+}
+
+void sub_8129020(u8 taskId)
+{
+ if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON)
+ {
+ sub_8128FD8(taskId);
+ }
+}
+
+void sub_8129048(struct PlaceDecorationGraphicsDataBuffer *data)
+{
+ CpuFill16(0, data, sizeof(*data));
+}
+
+void sub_8129068(u16 *dest, u16 pal)
+{
+ CpuFastCopy(&((u16 *)gTilesetPointer_SecretBase->palettes)[pal << 4], dest, 32);
+}
+
+void sub_8129088(u8 *dest, u16 tile)
+{
+ u8 buffer[32];
+ u16 mode;
+ u16 i;
+
+ mode = tile >> 10;
+ if (tile != 0)
+ {
+ tile &= 0x03FF;
+ }
+ CpuFastCopy(&((u8 *)gTilesetPointer_SecretBase->tiles)[tile << 5], buffer, 32);
+ switch (mode)
+ {
+ case 0:
+ CpuFastCopy(buffer, dest, 32);
+ break;
+ case 1:
+ for (i = 0; i < 8; i ++)
+ {
+ dest[4 * i] = (buffer[4 * (i + 1) - 1] >> 4) + ((buffer[4 * (i + 1) - 1] & 0x0F) << 4);
+ dest[4 * i + 1] = (buffer[4 * (i + 1) - 2] >> 4) + ((buffer[4 * (i + 1) - 2] & 0x0F) << 4);
+ dest[4 * i + 2] = (buffer[4 * (i + 1) - 3] >> 4) + ((buffer[4 * (i + 1) - 3] & 0x0F) << 4);
+ dest[4 * i + 3] = (buffer[4 * (i + 1) - 4] >> 4) + ((buffer[4 * (i + 1) - 4] & 0x0F) << 4);
+ }
+ break;
+ case 2:
+ for (i = 0; i < 8; i ++)
+ {
+ dest[4 * i] = buffer[4 * (7 - i)];
+ dest[4 * i + 1] = buffer[4 * (7 - i) + 1];
+ dest[4 * i + 2] = buffer[4 * (7 - i) + 2];
+ dest[4 * i + 3] = buffer[4 * (7 - i) + 3];
+ }
+ break;
+ case 3:
+ for (i = 0; i < 32; i ++)
+ {
+ dest[i] = (buffer[31 - i] >> 4) + ((buffer[31 - i] & 0x0F) << 4);
+ }
+ break;
+ }
+}
+
+void sub_81291A4(struct PlaceDecorationGraphicsDataBuffer *data)
+{
+ u16 i;
+ for (i = 0; i < 64; i ++)
+ {
+ sub_8129088(&data->image[i * 32], data->tiles[i]);
+ }
+}
+
+u16 sub_81291CC(u16 tile)
+{
+ return ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[tile] & 0xFFF;
+}
+
+void sub_81291E8(struct PlaceDecorationGraphicsDataBuffer *data)
+{
+ u8 i;
+ u8 shape;
+
+ shape = data->decoration->shape;
+ for (i = 0; i < gUnknown_085A71B0[shape].size; i ++)
+ {
+ data->tiles[gUnknown_085A71B0[shape].tiles[i]] = sub_81291CC(data->decoration->tiles[gUnknown_085A71B0[shape].y[i]] * 8 + gUnknown_085A71B0[shape].x[i]);
+ }
+}
+
+void SetDecorSelectionBoxOamAttributes(u8 decorShape)
+{
+ sDecorSelectorOam.y = 0;
+ sDecorSelectorOam.affineMode = ST_OAM_AFFINE_OFF;
+ sDecorSelectorOam.objMode = ST_OAM_OBJ_NORMAL;
+ sDecorSelectorOam.mosaic = 0;
+ sDecorSelectorOam.bpp = ST_OAM_4BPP;
+ sDecorSelectorOam.shape = gUnknown_085A7250[decorShape].shape;
+ sDecorSelectorOam.x = 0;
+ sDecorSelectorOam.matrixNum = 0;
+ sDecorSelectorOam.size = gUnknown_085A7250[decorShape].size;
+ sDecorSelectorOam.tileNum = 0;
+ sDecorSelectorOam.priority = 0;
+ sDecorSelectorOam.paletteNum = 0;
+}
+
+void sub_81292D0(struct Sprite *sprite)
+{
+ sprite->data2 = 0;
+ sprite->data3 = 0;
+ sprite->data4 = 0;
+ sprite->data5 = 0;
+ sprite->data6 = 0;
+ sprite->data7 = 0;
+ sprite->callback = sub_81292E8;
+}
+
+void sub_81292E8(struct Sprite *sprite)
+{
+ if (sprite->data7 == 0)
+ {
+ if (sprite->data6 < 15)
+ {
+ sprite->invisible = FALSE;
+ }
+ else
+ {
+ sprite->invisible = TRUE;
+ }
+ sprite->data6 ++;
+ sprite->data6 &= 0x1F;
+ }
+ else
+ {
+ sprite->invisible = FALSE;
+ }
+}
+
+u8 gpu_pal_decompress_alloc_tag_and_upload(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor)
+{
+ sub_8129048(data);
+ data->decoration = &gDecorations[decor];
+ if (data->decoration->permission == DECORPERM_SOLID_MAT)
+ {
+ return AddPseudoFieldObject(data->decoration->tiles[0], SpriteCallbackDummy, 0, 0, 1);
+ }
+ FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG);
+ sub_81291E8(data);
+ SetDecorSelectionBoxOamAttributes(data->decoration->shape);
+ sub_81291A4(data);
+ sub_8129068(data->palette, ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[(data->decoration->tiles[0] * 8) + 7] >> 12);
+ LoadSpritePalette(&gUnknown_085A72BC);
+ return CreateSprite(&sDecorSelectorSpriteTemplate, 0, 0, 0);
+}
+
+u8 AddDecorationIconObjectFromIconTable(u16 tilesTag, u16 paletteTag, u8 decor)
+{
+ struct SpriteSheet sheet;
+ struct CompressedSpritePalette palette;
+ struct SpriteTemplate *template;
+ u8 spriteId;
+
+ if (!AllocItemIconTemporaryBuffers())
+ {
+ return MAX_SPRITES;
+ }
+ LZDecompressWram(GetDecorationIconPicOrPalette(decor, 0), gUnknown_0203CEBC);
+ CopyItemIconPicTo4x4Buffer(gUnknown_0203CEBC, gUnknown_0203CEC0);
+ sheet.data = gUnknown_0203CEC0;
+ sheet.size = 0x200;
+ sheet.tag = tilesTag;
+ LoadSpriteSheet(&sheet);
+ palette.data = GetDecorationIconPicOrPalette(decor, 1);
+ palette.tag = paletteTag;
+ LoadCompressedObjectPalette(&palette);
+ template = malloc(sizeof(struct SpriteTemplate));
+ *template = gUnknown_08614FF4;
+ template->tileTag = tilesTag;
+ template->paletteTag = paletteTag;
+ spriteId = CreateSprite(template, 0, 0, 0);
+ FreeItemIconTemporaryBuffers();
+ free(template);
+ return spriteId;
+}
+
+const u8 *GetDecorationIconPicOrPalette(u16 decor, u8 mode)
+{
+ if (decor > 120)
+ {
+ decor = DECOR_NONE;
+ }
+ return gUnknown_085A6BE8[decor][mode];
+}
+
+u8 AddDecorationIconObjectFromFieldObject(u16 tilesTag, u16 paletteTag, u8 decor)
+{
+ u8 spriteId;
+ struct SpriteSheet sheet;
+ struct SpritePalette palette;
+ struct SpriteTemplate *template;
+
+ sub_8129048(&sPlaceDecorationGraphicsDataBuffer);
+ sPlaceDecorationGraphicsDataBuffer.decoration = &gDecorations[decor];
+ if (sPlaceDecorationGraphicsDataBuffer.decoration->permission != DECORPERM_SOLID_MAT)
+ {
+ sub_81291E8(&sPlaceDecorationGraphicsDataBuffer);
+ SetDecorSelectionBoxOamAttributes(sPlaceDecorationGraphicsDataBuffer.decoration->shape);
+ sub_81291A4(&sPlaceDecorationGraphicsDataBuffer);
+ sub_8129068(sPlaceDecorationGraphicsDataBuffer.palette, ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[(sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0] * 8) + 7] >> 12);
+ sheet.data = sPlaceDecorationGraphicsDataBuffer.image;
+ sheet.size = gUnknown_085A72F4[sPlaceDecorationGraphicsDataBuffer.decoration->shape] << 5;
+ sheet.tag = tilesTag;
+ LoadSpriteSheet(&sheet);
+ palette.data = sPlaceDecorationGraphicsDataBuffer.palette;
+ palette.tag = paletteTag;
+ LoadSpritePalette(&palette);
+ template = Alloc(sizeof(struct SpriteTemplate));
+ *template = sDecorWhilePlacingSpriteTemplate;
+ template->tileTag = tilesTag;
+ template->paletteTag = paletteTag;
+ spriteId = CreateSprite(template, 0, 0, 0);
+ free(template);
+ }
+ else
+ {
+ spriteId = AddPseudoFieldObject(sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0], SpriteCallbackDummy, 0, 0, 1);
+ }
+ return spriteId;
+}
+
+u8 AddDecorationIconObject(u8 decor, s16 x, s16 y, u8 priority, u16 tilesTag, u16 paletteTag)
+{
+ u8 spriteId;
+
+ if (decor > 120)
+ {
+ spriteId = AddDecorationIconObjectFromIconTable(tilesTag, paletteTag, DECOR_NONE);
+ if (spriteId == MAX_SPRITES)
+ {
+ return MAX_SPRITES;
+ }
+ gSprites[spriteId].pos2.x = x + 4;
+ gSprites[spriteId].pos2.y = y + 4;
+ }
+ else if (gUnknown_085A6BE8[decor][0] == NULL)
+ {
+ spriteId = AddDecorationIconObjectFromFieldObject(tilesTag, paletteTag, decor);
+ if (spriteId == MAX_SPRITES)
+ {
+ return MAX_SPRITES;
+ }
+ gSprites[spriteId].pos2.x = x;
+ if (decor == DECOR_SILVER_SHIELD || decor == DECOR_GOLD_SHIELD)
+ {
+ gSprites[spriteId].pos2.y = y - 4;
+ }
+ else
+ {
+ gSprites[spriteId].pos2.y = y;
+ }
+ }
+ else
+ {
+ spriteId = AddDecorationIconObjectFromIconTable(tilesTag, paletteTag, decor);
+ if (spriteId == MAX_SPRITES)
+ {
+ return MAX_SPRITES;
+ }
+ gSprites[spriteId].pos2.x = x + 4;
+ gSprites[spriteId].pos2.y = y + 4;
+ }
+ gSprites[spriteId].oam.priority = priority;
+ return spriteId;
+}
+
+void sub_81296EC(u8 idx)
+{
+ gUnknown_0203A17C.items[idx] = 0;
+ gUnknown_0203A17C.pos[idx] = 0;
+}
+
+void sub_8129708(void)
+{
+ u16 i;
+
+ gSpecialVar_0x8005 = 0;
+ gScriptResult = 0;
+ if (gSpecialVar_0x8004 == sCurDecorSelectedInRearrangement)
+ {
+ gScriptResult = 1;
+ }
+ else if (gDecorations[gUnknown_0203A17C.items[sDecorRearrangementDataBuffer[gSpecialVar_0x8004].idx]].permission == DECORPERM_SOLID_MAT)
+ {
+ gSpecialVar_0x8005 = sDecorRearrangementDataBuffer[gSpecialVar_0x8004].flagId;
+ sub_81296EC(sDecorRearrangementDataBuffer[gSpecialVar_0x8004].idx);
+ for (i = 0; i < gMapHeader.events->mapObjectCount; i ++)
+ {
+ if (gMapHeader.events->mapObjects[i].flagId == gSpecialVar_0x8005)
+ {
+ gSpecialVar_0x8006 = gMapHeader.events->mapObjects[i].localId;
+ break;
+ }
+ }
+ }
+}
+
+void sub_81297AC(void)
+{
+ u8 i;
+
+ for (i = 0; i < gMapHeader.events->mapObjectCount; i ++)
+ {
+ if (gMapHeader.events->mapObjects[i].flagId == gSpecialVar_0x8004)
+ {
+ gSpecialVar_0x8005 = gMapHeader.events->mapObjects[i].localId;
+ break;
+ }
+ }
+}
+
+void sub_81297F8(void)
+{
+ u8 i;
+ u8 y;
+ u8 x;
+ int posX;
+ int posY;
+ u8 perm;
+
+ for (i = 0; i < sCurDecorSelectedInRearrangement; i ++)
+ {
+ perm = gDecorations[gUnknown_0203A17C.items[sDecorRearrangementDataBuffer[i].idx]].permission;
+ posX = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[i].idx] >> 4;
+ posY = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[i].idx] & 0x0F;
+ if (perm != DECORPERM_SOLID_MAT)
+ {
+ for (y = 0; y < sDecorRearrangementDataBuffer[i].height; y ++)
+ {
+ for (x = 0; x < sDecorRearrangementDataBuffer[i].width; x ++)
+ {
+ MapGridSetMetatileEntryAt(posX + 7 + x, posY + 7 - y, gMapHeader.mapData->map[posX + x + gMapHeader.mapData->width * (posY - y)] | 0x3000);
+ }
+ }
+ sub_81296EC(sDecorRearrangementDataBuffer[i].idx);
+ }
+ }
+}
+
+void sub_81298EC(u8 taskId)
+{
+ switch (gTasks[taskId].data[2])
+ {
+ case 0:
+ sub_81297F8();
+ gTasks[taskId].data[2] = 1;
+ break;
+ case 1:
+ if (!gPaletteFade.active) {
+ DrawWholeMapView();
+ ScriptContext1_SetupScript(gUnknown_08275D2E);
+ sub_8197434(0, 1);
+ gTasks[taskId].data[2] = 2;
+ }
+ break;
+ case 2:
+ ScriptContext2_Enable();
+ IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId);
+ pal_fill_black();
+ gTasks[taskId].data[2] = 3;
+ break;
+ case 3:
+ if (sub_80ABDFC() == TRUE)
+ {
+ StringExpandPlaceholders(gStringVar4, gText_DecorationReturnedToPC);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64);
+ if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE)
+ {
+ TV_PutSecretBaseVisitOnTheAir();
+ }
+ }
+ break;
+ }
+}
+
+
+bool8 sub_81299AC(u8 taskId)
+{
+ u16 i;
+
+ for (i = 0; i < gUnknown_0203A17C.size; i ++)
+ {
+ if (gUnknown_0203A17C.items[i] != DECOR_NONE)
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+void SetUpPuttingAwayDecorationPlayerAvatar(void)
+{
+ player_get_direction_lower_nybble();
+ sDecor_CameraSpriteObjectIdx1 = gSprites[gUnknown_03005DD0.unk4].data0;
+ sub_812A39C();
+ gUnknown_03005DD0.unk4 = CreateSprite(&gUnknown_085A7404, 0x78, 0x50, 0);
+ if (gSaveBlock2Ptr->playerGender == MALE)
+ {
+ sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC1, SpriteCallbackDummy, 0x88, 0x48, 0);
+ }
+ else
+ {
+ sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC2, SpriteCallbackDummy, 0x88, 0x48, 0);
+ }
+ gSprites[sDecor_CameraSpriteObjectIdx2].oam.priority = 1;
+ DestroySprite(&gSprites[sDecor_CameraSpriteObjectIdx1]);
+ sDecor_CameraSpriteObjectIdx1 = gUnknown_03005DD0.unk4;
+ gSprites[sDecor_CameraSpriteObjectIdx1].oam.priority = 1;
+}
+
+void sub_8129ABC(u8 taskId)
+{
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ switch (data[2])
+ {
+ case 0:
+ if (!gPaletteFade.active)
+ {
+ sub_8127ACC(taskId);
+ data[2] = 1;
+ data[6] = 1;
+ data[5] = 1;
+ }
+ break;
+ case 1:
+ SetUpPuttingAwayDecorationPlayerAvatar();
+ pal_fill_black();
+ data[2] = 2;
+ break;
+ case 2:
+ if (sub_80ABDFC() == TRUE)
+ {
+ data[12] = 1;
+ sub_8129B34(taskId);
+ }
+ break;
+ }
+}
+
+void sub_8129B34(u8 taskId)
+{
+ sub_8197434(0, 1);
+ gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 0;
+ gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE;
+ gSprites[sDecor_CameraSpriteObjectIdx1].callback = sub_812A36C;
+ gSprites[sDecor_CameraSpriteObjectIdx2].pos1.x = 0x88;
+ gSprites[sDecor_CameraSpriteObjectIdx2].pos1.y = 0x48;
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].func = sub_8128E18;
+}
+
+void sub_8129BCC(u8 taskId)
+{
+ gTasks[taskId].data[10] = 0;
+ sub_8128DE0();
+ sub_8129C74(taskId);
+}
+
+void sub_8129BF8(u8 taskId)
+{
+ gTasks[taskId].data[10] = 0;
+ sub_8128DE0();
+ gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE;
+ gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy;
+ StringExpandPlaceholders(gStringVar4, gText_StopPuttingAwayDecorations);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1F0);
+}
+
+void sub_8129C74(u8 taskId)
+{
+ s16 *data;
+ u8 behavior;
+
+ sub_812A0E8(taskId);
+ if (sCurDecorSelectedInRearrangement != 0)
+ {
+ StringExpandPlaceholders(gStringVar4, gText_ReturnDecorationToPC);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1A0);
+ }
+ else
+ {
+ data = gTasks[taskId].data;
+ behavior = MapGridGetMetatileBehaviorAt(data[0], data[1]);
+ if (MetatileBehavior_IsSecretBasePC(behavior) == TRUE || MetatileBehavior_IsMB_C5(behavior) == TRUE)
+ {
+ gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE;
+ gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy;
+ StringExpandPlaceholders(gStringVar4, gText_StopPuttingAwayDecorations);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1F0);
+ }
+ else
+ {
+ StringExpandPlaceholders(gStringVar4, gText_NoDecorationHere);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64);
+ }
+ }
+}
+
+void sub_8129D64(u8 taskId)
+{
+ if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON)
+ {
+ sub_8129B34(taskId);
+ }
+}
+
+void sub_8129D8C(u8 decor, struct DecorRearrangementDataBuffer *data)
+{
+ if (gDecorations[decor].shape == DECORSHAPE_1x1)
+ {
+ data->width = 1;
+ data->height = 1;
+ } else if (gDecorations[decor].shape == DECORSHAPE_2x1)
+ {
+ data->width = 2;
+ data->height = 1;
+ } else if (gDecorations[decor].shape == DECORSHAPE_3x1)
+ {
+ data->width = 3;
+ data->height = 1;
+ } else if (gDecorations[decor].shape == DECORSHAPE_4x2)
+ {
+ data->width = 4;
+ data->height = 2;
+ } else if (gDecorations[decor].shape == DECORSHAPE_2x2)
+ {
+ data->width = 2;
+ data->height = 2;
+ } else if (gDecorations[decor].shape == DECORSHAPE_1x2)
+ {
+ data->width = 1;
+ data->height = 2;
+ } else if (gDecorations[decor].shape == DECORSHAPE_1x3)
+ {
+ data->width = 1;
+ data->height = 3;
+ } else if (gDecorations[decor].shape == DECORSHAPE_2x4)
+ {
+ data->width = 2;
+ data->height = 4;
+ } else if (gDecorations[decor].shape == DECORSHAPE_3x3)
+ {
+ data->width = 3;
+ data->height = 3;
+ } else if (gDecorations[decor].shape == DECORSHAPE_3x2)
+ {
+ data->width = 3;
+ data->height = 2;
+ }
+}
+
+void sub_8129E0C(u8 x, u8 y)
+{
+ gSprites[sDecor_CameraSpriteObjectIdx1].invisible = TRUE;
+ gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy;
+ gSprites[sDecor_CameraSpriteObjectIdx2].pos1.x = (x << 4) + 0x88;
+ gSprites[sDecor_CameraSpriteObjectIdx2].pos1.y = (y << 4) + 0x48;
+}
+
+bool8 sub_8129E74(u8 taskId, u8 idx, struct DecorRearrangementDataBuffer *data)
+{
+ u8 x;
+ u8 y;
+ u8 xOff;
+ u8 yOff;
+ u8 ht;
+
+ x = gTasks[taskId].data[0] - 7;
+ y = gTasks[taskId].data[1] - 7;
+ xOff = gUnknown_0203A17C.pos[idx] >> 4;
+ yOff = gUnknown_0203A17C.pos[idx] & 0x0F;
+ ht = data->height;
+ if (gUnknown_0203A17C.items[idx] == DECOR_SAND_ORNAMENT && MapGridGetMetatileIdAt(xOff + 7, yOff + 7) == 0x28C)
+ {
+ ht --;
+ }
+ if (x >= xOff && x < xOff + data->width && y > yOff - ht && y <= yOff)
+ {
+ sub_8129E0C(data->width - (x - xOff + 1), yOff - y);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+void sub_8129F20(void)
+{
+ u8 xOff;
+ u8 yOff;
+ u16 i;
+
+ xOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx] >> 4;
+ yOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx] & 0x0F;
+ for (i = 0; i < 0x40; i ++)
+ {
+ if (gSaveBlock1Ptr->mapObjectTemplates[i].x == xOff && gSaveBlock1Ptr->mapObjectTemplates[i].y == yOff && !FlagGet(gSaveBlock1Ptr->mapObjectTemplates[i].flagId))
+ {
+ sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].flagId = gSaveBlock1Ptr->mapObjectTemplates[i].flagId;
+ break;
+ }
+ }
+}
+
+bool8 sub_8129FC8(u8 taskId)
+{
+ u16 i;
+
+ for (i = 0; i < gUnknown_0203A17C.size; i ++)
+ {
+ if (gUnknown_0203A17C.items[i] != 0)
+ {
+ if (gDecorations[gUnknown_0203A17C.items[i]].permission == DECORPERM_SOLID_MAT)
+ {
+ sub_8129D8C(gUnknown_0203A17C.items[i], sDecorRearrangementDataBuffer);
+ if (sub_8129E74(taskId, i, sDecorRearrangementDataBuffer) == TRUE)
+ {
+ sDecorRearrangementDataBuffer->idx = i;
+ sub_8129F20();
+ sCurDecorSelectedInRearrangement = 1;
+ return TRUE;
+ }
+ }
+ }
+ }
+ return FALSE;
+}
+
+void sub_812A040(u8 left, u8 top, u8 right, u8 bottom)
+{
+ u8 i;
+ u8 xOff;
+ u8 yOff;
+ u8 decorIdx;
+
+ for (i = 0; i < gUnknown_0203A17C.size; i ++)
+ {
+ decorIdx = gUnknown_0203A17C.items[i];
+ xOff = gUnknown_0203A17C.pos[i] >> 4;
+ yOff = gUnknown_0203A17C.pos[i] & 0x0F;
+ if (decorIdx != 0 && gDecorations[decorIdx].permission == DECORPERM_SOLID_MAT && left <= xOff && top <= yOff && right >= xOff && bottom >= yOff)
+ {
+ sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx = i;
+ sub_8129F20();
+ sCurDecorSelectedInRearrangement++;
+ }
+ }
+}
+
+#ifdef NONMATCHING
+void sub_812A0E8(u8 taskId)
+{
+ u8 i;
+ u8 xOff;
+ u8 yOff;
+ u8 decor;
+ register u8 decor asm("r1");
+ struct DecorRearrangementDataBuffer *data;
+
+ sCurDecorSelectedInRearrangement = 0;
+ if (sub_8129FC8(taskId) != TRUE)
+ {
+ for (i = 0; i < gUnknown_0203A17C.size; i ++)
+ {
+ decor = gUnknown_0203A17C.items[i];
+ if (decor != DECOR_NONE)
+ {
+ data = &sDecorRearrangementDataBuffer[0];
+ sub_8129D8C(decor, data);
+ if (sub_8129E74(taskId, i, data) == TRUE)
+ {
+ data->idx = i;
+ sCurDecorSelectedInRearrangement ++;
+ break;
+ }
+ }
+ }
+ if (sCurDecorSelectedInRearrangement != 0)
+ {
+ xOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[0].idx] >> 4;
+ yOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[0].idx] & 0x0F;
+ sub_812A040(xOff, yOff - sDecorRearrangementDataBuffer[0].height + 1, xOff + sDecorRearrangementDataBuffer[0].width - 1, yOff); // Arithmetic register swap at the r2 argument: `add r2, r0, r2` instead of `add r2, r2, r0`
+ }
+ }
+}
+#else
+__attribute__((naked)) void sub_812A0E8(u8 taskId)
+{
+ asm_unified("\tpush {r4-r7,lr}\n"
+ "\tlsls r0, 24\n"
+ "\tlsrs r6, r0, 24\n"
+ "\tldr r4, =sCurDecorSelectedInRearrangement\n"
+ "\tmovs r0, 0\n"
+ "\tstrb r0, [r4]\n"
+ "\tadds r0, r6, 0\n"
+ "\tbl sub_8129FC8\n"
+ "\tlsls r0, 24\n"
+ "\tlsrs r0, 24\n"
+ "\tcmp r0, 0x1\n"
+ "\tbeq _0812A18C\n"
+ "\tmovs r5, 0\n"
+ "\tldr r0, =gUnknown_0203A17C\n"
+ "\tldrb r1, [r0, 0x8]\n"
+ "\tcmp r5, r1\n"
+ "\tbcs _0812A15A\n"
+ "\tadds r7, r4, 0\n"
+ "_0812A10E:\n"
+ "\tldr r0, [r0]\n"
+ "\tadds r0, r5\n"
+ "\tldrb r1, [r0]\n"
+ "\tcmp r1, 0\n"
+ "\tbeq _0812A14C\n"
+ "\tldr r4, =sDecorRearrangementDataBuffer\n"
+ "\tadds r0, r1, 0\n"
+ "\tadds r1, r4, 0\n"
+ "\tbl sub_8129D8C\n"
+ "\tadds r0, r6, 0\n"
+ "\tadds r1, r5, 0\n"
+ "\tadds r2, r4, 0\n"
+ "\tbl sub_8129E74\n"
+ "\tlsls r0, 24\n"
+ "\tlsrs r0, 24\n"
+ "\tcmp r0, 0x1\n"
+ "\tbne _0812A14C\n"
+ "\tstrb r5, [r4]\n"
+ "\tldrb r0, [r7]\n"
+ "\tadds r0, 0x1\n"
+ "\tstrb r0, [r7]\n"
+ "\tb _0812A15A\n"
+ "\t.pool\n"
+ "_0812A14C:\n"
+ "\tadds r0, r5, 0x1\n"
+ "\tlsls r0, 24\n"
+ "\tlsrs r5, r0, 24\n"
+ "\tldr r0, =gUnknown_0203A17C\n"
+ "\tldrb r1, [r0, 0x8]\n"
+ "\tcmp r5, r1\n"
+ "\tbcc _0812A10E\n"
+ "_0812A15A:\n"
+ "\tldr r0, =sCurDecorSelectedInRearrangement\n"
+ "\tldrb r0, [r0]\n"
+ "\tcmp r0, 0\n"
+ "\tbeq _0812A18C\n"
+ "\tldr r0, =gUnknown_0203A17C\n"
+ "\tldr r2, =sDecorRearrangementDataBuffer\n"
+ "\tldrb r1, [r2]\n"
+ "\tldr r0, [r0, 0x4]\n"
+ "\tadds r0, r1\n"
+ "\tldrb r1, [r0]\n"
+ "\tlsrs r0, r1, 4\n"
+ "\tmovs r3, 0xF\n"
+ "\tands r3, r1\n"
+ "\tldrb r1, [r2, 0x2]\n"
+ "\tsubs r1, r3, r1\n"
+ "\tadds r1, 0x1\n"
+ "\tlsls r1, 24\n"
+ "\tlsrs r1, 24\n"
+ "\tldrb r2, [r2, 0x1]\n"
+ "\tadds r2, r0\n"
+ "\tsubs r2, 0x1\n"
+ "\tlsls r2, 24\n"
+ "\tlsrs r2, 24\n"
+ "\tbl sub_812A040\n"
+ "_0812A18C:\n"
+ "\tpop {r4-r7}\n"
+ "\tpop {r0}\n"
+ "\tbx r0\n"
+ "\t.pool");
+}
+#endif
+
+void sub_812A1A0(u8 taskId)
+{
+ sub_8197930();
+ sub_8121F68(taskId, &gUnknown_085A7348);
+}
+
+void sub_812A1C0(u8 taskId)
+{
+ fade_screen(1, 0);
+ gTasks[taskId].data[2] = 0;
+ gTasks[taskId].func = sub_81298EC;
+}
+
+void sub_812A1F0(u8 taskId)
+{
+ sub_8197930();
+ sub_8121F68(taskId, &gUnknown_085A7350);
+}
+
+void sub_812A210(u8 taskId)
+{
+ sub_8197434(0, 0);
+ sub_812A22C(taskId);
+}
+
+void sub_812A22C(u8 taskId)
+{
+ fade_screen(1, 0);
+ gTasks[taskId].data[2] = 0;
+ gTasks[taskId].func = sub_812A25C;
+}
+
+void sub_812A25C(u8 taskId)
+{
+ switch (gTasks[taskId].data[2])
+ {
+ case 0:
+ if (!gPaletteFade.active)
+ {
+ sub_8127B04(taskId);
+ gTasks[taskId].data[2] = 1;
+ }
+ break;
+ case 1:
+ sub_812A3C8();
+ gFieldCallback = sub_812A334;
+ SetMainCallback2(c2_exit_to_overworld_2_switch);
+ DestroyTask(taskId);
+ break;
+ }
+}
+
+void sub_812A2C4(u8 taskId)
+{
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ switch (data[2])
+ {
+ case 0:
+ sub_80E9578();
+ data[2] ++;
+ break;
+ case 1:
+ ScriptContext1_SetupScript(gUnknown_08275D0C);
+ data[2] ++;
+ break;
+ case 2:
+ ScriptContext2_Enable();
+ data[2] ++;
+ break;
+ case 3:
+ if (sub_80ABDFC() == TRUE)
+ {
+ gTasks[taskId].func = sub_8126B80;
+ }
+ break;
+ }
+}
+
+void sub_812A334(void)
+{
+ u8 taskId;
+
+ pal_fill_black();
+ sub_81973C4(0, 1);
+ sub_8126ABC();
+ taskId = CreateTask(sub_812A2C4, 8);
+ gTasks[taskId].data[2] = 0;
+}
+
+void sub_812A36C(struct Sprite *sprite)
+{
+ sprite->data0 ++;
+ sprite->data0 &= 0x1F;
+ if (sprite->data0 > 15)
+ {
+ sprite->invisible = TRUE;
+ }
+ else
+ {
+ sprite->invisible = FALSE;
+ }
+}
+
+void sub_812A39C(void)
+{
+ if (gSaveBlock2Ptr->playerGender == MALE)
+ {
+ LoadSpritePalette(&gUnknown_085A73D8);
+ }
+ else
+ {
+ LoadSpritePalette(&gUnknown_085A73E0);
+ }
+}
+
+void sub_812A3C8(void)
+{
+ FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG);
+}
+
+void sub_812A3D4(u8 taskId)
+{
+ if (IsSelectedDecorInThePC() == TRUE)
+ {
+ StringCopy(gStringVar1, gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].name);
+ StringExpandPlaceholders(gStringVar4, gText_DecorationWillBeDiscarded);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_812A458);
+ }
+ else
+ {
+ StringExpandPlaceholders(gStringVar4, gText_CantThrowAwayInUse);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+ }
+}
+
+void sub_812A458(u8 taskId)
+{
+ sub_8197930();
+ sub_8121F68(taskId, &gUnknown_085A741C);
+}
+
+void sub_812A478(u8 taskId)
+{
+ gCurDecorInventoryItems[gCurDecorationIndex] = DECOR_NONE;
+ sCurDecorCatCount = CountDecorationCategoryN(sCurDecorationCategory);
+ CondenseDecorationCategoryN(sCurDecorationCategory);
+ IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId);
+ StringExpandPlaceholders(gStringVar4, gText_DecorationThrownAway);
+ DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C);
+}
diff --git a/src/decoration_inventory.c b/src/decoration_inventory.c
new file mode 100644
index 000000000..03ab6c00c
--- /dev/null
+++ b/src/decoration_inventory.c
@@ -0,0 +1,189 @@
+
+// Includes
+#include "global.h"
+#include "decoration.h"
+#include "decoration_inventory.h"
+
+// Static type declarations
+
+// Static RAM declarations
+
+EWRAM_DATA struct DecorationInventory gDecorationInventories[8] = {};
+
+// Static ROM declarations
+
+// .rodata
+
+// .text
+
+#define SET_DECOR_INV(i, ptr) {\
+ gDecorationInventories[i].items = ptr;\
+ gDecorationInventories[i].size = sizeof(ptr);\
+}
+
+void SetDecorationInventoriesPointers(void)
+{
+ SET_DECOR_INV(0, gSaveBlock1Ptr->decorDesk);
+ SET_DECOR_INV(1, gSaveBlock1Ptr->decorChair);
+ SET_DECOR_INV(2, gSaveBlock1Ptr->decorPlant);
+ SET_DECOR_INV(3, gSaveBlock1Ptr->decorOrnament);
+ SET_DECOR_INV(4, gSaveBlock1Ptr->decorMat);
+ SET_DECOR_INV(5, gSaveBlock1Ptr->decorPoster);
+ SET_DECOR_INV(6, gSaveBlock1Ptr->decorDoll);
+ SET_DECOR_INV(7, gSaveBlock1Ptr->decorCushion);
+ sub_8126968();
+}
+
+static void ClearDecorationInventory(u8 idx)
+{
+ u8 i;
+
+ for (i = 0; i < gDecorationInventories[idx].size; i ++)
+ {
+ gDecorationInventories[idx].items[i] = DECOR_NONE;
+ }
+}
+
+void ClearDecorationInventories(void)
+{
+ u8 idx;
+
+ for (idx = 0; idx < 8; idx ++)
+ {
+ ClearDecorationInventory(idx);
+ }
+}
+
+s8 GetFirstEmptyDecorSlot(u8 idx)
+{
+ s8 i;
+
+ for (i = 0; i < (s8)gDecorationInventories[idx].size; i ++)
+ {
+ if (gDecorationInventories[idx].items[i] == DECOR_NONE)
+ {
+ return i;
+ }
+ }
+ return -1;
+}
+
+bool8 CheckHasDecoration(u8 decor)
+{
+ u8 i;
+ u8 category;
+
+ category = gDecorations[decor].category;
+ for (i = 0; i < gDecorationInventories[category].size; i ++)
+ {
+ if (gDecorationInventories[category].items[i] == decor)
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+bool8 DecorationAdd(u8 decor)
+{
+ u8 category;
+ s8 idx;
+
+ if (decor == DECOR_NONE)
+ {
+ return FALSE;
+ }
+ category = gDecorations[decor].category;
+ idx = GetFirstEmptyDecorSlot(category);
+ if (idx == -1)
+ {
+ return FALSE;
+ }
+ gDecorationInventories[category].items[idx] = decor;
+ return TRUE;
+}
+
+bool8 DecorationCheckSpace(u8 decor)
+{
+ if (decor == DECOR_NONE)
+ {
+ return FALSE;
+ }
+ if (GetFirstEmptyDecorSlot(gDecorations[decor].category) == -1)
+ {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+s8 DecorationRemove(u8 decor)
+{
+ u8 i;
+ u8 idx;
+
+ i = 0;
+ if (decor == DECOR_NONE)
+ {
+ return 0;
+ }
+ for (i = 0; i < gDecorationInventories[gDecorations[decor].category].size; i ++)
+ {
+ idx = gDecorations[decor].category;
+ if (gDecorationInventories[idx].items[i] == decor)
+ {
+ gDecorationInventories[idx].items[i] = DECOR_NONE;
+ CondenseDecorationCategoryN(idx);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+void CondenseDecorationCategoryN(u8 idx)
+{
+ u8 i;
+ u8 j;
+ u8 tmp;
+
+ for (i = 0; i < gDecorationInventories[idx].size; i ++)
+ {
+ for (j = i + 1; j < gDecorationInventories[idx].size; j ++)
+ {
+ if (gDecorationInventories[idx].items[j] != DECOR_NONE && (gDecorationInventories[idx].items[i] == DECOR_NONE || gDecorationInventories[idx].items[i] > gDecorationInventories[idx].items[j]))
+ {
+ tmp = gDecorationInventories[idx].items[i];
+ gDecorationInventories[idx].items[i] = gDecorationInventories[idx].items[j];
+ gDecorationInventories[idx].items[j] = tmp;
+ }
+ }
+ }
+}
+
+u8 CountDecorationCategoryN(u8 idx)
+{
+ u8 i;
+ u8 ct;
+
+ ct = 0;
+ for (i = 0; i < gDecorationInventories[idx].size; i ++)
+ {
+ if (gDecorationInventories[idx].items[i] != DECOR_NONE)
+ {
+ ct ++;
+ }
+ }
+ return ct;
+}
+
+u8 CountDecorations(void)
+{
+ u8 idx;
+ u8 ct;
+
+ ct = 0;
+ for (idx = 0; idx < 8; idx ++)
+ {
+ ct += CountDecorationCategoryN(idx);
+ }
+ return ct;
+}
diff --git a/src/egg_hatch.c b/src/egg_hatch.c
index a1f187b85..589e8901d 100644
--- a/src/egg_hatch.c
+++ b/src/egg_hatch.c
@@ -462,7 +462,7 @@ static void VBlankCB_EggHatch(void)
TransferPlttBuffer();
}
-static void EggHatch(void)
+void EggHatch(void)
{
ScriptContext2_Enable();
CreateTask(Task_EggHatch, 10);
diff --git a/src/international_string_util.c b/src/international_string_util.c
index c77b4f8ff..81985d614 100644
--- a/src/international_string_util.c
+++ b/src/international_string_util.c
@@ -28,13 +28,13 @@ s32 GetStringWidthDifference(s32 fontId, const u8 *str, s32 totalWidth, s32 lett
return 0;
}
-s32 GetMaxWidthInMenuTable(const u8 **str, s32 arg1)
+s32 GetMaxWidthInMenuTable(const struct MenuAction *str, s32 arg1)
{
s32 i, var;
for (var = 0, i = 0; i < arg1; i++)
{
- s32 stringWidth = GetStringWidth(1, str[i * 2], 0);
+ s32 stringWidth = GetStringWidth(1, str[i].text, 0);
if (stringWidth > var)
var = stringWidth;
}
@@ -42,13 +42,13 @@ s32 GetMaxWidthInMenuTable(const u8 **str, s32 arg1)
return convert_pixel_width_to_tile_width(var);
}
-s32 sub_81DB3D8(const u8 **str, u8* arg1, s32 arg2)
+s32 sub_81DB3D8(const struct MenuAction *str, u8* arg1, s32 arg2)
{
s32 i, var;
for (var = 0, i = 0; i < arg2; i++)
{
- s32 stringWidth = GetStringWidth(1, str[arg1[i] * 2], 0);
+ s32 stringWidth = GetStringWidth(1, str[arg1[i]].text, 0);
if (stringWidth > var)
var = stringWidth;
}
diff --git a/src/librfu_intr.c b/src/librfu_intr.c
new file mode 100644
index 000000000..bdf8b072a
--- /dev/null
+++ b/src/librfu_intr.c
@@ -0,0 +1,4 @@
+#include "global.h"
+#include "main.h"
+
+//TODO: decompile asm/librfu_intr.s to here
diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c
new file mode 100644
index 000000000..cf3fe12ad
--- /dev/null
+++ b/src/librfu_rfu.c
@@ -0,0 +1,109 @@
+#include "global.h"
+#include "main.h"
+
+#include "librfu.h"
+
+struct RfuUnk1
+{
+ u8 unk_0[0x14];
+ u32 unk_14;
+ u32 unk_18;
+ struct RfuIntrStruct unk_1c;
+};
+
+struct RfuUnk2
+{
+ u8 unk_0[0x68];
+ u32 unk_68;
+ u32 unk_6c;
+ u8 unk_70[0x70];
+};
+
+struct RfuUnk3
+{
+ u32 unk_0;
+ u32 unk_4;
+ u8 unk_8[0xD4];
+ u32 unk_dc;
+};
+
+extern u32 *gUnknown_03007890;
+extern u32 *gUnknown_03007894;
+extern struct RfuUnk3* gUnknown_03007898;
+extern struct RfuUnk2* gUnknown_03007880[4];
+extern struct RfuUnk1* gUnknown_03007870[4];
+extern void* sub_82E53F4;
+extern void rfu_STC_clearAPIVariables(void);
+
+// Nonmatching, only register differences
+/*u16 rfu_initializeAPI(u32 *unk0, u16 unk1, IntrFunc *interrupt, bool8 copyInterruptToRam)
+{
+ u16 i;
+ u16 *v13;
+ u16 *v12;
+ u16 num;
+
+ if (((u32)unk0 & 0xF000000) == 0x2000000 && copyInterruptToRam)
+ {
+ return 2;
+ }
+
+ if ((u32)unk0 & 3)
+ return 2;
+
+ // Nintendo pls, just use a ternary for once
+ if (copyInterruptToRam)
+ {
+ // An assert/debug print may have existed before, ie
+ // printf("%s %u < %u", "somefile.c:12345", unk1, num)
+ // to push this into r3?
+ num = 0xe64;
+ if (unk1 < num)
+ return 1;
+ }
+
+ if (copyInterruptToRam == FALSE)
+ {
+ num = 0x504; // same as above, this should be r3 not r0
+ if (unk1 < num)
+ return 1;
+ }
+ gUnknown_03007890 = unk0;
+ gUnknown_03007894 = unk0 + (0xB4 / sizeof(u32));
+ gUnknown_03007898 = (struct RfuUnk3*)(unk0 + (0xDC / sizeof(u32)));
+ gUnknown_03007880[0] = (struct RfuUnk2*)(unk0 + (0x1BC / sizeof(u32)));
+ gUnknown_03007870[0] = (struct RfuUnk1*)(unk0 + (0x37C / sizeof(u32)));
+
+ for (i = 1; i < 4; i++, num)
+ {
+ gUnknown_03007880[i] = (struct RfuUnk2*)&gUnknown_03007880[i-1]->unk_70;
+ gUnknown_03007870[i] = (struct RfuUnk1*)&gUnknown_03007870[i-1]->unk_1c;
+ }
+
+ gUnknown_03007898->unk_dc = (u32)&gUnknown_03007870[3]->unk_1c;
+ STWI_init_all(&gUnknown_03007870[3]->unk_1c, interrupt, copyInterruptToRam);
+ rfu_STC_clearAPIVariables();
+
+ for (i = 0; i < 4; i++)
+ {
+ gUnknown_03007880[i]->unk_68 = 0;
+ gUnknown_03007880[i]->unk_6c = 0;
+ gUnknown_03007870[i]->unk_14 = 0;
+ gUnknown_03007870[i]->unk_18 = 0;
+ }
+
+ // Not matching, register differences
+ v12 = (u16*)((u32)&sub_82E53F4 & ~1);
+ v13 = (u16*)gUnknown_03007898->unk_8;
+
+ for (i = 47; i != 0xFFFF; i--)
+ {
+ *v13 = *v12;
+ ++v12;
+ ++v13;
+ }
+
+ gUnknown_03007898->unk_4 = (u32)(&gUnknown_03007898->unk_8[1]);
+
+ return 0;
+}*/
diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c
new file mode 100644
index 000000000..21d38bb38
--- /dev/null
+++ b/src/librfu_stwi.c
@@ -0,0 +1,687 @@
+#include "global.h"
+#include "librfu.h"
+
+extern IntrFunc IntrSIO32(void);
+
+extern void STWI_stop_timer(void);
+
+void STWI_init_Callback_M(void);
+void STWI_init_Callback_S(void);
+void STWI_set_Callback_M(void * callback);
+void STWI_set_Callback_S(void * callback);
+u16 STWI_init(u8 request);
+int STWI_start_Command(void);
+void STWI_intr_timer(void);
+void STWI_set_timer(u8 unk);
+
+int STWI_restart_Command(void);
+int STWI_reset_ClockCounter(void);
+
+void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, bool8 copyInterruptToRam)
+{
+ // If we're copying our interrupt into RAM, DMA it to block1 and use
+ // block2 for our RfuStruct, otherwise block1 holds the RfuStruct.
+ // interrupt usually is a pointer to gIntrTable[1]
+ if (copyInterruptToRam == TRUE)
+ {
+ *interrupt = (IntrFunc)interruptStruct->block1;
+ DmaCopy16(3, &IntrSIO32, interruptStruct->block1, 0x960);
+ gRfuState = (struct RfuStruct*)interruptStruct->block2;
+ }
+ else
+ {
+ *interrupt = (IntrFunc)IntrSIO32;
+ gRfuState = (struct RfuStruct*)interruptStruct->block1;
+ }
+
+ gRfuState->rxPacket = (union RfuPacket*)interruptStruct->rxPacketAlloc;
+ gRfuState->txPacket = (union RfuPacket*)interruptStruct->txPacketAlloc;
+ gRfuState->msMode = 1;
+ gRfuState->unk_0 = 0;
+ gRfuState->txParams = 0;
+ gRfuState->unk_5 = 0;
+ gRfuState->unk_7 = 0;
+ gRfuState->unk_8 = 0;
+ gRfuState->unk_9 = 0;
+ gRfuState->timerState = 0;
+ gRfuState->timerActive = 0;
+ gRfuState->unk_12 = 0;
+ gRfuState->unk_15 = 0;
+ gRfuState->unk_2c = 0;
+
+ REG_RCNT = 0x100; //TODO: mystery bit?
+ REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+ STWI_init_Callback_M();
+ STWI_init_Callback_S();
+
+ IntrEnable(INTR_FLAG_SERIAL);
+}
+
+void STWI_init_timer(IntrFunc *interrupt, int timerSelect)
+{
+ *interrupt = STWI_intr_timer;
+ gRfuState->timerSelect = timerSelect;
+
+ IntrEnable(INTR_FLAG_TIMER0 << gRfuState->timerSelect);
+}
+
+void AgbRFU_SoftReset(void)
+{
+ vu16 *timerL;
+ vu16 *timerH;
+
+ REG_RCNT = 0x8000;
+ REG_RCNT = 0x80A0; // all these bits are undocumented
+ timerL = &REG_TMCNT_L(gRfuState->timerSelect);
+ timerH = &REG_TMCNT_H(gRfuState->timerSelect);
+ *timerH = 0;
+ *timerL = 0;
+ *timerH = 0x83;
+ while (*timerL <= 0x11)
+ REG_RCNT = 0x80A2;
+ *timerH = 3;
+ REG_RCNT = 0x80A0;
+ REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+
+ gRfuState->unk_0 = 0;
+ gRfuState->txParams = 0;
+ gRfuState->unk_5 = 0;
+ gRfuState->activeCommand = 0;
+ gRfuState->unk_7 = 0;
+ gRfuState->unk_8 = 0;
+ gRfuState->unk_9 = 0;
+ gRfuState->timerState = 0;
+ gRfuState->timerActive = 0;
+ gRfuState->unk_12 = 0;
+ gRfuState->msMode = 1;
+ gRfuState->unk_15 = 0;
+ gRfuState->unk_2c = 0;
+}
+
+void STWI_set_MS_mode(u8 mode)
+{
+ gRfuState->msMode = mode;
+}
+
+u16 STWI_read_status(u8 index)
+{
+ switch (index)
+ {
+ case 0:
+ return gRfuState->unk_12;
+ case 1:
+ return gRfuState->msMode;
+ case 2:
+ return gRfuState->unk_0;
+ case 3:
+ return gRfuState->activeCommand;
+ default:
+ return 0xFFFF;
+ }
+}
+
+void STWI_init_Callback_M(void)
+{
+ STWI_set_Callback_M(0);
+}
+
+void STWI_init_Callback_S(void)
+{
+ STWI_set_Callback_S(0);
+}
+
+void STWI_set_Callback_M(void *callback)
+{
+ gRfuState->callbackM = callback;
+}
+
+void STWI_set_Callback_S(void *callback)
+{
+ gRfuState->callbackS = callback;
+}
+
+void STWI_set_Callback_ID(u32 id)
+{
+ gRfuState->callbackID = id;
+}
+
+u16 STWI_poll_CommandEnd(void)
+{
+ while (gRfuState->unk_2c == TRUE)
+ ;
+ return gRfuState->unk_12;
+}
+
+void STWI_send_ResetREQ(void)
+{
+ if (!STWI_init(RFU_RESET))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_LinkStatusREQ(void)
+{
+ if (!STWI_init(RFU_LINK_STATUS))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_VersionStatusREQ(void)
+{
+ if (!STWI_init(RFU_VERSION_STATUS))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SystemStatusREQ(void)
+{
+ if (!STWI_init(RFU_SYSTEM_STATUS))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SlotStatusREQ(void)
+{
+ if (!STWI_init(RFU_SLOT_STATUS))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_ConfigStatusREQ(void)
+{
+ if (!STWI_init(RFU_CONFIG_STATUS))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_GameConfigREQ(u8 * unk1, u8 *data)
+{
+ u8 *packetBytes;
+ int i;
+
+ if (!STWI_init(RFU_GAME_CONFIG))
+ {
+ gRfuState->txParams = 6;
+
+ //TODO: what is unk1
+ packetBytes = gRfuState->txPacket->rfuPacket8.data;
+ packetBytes += sizeof(u32);
+ *(u16*)packetBytes = *(u16*)unk1;
+
+ packetBytes += sizeof(u16);
+ unk1 += sizeof(u16);
+
+ for (i = 0; i < 14; i++)
+ {
+ *packetBytes = *unk1;
+ packetBytes++;
+ unk1++;
+ }
+
+ for (i = 0; i < 8; i++)
+ {
+ *packetBytes = *data;
+ packetBytes++;
+ data++;
+ }
+
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3)
+{
+ if (!STWI_init(RFU_SYSTEM_CONFIG))
+ {
+ u8 *packetBytes;
+
+ gRfuState->txParams = 1;
+
+ packetBytes = gRfuState->txPacket->rfuPacket8.data;
+ packetBytes += sizeof(u32);
+
+ *packetBytes++ = unk3;
+ *packetBytes++ = unk2;
+ *(u16*)packetBytes = unk1;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SC_StartREQ(void)
+{
+ if (!STWI_init(RFU_SC_START))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SC_PollingREQ(void)
+{
+ if (!STWI_init(RFU_SC_POLLING))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SC_EndREQ(void)
+{
+ if (!STWI_init(RFU_SC_END))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SP_StartREQ(void)
+{
+ if (!STWI_init(RFU_SP_START))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SP_PollingREQ(void)
+{
+ if (!STWI_init(RFU_SP_POLLING))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_SP_EndREQ(void)
+{
+ if (!STWI_init(RFU_SP_END))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_CP_StartREQ(u16 unk1)
+{
+ if (!STWI_init(RFU_CP_START))
+ {
+ gRfuState->txParams = 1;
+ gRfuState->txPacket->rfuPacket32.data[0] = unk1;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_CP_PollingREQ(void)
+{
+ if (!STWI_init(RFU_CP_POLLING))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_CP_EndREQ(void)
+{
+ if (!STWI_init(RFU_CP_END))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_DataTxREQ(void *in, u8 size)
+{
+ if (!STWI_init(RFU_DATA_TX))
+ {
+ u8 txParams = (size / sizeof(u32));
+ if (size & (sizeof(u32) - 1))
+ txParams += 1;
+
+ gRfuState->txParams = txParams;
+ CpuCopy32(in, gRfuState->txPacket->rfuPacket32.data, gRfuState->txParams * sizeof(u32));
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_DataTxAndChangeREQ(void *in, u8 size)
+{
+ if (!STWI_init(RFU_DATA_TX_AND_CHANGE))
+ {
+ u8 txParams = (size / sizeof(u32));
+ if (size & (sizeof(u32) - 1))
+ txParams += 1;
+
+ gRfuState->txParams = txParams;
+ CpuCopy32(in, gRfuState->txPacket->rfuPacket32.data, gRfuState->txParams * sizeof(u32));
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_DataRxREQ(void)
+{
+ if (!STWI_init(RFU_DATA_RX))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_MS_ChangeREQ(void)
+{
+ if (!STWI_init(RFU_MS_CHANGE))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_DataReadyAndChangeREQ(u8 unk)
+{
+ if (!STWI_init(RFU_DATA_READY_AND_CHANGE))
+ {
+ if (!unk)
+ {
+ gRfuState->txParams = 0;
+ }
+ else
+ {
+ u8 *packetBytes;
+
+ gRfuState->txParams = 1;
+
+ packetBytes = gRfuState->txPacket->rfuPacket8.data;
+ packetBytes += sizeof(u32);
+
+ *packetBytes++ = unk;
+ *packetBytes++ = 0;
+ *packetBytes++ = 0;
+ *packetBytes = 0;
+ }
+
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_DisconnectedAndChangeREQ(u8 unk0, u8 unk1)
+{
+ if (!STWI_init(RFU_DISCONNECTED_AND_CHANGE))
+ {
+ u8 *packetBytes;
+
+ gRfuState->txParams = 1;
+
+ packetBytes = gRfuState->txPacket->rfuPacket8.data;
+ packetBytes += sizeof(u32);
+
+ *packetBytes++ = unk0;
+ *packetBytes++ = unk1;
+ *packetBytes++ = 0;
+ *packetBytes = 0;
+
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_ResumeRetransmitAndChangeREQ(void)
+{
+ if (!STWI_init(RFU_RESUME_RETRANSMIT_AND_CHANGE))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_DisconnectREQ(u8 unk)
+{
+ if (!STWI_init(RFU_DISCONNECT))
+ {
+ gRfuState->txParams = 1;
+ gRfuState->txPacket->rfuPacket32.data[0] = unk;
+
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_TestModeREQ(u8 unk0, u8 unk1)
+{
+ if (!STWI_init(RFU_TEST_MODE))
+ {
+ gRfuState->txParams = 1;
+ gRfuState->txPacket->rfuPacket32.data[0] = unk0 | (unk1 << 8);
+
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_CPR_StartREQ(u16 unk0, u16 unk1, u8 unk2)
+{
+ u32 *packetData;
+ u32 arg1;
+
+ if (!STWI_init(RFU_CPR_START))
+ {
+ gRfuState->txParams = 2;
+
+ arg1 = unk1 | (unk0 << 16);
+ packetData = gRfuState->txPacket->rfuPacket32.data;
+ packetData[0] = arg1;
+ packetData[1] = unk2;
+
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_CPR_PollingREQ(void)
+{
+ if (!STWI_init(RFU_CPR_POLLING))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_CPR_EndREQ(void)
+{
+ if (!STWI_init(RFU_CPR_END))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_send_StopModeREQ(void)
+{
+ if (!STWI_init(RFU_STOP_MODE))
+ {
+ gRfuState->txParams = 0;
+ STWI_start_Command();
+ }
+}
+
+void STWI_intr_timer(void)
+{
+ switch (gRfuState->timerState)
+ {
+ //TODO: Make an enum for these
+ case 2:
+ gRfuState->timerActive = 1;
+ STWI_set_timer(50);
+ break;
+ case 1:
+ case 4:
+ STWI_stop_timer();
+ STWI_restart_Command();
+ break;
+ case 3:
+ gRfuState->timerActive = 1;
+ STWI_stop_timer();
+ STWI_reset_ClockCounter();
+ if (gRfuState->callbackM)
+ gRfuState->callbackM(255, 0);
+ break;
+ }
+}
+
+void STWI_set_timer(u8 unk)
+{
+ vu16 *timerL;
+ vu16 *timerH;
+
+ timerL = &REG_TMCNT_L(gRfuState->timerSelect);
+ timerH = &REG_TMCNT_H(gRfuState->timerSelect);
+ REG_IME = 0;
+ switch (unk)
+ {
+ case 50:
+ *timerL = 0xFCCB;
+ gRfuState->timerState = 1;
+ break;
+ case 80:
+ *timerL = 0xFAE0;
+ gRfuState->timerState = 2;
+ break;
+ case 100:
+ *timerL = 0xF996;
+ gRfuState->timerState = 3;
+ break;
+ case 130:
+ *timerL = 0xF7AD;
+ gRfuState->timerState = 4;
+ break;
+ }
+ *timerH = TIMER_ENABLE | TIMER_INTR_ENABLE | TIMER_1024CLK;
+ REG_IF = INTR_FLAG_TIMER0 << gRfuState->timerSelect;
+ REG_IME = 1;
+}
+
+void STWI_stop_timer(void)
+{
+ gRfuState->timerState = 0;
+
+ REG_TMCNT_L(gRfuState->timerSelect) = 0;
+ REG_TMCNT_H(gRfuState->timerSelect) = 0;
+}
+
+u16 STWI_init(u8 request)
+{
+ if (!REG_IME)
+ {
+ gRfuState->unk_12 = 6;
+ if (gRfuState->callbackM)
+ gRfuState->callbackM(request, gRfuState->unk_12);
+ return TRUE;
+ }
+ else if (gRfuState->unk_2c == TRUE)
+ {
+ gRfuState->unk_12 = 2;
+ gRfuState->unk_2c = FALSE;
+ if (gRfuState->callbackM)
+ gRfuState->callbackM(request, gRfuState->unk_12);
+ return TRUE;
+ }
+ else if(!gRfuState->msMode)
+ {
+ gRfuState->unk_12 = 4;
+ if (gRfuState->callbackM)
+ gRfuState->callbackM(request, gRfuState->unk_12, gRfuState);
+ return TRUE;
+ }
+ else
+ {
+ gRfuState->unk_2c = TRUE;
+ gRfuState->activeCommand = request;
+ gRfuState->unk_0 = 0;
+ gRfuState->txParams = 0;
+ gRfuState->unk_5 = 0;
+ gRfuState->unk_7 = 0;
+ gRfuState->unk_8 = 0;
+ gRfuState->unk_9 = 0;
+ gRfuState->timerState = 0;
+ gRfuState->timerActive = 0;
+ gRfuState->unk_12 = 0;
+ gRfuState->unk_15 = 0;
+
+ REG_RCNT = 0x100;
+ REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+ return FALSE;
+ }
+}
+
+int STWI_start_Command()
+{
+ u16 imeTemp;
+
+ // Yes, it matters that it's casted to a u32...
+ *(u32*)gRfuState->txPacket->rfuPacket8.data = 0x99660000 | (gRfuState->txParams << 8) | gRfuState->activeCommand;
+ REG_SIODATA32 = gRfuState->txPacket->rfuPacket32.command;
+
+ gRfuState->unk_0 = 0;
+ gRfuState->unk_5 = 1;
+
+ imeTemp = REG_IME;
+ REG_IME = 0;
+ REG_IE |= (INTR_FLAG_TIMER0 << gRfuState->timerSelect);
+ REG_IE |= INTR_FLAG_SERIAL;
+ REG_IME = imeTemp;
+
+ REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_MULTI_BUSY | SIO_115200_BPS;
+
+ return 0;
+}
+
+int STWI_restart_Command(void)
+{
+ if (gRfuState->unk_15 <= 1)
+ {
+ gRfuState->unk_15++;
+ STWI_start_Command();
+ }
+ else
+ {
+ if (gRfuState->activeCommand == RFU_MS_CHANGE || gRfuState->activeCommand == RFU_DATA_TX_AND_CHANGE || gRfuState->activeCommand == RFU_UNK35 || gRfuState->activeCommand == RFU_RESUME_RETRANSMIT_AND_CHANGE)
+ {
+ gRfuState->unk_12 = 1;
+ gRfuState->unk_2c = 0;
+
+ if (gRfuState->callbackM)
+ gRfuState->callbackM(gRfuState->activeCommand, gRfuState->unk_12);
+ }
+ else
+ {
+ gRfuState->unk_12 = 1;
+ gRfuState->unk_2c = 0;
+
+ if (gRfuState->callbackM)
+ gRfuState->callbackM(gRfuState->activeCommand, gRfuState->unk_12);
+
+ gRfuState->unk_0 = 4; //TODO: what's 4
+ }
+ }
+
+ return 0;
+}
+
+int STWI_reset_ClockCounter()
+{
+ gRfuState->unk_0 = 5; //TODO: what is 5
+ gRfuState->txParams = 0;
+ gRfuState->unk_5 = 0;
+ REG_SIODATA32 = (1 << 31);
+ REG_SIOCNT = 0;
+ REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS;
+ REG_SIOCNT = (SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS) + 0x7F;
+
+ return 0;
+}
diff --git a/src/mail.c b/src/mail.c
new file mode 100644
index 000000000..1060d73bd
--- /dev/null
+++ b/src/mail.c
@@ -0,0 +1,577 @@
+
+// Includes
+#include "global.h"
+#include "main.h"
+#include "overworld.h"
+#include "task.h"
+#include "unknown_task.h"
+#include "palette.h"
+#include "menu.h"
+#include "menu_helpers.h"
+#include "text.h"
+#include "text_window.h"
+#include "string_util.h"
+#include "international_string_util.h"
+#include "strings.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "pokemon_icon.h"
+#include "species.h"
+#include "malloc.h"
+#include "easy_chat.h"
+#include "mail_data.h"
+#include "mail.h"
+
+// Static type declarations
+
+struct UnkMailStruct
+{
+ u32 numEasyChatWords:2;
+ u32 xOffset:6;
+ u32 lineHeight:8;
+};
+
+struct MailLayout
+{
+ u8 numSubStructs;
+ u8 signatureYPos;
+ u8 signatureWidth;
+ u8 wordsXPos;
+ u8 wordsYPos;
+ const struct UnkMailStruct *var8;
+};
+
+struct MailGraphics
+{
+ const u16 *palette;
+ const u8 *tiles;
+ const u8 *tileMap;
+ u16 var0C;
+ u16 var0E;
+ u16 color10;
+ u16 color12;
+};
+
+// Static RAM declarations
+
+static EWRAM_DATA struct
+{
+ /*0x0000*/ u8 strbuf[8][64];
+ /*0x0200*/ u8 playerName[12];
+ /*0x020C*/ MainCallback callback;
+ /*0x0210*/ MainCallback callback2;
+ /*0x0214*/ struct MailStruct *mail;
+ /*0x0218*/ bool8 flag;
+ /*0x0219*/ u8 signatureWidth;
+ /*0x021a*/ u8 mailType;
+ /*0x021b*/ u8 animsActive;
+ /*0x021c*/ u8 monIconSprite;
+ /*0x021d*/ u8 language;
+ /*0x021e*/ bool8 playerIsSender;
+ /*0x0220*/ void (*parserSingle)(u8 *dest, u16 word);
+ /*0x0224*/ void (*parserMultiple)(u8 *dest, const u16 *src, u16 length1, u16 length2);
+ /*0x0228*/ const struct MailLayout *layout;
+ /*0x022c*/ u8 bg1TilemapBuffer[0x1000];
+ /*0x122c*/ u8 bg2TilemapBuffer[0x1000];
+} *gUnknown_0203A134 = NULL;
+
+// Static ROM declarations
+
+void sub_81219F0(void);
+void sub_8121A1C(void);
+void sub_8121B1C(void);
+void sub_8121C50(void);
+void sub_8121C64(void);
+void sub_8121C98(void);
+void sub_8121CC0(void);
+void sub_8121D00(void);
+
+// .rodata
+
+const struct BgTemplate gUnknown_0859F290[] = {
+ {
+ .bg = 0,
+ .charBaseIndex = 2,
+ .mapBaseIndex = 31,
+ .priority = 0
+ }, {
+ .bg = 1,
+ .charBaseIndex = 0,
+ .mapBaseIndex = 30,
+ .priority = 1
+ }, {
+ .bg = 2,
+ .charBaseIndex = 0,
+ .mapBaseIndex = 29,
+ .priority = 2
+ }
+};
+
+const struct WindowTemplate gUnknown_0859F29C[] = {
+ {
+ .priority = 0,
+ .tilemapLeft = 2,
+ .tilemapTop = 3,
+ .width = 26,
+ .height = 15,
+ .paletteNum = 15,
+ .baseBlock = 1
+ },
+ DUMMY_WIN_TEMPLATE
+};
+
+const u8 gUnknown_0859F2AC[] = {
+ 0,
+ 10,
+ 11
+};
+
+const u16 gUnknown_0859F2B0[][2] = {
+ { 0x6ACD, 0x51A5 },
+ { 0x45FC, 0x38D4 }
+};
+
+extern const u16 gUnknown_08DBE818[];
+extern const u16 gUnknown_08DBE838[];
+extern const u16 gUnknown_08DBE858[];
+extern const u16 gUnknown_08DBE878[];
+extern const u16 gUnknown_08DBE898[];
+extern const u16 gUnknown_08DBE8B8[];
+extern const u16 gUnknown_08DBE8D8[];
+extern const u16 gUnknown_08DBE8F8[];
+extern const u16 gUnknown_08DBE918[];
+extern const u16 gUnknown_08DBE938[];
+extern const u16 gUnknown_08DBE958[];
+extern const u16 gUnknown_08DBE978[];
+extern const u8 gUnknown_08DBE998[];
+extern const u8 gUnknown_08DBFBA4[];
+extern const u8 gUnknown_08DBEB38[];
+extern const u8 gUnknown_08DBFC7C[];
+extern const u8 gUnknown_08DBEC74[];
+extern const u8 gUnknown_08DBFD5C[];
+extern const u8 gUnknown_08DBEE84[];
+extern const u8 gUnknown_08DBFE68[];
+extern const u8 gUnknown_08DBEF5C[];
+extern const u8 gUnknown_08DBFF44[];
+extern const u8 gUnknown_08DBF154[];
+extern const u8 gUnknown_08DC0034[];
+extern const u8 gUnknown_08DBF2D4[];
+extern const u8 gUnknown_08DC0114[];
+extern const u8 gUnknown_08DBF37C[];
+extern const u8 gUnknown_08DC01F4[];
+extern const u8 gUnknown_08DBF50C[];
+extern const u8 gUnknown_08DC0300[];
+extern const u8 gUnknown_08DBF64C[];
+extern const u8 gUnknown_08DC03F0[];
+extern const u8 gUnknown_08DBF7B4[];
+extern const u8 gUnknown_08DC04E8[];
+extern const u8 gUnknown_08DBF904[];
+extern const u8 gUnknown_08DC0600[];
+
+const struct MailGraphics gUnknown_0859F2B8[] = {
+ {
+ gUnknown_08DBE818, gUnknown_08DBE998, gUnknown_08DBFBA4, 0x02c0, 0x0000, 0x294a, 0x6739
+ }, {
+ gUnknown_08DBE838, gUnknown_08DBEB38, gUnknown_08DBFC7C, 0x02e0, 0x0000, 0x7fff, 0x4631
+ }, {
+ gUnknown_08DBE858, gUnknown_08DBEC74, gUnknown_08DBFD5C, 0x0400, 0x0000, 0x294a, 0x6739
+ }, {
+ gUnknown_08DBE878, gUnknown_08DBEE84, gUnknown_08DBFE68, 0x01e0, 0x0000, 0x7fff, 0x4631
+ }, {
+ gUnknown_08DBE898, gUnknown_08DBEF5C, gUnknown_08DBFF44, 0x02e0, 0x0000, 0x7fff, 0x4631
+ }, {
+ gUnknown_08DBE8B8, gUnknown_08DBF154, gUnknown_08DC0034, 0x0300, 0x0000, 0x294a, 0x6739
+ }, {
+ gUnknown_08DBE8D8, gUnknown_08DBF2D4, gUnknown_08DC0114, 0x0140, 0x0000, 0x7fff, 0x4631
+ }, {
+ gUnknown_08DBE8F8, gUnknown_08DBF37C, gUnknown_08DC01F4, 0x0300, 0x0000, 0x7fff, 0x4631
+ }, {
+ gUnknown_08DBE918, gUnknown_08DBF50C, gUnknown_08DC0300, 0x0220, 0x0000, 0x294a, 0x6739
+ }, {
+ gUnknown_08DBE938, gUnknown_08DBF64C, gUnknown_08DC03F0, 0x0340, 0x0000, 0x294a, 0x6739
+ }, {
+ gUnknown_08DBE958, gUnknown_08DBF7B4, gUnknown_08DC04E8, 0x02a0, 0x0000, 0x294a, 0x6739
+ }, {
+ gUnknown_08DBE978, gUnknown_08DBF904, gUnknown_08DC0600, 0x0520, 0x0000, 0x294a, 0x6739
+ }
+};
+
+const struct UnkMailStruct Unknown_0859F3A8[] = {
+ { .numEasyChatWords = 3, .lineHeight = 16 },
+ { .numEasyChatWords = 3, .lineHeight = 16 },
+ { .numEasyChatWords = 3, .lineHeight = 16 }
+};
+
+const struct MailLayout gUnknown_0859F3B4[] = {
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x08, 0x00, 0x02, 0x04, Unknown_0859F3A8 },
+ { 0x03, 0x00, 0x00, 0x02, 0x00, Unknown_0859F3A8 }
+};
+
+const struct UnkMailStruct Unknown_0859F444[] = {
+ { .numEasyChatWords = 2, .lineHeight = 16 },
+ { .numEasyChatWords = 2, .lineHeight = 16 },
+ { .numEasyChatWords = 2, .lineHeight = 16 },
+ { .numEasyChatWords = 2, .lineHeight = 16 },
+ { .numEasyChatWords = 1, .lineHeight = 16 }
+};
+
+const struct MailLayout gUnknown_0859F458[] = {
+ { 0x05, 0x07, 0x58, 0x0b, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x0a, 0x60, 0x09, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x0c, 0x68, 0x05, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x05, 0x60, 0x08, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x0a, 0x60, 0x09, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x09, 0x70, 0x05, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x0c, 0x68, 0x09, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x0d, 0x68, 0x0d, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x09, 0x60, 0x09, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x09, 0x60, 0x09, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x11, 0x68, 0x0f, 0x1e, Unknown_0859F444 },
+ { 0x05, 0x09, 0x60, 0x05, 0x1e, Unknown_0859F444 }
+};
+
+// What the heck are these meant to be? Call them u16 for now.
+
+const u16 Unknown_0859F4E8[] = {
+ 0x00, 0x4000, 0x00, 0x00
+};
+
+const u16 Unknown_0859F4F0[] = {
+ 0x00, 0x00, -1, 0x00
+};
+
+const u16 Unknown_0859F4F8[] = {
+ 0x04, 0x00, -1, 0x00
+};
+
+const u16 Unknown_0859F500[] = {
+ 0x00, 0x40, -1, 0x00
+};
+
+const u16 *const gUnknown_0859F508[] = {
+ Unknown_0859F4F0,
+ Unknown_0859F4F8,
+ Unknown_0859F500
+};
+
+// .text
+
+void sub_8121478(struct MailStruct *mail, MainCallback callback, bool8 flag) {
+ u16 buffer[2];
+ u16 species;
+
+ gUnknown_0203A134 = calloc(1, sizeof(*gUnknown_0203A134));
+ gUnknown_0203A134->language = LANGUAGE_ENGLISH;
+ gUnknown_0203A134->playerIsSender = TRUE;
+ gUnknown_0203A134->parserSingle = CopyEasyChatWord;
+ gUnknown_0203A134->parserMultiple = ConvertEasyChatWordsToString;
+ if (mail->itemId >= ITEM_ORANGE_MAIL && mail->itemId <= ITEM_RETRO_MAIL) {
+ gUnknown_0203A134->mailType = mail->itemId - ITEM_ORANGE_MAIL;
+ }
+ else
+ {
+ gUnknown_0203A134->mailType = 0;
+ flag = FALSE;
+ }
+ switch (gUnknown_0203A134->playerIsSender)
+ {
+ case FALSE:
+ default:
+ gUnknown_0203A134->layout = &gUnknown_0859F3B4[gUnknown_0203A134->mailType];
+ break;
+ case TRUE:
+ gUnknown_0203A134->layout = &gUnknown_0859F458[gUnknown_0203A134->mailType];
+ break;
+ }
+ species = sub_80D45E8(mail->species, buffer);
+ if (species >= SPECIES_BULBASAUR && species < NUM_SPECIES)
+ {
+ switch (gUnknown_0203A134->mailType)
+ {
+ default:
+ gUnknown_0203A134->animsActive = 0;
+ break;
+ case ITEM_BEAD_MAIL - ITEM_ORANGE_MAIL:
+ gUnknown_0203A134->animsActive = 1;
+ break;
+ case ITEM_DREAM_MAIL - ITEM_ORANGE_MAIL:
+ gUnknown_0203A134->animsActive = 2;
+ break;
+ }
+ }
+ else
+ {
+ gUnknown_0203A134->animsActive = 0;
+ }
+ gUnknown_0203A134->mail = mail;
+ gUnknown_0203A134->callback = callback;
+ gUnknown_0203A134->flag = flag;
+ SetMainCallback2(sub_81219F0);
+}
+
+bool8 sub_81215EC(void)
+{
+ u16 icon;
+
+ switch (gMain.state)
+ {
+ case 0:
+ SetVBlankCallback(NULL);
+ remove_some_task();
+ SetGpuReg(REG_OFFSET_DISPCNT, 0x0000);
+ break;
+ case 1:
+ CpuFill16(0, (void *)OAM, OAM_SIZE);
+ break;
+ case 2:
+ ResetPaletteFade();
+ break;
+ case 3:
+ ResetTasks();
+ break;
+ case 4:
+ ResetSpriteData();
+ break;
+ case 5:
+ FreeAllSpritePalettes();
+ reset_temp_tile_data_buffers();
+ SetGpuReg(REG_OFFSET_BG0HOFS, 0x0000);
+ SetGpuReg(REG_OFFSET_BG0VOFS, 0x0000);
+ SetGpuReg(REG_OFFSET_BG1HOFS, 0x0000);
+ SetGpuReg(REG_OFFSET_BG1VOFS, 0x0000);
+ SetGpuReg(REG_OFFSET_BG2VOFS, 0x0000);
+ SetGpuReg(REG_OFFSET_BG2HOFS, 0x0000);
+ SetGpuReg(REG_OFFSET_BG3HOFS, 0x0000);
+ SetGpuReg(REG_OFFSET_BG3VOFS, 0x0000);
+ SetGpuReg(REG_OFFSET_BLDCNT, 0x0000);
+ SetGpuReg(REG_OFFSET_BLDALPHA, 0x0000);
+ break;
+ case 6:
+ ResetBgsAndClearDma3BusyFlags(0);
+ InitBgsFromTemplates(0, gUnknown_0859F290, 3);
+ SetBgTilemapBuffer(1, gUnknown_0203A134->bg1TilemapBuffer);
+ SetBgTilemapBuffer(2, gUnknown_0203A134->bg2TilemapBuffer);
+ break;
+ case 7:
+ InitWindows(gUnknown_0859F29C);
+ DeactivateAllTextPrinters();
+ break;
+ case 8:
+ decompress_and_copy_tile_data_to_vram(1, gUnknown_0859F2B8[gUnknown_0203A134->mailType].tiles, 0, 0, 0);
+ break;
+ case 9:
+ if (free_temp_tile_data_buffers_if_possible())
+ {
+ return FALSE;
+ }
+ break;
+ case 10:
+ FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 30, 20);
+ FillBgTilemapBufferRect_Palette0(2, 1, 0, 0, 30, 20);
+ CopyToBgTilemapBuffer(1, gUnknown_0859F2B8[gUnknown_0203A134->mailType].tileMap, 0, 0);
+ break;
+ case 11:
+ CopyBgTilemapBufferToVram(0);
+ CopyBgTilemapBufferToVram(1);
+ CopyBgTilemapBufferToVram(2);
+ break;
+ case 12:
+ LoadPalette(sub_8098C64(), 240, 32);
+ gPlttBufferUnfaded[250] = gUnknown_0859F2B8[gUnknown_0203A134->mailType].color10;
+ gPlttBufferFaded[250] = gUnknown_0859F2B8[gUnknown_0203A134->mailType].color10;
+ gPlttBufferUnfaded[251] = gUnknown_0859F2B8[gUnknown_0203A134->mailType].color12;
+ gPlttBufferFaded[251] = gUnknown_0859F2B8[gUnknown_0203A134->mailType].color12;
+ LoadPalette(gUnknown_0859F2B8[gUnknown_0203A134->mailType].palette, 0, 32);
+ gPlttBufferUnfaded[10] = gUnknown_0859F2B0[gSaveBlock2Ptr->playerGender][0];
+ gPlttBufferFaded[10] = gUnknown_0859F2B0[gSaveBlock2Ptr->playerGender][0];
+ gPlttBufferUnfaded[11] = gUnknown_0859F2B0[gSaveBlock2Ptr->playerGender][1];
+ gPlttBufferFaded[11] = gUnknown_0859F2B0[gSaveBlock2Ptr->playerGender][1];
+ break;
+ case 13:
+ if (gUnknown_0203A134->flag)
+ {
+ sub_8121A1C();
+ }
+ break;
+ case 14:
+ if (gUnknown_0203A134->flag)
+ {
+ sub_8121B1C();
+ RunTextPrinters();
+ }
+ break;
+ case 15:
+ if (sub_8087598() == TRUE)
+ {
+ return FALSE;
+ }
+ break;
+ case 16:
+ SetVBlankCallback(sub_8121C50);
+ gPaletteFade.bufferTransferDisabled = TRUE;
+ break;
+ case 17:
+ icon = sub_80D2E84(gUnknown_0203A134->mail->species);
+ switch (gUnknown_0203A134->animsActive)
+ {
+ case 1:
+ sub_80D2F68(icon);
+ gUnknown_0203A134->monIconSprite = sub_80D2D78(icon, SpriteCallbackDummy, 0x60, 0x80, 0, 0);
+ break;
+ case 2:
+ sub_80D2F68(icon);
+ gUnknown_0203A134->monIconSprite = sub_80D2D78(icon, SpriteCallbackDummy, 0x28, 0x80, 0, 0);
+ break;
+ }
+ break;
+ case 18:
+ SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+ ShowBg(0);
+ ShowBg(1);
+ ShowBg(2);
+ BeginNormalPaletteFade(-1, 0, 16, 0, 0);
+ gPaletteFade.bufferTransferDisabled = FALSE;
+ gUnknown_0203A134->callback2 = sub_8121C98;
+ return TRUE;
+ default:
+ return FALSE;
+ }
+ gMain.state ++;
+ return FALSE;
+}
+
+void sub_81219F0(void)
+{
+ do
+ {
+ if (sub_81215EC() == TRUE)
+ {
+ SetMainCallback2(sub_8121C64);
+ break;
+ }
+ } while (sub_81221AC() != TRUE);
+}
+
+void sub_8121A1C(void)
+{
+ u16 i;
+ u8 total;
+ u8 *ptr;
+
+ total = 0;
+ for (i = 0; i < gUnknown_0203A134->layout->numSubStructs; i ++)
+ {
+ ConvertEasyChatWordsToString(gUnknown_0203A134->strbuf[i], &gUnknown_0203A134->mail->words[total], gUnknown_0203A134->layout->var8[i].numEasyChatWords, 1);
+ total += gUnknown_0203A134->layout->var8[i].numEasyChatWords;
+ }
+ ptr = StringCopy(gUnknown_0203A134->playerName, gUnknown_0203A134->mail->playerName);
+ if (!gUnknown_0203A134->playerIsSender)
+ {
+ StringCopy(ptr, gText_FromSpace);
+ gUnknown_0203A134->signatureWidth = gUnknown_0203A134->layout->signatureWidth - (StringLength(gUnknown_0203A134->playerName) * 8 - 0x60);
+ }
+ else
+ {
+ sub_81DB52C(gUnknown_0203A134->playerName);
+ gUnknown_0203A134->signatureWidth = gUnknown_0203A134->layout->signatureWidth;
+ }
+}
+
+void sub_8121B1C(void)
+{
+ u16 i;
+ u8 strbuf[0x20];
+ u8 y;
+ u8 *bufptr;
+ s32 box_x;
+ s32 box_y;
+
+ y = 0;
+ PutWindowTilemap(0);
+ PutWindowTilemap(1);
+ FillWindowPixelBuffer(0, 0);
+ FillWindowPixelBuffer(1, 0);
+ for (i = 0; i < gUnknown_0203A134->layout->numSubStructs; i ++)
+ {
+ if (gUnknown_0203A134->strbuf[i][0] == EOS || gUnknown_0203A134->strbuf[i][0] == CHAR_SPACE)
+ {
+ continue;
+ }
+ box_print(0, 1, gUnknown_0203A134->layout->var8[i].xOffset + gUnknown_0203A134->layout->wordsYPos, y + gUnknown_0203A134->layout->wordsXPos, gUnknown_0859F2AC, 0, gUnknown_0203A134->strbuf[i]);
+ y += gUnknown_0203A134->layout->var8[i].lineHeight;
+ }
+ bufptr = StringCopy(strbuf, gText_FromSpace);
+ StringCopy(bufptr, gUnknown_0203A134->playerName);
+ box_x = GetStringCenterAlignXOffset(1, strbuf, gUnknown_0203A134->signatureWidth) + 0x68;
+ box_y = gUnknown_0203A134->layout->signatureYPos + 0x58;
+ box_print(0, 1, box_x, box_y, gUnknown_0859F2AC, 0, strbuf);
+ CopyWindowToVram(0, 3);
+ CopyWindowToVram(1, 3);
+}
+
+void sub_8121C50(void)
+{
+ LoadOam();
+ ProcessSpriteCopyRequests();
+ TransferPlttBuffer();
+}
+
+void sub_8121C64(void)
+{
+ if (gUnknown_0203A134->animsActive != 0)
+ {
+ AnimateSprites();
+ BuildOamBuffer();
+ }
+ gUnknown_0203A134->callback2();
+}
+
+void sub_8121C98(void)
+{
+ if (!UpdatePaletteFade())
+ {
+ gUnknown_0203A134->callback2 = sub_8121CC0;
+ }
+}
+
+void sub_8121CC0(void)
+{
+ if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+ {
+ BeginNormalPaletteFade(-1, 0, 0, 16, 0);
+ gUnknown_0203A134->callback2 = sub_8121D00;
+ }
+}
+
+void sub_8121D00(void)
+{
+ if (!UpdatePaletteFade())
+ {
+ SetMainCallback2(gUnknown_0203A134->callback);
+ switch (gUnknown_0203A134->animsActive)
+ {
+ case 1:
+ case 2:
+ sub_80D2FF0(sub_80D2E84(gUnknown_0203A134->mail->species));
+ sub_80D2EF8(&gSprites[gUnknown_0203A134->monIconSprite]);
+ }
+ memset(gUnknown_0203A134, 0, sizeof(*gUnknown_0203A134));
+ ResetPaletteFade();
+ UnsetBgTilemapBuffer(0);
+ UnsetBgTilemapBuffer(1);
+ ResetBgsAndClearDma3BusyFlags(0);
+ FreeAllWindowBuffers();
+ free(gUnknown_0203A134);
+ gUnknown_0203A134 = NULL;
+ }
+}
diff --git a/src/reshow_battle_screen.c b/src/reshow_battle_screen.c
index 25c2ca658..343ddb9c0 100644
--- a/src/reshow_battle_screen.c
+++ b/src/reshow_battle_screen.c
@@ -336,9 +336,9 @@ static void CreateHealthboxSprite(u8 bank)
UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gPlayerParty[gBattlePartyID[bank]], HEALTHBOX_ALL);
if (GetBankIdentity(bank) == IDENTITY_OPPONENT_MON2 || GetBankIdentity(bank) == IDENTITY_PLAYER_MON2)
- nullsub_30(gHealthBoxesIds[bank], TRUE);
+ DummyBattleInterfaceFunc(gHealthBoxesIds[bank], TRUE);
else
- nullsub_30(gHealthBoxesIds[bank], FALSE);
+ DummyBattleInterfaceFunc(gHealthBoxesIds[bank], FALSE);
if (GetBankSide(bank) != SIDE_PLAYER)
{
diff --git a/src/safari_zone.c b/src/safari_zone.c
index a1ec38920..77c6bbd61 100644
--- a/src/safari_zone.c
+++ b/src/safari_zone.c
@@ -139,7 +139,7 @@ static void ClearAllPokeblockFeeders(void)
memset(sPokeblockFeeders, 0, sizeof(sPokeblockFeeders));
}
-static void GetPokeblockFeederInFront(void)
+void GetPokeblockFeederInFront(void)
{
s16 x, y;
u16 i;
diff --git a/src/sprite.c b/src/sprite.c
index 17b0f181a..daa019019 100644
--- a/src/sprite.c
+++ b/src/sprite.c
@@ -594,7 +594,7 @@ u8 CreateSpriteAt(u8 index, const struct SpriteTemplate *template, s16 x, s16 y,
return index;
}
-u8 CreateSpriteAndAnimate(struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority)
+u8 CreateSpriteAndAnimate(const struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority)
{
u8 i;
diff --git a/src/start_menu.c b/src/start_menu.c
index be30d0e53..37331a922 100644
--- a/src/start_menu.c
+++ b/src/start_menu.c
@@ -207,7 +207,7 @@ static bool32 PrintStartMenuItemsMultistep(s16 *index, u32 n)
do
{
- if (sStartMenuItems[sCurrentStartMenuActions[_index]].func == StartMenu_PlayerName)
+ if (sStartMenuItems[sCurrentStartMenuActions[_index]].func.u8_void == StartMenu_PlayerName)
{
}
diff --git a/src/tv.c b/src/tv.c
index 7f64b46ac..3c822b394 100644
--- a/src/tv.c
+++ b/src/tv.c
@@ -2353,7 +2353,7 @@ void sub_80EDFB4(TVShow *show)
show->secretBaseVisit.move = sTV_SecretBaseVisitMonsTemp[j].move;
}
-void sub_80EE104(void)
+void TV_PutSecretBaseVisitOnTheAir(void)
{
TVShow *show;
diff --git a/src/walda_phrase.c b/src/walda_phrase.c
new file mode 100644
index 000000000..7e06d1319
--- /dev/null
+++ b/src/walda_phrase.c
@@ -0,0 +1,257 @@
+#include "global.h"
+#include "walda_phrase.h"
+#include "string_util.h"
+#include "event_data.h"
+#include "naming_screen.h"
+#include "main.h"
+#include "text.h"
+#include "new_game.h"
+
+extern void (*gFieldCallback)(void);
+
+extern const u8 gText_Peekaboo[];
+
+extern u8 *GetWaldaPhrasePtr(void);
+extern bool32 IsWaldaPhraseEmpty(void);
+extern void sub_80AF168(void);
+extern void c2_exit_to_overworld_2_switch(void);
+extern void SetWaldaPhrase(const u8 *src);
+extern void SetWaldaWallpaperPatternId(u8 patternId);
+extern void SetWaldaWallpaperIconId(u8 iconId);
+extern void SetWaldaWallpaperColors(u16 backgroundColor, u16 foregroundColor);
+extern void SetWaldaWallpaperLockedOrUnlocked(bool32 unlocked);
+
+// this file's functions
+static void CB2_HandleGivenWaldaPhrase(void);
+static u32 GetWaldaPhraseInputCase(u8 *inputPtr);
+static bool32 TryCalculateWallpaper(u16* backgroundClr, u16 *foregroundClr, u8 *iconId, u8 *patternId, u16 trainerId, u8 *phrase);
+static void sub_81D9D5C(u8 *array, u8 *letterTableIds, u32 arg2, u32 arg3, u32 loopCount);
+static u32 sub_81D9DAC(u8 *array, u32 arg1, u32 loopCount);
+static void sub_81D9C90(u8 *array, s32 arg1, s32 arg2);
+static void sub_81D9CDC(u8 *array, u32 loopCount, u8 arg2);
+
+// only consonants are allowed, no vowels, some lowercase letters are missing
+static const u8 sWaldaLettersTable[] =
+{
+ CHAR_B, CHAR_C, CHAR_D, CHAR_F, CHAR_G, CHAR_H, CHAR_J, CHAR_K, CHAR_L, CHAR_M, CHAR_N, CHAR_P, CHAR_Q, CHAR_R, CHAR_S, CHAR_T, CHAR_V, CHAR_W, CHAR_Z,
+ CHAR_b, CHAR_c, CHAR_d, CHAR_f, CHAR_g, CHAR_h, CHAR_j, CHAR_k, CHAR_m, CHAR_n, CHAR_p, CHAR_q, CHAR_s
+};
+
+enum
+{
+ PHRASE_GIVEN_NEW,
+ PHRASE_NO_CHANGE,
+ PHRASE_FIRST_ATTEMPT
+};
+
+u16 TryBufferWaldaPhrase(void)
+{
+ if (IsWaldaPhraseEmpty())
+ return FALSE;
+
+ StringCopy(gStringVar1, GetWaldaPhrasePtr());
+ return TRUE;
+}
+
+void DoWaldaNamingScreen(void)
+{
+ StringCopy(gStringVar2, GetWaldaPhrasePtr());
+ DoNamingScreen(NAMING_SCREEN_WALDA, gStringVar2, 0, 0, 0, CB2_HandleGivenWaldaPhrase);
+}
+
+static void CB2_HandleGivenWaldaPhrase(void)
+{
+ gSpecialVar_0x8004 = GetWaldaPhraseInputCase(gStringVar2);
+
+ switch (gSpecialVar_0x8004)
+ {
+ case PHRASE_FIRST_ATTEMPT:
+ if (IsWaldaPhraseEmpty())
+ SetWaldaPhrase(gText_Peekaboo);
+ else
+ gSpecialVar_0x8004 = PHRASE_NO_CHANGE;
+ break;
+ case PHRASE_GIVEN_NEW:
+ SetWaldaPhrase(gStringVar2);
+ break;
+ case PHRASE_NO_CHANGE:
+ break;
+ }
+
+ StringCopy(gStringVar1, GetWaldaPhrasePtr());
+ gFieldCallback = sub_80AF168;
+ SetMainCallback2(c2_exit_to_overworld_2_switch);
+}
+
+static u32 GetWaldaPhraseInputCase(u8 *inputPtr)
+{
+ if (inputPtr[0] == EOS)
+ return PHRASE_FIRST_ATTEMPT;
+ if (StringCompare(inputPtr, GetWaldaPhrasePtr()) == 0)
+ return PHRASE_NO_CHANGE;
+
+ return PHRASE_GIVEN_NEW;
+}
+
+u16 TryGetWallpaperWithWaldaPhrase(void)
+{
+ u16 backgroundClr, foregroundClr;
+ u8 patternId, iconId;
+ u16 trainerId = ReadUnalignedWord(gSaveBlock2Ptr->playerTrainerId);
+ gScriptResult = TryCalculateWallpaper(&backgroundClr, &foregroundClr, &iconId, &patternId, trainerId, GetWaldaPhrasePtr());
+
+ if (gScriptResult)
+ {
+ SetWaldaWallpaperPatternId(patternId);
+ SetWaldaWallpaperIconId(iconId);
+ SetWaldaWallpaperColors(backgroundClr, foregroundClr);
+ }
+
+ SetWaldaWallpaperLockedOrUnlocked(gScriptResult);
+ return (bool8)(gScriptResult);
+}
+
+static u8 GetLetterTableId(u8 letter)
+{
+ s32 i;
+
+ for (i = 0; i < ARRAY_COUNT(sWaldaLettersTable); i++)
+ {
+ if (sWaldaLettersTable[i] == letter)
+ return i;
+ }
+
+ return ARRAY_COUNT(sWaldaLettersTable);
+}
+
+static bool32 TryCalculateWallpaper(u16* backgroundClr, u16 *foregroundClr, u8 *iconId, u8 *patternId, u16 trainerId, u8 *phrase)
+{
+ s32 i;
+ ALIGNED(2) u8 array[12];
+ u8 charsByTableId[16];
+ u16 *ptr;
+
+ if (StringLength(phrase) != 15)
+ return FALSE;
+
+ for (i = 0; i < 15; i++)
+ {
+ charsByTableId[i] = GetLetterTableId(phrase[i]);
+ if (charsByTableId[i] == ARRAY_COUNT(sWaldaLettersTable))
+ return FALSE;
+ }
+
+ for (i = 0; i < 14; i++)
+ {
+ sub_81D9D5C(array, charsByTableId, (5 * i), 3 + (8 * i), 5);
+ }
+
+ sub_81D9D5C(array, charsByTableId, 70, 115, 2);
+
+ if (sub_81D9DAC(array, 0, 3) != sub_81D9DAC(charsByTableId, 117, 3))
+ return FALSE;
+
+ sub_81D9C90(array, 9, 21);
+ sub_81D9C90(array, 8, array[8] & 0xF);
+ sub_81D9CDC(array, 8, array[8] >> 4);
+
+ if (array[6] != (array[0] ^ array[2] ^ array[4] ^ (trainerId >> 8)))
+ return FALSE;
+
+ if (array[7] != (array[1] ^ array[3] ^ array[5] ^ (trainerId & 0xFF)))
+ return FALSE;
+
+ ptr = (u16*)(&array[0]);
+ *backgroundClr = *ptr;
+
+ ptr = (u16*)(&array[2]);
+ *foregroundClr = *ptr;
+
+ *iconId = array[4];
+ *patternId = array[5];
+
+ return TRUE;
+}
+
+static void sub_81D9C90(u8 *array, s32 arg1, s32 arg2)
+{
+ s32 i, j;
+ u8 var1, var2;
+
+ for (i = arg2 - 1; i != -1; i--)
+ {
+ var1 = (array[0] & 0x80) >> 7;
+
+ var1++; var1--; // needed to match
+
+ for (j = arg1 - 1; j >= 0; j--)
+ {
+ var2 = array[j] & 0x80;
+ array[j] <<= 1;
+ array[j] |= var1;
+ var1 = var2 >> 7;
+ }
+ }
+}
+
+static void sub_81D9CDC(u8 *array, u32 loopCount, u8 arg2)
+{
+ u32 i;
+
+ arg2 |= (arg2 << 4);
+
+ for (i = 0; i < loopCount; i++)
+ {
+ array[i] ^= arg2;
+ }
+}
+
+static bool8 sub_81D9D0C(u8 *array, u32 arg1)
+{
+ u32 arrayId = arg1 >> 3;
+ u32 bits = 0x80 >> (7 & arg1);
+
+ return ((array[arrayId] & bits) != 0);
+}
+
+static void sub_81D9D28(u8 *array, u32 arg1)
+{
+ u32 arrayId = arg1 >> 3;
+ u8 bits = 0x80 >> (7 & arg1);
+
+ array[arrayId] |= bits;
+}
+
+static void sub_81D9D40(u8 *array, u32 arg1)
+{
+ u32 arrayId = arg1 >> 3;
+ u8 bits = ~(0x80 >> (7 & arg1));
+
+ array[arrayId] &= bits;
+}
+
+static void sub_81D9D5C(u8 *array, u8 *letterTableIds, u32 arg2, u32 arg3, u32 loopCount)
+{
+ u32 i;
+
+ for (i = 0; i < loopCount; i++)
+ {
+ if (sub_81D9D0C(letterTableIds, arg3 + i))
+ sub_81D9D28(array, arg2 + i);
+ else
+ sub_81D9D40(array, arg2 + i);
+ }
+}
+
+static u32 sub_81D9DAC(u8 *array, u32 arg1, u32 loopCount)
+{
+ u32 ret, i;
+
+ for (ret = 0, i = 0; i < loopCount; i++)
+ {
+ ret <<= 1;
+ ret |= sub_81D9D0C(array, arg1 + i);
+ }
+
+ return ret;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-08 13:28:06 +0000