diff options
Diffstat (limited to 'src')
110 files changed, 20636 insertions, 2313 deletions
diff --git a/src/AgbRfu_LinkManager.c b/src/AgbRfu_LinkManager.c index e4127ee09..35ac45d5f 100644 --- a/src/AgbRfu_LinkManager.c +++ b/src/AgbRfu_LinkManager.c @@ -1,6 +1,6 @@ #include "global.h" #include "librfu.h" -#include "link_rfu.h" +#include "AgbRfu_LinkManager.h" #define RN_ACCEPT 0x01 #define RN_NAME_TIMER_CLEAR 0x02 @@ -1,8 +1,6 @@ #include "global.h" -#include "palette.h" +#include "gflib.h" #include "item_menu.h" -#include "text.h" -#include "window.h" #include "text_window.h" #include "menu_helpers.h" #include "new_menu_helpers.h" diff --git a/src/battle_ai_script_commands.c b/src/battle_ai_script_commands.c index a8bc439f4..877fba80a 100644 --- a/src/battle_ai_script_commands.c +++ b/src/battle_ai_script_commands.c @@ -4,7 +4,6 @@ #include "util.h" #include "item.h" #include "random.h" -#include "pokemon.h" #include "battle_ai_script_commands.h" #include "constants/species.h" #include "constants/abilities.h" diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c index 5d642bda9..e689d2353 100644 --- a/src/battle_ai_switch_items.c +++ b/src/battle_ai_switch_items.c @@ -2,7 +2,6 @@ #include "battle.h" #include "battle_anim.h" #include "battle_controllers.h" -#include "pokemon.h" #include "random.h" #include "util.h" #include "constants/abilities.h" diff --git a/src/battle_anim.c b/src/battle_anim.c index 0cb88219a..1132b5725 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -1,20 +1,13 @@ #include "global.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" #include "battle_controllers.h" #include "battle_interface.h" #include "battle_bg.h" -#include "bg.h" #include "decompress.h" -#include "dma3.h" -#include "gpu_regs.h" #include "graphics.h" -#include "main.h" #include "m4a.h" -#include "palette.h" -#include "pokemon.h" -#include "sound.h" -#include "sprite.h" #include "task.h" #include "constants/battle_anim.h" @@ -1970,6 +1963,11 @@ static void ScriptCmd_unloadspritegfx(void) ClearSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); } +// Create sprite from template and init data array with varargs +// args: template, flags, va_args +// flags: +// - bits 0-6: subpriority mod (signed) +// - bit 7: target if set else attacker static void ScriptCmd_createsprite(void) { s32 i; diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index 33b5ceacc..d1f75ff8f 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -1,10 +1,8 @@ #include "global.h" +#include "gflib.h" #include "battle_anim.h" #include "battle_interface.h" -#include "gpu_regs.h" -#include "palette.h" #include "random.h" -#include "sound.h" #include "trig.h" #include "util.h" #include "constants/songs.h" @@ -4321,7 +4319,7 @@ static void AnimLockOnTargetStep4(struct Sprite* sprite) sprite->data[1] = 0; } - BlendPalettes(sub_8075BE8(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB_WHITE); + BlendPalettes(SelectBattleAnimSpriteAndBgPalettes(1, 1, 1, 1, 1, 0, 0), sprite->data[1], RGB_WHITE); if (sprite->data[1] == 16) { int pal; @@ -4981,7 +4979,7 @@ void AnimTask_FadeScreenBlueStep(u8); void AnimTask_FadeScreenBlue(u8 taskId) { - int a = sub_8075BE8(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; + int a = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; int b; int c; int d; @@ -4996,7 +4994,7 @@ void AnimTask_FadeScreenBlue(u8 taskId) gTasks[taskId].data[7] = 13; gTasks[taskId].data[8] = 14; gTasks[taskId].data[9] = 15; - b = sub_8075CB8(1, 1, 1, 1); + b = SelectBattlerSpritePalettes(1, 1, 1, 1); c = a | b; StorePointerInVars(&gTasks[taskId].data[14], &gTasks[taskId].data[15], (void*)c); b = b | (0x10000 << IndexOfSpritePaletteTag(ANIM_TAG_MOON)); diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index 093660389..510b8eabb 100644 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -1,15 +1,12 @@ #include "global.h" -#include "malloc.h" +#include "gflib.h" #include "battle_anim.h" #include "battle_interface.h" #include "decompress.h" -#include "gpu_regs.h" #include "graphics.h" #include "math_util.h" -#include "palette.h" #include "random.h" #include "scanline_effect.h" -#include "sound.h" #include "trig.h" #include "util.h" #include "constants/songs.h" @@ -3090,7 +3087,7 @@ static void FakeOutStep2(u8 taskId) { gTasks[taskId].data[11] = 0x88; SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_LIGHTEN); - BlendPalettes(sub_8075BE8(1, 0, 0, 0, 0, 0, 0), 16, RGB_WHITE); + BlendPalettes(SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0), 16, RGB_WHITE); } else if (gTasks[taskId].data[10] > 4) { diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 69bae2c6f..e9bfb2618 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -1,19 +1,13 @@ #include "global.h" -#include "malloc.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" -#include "bg.h" #include "data.h" #include "decompress.h" -#include "dma3.h" -#include "gpu_regs.h" #include "graphics.h" -#include "palette.h" #include "pokemon_icon.h" #include "random.h" #include "scanline_effect.h" -#include "sound.h" -#include "sprite.h" #include "task.h" #include "trig.h" #include "util.h" diff --git a/src/battle_anim_mons.c b/src/battle_anim_mons.c index 7f3516670..8cc6c9a00 100644 --- a/src/battle_anim_mons.c +++ b/src/battle_anim_mons.c @@ -1,14 +1,9 @@ #include "global.h" +#include "gflib.h" #include "battle_anim.h" -#include "bg.h" #include "data.h" #include "decompress.h" -#include "dma3.h" -#include "gpu_regs.h" -#include "malloc.h" -#include "palette.h" #include "pokemon_icon.h" -#include "sprite.h" #include "task.h" #include "trig.h" #include "util.h" @@ -1240,7 +1235,7 @@ void SetGreyscaleOrOriginalPalette(u16 paletteNum, bool8 restoreOriginalColor) } } -u32 sub_8075BE8(u8 battleBackground, u8 attacker, u8 target, u8 attackerPartner, u8 targetPartner, u8 a6, u8 a7) +u32 SelectBattleAnimSpriteAndBgPalettes(bool8 battleBackground, bool8 attacker, bool8 target, bool8 attackerPartner, bool8 targetPartner, bool8 a6, bool8 a7) { u32 selectedPalettes = 0; u32 shift; @@ -1286,19 +1281,19 @@ u32 sub_8075BE8(u8 battleBackground, u8 attacker, u8 target, u8 attackerPartner, return selectedPalettes; } -u32 sub_8075CB8(u8 a1, u8 a2, u8 a3, u8 a4) +u32 SelectBattlerSpritePalettes(bool8 playerLeft, bool8 playerRight, bool8 foeLeft, bool8 foeRight) { u32 var = 0; u32 shift; - if (a1) + if (playerLeft) { if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT))) { var |= 1 << (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) + 16); } } - if (a2) + if (playerRight) { if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT))) { @@ -1306,7 +1301,7 @@ u32 sub_8075CB8(u8 a1, u8 a2, u8 a3, u8 a4) var |= 1 << shift; } } - if (a3) + if (foeLeft) { if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))) { @@ -1314,7 +1309,7 @@ u32 sub_8075CB8(u8 a1, u8 a2, u8 a3, u8 a4) var |= 1 << shift; } } - if (a4) + if (foeRight) { if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT))) { @@ -1325,13 +1320,13 @@ u32 sub_8075CB8(u8 a1, u8 a2, u8 a3, u8 a4) return var; } -u8 sub_8075D80(u8 a1) +u8 GetSpritePalIdxByBattler(u8 a1) { return a1; } // not used -static u8 GetBattlerAtPosition_(u8 position) +static u8 GetSpritePalIdxByPosition(u8 position) { return GetBattlerAtPosition(position); } diff --git a/src/battle_anim_sound_tasks.c b/src/battle_anim_sound_tasks.c index f2740a1a5..a820667fb 100644 --- a/src/battle_anim_sound_tasks.c +++ b/src/battle_anim_sound_tasks.c @@ -1,7 +1,7 @@ #include "global.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" -#include "sound.h" #include "task.h" #include "constants/battle_anim.h" #include "constants/species.h" diff --git a/src/battle_anim_special.c b/src/battle_anim_special.c index 7590c0e58..621ee9039 100644 --- a/src/battle_anim_special.c +++ b/src/battle_anim_special.c @@ -1,19 +1,14 @@ #include "global.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" #include "battle_main.h" #include "battle_controllers.h" #include "battle_interface.h" #include "decompress.h" -#include "dma3.h" -#include "gpu_regs.h" #include "graphics.h" #include "m4a.h" -#include "main.h" -#include "palette.h" #include "pokeball.h" -#include "sound.h" -#include "sprite.h" #include "task.h" #include "trig.h" #include "util.h" @@ -666,7 +661,7 @@ void sub_80EF344(u8 taskId) priority = gSprites[spriteId].oam.priority; subpriority = gSprites[spriteId].subpriority; gTasks[taskId].data[10] = LaunchBallStarsTask(x, y + 32, priority, subpriority, ballId); - selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0); + selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0); gTasks[taskId].data[11] = LaunchBallFadeMonTask(0, gBattleAnimAttacker, selectedPalettes, ballId); gTasks[taskId].data[0]++; break; diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c index 2e7f30ff1..4eb475a5c 100644 --- a/src/battle_anim_status_effects.c +++ b/src/battle_anim_status_effects.c @@ -1,10 +1,8 @@ #include "global.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" #include "decompress.h" -#include "gpu_regs.h" -#include "palette.h" -#include "sprite.h" #include "task.h" #include "trig.h" #include "util.h" diff --git a/src/battle_anim_utility_funcs.c b/src/battle_anim_utility_funcs.c index df4a8243b..a1897b94a 100644 --- a/src/battle_anim_utility_funcs.c +++ b/src/battle_anim_utility_funcs.c @@ -1,12 +1,8 @@ #include "global.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" -#include "gpu_regs.h" #include "graphics.h" -#include "malloc.h" -#include "palette.h" -#include "sound.h" -#include "sprite.h" #include "task.h" #include "util.h" #include "constants/songs.h" @@ -22,9 +18,9 @@ struct AnimStatsChangeData static void StartBlendAnimSpriteColor(u8 taskId, u32 selectedPalettes); static void AnimTask_BlendSpriteColor_Step2(u8 taskId); -static void sub_80BAB78(u8 taskId); -static void sub_80BABD0(u8 taskId); -static void sub_80BACA8(struct Sprite *sprite); +static void Task_WaitHardwarePaletteFade(u8 taskId); +static void Task_DoCloneBattlerSpriteWithBlend(u8 taskId); +static void Task_FinishCloneBattlerSpriteWithBlend(struct Sprite *sprite); static void sub_80BAF38(u8 taskId); static void sub_80BB0D8(u8 taskId); static void sub_80BB2A0(u8 taskId); @@ -41,18 +37,42 @@ static const u16 gUnknown_83E7CC8[] = { RGB(31, 31, 31) }; const u8 gUnknown_83E7CCA[] = { REG_OFFSET_BG0CNT, REG_OFFSET_BG1CNT, REG_OFFSET_BG2CNT, REG_OFFSET_BG3CNT }; const u8 gUnknown_83E7CCE[] = { REG_OFFSET_BG0CNT, REG_OFFSET_BG1CNT, REG_OFFSET_BG2CNT, REG_OFFSET_BG3CNT }; -void sub_80BA7F8(u8 taskId) +// gBattleAnimArgs[0] is a bitfield. +// Bits 0-10 result in the following palettes being selected: +// 0: battle background palettes (BG palettes 1, 2, and 3) +// 1: gBattleAnimAttacker OBJ palette +// 2: gBattleAnimTarget OBJ palette +// 3: gBattleAnimAttacker partner OBJ palette +// 4: gBattleAnimTarget partner OBJ palette +// 5: BG palette 4 +// 6: BG palette 5 +// 7: Player battler left +// 8: Player battler right +// 9: Enemy battler left +// 10: Enemy battler right +void AnimTask_BlendSelected(u8 taskId) { u32 selectedPalettes = UnpackSelectedBattleAnimPalettes(gBattleAnimArgs[0]); - selectedPalettes |= sub_8075CB8((gBattleAnimArgs[0] >> 7) & 1, - (gBattleAnimArgs[0] >> 8) & 1, - (gBattleAnimArgs[0] >> 9) & 1, - (gBattleAnimArgs[0] >> 10) & 1); + selectedPalettes |= SelectBattlerSpritePalettes( + (gBattleAnimArgs[0] >> 7) & 1, + (gBattleAnimArgs[0] >> 8) & 1, + (gBattleAnimArgs[0] >> 9) & 1, + (gBattleAnimArgs[0] >> 10) & 1); StartBlendAnimSpriteColor(taskId, selectedPalettes); } -void sub_80BA83C(u8 taskId) +// gBattleAnimArgs[0] is a command ID +// This command will blend bg and battlers except as commanded: +// 0: Not attacker +// 1: Not target +// 2: Not attacker nor bg +// 3: Not target nor bg +// 4: Neither attacker nor target +// 5: Blend all +// 6: Neither bg nor attacker's partner +// 7: Neither bg nor target's partner +void AnimTask_BlendExcept(u8 taskId) { u8 battler; u32 selectedPalettes; @@ -95,7 +115,7 @@ void sub_80BA83C(u8 taskId) if (battler != animBattlers[0] && battler != animBattlers[1] && IsBattlerSpriteVisible(battler)) - selectedPalettes |= 0x10000 << sub_8075D80(battler); + selectedPalettes |= 0x10000 << GetSpritePalIdxByBattler(battler); } StartBlendAnimSpriteColor(taskId, selectedPalettes); } @@ -190,23 +210,23 @@ static void AnimTask_BlendSpriteColor_Step2(u8 taskId) } } -void sub_80BAB38(u8 taskId) +void AnimTask_HardwarePaletteFade(u8 taskId) { BeginHardwarePaletteFade(gBattleAnimArgs[0], gBattleAnimArgs[1], gBattleAnimArgs[2], gBattleAnimArgs[3], gBattleAnimArgs[4]); - gTasks[taskId].func = sub_80BAB78; + gTasks[taskId].func = Task_WaitHardwarePaletteFade; } -static void sub_80BAB78(u8 taskId) +static void Task_WaitHardwarePaletteFade(u8 taskId) { if (!gPaletteFade.active) DestroyAnimVisualTask(taskId); } -void sub_80BAB98(u8 taskId) +void AnimTask_CloneBattlerSpriteWithBlend(u8 taskId) { struct Task *task = &gTasks[taskId]; @@ -216,9 +236,9 @@ void sub_80BAB98(u8 taskId) task->data[3] = gBattleAnimArgs[2]; task->data[4] = gBattleAnimArgs[3]; task->data[5] = 0; - task->func = sub_80BABD0; + task->func = Task_DoCloneBattlerSpriteWithBlend; } -static void sub_80BABD0(u8 taskId) +static void Task_DoCloneBattlerSpriteWithBlend(u8 taskId) { struct Task *task = &gTasks[taskId]; @@ -237,7 +257,7 @@ static void sub_80BABD0(u8 taskId) gSprites[task->data[6]].data[0] = task->data[3]; gSprites[task->data[6]].data[1] = taskId; gSprites[task->data[6]].data[2] = 5; - gSprites[task->data[6]].callback = sub_80BACA8; + gSprites[task->data[6]].callback = Task_FinishCloneBattlerSpriteWithBlend; ++task->data[5]; } --task->data[4]; @@ -250,7 +270,7 @@ static void sub_80BABD0(u8 taskId) } } -static void sub_80BACA8(struct Sprite *sprite) +static void Task_FinishCloneBattlerSpriteWithBlend(struct Sprite *sprite) { if (sprite->data[0]) { @@ -263,7 +283,7 @@ static void sub_80BACA8(struct Sprite *sprite) } } -void sub_80BACEC(u8 taskId) +void AnimTask_SetUpCurseBackground(u8 taskId) { u16 species; s32 newSpriteId; @@ -559,11 +579,11 @@ static void sub_80BB4B8(u8 taskId) void sub_80BB660(u8 taskId) { - u32 selectedPalettes = sub_8075CB8(1, 1, 1, 1); + u32 selectedPalettes = SelectBattlerSpritePalettes(1, 1, 1, 1); sub_80BB790(selectedPalettes, 0); gTasks[taskId].data[14] = selectedPalettes >> 16; - selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; + selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0) & 0xFFFF; sub_80BB790(selectedPalettes, 0xFFFF); gTasks[taskId].data[15] = selectedPalettes; gTasks[taskId].data[0] = 0; @@ -835,7 +855,7 @@ void sub_80BBE6C(u8 taskId) s32 paletteIndex = 0; if (gBattleAnimArgs[0] == 0) - for (selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0); + for (selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0); (selectedPalettes & 1) == 0; ++paletteIndex) selectedPalettes >>= 1; @@ -853,7 +873,7 @@ void sub_80BBF08(u8 taskId) s32 paletteIndex = 0; if (gBattleAnimArgs[0] == 0) - for (selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0); + for (selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0); (selectedPalettes & 1) == 0; ++paletteIndex) selectedPalettes >>= 1; @@ -871,7 +891,7 @@ void sub_80BBFA4(u8 taskId) s32 paletteIndex = 0; if (gBattleAnimArgs[0] == 0) - for (selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0); + for (selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0); (selectedPalettes & 1) == 0; ++paletteIndex) selectedPalettes >>= 1; diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index a80e79bf4..90080b88e 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -1,14 +1,10 @@ #include "global.h" +#include "gflib.h" #include "data.h" #include "link.h" #include "m4a.h" -#include "palette.h" #include "pokeball.h" -#include "pokemon.h" -#include "sound.h" -#include "string_util.h" #include "task.h" -#include "text.h" #include "util.h" #include "battle.h" #include "battle_anim.h" diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 5ac4f1abc..fdac017c8 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -1,13 +1,9 @@ #include "global.h" +#include "gflib.h" #include "data.h" #include "link.h" -#include "palette.h" #include "pokeball.h" -#include "pokemon.h" -#include "sound.h" -#include "string_util.h" #include "task.h" -#include "text.h" #include "util.h" #include "battle.h" #include "battle_anim.h" diff --git a/src/battle_controller_oak_old_man.c b/src/battle_controller_oak_old_man.c index 0807018a2..97a167fe3 100644 --- a/src/battle_controller_oak_old_man.c +++ b/src/battle_controller_oak_old_man.c @@ -1,21 +1,14 @@ #include "global.h" +#include "gflib.h" #include "task.h" -#include "pokemon.h" #include "pokeball.h" #include "party_menu.h" -#include "bg.h" -#include "data.h" -#include "palette.h" #include "util.h" #include "m4a.h" #include "link.h" -#include "sound.h" #include "item.h" #include "item_menu.h" -#include "text.h" #include "strings.h" -#include "string_util.h" -#include "window.h" #include "battle.h" #include "battle_anim.h" #include "battle_controllers.h" diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 26e35ae65..b7522c0de 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -1,15 +1,11 @@ #include "global.h" +#include "gflib.h" #include "data.h" -#include "main.h" #include "m4a.h" #include "task.h" -#include "text.h" #include "util.h" #include "pokeball.h" -#include "pokemon.h" #include "random.h" -#include "sound.h" -#include "string_util.h" #include "battle.h" #include "battle_anim.h" #include "battle_controllers.h" diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index b28249a97..97e833ffd 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -1,23 +1,16 @@ #include "global.h" -#include "bg.h" +#include "gflib.h" #include "data.h" #include "item.h" #include "item_menu.h" #include "link.h" -#include "main.h" #include "m4a.h" -#include "palette.h" #include "party_menu.h" #include "pokeball.h" -#include "pokemon.h" -#include "sound.h" #include "strings.h" -#include "string_util.h" #include "pokemon_special_anim.h" #include "task.h" -#include "text.h" #include "util.h" -#include "window.h" #include "battle.h" #include "battle_anim.h" #include "battle_controllers.h" diff --git a/src/battle_controller_pokedude.c b/src/battle_controller_pokedude.c index a6b3fe994..2489c2d95 100644 --- a/src/battle_controller_pokedude.c +++ b/src/battle_controller_pokedude.c @@ -1,21 +1,15 @@ #include "global.h" +#include "gflib.h" #include "task.h" -#include "pokemon.h" #include "party_menu.h" #include "pokeball.h" -#include "bg.h" #include "data.h" -#include "palette.h" #include "util.h" #include "m4a.h" #include "link.h" -#include "sound.h" #include "event_data.h" #include "item_menu.h" -#include "text.h" #include "strings.h" -#include "string_util.h" -#include "window.h" #include "battle.h" #include "battle_anim.h" #include "battle_controllers.h" diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 28ed4091e..e15d76deb 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -1,19 +1,15 @@ #include "global.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" #include "battle_controllers.h" #include "battle_interface.h" #include "battle_message.h" -#include "bg.h" #include "data.h" #include "item_menu.h" #include "link.h" #include "main.h" -#include "palette.h" #include "pokeball.h" -#include "pokemon.h" -#include "sound.h" -#include "text.h" #include "util.h" #include "strings.h" #include "constants/songs.h" diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 834b9e6b6..d06d09012 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -10,7 +10,6 @@ #include "link_rfu.h" #include "cable_club.h" #include "party_menu.h" -#include "pokemon.h" #include "task.h" #include "util.h" #include "constants/abilities.h" diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c index 127b0903b..45188d022 100644 --- a/src/battle_gfx_sfx_util.c +++ b/src/battle_gfx_sfx_util.c @@ -1,10 +1,8 @@ #include "global.h" -#include "main.h" +#include "gflib.h" #include "m4a.h" #include "task.h" -#include "malloc.h" #include "graphics.h" -#include "sound.h" #include "decompress.h" #include "palette.h" #include "sprite.h" diff --git a/src/battle_interface.c b/src/battle_interface.c index e5145adc0..107999045 100644 --- a/src/battle_interface.c +++ b/src/battle_interface.c @@ -1,19 +1,14 @@ #include "global.h" +#include "gflib.h" #include "battle_anim.h" #include "battle_interface.h" #include "battle_message.h" #include "decompress.h" -#include "gpu_regs.h" #include "graphics.h" #include "menu.h" -#include "palette.h" #include "pokedex.h" #include "pokemon_summary_screen.h" #include "safari_zone.h" -#include "sound.h" -#include "string_util.h" -#include "text.h" -#include "window.h" #include "constants/songs.h" #define GetStringRightAlignXOffset(fontId, string, destWidth) ({ \ diff --git a/src/battle_intro.c b/src/battle_intro.c index 93141f2ca..25fdbafda 100644 --- a/src/battle_intro.c +++ b/src/battle_intro.c @@ -1,10 +1,8 @@ #include "global.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" #include "battle_setup.h" -#include "bg.h" -#include "gpu_regs.h" -#include "main.h" #include "scanline_effect.h" #include "task.h" #include "trig.h" diff --git a/src/battle_main.c b/src/battle_main.c index bbfcf5cf9..d2735086f 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -1,4 +1,5 @@ #include "global.h" +#include "gflib.h" #include "battle.h" #include "battle_anim.h" #include "battle_ai_script_commands.h" @@ -10,40 +11,29 @@ #include "battle_setup.h" #include "battle_string_ids.h" #include "berry.h" -#include "bg.h" #include "data.h" #include "decompress.h" #include "event_data.h" #include "evolution_scene.h" #include "graphics.h" -#include "gpu_regs.h" #include "help_system.h" #include "item.h" #include "link.h" #include "link_rfu.h" #include "load_save.h" -#include "main.h" -#include "malloc.h" #include "m4a.h" -#include "palette.h" #include "party_menu.h" #include "pokeball.h" #include "pokedex.h" -#include "pokemon.h" #include "quest_log.h" #include "random.h" #include "roamer.h" #include "safari_zone.h" #include "scanline_effect.h" -#include "sound.h" -#include "sprite.h" -#include "string_util.h" #include "task.h" -#include "text.h" #include "trig.h" #include "vs_seeker.h" #include "util.h" -#include "window.h" #include "constants/abilities.h" #include "constants/battle_move_effects.h" #include "constants/battle_setup.h" diff --git a/src/battle_message.c b/src/battle_message.c index 7ca47e6fb..e17d3241b 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -1,11 +1,8 @@ #include "global.h" +#include "gflib.h" #include "battle_string_ids.h" #include "battle.h" -#include "palette.h" #include "battle_anim.h" -#include "string_util.h" -#include "text.h" -#include "window.h" #include "strings.h" #include "battle_message.h" #include "link.h" diff --git a/src/battle_records.c b/src/battle_records.c index 3196d9bad..7d9ddffe4 100644 --- a/src/battle_records.c +++ b/src/battle_records.c @@ -1,20 +1,12 @@ #include "global.h" -#include "malloc.h" -#include "main.h" -#include "bg.h" -#include "gpu_regs.h" +#include "gflib.h" #include "event_data.h" -#include "palette.h" #include "task.h" -#include "text.h" -#include "window.h" #include "text_window.h" #include "battle.h" #include "trainer_tower.h" #include "trainer_pokemon_sprites.h" #include "scanline_effect.h" -#include "sound.h" -#include "string_util.h" #include "link.h" #include "menu.h" #include "overworld.h" diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index 225a47729..ceccdac87 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -1,17 +1,10 @@ #include "global.h" +#include "gflib.h" #include "item.h" #include "util.h" -#include "pokemon.h" #include "random.h" -#include "text.h" -#include "sound.h" #include "pokedex.h" -#include "window.h" -#include "main.h" -#include "palette.h" #include "money.h" -#include "bg.h" -#include "string_util.h" #include "pokemon_icon.h" #include "mail.h" #include "event_data.h" diff --git a/src/battle_setup.c b/src/battle_setup.c index df8a3ac45..ee923d6c7 100644 --- a/src/battle_setup.c +++ b/src/battle_setup.c @@ -235,7 +235,7 @@ static void DoStandardWildBattle(void) { ScriptContext2_Enable(); FreezeObjectEvents(); - sub_805C780(); + StopPlayerAvatar(); gMain.savedCallback = CB2_EndWildBattle; gBattleTypeFlags = 0; CreateBattleStartTask(GetWildBattleTransition(), 0); @@ -247,7 +247,7 @@ void StartRoamerBattle(void) { ScriptContext2_Enable(); FreezeObjectEvents(); - sub_805C780(); + StopPlayerAvatar(); gMain.savedCallback = CB2_EndWildBattle; gBattleTypeFlags = BATTLE_TYPE_ROAMER; CreateBattleStartTask(GetWildBattleTransition(), MUS_VS_DEN); @@ -259,7 +259,7 @@ static void DoSafariBattle(void) { ScriptContext2_Enable(); FreezeObjectEvents(); - sub_805C780(); + StopPlayerAvatar(); gMain.savedCallback = CB2_EndSafariBattle; gBattleTypeFlags = BATTLE_TYPE_SAFARI; CreateBattleStartTask(GetWildBattleTransition(), 0); @@ -269,7 +269,7 @@ static void DoGhostBattle(void) { ScriptContext2_Enable(); FreezeObjectEvents(); - sub_805C780(); + StopPlayerAvatar(); gMain.savedCallback = CB2_EndWildBattle; gBattleTypeFlags = BATTLE_TYPE_GHOST; CreateBattleStartTask(GetWildBattleTransition(), 0); @@ -399,7 +399,7 @@ static void sub_807FB08(void) { ScriptContext2_Enable(); FreezeObjectEvents(); - sub_805C780(); + StopPlayerAvatar(); gMain.savedCallback = sub_807FAF8; SavePlayerParty(); InitPokedudePartyAndOpponent(); diff --git a/src/berry_pouch.c b/src/berry_pouch.c index 01a94c075..9798dd441 100644 --- a/src/berry_pouch.c +++ b/src/berry_pouch.c @@ -457,7 +457,7 @@ static void CB2_InitBerryPouch(void) { while (1) { - if ((u8)sub_80BF72C() == TRUE) + if ((u8)MenuHelpers_CallLinkSomething() == TRUE) break; if (RunBerryPouchInit() == TRUE) break; @@ -934,7 +934,7 @@ static void Task_BerryPouchMain(u8 taskId) { s16 * data = gTasks[taskId].data; s32 menuInput; - if (!gPaletteFade.active && (u8)sub_80BF72C() != TRUE) + if (!gPaletteFade.active && (u8)MenuHelpers_CallLinkSomething() != TRUE) { menuInput = ListMenu_ProcessInput(data[0]); ListMenuGetScrollAndRow(data[0], &sStaticCnt.listMenuScrollOffset, &sStaticCnt.listMenuSelectedRow); @@ -1040,7 +1040,7 @@ static void Task_NormalContextMenu(u8 taskId) static void Task_NormalContextMenu_HandleInput(u8 taskId) { s8 input; - if ((u8)sub_80BF72C() != TRUE) + if ((u8)MenuHelpers_CallLinkSomething() != TRUE) { input = Menu_ProcessInputNoWrapAround(); switch (input) diff --git a/src/bg_regs.c b/src/bg_regs.c index d5879a862..ec884e4f7 100644 --- a/src/bg_regs.c +++ b/src/bg_regs.c @@ -25,7 +25,7 @@ vu16 *const gBGVOffsetRegs[] = }; const u16 gDISPCNTBGFlags[] = { DISPCNT_BG0_ON, DISPCNT_BG1_ON, DISPCNT_BG2_ON, DISPCNT_BG3_ON }; -const u16 gBLDCNTTarget2BGFlags[] = { BLDCNT_TGT2_BG0, BLDCNT_TGT2_BG1, BLDCNT_TGT2_BG2, BLDCNT_TGT2_BG3 }; +const u16 gOverworldBackgroundLayerFlags[] = { BLDCNT_TGT2_BG0, BLDCNT_TGT2_BG1, BLDCNT_TGT2_BG2, BLDCNT_TGT2_BG3 }; const u16 gBLDCNTTarget1BGFlags[] = { BLDCNT_TGT1_BG0, BLDCNT_TGT1_BG1, BLDCNT_TGT1_BG2, BLDCNT_TGT1_BG3 }; const u8 gBGControlRegOffsets[] = diff --git a/src/bike.c b/src/bike.c new file mode 100644 index 000000000..d08a5fe82 --- /dev/null +++ b/src/bike.c @@ -0,0 +1,426 @@ +#include "global.h" +#include "bike.h" +#include "field_player_avatar.h" +#include "metatile_behavior.h" +#include "event_object_movement.h" +#include "fieldmap.h" +#include "field_camera.h" +#include "overworld.h" +#include "constants/map_types.h" +#include "constants/songs.h" + +static u8 GetMovePlayerOnBikeFuncId(u8 *, u16, u16); +static void sub_80BD664(void); +static u8 BikeCanFaceDIrectionOnRail(u8, u8); +static u8 CheckNextTileForBikingCollision(u8); +static u8 AdjustCollisionForBiking(struct ObjectEvent *, s16, s16, u8, u8); +static bool8 MetatileBehaviorForbidsBiking(u8); +static void BikeFaceDirection(u8); +static void BikeFaceDirectionAccountForRail(u8); +static void BikeTryMoveFastInDirection(u8); +static void BikeLetGravityTakeTheWheel(u8); +static void BikeTryMoveInDirection(u8); +static u8 GetBikeMoveCmd_0(u8 *, u16, u16); +static u8 GetBikeMoveCmd_1(u8 *, u16, u16); +static u8 GetBikeMoveCmd_2(u8 *, u16, u16); + +static void (*const sMovePlayerOnBikeFuncs[])(u8) = +{ + BikeFaceDirection, + BikeFaceDirectionAccountForRail, + BikeTryMoveFastInDirection, + BikeLetGravityTakeTheWheel, + BikeTryMoveInDirection, +}; + +static u8 (*const sGetMovePlayerOnBikeFuncIdFuncs[])(u8 *, u16, u16) = +{ + GetBikeMoveCmd_0, + GetBikeMoveCmd_1, + GetBikeMoveCmd_2, +}; + +void MovePlayerOnBike(u8 direction, u16 newKeys, u16 heldKeys) +{ + sMovePlayerOnBikeFuncs[GetMovePlayerOnBikeFuncId(&direction, newKeys, heldKeys)](direction); +} + +static u8 GetMovePlayerOnBikeFuncId(u8 *direction, u16 newKeys, u16 heldKeys) +{ + return sGetMovePlayerOnBikeFuncIdFuncs[gPlayerAvatar.acroBikeState](direction, newKeys, heldKeys); +} + +static u8 GetBikeMoveCmd_0(u8 *direction_p, u16 newKeys, u16 heldKeys) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + u8 direction = GetPlayerMovementDirection(); + + gPlayerAvatar.bikeFrameCounter = 0; + if (MetatileBehavior_IsCyclingRoadPullDownTile(playerObjEvent->currentMetatileBehavior) == TRUE) + { + if (!JOY_HELD(B_BUTTON)) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING; + gPlayerAvatar.runningState = 2; + if (*direction_p < DIR_NORTH) + return 3; + else + return 4; + } + else + { + if (*direction_p != DIR_NONE) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING; + gPlayerAvatar.runningState = 2; + return 4; + } + else + { + goto _080BD17E; // for matching purpose + } + } + } + else + { + if (*direction_p == DIR_NONE) + { + _080BD17E: + *direction_p = direction; + gPlayerAvatar.runningState = 0; + return 0; + } + else + { + if (*direction_p != direction && gPlayerAvatar.runningState != 2) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_TURNING; + gPlayerAvatar.newDirBackup = *direction_p; + gPlayerAvatar.runningState = 0; + return GetMovePlayerOnBikeFuncId(direction_p, newKeys, heldKeys); + } + else + { + gPlayerAvatar.runningState = 2; + return 2; + } + } + } +} + +static u8 GetBikeMoveCmd_1(u8 *direction_p, UNUSED u16 newKeys, UNUSED u16 heldKeys) +{ + *direction_p = gPlayerAvatar.newDirBackup; + gPlayerAvatar.runningState = 1; + gPlayerAvatar.acroBikeState = ACRO_STATE_NORMAL; + sub_80BD664(); + return 1; +} + +static u8 GetBikeMoveCmd_2(u8 *direction_p, u16 newKeys, u16 heldKeys) +{ + u8 direction = GetPlayerMovementDirection(); + u8 playerObjEventId = gPlayerAvatar.objectEventId; + if (MetatileBehavior_IsCyclingRoadPullDownTile(playerObjEventId[gObjectEvents].currentMetatileBehavior) == TRUE) + { + if (*direction_p != direction) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_TURNING; + gPlayerAvatar.newDirBackup = *direction_p; + gPlayerAvatar.runningState = 0; + return GetMovePlayerOnBikeFuncId(direction_p, newKeys, heldKeys); + } + else + { + gPlayerAvatar.runningState = 2; + gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING; + if (*direction_p < DIR_NORTH) + return 3; + else + return 4; + } + } + else + { + gPlayerAvatar.acroBikeState = ACRO_STATE_NORMAL; + if (*direction_p == DIR_NONE) + { + *direction_p = direction; + gPlayerAvatar.runningState = 0; + return 0; + } + else + { + gPlayerAvatar.runningState = 2; + return 2; + } + } +} + +static void BikeFaceDirection(u8 direction) +{ + PlayerFaceDirection(direction); +} + +static void BikeFaceDirectionAccountForRail(u8 direction) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + if (!BikeCanFaceDIrectionOnRail(direction, playerObjEvent->currentMetatileBehavior)) + direction = playerObjEvent->movementDirection; + PlayerFaceDirection(direction); +} + +static void BikeTryMoveFastInDirection(u8 direction) +{ + struct ObjectEvent *playerObjEvent; + + playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (!BikeCanFaceDIrectionOnRail(direction, playerObjEvent->currentMetatileBehavior)) + { + BikeFaceDirection(playerObjEvent->movementDirection); + } + else + { + u8 collision = CheckNextTileForBikingCollision(direction); + + if (collision > COLLISION_NONE && collision <= COLLISION_ISOLATED_HORIZONTAL_RAIL) + { + if (collision == COLLISION_LEDGE_JUMP) + PlayerJumpLedge(direction); + else if (collision != COLLISION_STOP_SURFING && collision != COLLISION_LEDGE_JUMP && collision != COLLISION_PUSHED_BOULDER && collision != COLLISION_UNKNOWN_WARP_6C_6D_6E_6F) + PlayerOnBikeCollide(direction); + } + else + { + + if (collision == COLLISION_COUNT) + PlayerGoSpeed2(direction); + else if (PlayerIsMovingOnRockStairs(direction)) + PlayerGoSpeed2(direction); + else + PlayerRideWaterCurrent(direction); + } + } +} + +static void BikeLetGravityTakeTheWheel(UNUSED u8 v) +{ + u8 collision = CheckNextTileForBikingCollision(DIR_SOUTH); + + if (collision == COLLISION_NONE) + sub_805C164(DIR_SOUTH); + else if (collision == COLLISION_LEDGE_JUMP) + PlayerJumpLedge(DIR_SOUTH); +} + +static void BikeTryMoveInDirection(u8 direction) +{ + if (CheckNextTileForBikingCollision(direction) == COLLISION_NONE) + PlayerGoSpeed1(direction); +} + +static u8 CheckNextTileForBikingCollision(u8 direction) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + s16 x, y; + u8 metatileBehavior; + + x = playerObjEvent->currentCoords.x; + y = playerObjEvent->currentCoords.y; + MoveCoords(direction, &x, &y); + metatileBehavior = MapGridGetMetatileBehaviorAt(x, y); + return AdjustCollisionForBiking(playerObjEvent, x, y, direction, metatileBehavior); +} + +static u8 AdjustCollisionForBiking(struct ObjectEvent *playerObjEvent, s16 x, s16 y, u8 direction, u8 metatileBehavior) +{ + u8 retVal = CheckForObjectEventCollision(playerObjEvent, x, y, direction, metatileBehavior); + + if (retVal <= COLLISION_OBJECT_EVENT) + { + bool8 isCrackedIce = MetatileBehavior_IsCrackedIce(metatileBehavior); + if (isCrackedIce == TRUE) + return COLLISION_COUNT; + if (retVal == COLLISION_NONE && MetatileBehaviorForbidsBiking(metatileBehavior)) + retVal = COLLISION_IMPASSABLE; + } + return retVal; +} + +bool8 sub_80BD460(u8 r0) +{ + if (MetatileBehaviorForbidsBiking(r0)) + return TRUE; + if (gMapHeader.mapType != MAP_TYPE_INDOOR) + return FALSE; + else + return TRUE; +} + +bool32 IsRunningDisallowed(u8 metatileBehavior) +{ + if (!(gMapHeader.flags & MAP_ALLOW_RUN)) + return TRUE; + if (MetatileBehaviorForbidsBiking(metatileBehavior) != TRUE) + return FALSE; + else + return TRUE; +} + +static bool8 MetatileBehaviorForbidsBiking(u8 r4) +{ + if (MetatileBehavior_IsMB0A(r4)) + return TRUE; + if (!MetatileBehavior_ReturnFalse_9(r4)) + return FALSE; + if (PlayerGetZCoord() & 1) + return FALSE; + return TRUE; +} + +static bool8 BikeCanFaceDIrectionOnRail(u8 direction, u8 metatileBehavior) +{ + if (direction == DIR_EAST || direction == DIR_WEST) + { + if (MetatileBehavior_IsIsolatedVerticalRail(metatileBehavior) || MetatileBehavior_IsVerticalRail(metatileBehavior)) + return FALSE; + } + else + { + if (MetatileBehavior_IsIsolatedHorizontalRail(metatileBehavior) || MetatileBehavior_IsHorizontalRail(metatileBehavior)) + return FALSE; + } + return TRUE; +} + +bool8 MetatileAtPlayerPositionForbidsBiking(void) +{ + s16 x, y; + u8 metatileBehavior; + + if (!(gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_UNDERWATER | PLAYER_AVATAR_FLAG_SURFING))) + { + PlayerGetDestCoords(&x, &y); + metatileBehavior = MapGridGetMetatileBehaviorAt(x, y); + if (!MetatileBehaviorForbidsBiking(metatileBehavior)) + return FALSE; + } + return TRUE; +} + +bool8 player_should_look_direction_be_enforced_upon_movement(void) +{ + if (TestPlayerAvatarFlags(PLAYER_AVATAR_STATE_UNDERWATER)) + { + if (MetatileBehavior_IsBumpySlope(gObjectEvents[gPlayerAvatar.objectEventId].currentMetatileBehavior)) + return FALSE; + } + return TRUE; +} + +void StartTransitionToFlipBikeState(u8 flags) +{ + gBikeCameraAheadPanback = FALSE; + if (gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE)) + { + SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_ON_FOOT); + Overworld_ClearSavedMusic(); + Overworld_PlaySpecialMapMusic(); + } + else + { + SetPlayerAvatarTransitionFlags(flags); + if (Overworld_MusicCanOverrideMapMusic(MUS_CYCLING)) + { + Overworld_SetSavedMusic(MUS_CYCLING); + Overworld_ChangeMusicTo(MUS_CYCLING); + } + } +} + +void InitPlayerAvatarBikeState(u32 directionHistory, u32 abStartSelectHistory) +{ + u8 i; + + gPlayerAvatar.acroBikeState = ACRO_STATE_NORMAL; + gPlayerAvatar.newDirBackup = 0; + gPlayerAvatar.bikeFrameCounter = 0; + gPlayerAvatar.bikeSpeed = SPEED_STANDING; + gPlayerAvatar.directionHistory = directionHistory; + gPlayerAvatar.abStartSelectHistory = abStartSelectHistory; + gPlayerAvatar.lastSpinTile = 0; + for (i = 0; i < NELEMS(gPlayerAvatar.dirTimerHistory); ++i) + gPlayerAvatar.dirTimerHistory[i] = 0; +} + +void Bike_UpdateBikeCounterSpeed(u8 counter) +{ + gPlayerAvatar.bikeFrameCounter = counter; + gPlayerAvatar.bikeSpeed = counter + (gPlayerAvatar.bikeFrameCounter >> 1); +} + +static void sub_80BD664(void) +{ + gPlayerAvatar.bikeFrameCounter = 0; + gPlayerAvatar.bikeSpeed = SPEED_STANDING; +} + +s16 GetPlayerSpeed(void) +{ + s16 exp[] = { 1, 2, 4 }; + + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_MACH_BIKE) + return exp[gPlayerAvatar.bikeFrameCounter]; + else if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_ACRO_BIKE) + return 3; + else if (gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_SURFING | PLAYER_AVATAR_FLAG_WATERING)) + return 2; + else + return 1; +} + +void Bike_HandleBumpySlopeJump(void) +{ + s16 x, y; + u8 tileBehavior; + + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_ACRO_BIKE) + { + PlayerGetDestCoords(&x, &y); + tileBehavior = MapGridGetMetatileBehaviorAt(x, y); + if (MetatileBehavior_IsBumpySlope(tileBehavior)) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING; + nullsub_24(GetPlayerMovementDirection()); + } + } +} + +// R/S leftover + +// the struct below is used for checking button combinations of the last input so that the acro can potentially perform a side/turn jump. +// its possible that at some point Game Freak intended for the acro bike to have more complex tricks: but only the acro jump combinations can be seen in the final ROM. +struct BikeHistoryInputInfo +{ + u32 dirHistoryMatch; // the direction you need to press + u32 abStartSelectHistoryMatch; // the button you need to press + u32 dirHistoryMask; // mask applied so that way only the recent nybble (the recent input) is checked + u32 abStartSelectHistoryMask; // mask applied so that way only the recent nybble (the recent input) is checked + const u8 *dirTimerHistoryList; // list of timers to check for direction before the button+dir combination can be verified. + const u8 *abStartSelectHistoryList; // list of timers to check for buttons before the button+dir combination can be verified. + u32 direction; // direction to jump +}; + +// this is a list of timers to compare against later, terminated with 0. the only timer being compared against is 4 frames in this list. +static const u8 sAcroBikeJumpTimerList[] = {4, 0}; + +// this is a list of history inputs to do in order to do the check to retrieve a jump direction for acro bike. it seems to be an extensible list, so its possible that Game Freak may have intended for the Acro Bike to have more complex tricks at some point. The final list only has the acro jump. +static const struct BikeHistoryInputInfo sAcroBikeTricksList[] = +{ + // the 0xF is a mask performed with each byte of the array in order to perform the check on only the last entry of the history list, otherwise the check wouldn't work as there can be 0xF0 as opposed to 0x0F. + {DIR_SOUTH, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_SOUTH}, + {DIR_NORTH, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_NORTH}, + {DIR_WEST, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_WEST}, + {DIR_EAST, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_EAST}, +}; diff --git a/src/cable_club.c b/src/cable_club.c index bc41ca4f6..52856e3a3 100644 --- a/src/cable_club.c +++ b/src/cable_club.c @@ -402,7 +402,7 @@ static void Task_Linkup_6a(u8 taskId) if (gSpecialVar_Result == 1) { // Dumb trick required to match - if (gLinkType == LINKTYPE_0x4411) + if (gLinkType == LINKTYPE_BERRY_BLENDER_SETUP) *UnusedVarNeededToMatch += 0; DestroyLinkPlayerCountDisplayWindow(gTasks[taskId].data[5]); EnableBothScriptContexts(); @@ -493,9 +493,9 @@ void TryRecordMixLinkup(void) CreateLinkupTask(2, 4); } -void sub_8081128(void) +void TryContestLinkup(void) { - gLinkType = LINKTYPE_0x6601; + gLinkType = LINKTYPE_CONTEST_GMODE; gBattleTypeFlags = 0; CreateLinkupTask(4, 4); } @@ -724,7 +724,7 @@ static void sub_8081624(void) void CB2_ReturnFromCableClubBattle(void) { gBattleTypeFlags &= (u16)~BATTLE_TYPE_20; - sub_8055DB8(); + Overworld_ResetMapMusic(); LoadPlayerParty(); SavePlayerBag(); Special_UpdateTrainerFansAfterLinkBattle(); @@ -750,7 +750,7 @@ void CB2_ReturnFromCableClubBattle(void) } else { - gMain.savedCallback = c2_8056854; + gMain.savedCallback = CB2_ReturnToFieldFromMultiplayer; } SetMainCallback2(CB2_SetUpSaveAfterLinkBattle); } @@ -767,7 +767,7 @@ void CleanupLinkRoomState(void) void ExitLinkRoom(void) { - sub_8057F5C(); + QueueExitLinkRoomKey(); } static void Task_EnterCableClubSeat(u8 taskId) diff --git a/src/credits.c b/src/credits.c index 4d7bbd67b..58647f7b1 100644 --- a/src/credits.c +++ b/src/credits.c @@ -1,6 +1,7 @@ #include "global.h" #include "malloc.h" #include "bg.h" +#include "credits.h" #include "palette.h" #include "gpu_regs.h" #include "task.h" @@ -563,94 +564,81 @@ static const struct SpriteTemplate sGroundSpriteTemplate_Static = { }; static const struct CreditsOverworldCmd sOverworldCmd_Route23[] = { - { 0x00fe, MAP_GROUP(ROUTE23), MAP_NUM(ROUTE23) }, - { 0x000b, 0x006b, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(ROUTE23, 11, 107, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_ViridianCity[] = { - { 0x00fe, MAP_GROUP(VIRIDIAN_CITY), MAP_NUM(VIRIDIAN_CITY) }, - { 0x001e, 0x0022, 0x0001 }, - { 0x0000, 0xffff, 0x0500 }, // Scroll up - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(VIRIDIAN_CITY, 30, 34, 1), + CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_PewterCity[] = { - { 0x00fe, MAP_GROUP(PEWTER_CITY), MAP_NUM(PEWTER_CITY) }, - { 0x0014, 0x001a, 0x0001 }, - { 0x0000, 0xffff, 0x0500 }, // Scroll up - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(PEWTER_CITY, 20, 26, 1), + CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_CeruleanCity[] = { - { 0x00fe, MAP_GROUP(CERULEAN_CITY), MAP_NUM(CERULEAN_CITY) }, - { 0x0008, 0x0006, 0x0001 }, - { 0x0001, 0x0001, 0x0500 }, // Scroll right and down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(CERULEAN_CITY, 8, 6, 1), + CREDITSOVWLDSCROLL(1, 1, 0x0500), // Scroll right and down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_Route25[] = { - { 0x00fe, MAP_GROUP(ROUTE25), MAP_NUM(ROUTE25) }, - { 0x0019, 0x0006, 0x0001 }, - { 0x0001, 0x0000, 0x0500 }, // Scroll right - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(ROUTE25, 25, 6, 1), + CREDITSOVWLDSCROLL(1, 0, 0x0500), // Scroll right + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_VermilionCity[] = { - { 0x00fe, MAP_GROUP(VERMILION_CITY), MAP_NUM(VERMILION_CITY) }, - { 0x0009, 0x0007, 0x0001 }, - { 0x0001, 0x0001, 0x0500 }, // Scroll right and down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(VERMILION_CITY, 9, 7, 1), + CREDITSOVWLDSCROLL(1, 1, 0x0500), // Scroll right and down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_Route10[] = { - { 0x00fe, MAP_GROUP(ROUTE10), MAP_NUM(ROUTE10) }, - { 0x000b, 0x0044, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(ROUTE10, 11, 68, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_CeladonCity[] = { - { 0x00fe, MAP_GROUP(CELADON_CITY), MAP_NUM(CELADON_CITY) }, - { 0x0030, 0x0010, 0x0001 }, - { 0xffff, 0x0000, 0x0500 }, // Scroll left - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(CELADON_CITY, 48, 16, 1), + CREDITSOVWLDSCROLL(-1, 0, 0x0500), // Scroll left + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_SaffronCity[] = { - { 0x00fe, MAP_GROUP(SAFFRON_CITY), MAP_NUM(SAFFRON_CITY) }, - { 0x0027, 0x0005, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(SAFFRON_CITY, 39, 5, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_Route17[] = { - { 0x00fe, MAP_GROUP(ROUTE17), MAP_NUM(ROUTE17) }, - { 0x0007, 0x002b, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(ROUTE17, 7, 43, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_FuchsiaCity[] = { - { 0x00fe, MAP_GROUP(FUCHSIA_CITY), MAP_NUM(FUCHSIA_CITY) }, - { 0x001c, 0x0005, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(FUCHSIA_CITY, 28, 5, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_CinnabarIsland[] = { - { 0x00fe, MAP_GROUP(CINNABAR_ISLAND), MAP_NUM(CINNABAR_ISLAND) }, - { 0x000d, 0x0011, 0x0001 }, - { 0x0000, 0xffff, 0x0500 }, // Scroll up - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(CINNABAR_ISLAND, 13, 17, 1), + CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_Route21[] = { - { 0x00fe, MAP_GROUP(ROUTE21_NORTH), MAP_NUM(ROUTE21_NORTH) }, - { 0x0008, 0x0014, 0x0001 }, - { 0x0000, 0xffff, 0x0500 }, // Scroll up - { 0x00fd, 0x00fd, 0x00fd }, + CREDITSOVWLDLOADMAP(ROUTE21_NORTH, 8, 20, 1), + CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up + CREDITSOVWLDEND, }; static const struct CreditsOverworldCmd *const sOverworldMapScenes[] = { @@ -750,7 +738,7 @@ static void CB2_Credits(void) sCreditsMgr->unk_1D++; break; case 2: - FlagClear(FLAG_SPECIAL_FLAG_0x4000); + FlagClear(FLAG_DONT_SHOW_MAP_NAME_POPUP); gDisableMapMusicChangeOnMapLoad = MUSIC_DISABLE_OFF; Free(sCreditsMgr); SoftReset(RESET_ALL); @@ -797,7 +785,7 @@ static bool32 DoOverworldMapScrollScene(UNUSED u8 unused) switch (sCreditsMgr->subseqno) { case 0: - FlagSet(FLAG_SPECIAL_FLAG_0x4000); + FlagSet(FLAG_DONT_SHOW_MAP_NAME_POPUP); gDisableMapMusicChangeOnMapLoad = MUSIC_DISABLE_KEEP; sCreditsMgr->ovwldseqno = 0; sCreditsMgr->subseqno++; diff --git a/src/data/decoration/description.h b/src/data/decoration/description.h new file mode 100644 index 000000000..b56f43eb6 --- /dev/null +++ b/src/data/decoration/description.h @@ -0,0 +1,573 @@ +const u8 DecorDesc_SMALL_DESK[] = _( + "A small desk built\n" + "for one."); + +const u8 DecorDesc_POKEMON_DESK[] = _( + "A small desk built in\n" + "the shape of a POKé\n" + "BALL."); + +const u8 DecorDesc_HEAVY_DESK[] = _( + "A large desk made\n" + "of steel. Put some\n" + "decorations on it."); + +const u8 DecorDesc_RAGGED_DESK[] = _( + "A large desk made\n" + "of wood. Put some\n" + "decorations on it."); + +const u8 DecorDesc_COMFORT_DESK[] = _( + "A large desk made\n" + "of leaves. Put some\n" + "decorations on it."); + +const u8 DecorDesc_PRETTY_DESK[] = _( + "A huge desk made\n" + "of glass. Holds lots\n" + "of decorations."); + +const u8 DecorDesc_BRICK_DESK[] = _( + "A huge desk made\n" + "of brick. Holds lots\n" + "of decorations."); + +const u8 DecorDesc_CAMP_DESK[] = _( + "A huge desk made\n" + "of logs. Put lots of\n" + "decorations on it."); + +const u8 DecorDesc_HARD_DESK[] = _( + "A huge desk made\n" + "of rocks. Holds\n" + "many decorations."); + +const u8 DecorDesc_SMALL_CHAIR[] = _( + "A small chair made\n" + "for one."); + +const u8 DecorDesc_POKEMON_CHAIR[] = _( + "A small chair built\n" + "in the shape of a\n" + "POKé BALL."); + +const u8 DecorDesc_HEAVY_CHAIR[] = _( + "A small chair made\n" + "of steel."); + +const u8 DecorDesc_PRETTY_CHAIR[] = _( + "A small chair made\n" + "of glass."); + +const u8 DecorDesc_COMFORT_CHAIR[] = _( + "A small chair made\n" + "of leaves."); + +const u8 DecorDesc_RAGGED_CHAIR[] = _( + "A small chair made\n" + "of wood."); + +const u8 DecorDesc_BRICK_CHAIR[] = _( + "A small chair made\n" + "of brick."); + +const u8 DecorDesc_CAMP_CHAIR[] = _( + "A small chair made\n" + "of logs."); + +const u8 DecorDesc_HARD_CHAIR[] = _( + "A small chair made\n" + "of rock."); + +const u8 DecorDesc_RED_PLANT[] = _( + "A vivid red potted\n" + "plant."); + +const u8 DecorDesc_TROPICAL_PLANT[] = _( + "A flowering tropical\n" + "plant in a pot."); + +const u8 DecorDesc_PRETTY_FLOWERS[] = _( + "A pot of cute\n" + "flowers."); + +const u8 DecorDesc_COLORFUL_PLANT[] = _( + "A large pot with\n" + "many colorful\n" + "flowers."); + +const u8 DecorDesc_BIG_PLANT[] = _( + "A large, umbrella-\n" + "shaped plant in a\n" + "big pot."); + +const u8 DecorDesc_GORGEOUS_PLANT[] = _( + "A large, impressive\n" + "plant in a big pot."); + +const u8 DecorDesc_RED_BRICK[] = _( + "A red-colored brick.\n" + "Decorations can be\n" + "placed on top."); + +const u8 DecorDesc_YELLOW_BRICK[] = _( + "A yellow-colored\n" + "brick. Put some\n" + "decorations on top."); + +const u8 DecorDesc_BLUE_BRICK[] = _( + "A blue-colored\n" + "brick. Put some\n" + "decorations on top."); + +const u8 DecorDesc_RED_BALLOON[] = _( + "A red balloon filled\n" + "with water. Bursts\n" + "if stepped on."); + +const u8 DecorDesc_BLUE_BALLOON[] = _( + "A blue balloon filled\n" + "with water. Bursts\n" + "if stepped on."); + +const u8 DecorDesc_YELLOW_BALLOON[] = _( + "A yellow balloon\n" + "filled with water.\n" + "Pops if stepped on."); + +const u8 DecorDesc_RED_TENT[] = _( + "A large red tent.\n" + "You can hide inside\n" + "it."); + +const u8 DecorDesc_BLUE_TENT[] = _( + "A large blue tent.\n" + "You can hide inside\n" + "it."); + +const u8 DecorDesc_SOLID_BOARD[] = _( + "Place over a hole to\n" + "cross to the other\n" + "side."); + +const u8 DecorDesc_SLIDE[] = _( + "Use to slide down\n" + "from the platform."); + +const u8 DecorDesc_FENCE_LENGTH[] = _( + "A small fence that\n" + "blocks passage."); + +const u8 DecorDesc_FENCE_WIDTH[] = _( + "A small fence that\n" + "blocks passage."); + +const u8 DecorDesc_TIRE[] = _( + "An old large tire.\n" + "Decorations can be\n" + "placed on top."); + +const u8 DecorDesc_STAND[] = _( + "A large pedestal\n" + "with steps."); + +const u8 DecorDesc_MUD_BALL[] = _( + "A large ball of mud.\n" + "Crumbles if stepped\n" + "on."); + +const u8 DecorDesc_BREAKABLE_DOOR[] = _( + "A weird door that\n" + "people can walk\n" + "right through."); + +const u8 DecorDesc_SAND_ORNAMENT[] = _( + "An ornament made\n" + "of sand. Crumbles if\n" + "touched."); + +const u8 DecorDesc_SILVER_SHIELD[] = _( + "Awarded for 50\n" + "straight wins at\n" + "the BATTLE TOWER."); + +const u8 DecorDesc_GOLD_SHIELD[] = _( + "Awarded for 100\n" + "straight wins at\n" + "the BATTLE TOWER."); + +const u8 DecorDesc_GLASS_ORNAMENT[] = _( + "A glass replica of\n" + "a famous sculpture\n" + "at the ART MUSEUM."); + +const u8 DecorDesc_TV[] = _( + "A small, gray-\n" + "colored toy TV."); + +const u8 DecorDesc_ROUND_TV[] = _( + "A toy TV modeled\n" + "in the image of a\n" + "SEEDOT."); + +const u8 DecorDesc_CUTE_TV[] = _( + "A toy TV modeled\n" + "in the image of a\n" + "SKITTY."); + +const u8 DecorDesc_GLITTER_MAT[] = _( + "An odd mat that\n" + "glitters if stepped\n" + "on."); + +const u8 DecorDesc_JUMP_MAT[] = _( + "A trick mat that\n" + "jumps when it is\n" + "stepped on."); + +const u8 DecorDesc_SPIN_MAT[] = _( + "A trick mat that\n" + "spins around when\n" + "stepped on."); + +const u8 DecorDesc_C_LOW_NOTE_MAT[] = _( + "A mat that plays\n" + "a low C note when\n" + "stepped on."); + +const u8 DecorDesc_D_NOTE_MAT[] = _( + "A mat that plays\n" + "a D note when\n" + "stepped on."); + +const u8 DecorDesc_E_NOTE_MAT[] = _( + "A mat that plays\n" + "an E note when\n" + "stepped on."); + +const u8 DecorDesc_F_NOTE_MAT[] = _( + "A mat that plays\n" + "an F note when\n" + "stepped on."); + +const u8 DecorDesc_G_NOTE_MAT[] = _( + "A mat that plays\n" + "a G note when\n" + "stepped on."); + +const u8 DecorDesc_A_NOTE_MAT[] = _( + "A mat that plays\n" + "an A note when\n" + "stepped on."); + +const u8 DecorDesc_B_NOTE_MAT[] = _( + "A mat that plays\n" + "a B note when\n" + "stepped on."); + +const u8 DecorDesc_C_HIGH_NOTE_MAT[] = _( + "A mat that plays\n" + "a high C note when\n" + "stepped on."); + +const u8 DecorDesc_SURF_MAT[] = _( + "A mat designed with\n" + "a SURF image.\n" + "Put items on top."); + +const u8 DecorDesc_THUNDER_MAT[] = _( + "A mat designed with\n" + "a THUNDER image.\n" + "Put items on top."); + +const u8 DecorDesc_FIRE_BLAST_MAT[] = _( + "A mat designed with\n" + "a FIRE BLAST image.\n" + "Put items on top."); + +const u8 DecorDesc_POWDER_SNOW_MAT[] = _( + "A mat with a POWDER\n" + "SNOW image design.\n" + "Put items on top."); + +const u8 DecorDesc_ATTRACT_MAT[] = _( + "A mat designed with\n" + "an ATTRACT image.\n" + "Put items on top."); + +const u8 DecorDesc_FISSURE_MAT[] = _( + "A mat designed with\n" + "a FISSURE image.\n" + "Put items on top."); + +const u8 DecorDesc_SPIKES_MAT[] = _( + "A mat designed with\n" + "a SPIKES image.\n" + "Put items on top."); + +const u8 DecorDesc_BALL_POSTER[] = _( + "A small poster\n" + "printed with POKé\n" + "BALLS."); + +const u8 DecorDesc_GREEN_POSTER[] = _( + "A small poster with\n" + "a TREECKO print."); + +const u8 DecorDesc_RED_POSTER[] = _( + "A small poster with\n" + "a TORCHIC print."); + +const u8 DecorDesc_BLUE_POSTER[] = _( + "A small poster with\n" + "a MUDKIP print."); + +const u8 DecorDesc_CUTE_POSTER[] = _( + "A small poster with\n" + "an AZURILL print."); + +const u8 DecorDesc_PIKA_POSTER[] = _( + "A large poster with\n" + "a PIKACHU and\n" + "PICHU print."); + +const u8 DecorDesc_LONG_POSTER[] = _( + "A large poster with\n" + "a SEVIPER print."); + +const u8 DecorDesc_SEA_POSTER[] = _( + "A large poster with\n" + "a RELICANTH print."); + +const u8 DecorDesc_SKY_POSTER[] = _( + "A large poster with\n" + "a WINGULL print."); + +const u8 DecorDesc_KISS_POSTER[] = _( + "A large poster with\n" + "a SMOOCHUM print."); + +const u8 DecorDesc_PICHU_DOLL[] = _( + "A PICHU doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_PIKACHU_DOLL[] = _( + "A PIKACHU doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_MARILL_DOLL[] = _( + "A MARILL doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_TOGEPI_DOLL[] = _( + "A TOGEPI doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_CYNDAQUIL_DOLL[] = _( + "A CYNDAQUIL doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_CHIKORITA_DOLL[] = _( + "A CHIKORITA doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_TOTODILE_DOLL[] = _( + "A TOTODILE doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_JIGGLYPUFF_DOLL[] = _( + "A JIGGLYPUFF doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_MEOWTH_DOLL[] = _( + "A MEOWTH doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_CLEFAIRY_DOLL[] = _( + "A CLEFAIRY doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_DITTO_DOLL[] = _( + "A DITTO doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_SMOOCHUM_DOLL[] = _( + "A SMOOCHUM doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_TREECKO_DOLL[] = _( + "A TREECKO doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_TORCHIC_DOLL[] = _( + "A TORCHIC doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_MUDKIP_DOLL[] = _( + "A MUDKIP doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_DUSKULL_DOLL[] = _( + "A DUSKULL doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_WYNAUT_DOLL[] = _( + "A WYNAUT doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_BALTOY_DOLL[] = _( + "A BALTOY doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_KECLEON_DOLL[] = _( + "A KECLEON doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_AZURILL_DOLL[] = _( + "An AZURILL doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_SKITTY_DOLL[] = _( + "A SKITTY doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_SWABLU_DOLL[] = _( + "A SWABLU doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_GULPIN_DOLL[] = _( + "A GULPIN doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_LOTAD_DOLL[] = _( + "A LOTAD doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_SEEDOT_DOLL[] = _( + "A SEEDOT doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_PIKA_CUSHION[] = _( + "A PIKACHU cushion.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_ROUND_CUSHION[] = _( + "A MARILL cushion.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_KISS_CUSHION[] = _( + "A SMOOCHUM\n" + "cushion. Place it on\n" + "a mat or a desk."); + +const u8 DecorDesc_ZIGZAG_CUSHION[] = _( + "A ZIGZAGOON\n" + "cushion. Place it on\n" + "a mat or a desk."); + +const u8 DecorDesc_SPIN_CUSHION[] = _( + "A SPINDA cushion.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_DIAMOND_CUSHION[] = _( + "A SABLEYE cushion.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_BALL_CUSHION[] = _( + "A BALL cushion.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_GRASS_CUSHION[] = _( + "A grass-mark\n" + "cushion. Place it on\n" + "a mat or a desk."); + +const u8 DecorDesc_FIRE_CUSHION[] = _( + "A fire-mark\n" + "cushion. Place it on\n" + "a mat or a desk."); + +const u8 DecorDesc_WATER_CUSHION[] = _( + "A water-mark\n" + "cushion. Place it on\n" + "a mat or a desk."); + +const u8 DecorDesc_SNORLAX_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_RHYDON_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_LAPRAS_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_VENUSAUR_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_CHARIZARD_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_BLASTOISE_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_WAILMER_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_REGIROCK_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_REGICE_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); + +const u8 DecorDesc_REGISTEEL_DOLL[] = _( + "A large doll.\n" + "Place it on a mat\n" + "or a desk."); diff --git a/src/data/decoration/header.h b/src/data/decoration/header.h new file mode 100644 index 000000000..55458c7a3 --- /dev/null +++ b/src/data/decoration/header.h @@ -0,0 +1,1091 @@ +const struct Decoration gDecorations[] = { + { + DECOR_NONE, + _("SMALL DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x1, + DECORCAT_DESK, + 0, + DecorDesc_SMALL_DESK, + DecorGfx_SMALL_DESK + }, { + DECOR_SMALL_DESK, + _("SMALL DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x1, + DECORCAT_DESK, + 3000, + DecorDesc_SMALL_DESK, + DecorGfx_SMALL_DESK + }, { + DECOR_POKEMON_DESK, + _("POKéMON DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x1, + DECORCAT_DESK, + 3000, + DecorDesc_POKEMON_DESK, + DecorGfx_POKEMON_DESK + }, { + DECOR_HEAVY_DESK, + _("HEAVY DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_3x2, + DECORCAT_DESK, + 6000, + DecorDesc_HEAVY_DESK, + DecorGfx_HEAVY_DESK + }, { + DECOR_RAGGED_DESK, + _("RAGGED DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_3x2, + DECORCAT_DESK, + 6000, + DecorDesc_RAGGED_DESK, + DecorGfx_RAGGED_DESK + }, { + DECOR_COMFORT_DESK, + _("COMFORT DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_3x2, + DECORCAT_DESK, + 6000, + DecorDesc_COMFORT_DESK, + DecorGfx_COMFORT_DESK + }, { + DECOR_PRETTY_DESK, + _("PRETTY DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_3x3, + DECORCAT_DESK, + 9000, + DecorDesc_PRETTY_DESK, + DecorGfx_PRETTY_DESK + }, { + DECOR_BRICK_DESK, + _("BRICK DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_3x3, + DECORCAT_DESK, + 9000, + DecorDesc_BRICK_DESK, + DecorGfx_BRICK_DESK + }, { + DECOR_CAMP_DESK, + _("CAMP DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_3x3, + DECORCAT_DESK, + 9000, + DecorDesc_CAMP_DESK, + DecorGfx_CAMP_DESK + }, { + DECOR_HARD_DESK, + _("HARD DESK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_3x3, + DECORCAT_DESK, + 9000, + DecorDesc_HARD_DESK, + DecorGfx_HARD_DESK + }, { + DECOR_SMALL_CHAIR, + _("SMALL CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_SMALL_CHAIR, + DecorGfx_SMALL_CHAIR + }, { + DECOR_POKEMON_CHAIR, + _("POKéMON CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_POKEMON_CHAIR, + DecorGfx_POKEMON_CHAIR + }, { + DECOR_HEAVY_CHAIR, + _("HEAVY CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_HEAVY_CHAIR, + DecorGfx_HEAVY_CHAIR + }, { + DECOR_PRETTY_CHAIR, + _("PRETTY CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_PRETTY_CHAIR, + DecorGfx_PRETTY_CHAIR + }, { + DECOR_COMFORT_CHAIR, + _("COMFORT CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_COMFORT_CHAIR, + DecorGfx_COMFORT_CHAIR + }, { + DECOR_RAGGED_CHAIR, + _("RAGGED CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_RAGGED_CHAIR, + DecorGfx_RAGGED_CHAIR + }, { + DECOR_BRICK_CHAIR, + _("BRICK CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_BRICK_CHAIR, + DecorGfx_BRICK_CHAIR + }, { + DECOR_CAMP_CHAIR, + _("CAMP CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_CAMP_CHAIR, + DecorGfx_CAMP_CHAIR + }, { + DECOR_HARD_CHAIR, + _("HARD CHAIR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_CHAIR, + 2000, + DecorDesc_HARD_CHAIR, + DecorGfx_HARD_CHAIR + }, { + DECOR_RED_PLANT, + _("RED PLANT"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_1x2, + DECORCAT_PLANT, + 3000, + DecorDesc_RED_PLANT, + DecorGfx_RED_PLANT + }, { + DECOR_TROPICAL_PLANT, + _("TROPICAL PLANT"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_1x2, + DECORCAT_PLANT, + 3000, + DecorDesc_TROPICAL_PLANT, + DecorGfx_TROPICAL_PLANT + }, { + DECOR_PRETTY_FLOWERS, + _("PRETTY FLOWERS"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_1x2, + DECORCAT_PLANT, + 3000, + DecorDesc_PRETTY_FLOWERS, + DecorGfx_PRETTY_FLOWERS + }, { + DECOR_COLORFUL_PLANT, + _("COLORFUL PLANT"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_2x2, + DECORCAT_PLANT, + 5000, + DecorDesc_COLORFUL_PLANT, + DecorGfx_COLORFUL_PLANT + }, { + DECOR_BIG_PLANT, + _("BIG PLANT"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_2x2, + DECORCAT_PLANT, + 5000, + DecorDesc_BIG_PLANT, + DecorGfx_BIG_PLANT + }, { + DECOR_GORGEOUS_PLANT, + _("GORGEOUS PLANT"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_2x2, + DECORCAT_PLANT, + 5000, + DecorDesc_GORGEOUS_PLANT, + DecorGfx_GORGEOUS_PLANT + }, { + DECOR_RED_BRICK, + _("RED BRICK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 500, + DecorDesc_RED_BRICK, + DecorGfx_RED_BRICK + }, { + DECOR_YELLOW_BRICK, + _("YELLOW BRICK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 500, + DecorDesc_YELLOW_BRICK, + DecorGfx_YELLOW_BRICK + }, { + DECOR_BLUE_BRICK, + _("BLUE BRICK"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 500, + DecorDesc_BLUE_BRICK, + DecorGfx_BLUE_BRICK + }, { + DECOR_RED_BALLOON, + _("RED BALLOON"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 500, + DecorDesc_RED_BALLOON, + DecorGfx_RED_BALLOON + }, { + DECOR_BLUE_BALLOON, + _("BLUE BALLOON"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 500, + DecorDesc_BLUE_BALLOON, + DecorGfx_BLUE_BALLOON + }, { + DECOR_YELLOW_BALLOON, + _("YELLOW BALLOON"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 500, + DecorDesc_YELLOW_BALLOON, + DecorGfx_YELLOW_BALLOON + }, { + DECOR_RED_TENT, + _("RED TENT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_ORNAMENT, + 10000, + DecorDesc_RED_TENT, + DecorGfx_RED_TENT + }, { + DECOR_BLUE_TENT, + _("BLUE TENT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_ORNAMENT, + 10000, + DecorDesc_BLUE_TENT, + DecorGfx_BLUE_TENT + }, { + DECOR_SOLID_BOARD, + _("SOLID BOARD"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 3000, + DecorDesc_SOLID_BOARD, + DecorGfx_SOLID_BOARD + }, { + DECOR_SLIDE, + _("SLIDE"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_2x4, + DECORCAT_ORNAMENT, + 8000, + DecorDesc_SLIDE, + DecorGfx_SLIDE + }, { + DECOR_FENCE_LENGTH, + _("FENCE LENGTH"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 500, + DecorDesc_FENCE_LENGTH, + DecorGfx_FENCE_LENGTH + }, { + DECOR_FENCE_WIDTH, + _("FENCE WIDTH"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 500, + DecorDesc_FENCE_WIDTH, + DecorGfx_FENCE_WIDTH + }, { + DECOR_TIRE, + _("TIRE"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_2x2, + DECORCAT_ORNAMENT, + 800, + DecorDesc_TIRE, + DecorGfx_TIRE + }, { + DECOR_STAND, + _("STAND"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_4x2, + DECORCAT_ORNAMENT, + 7000, + DecorDesc_STAND, + DecorGfx_STAND + }, { + DECOR_MUD_BALL, + _("MUD BALL"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 200, + DecorDesc_MUD_BALL, + DecorGfx_MUD_BALL + }, { + DECOR_BREAKABLE_DOOR, + _("BREAKABLE DOOR"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 3000, + DecorDesc_BREAKABLE_DOOR, + DecorGfx_BREAKABLE_DOOR + }, { + DECOR_SAND_ORNAMENT, + _("SAND ORNAMENT"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 3000, + DecorDesc_SAND_ORNAMENT, + DecorGfx_SAND_ORNAMENT + }, { + DECOR_SILVER_SHIELD, + _("SILVER SHIELD"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 0, + DecorDesc_SILVER_SHIELD, + DecorGfx_SILVER_SHIELD + }, { + DECOR_GOLD_SHIELD, + _("GOLD SHIELD"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 0, + DecorDesc_GOLD_SHIELD, + DecorGfx_GOLD_SHIELD + }, { + DECOR_GLASS_ORNAMENT, + _("GLASS ORNAMENT"), + DECORPERM_BEHIND_FLOOR, + DECORSHAPE_1x2, + DECORCAT_ORNAMENT, + 0, + DecorDesc_GLASS_ORNAMENT, + DecorGfx_GLASS_ORNAMENT + }, { + DECOR_TV, + _("TV"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 3000, + DecorDesc_TV, + DecorGfx_TV + }, { + DECOR_ROUND_TV, + _("ROUND TV"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 4000, + DecorDesc_ROUND_TV, + DecorGfx_ROUND_TV + }, { + DECOR_CUTE_TV, + _("CUTE TV"), + DECORPERM_SOLID_FLOOR, + DECORSHAPE_1x1, + DECORCAT_ORNAMENT, + 4000, + DecorDesc_CUTE_TV, + DecorGfx_CUTE_TV + }, { + DECOR_GLITTER_MAT, + _("GLITTER MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 2000, + DecorDesc_GLITTER_MAT, + DecorGfx_GLITTER_MAT + }, { + DECOR_JUMP_MAT, + _("JUMP MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 2000, + DecorDesc_JUMP_MAT, + DecorGfx_JUMP_MAT + }, { + DECOR_SPIN_MAT, + _("SPIN MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 2000, + DecorDesc_SPIN_MAT, + DecorGfx_SPIN_MAT + }, { + DECOR_C_LOW_NOTE_MAT, + _("C Low NOTE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 500, + DecorDesc_C_LOW_NOTE_MAT, + DecorGfx_C_LOW_NOTE_MAT + }, { + DECOR_D_NOTE_MAT, + _("D NOTE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 500, + DecorDesc_D_NOTE_MAT, + DecorGfx_D_NOTE_MAT + }, { + DECOR_E_NOTE_MAT, + _("E NOTE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 500, + DecorDesc_E_NOTE_MAT, + DecorGfx_E_NOTE_MAT + }, { + DECOR_F_NOTE_MAT, + _("F NOTE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 500, + DecorDesc_F_NOTE_MAT, + DecorGfx_F_NOTE_MAT + }, { + DECOR_G_NOTE_MAT, + _("G NOTE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 500, + DecorDesc_G_NOTE_MAT, + DecorGfx_G_NOTE_MAT + }, { + DECOR_A_NOTE_MAT, + _("A NOTE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 500, + DecorDesc_A_NOTE_MAT, + DecorGfx_A_NOTE_MAT + }, { + DECOR_B_NOTE_MAT, + _("B NOTE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 500, + DecorDesc_B_NOTE_MAT, + DecorGfx_B_NOTE_MAT + }, { + DECOR_C_HIGH_NOTE_MAT, + _("C High NOTE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_1x1, + DECORCAT_MAT, + 500, + DecorDesc_C_HIGH_NOTE_MAT, + DecorGfx_C_HIGH_NOTE_MAT + }, { + DECOR_SURF_MAT, + _("SURF MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_MAT, + 4000, + DecorDesc_SURF_MAT, + DecorGfx_SURF_MAT + }, { + DECOR_THUNDER_MAT, + _("THUNDER MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_MAT, + 4000, + DecorDesc_THUNDER_MAT, + DecorGfx_THUNDER_MAT + }, { + DECOR_FIRE_BLAST_MAT, + _("FIRE BLAST MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_MAT, + 4000, + DecorDesc_FIRE_BLAST_MAT, + DecorGfx_FIRE_BLAST_MAT + }, { + DECOR_POWDER_SNOW_MAT, + _("POWDER SNOW MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_MAT, + 4000, + DecorDesc_POWDER_SNOW_MAT, + DecorGfx_POWDER_SNOW_MAT + }, { + DECOR_ATTRACT_MAT, + _("ATTRACT MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_MAT, + 4000, + DecorDesc_ATTRACT_MAT, + DecorGfx_ATTRACT_MAT + }, { + DECOR_FISSURE_MAT, + _("FISSURE MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_MAT, + 4000, + DecorDesc_FISSURE_MAT, + DecorGfx_FISSURE_MAT + }, { + DECOR_SPIKES_MAT, + _("SPIKES MAT"), + DECORPERM_PASS_FLOOR, + DECORSHAPE_3x3, + DECORCAT_MAT, + 4000, + DecorDesc_SPIKES_MAT, + DecorGfx_SPIKES_MAT + }, { + DECOR_BALL_POSTER, + _("BALL POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_1x1, + DECORCAT_POSTER, + 1000, + DecorDesc_BALL_POSTER, + DecorGfx_BALL_POSTER + }, { + DECOR_GREEN_POSTER, + _("GREEN POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_1x1, + DECORCAT_POSTER, + 1000, + DecorDesc_GREEN_POSTER, + DecorGfx_GREEN_POSTER + }, { + DECOR_RED_POSTER, + _("RED POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_1x1, + DECORCAT_POSTER, + 1000, + DecorDesc_RED_POSTER, + DecorGfx_RED_POSTER + }, { + DECOR_BLUE_POSTER, + _("BLUE POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_1x1, + DECORCAT_POSTER, + 1000, + DecorDesc_BLUE_POSTER, + DecorGfx_BLUE_POSTER + }, { + DECOR_CUTE_POSTER, + _("CUTE POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_1x1, + DECORCAT_POSTER, + 1000, + DecorDesc_CUTE_POSTER, + DecorGfx_CUTE_POSTER + }, { + DECOR_PIKA_POSTER, + _("PIKA POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_2x1, + DECORCAT_POSTER, + 1500, + DecorDesc_PIKA_POSTER, + DecorGfx_PIKA_POSTER + }, { + DECOR_LONG_POSTER, + _("LONG POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_2x1, + DECORCAT_POSTER, + 1500, + DecorDesc_LONG_POSTER, + DecorGfx_LONG_POSTER + }, { + DECOR_SEA_POSTER, + _("SEA POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_2x1, + DECORCAT_POSTER, + 1500, + DecorDesc_SEA_POSTER, + DecorGfx_SEA_POSTER + }, { + DECOR_SKY_POSTER, + _("SKY POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_2x1, + DECORCAT_POSTER, + 1500, + DecorDesc_SKY_POSTER, + DecorGfx_SKY_POSTER + }, { + DECOR_KISS_POSTER, + _("KISS POSTER"), + DECORPERM_NA_WALL, + DECORSHAPE_2x1, + DECORCAT_POSTER, + 1500, + DecorDesc_KISS_POSTER, + DecorGfx_KISS_POSTER + }, { + DECOR_PICHU_DOLL, + _("PICHU DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_PICHU_DOLL, + DecorGfx_PICHU_DOLL + }, { + DECOR_PIKACHU_DOLL, + _("PIKACHU DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_PIKACHU_DOLL, + DecorGfx_PIKACHU_DOLL + }, { + DECOR_MARILL_DOLL, + _("MARILL DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_MARILL_DOLL, + DecorGfx_MARILL_DOLL + }, { + DECOR_TOGEPI_DOLL, + _("TOGEPI DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_TOGEPI_DOLL, + DecorGfx_TOGEPI_DOLL + }, { + DECOR_CYNDAQUIL_DOLL, + _("CYNDAQUIL DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_CYNDAQUIL_DOLL, + DecorGfx_CYNDAQUIL_DOLL + }, { + DECOR_CHIKORITA_DOLL, + _("CHIKORITA DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_CHIKORITA_DOLL, + DecorGfx_CHIKORITA_DOLL + }, { + DECOR_TOTODILE_DOLL, + _("TOTODILE DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_TOTODILE_DOLL, + DecorGfx_TOTODILE_DOLL + }, { + DECOR_JIGGLYPUFF_DOLL, + _("JIGGLYPUFF DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_JIGGLYPUFF_DOLL, + DecorGfx_JIGGLYPUFF_DOLL + }, { + DECOR_MEOWTH_DOLL, + _("MEOWTH DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_MEOWTH_DOLL, + DecorGfx_MEOWTH_DOLL + }, { + DECOR_CLEFAIRY_DOLL, + _("CLEFAIRY DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_CLEFAIRY_DOLL, + DecorGfx_CLEFAIRY_DOLL + }, { + DECOR_DITTO_DOLL, + _("DITTO DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_DITTO_DOLL, + DecorGfx_DITTO_DOLL + }, { + DECOR_SMOOCHUM_DOLL, + _("SMOOCHUM DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_SMOOCHUM_DOLL, + DecorGfx_SMOOCHUM_DOLL + }, { + DECOR_TREECKO_DOLL, + _("TREECKO DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_TREECKO_DOLL, + DecorGfx_TREECKO_DOLL + }, { + DECOR_TORCHIC_DOLL, + _("TORCHIC DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_TORCHIC_DOLL, + DecorGfx_TORCHIC_DOLL + }, { + DECOR_MUDKIP_DOLL, + _("MUDKIP DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_MUDKIP_DOLL, + DecorGfx_MUDKIP_DOLL + }, { + DECOR_DUSKULL_DOLL, + _("DUSKULL DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_DUSKULL_DOLL, + DecorGfx_DUSKULL_DOLL + }, { + DECOR_WYNAUT_DOLL, + _("WYNAUT DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_WYNAUT_DOLL, + DecorGfx_WYNAUT_DOLL + }, { + DECOR_BALTOY_DOLL, + _("BALTOY DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_BALTOY_DOLL, + DecorGfx_BALTOY_DOLL + }, { + DECOR_KECLEON_DOLL, + _("KECLEON DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_KECLEON_DOLL, + DecorGfx_KECLEON_DOLL + }, { + DECOR_AZURILL_DOLL, + _("AZURILL DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_AZURILL_DOLL, + DecorGfx_AZURILL_DOLL + }, { + DECOR_SKITTY_DOLL, + _("SKITTY DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_SKITTY_DOLL, + DecorGfx_SKITTY_DOLL + }, { + DECOR_SWABLU_DOLL, + _("SWABLU DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_SWABLU_DOLL, + DecorGfx_SWABLU_DOLL + }, { + DECOR_GULPIN_DOLL, + _("GULPIN DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_GULPIN_DOLL, + DecorGfx_GULPIN_DOLL + }, { + DECOR_LOTAD_DOLL, + _("LOTAD DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_LOTAD_DOLL, + DecorGfx_LOTAD_DOLL + }, { + DECOR_SEEDOT_DOLL, + _("SEEDOT DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_DOLL, + 3000, + DecorDesc_SEEDOT_DOLL, + DecorGfx_SEEDOT_DOLL + }, { + DECOR_PIKA_CUSHION, + _("PIKA CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_PIKA_CUSHION, + DecorGfx_PIKA_CUSHION + }, { + DECOR_ROUND_CUSHION, + _("ROUND CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_ROUND_CUSHION, + DecorGfx_ROUND_CUSHION + }, { + DECOR_KISS_CUSHION, + _("KISS CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_KISS_CUSHION, + DecorGfx_KISS_CUSHION + }, { + DECOR_ZIGZAG_CUSHION, + _("ZIGZAG CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_ZIGZAG_CUSHION, + DecorGfx_ZIGZAG_CUSHION + }, { + DECOR_SPIN_CUSHION, + _("SPIN CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_SPIN_CUSHION, + DecorGfx_SPIN_CUSHION + }, { + DECOR_DIAMOND_CUSHION, + _("DIAMOND CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_DIAMOND_CUSHION, + DecorGfx_DIAMOND_CUSHION + }, { + DECOR_BALL_CUSHION, + _("BALL CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_BALL_CUSHION, + DecorGfx_BALL_CUSHION + }, { + DECOR_GRASS_CUSHION, + _("GRASS CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_GRASS_CUSHION, + DecorGfx_GRASS_CUSHION + }, { + DECOR_FIRE_CUSHION, + _("FIRE CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_FIRE_CUSHION, + DecorGfx_FIRE_CUSHION + }, { + DECOR_WATER_CUSHION, + _("WATER CUSHION"), + DECORPERM_SPRITE, + DECORSHAPE_1x1, + DECORCAT_CUSHION, + 2000, + DecorDesc_WATER_CUSHION, + DecorGfx_WATER_CUSHION + }, { + DECOR_SNORLAX_DOLL, + _("SNORLAX DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_SNORLAX_DOLL, + DecorGfx_SNORLAX_DOLL + }, { + DECOR_RHYDON_DOLL, + _("RHYDON DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_RHYDON_DOLL, + DecorGfx_RHYDON_DOLL + }, { + DECOR_LAPRAS_DOLL, + _("LAPRAS DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_LAPRAS_DOLL, + DecorGfx_LAPRAS_DOLL + }, { + DECOR_VENUSAUR_DOLL, + _("VENUSAUR DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_VENUSAUR_DOLL, + DecorGfx_VENUSAUR_DOLL + }, { + DECOR_CHARIZARD_DOLL, + _("CHARIZARD DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_CHARIZARD_DOLL, + DecorGfx_CHARIZARD_DOLL + }, { + DECOR_BLASTOISE_DOLL, + _("BLASTOISE DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_BLASTOISE_DOLL, + DecorGfx_BLASTOISE_DOLL + }, { + DECOR_WAILMER_DOLL, + _("WAILMER DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_WAILMER_DOLL, + DecorGfx_WAILMER_DOLL + }, { + DECOR_REGIROCK_DOLL, + _("REGIROCK DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_REGIROCK_DOLL, + DecorGfx_REGIROCK_DOLL + }, { + DECOR_REGICE_DOLL, + _("REGICE DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_REGICE_DOLL, + DecorGfx_REGICE_DOLL + }, { + DECOR_REGISTEEL_DOLL, + _("REGISTEEL DOLL"), + DECORPERM_SPRITE, + DECORSHAPE_1x2, + DECORCAT_DOLL, + 10000, + DecorDesc_REGISTEEL_DOLL, + DecorGfx_REGISTEEL_DOLL} +}; diff --git a/src/data/decoration/tiles.h b/src/data/decoration/tiles.h new file mode 100644 index 000000000..ff6ef3e12 --- /dev/null +++ b/src/data/decoration/tiles.h @@ -0,0 +1,643 @@ +#include "constants/event_objects.h" + +const u16 DecorGfx_SMALL_DESK[] = { + 0x87 +}; + +const u16 DecorGfx_POKEMON_DESK[] = { + 0x8F +}; + +const u16 DecorGfx_HEAVY_DESK[] = { + 0x90, + 0x91, + 0x92, + 0x98, + 0x99, + 0x9A +}; + +const u16 DecorGfx_RAGGED_DESK[] = { + 0x93, + 0x94, + 0x95, + 0x9B, + 0x9C, + 0x9D +}; + +const u16 DecorGfx_COMFORT_DESK[] = { + 0x96, + 0x97, + 0xA3, + 0x9E, + 0x9F, + 0xAB +}; + +const u16 DecorGfx_PRETTY_DESK[] = { + 0xBD, + 0xBE, + 0xBF, + 0xC5, + 0xC6, + 0xC7, + 0xCD, + 0xCE, + 0xCF +}; + +const u16 DecorGfx_BRICK_DESK[] = { + 0xA0, + 0xA1, + 0xA2, + 0xA8, + 0xA9, + 0xAA, + 0xB0, + 0xB1, + 0xB2 +}; + +const u16 DecorGfx_CAMP_DESK[] = { + 0xA4, + 0xA5, + 0xA6, + 0xAC, + 0xAD, + 0xAE, + 0xB4, + 0xB5, + 0xB6 +}; + +const u16 DecorGfx_HARD_DESK[] = { + 0xA7, + 0xBB, + 0xBC, + 0xAF, + 0xC3, + 0xC4, + 0xB7, + 0xCB, + 0xCC +}; + +const u16 DecorGfx_SMALL_CHAIR[] = { + 0xB8 +}; + +const u16 DecorGfx_POKEMON_CHAIR[] = { + 0xB9 +}; + +const u16 DecorGfx_HEAVY_CHAIR[] = { + 0xBA +}; + +const u16 DecorGfx_PRETTY_CHAIR[] = { + 0xC0 +}; + +const u16 DecorGfx_COMFORT_CHAIR[] = { + 0xC1 +}; + +const u16 DecorGfx_RAGGED_CHAIR[] = { + 0xC2 +}; + +const u16 DecorGfx_BRICK_CHAIR[] = { + 0xC8 +}; + +const u16 DecorGfx_CAMP_CHAIR[] = { + 0xC9 +}; + +const u16 DecorGfx_HARD_CHAIR[] = { + 0xCA +}; + +const u16 DecorGfx_RED_PLANT[] = { + 0xD0, + 0xD8 +}; + +const u16 DecorGfx_TROPICAL_PLANT[] = { + 0xD2, + 0xDA +}; + +const u16 DecorGfx_PRETTY_FLOWERS[] = { + 0xD4, + 0xDC +}; + +const u16 DecorGfx_COLORFUL_PLANT[] = { + 0xE0, + 0xE2, + 0xE8, + 0xE9 +}; + +const u16 DecorGfx_BIG_PLANT[] = { + 0xE4, + 0xE6, + 0xEC, + 0xED +}; + +const u16 DecorGfx_GORGEOUS_PLANT[] = { + 0xF0, + 0xF2, + 0xF8, + 0xF9 +}; + +const u16 DecorGfx_RED_BRICK[] = { + 0x25, + 0x2D +}; + +const u16 DecorGfx_YELLOW_BRICK[] = { + 0x26, + 0x2E +}; + +const u16 DecorGfx_BLUE_BRICK[] = { + 0x27, + 0x2F +}; + +const u16 DecorGfx_RED_BALLOON[] = { + 0x138 +}; + +const u16 DecorGfx_BLUE_BALLOON[] = { + 0x13C +}; + +const u16 DecorGfx_YELLOW_BALLOON[] = { + 0x140 +}; + +const u16 DecorGfx_RED_TENT[] = { + 0x30, + 0x31, + 0x32, + 0x38, + 0x39, + 0x3A, + 0x40, + 0x41, + 0x3B +}; + +const u16 DecorGfx_BLUE_TENT[] = { + 0x48, + 0x49, + 0x68, + 0x50, + 0x51, + 0x70, + 0x58, + 0x59, + 0x69 +}; + +const u16 DecorGfx_SOLID_BOARD[] = { + 0x34, + 0x3C +}; + +const u16 DecorGfx_SLIDE[] = { + 0x35, + 0x36, + 0x3D, + 0x3E, + 0x63, + 0x64, + 0x6F, + 0x77 +}; + +const u16 DecorGfx_FENCE_LENGTH[] = { + 0x33 +}; + +const u16 DecorGfx_FENCE_WIDTH[] = { + 0x2C +}; + +const u16 DecorGfx_TIRE[] = { + 0x80, + 0x81, + 0x88, + 0x89 +}; + +const u16 DecorGfx_STAND[] = { + 0x6A, + 0x6B, + 0x6C, + 0x6D, + 0x72, + 0x73, + 0x74, + 0x75 +}; + +const u16 DecorGfx_MUD_BALL[] = { + 0x28 +}; + +const u16 DecorGfx_BREAKABLE_DOOR[] = { + 0x37, + 0x3F +}; + +const u16 DecorGfx_SAND_ORNAMENT[] = { + 0x85, + 0x8D +}; + +const u16 DecorGfx_SILVER_SHIELD[] = { + 0xD6, + 0xDE +}; + +const u16 DecorGfx_GOLD_SHIELD[] = { + 0x12E, + 0x136 +}; + +const u16 DecorGfx_GLASS_ORNAMENT[] = { + 0x82, + 0x8A +}; + +const u16 DecorGfx_TV[] = { + 0xF4 +}; + +const u16 DecorGfx_ROUND_TV[] = { + 0xF5 +}; + +const u16 DecorGfx_CUTE_TV[] = { + 0xF6 +}; + +const u16 DecorGfx_GLITTER_MAT[] = { + 0x60 +}; + +const u16 DecorGfx_JUMP_MAT[] = { + 0x61 +}; + +const u16 DecorGfx_SPIN_MAT[] = { + 0x62 +}; + +const u16 DecorGfx_C_LOW_NOTE_MAT[] = { + 0x78 +}; + +const u16 DecorGfx_D_NOTE_MAT[] = { + 0x79 +}; + +const u16 DecorGfx_E_NOTE_MAT[] = { + 0x7A +}; + +const u16 DecorGfx_F_NOTE_MAT[] = { + 0x7B +}; + +const u16 DecorGfx_G_NOTE_MAT[] = { + 0x7C +}; + +const u16 DecorGfx_A_NOTE_MAT[] = { + 0x7D +}; + +const u16 DecorGfx_B_NOTE_MAT[] = { + 0x7E +}; + +const u16 DecorGfx_C_HIGH_NOTE_MAT[] = { + 0xB3 +}; + +const u16 DecorGfx_SURF_MAT[] = { + 0x42, + 0x43, + 0x44, + 0x4A, + 0x4B, + 0x4C, + 0x52, + 0x53, + 0x54 +}; + +const u16 DecorGfx_THUNDER_MAT[] = { + 0x45, + 0x46, + 0x47, + 0x4D, + 0x4E, + 0x4F, + 0x55, + 0x56, + 0x57 +}; + +const u16 DecorGfx_FIRE_BLAST_MAT[] = { + 0x5A, + 0x5B, + 0x5C, + 0x5D, + 0x5E, + 0x5F, + 0x65, + 0x66, + 0x67 +}; + +const u16 DecorGfx_POWDER_SNOW_MAT[] = { + 0x100, + 0x101, + 0x102, + 0x108, + 0x109, + 0x10A, + 0x110, + 0x111, + 0x112 +}; + +const u16 DecorGfx_ATTRACT_MAT[] = { + 0x103, + 0x104, + 0x105, + 0x10B, + 0x10C, + 0x10D, + 0x113, + 0x114, + 0x115 +}; + +const u16 DecorGfx_FISSURE_MAT[] = { + 0x106, + 0x107, + 0x118, + 0x10E, + 0x10F, + 0x120, + 0x116, + 0x117, + 0x128 +}; + +const u16 DecorGfx_SPIKES_MAT[] = { + 0x119, + 0x11A, + 0x11B, + 0x121, + 0x122, + 0x123, + 0x129, + 0x12A, + 0x12B +}; + +const u16 DecorGfx_BALL_POSTER[] = { + 0x130 +}; + +const u16 DecorGfx_GREEN_POSTER[] = { + 0x131 +}; + +const u16 DecorGfx_RED_POSTER[] = { + 0x132 +}; + +const u16 DecorGfx_BLUE_POSTER[] = { + 0x133 +}; + +const u16 DecorGfx_CUTE_POSTER[] = { + 0x134 +}; + +const u16 DecorGfx_PIKA_POSTER[] = { + 0x11C, + 0x11D +}; + +const u16 DecorGfx_LONG_POSTER[] = { + 0x11E, + 0x11F +}; + +const u16 DecorGfx_SEA_POSTER[] = { + 0x124, + 0x125 +}; + +const u16 DecorGfx_SKY_POSTER[] = { + 0x126, + 0x127 +}; + +const u16 DecorGfx_KISS_POSTER[] = { + 0x12C, + 0x12D +}; + +const u16 DecorGfx_PICHU_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_PIKACHU_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_MARILL_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_TOGEPI_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_CYNDAQUIL_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_CHIKORITA_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_TOTODILE_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_JIGGLYPUFF_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_MEOWTH_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_CLEFAIRY_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_DITTO_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_SMOOCHUM_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_TREECKO_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_TORCHIC_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_MUDKIP_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_DUSKULL_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_WYNAUT_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_BALTOY_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_KECLEON_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_AZURILL_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_SKITTY_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_SWABLU_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_GULPIN_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_LOTAD_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_SEEDOT_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_PIKA_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_ROUND_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_KISS_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_ZIGZAG_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_SPIN_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_DIAMOND_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_BALL_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_GRASS_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_FIRE_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_WATER_CUSHION[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_SNORLAX_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_RHYDON_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_LAPRAS_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_VENUSAUR_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_CHARIZARD_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_BLASTOISE_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_WAILMER_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_REGIROCK_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_REGICE_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; + +const u16 DecorGfx_REGISTEEL_DOLL[] = { + OBJ_EVENT_GFX_ITEM_BALL +}; diff --git a/src/data/field_effects/field_effect_object_template_pointers.h b/src/data/field_effects/field_effect_object_template_pointers.h new file mode 100644 index 000000000..39321bb3d --- /dev/null +++ b/src/data/field_effects/field_effect_object_template_pointers.h @@ -0,0 +1,74 @@ +const struct SpriteTemplate gUnknown_83A537C; +const struct SpriteTemplate gUnknown_83A5394; +const struct SpriteTemplate gUnknown_83A53AC; +const struct SpriteTemplate gUnknown_83A53C4; +const struct SpriteTemplate gUnknown_83A5420; +const struct SpriteTemplate gUnknown_83A5488; +const struct SpriteTemplate gUnknown_83A54E4; +const struct SpriteTemplate gUnknown_83A556C; +const struct SpriteTemplate gUnknown_83A5604; +const struct SpriteTemplate gUnknown_83A5648; +const struct SpriteTemplate gUnknown_83A5698; +const struct SpriteTemplate gUnknown_83A56F4; +const struct SpriteTemplate gUnknown_83A583C; +const struct SpriteTemplate gUnknown_83A589C; +const struct SpriteTemplate gUnknown_83A58E0; +const struct SpriteTemplate gUnknown_83A593C; +const struct SpriteTemplate gUnknown_83A59A4; +const struct SpriteTemplate gUnknown_83A5A30; +const struct SpriteTemplate gUnknown_83A5A88; +const struct SpriteTemplate gUnknown_83A5AD8; +const struct SpriteTemplate gUnknown_83A5B74; +const struct SpriteTemplate gUnknown_83A5C34; +const struct SpriteTemplate gUnknown_83A5750; +const struct SpriteTemplate gUnknown_83A5CB4; +const struct SpriteTemplate gUnknown_83A5D34; +const struct SpriteTemplate gUnknown_83A5E00; +const struct SpriteTemplate gUnknown_83A57EC; +const struct SpriteTemplate gUnknown_83A5D84; +const struct SpriteTemplate gUnknown_83A5B1C; +const struct SpriteTemplate gUnknown_83A5E38; +const struct SpriteTemplate gUnknown_83A5E64; +const struct SpriteTemplate gUnknown_83A5EC0; +const struct SpriteTemplate gUnknown_83A5F24; +const struct SpriteTemplate gUnknown_83A5FA4; +const struct SpriteTemplate gUnknown_83A5FE0; + +const struct SpriteTemplate *const gFieldEffectObjectTemplatePointers[] = { + &gUnknown_83A537C, + &gUnknown_83A5394, + &gUnknown_83A53AC, + &gUnknown_83A53C4, + &gUnknown_83A5420, + &gUnknown_83A5488, + &gUnknown_83A54E4, + &gUnknown_83A556C, + &gUnknown_83A5604, + &gUnknown_83A5648, + &gUnknown_83A5698, + &gUnknown_83A56F4, + &gUnknown_83A583C, + &gUnknown_83A589C, + &gUnknown_83A58E0, + &gUnknown_83A593C, + &gUnknown_83A59A4, + &gUnknown_83A5A30, + &gUnknown_83A5A88, + &gUnknown_83A5AD8, + &gUnknown_83A5B74, + &gUnknown_83A5C34, + NULL, + &gUnknown_83A5750, + &gUnknown_83A5CB4, + &gUnknown_83A5D34, + &gUnknown_83A5E00, + &gUnknown_83A57EC, + &gUnknown_83A5D84, + &gUnknown_83A5B1C, + &gUnknown_83A5E38, + &gUnknown_83A5E64, + &gUnknown_83A5EC0, + &gUnknown_83A5F24, + &gUnknown_83A5FA4, + &gUnknown_83A5FE0, +}; diff --git a/src/data/field_effects/field_effect_objects.h b/src/data/field_effects/field_effect_objects.h new file mode 100644 index 000000000..0f2694de2 --- /dev/null +++ b/src/data/field_effects/field_effect_objects.h @@ -0,0 +1,1306 @@ +const struct SpritePalette gUnknown_83A5340 = { .data = gUnknown_8398FA8, .tag = 0x1004 }; +const struct SpritePalette gUnknown_83A5348 = { .data = gUnknown_8398FC8, .tag = 0x1005 }; + +const union AnimCmd gUnknown_83A5350[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5358[] = +{ + gUnknown_83A5350, +}; + +const struct SpriteFrameImage gUnknown_83A535C[] = { obj_frame_tiles(gUnknown_8398048) }; +const struct SpriteFrameImage gUnknown_83A5364[] = { obj_frame_tiles(gUnknown_8398068) }; +const struct SpriteFrameImage gUnknown_83A536C[] = { obj_frame_tiles(gUnknown_83980A8) }; +const struct SpriteFrameImage gUnknown_83A5374[] = { obj_frame_tiles(gUnknown_8398128) }; + +const struct SpriteTemplate gUnknown_83A537C = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_8x8, + .anims = gUnknown_83A5358, + .images = gUnknown_83A535C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateShadowFieldEffect, +}; + +const struct SpriteTemplate gUnknown_83A5394 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_16x8, + .anims = gUnknown_83A5358, + .images = gUnknown_83A5364, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateShadowFieldEffect, +}; + +const struct SpriteTemplate gUnknown_83A53AC = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_32x8, + .anims = gUnknown_83A5358, + .images = gUnknown_83A536C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateShadowFieldEffect, +}; + +const struct SpriteTemplate gUnknown_83A53C4 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_64x32, + .anims = gUnknown_83A5358, + .images = gUnknown_83A5374, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateShadowFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A53DC[] = +{ + overworld_frame(gUnknown_839A008, 2, 2, 0), + overworld_frame(gUnknown_839A008, 2, 2, 1), + overworld_frame(gUnknown_839A008, 2, 2, 2), + overworld_frame(gUnknown_839A008, 2, 2, 3), + overworld_frame(gUnknown_839A008, 2, 2, 4), +}; + +const union AnimCmd gUnknown_83A5404[] = +{ + ANIMCMD_FRAME(1, 10), + ANIMCMD_FRAME(2, 10), + ANIMCMD_FRAME(3, 10), + ANIMCMD_FRAME(4, 10), + ANIMCMD_FRAME(0, 10), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A541C[] = +{ + gUnknown_83A5404, +}; + +const struct SpriteTemplate gUnknown_83A5420 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A541C, + .images = gUnknown_83A53DC, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateTallGrassFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5438[] = +{ + overworld_frame(gUnknown_83986A8, 2, 2, 0), + overworld_frame(gUnknown_83986A8, 2, 2, 1), + overworld_frame(gUnknown_83986A8, 2, 2, 2), + overworld_frame(gUnknown_83986A8, 2, 2, 3), + overworld_frame(gUnknown_83986A8, 2, 2, 4), +}; + +const union AnimCmd gUnknown_83A5460[] = +{ + ANIMCMD_FRAME(0, 12), + ANIMCMD_FRAME(1, 9), + ANIMCMD_FRAME(2, 9), + ANIMCMD_FRAME(3, 9), + ANIMCMD_FRAME(0, 9), + ANIMCMD_FRAME(1, 9), + ANIMCMD_FRAME(2, 11), + ANIMCMD_FRAME(4, 11), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5484[] = +{ + gUnknown_83A5460, +}; + +const struct SpriteTemplate gUnknown_83A5488 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5484, + .images = gUnknown_83A5438, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = WaitFieldEffectSpriteAnim, +}; + +const struct SpriteFrameImage gUnknown_83A54A0[] = +{ + overworld_frame(gUnknown_8398928, 2, 2, 0), + overworld_frame(gUnknown_8398928, 2, 2, 1), + overworld_frame(gUnknown_8398928, 2, 2, 2), + overworld_frame(gUnknown_8398928, 2, 2, 3), + overworld_frame(gUnknown_8398928, 2, 2, 4), +}; + +const union AnimCmd gUnknown_83A54C8[] = +{ + ANIMCMD_FRAME(0, 12), + ANIMCMD_FRAME(1, 12), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(3, 12), + ANIMCMD_FRAME(4, 12), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A54E0[] = +{ + gUnknown_83A54C8, +}; + +const struct SpriteTemplate gUnknown_83A54E4 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A54E0, + .images = gUnknown_83A54A0, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateAshFieldEffect, +}; + +const struct SpriteFrameImage gObjectEventPicTable_SurfBlob[] = +{ + overworld_frame(gObjectEventPic_SurfBlob, 2, 8, 0), + overworld_frame(gObjectEventPic_SurfBlob, 2, 8, 1), + overworld_frame(gObjectEventPic_SurfBlob, 2, 8, 2), + overworld_frame(gObjectEventPic_SurfBlob, 2, 8, 3), + overworld_frame(gObjectEventPic_SurfBlob, 2, 8, 4), + overworld_frame(gObjectEventPic_SurfBlob, 2, 8, 5), +}; + +const union AnimCmd gUnknown_83A552C[] = +{ + ANIMCMD_FRAME(0, 48), + ANIMCMD_FRAME(1, 48), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gUnknown_83A5538[] = +{ + ANIMCMD_FRAME(2, 48), + ANIMCMD_FRAME(3, 48), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gUnknown_83A5544[] = +{ + ANIMCMD_FRAME(4, 48), + ANIMCMD_FRAME(5, 48), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gUnknown_83A5550[] = +{ + ANIMCMD_FRAME(4, 48, .hFlip = TRUE), + ANIMCMD_FRAME(5, 48, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gUnknown_83A555C[] = +{ + gUnknown_83A552C, + gUnknown_83A5538, + gUnknown_83A5544, + gUnknown_83A5550, +}; + +const struct SpriteTemplate gUnknown_83A556C = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_32x32, + .anims = gUnknown_83A555C, + .images = gObjectEventPicTable_SurfBlob, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateSurfBlobFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5584[] = +{ + overworld_frame(gUnknown_8398BA8, 2, 2, 0), + overworld_frame(gUnknown_8398BA8, 2, 2, 1), + overworld_frame(gUnknown_8398BA8, 2, 2, 2), + overworld_frame(gUnknown_8398BA8, 2, 2, 3), + overworld_frame(gUnknown_8398BA8, 2, 2, 4), + overworld_frame(gUnknown_8398BA8, 2, 2, 5), + overworld_frame(gUnknown_8398BA8, 2, 2, 6), + overworld_frame(gUnknown_8398BA8, 2, 2, 7), +}; + +const union AnimCmd gUnknown_83A55C4[] = +{ + ANIMCMD_FRAME(2, 32), + ANIMCMD_FRAME(3, 32), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gUnknown_83A55D0[] = +{ + ANIMCMD_FRAME(0, 32), + ANIMCMD_FRAME(1, 32), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gUnknown_83A55DC[] = +{ + ANIMCMD_FRAME(4, 32), + ANIMCMD_FRAME(5, 32), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gUnknown_83A55E8[] = +{ + ANIMCMD_FRAME(6, 32), + ANIMCMD_FRAME(7, 32), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gUnknown_83A55F4[] = +{ + gUnknown_83A55C4, + gUnknown_83A55D0, + gUnknown_83A55DC, + gUnknown_83A55E8, +}; + +const struct SpriteTemplate gUnknown_83A5604 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A55F4, + .images = gUnknown_83A5584, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const struct SpriteFrameImage gUnknown_83A561C[] = +{ + overworld_frame(gUnknown_8399008, 2, 1, 0), + overworld_frame(gUnknown_8399008, 2, 1, 1), + overworld_frame(gUnknown_8399008, 2, 1, 2), +}; + +const union AnimCmd gUnknown_83A5634[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5644[] = +{ + gUnknown_83A5634, +}; + +const struct SpriteTemplate gUnknown_83A5648 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x8, + .anims = gUnknown_83A5644, + .images = gUnknown_83A561C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80DCCE0, +}; + +const struct SpriteFrameImage gUnknown_83A5660[] = +{ + overworld_frame(gUnknown_8399188, 2, 1, 0), + overworld_frame(gUnknown_8399188, 2, 1, 1), + overworld_frame(gUnknown_8399188, 2, 1, 2), + overworld_frame(gUnknown_8399188, 2, 1, 3), +}; + +const union AnimCmd gUnknown_83A5680[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(3, 8), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5694[] = +{ + gUnknown_83A5680, +}; + +const struct SpriteTemplate gUnknown_83A5698 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x8, + .anims = gUnknown_83A5694, + .images = gUnknown_83A5660, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80DCCE0, +}; + +const struct SpriteFrameImage gUnknown_83A56B0[] = +{ + overworld_frame(gUnknown_839A388, 2, 2, 0), + overworld_frame(gUnknown_839A388, 2, 2, 1), +}; + +const union AnimCmd gUnknown_83A56C0[] = +{ + ANIMCMD_FRAME(0, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A56C8[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A56D0[] = +{ + ANIMCMD_FRAME(1, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A56D8[] = +{ + ANIMCMD_FRAME(1, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A56E0[] = +{ + gUnknown_83A56C0, + gUnknown_83A56C0, + gUnknown_83A56C8, + gUnknown_83A56D0, + gUnknown_83A56D8, +}; + +const struct SpriteTemplate gUnknown_83A56F4 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A56E0, + .images = gUnknown_83A56B0, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateFootprintsTireTracksFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A570C[] = +{ + overworld_frame(gUnknown_839A488, 2, 2, 0), + overworld_frame(gUnknown_839A488, 2, 2, 1), +}; + +const union AnimCmd gUnknown_83A571C[] = +{ + ANIMCMD_FRAME(0, 1, .vFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5724[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A572C[] = +{ + ANIMCMD_FRAME(1, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5734[] = +{ + ANIMCMD_FRAME(1, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A573C[] = +{ + gUnknown_83A571C, + gUnknown_83A571C, + gUnknown_83A5724, + gUnknown_83A572C, + gUnknown_83A5734, +}; + +const struct SpriteTemplate gUnknown_83A5750 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A573C, + .images = gUnknown_83A570C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateFootprintsTireTracksFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5768[] = +{ + overworld_frame(gUnknown_839A588, 2, 2, 0), + overworld_frame(gUnknown_839A588, 2, 2, 1), + overworld_frame(gUnknown_839A588, 2, 2, 2), + overworld_frame(gUnknown_839A588, 2, 2, 3), +}; + +const union AnimCmd gUnknown_83A5788[] = +{ + ANIMCMD_FRAME(2, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5790[] = +{ + ANIMCMD_FRAME(2, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5798[] = +{ + ANIMCMD_FRAME(1, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A57A0[] = +{ + ANIMCMD_FRAME(1, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A57A8[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A57B0[] = +{ + ANIMCMD_FRAME(0, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A57B8[] = +{ + ANIMCMD_FRAME(3, 1, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A57C0[] = +{ + ANIMCMD_FRAME(3, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A57C8[] = +{ + gUnknown_83A5788, + gUnknown_83A5788, + gUnknown_83A5790, + gUnknown_83A5798, + gUnknown_83A57A0, + gUnknown_83A57A8, + gUnknown_83A57B0, + gUnknown_83A57B8, + gUnknown_83A57C0, +}; + +const struct SpriteTemplate gUnknown_83A57EC = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A57C8, + .images = gUnknown_83A5768, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateFootprintsTireTracksFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5804[] = +{ + overworld_frame(gUnknown_839AA48, 2, 2, 0), + overworld_frame(gUnknown_839AA48, 2, 2, 1), + overworld_frame(gUnknown_839AA48, 2, 2, 2), + overworld_frame(gUnknown_839AA48, 2, 2, 3), +}; + +const union AnimCmd gUnknown_83A5824[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(3, 8), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5838[] = +{ + gUnknown_83A5824, +}; + +const struct SpriteTemplate gUnknown_83A583C = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5838, + .images = gUnknown_83A5804, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80DCCE0, +}; + +const struct SpriteFrameImage gUnknown_83A5854[] = +{ + overworld_frame(gUnknown_839AC48, 2, 1, 0), + overworld_frame(gUnknown_839AC48, 2, 1, 1), +}; + +const union AnimCmd gUnknown_83A5864[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5870[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(1, 6), + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(1, 6), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gUnknown_83A5894[] = +{ + gUnknown_83A5864, + gUnknown_83A5870, +}; + +const struct SpriteTemplate gUnknown_83A589C = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x8, + .anims = gUnknown_83A5894, + .images = gUnknown_83A5854, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateSplashFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A58B4[] = +{ + overworld_frame(gUnknown_839ACC8, 2, 1, 0), + overworld_frame(gUnknown_839ACC8, 2, 1, 1), + overworld_frame(gUnknown_839ACC8, 2, 1, 2), +}; + +const union AnimCmd gUnknown_83A58CC[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A58DC[] = +{ + gUnknown_83A58CC, +}; + +const struct SpriteTemplate gUnknown_83A58E0 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x8, + .anims = gUnknown_83A58DC, + .images = gUnknown_83A58B4, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80DCCE0, +}; + +const struct SpriteFrameImage gUnknown_83A58F8[] = +{ + overworld_frame(gUnknown_8399E08, 2, 2, 0), + overworld_frame(gUnknown_8399E08, 2, 2, 1), + overworld_frame(gUnknown_8399E08, 2, 2, 2), + overworld_frame(gUnknown_8399E08, 2, 2, 3), +}; + +const union AnimCmd gUnknown_83A5918[] = +{ + ANIMCMD_FRAME(1, 3), + ANIMCMD_FRAME(2, 3), + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5938[] = +{ + gUnknown_83A5918, +}; + +const struct SpriteTemplate gUnknown_83A593C = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5938, + .images = gUnknown_83A58F8, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateLongGrassFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5954[] = +{ + overworld_frame(gUnknown_8399488, 2, 2, 0), + overworld_frame(gUnknown_8399488, 2, 2, 1), + overworld_frame(gUnknown_8399488, 2, 2, 2), + overworld_frame(gUnknown_8399488, 2, 2, 3), + overworld_frame(gUnknown_8399488, 2, 2, 4), + overworld_frame(gUnknown_8399488, 2, 2, 6), +}; + +const union AnimCmd gUnknown_83A5984[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(3, 8), + ANIMCMD_FRAME(4, 8), + ANIMCMD_FRAME(5, 8), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A59A0[] = +{ + gUnknown_83A5984, +}; + +const struct SpriteTemplate gUnknown_83A59A4 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A59A0, + .images = gUnknown_83A5954, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80DCCE0, +}; + +const struct SpriteFrameImage gUnknown_83A59BC[] = +{ + overworld_frame(gUnknown_8399788, 2, 2, 0), + overworld_frame(gUnknown_8399788, 2, 2, 1), + overworld_frame(gUnknown_8399788, 2, 2, 2), + overworld_frame(gUnknown_8399788, 2, 2, 3), + overworld_frame(gUnknown_8399788, 2, 2, 4), + overworld_frame(gUnknown_8399788, 2, 2, 5), + overworld_frame(gUnknown_8399788, 2, 2, 6), + overworld_frame(gUnknown_8399788, 2, 2, 7), + overworld_frame(gUnknown_8399788, 2, 2, 8), +}; + +const union AnimCmd gUnknown_83A5A04[] = +{ + ANIMCMD_FRAME(0, 10), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(7, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_JUMP(7), +}; + +const union AnimCmd *const gUnknown_83A5A2C[] = +{ + gUnknown_83A5A04, +}; + +const struct SpriteTemplate gUnknown_83A5A30 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5A2C, + .images = gUnknown_83A59BC, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = WaitFieldEffectSpriteAnim, +}; + +const struct SpriteFrameImage gUnknown_83A5A48[] = +{ + overworld_frame(gUnknown_8399C08, 2, 2, 0), + overworld_frame(gUnknown_8399C08, 2, 2, 1), + overworld_frame(gUnknown_8399C08, 2, 2, 2), + overworld_frame(gUnknown_8399C08, 2, 2, 3), +}; + +const union AnimCmd gUnknown_83A5A68[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gUnknown_83A5A84[] = +{ + gUnknown_83A5A68, +}; + +const struct SpriteTemplate gUnknown_83A5A88 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5A84, + .images = gUnknown_83A5A48, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = WaitFieldEffectSpriteAnim, +}; + +const struct SpriteFrameImage gUnknown_83A5AA0[] = +{ + overworld_frame(gUnknown_839A788, 2, 2, 0), + overworld_frame(gUnknown_839A788, 2, 2, 1), + overworld_frame(gUnknown_839A788, 2, 2, 2), + overworld_frame(gUnknown_839A788, 2, 2, 3), +}; + +const union AnimCmd gUnknown_83A5AC0[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gUnknown_83A5AD4[] = +{ + gUnknown_83A5AC0, +}; + +const struct SpriteTemplate gUnknown_83A5AD8 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5AD4, + .images = gUnknown_83A5AA0, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = WaitFieldEffectSpriteAnim, +}; + +const struct SpriteFrameImage gUnknown_83A5AF0[] = +{ + overworld_frame(gUnknown_839A988, 2, 1, 0), + overworld_frame(gUnknown_839A988, 2, 1, 1), + overworld_frame(gUnknown_839A988, 2, 1, 2), +}; + +const union AnimCmd gUnknown_83A5B08[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5B18[] = +{ + gUnknown_83A5B08, +}; + +const struct SpriteTemplate gUnknown_83A5B1C = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x8, + .anims = gUnknown_83A5B18, + .images = gUnknown_83A5AF0, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateSandPileFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5B34[] = +{ + overworld_frame(gUnknown_839AD88, 2, 2, 0), + overworld_frame(gUnknown_839AD88, 2, 2, 1), + overworld_frame(gUnknown_839AD88, 2, 2, 2), + overworld_frame(gUnknown_839AD88, 2, 2, 3), +}; + +const union AnimCmd gUnknown_83A5B54[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gUnknown_83A5B70[] = +{ + gUnknown_83A5B54, +}; + +const struct SpriteTemplate gUnknown_83A5B74 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5B70, + .images = gUnknown_83A5B34, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = WaitFieldEffectSpriteAnim, +}; + +const union AffineAnimCmd gUnknown_83A5B8C[] = +{ + AFFINEANIMCMD_FRAME(-256, 256, 128, 0), + AFFINEANIMCMD_FRAME(1, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 8), + AFFINEANIMCMD_FRAME(-1, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 8), + AFFINEANIMCMD_FRAME(-1, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 8), + AFFINEANIMCMD_FRAME(1, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 8), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd gUnknown_83A5BDC[] = +{ + AFFINEANIMCMD_FRAME(256, 256, 128, 0), + AFFINEANIMCMD_FRAME(-1, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 8), + AFFINEANIMCMD_FRAME(1, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 8), + AFFINEANIMCMD_FRAME(1, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 8), + AFFINEANIMCMD_FRAME(-1, 0, 0, 4), + AFFINEANIMCMD_FRAME(0, 0, 0, 8), + AFFINEANIMCMD_JUMP(1), +}; + +const union AffineAnimCmd *const gUnknown_83A5C2C[] = +{ + gUnknown_83A5B8C, + gUnknown_83A5BDC, +}; + +const struct SpriteTemplate gUnknown_83A5C34 = +{ + .tileTag = 0x0, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gDummyOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gUnknown_83A5C2C, + .callback = SpriteCallbackDummy, +}; + +const struct SpriteFrameImage gUnknown_83A5C4C[] = +{ + overworld_frame(gUnknown_839B008, 2, 4, 0), + overworld_frame(gUnknown_839B008, 2, 4, 1), + overworld_frame(gUnknown_839B008, 2, 4, 2), + overworld_frame(gUnknown_839B008, 2, 4, 3), + overworld_frame(gUnknown_839B008, 2, 4, 4), + overworld_frame(gUnknown_839B008, 2, 4, 5), + overworld_frame(gUnknown_839B008, 2, 4, 6), +}; + +const union AnimCmd gUnknown_83A5C84[] = +{ + ANIMCMD_FRAME(0, 16), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5C8C[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5CAC[] = +{ + gUnknown_83A5C84, + gUnknown_83A5C8C, +}; + +const struct SpriteTemplate gUnknown_83A5CB4 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_16x32, + .anims = gUnknown_83A5CAC, + .images = gUnknown_83A5C4C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateDisguiseFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5CCC[] = +{ + overworld_frame(gUnknown_839B708, 2, 4, 0), + overworld_frame(gUnknown_839B708, 2, 4, 1), + overworld_frame(gUnknown_839B708, 2, 4, 2), + overworld_frame(gUnknown_839B708, 2, 4, 3), + overworld_frame(gUnknown_839B708, 2, 4, 4), + overworld_frame(gUnknown_839B708, 2, 4, 5), + overworld_frame(gUnknown_839B708, 2, 4, 6), +}; + +const union AnimCmd gUnknown_83A5D04[] = +{ + ANIMCMD_FRAME(0, 16), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5D0C[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5D2C[] = +{ + gUnknown_83A5D04, + gUnknown_83A5D0C, +}; + +const struct SpriteTemplate gUnknown_83A5D34 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_16x32, + .anims = gUnknown_83A5D2C, + .images = gUnknown_83A5CCC, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateDisguiseFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5D4C[] = +{ + overworld_frame(gUnknown_839BE08, 2, 4, 0), + overworld_frame(gUnknown_839BE08, 2, 4, 1), + overworld_frame(gUnknown_839BE08, 2, 4, 2), + overworld_frame(gUnknown_839BE08, 2, 4, 3), + overworld_frame(gUnknown_839BE08, 2, 4, 4), + overworld_frame(gUnknown_839BE08, 2, 4, 5), + overworld_frame(gUnknown_839BE08, 2, 4, 6), +}; + +const struct SpriteTemplate gUnknown_83A5D84 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_16x32, + .anims = gUnknown_83A5CAC, + .images = gUnknown_83A5D4C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateDisguiseFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5D9C[] = +{ + overworld_frame(gUnknown_839D3C8, 8, 8, 0), + overworld_frame(gUnknown_839D3C8, 8, 8, 1), + overworld_frame(gUnknown_839D3C8, 8, 8, 2), + overworld_frame(gUnknown_839D3C8, 8, 8, 3), + overworld_frame(gUnknown_839D3C8, 8, 8, 4), +}; + +const union AnimCmd gUnknown_83A5DC4[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5DCC[] = +{ + ANIMCMD_FRAME(1, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5DD4[] = +{ + ANIMCMD_FRAME(2, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5DDC[] = +{ + ANIMCMD_FRAME(3, 1), + ANIMCMD_END, +}; + +const union AnimCmd gUnknown_83A5DE4[] = +{ + ANIMCMD_FRAME(4, 1), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5DEC[] = +{ + gUnknown_83A5DC4, + gUnknown_83A5DCC, + gUnknown_83A5DD4, + gUnknown_83A5DDC, + gUnknown_83A5DE4, +}; + +const struct SpriteTemplate gUnknown_83A5E00 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = SPRITE_INVALID_TAG, + .oam = &gObjectEventBaseOam_64x64, + .anims = gUnknown_83A5DEC, + .images = gUnknown_83A5D9C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +const struct SpriteFrameImage gUnknown_83A5E18[] = +{ + overworld_frame(gUnknown_839A288, 2, 2, 0), + overworld_frame(gUnknown_839A288, 2, 2, 1), +}; + +const union AnimCmd gUnknown_83A5E28[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5E34[] = +{ + gUnknown_83A5E28, +}; + +const struct SpriteTemplate gUnknown_83A5E38 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5E34, + .images = gUnknown_83A5E18, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateShortGrassFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5E50[] = +{ + overworld_frame(gUnknown_839C508, 2, 2, 0), +}; + +const union AnimCmd gUnknown_83A5E58[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5E60[] = +{ + gUnknown_83A5E58, +}; + +const struct SpriteTemplate gUnknown_83A5E64 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1005, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5E60, + .images = gUnknown_83A5E50, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateHotSpringsWaterFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5E7C[] = +{ + overworld_frame(gUnknown_839C5A8, 2, 2, 0), + overworld_frame(gUnknown_839C5A8, 2, 2, 1), + overworld_frame(gUnknown_839C5A8, 2, 2, 2), + overworld_frame(gUnknown_839C5A8, 2, 2, 3), + overworld_frame(gUnknown_839C5A8, 2, 2, 4), +}; + +const union AnimCmd gUnknown_83A5EA4[] = +{ + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(1, 6), + ANIMCMD_FRAME(2, 6), + ANIMCMD_FRAME(3, 6), + ANIMCMD_FRAME(4, 6), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5EBC[] = +{ + gUnknown_83A5EA4, +}; + +const struct SpriteTemplate gUnknown_83A5EC0 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x100D, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5EBC, + .images = gUnknown_83A5E7C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCB_PopOutOfAsh, +}; + +const struct SpritePalette gUnknown_83A5ED8 = { .data = gUnknown_839C588, .tag = 0x100D }; + +const struct SpriteFrameImage gUnknown_83A5EE0[] = +{ + overworld_frame(gUnknown_839C828, 2, 2, 0), + overworld_frame(gUnknown_839C828, 2, 2, 1), + overworld_frame(gUnknown_839C828, 2, 2, 2), + overworld_frame(gUnknown_839C828, 2, 2, 3), + overworld_frame(gUnknown_839C828, 2, 2, 4), +}; + +const union AnimCmd gUnknown_83A5F08[] = +{ + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(1, 6), + ANIMCMD_FRAME(2, 6), + ANIMCMD_FRAME(3, 6), + ANIMCMD_FRAME(4, 6), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5F20[] = +{ + gUnknown_83A5F08, +}; + +const struct SpriteTemplate gUnknown_83A5F24 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x100D, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5F20, + .images = gUnknown_83A5EE0, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCB_LavaridgeGymWarp, +}; + +const struct SpriteFrameImage gUnknown_83A5F3C[] = +{ + overworld_frame(gUnknown_839CAA8, 2, 4, 0), + overworld_frame(gUnknown_839CAA8, 2, 4, 1), + overworld_frame(gUnknown_839CAA8, 2, 4, 2), + overworld_frame(gUnknown_839CAA8, 2, 4, 3), + overworld_frame(gUnknown_839CAA8, 2, 4, 4), + overworld_frame(gUnknown_839CAA8, 2, 4, 5), + overworld_frame(gUnknown_839CAA8, 2, 4, 6), + overworld_frame(gUnknown_839CAA8, 2, 4, 7), +}; + +const union AnimCmd gUnknown_83A5F7C[] = +{ + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 6), + ANIMCMD_FRAME(4, 6), + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(7, 4), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5FA0[] = +{ + gUnknown_83A5F7C, +}; + +const struct SpriteTemplate gUnknown_83A5FA4 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x1004, + .oam = &gObjectEventBaseOam_16x32, + .anims = gUnknown_83A5FA0, + .images = gUnknown_83A5F3C, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateBubblesFieldEffect, +}; + +const struct SpriteFrameImage gUnknown_83A5FBC[] = +{ + overworld_frame(gUnknown_839D2A8, 2, 2, 0), + overworld_frame(gUnknown_839D2A8, 2, 2, 1), +}; + +const union AnimCmd gUnknown_83A5FCC[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(1, 5), + ANIMCMD_FRAME(0, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gUnknown_83A5FDC[] = +{ + gUnknown_83A5FCC, +}; + +const struct SpriteTemplate gUnknown_83A5FE0 = +{ + .tileTag = SPRITE_INVALID_TAG, + .paletteTag = 0x100F, + .oam = &gObjectEventBaseOam_16x16, + .anims = gUnknown_83A5FDC, + .images = gUnknown_83A5FBC, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = UpdateSparkleFieldEffect, +}; + +const struct SpritePalette gUnknown_83A5FF8 = { .data = gUnknown_839D3A8, .tag = 0x100F }; diff --git a/src/data/object_events/base_oam.h b/src/data/object_events/base_oam.h new file mode 100644 index 000000000..94b0b09af --- /dev/null +++ b/src/data/object_events/base_oam.h @@ -0,0 +1,53 @@ +const struct OamData gObjectEventBaseOam_8x8 = { + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .priority = 2 +}; + +const struct OamData gObjectEventBaseOam_16x8 = { + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .priority = 2 +}; + +const struct OamData gObjectEventBaseOam_16x16 = { + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .priority = 2 +}; + +const struct OamData gObjectEventBaseOam_32x16 = { + .shape = SPRITE_SHAPE(32x16), + .size = SPRITE_SIZE(32x16), + .priority = 2 +}; + +const struct OamData gObjectEventBaseOam_32x8 = { + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .priority = 2 +}; + +const struct OamData gObjectEventBaseOam_64x32 = { + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .priority = 2 +}; + +const struct OamData gObjectEventBaseOam_16x32 = { + .shape = SPRITE_SHAPE(16x32), + .size = SPRITE_SIZE(16x32), + .priority = 2 +}; + +const struct OamData gObjectEventBaseOam_32x32 = { + .shape = SPRITE_SHAPE(32x32), + .size = SPRITE_SIZE(32x32), + .priority = 2 +}; + +const struct OamData gObjectEventBaseOam_64x64 = { + .shape = SPRITE_SHAPE(64x64), + .size = SPRITE_SIZE(64x64), + .priority = 2 +}; diff --git a/src/data/object_events/movement_action_func_tables.h b/src/data/object_events/movement_action_func_tables.h new file mode 100644 index 000000000..701167500 --- /dev/null +++ b/src/data/object_events/movement_action_func_tables.h @@ -0,0 +1,1645 @@ +static bool8 MovementActionFunc_x04_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x05_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x06_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x07_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x08_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x08_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x09_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x09_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0A_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0A_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0B_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0B_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0C_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0C_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0D_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0D_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0E_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0E_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0F_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x0F_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x41_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x41_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x42_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x42_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x43_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x43_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x44_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x44_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x70_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x71_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x72_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x73_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x88_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x89_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x8A_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x8B_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x94_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x94_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x95_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x95_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x96_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x96_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x97_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x97_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x98_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x98_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x99_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9A_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9B_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9B_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9C_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9C_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9D_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9D_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9E_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9E_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9F_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_x9F_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA0_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA0_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA1_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA1_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA2_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA2_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA3_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA3_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA4_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA4_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA4_2(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA5_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA5_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA6_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA6_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA7_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA7_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA8_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA8_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA9_0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementActionFunc_xA9_1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_FaceDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_FaceUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_FaceLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_FaceRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PauseSpriteAnim(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkNormalDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkNormalDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkNormalUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkNormalUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkNormalLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkNormalLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkNormalRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkNormalRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceSlowDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceSlowUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceSlowLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceSlowRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceSlow_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceNormalDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceNormalUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceNormalLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceNormalRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlace_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceFastDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceFastUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceFastLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceFastRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceFastestDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceFastestUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceFastestLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkInPlaceFastestRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Jump2Down_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Jump2Down_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Jump2Up_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Jump2Up_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Jump2Left_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Jump2Left_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Jump2Right_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Jump2Right_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RideWaterCurrentDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RideWaterCurrentDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RideWaterCurrentUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RideWaterCurrentUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RideWaterCurrentLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RideWaterCurrentLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RideWaterCurrentRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RideWaterCurrentRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastestDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastestDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastestUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastestUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastestLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastestLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastestRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkFastestRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SlideDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SlideDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SlideUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SlideUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SlideLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SlideLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SlideRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SlideRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PlayerRunDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PlayerRunDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PlayerRunUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PlayerRunUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PlayerRunLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PlayerRunLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PlayerRunRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_PlayerRunRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpSpecialDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpSpecialDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpSpecialUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpSpecialUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpSpecialLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpSpecialLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpSpecialRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceDownUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceDownUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceUpDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceUpDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceLeftRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceLeftRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceRightLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_JumpInPlaceRightLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RevealTrainer_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RevealTrainer_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkDownStartAffine_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkDownStartAffine_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkDownAffine_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WalkDownAffine_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopFaceDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopFaceDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopFaceUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopFaceUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopFaceLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopFaceRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopFaceRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieHopRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieJumpDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieJumpDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieJumpUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieJumpUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieJumpLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieJumpLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieJumpRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieJumpRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieMoveDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieMoveUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieMoveLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieMoveRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieMoveDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieMoveDown_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieMoveUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieMoveUp_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieMoveLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieMoveRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroWheelieMoveRight_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroEndWheelieFaceDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroEndWheelieFaceUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroEndWheelieFaceLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_AcroEndWheelieFaceRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_UnusedAcroActionDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_UnusedAcroActionUp_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_UnusedAcroActionLeft_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_UnusedAcroActionRight_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RockSmashBreak_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RockSmashBreak_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RockSmashBreak_Step2(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_CutTree_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_CutTree_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_CutTree_Step2(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_WaitSpriteAnim(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Finish(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Delay_Step1(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Delay1_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Delay2_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Delay4_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Delay8_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_Delay16_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_FacePlayer_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_FaceAwayPlayer_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_FaceOriginalDirection_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_LockFacingDirection_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_UnlockFacingDirection_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_DisableAnimation_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_RestoreAnimation_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SetInvisible_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SetVisible_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_StartAnimInDirection_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_NurseJoyBowDown_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_EnableJumpLandingGroundEffect_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_DisableJumpLandingGroundEffect_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_EmoteExclamationMark_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_EmoteQuestionMark_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_EmoteHeart_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 do_double_excl_bubble(struct ObjectEvent *, struct Sprite *); +static bool8 do_smile_bubble(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_SetFixedPriority_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_ClearFixedPriority_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_InitAffineAnim_Step0(struct ObjectEvent *, struct Sprite *); +static bool8 MovementAction_ClearAffineAnim_Step0(struct ObjectEvent *, struct Sprite *); + +static bool8 (*const sMovementActionFuncs_x00[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x01[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x02[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x03[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x04[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x05[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x06[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x07[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x08[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x09[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x0A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x0B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x0D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x0C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x0E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x0F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x10[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x11[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x12[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x13[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x14[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x15[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x16[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x17[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x18[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x19[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x1A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x1B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x1C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x1D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x1E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x1F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x20[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x21[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x22[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x23[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x24[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x25[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x26[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x27[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x28[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x29[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x2A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x2B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x2C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x2D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x2E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x2F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x30[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x31[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x32[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x33[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x34[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x35[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x36[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x37[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x38[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x39[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x3A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x3B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x3C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x3D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x3E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x3F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x40[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x41[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x42[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x43[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x44[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x45[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x46[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x47[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x48[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x49[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x4A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x4B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x4C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x4D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x4E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x4F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x50[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x51[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x52[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x53[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x54[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x55[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x56[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x57[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x58[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x59[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x5A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x5B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x5C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x5D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x5E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x5F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x60[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x61[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x62[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x63[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x64[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x65[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x66[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x67[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x68[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x69[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x6A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x6B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x6C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x6D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x6E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x6F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x70[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x71[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x72[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x73[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x74[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x75[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x76[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x77[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x78[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x79[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x7A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x7B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x7C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x7D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x7E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x7F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x80[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x81[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x82[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x83[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x84[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x85[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x86[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x87[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x88[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x89[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x8A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x8B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x8C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x8D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x8E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x8F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x90[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x91[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x92[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x93[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x94[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x95[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x96[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x97[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x98[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x99[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x9A[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x9B[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x9C[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x9D[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x9E[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_x9F[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA0[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA1[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA2[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA3[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA4[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA5[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA6[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA7[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA8[])(struct ObjectEvent *, struct Sprite *); +static bool8 (*const sMovementActionFuncs_xA9[])(struct ObjectEvent *, struct Sprite *); + +static u8 GetMoveDirectionFastAnimNum(u8 direction); +static u8 GetMoveDirectionFasterAnimNum(u8 direction); +static u8 GetMoveDirectionFastestAnimNum(u8 direction); + +bool8 (*const *const gMovementActionFuncs[])(struct ObjectEvent *, struct Sprite *) = { + sMovementActionFuncs_x00, + sMovementActionFuncs_x01, + sMovementActionFuncs_x02, + sMovementActionFuncs_x03, + sMovementActionFuncs_x04, + sMovementActionFuncs_x05, + sMovementActionFuncs_x06, + sMovementActionFuncs_x07, + sMovementActionFuncs_x08, + sMovementActionFuncs_x09, + sMovementActionFuncs_x0A, + sMovementActionFuncs_x0B, + sMovementActionFuncs_x0C, + sMovementActionFuncs_x0D, + sMovementActionFuncs_x0E, + sMovementActionFuncs_x0F, + sMovementActionFuncs_x10, + sMovementActionFuncs_x11, + sMovementActionFuncs_x12, + sMovementActionFuncs_x13, + sMovementActionFuncs_x14, + sMovementActionFuncs_x15, + sMovementActionFuncs_x16, + sMovementActionFuncs_x17, + sMovementActionFuncs_x18, + sMovementActionFuncs_x19, + sMovementActionFuncs_x1A, + sMovementActionFuncs_x1B, + sMovementActionFuncs_x1C, + sMovementActionFuncs_x1D, + sMovementActionFuncs_x1E, + sMovementActionFuncs_x1F, + sMovementActionFuncs_x20, + sMovementActionFuncs_x21, + sMovementActionFuncs_x22, + sMovementActionFuncs_x23, + sMovementActionFuncs_x24, + sMovementActionFuncs_x25, + sMovementActionFuncs_x26, + sMovementActionFuncs_x27, + sMovementActionFuncs_x28, + sMovementActionFuncs_x29, + sMovementActionFuncs_x2A, + sMovementActionFuncs_x2B, + sMovementActionFuncs_x2C, + sMovementActionFuncs_x2D, + sMovementActionFuncs_x2E, + sMovementActionFuncs_x2F, + sMovementActionFuncs_x30, + sMovementActionFuncs_x31, + sMovementActionFuncs_x32, + sMovementActionFuncs_x33, + sMovementActionFuncs_x34, + sMovementActionFuncs_x35, + sMovementActionFuncs_x36, + sMovementActionFuncs_x37, + sMovementActionFuncs_x38, + sMovementActionFuncs_x39, + sMovementActionFuncs_x3A, + sMovementActionFuncs_x3B, + sMovementActionFuncs_x3C, + sMovementActionFuncs_x3D, + sMovementActionFuncs_x3E, + sMovementActionFuncs_x3F, + sMovementActionFuncs_x40, + sMovementActionFuncs_x41, + sMovementActionFuncs_x42, + sMovementActionFuncs_x43, + sMovementActionFuncs_x44, + sMovementActionFuncs_x45, + sMovementActionFuncs_x46, + sMovementActionFuncs_x47, + sMovementActionFuncs_x48, + sMovementActionFuncs_x49, + sMovementActionFuncs_x4A, + sMovementActionFuncs_x4B, + sMovementActionFuncs_x4C, + sMovementActionFuncs_x4D, + sMovementActionFuncs_x4E, + sMovementActionFuncs_x4F, + sMovementActionFuncs_x50, + sMovementActionFuncs_x51, + sMovementActionFuncs_x52, + sMovementActionFuncs_x53, + sMovementActionFuncs_x54, + sMovementActionFuncs_x55, + sMovementActionFuncs_x56, + sMovementActionFuncs_x57, + sMovementActionFuncs_x58, + sMovementActionFuncs_x59, + sMovementActionFuncs_x5A, + sMovementActionFuncs_x5B, + sMovementActionFuncs_x5C, + sMovementActionFuncs_x5D, + sMovementActionFuncs_x5E, + sMovementActionFuncs_x5F, + sMovementActionFuncs_x60, + sMovementActionFuncs_x61, + sMovementActionFuncs_x62, + sMovementActionFuncs_x63, + sMovementActionFuncs_x64, + sMovementActionFuncs_x65, + sMovementActionFuncs_x66, + sMovementActionFuncs_x67, + sMovementActionFuncs_x68, + sMovementActionFuncs_x69, + sMovementActionFuncs_x6A, + sMovementActionFuncs_x6B, + sMovementActionFuncs_x6C, + sMovementActionFuncs_x6D, + sMovementActionFuncs_x6E, + sMovementActionFuncs_x6F, + sMovementActionFuncs_x70, + sMovementActionFuncs_x71, + sMovementActionFuncs_x72, + sMovementActionFuncs_x73, + sMovementActionFuncs_x74, + sMovementActionFuncs_x75, + sMovementActionFuncs_x76, + sMovementActionFuncs_x77, + sMovementActionFuncs_x78, + sMovementActionFuncs_x79, + sMovementActionFuncs_x7A, + sMovementActionFuncs_x7B, + sMovementActionFuncs_x7C, + sMovementActionFuncs_x7D, + sMovementActionFuncs_x7E, + sMovementActionFuncs_x7F, + sMovementActionFuncs_x80, + sMovementActionFuncs_x81, + sMovementActionFuncs_x82, + sMovementActionFuncs_x83, + sMovementActionFuncs_x84, + sMovementActionFuncs_x85, + sMovementActionFuncs_x86, + sMovementActionFuncs_x87, + sMovementActionFuncs_x88, + sMovementActionFuncs_x89, + sMovementActionFuncs_x8A, + sMovementActionFuncs_x8B, + sMovementActionFuncs_x8C, + sMovementActionFuncs_x8D, + sMovementActionFuncs_x8E, + sMovementActionFuncs_x8F, + sMovementActionFuncs_x90, + sMovementActionFuncs_x91, + sMovementActionFuncs_x92, + sMovementActionFuncs_x93, + sMovementActionFuncs_x94, + sMovementActionFuncs_x95, + sMovementActionFuncs_x96, + sMovementActionFuncs_x97, + sMovementActionFuncs_x98, + sMovementActionFuncs_x99, + sMovementActionFuncs_x9A, + sMovementActionFuncs_x9B, + sMovementActionFuncs_x9C, + sMovementActionFuncs_x9D, + sMovementActionFuncs_x9E, + sMovementActionFuncs_x9F, + sMovementActionFuncs_xA0, + sMovementActionFuncs_xA1, + sMovementActionFuncs_xA2, + sMovementActionFuncs_xA3, + sMovementActionFuncs_xA4, + sMovementActionFuncs_xA5, + sMovementActionFuncs_xA6, + sMovementActionFuncs_xA7, + sMovementActionFuncs_xA8, + sMovementActionFuncs_xA9, +}; + +static bool8 (*const sMovementActionFuncs_x00[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_FaceDown_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x01[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_FaceUp_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x02[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_FaceLeft_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x03[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_FaceRight_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const gUnknown_83A6884[])(u8) = { + GetMoveDirectionAnimNum, + GetMoveDirectionFastAnimNum, + GetMoveDirectionFastAnimNum, + GetMoveDirectionFasterAnimNum, + GetMoveDirectionFastestAnimNum, +}; + +static bool8 (*const sMovementActionFuncs_x9B[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x9B_0, + MovementActionFunc_x9B_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x9C[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x9C_0, + MovementActionFunc_x9C_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x9D[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x9D_0, + MovementActionFunc_x9D_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x9E[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x9E_0, + MovementActionFunc_x9E_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x08[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x08_0, + MovementActionFunc_x08_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x09[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x09_0, + MovementActionFunc_x09_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x0A[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x0A_0, + MovementActionFunc_x0A_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x0B[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x0B_0, + MovementActionFunc_x0B_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x0D[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x0D_0, + MovementActionFunc_x0D_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x0C[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x0C_0, + MovementActionFunc_x0C_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x0E[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x0E_0, + MovementActionFunc_x0E_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x0F[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x0F_0, + MovementActionFunc_x0F_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x10[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkNormalDown_Step0, + MovementAction_WalkNormalDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x11[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkNormalUp_Step0, + MovementAction_WalkNormalUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x12[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkNormalLeft_Step0, + MovementAction_WalkNormalLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x13[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkNormalRight_Step0, + MovementAction_WalkNormalRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +const s16 gUnknown_83A6958[] = {0, 1, 1}; +const s16 gUnknown_83A695E[] = {0, 0, 1}; + +static bool8 (*const sMovementActionFuncs_x14[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Jump2Down_Step0, + MovementAction_Jump2Down_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x15[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Jump2Up_Step0, + MovementAction_Jump2Up_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x16[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Jump2Left_Step0, + MovementAction_Jump2Left_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x17[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Jump2Right_Step0, + MovementAction_Jump2Right_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x18[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Delay1_Step0, + MovementAction_Delay_Step1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x19[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Delay2_Step0, + MovementAction_Delay_Step1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x1A[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Delay4_Step0, + MovementAction_Delay_Step1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x1B[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Delay8_Step0, + MovementAction_Delay_Step1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x1C[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_Delay16_Step0, + MovementAction_Delay_Step1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x1D[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkFastDown_Step0, + MovementAction_WalkFastDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x1E[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkFastUp_Step0, + MovementAction_WalkFastUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x1F[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkFastLeft_Step0, + MovementAction_WalkFastLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x20[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkFastRight_Step0, + MovementAction_WalkFastRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_xA0[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA0_0, + MovementActionFunc_xA0_1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_xA1[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA1_0, + MovementActionFunc_xA1_1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_xA2[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA2_0, + MovementActionFunc_xA2_1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_xA3[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA3_0, + MovementActionFunc_xA3_1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x04[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x04_0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x05[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x05_0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x06[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x06_0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x07[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x07_0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x21[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceSlowDown_Step0, + MovementAction_WalkInPlaceSlow_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x22[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceSlowUp_Step0, + MovementAction_WalkInPlaceSlow_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x23[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceSlowLeft_Step0, + MovementAction_WalkInPlaceSlow_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x24[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceSlowRight_Step0, + MovementAction_WalkInPlaceSlow_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x25[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceNormalDown_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x26[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceNormalUp_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x27[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceNormalLeft_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x28[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceNormalRight_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x29[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceFastDown_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x2A[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceFastUp_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x2B[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceFastLeft_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x2C[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceFastRight_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x2D[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceFastestDown_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x2E[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceFastestUp_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x2F[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceFastestLeft_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x30[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkInPlaceFastestRight_Step0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x31[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_RideWaterCurrentDown_Step0, + MovementAction_RideWaterCurrentDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x32[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_RideWaterCurrentUp_Step0, + MovementAction_RideWaterCurrentUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x33[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_RideWaterCurrentLeft_Step0, + MovementAction_RideWaterCurrentLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x34[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_RideWaterCurrentRight_Step0, + MovementAction_RideWaterCurrentRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x35[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkFastestDown_Step0, + MovementAction_WalkFastestDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x36[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkFastestUp_Step0, + MovementAction_WalkFastestUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x37[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkFastestLeft_Step0, + MovementAction_WalkFastestLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x38[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkFastestRight_Step0, + MovementAction_WalkFastestRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x39[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_SlideDown_Step0, + MovementAction_SlideDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x3A[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_SlideUp_Step0, + MovementAction_SlideUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x3B[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_SlideLeft_Step0, + MovementAction_SlideLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x3C[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_SlideRight_Step0, + MovementAction_SlideRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x3D[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_PlayerRunDown_Step0, + MovementAction_PlayerRunDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x3E[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_PlayerRunUp_Step0, + MovementAction_PlayerRunUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x3F[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_PlayerRunLeft_Step0, + MovementAction_PlayerRunLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x40[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_PlayerRunRight_Step0, + MovementAction_PlayerRunRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x41[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x41_0, + MovementActionFunc_x41_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x42[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x42_0, + MovementActionFunc_x42_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x43[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x43_0, + MovementActionFunc_x43_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x44[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x44_0, + MovementActionFunc_x44_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x45[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_StartAnimInDirection_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x46[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpSpecialDown_Step0, + MovementAction_JumpSpecialDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x47[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpSpecialUp_Step0, + MovementAction_JumpSpecialUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x48[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpSpecialLeft_Step0, + MovementAction_JumpSpecialLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x49[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpSpecialRight_Step0, + MovementAction_JumpSpecialRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_xA6[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA6_0, + MovementActionFunc_xA6_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_xA7[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA7_0, + MovementActionFunc_xA7_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_xA8[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA8_0, + MovementActionFunc_xA8_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_xA9[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA9_0, + MovementActionFunc_xA9_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x4A[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_FacePlayer_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x4B[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_FaceAwayPlayer_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x4C[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_LockFacingDirection_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x4D[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_UnlockFacingDirection_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x4E[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpDown_Step0, + MovementAction_JumpDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x4F[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpUp_Step0, + MovementAction_JumpUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x50[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpLeft_Step0, + MovementAction_JumpLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x51[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpRight_Step0, + MovementAction_JumpRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x52[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpInPlaceDown_Step0, + MovementAction_JumpInPlaceDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x53[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpInPlaceUp_Step0, + MovementAction_JumpInPlaceUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x54[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpInPlaceLeft_Step0, + MovementAction_JumpInPlaceLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x55[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpInPlaceRight_Step0, + MovementAction_JumpInPlaceRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x56[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpInPlaceDownUp_Step0, + MovementAction_JumpInPlaceDownUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x57[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpInPlaceUpDown_Step0, + MovementAction_JumpInPlaceUpDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x58[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpInPlaceLeftRight_Step0, + MovementAction_JumpInPlaceLeftRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x59[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_JumpInPlaceRightLeft_Step0, + MovementAction_JumpInPlaceRightLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x5A[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_FaceOriginalDirection_Step0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x5B[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_NurseJoyBowDown_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x5C[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_EnableJumpLandingGroundEffect_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x5D[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_DisableJumpLandingGroundEffect_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x5E[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_DisableAnimation_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x5F[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_RestoreAnimation_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x60[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_SetInvisible_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x61[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_SetVisible_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x62[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_EmoteExclamationMark_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x63[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_EmoteQuestionMark_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x64[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_EmoteHeart_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x65[])(struct ObjectEvent *, struct Sprite *) = { + do_double_excl_bubble, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x66[])(struct ObjectEvent *, struct Sprite *) = { + do_smile_bubble, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x67[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_RevealTrainer_Step0, + MovementAction_RevealTrainer_Step1, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x68[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_RockSmashBreak_Step0, + MovementAction_RockSmashBreak_Step1, + MovementAction_RockSmashBreak_Step2, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x69[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_CutTree_Step0, + MovementAction_CutTree_Step1, + MovementAction_CutTree_Step2, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x6A[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_SetFixedPriority_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x6B[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_ClearFixedPriority_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x6C[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_InitAffineAnim_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x6D[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_ClearAffineAnim_Step0, + MovementAction_Finish, +}; + +static bool8 (*const sMovementActionFuncs_x6E[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkDownStartAffine_Step0, + MovementAction_WalkDownStartAffine_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x6F[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_WalkDownAffine_Step0, + MovementAction_WalkDownAffine_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x70[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x70_0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x71[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x71_0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x72[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x72_0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x73[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x73_0, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x74[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroPopWheelieDown_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x75[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroPopWheelieUp_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x76[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroPopWheelieLeft_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x77[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroPopWheelieRight_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x78[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroEndWheelieFaceDown_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x79[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroEndWheelieFaceUp_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x7A[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroEndWheelieFaceLeft_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x7B[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroEndWheelieFaceRight_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, + MovementAction_UnusedAcroActionDown_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, + MovementAction_UnusedAcroActionUp_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, + MovementAction_UnusedAcroActionLeft_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, + MovementAction_UnusedAcroActionRight_Step0, + MovementAction_WaitSpriteAnim, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x7C[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieHopFaceDown_Step0, + MovementAction_AcroWheelieHopFaceDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x7D[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieHopFaceUp_Step0, + MovementAction_AcroWheelieHopFaceUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x7E[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieHopFaceLeft_Step0, + MovementAction_AcroWheelieHopFaceLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x7F[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieHopFaceRight_Step0, + MovementAction_AcroWheelieHopFaceRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x80[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieHopDown_Step0, + MovementAction_AcroWheelieHopDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x81[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieHopUp_Step0, + MovementAction_AcroWheelieHopUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x82[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieHopLeft_Step0, + MovementAction_AcroWheelieHopLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x83[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieHopRight_Step0, + MovementAction_AcroWheelieHopRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x84[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieJumpDown_Step0, + MovementAction_AcroWheelieJumpDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x85[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieJumpUp_Step0, + MovementAction_AcroWheelieJumpUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x86[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieJumpLeft_Step0, + MovementAction_AcroWheelieJumpLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x87[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieJumpRight_Step0, + MovementAction_AcroWheelieJumpRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x88[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x88_0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x89[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x89_0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x8A[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x8A_0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x8B[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x8B_0, + MovementAction_WalkInPlace_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x8C[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroPopWheelieMoveDown_Step0, + MovementAction_AcroPopWheelieMoveDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x8D[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroPopWheelieMoveUp_Step0, + MovementAction_AcroPopWheelieMoveUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x8E[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroPopWheelieMoveLeft_Step0, + MovementAction_AcroPopWheelieMoveLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x8F[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroPopWheelieMoveRight_Step0, + MovementAction_AcroPopWheelieMoveRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x90[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieMoveDown_Step0, + MovementAction_AcroWheelieMoveDown_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x91[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieMoveUp_Step0, + MovementAction_AcroWheelieMoveUp_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x92[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieMoveLeft_Step0, + MovementAction_AcroWheelieMoveLeft_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x93[])(struct ObjectEvent *, struct Sprite *) = { + MovementAction_AcroWheelieMoveRight_Step0, + MovementAction_AcroWheelieMoveRight_Step1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x94[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x94_0, + MovementActionFunc_x94_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x95[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x95_0, + MovementActionFunc_x95_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x96[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x96_0, + MovementActionFunc_x96_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x97[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x97_0, + MovementActionFunc_x97_1, + MovementAction_PauseSpriteAnim, +}; + +static bool8 (*const sMovementActionFuncs_x98[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x98_0, + MovementActionFunc_x98_1, +}; + +static bool8 (*const sMovementActionFuncs_x99[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x98_0, + MovementActionFunc_x99_1, +}; + +static bool8 (*const sMovementActionFuncs_x9A[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x98_0, + MovementActionFunc_x9A_1, +}; + +static bool8 (*const sMovementActionFuncs_x9F[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_x9F_0, + MovementActionFunc_x9F_1, +}; + +static bool8 (*const sMovementActionFuncs_xA4[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA4_0, + MovementActionFunc_xA4_1, + MovementActionFunc_xA4_2, +}; + +static bool8 (*const sMovementActionFuncs_xA5[])(struct ObjectEvent *, struct Sprite *) = { + MovementActionFunc_xA5_0, + MovementActionFunc_xA5_1, + MovementActionFunc_xA4_2, +}; diff --git a/src/data/object_events/movement_type_func_tables.h b/src/data/object_events/movement_type_func_tables.h new file mode 100644 index 000000000..7f5ad4d11 --- /dev/null +++ b/src/data/object_events/movement_type_func_tables.h @@ -0,0 +1,613 @@ +static bool8 MovementType_WanderAround_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderAround_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderAround_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderAround_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderAround_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderAround_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderAround_Step5Duplicate(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderAround_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_LookAround_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_LookAround_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_LookAround_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_LookAround_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_LookAround_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderUpAndDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderUpAndDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderUpAndDown_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderUpAndDown_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderUpAndDown_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderUpAndDown_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderUpAndDown_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderLeftAndRight_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WanderLeftAndRight_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDirection_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDirection_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndUp_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndUp_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndUp_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownUpAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceUpLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_FaceDownLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_RotateCounterclockwise_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_RotateCounterclockwise_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_RotateCounterclockwise_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_RotateCounterclockwise_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_RotateClockwise_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_RotateClockwise_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_RotateClockwise_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_RotateClockwise_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkBackAndForth_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkBackAndForth_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkBackAndForth_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkBackAndForth_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequence_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequence_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceUpRightLeftDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceRightLeftDownUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceDownUpRightLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceLeftDownUpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceUpLeftRightDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceLeftRightDownUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceDownUpLeftRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceRightDownUpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceLeftUpDownRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceUpDownRightLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceRightLeftUpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceDownRightLeftUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceRightUpDownLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceUpDownLeftRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceLeftRightUpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceDownLeftRightUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceUpLeftDownRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceDownRightUpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceLeftDownRightUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceRightUpLeftDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceUpRightDownLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceDownLeftUpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceLeftUpRightDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSequenceRightDownLeftUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_CopyPlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_CopyPlayer_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_CopyPlayer_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 CopyablePlayerMovement_None(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 CopyablePlayerMovement_FaceDirection(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 CopyablePlayerMovement_GoSpeed0(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 CopyablePlayerMovement_GoSpeed1(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 CopyablePlayerMovement_GoSpeed2(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 CopyablePlayerMovement_Slide(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 cph_IM_DIFFERENT(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 CopyablePlayerMovement_GoSpeed4(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 CopyablePlayerMovement_Jump(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)); +static bool8 MovementType_CopyPlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_CopyPlayerInGrass_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_CopyPlayer_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_Hidden_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_MoveInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_WalkSlowlyInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_MoveInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_JogInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_MoveInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_Invisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_Invisible_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 MovementType_Invisible_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 sub_8063364(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 sub_8063384(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 sub_80633A4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 sub_80633B4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 sub_80633D4(struct ObjectEvent *objectEvent, struct Sprite *sprite); +static bool8 sub_80633F4(struct ObjectEvent *objectEvent, struct Sprite *sprite); + +static u8 GetVectorDirection(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_SouthNorth(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_WestEast(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_WestNorth(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_EastNorth(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_WestSouth(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_EastSouth(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_SouthNorthWest(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_SouthNorthEast(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_NorthWestEast(s16 dx, s16 dy, s16 absdx, s16 absdy); +static u8 GetLimitedVectorDirection_SouthWestEast(s16 dx, s16 dy, s16 absdx, s16 absdy); + +u8 (*const gMovementTypeFuncs_WanderAround[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WanderAround_Step0, + MovementType_WanderAround_Step1, + MovementType_WanderAround_Step2, + MovementType_WanderAround_Step3, + MovementType_WanderAround_Step4, + MovementType_WanderAround_Step5, + MovementType_WanderAround_Step6, +}; + +u8 (*const gMovementTypeFuncs_WanderAroundDuplicate[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WanderAround_Step0, + MovementType_WanderAround_Step1, + MovementType_WanderAround_Step2, + MovementType_WanderAround_Step3, + MovementType_WanderAround_Step4, + MovementType_WanderAround_Step5Duplicate, + MovementType_WanderAround_Step6, +}; + +const u8 gStandardDirections[] = {DIR_SOUTH, DIR_NORTH, DIR_WEST, DIR_EAST}; + +u8 (*const gGetVectorDirectionFuncs[])(s16, s16, s16, s16) = { + GetVectorDirection, + GetLimitedVectorDirection_SouthNorth, + GetLimitedVectorDirection_WestEast, + GetLimitedVectorDirection_WestNorth, + GetLimitedVectorDirection_EastNorth, + GetLimitedVectorDirection_WestSouth, + GetLimitedVectorDirection_EastSouth, + GetLimitedVectorDirection_SouthNorthWest, + GetLimitedVectorDirection_SouthNorthEast, + GetLimitedVectorDirection_NorthWestEast, + GetLimitedVectorDirection_SouthWestEast, +}; + +u8 (*const gMovementTypeFuncs_LookAround[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_LookAround_Step0, + MovementType_LookAround_Step1, + MovementType_LookAround_Step2, + MovementType_LookAround_Step3, + MovementType_LookAround_Step4, +}; + +u8 (*const gMovementTypeFuncs_WanderUpAndDown[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WanderUpAndDown_Step0, + MovementType_WanderUpAndDown_Step1, + MovementType_WanderUpAndDown_Step2, + MovementType_WanderUpAndDown_Step3, + MovementType_WanderUpAndDown_Step4, + MovementType_WanderUpAndDown_Step5, + MovementType_WanderUpAndDown_Step6, +}; + +const u8 gUpAndDownDirections[] = {DIR_SOUTH, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_WanderLeftAndRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WanderLeftAndRight_Step0, + MovementType_WanderLeftAndRight_Step1, + MovementType_WanderLeftAndRight_Step2, + MovementType_WanderLeftAndRight_Step3, + MovementType_WanderLeftAndRight_Step4, + MovementType_WanderLeftAndRight_Step5, + MovementType_WanderLeftAndRight_Step6, +}; + +const u8 gLeftAndRightDirections[] = {DIR_WEST, DIR_EAST}; + +u8 (*const gMovementTypeFuncs_FaceDirection[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceDirection_Step0, + MovementType_FaceDirection_Step1, + MovementType_FaceDirection_Step2, +}; + +u8 (*const gMovementTypeFuncs_FaceDownAndUp[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceDownAndUp_Step0, + MovementType_FaceDownAndUp_Step1, + MovementType_FaceDownAndUp_Step2, + MovementType_FaceDownAndUp_Step3, + MovementType_FaceDownAndUp_Step4, +}; + +u8 (*const gMovementTypeFuncs_FaceLeftAndRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceLeftAndRight_Step0, + MovementType_FaceLeftAndRight_Step1, + MovementType_FaceLeftAndRight_Step2, + MovementType_FaceLeftAndRight_Step3, + MovementType_FaceLeftAndRight_Step4, +}; + +u8 (*const gMovementTypeFuncs_FaceUpAndLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceUpAndLeft_Step0, + MovementType_FaceUpAndLeft_Step1, + MovementType_FaceUpAndLeft_Step2, + MovementType_FaceUpAndLeft_Step3, + MovementType_FaceUpAndLeft_Step4, +}; + +const u8 gUpAndLeftDirections[] = {DIR_NORTH, DIR_WEST}; + +u8 (*const gMovementTypeFuncs_FaceUpAndRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceUpAndRight_Step0, + MovementType_FaceUpAndRight_Step1, + MovementType_FaceUpAndRight_Step2, + MovementType_FaceUpAndRight_Step3, + MovementType_FaceUpAndRight_Step4, +}; + +const u8 gUpAndRightDirections[] = {DIR_NORTH, DIR_EAST}; + +u8 (*const gMovementTypeFuncs_FaceDownAndLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceDownAndLeft_Step0, + MovementType_FaceDownAndLeft_Step1, + MovementType_FaceDownAndLeft_Step2, + MovementType_FaceDownAndLeft_Step3, + MovementType_FaceDownAndLeft_Step4, +}; + +const u8 gDownAndLeftDirections[] = {DIR_SOUTH, DIR_WEST}; + +u8 (*const gMovementTypeFuncs_FaceDownAndRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceDownAndRight_Step0, + MovementType_FaceDownAndRight_Step1, + MovementType_FaceDownAndRight_Step2, + MovementType_FaceDownAndRight_Step3, + MovementType_FaceDownAndRight_Step4, +}; + +const u8 gDownAndRightDirections[] = {DIR_SOUTH, DIR_EAST}; + +u8 (*const gMovementTypeFuncs_FaceDownUpAndLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceDownUpAndLeft_Step0, + MovementType_FaceDownUpAndLeft_Step1, + MovementType_FaceDownUpAndLeft_Step2, + MovementType_FaceDownUpAndLeft_Step3, + MovementType_FaceDownUpAndLeft_Step4, +}; + +const u8 gDownUpAndLeftDirections[] = {DIR_NORTH, DIR_SOUTH, DIR_WEST, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_FaceDownUpAndRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceDownUpAndRight_Step0, + MovementType_FaceDownUpAndRight_Step1, + MovementType_FaceDownUpAndRight_Step2, + MovementType_FaceDownUpAndRight_Step3, + MovementType_FaceDownUpAndRight_Step4, +}; + +const u8 gDownUpAndRightDirections[] = {DIR_SOUTH, DIR_NORTH, DIR_EAST, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_FaceUpLeftAndRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceUpLeftAndRight_Step0, + MovementType_FaceUpLeftAndRight_Step1, + MovementType_FaceUpLeftAndRight_Step2, + MovementType_FaceUpLeftAndRight_Step3, + MovementType_FaceUpLeftAndRight_Step4, +}; + +const u8 gUpLeftAndRightDirections[] = {DIR_NORTH, DIR_WEST, DIR_EAST, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_FaceDownLeftAndRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_FaceDownLeftAndRight_Step0, + MovementType_FaceDownLeftAndRight_Step1, + MovementType_FaceDownLeftAndRight_Step2, + MovementType_FaceDownLeftAndRight_Step3, + MovementType_FaceDownLeftAndRight_Step4, +}; + +const u8 gDownLeftAndRightDirections[] = {DIR_WEST, DIR_EAST, DIR_SOUTH, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_RotateCounterclockwise[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_RotateCounterclockwise_Step0, + MovementType_RotateCounterclockwise_Step1, + MovementType_RotateCounterclockwise_Step2, + MovementType_RotateCounterclockwise_Step3, +}; + +const u8 gCounterclockwiseDirections[] = {DIR_SOUTH, DIR_EAST, DIR_WEST, DIR_SOUTH, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_RotateClockwise[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_RotateClockwise_Step0, + MovementType_RotateClockwise_Step1, + MovementType_RotateClockwise_Step2, + MovementType_RotateClockwise_Step3, +}; + +const u8 gClockwiseDirections[] = {DIR_SOUTH, DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_WalkBackAndForth[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkBackAndForth_Step0, + MovementType_WalkBackAndForth_Step1, + MovementType_WalkBackAndForth_Step2, + MovementType_WalkBackAndForth_Step3, +}; + +u8 (*const gMovementTypeFuncs_WalkSequenceUpRightLeftDown[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceUpRightLeftDown_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gUpRightLeftDownDirections[] = {DIR_NORTH, DIR_EAST, DIR_WEST, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceRightLeftDownUp[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceRightLeftDownUp_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gRightLeftDownUpDirections[] = {DIR_EAST, DIR_WEST, DIR_SOUTH, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceDownUpRightLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceDownUpRightLeft_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gDownUpRightLeftDirections[] = {DIR_SOUTH, DIR_NORTH, DIR_EAST, DIR_WEST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceLeftDownUpRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceLeftDownUpRight_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gLeftDownUpRightDirections[] = {DIR_WEST, DIR_SOUTH, DIR_NORTH, DIR_EAST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceUpLeftRightDown[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceUpLeftRightDown_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gUpLeftRightDownDirections[] = {DIR_NORTH, DIR_WEST, DIR_EAST, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceLeftRightDownUp[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceLeftRightDownUp_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gLeftRightDownUpDirections[] = {DIR_WEST, DIR_EAST, DIR_SOUTH, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceDownUpLeftRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceDownUpLeftRight_Step1, + MovementType_WalkSequence_Step2, +}; + +u8 (*const gMovementTypeFuncs_WalkSequenceRightDownUpLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceRightDownUpLeft_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gRightDownUpLeftDirections[] = {DIR_EAST, DIR_SOUTH, DIR_NORTH, DIR_WEST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceLeftUpDownRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceLeftUpDownRight_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gLeftUpDownRightDirections[] = {DIR_WEST, DIR_NORTH, DIR_SOUTH, DIR_EAST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceUpDownRightLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceUpDownRightLeft_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gUpDownRightLeftDirections[] = {DIR_NORTH, DIR_SOUTH, DIR_EAST, DIR_WEST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceRightLeftUpDown[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceRightLeftUpDown_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gRightLeftUpDownDirections[] = {DIR_EAST, DIR_WEST, DIR_NORTH, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceDownRightLeftUp[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceDownRightLeftUp_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gDownRightLeftUpDirections[] = {DIR_SOUTH, DIR_EAST, DIR_WEST, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceRightUpDownLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceRightUpDownLeft_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gRightUpDownLeftDirections[] = {DIR_EAST, DIR_NORTH, DIR_SOUTH, DIR_WEST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceUpDownLeftRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceUpDownLeftRight_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gUpDownLeftRightDirections[] = {DIR_NORTH, DIR_SOUTH, DIR_WEST, DIR_EAST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceLeftRightUpDown[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceLeftRightUpDown_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gLeftRightUpDownDirections[] = {DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceDownLeftRightUp[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceDownLeftRightUp_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gDownLeftRightUpDirections[] = {DIR_SOUTH, DIR_WEST, DIR_EAST, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceUpLeftDownRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceUpLeftDownRight_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gUpLeftDownRightDirections[] = {DIR_NORTH, DIR_WEST, DIR_SOUTH, DIR_EAST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceDownRightUpLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceDownRightUpLeft_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gDownRightUpLeftDirections[] = {DIR_SOUTH, DIR_EAST, DIR_NORTH, DIR_WEST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceLeftDownRightUp[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceLeftDownRightUp_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gLeftDownRightUpDirections[] = {DIR_WEST, DIR_SOUTH, DIR_EAST, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceRightUpLeftDown[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceRightUpLeftDown_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gRightUpLeftDownDirections[] = {DIR_EAST, DIR_NORTH, DIR_WEST, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceUpRightDownLeft[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceUpRightDownLeft_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gUpRightDownLeftDirections[] = {DIR_NORTH, DIR_EAST, DIR_SOUTH, DIR_WEST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceDownLeftUpRight[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceDownLeftUpRight_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gDownLeftUpRightDirections[] = {DIR_SOUTH, DIR_WEST, DIR_NORTH, DIR_EAST}; + +u8 (*const gMovementTypeFuncs_WalkSequenceLeftUpRightDown[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceLeftUpRightDown_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gLeftUpRightDownDirections[] = {DIR_WEST, DIR_NORTH, DIR_EAST, DIR_SOUTH}; + +u8 (*const gMovementTypeFuncs_WalkSequenceRightDownLeftUp[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSequence_Step0, + MovementType_WalkSequenceRightDownLeftUp_Step1, + MovementType_WalkSequence_Step2, +}; + +const u8 gRightDownLeftUpDirections[] = {DIR_EAST, DIR_SOUTH, DIR_WEST, DIR_NORTH}; + +u8 (*const gMovementTypeFuncs_CopyPlayer[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_CopyPlayer_Step0, + MovementType_CopyPlayer_Step1, + MovementType_CopyPlayer_Step2, +}; + +bool8 (*const gCopyPlayerMovementFuncs[])(struct ObjectEvent *, struct Sprite *, u8, bool8(u8)) = { + CopyablePlayerMovement_None, + CopyablePlayerMovement_FaceDirection, + CopyablePlayerMovement_GoSpeed0, + CopyablePlayerMovement_GoSpeed1, + CopyablePlayerMovement_GoSpeed2, + CopyablePlayerMovement_Slide, + cph_IM_DIFFERENT, + CopyablePlayerMovement_GoSpeed4, + CopyablePlayerMovement_Jump, + CopyablePlayerMovement_None, + CopyablePlayerMovement_None, +}; + +u8 (*const gMovementTypeFuncs_CopyPlayerInGrass[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_CopyPlayer_Step0, + MovementType_CopyPlayerInGrass_Step1, + MovementType_CopyPlayer_Step2, +}; + +u8 (*const gMovementTypeFuncs_Hidden[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_Hidden_Step0, +}; + +u8 (*const gMovementTypeFuncs_WalkInPlace[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkInPlace_Step0, + MovementType_MoveInPlace_Step1, +}; + +u8 (*const gMovementTypeFuncs_WalkSlowlyInPlace[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_WalkSlowlyInPlace_Step0, + MovementType_MoveInPlace_Step1, +}; + +u8 (*const gMovementTypeFuncs_JogInPlace[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_JogInPlace_Step0, + MovementType_MoveInPlace_Step1, +}; + +u8 (*const gMovementTypeFuncs_Invisible[])(struct ObjectEvent *, struct Sprite *) = { + MovementType_Invisible_Step0, + MovementType_Invisible_Step1, + MovementType_Invisible_Step2, +}; + +u8 (*const gUnknown_83A63F0[])(struct ObjectEvent *, struct Sprite *) = { + sub_8063364, + sub_8063384, + sub_80633A4, +}; + +u8 (*const gUnknown_83A63FC[])(struct ObjectEvent *, struct Sprite *) = { + sub_80633B4, + sub_80633F4, +}; + +u8 (*const gUnknown_83A6404[])(struct ObjectEvent *, struct Sprite *) = { + sub_80633D4, + sub_80633F4, +}; diff --git a/src/data/object_events/object_event_anims.h b/src/data/object_events/object_event_anims.h new file mode 100644 index 000000000..ae79226e3 --- /dev/null +++ b/src/data/object_events/object_event_anims.h @@ -0,0 +1,1298 @@ +const union AnimCmd gAnimCmd_83A2950[] = { + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(0, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2964[] = { + ANIMCMD_FRAME(0, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A296C[] = { + ANIMCMD_FRAME(1, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2974[] = { + ANIMCMD_FRAME(2, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A297C[] = { + ANIMCMD_FRAME(2, 16, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2984[] = { + ANIMCMD_FRAME(3, 8), + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(3, 8, .hFlip = TRUE), + ANIMCMD_FRAME(0, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2998[] = { + ANIMCMD_FRAME(4, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(4, 8, .hFlip = TRUE), + ANIMCMD_FRAME(1, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A29AC[] = { + ANIMCMD_FRAME(5, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(6, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A29C0[] = { + ANIMCMD_FRAME(5, 8, .hFlip = TRUE), + ANIMCMD_FRAME(2, 8, .hFlip = TRUE), + ANIMCMD_FRAME(6, 8, .hFlip = TRUE), + ANIMCMD_FRAME(2, 8, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A29D4[] = { + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(3, 4, .hFlip = TRUE), + ANIMCMD_FRAME(0, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A29E8[] = { + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(4, 4, .hFlip = TRUE), + ANIMCMD_FRAME(1, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A29FC[] = { + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2A10[] = { + ANIMCMD_FRAME(5, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_FRAME(6, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2A24[] = { + ANIMCMD_FRAME(3, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(3, 2, .hFlip = TRUE), + ANIMCMD_FRAME(0, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2A38[] = { + ANIMCMD_FRAME(4, 2), + ANIMCMD_FRAME(1, 2), + ANIMCMD_FRAME(4, 2, .hFlip = TRUE), + ANIMCMD_FRAME(1, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2A4C[] = { + ANIMCMD_FRAME(5, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_FRAME(6, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2A60[] = { + ANIMCMD_FRAME(5, 2, .hFlip = TRUE), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_FRAME(6, 2, .hFlip = TRUE), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2A74[] = { + ANIMCMD_FRAME(3, 1), + ANIMCMD_FRAME(0, 1), + ANIMCMD_FRAME(3, 1, .hFlip = TRUE), + ANIMCMD_FRAME(0, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2A88[] = { + ANIMCMD_FRAME(4, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_FRAME(4, 1, .hFlip = TRUE), + ANIMCMD_FRAME(1, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2A9C[] = { + ANIMCMD_FRAME(5, 1), + ANIMCMD_FRAME(2, 1), + ANIMCMD_FRAME(6, 1), + ANIMCMD_FRAME(2, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2AB0[] = { + ANIMCMD_FRAME(5, 1, .hFlip = TRUE), + ANIMCMD_FRAME(2, 1, .hFlip = TRUE), + ANIMCMD_FRAME(6, 1, .hFlip = TRUE), + ANIMCMD_FRAME(2, 1, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2AC4[] = { + ANIMCMD_FRAME(0, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2ACC[] = { + ANIMCMD_FRAME(1, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2AD4[] = { + ANIMCMD_FRAME(2, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2ADC[] = { + ANIMCMD_FRAME(2, 16, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2AE4[] = { + ANIMCMD_FRAME(3, 8), + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(4, 8), + ANIMCMD_FRAME(0, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2AF8[] = { + ANIMCMD_FRAME(5, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(6, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2B0C[] = { + ANIMCMD_FRAME(7, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(8, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2B20[] = { + ANIMCMD_FRAME(7, 8, .hFlip = TRUE), + ANIMCMD_FRAME(2, 8, .hFlip = TRUE), + ANIMCMD_FRAME(8, 8, .hFlip = TRUE), + ANIMCMD_FRAME(2, 8, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2B34[] = { + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2B48[] = { + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2B5C[] = { + ANIMCMD_FRAME(7, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2B70[] = { + ANIMCMD_FRAME(7, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_FRAME(8, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2B84[] = { + ANIMCMD_FRAME(3, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(4, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2B98[] = { + ANIMCMD_FRAME(5, 2), + ANIMCMD_FRAME(1, 2), + ANIMCMD_FRAME(6, 2), + ANIMCMD_FRAME(1, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2BAC[] = { + ANIMCMD_FRAME(7, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_FRAME(8, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2BC0[] = { + ANIMCMD_FRAME(7, 2, .hFlip = TRUE), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_FRAME(8, 2, .hFlip = TRUE), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2BD4[] = { + ANIMCMD_FRAME(3, 1), + ANIMCMD_FRAME(0, 1), + ANIMCMD_FRAME(4, 1), + ANIMCMD_FRAME(0, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2BE8[] = { + ANIMCMD_FRAME(5, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_FRAME(6, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2BFC[] = { + ANIMCMD_FRAME(7, 1), + ANIMCMD_FRAME(2, 1), + ANIMCMD_FRAME(8, 1), + ANIMCMD_FRAME(2, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C10[] = { + ANIMCMD_FRAME(7, 1, .hFlip = TRUE), + ANIMCMD_FRAME(2, 1, .hFlip = TRUE), + ANIMCMD_FRAME(8, 1, .hFlip = TRUE), + ANIMCMD_FRAME(2, 1, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C24[] = { + ANIMCMD_FRAME(9, 0), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A2C2C[] = { + ANIMCMD_FRAME(3, 8), + ANIMCMD_FRAME(4, 8), + ANIMCMD_FRAME(3, 8), + ANIMCMD_FRAME(4, 8), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C40[] = { + ANIMCMD_FRAME(3, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C48[] = { + ANIMCMD_FRAME(0, 60), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C50[] = { + ANIMCMD_FRAME(1, 60), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C58[] = { + ANIMCMD_FRAME(2, 60), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C60[] = { + ANIMCMD_FRAME(2, 60, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C68[] = { + ANIMCMD_FRAME(0, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C70[] = { + ANIMCMD_FRAME(1, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C78[] = { + ANIMCMD_FRAME(2, 16), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C80[] = { + ANIMCMD_FRAME(2, 16, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2C88[] = { + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2CAC[] = { + ANIMCMD_FRAME(7, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(7, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(9, 4), + ANIMCMD_FRAME(10, 4), + ANIMCMD_FRAME(9, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2CD0[] = { + ANIMCMD_FRAME(11, 4), + ANIMCMD_FRAME(12, 4), + ANIMCMD_FRAME(11, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(13, 4), + ANIMCMD_FRAME(14, 4), + ANIMCMD_FRAME(13, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2CF4[] = { + ANIMCMD_FRAME(11, 4, .hFlip = TRUE), + ANIMCMD_FRAME(12, 4, .hFlip = TRUE), + ANIMCMD_FRAME(11, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_FRAME(13, 4, .hFlip = TRUE), + ANIMCMD_FRAME(14, 4, .hFlip = TRUE), + ANIMCMD_FRAME(13, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2D18[] = { + ANIMCMD_FRAME(3, 2), + ANIMCMD_FRAME(4, 2), + ANIMCMD_FRAME(3, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(5, 2), + ANIMCMD_FRAME(6, 2), + ANIMCMD_FRAME(5, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2D3C[] = { + ANIMCMD_FRAME(7, 2), + ANIMCMD_FRAME(8, 2), + ANIMCMD_FRAME(7, 2), + ANIMCMD_FRAME(1, 2), + ANIMCMD_FRAME(9, 2), + ANIMCMD_FRAME(10, 2), + ANIMCMD_FRAME(9, 2), + ANIMCMD_FRAME(1, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2D60[] = { + ANIMCMD_FRAME(11, 2), + ANIMCMD_FRAME(12, 2), + ANIMCMD_FRAME(11, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_FRAME(13, 2), + ANIMCMD_FRAME(14, 2), + ANIMCMD_FRAME(13, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2D84[] = { + ANIMCMD_FRAME(11, 2, .hFlip = TRUE), + ANIMCMD_FRAME(12, 2, .hFlip = TRUE), + ANIMCMD_FRAME(11, 2, .hFlip = TRUE), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_FRAME(13, 2, .hFlip = TRUE), + ANIMCMD_FRAME(14, 2, .hFlip = TRUE), + ANIMCMD_FRAME(13, 2, .hFlip = TRUE), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2DA8[] = { + ANIMCMD_FRAME(3, 1), + ANIMCMD_FRAME(4, 1), + ANIMCMD_FRAME(3, 1), + ANIMCMD_FRAME(0, 1), + ANIMCMD_FRAME(5, 1), + ANIMCMD_FRAME(6, 1), + ANIMCMD_FRAME(5, 1), + ANIMCMD_FRAME(0, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2DCC[] = { + ANIMCMD_FRAME(7, 1), + ANIMCMD_FRAME(8, 1), + ANIMCMD_FRAME(7, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_FRAME(9, 1), + ANIMCMD_FRAME(10, 1), + ANIMCMD_FRAME(9, 1), + ANIMCMD_FRAME(1, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2DF0[] = { + ANIMCMD_FRAME(11, 1), + ANIMCMD_FRAME(12, 1), + ANIMCMD_FRAME(11, 1), + ANIMCMD_FRAME(2, 1), + ANIMCMD_FRAME(13, 1), + ANIMCMD_FRAME(14, 1), + ANIMCMD_FRAME(13, 1), + ANIMCMD_FRAME(2, 1), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2E14[] = { + ANIMCMD_FRAME(11, 1, .hFlip = TRUE), + ANIMCMD_FRAME(12, 1, .hFlip = TRUE), + ANIMCMD_FRAME(11, 1, .hFlip = TRUE), + ANIMCMD_FRAME(2, 1, .hFlip = TRUE), + ANIMCMD_FRAME(13, 1, .hFlip = TRUE), + ANIMCMD_FRAME(14, 1, .hFlip = TRUE), + ANIMCMD_FRAME(13, 1, .hFlip = TRUE), + ANIMCMD_FRAME(2, 1, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2E38[] = { + ANIMCMD_FRAME(3, 0), + ANIMCMD_FRAME(4, 0), + ANIMCMD_FRAME(3, 0), + ANIMCMD_FRAME(0, 0), + ANIMCMD_FRAME(5, 0), + ANIMCMD_FRAME(6, 0), + ANIMCMD_FRAME(5, 0), + ANIMCMD_FRAME(0, 0), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2E5C[] = { + ANIMCMD_FRAME(7, 0), + ANIMCMD_FRAME(8, 0), + ANIMCMD_FRAME(7, 0), + ANIMCMD_FRAME(1, 0), + ANIMCMD_FRAME(9, 0), + ANIMCMD_FRAME(10, 0), + ANIMCMD_FRAME(9, 0), + ANIMCMD_FRAME(1, 0), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2E80[] = { + ANIMCMD_FRAME(11, 0), + ANIMCMD_FRAME(12, 0), + ANIMCMD_FRAME(11, 0), + ANIMCMD_FRAME(2, 0), + ANIMCMD_FRAME(13, 0), + ANIMCMD_FRAME(14, 0), + ANIMCMD_FRAME(13, 0), + ANIMCMD_FRAME(2, 0), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2EA4[] = { + ANIMCMD_FRAME(11, 0, .hFlip = TRUE), + ANIMCMD_FRAME(12, 0, .hFlip = TRUE), + ANIMCMD_FRAME(11, 0, .hFlip = TRUE), + ANIMCMD_FRAME(2, 0, .hFlip = TRUE), + ANIMCMD_FRAME(13, 0, .hFlip = TRUE), + ANIMCMD_FRAME(14, 0, .hFlip = TRUE), + ANIMCMD_FRAME(13, 0, .hFlip = TRUE), + ANIMCMD_FRAME(2, 0, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2EC8[] = { + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_FRAME(1, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A2EE0[] = { + ANIMCMD_FRAME(1, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A2EF8[] = { + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_FRAME(1, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A2F10[] = { + ANIMCMD_FRAME(2, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(2, 2, .hFlip = TRUE), + ANIMCMD_FRAME(1, 2), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A2F28[] = { + ANIMCMD_FRAME(18, 16), + ANIMCMD_FRAME(0, 16), + ANIMCMD_FRAME(19, 16), + ANIMCMD_FRAME(0, 32), + ANIMCMD_LOOP(1), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A2F40[] = { + ANIMCMD_FRAME(9, 5), + ANIMCMD_FRAME(10, 3), + ANIMCMD_FRAME(9, 5), + ANIMCMD_FRAME(11, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2F54[] = { + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(13, 3), + ANIMCMD_FRAME(12, 5), + ANIMCMD_FRAME(14, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2F68[] = { + ANIMCMD_FRAME(15, 5), + ANIMCMD_FRAME(16, 3), + ANIMCMD_FRAME(15, 5), + ANIMCMD_FRAME(17, 3), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2F7C[] = { + ANIMCMD_FRAME(15, 5, .hFlip = TRUE), + ANIMCMD_FRAME(16, 3, .hFlip = TRUE), + ANIMCMD_FRAME(15, 5, .hFlip = TRUE), + ANIMCMD_FRAME(17, 3, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A2F90[] = { + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(4, 8), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A2FA8[] = { + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_LOOP(0), + ANIMCMD_FRAME(7, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_LOOP(6), + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A2FD8[] = { + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_LOOP(0), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(5, 4), + ANIMCMD_LOOP(6), + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A300C[] = { + ANIMCMD_FRAME(9, 32), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A3014[] = { + ANIMCMD_FRAME(10, 32), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A301C[] = { + ANIMCMD_FRAME(11, 32), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A3024[] = { + ANIMCMD_FRAME(11, 32, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A302C[] = { + ANIMCMD_FRAME(15, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3038[] = { + ANIMCMD_FRAME(19, 4), + ANIMCMD_FRAME(20, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3044[] = { + ANIMCMD_FRAME(23, 4), + ANIMCMD_FRAME(24, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3050[] = { + ANIMCMD_FRAME(23, 4, .hFlip = TRUE), + ANIMCMD_FRAME(24, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A305C[] = { + ANIMCMD_FRAME(17, 4), + ANIMCMD_FRAME(18, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3068[] = { + ANIMCMD_FRAME(21, 4), + ANIMCMD_FRAME(22, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3074[] = { + ANIMCMD_FRAME(25, 4), + ANIMCMD_FRAME(26, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3080[] = { + ANIMCMD_FRAME(25, 4, .hFlip = TRUE), + ANIMCMD_FRAME(26, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A308C[] = { + ANIMCMD_FRAME(15, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3098[] = { + ANIMCMD_FRAME(19, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A30A4[] = { + ANIMCMD_FRAME(23, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A30B0[] = { + ANIMCMD_FRAME(23, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A30BC[] = { + ANIMCMD_FRAME(17, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A30C8[] = { + ANIMCMD_FRAME(21, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A30D4[] = { + ANIMCMD_FRAME(25, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A30E0[] = { + ANIMCMD_FRAME(25, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A30EC[] = { + ANIMCMD_FRAME(27, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_FRAME(28, 4), + ANIMCMD_FRAME(16, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A3100[] = { + ANIMCMD_FRAME(29, 4), + ANIMCMD_FRAME(20, 4), + ANIMCMD_FRAME(30, 4), + ANIMCMD_FRAME(20, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A3114[] = { + ANIMCMD_FRAME(31, 4), + ANIMCMD_FRAME(24, 4), + ANIMCMD_FRAME(32, 4), + ANIMCMD_FRAME(24, 4), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A3128[] = { + ANIMCMD_FRAME(31, 4, .hFlip = TRUE), + ANIMCMD_FRAME(24, 4, .hFlip = TRUE), + ANIMCMD_FRAME(32, 4, .hFlip = TRUE), + ANIMCMD_FRAME(24, 4, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A313C[] = { + ANIMCMD_FRAME(0, 32), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3144[] = { + ANIMCMD_FRAME(1, 32), + ANIMCMD_FRAME(2, 32), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3150[] = { + ANIMCMD_FRAME(3, 48), + ANIMCMD_FRAME(4, 48), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A315C[] = { + ANIMCMD_FRAME(5, 32), + ANIMCMD_FRAME(5, 32), + ANIMCMD_FRAME(6, 32), + ANIMCMD_FRAME(6, 32), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3170[] = { + ANIMCMD_FRAME(7, 48), + ANIMCMD_FRAME(7, 48), + ANIMCMD_FRAME(8, 48), + ANIMCMD_FRAME(8, 48), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3184[] = { + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(9, 32), + ANIMCMD_FRAME(0, 8), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3194[] = { + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(3, 8), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A31A8[] = { + ANIMCMD_FRAME(0, 6), + ANIMCMD_FRAME(1, 6), + ANIMCMD_FRAME(2, 6), + ANIMCMD_FRAME(3, 6), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A31BC[] = { + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(9, 4), + ANIMCMD_FRAME(10, 4), + ANIMCMD_FRAME(11, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A31D0[] = { + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(5, 4), + ANIMCMD_FRAME(6, 4), + ANIMCMD_FRAME(7, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A31E4[] = { + ANIMCMD_FRAME(0, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(3, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A31F8[] = { + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_FRAME(1, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_FRAME(3, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A320C[] = { + ANIMCMD_FRAME(11, 4), + ANIMCMD_FRAME(10, 6), + ANIMCMD_FRAME(9, 6), + ANIMCMD_FRAME(8, 6), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3220[] = { + ANIMCMD_FRAME(7, 4), + ANIMCMD_FRAME(6, 6), + ANIMCMD_FRAME(5, 6), + ANIMCMD_FRAME(4, 6), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3234[] = { + ANIMCMD_FRAME(3, 4), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(0, 4), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A3248[] = { + ANIMCMD_FRAME(3, 4, .hFlip = TRUE), + ANIMCMD_FRAME(2, 4, .hFlip = TRUE), + ANIMCMD_FRAME(1, 4, .hFlip = TRUE), + ANIMCMD_FRAME(0, 4, .hFlip = TRUE), + ANIMCMD_END, +}; + +const union AnimCmd gAnimCmd_83A325C[] = { + ANIMCMD_FRAME(10, 6), + ANIMCMD_FRAME(11, 6), + ANIMCMD_LOOP(1), + ANIMCMD_FRAME(11, 30), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A3270[] = { + ANIMCMD_FRAME(6, 6), + ANIMCMD_FRAME(7, 6), + ANIMCMD_LOOP(1), + ANIMCMD_FRAME(7, 30), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A3284[] = { + ANIMCMD_FRAME(2, 6), + ANIMCMD_FRAME(3, 6), + ANIMCMD_LOOP(1), + ANIMCMD_FRAME(3, 30), + ANIMCMD_JUMP(0), +}; + +const union AnimCmd gAnimCmd_83A3298[] = { + ANIMCMD_FRAME(2, 6, .hFlip = TRUE), + ANIMCMD_FRAME(3, 6, .hFlip = TRUE), + ANIMCMD_LOOP(1), + ANIMCMD_FRAME(3, 30, .hFlip = TRUE), + ANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gUnknown_83A32AC[] = { + AFFINEANIMCMD_FRAME(0, 0, 1, 1), + AFFINEANIMCMD_FRAME(0, 0, 0, 1), + AFFINEANIMCMD_FRAME(0, 0, 0, 1), + AFFINEANIMCMD_FRAME(0, 0, 0, 1), + AFFINEANIMCMD_LOOP(7), + AFFINEANIMCMD_JUMP(0), +}; + +const union AffineAnimCmd gUnknown_83A32DC[] = { + AFFINEANIMCMD_FRAME(0, 0, -1, 1), + AFFINEANIMCMD_FRAME(0, 0, 0, 1), + AFFINEANIMCMD_LOOP(15), + AFFINEANIMCMD_FRAME(0, 0, 1, 1), + AFFINEANIMCMD_FRAME(0, 0, 0, 1), + AFFINEANIMCMD_LOOP(15), + AFFINEANIMCMD_JUMP(0), +}; + +const union AnimCmd *const gObjectEventImageAnimTable_Inanimate[] = { + gAnimCmd_83A2950 +}; + +const union AnimCmd *const gAnimTable_83A3318[] = { + gAnimCmd_83A2964, + gAnimCmd_83A296C, + gAnimCmd_83A2974, + gAnimCmd_83A297C, + gAnimCmd_83A2984, + gAnimCmd_83A2998, + gAnimCmd_83A29AC, + gAnimCmd_83A29C0, + gAnimCmd_83A29D4, + gAnimCmd_83A29E8, + gAnimCmd_83A29FC, + gAnimCmd_83A2A10, + gAnimCmd_83A2A24, + gAnimCmd_83A2A38, + gAnimCmd_83A2A4C, + gAnimCmd_83A2A60, + gAnimCmd_83A2A74, + gAnimCmd_83A2A88, + gAnimCmd_83A2A9C, + gAnimCmd_83A2AB0, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_Standard[] = { + gAnimCmd_83A2AC4, + gAnimCmd_83A2ACC, + gAnimCmd_83A2AD4, + gAnimCmd_83A2ADC, + gAnimCmd_83A2AE4, + gAnimCmd_83A2AF8, + gAnimCmd_83A2B0C, + gAnimCmd_83A2B20, + gAnimCmd_83A2B34, + gAnimCmd_83A2B48, + gAnimCmd_83A2B5C, + gAnimCmd_83A2B70, + gAnimCmd_83A2B84, + gAnimCmd_83A2B98, + gAnimCmd_83A2BAC, + gAnimCmd_83A2BC0, + gAnimCmd_83A2BD4, + gAnimCmd_83A2BE8, + gAnimCmd_83A2BFC, + gAnimCmd_83A2C10, + gAnimCmd_83A2C24, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_HoOh[] = { + gAnimCmd_83A2AC4, + gAnimCmd_83A2ACC, + gAnimCmd_83A2AD4, + gAnimCmd_83A2ADC, + gAnimCmd_83A2C2C, + gAnimCmd_83A2C40, + gAnimCmd_83A2B0C, + gAnimCmd_83A2B20, + gAnimCmd_83A2B34, + gAnimCmd_83A2B48, + gAnimCmd_83A2B5C, + gAnimCmd_83A2B70, + gAnimCmd_83A2B84, + gAnimCmd_83A2B98, + gAnimCmd_83A2BAC, + gAnimCmd_83A2BC0, + gAnimCmd_83A2BD4, + gAnimCmd_83A2BE8, + gAnimCmd_83A2BFC, + gAnimCmd_83A2C10, + gAnimCmd_83A2C24, +}; + +const union AnimCmd *const gAnimTable_83A3410[] = { + gAnimCmd_83A2C68, + gAnimCmd_83A2C70, + gAnimCmd_83A2C78, + gAnimCmd_83A2C80, + gAnimCmd_83A2C88, + gAnimCmd_83A2CAC, + gAnimCmd_83A2CD0, + gAnimCmd_83A2CF4, + gAnimCmd_83A2D18, + gAnimCmd_83A2D3C, + gAnimCmd_83A2D60, + gAnimCmd_83A2D84, + gAnimCmd_83A2DA8, + gAnimCmd_83A2DCC, + gAnimCmd_83A2DF0, + gAnimCmd_83A2E14, + gAnimCmd_83A2E38, + gAnimCmd_83A2E5C, + gAnimCmd_83A2E80, + gAnimCmd_83A2EA4, + gAnimCmd_83A2F40, + gAnimCmd_83A2F54, + gAnimCmd_83A2F68, + gAnimCmd_83A2F7C, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_RedGreenNormal[] = { + gAnimCmd_83A2AC4, + gAnimCmd_83A2ACC, + gAnimCmd_83A2AD4, + gAnimCmd_83A2ADC, + gAnimCmd_83A2AE4, + gAnimCmd_83A2AF8, + gAnimCmd_83A2B0C, + gAnimCmd_83A2B20, + gAnimCmd_83A2B34, + gAnimCmd_83A2B48, + gAnimCmd_83A2B5C, + gAnimCmd_83A2B70, + gAnimCmd_83A2B84, + gAnimCmd_83A2B98, + gAnimCmd_83A2BAC, + gAnimCmd_83A2BC0, + gAnimCmd_83A2BD4, + gAnimCmd_83A2BE8, + gAnimCmd_83A2BFC, + gAnimCmd_83A2C10, + gAnimCmd_83A2F40, + gAnimCmd_83A2F54, + gAnimCmd_83A2F68, + gAnimCmd_83A2F7C, + gAnimCmd_83A2EC8, + gAnimCmd_83A2EE0, + gAnimCmd_83A2EF8, + gAnimCmd_83A2F10, + gAnimCmd_83A2F28, +}; + +const union AnimCmd *const gAnimTable_83A34E4[] = { + gAnimCmd_83A2AC4, + gAnimCmd_83A2ACC, + gAnimCmd_83A2AD4, + gAnimCmd_83A2ADC, + gAnimCmd_83A2AE4, + gAnimCmd_83A2AF8, + gAnimCmd_83A2B0C, + gAnimCmd_83A2B20, + gAnimCmd_83A2B34, + gAnimCmd_83A2B48, + gAnimCmd_83A2B5C, + gAnimCmd_83A2B70, + gAnimCmd_83A2B84, + gAnimCmd_83A2B98, + gAnimCmd_83A2BAC, + gAnimCmd_83A2BC0, + gAnimCmd_83A2BD4, + gAnimCmd_83A2BE8, + gAnimCmd_83A2BFC, + gAnimCmd_83A2C10, + gAnimCmd_83A302C, + gAnimCmd_83A3038, + gAnimCmd_83A3044, + gAnimCmd_83A3050, + gAnimCmd_83A305C, + gAnimCmd_83A3068, + gAnimCmd_83A3074, + gAnimCmd_83A3080, + gAnimCmd_83A308C, + gAnimCmd_83A3098, + gAnimCmd_83A30A4, + gAnimCmd_83A30B0, + gAnimCmd_83A30BC, + gAnimCmd_83A30C8, + gAnimCmd_83A30D4, + gAnimCmd_83A30E0, + gAnimCmd_83A30EC, + gAnimCmd_83A3100, + gAnimCmd_83A3114, + gAnimCmd_83A3128, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_RedGreenSurf[] = { + gAnimCmd_83A2C48, + gAnimCmd_83A2C50, + gAnimCmd_83A2C58, + gAnimCmd_83A2C60, + gAnimCmd_83A2C48, + gAnimCmd_83A2C50, + gAnimCmd_83A2C58, + gAnimCmd_83A2C60, + gAnimCmd_83A2C48, + gAnimCmd_83A2C50, + gAnimCmd_83A2C58, + gAnimCmd_83A2C60, + gAnimCmd_83A2C48, + gAnimCmd_83A2C50, + gAnimCmd_83A2C58, + gAnimCmd_83A2C60, + gAnimCmd_83A2C48, + gAnimCmd_83A2C50, + gAnimCmd_83A2C58, + gAnimCmd_83A2C60, + gAnimCmd_83A300C, + gAnimCmd_83A3014, + gAnimCmd_83A301C, + gAnimCmd_83A3024, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_Nurse[] = { + gAnimCmd_83A2AC4, + gAnimCmd_83A2ACC, + gAnimCmd_83A2AD4, + gAnimCmd_83A2ADC, + gAnimCmd_83A2AE4, + gAnimCmd_83A2AF8, + gAnimCmd_83A2B0C, + gAnimCmd_83A2B20, + gAnimCmd_83A2B34, + gAnimCmd_83A2B48, + gAnimCmd_83A2B5C, + gAnimCmd_83A2B70, + gAnimCmd_83A2B84, + gAnimCmd_83A2B98, + gAnimCmd_83A2BAC, + gAnimCmd_83A2BC0, + gAnimCmd_83A2BD4, + gAnimCmd_83A2BE8, + gAnimCmd_83A2BFC, + gAnimCmd_83A2C10, + gAnimCmd_83A3184, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_RedGreenItem[] = { + gAnimCmd_83A2F90, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_RedGreenVSSeeker[] = { + gAnimCmd_83A2FA8, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_RedGreenVSSeekerBike[] = { + gAnimCmd_83A2FD8, + gAnimCmd_83A313C, + gAnimCmd_83A3144, + gAnimCmd_83A3150, + gAnimCmd_83A315C, + gAnimCmd_83A3170, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_RockSmashRock[] = { + gAnimCmd_83A2950, + gAnimCmd_83A3194, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_CutTree[] = { + gAnimCmd_83A2950, + gAnimCmd_83A31A8, +}; + +const union AnimCmd *const gObjectEventImageAnimTable_RedGreenFish[] = { + gAnimCmd_83A31BC, + gAnimCmd_83A31D0, + gAnimCmd_83A31E4, + gAnimCmd_83A31F8, + gAnimCmd_83A320C, + gAnimCmd_83A3220, + gAnimCmd_83A3234, + gAnimCmd_83A3248, + gAnimCmd_83A325C, + gAnimCmd_83A3270, + gAnimCmd_83A3284, + gAnimCmd_83A3298, +}; + +const struct UnkStruct_083A3698 gUnknown_83A3698[] = { + { + .anims = gAnimTable_83A3318, + .animPos = {1, 3, 0, 2}, + }, + { + .anims = gObjectEventImageAnimTable_Standard, + .animPos = {1, 3, 0, 2}, + }, + { + .anims = gObjectEventImageAnimTable_RedGreenNormal, + .animPos = {1, 3, 0, 2}, + }, + { + .anims = gAnimTable_83A34E4, + .animPos = {1, 3, 0, 2}, + }, + { + .anims = gObjectEventImageAnimTable_RedGreenSurf, + .animPos = {1, 3, 0, 2}, + }, + { + .anims = gObjectEventImageAnimTable_Nurse, + .animPos = {1, 3, 0, 2}, + }, + { + .anims = gObjectEventImageAnimTable_RedGreenFish, + .animPos = {1, 3, 0, 2}, + }, + { + .anims = gAnimTable_83A3410, + .animPos = {3, 7, 0, 4}, + }, + { + .anims = NULL, + .animPos = {0, 0, 0, 0}, + } +}; diff --git a/src/data/object_events/object_event_graphics.h b/src/data/object_events/object_event_graphics.h new file mode 100644 index 000000000..87451cae1 --- /dev/null +++ b/src/data/object_events/object_event_graphics.h @@ -0,0 +1,261 @@ +const u16 gUnknown_835B968[] = INCBIN_U16("graphics/object_events/palettes/0.gbapal"); +const u16 gUnknown_835B988[] = INCBIN_U16("graphics/object_events/palettes/unk_835B988.gbapal"); +const u16 gObjectEventPaletteNull1[16] = {}; +const u16 gObjectEventPaletteNull2[16] = {}; +const u16 gObjectEventPaletteNull3[16] = {}; +const u16 gObjectEventPaletteNull4[16] = {}; +const u16 gObjectEventPaletteNull5[16] = {}; +const u16 gObjectEventPaletteNull6[16] = {}; +const u16 gObjectEventPaletteNull7[16] = {}; +const u16 gObjectEventPaletteNull8[16] = {}; +const u16 gObjectEventPaletteNull9[16] = {}; +const u16 gObjectEventPaletteNull10[16] = {}; +const u16 gObjectEventPaletteNull11[16] = {}; +const u16 gObjectEventPaletteNull12[16] = {}; +const u16 gObjectEventPaletteNull13[16] = {}; +const u16 gObjectEventPaletteNull14[16] = {}; +const u32 gObjectEventPic_RedNormal[] = INCBIN_U32("graphics/object_events/pics/people/red_normal.4bpp"); +const u32 gObjectEventPic_RedSurfRun[] = INCBIN_U32("graphics/object_events/pics/people/red_surf_run.4bpp"); +const u32 gObjectEventPic_GreenNormal[] = INCBIN_U32("graphics/object_events/pics/people/green_normal.4bpp"); +const u32 gObjectEventPic_GreenSurfRun[] = INCBIN_U32("graphics/object_events/pics/people/green_surf_run.4bpp"); +const u16 gUnknown_835E968[] = INCBIN_U16("graphics/object_events/palettes/1.gbapal"); +const u16 gUnknown_835E988[] = INCBIN_U16("graphics/object_events/palettes/2.gbapal"); +const u32 gObjectEventPic_RedItem[] = INCBIN_U32("graphics/object_events/pics/people/red_item.4bpp"); +const u32 gObjectEventPic_GreenItem[] = INCBIN_U32("graphics/object_events/pics/people/green_item.4bpp"); +const u32 gObjectEventPic_RedSurf[] = INCBIN_U32("graphics/object_events/pics/people/red_surf.4bpp"); +const u32 gObjectEventPic_GreenSurf[] = INCBIN_U32("graphics/object_events/pics/people/green_surf.4bpp"); +const u32 gObjectEventPic_RedBike[] = INCBIN_U32("graphics/object_events/pics/people/red_bike.4bpp"); +const u32 gObjectEventPic_RedVSSeekerBike[] = INCBIN_U32("graphics/object_events/pics/people/red_vs_seeker_bike.4bpp"); +const u32 gObjectEventPic_GreenBike[] = INCBIN_U32("graphics/object_events/pics/people/green_bike.4bpp"); +const u32 gObjectEventPic_GreenVSSeekerBike[] = INCBIN_U32("graphics/object_events/pics/people/green_vs_seeker_bike.4bpp"); +const u32 gObjectEventPic_RSBrendan[] = INCBIN_U32("graphics/object_events/pics/people/rs_brendan.4bpp"); +const u32 gObjectEventPic_RSMay[] = INCBIN_U32("graphics/object_events/pics/people/rs_may.4bpp"); +const u32 gObjectEventPic_RedFish[] = INCBIN_U32("graphics/object_events/pics/people/red_fish.4bpp"); +const u32 gObjectEventPic_GreenFish[] = INCBIN_U32("graphics/object_events/pics/people/green_fish.4bpp"); +const u32 gObjectEventPic_Pokedex[] = INCBIN_U32("graphics/object_events/pics/misc/pokedex.4bpp"); +const u32 gObjectEventPic_TownMap[] = INCBIN_U32("graphics/object_events/pics/misc/town_map.4bpp"); +const u32 gObjectEventPic_UnusedMan[] = INCBIN_U32("graphics/object_events/pics/people/unused_man.4bpp"); // Unused +const u32 gObjectEventPic_Giovanni[] = INCBIN_U32("graphics/object_events/pics/people/giovanni.4bpp"); +const u32 gObjectEventPic_Blaine[] = INCBIN_U32("graphics/object_events/pics/people/blaine.4bpp"); +const u32 gObjectEventPic_Sabrina[] = INCBIN_U32("graphics/object_events/pics/people/sabrina.4bpp"); +const u32 gObjectEventPic_Daisy[] = INCBIN_U32("graphics/object_events/pics/people/daisy.4bpp"); +const u32 gObjectEventPic_Lorelei[] = INCBIN_U32("graphics/object_events/pics/people/lorelei.4bpp"); +const u32 gObjectEventPic_Erika[] = INCBIN_U32("graphics/object_events/pics/people/erika.4bpp"); +const u32 gObjectEventPic_Koga[] = INCBIN_U32("graphics/object_events/pics/people/koga.4bpp"); +const u32 gObjectEventPic_Brock[] = INCBIN_U32("graphics/object_events/pics/people/brock.4bpp"); +const u32 gObjectEventPic_LtSurge[] = INCBIN_U32("graphics/object_events/pics/people/lt_surge.4bpp"); +const u32 gObjectEventPic_Bill[] = INCBIN_U32("graphics/object_events/pics/people/bill.4bpp"); +const u16 gUnknown_836D828[] = INCBIN_U16("graphics/object_events/palettes/3.gbapal"); +const u16 gUnknown_836D848[] = INCBIN_U16("graphics/object_events/palettes/4.gbapal"); +const u16 gUnknown_836D868[] = INCBIN_U16("graphics/object_events/palettes/5.gbapal"); +const u16 gUnknown_836D888[] = INCBIN_U16("graphics/object_events/palettes/6.gbapal"); +const u16 gUnknown_836D8A8[] = INCBIN_U16("graphics/object_events/palettes/7.gbapal"); +const u16 gUnknown_836D8C8[] = INCBIN_U16("graphics/object_events/palettes/8.gbapal"); +const u16 gUnknown_836D8E8[] = INCBIN_U16("graphics/object_events/palettes/9.gbapal"); +const u16 gUnknown_836D908[] = INCBIN_U16("graphics/object_events/palettes/10.gbapal"); +const u32 gObjectEventPic_LittleBoy[] = INCBIN_U32("graphics/object_events/pics/people/little_boy.4bpp"); +const u32 gObjectEventPic_LittleGirl[] = INCBIN_U32("graphics/object_events/pics/people/little_girl.4bpp"); +const u32 gObjectEventPic_SittingBoy[] = INCBIN_U32("graphics/object_events/pics/people/sitting_boy.4bpp"); +const u32 gObjectEventPic_Lass[] = INCBIN_U32("graphics/object_events/pics/people/lass.4bpp"); +const u32 gObjectEventPic_Youngster[] = INCBIN_U32("graphics/object_events/pics/people/youngster.4bpp"); +const u32 gObjectEventPic_Boy[] = INCBIN_U32("graphics/object_events/pics/people/boy.4bpp"); +const u32 gObjectEventPic_Woman1[] = INCBIN_U32("graphics/object_events/pics/people/woman_1.4bpp"); +const u32 gObjectEventPic_Woman3[] = INCBIN_U32("graphics/object_events/pics/people/woman_3.4bpp"); +const u32 gObjectEventPic_BugCatcher[] = INCBIN_U32("graphics/object_events/pics/people/bug_catcher.4bpp"); +const u32 gObjectEventPic_BattleGirl[] = INCBIN_U32("graphics/object_events/pics/people/battle_girl.4bpp"); +const u32 gObjectEventPic_RichBoy[] = INCBIN_U32("graphics/object_events/pics/people/rich_boy.4bpp"); // Unused +const u32 gObjectEventPic_FatMan[] = INCBIN_U32("graphics/object_events/pics/people/fat_man.4bpp"); +const u32 gObjectEventPic_BaldingMan[] = INCBIN_U32("graphics/object_events/pics/people/balding_man.4bpp"); +const u32 gObjectEventPic_Woman2[] = INCBIN_U32("graphics/object_events/pics/people/woman_2.4bpp"); +const u32 gObjectEventPic_OldMan1[] = INCBIN_U32("graphics/object_events/pics/people/old_man_1.4bpp"); +const u32 gObjectEventPic_OldManLyingDown[] = INCBIN_U32("graphics/object_events/pics/people/old_man_lying_down.4bpp"); +const u32 gObjectEventPic_WorkerM[] = INCBIN_U32("graphics/object_events/pics/people/worker_m.4bpp"); +const u32 gObjectEventPic_WorkerF[] = INCBIN_U32("graphics/object_events/pics/people/worker_f.4bpp"); +const u32 gObjectEventPic_Beauty[] = INCBIN_U32("graphics/object_events/pics/people/beauty.4bpp"); +const u32 gObjectEventPic_Chef[] = INCBIN_U32("graphics/object_events/pics/people/chef.4bpp"); +const u32 gObjectEventPic_OldMan2[] = INCBIN_U32("graphics/object_events/pics/people/old_man_2.4bpp"); +const u32 gObjectEventPic_OldWoman[] = INCBIN_U32("graphics/object_events/pics/people/old_woman.4bpp"); +const u32 gObjectEventPic_Camper[] = INCBIN_U32("graphics/object_events/pics/people/camper.4bpp"); +const u32 gObjectEventPic_Picnicker[] = INCBIN_U32("graphics/object_events/pics/people/picnicker.4bpp"); +const u32 gObjectEventPic_CooltrainerM[] = INCBIN_U32("graphics/object_events/pics/people/cooltrainer_m.4bpp"); +const u32 gObjectEventPic_CooltrainerF[] = INCBIN_U32("graphics/object_events/pics/people/cooltrainer_f.4bpp"); +const u32 gObjectEventPic_Psyduck[] = INCBIN_U32("graphics/object_events/pics/pokemon/psyduck.4bpp"); +const u32 gObjectEventPic_SuperNerd[] = INCBIN_U32("graphics/object_events/pics/people/super_nerd.4bpp"); +const u32 gObjectEventPic_Channeler[] = INCBIN_U32("graphics/object_events/pics/people/channeler.4bpp"); +const u32 gObjectEventPic_RocketF[] = INCBIN_U32("graphics/object_events/pics/people/rocket_f.4bpp"); +const u32 gObjectEventPic_SwimmerMWater[] = INCBIN_U32("graphics/object_events/pics/people/swimmer_m_water.4bpp"); +const u32 gObjectEventPic_SwimmerFWater[] = INCBIN_U32("graphics/object_events/pics/people/swimmer_f_water.4bpp"); +const u32 gObjectEventPic_SwimmerMLand[] = INCBIN_U32("graphics/object_events/pics/people/swimmer_m_land.4bpp"); +const u32 gObjectEventPic_SwimmerFLand[] = INCBIN_U32("graphics/object_events/pics/people/swimmer_f_land.4bpp"); +const u32 gObjectEventPic_Blackbelt[] = INCBIN_U32("graphics/object_events/pics/people/blackbelt.4bpp"); +const u32 gObjectEventPic_Scientist[] = INCBIN_U32("graphics/object_events/pics/people/scientist.4bpp"); +const u32 gObjectEventPic_Gentleman[] = INCBIN_U32("graphics/object_events/pics/people/gentleman.4bpp"); +const u32 gObjectEventPic_Sailor[] = INCBIN_U32("graphics/object_events/pics/people/sailor.4bpp"); +const u32 gObjectEventPic_Captain[] = INCBIN_U32("graphics/object_events/pics/people/captain.4bpp"); +const u32 gObjectEventPic_Fisher[] = INCBIN_U32("graphics/object_events/pics/people/fisher.4bpp"); +const u32 gObjectEventPic_TeachyTVHost[] = INCBIN_U32("graphics/object_events/pics/people/teachy_tv_host.4bpp"); +const u32 gObjectEventPic_UnusedWoman[] = INCBIN_U32("graphics/object_events/pics/people/unused_woman.4bpp"); +const u32 gObjectEventPic_TuberF[] = INCBIN_U32("graphics/object_events/pics/people/tuber_f.4bpp"); +const u32 gObjectEventPic_TuberMWater[] = INCBIN_U32("graphics/object_events/pics/people/tuber_m_water.4bpp"); +const u32 gObjectEventPic_TuberMLand[] = INCBIN_U32("graphics/object_events/pics/people/tuber_m_land.4bpp"); +const u32 gObjectEventPic_Hiker[] = INCBIN_U32("graphics/object_events/pics/people/hiker.4bpp"); +const u32 gObjectEventPic_Biker[] = INCBIN_U32("graphics/object_events/pics/people/biker.4bpp"); +const u32 gObjectEventPic_GymGuy[] = INCBIN_U32("graphics/object_events/pics/people/gym_guy.4bpp"); +const u32 gObjectEventPic_Man[] = INCBIN_U32("graphics/object_events/pics/people/man.4bpp"); +const u32 gObjectEventPic_Rocker[] = INCBIN_U32("graphics/object_events/pics/people/rocker.4bpp"); +const u32 gObjectEventPic_ProfOak[] = INCBIN_U32("graphics/object_events/pics/people/prof_oak.4bpp"); +const u32 gObjectEventPic_Blue[] = INCBIN_U32("graphics/object_events/pics/people/blue.4bpp"); +const u32 gObjectEventPic_Nurse[] = INCBIN_U32("graphics/object_events/pics/people/nurse.4bpp"); +const u32 gObjectEventPic_CableClubReceptionist[] = INCBIN_U32("graphics/object_events/pics/people/cable_club_receptionist.4bpp"); +const u32 gObjectEventPic_UnionRoomReceptionist[] = INCBIN_U32("graphics/object_events/pics/people/union_room_receptionist.4bpp"); +const u32 gObjectEventPic_UnusedMaleReceptionist[] = INCBIN_U32("graphics/object_events/pics/people/unused_male_receptionist.4bpp"); +const u32 gObjectEventPic_ItemBall[] = INCBIN_U32("graphics/object_events/pics/misc/item_ball.4bpp"); +const u32 gObjectEventPic_MrFuji[] = INCBIN_U32("graphics/object_events/pics/people/mr_fuji.4bpp"); +const u32 gObjectEventPic_Bruno[] = INCBIN_U32("graphics/object_events/pics/people/bruno.4bpp"); +const u32 gObjectEventPic_Clerk[] = INCBIN_U32("graphics/object_events/pics/people/clerk.4bpp"); +const u32 gObjectEventPic_MGDeliveryman[] = INCBIN_U32("graphics/object_events/pics/people/mg_deliveryman.4bpp"); +const u32 gObjectEventPic_TrainerTowerDude[] = INCBIN_U32("graphics/object_events/pics/people/trainer_tower_dude.4bpp"); +const u32 gObjectEventPic_Cameraman[] = INCBIN_U32("graphics/object_events/pics/people/cameraman.4bpp"); // Unused +const u32 gObjectEventPic_RocketM[] = INCBIN_U32("graphics/object_events/pics/people/rocket_m.4bpp"); +const u32 gObjectEventPic_Celio[] = INCBIN_U32("graphics/object_events/pics/people/celio.4bpp"); +const u32 gObjectEventPic_Lapras[] = INCBIN_U32("graphics/object_events/pics/pokemon/lapras.4bpp"); +const u32 gObjectEventPic_Zapdos[] = INCBIN_U32("graphics/object_events/pics/pokemon/zapdos.4bpp"); +const u32 gObjectEventPic_Moltres[] = INCBIN_U32("graphics/object_events/pics/pokemon/moltres.4bpp"); +const u32 gObjectEventPic_Articuno[] = INCBIN_U32("graphics/object_events/pics/pokemon/articuno.4bpp"); +const u32 gObjectEventPic_Mewtwo[] = INCBIN_U32("graphics/object_events/pics/pokemon/mewtwo.4bpp"); +const u32 gObjectEventPic_Mew[] = INCBIN_U32("graphics/object_events/pics/pokemon/mew.4bpp"); +const u32 gObjectEventPic_Entei[] = INCBIN_U32("graphics/object_events/pics/pokemon/entei.4bpp"); +const u32 gObjectEventPic_Raikou[] = INCBIN_U32("graphics/object_events/pics/pokemon/raikou.4bpp"); +const u32 gObjectEventPic_Suicune[] = INCBIN_U32("graphics/object_events/pics/pokemon/suicune.4bpp"); +const u32 gObjectEventPic_Lugia[] = INCBIN_U32("graphics/object_events/pics/pokemon/lugia.4bpp"); +const u32 gObjectEventPic_HoOh[] = INCBIN_U32("graphics/object_events/pics/pokemon/ho_oh.4bpp"); +const u32 gObjectEventPic_Celebi[] = INCBIN_U32("graphics/object_events/pics/pokemon/celebi.4bpp"); +const u32 gObjectEventPic_DeoxysD[] = INCBIN_U32("graphics/object_events/pics/pokemon/deoxys_d.4bpp"); +const u32 gObjectEventPic_DeoxysA[] = INCBIN_U32("graphics/object_events/pics/pokemon/deoxys_a.4bpp"); +const u32 gObjectEventPic_DeoxysN[] = INCBIN_U32("graphics/object_events/pics/pokemon/deoxys_n.4bpp"); +const u32 gObjectEventPic_Agatha[] = INCBIN_U32("graphics/object_events/pics/people/agatha.4bpp"); +const u32 gObjectEventPic_Misty[] = INCBIN_U32("graphics/object_events/pics/people/misty.4bpp"); +const u32 gObjectEventPic_Lance[] = INCBIN_U32("graphics/object_events/pics/people/lance.4bpp"); +const u32 gObjectEventPic_GBAKid[] = INCBIN_U32("graphics/object_events/pics/people/gba_kid.4bpp"); +const u32 gObjectEventPic_Mom[] = INCBIN_U32("graphics/object_events/pics/people/mom.4bpp"); +const u32 gObjectEventPic_Pidgeot[] = INCBIN_U32("graphics/object_events/pics/pokemon/pidgeot.4bpp"); +const u32 gObjectEventPic_Omanyte[] = INCBIN_U32("graphics/object_events/pics/pokemon/omanyte.4bpp"); +const u32 gObjectEventPic_Kangaskhan[] = INCBIN_U32("graphics/object_events/pics/pokemon/kangaskhan.4bpp"); +const u32 gObjectEventPic_NidoranF[] = INCBIN_U32("graphics/object_events/pics/pokemon/nidoran_f.4bpp"); +const u32 gObjectEventPic_NidoranM[] = INCBIN_U32("graphics/object_events/pics/pokemon/nidoran_m.4bpp"); +const u32 gObjectEventPic_Nidorino[] = INCBIN_U32("graphics/object_events/pics/pokemon/nidorino.4bpp"); +const u32 gObjectEventPic_Meowth[] = INCBIN_U32("graphics/object_events/pics/pokemon/meowth.4bpp"); +const u32 gObjectEventPic_Seel[] = INCBIN_U32("graphics/object_events/pics/pokemon/seel.4bpp"); +const u32 gObjectEventPic_Voltorb[] = INCBIN_U32("graphics/object_events/pics/pokemon/voltorb.4bpp"); +const u32 gObjectEventPic_Slowpoke[] = INCBIN_U32("graphics/object_events/pics/pokemon/slowpoke.4bpp"); +const u32 gObjectEventPic_Slowbro[] = INCBIN_U32("graphics/object_events/pics/pokemon/slowbro.4bpp"); +const u32 gObjectEventPic_Machop[] = INCBIN_U32("graphics/object_events/pics/pokemon/machop.4bpp"); +const u32 gObjectEventPic_Wigglytuff[] = INCBIN_U32("graphics/object_events/pics/pokemon/wigglytuff.4bpp"); +const u32 gObjectEventPic_Doduo[] = INCBIN_U32("graphics/object_events/pics/pokemon/doduo.4bpp"); +const u32 gObjectEventPic_Fearow[] = INCBIN_U32("graphics/object_events/pics/pokemon/fearow.4bpp"); +const u32 gObjectEventPic_Kabuto[] = INCBIN_U32("graphics/object_events/pics/pokemon/kabuto.4bpp"); +const u32 gObjectEventPic_Machoke[] = INCBIN_U32("graphics/object_events/pics/pokemon/machoke.4bpp"); +const u32 gObjectEventPic_Snorlax[] = INCBIN_U32("graphics/object_events/pics/pokemon/snorlax.4bpp"); +const u32 gObjectEventPic_Spearow[] = INCBIN_U32("graphics/object_events/pics/pokemon/spearow.4bpp"); +const u32 gObjectEventPic_Cubone[] = INCBIN_U32("graphics/object_events/pics/pokemon/cubone.4bpp"); +const u32 gObjectEventPic_Poliwrath[] = INCBIN_U32("graphics/object_events/pics/pokemon/poliwrath.4bpp"); +const u32 gObjectEventPic_Chansey[] = INCBIN_U32("graphics/object_events/pics/pokemon/chansey.4bpp"); +const u32 gObjectEventPic_Pikachu[] = INCBIN_U32("graphics/object_events/pics/pokemon/pikachu.4bpp"); +const u32 gObjectEventPic_Jigglypuff[] = INCBIN_U32("graphics/object_events/pics/pokemon/jigglypuff.4bpp"); +const u32 gObjectEventPic_Pidgey[] = INCBIN_U32("graphics/object_events/pics/pokemon/pidgey.4bpp"); +const u32 gObjectEventPic_Clefairy[] = INCBIN_U32("graphics/object_events/pics/pokemon/clefairy.4bpp"); +const u32 gObjectEventPic_CutTree[] = INCBIN_U32("graphics/object_events/pics/misc/cut_tree.4bpp"); +const u32 gObjectEventPic_RockSmashRock[] = INCBIN_U32("graphics/object_events/pics/misc/rock_smash_rock.4bpp"); +const u32 gObjectEventPic_StrengthBoulder[] = INCBIN_U32("graphics/object_events/pics/misc/strength_boulder.4bpp"); +const u32 gObjectEventPic_Fossil[] = INCBIN_U32("graphics/object_events/pics/misc/fossil.4bpp"); +const u32 gObjectEventPic_Ruby[] = INCBIN_U32("graphics/object_events/pics/misc/ruby.4bpp"); +const u32 gObjectEventPic_Sapphire[] = INCBIN_U32("graphics/object_events/pics/misc/sapphire.4bpp"); +const u32 gObjectEventPic_OldAmber[] = INCBIN_U32("graphics/object_events/pics/misc/old_amber.4bpp"); +const u32 gObjectEventPic_GymSign[] = INCBIN_U32("graphics/object_events/pics/misc/gym_sign.4bpp"); +const u32 gObjectEventPic_Sign[] = INCBIN_U32("graphics/object_events/pics/misc/sign.4bpp"); +const u32 gObjectEventPic_WoodenSign[] = INCBIN_U32("graphics/object_events/pics/misc/wooden_sign.4bpp"); +const u32 gObjectEventPic_Clipboard[] = INCBIN_U32("graphics/object_events/pics/misc/clipboard.4bpp"); +const u16 gUnknown_8394EA8[] = INCBIN_U16("graphics/object_events/palettes/19.gbapal"); +const u32 gObjectEventPic_BirthIslandStone[] = INCBIN_U32("graphics/object_events/pics/misc/birth_island_stone.4bpp"); +const u32 gObjectEventPic_LaprasDoll[] = INCBIN_U32("graphics/object_events/pics/misc/lapras_doll.4bpp"); +const u16 gUnknown_83952C8[] = INCBIN_U16("graphics/object_events/palettes/20.gbapal"); +const u32 gObjectEventPic_Seagallop[] = INCBIN_U32("graphics/object_events/pics/misc/seagallop.4bpp"); +const u16 gUnknown_8395AE8[] = INCBIN_U16("graphics/object_events/palettes/21.gbapal"); +const u32 gObjectEventPic_SSAnne[] = INCBIN_U32("graphics/object_events/pics/misc/ss_anne.4bpp"); +const u32 gObjectEventPic_SurfBlob[] = INCBIN_U32("graphics/object_events/pics/misc/surf_blob.4bpp"); +const u32 gObjectEventPic_Policeman[] = INCBIN_U32("graphics/object_events/pics/people/policeman.4bpp"); +const u16 gUnknown_8398008[] = INCBIN_U16("graphics/object_events/palettes/11.gbapal"); +const u16 gUnknown_8398028[] = INCBIN_U16("graphics/object_events/palettes/12.gbapal"); +const u32 gUnknown_8398048[] = INCBIN_U32("graphics/object_events/pics/effects/shadow_small.4bpp"); +const u32 gUnknown_8398068[] = INCBIN_U32("graphics/object_events/pics/effects/shadow_medium.4bpp"); +const u32 gUnknown_83980A8[] = INCBIN_U32("graphics/object_events/pics/effects/shadow_large.4bpp"); +const u32 gUnknown_8398128[] = INCBIN_U32("graphics/object_events/pics/effects/shadow_extra_large.4bpp"); +const u32 filler_8398188[0x48] = {}; +const u16 gUnknown_8398648[] = INCBIN_U16("graphics/field_effects/fldeff_cut.4bpp"); +const u32 gUnknown_8398668[] = INCBIN_U32("graphics/field_effects/fldeff_cut.4bpp"); +const u16 gUnknown_8398688[] = INCBIN_U16("graphics/field_effects/fldeff_cut.gbapal"); +const u32 gUnknown_83986A8[] = INCBIN_U32("graphics/object_events/pics/unknown/83986A8.4bpp"); +const u32 gUnknown_8398928[] = INCBIN_U32("graphics/object_events/pics/unknown/8398928.4bpp"); +const u32 gUnknown_8398BA8[] = INCBIN_U32("graphics/object_events/pics/unknown/8398BA8.4bpp"); +const u16 gUnknown_8398FA8[] = INCBIN_U16("graphics/object_events/palettes/8398FA8.gbapal"); +const u16 gUnknown_8398FC8[] = INCBIN_U16("graphics/object_events/palettes/8398FC8.gbapal"); +const u32 gUnknown_8399008[] = INCBIN_U32("graphics/object_events/pics/unknown/8399008.4bpp"); +const u32 gUnknown_83990C8[] = INCBIN_U32("graphics/object_events/pics/unknown/83990C8.4bpp"); +const u32 gUnknown_8399188[] = INCBIN_U32("graphics/object_events/pics/unknown/8399188.4bpp"); +const u32 gUnknown_8399288[] = INCBIN_U32("graphics/object_events/pics/unknown/8399288.4bpp"); +const u32 gUnknown_8399488[] = INCBIN_U32("graphics/object_events/pics/unknown/8399488.4bpp"); +const u32 gUnknown_8399788[] = INCBIN_U32("graphics/object_events/pics/unknown/8399788.4bpp"); +const u32 gUnknown_8399C08[] = INCBIN_U32("graphics/object_events/pics/unknown/8399C08.4bpp"); +const u32 gUnknown_8399E08[] = INCBIN_U32("graphics/object_events/pics/unknown/8399E08.4bpp"); +const u32 gUnknown_8399E88[] = INCBIN_U32("graphics/object_events/pics/unknown/8399E88.4bpp"); +const u32 gUnknown_8399F08[] = INCBIN_U32("graphics/object_events/pics/unknown/8399F08.4bpp"); +const u32 gUnknown_8399F88[] = INCBIN_U32("graphics/object_events/pics/unknown/8399F88.4bpp"); +const u32 gUnknown_839A008[] = INCBIN_U32("graphics/object_events/pics/unknown/839A008.4bpp"); +const u32 gUnknown_839A288[] = INCBIN_U32("graphics/object_events/pics/unknown/839A288.4bpp"); +const u32 gUnknown_839A388[] = INCBIN_U32("graphics/object_events/pics/unknown/839A388.4bpp"); +const u32 gUnknown_839A408[] = INCBIN_U32("graphics/object_events/pics/unknown/839A408.4bpp"); +const u32 gUnknown_839A488[] = INCBIN_U32("graphics/object_events/pics/unknown/839A488.4bpp"); +const u32 gUnknown_839A508[] = INCBIN_U32("graphics/object_events/pics/unknown/839A508.4bpp"); +const u32 gUnknown_839A588[] = INCBIN_U32("graphics/object_events/pics/unknown/839A588.4bpp"); +const u32 gUnknown_839A608[] = INCBIN_U32("graphics/object_events/pics/unknown/839A608.4bpp"); +const u32 gUnknown_839A688[] = INCBIN_U32("graphics/object_events/pics/unknown/839A688.4bpp"); +const u32 gUnknown_839A708[] = INCBIN_U32("graphics/object_events/pics/unknown/839A708.4bpp"); +const u32 gUnknown_839A788[] = INCBIN_U32("graphics/object_events/pics/unknown/839A788.4bpp"); +const u32 gUnknown_839A988[] = INCBIN_U32("graphics/object_events/pics/unknown/839A988.4bpp"); +const u32 gUnknown_839AA48[] = INCBIN_U32("graphics/object_events/pics/unknown/839AA48.4bpp"); +const u32 gUnknown_839AAC8[] = INCBIN_U32("graphics/object_events/pics/unknown/839AAC8.4bpp"); +const u32 gUnknown_839AB48[] = INCBIN_U32("graphics/object_events/pics/unknown/839AB48.4bpp"); +const u32 gUnknown_839ABC8[] = INCBIN_U32("graphics/object_events/pics/unknown/839ABC8.4bpp"); +const u32 gUnknown_839AC48[] = INCBIN_U32("graphics/object_events/pics/unknown/839AC48.4bpp"); +const u32 gUnknown_839AC88[] = INCBIN_U32("graphics/object_events/pics/unknown/839AC88.4bpp"); +const u32 gUnknown_839ACC8[] = INCBIN_U32("graphics/object_events/pics/unknown/839ACC8.4bpp"); +const u32 gUnknown_839AD08[] = INCBIN_U32("graphics/object_events/pics/unknown/839AD08.4bpp"); +const u32 gUnknown_839AD48[] = INCBIN_U32("graphics/object_events/pics/unknown/839AD48.4bpp"); +const u32 gUnknown_839AD88[] = INCBIN_U32("graphics/object_events/pics/unknown/839AD88.4bpp"); +const u32 gUnknown_839B008[] = INCBIN_U32("graphics/object_events/pics/unknown/839B008.4bpp"); +const u32 gUnknown_839B708[] = INCBIN_U32("graphics/object_events/pics/unknown/839B708.4bpp"); +const u32 gUnknown_839BE08[] = INCBIN_U32("graphics/object_events/pics/unknown/839BE08.4bpp"); +const u32 gUnknown_839C508[] = INCBIN_U32("graphics/object_events/pics/unknown/839C508.4bpp"); +const u16 gUnknown_839C588[] = INCBIN_U16("graphics/object_events/palettes/839C588.gbapal"); +const u32 gUnknown_839C5A8[] = INCBIN_U32("graphics/object_events/pics/unknown/839C5A8.4bpp"); +const u32 gUnknown_839C628[] = INCBIN_U32("graphics/object_events/pics/unknown/839C628.4bpp"); +const u32 gUnknown_839C6A8[] = INCBIN_U32("graphics/object_events/pics/unknown/839C6A8.4bpp"); +const u32 gUnknown_839C728[] = INCBIN_U32("graphics/object_events/pics/unknown/839C728.4bpp"); +const u32 gUnknown_839C7A8[] = INCBIN_U32("graphics/object_events/pics/unknown/839C7A8.4bpp"); +const u32 gUnknown_839C828[] = INCBIN_U32("graphics/object_events/pics/unknown/839C828.4bpp"); +const u32 gUnknown_839C8A8[] = INCBIN_U32("graphics/object_events/pics/unknown/839C8A8.4bpp"); +const u32 gUnknown_839C928[] = INCBIN_U32("graphics/object_events/pics/unknown/839C928.4bpp"); +const u32 gUnknown_839C9A8[] = INCBIN_U32("graphics/object_events/pics/unknown/839C9A8.4bpp"); +const u32 gUnknown_839CA28[] = INCBIN_U32("graphics/object_events/pics/unknown/839CA28.4bpp"); +const u32 gUnknown_839CAA8[] = INCBIN_U32("graphics/object_events/pics/unknown/839CAA8.4bpp"); +const u32 gUnknown_839CBA8[] = INCBIN_U32("graphics/object_events/pics/unknown/839CBA8.4bpp"); +const u32 gUnknown_839CCA8[] = INCBIN_U32("graphics/object_events/pics/unknown/839CCA8.4bpp"); +const u32 gUnknown_839CDA8[] = INCBIN_U32("graphics/object_events/pics/unknown/839CDA8.4bpp"); +const u32 gUnknown_839CEA8[] = INCBIN_U32("graphics/object_events/pics/unknown/839CEA8.4bpp"); +const u32 gUnknown_839CFA8[] = INCBIN_U32("graphics/object_events/pics/unknown/839CFA8.4bpp"); +const u32 gUnknown_839D0A8[] = INCBIN_U32("graphics/object_events/pics/unknown/839D0A8.4bpp"); +const u32 gUnknown_839D1A8[] = INCBIN_U32("graphics/object_events/pics/unknown/839D1A8.4bpp"); +const u32 gUnknown_839D2A8[] = INCBIN_U32("graphics/object_events/pics/unknown/839D2A8.4bpp"); +const u32 gUnknown_839D328[] = INCBIN_U32("graphics/object_events/pics/unknown/839D328.4bpp"); +const u16 gUnknown_839D3A8[] = INCBIN_U16("graphics/object_events/palettes/839D3A8.gbapal"); +const u32 gUnknown_839D3C8[] = INCBIN_U32("graphics/object_events/pics/unknown/839D3C8.4bpp"); diff --git a/src/data/object_events/object_event_graphics_info.h b/src/data/object_events/object_event_graphics_info.h new file mode 100644 index 000000000..f43e6f628 --- /dev/null +++ b/src/data/object_events/object_event_graphics_info.h @@ -0,0 +1,154 @@ +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedNormal = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 512, 16, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_RedGreenNormal, gObjectEventPicTable_RedNormal, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedBike = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_BIKE_TIRE, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_RedBike, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedSurf = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 0, SHADOW_SIZE_M, FALSE, TRUE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_RedGreenSurf, gObjectEventPicTable_RedSurf, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedItem = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 256, 16, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_RedGreenItem, gObjectEventPicTable_RedItem, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Policeman = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Policeman, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RSBrendan = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_RSBrendan, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RSMay = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_RSMay, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_LittleBoy = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_LittleBoy, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_LittleGirl = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_LittleGirl, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SittingBoy = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_SittingBoy, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lass = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Lass, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Youngster = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Youngster, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Woman1 = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Woman1, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Woman3 = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Woman3, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Boy = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Boy, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_BattleGirl = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_BattleGirl, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_BugCatcher = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_BugCatcher, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_FatMan = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_FatMan, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_BaldingMan = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_BaldingMan, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Woman2 = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Woman2, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldMan1 = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_OldMan1, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_WorkerM = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_WorkerM, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_WorkerF = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_WorkerF, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Beauty = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Beauty, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Chef = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Chef, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldMan2 = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_OldMan2, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldWoman = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_OldWoman, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Camper = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Camper, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Picnicker = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Picnicker, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_CooltrainerM = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_CooltrainerM, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_CooltrainerF = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_CooltrainerF, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SuperNerd = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_SuperNerd, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Channeler = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Channeler, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RocketF = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_RocketF, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SwimmerMWater = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_SwimmerMWater, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SwimmerFWater = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_SwimmerFWater, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SwimmerMLand = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_SwimmerMLand, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SwimmerFLand = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_SwimmerFLand, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Blackbelt = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Blackbelt, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Scientist = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Scientist, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Gentleman = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Gentleman, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Sailor = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Sailor, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Captain = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Captain, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Fisher = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Fisher, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TeachyTVHost = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_TeachyTVHost, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_UnusedWoman = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_UnusedWoman, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TuberF = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_TuberF, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TuberMWater = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_TuberMWater, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TuberMLand = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_TuberMLand, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Hiker = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Hiker, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Biker = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_BIKE_TIRE, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Biker, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GymGuy = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_BIKE_TIRE, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_GymGuy, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Nurse = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Nurse, gObjectEventPicTable_Nurse, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_UnusedMaleReceptionist = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_UnusedMaleReceptionist, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_ItemBall = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_ItemBall, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_ProfOak = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_ProfOak, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Man = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Man, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Rocker = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Rocker, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_MrFuji = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_MrFuji, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Bruno = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Bruno, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldManLyingDown = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_OldManLyingDown, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_CutTree = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 4, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_CutTree, gObjectEventPicTable_CutTree, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Clerk = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Clerk, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_MGDeliveryman = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_MGDeliveryman, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TrainerTowerDude = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_TrainerTowerDude, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_CableClubReceptionist = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_CableClubReceptionist, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_UnionRoomReceptionist = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_UnionRoomReceptionist, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RockSmashRock = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_RockSmashRock, gObjectEventPicTable_RockSmashRock, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_StrengthBoulder = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_StrengthBoulder, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenNormal = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_17, OBJ_EVENT_PAL_TAG_10, 512, 16, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_RedGreenNormal, gObjectEventPicTable_GreenNormal, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenBike = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_17, OBJ_EVENT_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_BIKE_TIRE, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_GreenBike, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenSurf = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_17, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 0, SHADOW_SIZE_M, FALSE, TRUE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_RedGreenSurf, gObjectEventPicTable_GreenSurf, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenItem = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_17, OBJ_EVENT_PAL_TAG_10, 256, 16, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_RedGreenItem, gObjectEventPicTable_GreenItem, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_83A45F4 = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 512, 32, 32, 10, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_BIKE_TIRE, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_RedBike, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RocketM = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_RocketM, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Celio = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Celio, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Agatha = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Agatha, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Brock = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Brock, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Misty = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Misty, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_LtSurge = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_LtSurge, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Erika = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Erika, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Koga = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Koga, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Giovanni = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Giovanni, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Blaine = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Blaine, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Sabrina = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Sabrina, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Bill = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Bill, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Daisy = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Daisy, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lorelei = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Lorelei, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lance = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Lance, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Blue = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Blue, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedFish = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_RedGreenFish, gObjectEventPicTable_RedFish, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenFish = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_17, OBJ_EVENT_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_RedGreenFish, gObjectEventPicTable_GreenFish, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedVSSeeker = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 256, 16, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_RedGreenVSSeeker, gObjectEventPicTable_RedItem, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedVSSeekerBike = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_RedGreenVSSeekerBike, gObjectEventPicTable_RedVSSeekerBike, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenVSSeeker = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 256, 16, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_RedGreenVSSeeker, gObjectEventPicTable_GreenItem, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenVSSeekerBike = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_8, OBJ_EVENT_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_RedGreenVSSeekerBike, gObjectEventPicTable_GreenVSSeekerBike, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TownMap = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 32, 16, 2, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_32x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_TownMap, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Pokedex = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_Pokedex, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GBAKid = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_GBAKid, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Snorlax = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Snorlax, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Fossil = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_Fossil, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Ruby = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_Ruby, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Sapphire = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_Sapphire, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldAmber = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_OldAmber, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GymSign = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_GymSign, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Sign = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_Sign, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TrainerTips = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_WoodenSign, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Clipboard = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_Clipboard, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Meteorite = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_20, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 10, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_BirthIslandStone, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_LaprasDoll = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 3, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Inanimate, gObjectEventPicTable_LaprasDoll, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Spearow = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Spearow, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Omanyte = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Omanyte, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Kangaskhan = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Kangaskhan, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Psyduck = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Psyduck, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_NidoranF = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_NidoranF, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_NidoranM = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_NidoranM, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Nidorino = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Nidorino, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Meowth = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Meowth, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Seel = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Seel, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Voltorb = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Voltorb, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Slowpoke = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Slowpoke, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Slowbro = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Slowbro, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Machop = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Machop, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Wigglytuff = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Wigglytuff, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Doduo = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Doduo, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Fearow = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Fearow, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lapras = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Lapras, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Zapdos = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Zapdos, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Moltres = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Moltres, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Articuno = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Articuno, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_DeoxysD = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_DeoxysD, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_DeoxysA = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_DeoxysA, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_DeoxysN = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_DeoxysN, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Mewtwo = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Mewtwo, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Mew = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Mew, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Entei = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Entei, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Raikou = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Raikou, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Suicune = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Suicune, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lugia = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Lugia, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_HoOh = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 512, 32, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_32x32, gObjectEventSpriteOamTables_32x32, gObjectEventImageAnimTable_HoOh, gObjectEventPicTable_HoOh, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Celebi = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_2, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Celebi, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Cubone = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_3, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Cubone, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Machoke = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Machoke, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Kabuto = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Kabuto, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Poliwrath = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Poliwrath, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Pidgeot = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Pidgeot, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Chansey = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Chansey, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Pikachu = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Pikachu, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Jigglypuff = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Jigglypuff, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Pidgey = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Pidgey, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Clefairy = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_1, OBJ_EVENT_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x16, gObjectEventSpriteOamTables_16x16, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Clefairy, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Mom = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_0, OBJ_EVENT_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gObjectEventBaseOam_16x32, gObjectEventSpriteOamTables_16x32, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Mom, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Seagallop = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_21, OBJ_EVENT_PAL_TAG_NONE, 2048, 64, 64, 10, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_64x64, gObjectEventSpriteOamTables_64x64, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_Seagallop, gDummySpriteAffineAnimTable}; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SSAnne = {SPRITE_INVALID_TAG, OBJ_EVENT_PAL_TAG_11, OBJ_EVENT_PAL_TAG_NONE, 4096, 128, 64, 10, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_NONE, &gObjectEventBaseOam_8x8, gObjectEventSpriteOamTables_128x64, gObjectEventImageAnimTable_Standard, gObjectEventPicTable_SSAnne, gDummySpriteAffineAnimTable}; diff --git a/src/data/object_events/object_event_graphics_info_pointers.h b/src/data/object_events/object_event_graphics_info_pointers.h new file mode 100644 index 000000000..164199089 --- /dev/null +++ b/src/data/object_events/object_event_graphics_info_pointers.h @@ -0,0 +1,308 @@ +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedNormal; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedBike; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedSurf; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedItem; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedFish; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedVSSeeker; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RedVSSeekerBike; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenNormal; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenBike; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenSurf; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenItem; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenFish; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenVSSeeker; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GreenVSSeekerBike; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RSBrendan; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RSMay; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_LittleBoy; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_LittleGirl; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Youngster; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Boy; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_BugCatcher; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SittingBoy; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lass; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Woman1; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_BattleGirl; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Man; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Rocker; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_FatMan; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Woman2; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Beauty; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_BaldingMan; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Woman3; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldMan1; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldMan2; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldManLyingDown; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldWoman; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TuberMWater; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TuberF; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TuberMLand; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Camper; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Picnicker; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_CooltrainerM; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_CooltrainerF; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SwimmerMWater; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SwimmerFWater; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SwimmerMLand; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SwimmerFLand; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_WorkerM; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_WorkerF; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RocketM; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RocketF; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GBAKid; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SuperNerd; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Biker; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Blackbelt; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Scientist; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Hiker; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Fisher; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Channeler; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Chef; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Policeman; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Gentleman; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Sailor; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Captain; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Nurse; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_CableClubReceptionist; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_UnionRoomReceptionist; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_UnusedMaleReceptionist; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Clerk; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_MGDeliveryman; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TrainerTowerDude; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_ProfOak; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Blue; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Bill; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lance; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Agatha; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Daisy; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lorelei; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_MrFuji; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Bruno; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Brock; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Misty; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_LtSurge; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Erika; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Koga; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Sabrina; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Blaine; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Giovanni; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Mom; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Celio; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TeachyTVHost; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GymGuy; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_ItemBall; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TownMap; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Pokedex; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_CutTree; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_RockSmashRock; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_StrengthBoulder; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Fossil; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Ruby; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Sapphire; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_OldAmber; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_GymSign; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Sign; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_TrainerTips; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Clipboard; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Meteorite; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_LaprasDoll; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Seagallop; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Snorlax; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Spearow; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Cubone; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Poliwrath; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Clefairy; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Pidgeot; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Jigglypuff; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Pidgey; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Chansey; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Omanyte; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Kangaskhan; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Pikachu; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Psyduck; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_NidoranF; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_NidoranM; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Nidorino; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Meowth; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Seel; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Voltorb; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Slowpoke; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Slowbro; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Machop; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Wigglytuff; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Doduo; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Fearow; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Machoke; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lapras; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Zapdos; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Moltres; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Articuno; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Mewtwo; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Mew; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Entei; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Suicune; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Raikou; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Lugia; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_HoOh; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Celebi; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_Kabuto; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_DeoxysD; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_DeoxysA; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_DeoxysN; +const struct ObjectEventGraphicsInfo gObjectEventGraphicsInfo_SSAnne; + + +const struct ObjectEventGraphicsInfo *const gObjectEventGraphicsInfoPointers[NUM_OBJ_EVENT_GFX] = { + [OBJ_EVENT_GFX_RED_NORMAL] = &gObjectEventGraphicsInfo_RedNormal, + [OBJ_EVENT_GFX_RED_BIKE] = &gObjectEventGraphicsInfo_RedBike, + [OBJ_EVENT_GFX_RED_SURF] = &gObjectEventGraphicsInfo_RedSurf, + [OBJ_EVENT_GFX_RED_ITEM] = &gObjectEventGraphicsInfo_RedItem, + [OBJ_EVENT_GFX_RED_FISH] = &gObjectEventGraphicsInfo_RedFish, + [OBJ_EVENT_GFX_RED_VS_SEEKER] = &gObjectEventGraphicsInfo_RedVSSeeker, + [OBJ_EVENT_GFX_RED_VS_SEEKER_BIKE] = &gObjectEventGraphicsInfo_RedVSSeekerBike, + [OBJ_EVENT_GFX_GREEN_NORMAL] = &gObjectEventGraphicsInfo_GreenNormal, + [OBJ_EVENT_GFX_GREEN_BIKE] = &gObjectEventGraphicsInfo_GreenBike, + [OBJ_EVENT_GFX_GREEN_SURF] = &gObjectEventGraphicsInfo_GreenSurf, + [OBJ_EVENT_GFX_GREEN_ITEM] = &gObjectEventGraphicsInfo_GreenItem, + [OBJ_EVENT_GFX_GREEN_FISH] = &gObjectEventGraphicsInfo_GreenFish, + [OBJ_EVENT_GFX_GREEN_VS_SEEKER] = &gObjectEventGraphicsInfo_GreenVSSeeker, + [OBJ_EVENT_GFX_GREEN_VS_SEEKER_BIKE] = &gObjectEventGraphicsInfo_GreenVSSeekerBike, + [OBJ_EVENT_GFX_RS_BRENDAN] = &gObjectEventGraphicsInfo_RSBrendan, + [OBJ_EVENT_GFX_RS_MAY] = &gObjectEventGraphicsInfo_RSMay, + [OBJ_EVENT_GFX_LITTLE_BOY] = &gObjectEventGraphicsInfo_LittleBoy, + [OBJ_EVENT_GFX_LITTLE_GIRL] = &gObjectEventGraphicsInfo_LittleGirl, + [OBJ_EVENT_GFX_YOUNGSTER] = &gObjectEventGraphicsInfo_Youngster, + [OBJ_EVENT_GFX_BOY] = &gObjectEventGraphicsInfo_Boy, + [OBJ_EVENT_GFX_BUG_CATCHER] = &gObjectEventGraphicsInfo_BugCatcher, + [OBJ_EVENT_GFX_SITTING_BOY] = &gObjectEventGraphicsInfo_SittingBoy, + [OBJ_EVENT_GFX_LASS] = &gObjectEventGraphicsInfo_Lass, + [OBJ_EVENT_GFX_WOMAN_1] = &gObjectEventGraphicsInfo_Woman1, + [OBJ_EVENT_GFX_BATTLE_GIRL] = &gObjectEventGraphicsInfo_BattleGirl, + [OBJ_EVENT_GFX_MAN] = &gObjectEventGraphicsInfo_Man, + [OBJ_EVENT_GFX_ROCKER] = &gObjectEventGraphicsInfo_Rocker, + [OBJ_EVENT_GFX_FAT_MAN] = &gObjectEventGraphicsInfo_FatMan, + [OBJ_EVENT_GFX_WOMAN_2] = &gObjectEventGraphicsInfo_Woman2, + [OBJ_EVENT_GFX_BEAUTY] = &gObjectEventGraphicsInfo_Beauty, + [OBJ_EVENT_GFX_BALDING_MAN] = &gObjectEventGraphicsInfo_BaldingMan, + [OBJ_EVENT_GFX_WOMAN_3] = &gObjectEventGraphicsInfo_Woman3, + [OBJ_EVENT_GFX_OLD_MAN_1] = &gObjectEventGraphicsInfo_OldMan1, + [OBJ_EVENT_GFX_OLD_MAN_2] = &gObjectEventGraphicsInfo_OldMan2, + [OBJ_EVENT_GFX_OLD_MAN_LYING_DOWN] = &gObjectEventGraphicsInfo_OldManLyingDown, + [OBJ_EVENT_GFX_OLD_WOMAN] = &gObjectEventGraphicsInfo_OldWoman, + [OBJ_EVENT_GFX_TUBER_M_WATER] = &gObjectEventGraphicsInfo_TuberMWater, + [OBJ_EVENT_GFX_TUBER_F] = &gObjectEventGraphicsInfo_TuberF, + [OBJ_EVENT_GFX_TUBER_M_LAND] = &gObjectEventGraphicsInfo_TuberMLand, + [OBJ_EVENT_GFX_CAMPER] = &gObjectEventGraphicsInfo_Camper, + [OBJ_EVENT_GFX_PICNICKER] = &gObjectEventGraphicsInfo_Picnicker, + [OBJ_EVENT_GFX_COOLTRAINER_M] = &gObjectEventGraphicsInfo_CooltrainerM, + [OBJ_EVENT_GFX_COOLTRAINER_F] = &gObjectEventGraphicsInfo_CooltrainerF, + [OBJ_EVENT_GFX_SWIMMER_M_WATER] = &gObjectEventGraphicsInfo_SwimmerMWater, + [OBJ_EVENT_GFX_SWIMMER_F_WATER] = &gObjectEventGraphicsInfo_SwimmerFWater, + [OBJ_EVENT_GFX_SWIMMER_M_LAND] = &gObjectEventGraphicsInfo_SwimmerMLand, + [OBJ_EVENT_GFX_SWIMMER_F_LAND] = &gObjectEventGraphicsInfo_SwimmerFLand, + [OBJ_EVENT_GFX_WORKER_M] = &gObjectEventGraphicsInfo_WorkerM, + [OBJ_EVENT_GFX_WORKER_F] = &gObjectEventGraphicsInfo_WorkerF, + [OBJ_EVENT_GFX_ROCKET_M] = &gObjectEventGraphicsInfo_RocketM, + [OBJ_EVENT_GFX_ROCKET_F] = &gObjectEventGraphicsInfo_RocketF, + [OBJ_EVENT_GFX_GBA_KID] = &gObjectEventGraphicsInfo_GBAKid, + [OBJ_EVENT_GFX_SUPER_NERD] = &gObjectEventGraphicsInfo_SuperNerd, + [OBJ_EVENT_GFX_BIKER] = &gObjectEventGraphicsInfo_Biker, + [OBJ_EVENT_GFX_BLACKBELT] = &gObjectEventGraphicsInfo_Blackbelt, + [OBJ_EVENT_GFX_SCIENTIST] = &gObjectEventGraphicsInfo_Scientist, + [OBJ_EVENT_GFX_HIKER] = &gObjectEventGraphicsInfo_Hiker, + [OBJ_EVENT_GFX_FISHER] = &gObjectEventGraphicsInfo_Fisher, + [OBJ_EVENT_GFX_CHANNELER] = &gObjectEventGraphicsInfo_Channeler, + [OBJ_EVENT_GFX_CHEF] = &gObjectEventGraphicsInfo_Chef, + [OBJ_EVENT_GFX_POLICEMAN] = &gObjectEventGraphicsInfo_Policeman, + [OBJ_EVENT_GFX_GENTLEMAN] = &gObjectEventGraphicsInfo_Gentleman, + [OBJ_EVENT_GFX_SAILOR] = &gObjectEventGraphicsInfo_Sailor, + [OBJ_EVENT_GFX_CAPTAIN] = &gObjectEventGraphicsInfo_Captain, + [OBJ_EVENT_GFX_NURSE] = &gObjectEventGraphicsInfo_Nurse, + [OBJ_EVENT_GFX_CABLE_CLUB_RECEPTIONIST] = &gObjectEventGraphicsInfo_CableClubReceptionist, + [OBJ_EVENT_GFX_UNION_ROOM_RECEPTIONIST] = &gObjectEventGraphicsInfo_UnionRoomReceptionist, + [OBJ_EVENT_GFX_UNUSED_MALE_RECEPTIONIST] = &gObjectEventGraphicsInfo_UnusedMaleReceptionist, + [OBJ_EVENT_GFX_CLERK] = &gObjectEventGraphicsInfo_Clerk, + [OBJ_EVENT_GFX_MG_DELIVERYMAN] = &gObjectEventGraphicsInfo_MGDeliveryman, + [OBJ_EVENT_GFX_TRAINER_TOWER_DUDE] = &gObjectEventGraphicsInfo_TrainerTowerDude, + [OBJ_EVENT_GFX_PROF_OAK] = &gObjectEventGraphicsInfo_ProfOak, + [OBJ_EVENT_GFX_BLUE] = &gObjectEventGraphicsInfo_Blue, + [OBJ_EVENT_GFX_BILL] = &gObjectEventGraphicsInfo_Bill, + [OBJ_EVENT_GFX_LANCE] = &gObjectEventGraphicsInfo_Lance, + [OBJ_EVENT_GFX_AGATHA] = &gObjectEventGraphicsInfo_Agatha, + [OBJ_EVENT_GFX_DAISY] = &gObjectEventGraphicsInfo_Daisy, + [OBJ_EVENT_GFX_LORELEI] = &gObjectEventGraphicsInfo_Lorelei, + [OBJ_EVENT_GFX_MR_FUJI] = &gObjectEventGraphicsInfo_MrFuji, + [OBJ_EVENT_GFX_BRUNO] = &gObjectEventGraphicsInfo_Bruno, + [OBJ_EVENT_GFX_BROCK] = &gObjectEventGraphicsInfo_Brock, + [OBJ_EVENT_GFX_MISTY] = &gObjectEventGraphicsInfo_Misty, + [OBJ_EVENT_GFX_LT_SURGE] = &gObjectEventGraphicsInfo_LtSurge, + [OBJ_EVENT_GFX_ERIKA] = &gObjectEventGraphicsInfo_Erika, + [OBJ_EVENT_GFX_KOGA] = &gObjectEventGraphicsInfo_Koga, + [OBJ_EVENT_GFX_SABRINA] = &gObjectEventGraphicsInfo_Sabrina, + [OBJ_EVENT_GFX_BLAINE] = &gObjectEventGraphicsInfo_Blaine, + [OBJ_EVENT_GFX_GIOVANNI] = &gObjectEventGraphicsInfo_Giovanni, + [OBJ_EVENT_GFX_MOM] = &gObjectEventGraphicsInfo_Mom, + [OBJ_EVENT_GFX_CELIO] = &gObjectEventGraphicsInfo_Celio, + [OBJ_EVENT_GFX_TEACHY_TV_HOST] = &gObjectEventGraphicsInfo_TeachyTVHost, + [OBJ_EVENT_GFX_GYM_GUY] = &gObjectEventGraphicsInfo_GymGuy, + [OBJ_EVENT_GFX_ITEM_BALL] = &gObjectEventGraphicsInfo_ItemBall, + [OBJ_EVENT_GFX_TOWN_MAP] = &gObjectEventGraphicsInfo_TownMap, + [OBJ_EVENT_GFX_POKEDEX] = &gObjectEventGraphicsInfo_Pokedex, + [OBJ_EVENT_GFX_CUT_TREE] = &gObjectEventGraphicsInfo_CutTree, + [OBJ_EVENT_GFX_ROCK_SMASH_ROCK] = &gObjectEventGraphicsInfo_RockSmashRock, + [OBJ_EVENT_GFX_PUSHABLE_BOULDER] = &gObjectEventGraphicsInfo_StrengthBoulder, + [OBJ_EVENT_GFX_FOSSIL] = &gObjectEventGraphicsInfo_Fossil, + [OBJ_EVENT_GFX_RUBY] = &gObjectEventGraphicsInfo_Ruby, + [OBJ_EVENT_GFX_SAPPHIRE] = &gObjectEventGraphicsInfo_Sapphire, + [OBJ_EVENT_GFX_OLD_AMBER] = &gObjectEventGraphicsInfo_OldAmber, + [OBJ_EVENT_GFX_GYM_SIGN] = &gObjectEventGraphicsInfo_GymSign, + [OBJ_EVENT_GFX_SIGN] = &gObjectEventGraphicsInfo_Sign, + [OBJ_EVENT_GFX_TRAINER_TIPS] = &gObjectEventGraphicsInfo_TrainerTips, + [OBJ_EVENT_GFX_CLIPBOARD] = &gObjectEventGraphicsInfo_Clipboard, + [OBJ_EVENT_GFX_METEORITE] = &gObjectEventGraphicsInfo_Meteorite, + [OBJ_EVENT_GFX_LAPRAS_DOLL] = &gObjectEventGraphicsInfo_LaprasDoll, + [OBJ_EVENT_GFX_SEAGALLOP] = &gObjectEventGraphicsInfo_Seagallop, + [OBJ_EVENT_GFX_SNORLAX] = &gObjectEventGraphicsInfo_Snorlax, + [OBJ_EVENT_GFX_SPEAROW] = &gObjectEventGraphicsInfo_Spearow, + [OBJ_EVENT_GFX_CUBONE] = &gObjectEventGraphicsInfo_Cubone, + [OBJ_EVENT_GFX_POLIWRATH] = &gObjectEventGraphicsInfo_Poliwrath, + [OBJ_EVENT_GFX_CLEFAIRY] = &gObjectEventGraphicsInfo_Clefairy, + [OBJ_EVENT_GFX_PIDGEOT] = &gObjectEventGraphicsInfo_Pidgeot, + [OBJ_EVENT_GFX_JIGGLYPUFF] = &gObjectEventGraphicsInfo_Jigglypuff, + [OBJ_EVENT_GFX_PIDGEY] = &gObjectEventGraphicsInfo_Pidgey, + [OBJ_EVENT_GFX_CHANSEY] = &gObjectEventGraphicsInfo_Chansey, + [OBJ_EVENT_GFX_OMANYTE] = &gObjectEventGraphicsInfo_Omanyte, + [OBJ_EVENT_GFX_KANGASKHAN] = &gObjectEventGraphicsInfo_Kangaskhan, + [OBJ_EVENT_GFX_PIKACHU] = &gObjectEventGraphicsInfo_Pikachu, + [OBJ_EVENT_GFX_PSYDUCK] = &gObjectEventGraphicsInfo_Psyduck, + [OBJ_EVENT_GFX_NIDORAN_F] = &gObjectEventGraphicsInfo_NidoranF, + [OBJ_EVENT_GFX_NIDORAN_M] = &gObjectEventGraphicsInfo_NidoranM, + [OBJ_EVENT_GFX_NIDORINO] = &gObjectEventGraphicsInfo_Nidorino, + [OBJ_EVENT_GFX_MEOWTH] = &gObjectEventGraphicsInfo_Meowth, + [OBJ_EVENT_GFX_SEEL] = &gObjectEventGraphicsInfo_Seel, + [OBJ_EVENT_GFX_VOLTORB] = &gObjectEventGraphicsInfo_Voltorb, + [OBJ_EVENT_GFX_SLOWPOKE] = &gObjectEventGraphicsInfo_Slowpoke, + [OBJ_EVENT_GFX_SLOWBRO] = &gObjectEventGraphicsInfo_Slowbro, + [OBJ_EVENT_GFX_MACHOP] = &gObjectEventGraphicsInfo_Machop, + [OBJ_EVENT_GFX_WIGGLYTUFF] = &gObjectEventGraphicsInfo_Wigglytuff, + [OBJ_EVENT_GFX_DODUO] = &gObjectEventGraphicsInfo_Doduo, + [OBJ_EVENT_GFX_FEAROW] = &gObjectEventGraphicsInfo_Fearow, + [OBJ_EVENT_GFX_MACHOKE] = &gObjectEventGraphicsInfo_Machoke, + [OBJ_EVENT_GFX_LAPRAS] = &gObjectEventGraphicsInfo_Lapras, + [OBJ_EVENT_GFX_ZAPDOS] = &gObjectEventGraphicsInfo_Zapdos, + [OBJ_EVENT_GFX_MOLTRES] = &gObjectEventGraphicsInfo_Moltres, + [OBJ_EVENT_GFX_ARTICUNO] = &gObjectEventGraphicsInfo_Articuno, + [OBJ_EVENT_GFX_MEWTWO] = &gObjectEventGraphicsInfo_Mewtwo, + [OBJ_EVENT_GFX_MEW] = &gObjectEventGraphicsInfo_Mew, + [OBJ_EVENT_GFX_ENTEI] = &gObjectEventGraphicsInfo_Entei, + [OBJ_EVENT_GFX_SUICUNE] = &gObjectEventGraphicsInfo_Suicune, + [OBJ_EVENT_GFX_RAIKOU] = &gObjectEventGraphicsInfo_Raikou, + [OBJ_EVENT_GFX_LUGIA] = &gObjectEventGraphicsInfo_Lugia, + [OBJ_EVENT_GFX_HO_OH] = &gObjectEventGraphicsInfo_HoOh, + [OBJ_EVENT_GFX_CELEBI] = &gObjectEventGraphicsInfo_Celebi, + [OBJ_EVENT_GFX_KABUTO] = &gObjectEventGraphicsInfo_Kabuto, + [OBJ_EVENT_GFX_DEOXYS_D] = &gObjectEventGraphicsInfo_DeoxysD, + [OBJ_EVENT_GFX_DEOXYS_A] = &gObjectEventGraphicsInfo_DeoxysA, + [OBJ_EVENT_GFX_DEOXYS_N] = &gObjectEventGraphicsInfo_DeoxysN, + [OBJ_EVENT_GFX_SS_ANNE] = &gObjectEventGraphicsInfo_SSAnne, +}; diff --git a/src/data/object_events/object_event_pic_tables.h b/src/data/object_events/object_event_pic_tables.h new file mode 100644 index 000000000..9c0abfba4 --- /dev/null +++ b/src/data/object_events/object_event_pic_tables.h @@ -0,0 +1,1754 @@ +const struct SpriteFrameImage gObjectEventPicTable_RedNormal[] = { + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 0), + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 1), + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 2), + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 3), + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 4), + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 5), + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 6), + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 7), + overworld_frame(gObjectEventPic_RedNormal, 2, 4, 8), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 3), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 4), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 5), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 6), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 7), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 8), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 9), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 10), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 11), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 12), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 13), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RedBike[] = { + overworld_frame(gObjectEventPic_RedBike, 4, 4, 0), + overworld_frame(gObjectEventPic_RedBike, 4, 4, 1), + overworld_frame(gObjectEventPic_RedBike, 4, 4, 2), + overworld_frame(gObjectEventPic_RedBike, 4, 4, 3), + overworld_frame(gObjectEventPic_RedBike, 4, 4, 4), + overworld_frame(gObjectEventPic_RedBike, 4, 4, 5), + overworld_frame(gObjectEventPic_RedBike, 4, 4, 6), + overworld_frame(gObjectEventPic_RedBike, 4, 4, 7), + overworld_frame(gObjectEventPic_RedBike, 4, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GreenNormal[] = { + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 0), + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 1), + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 2), + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 3), + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 4), + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 5), + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 6), + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 7), + overworld_frame(gObjectEventPic_GreenNormal, 2, 4, 8), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 3), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 4), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 5), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 6), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 7), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 8), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 9), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 10), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 11), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 12), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 13), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GreenBike[] = { + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 0), + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 1), + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 2), + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 3), + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 4), + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 5), + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 6), + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 7), + overworld_frame(gObjectEventPic_GreenBike, 4, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RedSurf[] = { + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 0), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 1), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 2), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 0), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 0), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 1), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 1), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 2), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 2), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 0), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 1), + overworld_frame(gObjectEventPic_RedSurfRun, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GreenSurf[] = { + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 0), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 1), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 2), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 0), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 0), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 1), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 1), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 2), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 2), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 0), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 1), + overworld_frame(gObjectEventPic_GreenSurfRun, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RedItem[] = { + overworld_frame(gObjectEventPic_RedItem, 2, 4, 0), + overworld_frame(gObjectEventPic_RedItem, 2, 4, 1), + overworld_frame(gObjectEventPic_RedItem, 2, 4, 2), + overworld_frame(gObjectEventPic_RedItem, 2, 4, 3), + overworld_frame(gObjectEventPic_RedItem, 2, 4, 4), + overworld_frame(gObjectEventPic_RedItem, 2, 4, 5), + overworld_frame(gObjectEventPic_RedItem, 2, 4, 6), + overworld_frame(gObjectEventPic_RedItem, 2, 4, 7), + overworld_frame(gObjectEventPic_RedItem, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GreenItem[] = { + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 0), + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 1), + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 2), + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 3), + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 4), + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 5), + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 6), + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 7), + overworld_frame(gObjectEventPic_GreenItem, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RedVSSeekerBike[] = { + overworld_frame(gObjectEventPic_RedVSSeekerBike, 4, 4, 0), + overworld_frame(gObjectEventPic_RedVSSeekerBike, 4, 4, 1), + overworld_frame(gObjectEventPic_RedVSSeekerBike, 4, 4, 2), + overworld_frame(gObjectEventPic_RedVSSeekerBike, 4, 4, 3), + overworld_frame(gObjectEventPic_RedVSSeekerBike, 4, 4, 4), + overworld_frame(gObjectEventPic_RedVSSeekerBike, 4, 4, 5), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GreenVSSeekerBike[] = { + overworld_frame(gObjectEventPic_GreenVSSeekerBike, 4, 4, 0), + overworld_frame(gObjectEventPic_GreenVSSeekerBike, 4, 4, 1), + overworld_frame(gObjectEventPic_GreenVSSeekerBike, 4, 4, 2), + overworld_frame(gObjectEventPic_GreenVSSeekerBike, 4, 4, 3), + overworld_frame(gObjectEventPic_GreenVSSeekerBike, 4, 4, 4), + overworld_frame(gObjectEventPic_GreenVSSeekerBike, 4, 4, 5), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RSBrendan[] = { + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 0), + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 1), + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 2), + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 3), + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 4), + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 5), + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 6), + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 7), + overworld_frame(gObjectEventPic_RSBrendan, 2, 4, 8), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RSMay[] = { + overworld_frame(gObjectEventPic_RSMay, 2, 4, 0), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 1), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 2), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 3), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 4), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 5), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 6), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 7), + overworld_frame(gObjectEventPic_RSMay, 2, 4, 8), + overworld_frame(gObjectEventPic_RedFish, 2, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Policeman[] = { + overworld_frame(gObjectEventPic_Policeman, 2, 4, 0), + overworld_frame(gObjectEventPic_Policeman, 2, 4, 1), + overworld_frame(gObjectEventPic_Policeman, 2, 4, 2), + overworld_frame(gObjectEventPic_Policeman, 2, 4, 3), + overworld_frame(gObjectEventPic_Policeman, 2, 4, 4), + overworld_frame(gObjectEventPic_Policeman, 2, 4, 5), + overworld_frame(gObjectEventPic_Policeman, 2, 4, 6), + overworld_frame(gObjectEventPic_Policeman, 2, 4, 7), + overworld_frame(gObjectEventPic_Policeman, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_LittleBoy[] = { + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 0), + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 1), + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 2), + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 3), + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 4), + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 5), + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 6), + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 7), + overworld_frame(gObjectEventPic_LittleBoy, 2, 2, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_LittleGirl[] = { + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 0), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 1), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 2), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 3), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 4), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 5), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 6), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 7), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 8), + overworld_frame(gObjectEventPic_LittleGirl, 2, 2, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_SittingBoy[] = { + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 0), + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 2), + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 1), + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 0), + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 0), + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 2), + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 2), + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 1), + overworld_frame(gObjectEventPic_SittingBoy, 2, 4, 1), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Lass[] = { + overworld_frame(gObjectEventPic_Lass, 2, 4, 0), + overworld_frame(gObjectEventPic_Lass, 2, 4, 1), + overworld_frame(gObjectEventPic_Lass, 2, 4, 2), + overworld_frame(gObjectEventPic_Lass, 2, 4, 3), + overworld_frame(gObjectEventPic_Lass, 2, 4, 4), + overworld_frame(gObjectEventPic_Lass, 2, 4, 5), + overworld_frame(gObjectEventPic_Lass, 2, 4, 6), + overworld_frame(gObjectEventPic_Lass, 2, 4, 7), + overworld_frame(gObjectEventPic_Lass, 2, 4, 8), + overworld_frame(gObjectEventPic_Lass, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Youngster[] = { + overworld_frame(gObjectEventPic_Youngster, 2, 4, 0), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 1), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 2), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 3), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 4), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 5), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 6), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 7), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 8), + overworld_frame(gObjectEventPic_Youngster, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Woman1[] = { + overworld_frame(gObjectEventPic_Woman1, 2, 4, 0), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 1), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 2), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 3), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 4), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 5), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 6), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 7), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 8), + overworld_frame(gObjectEventPic_Woman1, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Woman3[] = { + overworld_frame(gObjectEventPic_Woman3, 2, 4, 0), + overworld_frame(gObjectEventPic_Woman3, 2, 4, 1), + overworld_frame(gObjectEventPic_Woman3, 2, 4, 2), + overworld_frame(gObjectEventPic_Woman3, 2, 4, 3), + overworld_frame(gObjectEventPic_Woman3, 2, 4, 4), + overworld_frame(gObjectEventPic_Woman3, 2, 4, 5), + overworld_frame(gObjectEventPic_Woman3, 2, 4, 6), + overworld_frame(gObjectEventPic_Woman3, 2, 4, 7), + overworld_frame(gObjectEventPic_Woman3, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_BattleGirl[] = { + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 0), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 1), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 2), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 3), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 4), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 5), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 6), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 7), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 8), + overworld_frame(gObjectEventPic_BattleGirl, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_BugCatcher[] = { + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 0), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 1), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 2), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 3), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 4), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 5), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 6), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 7), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 8), + overworld_frame(gObjectEventPic_BugCatcher, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_FatMan[] = { + overworld_frame(gObjectEventPic_FatMan, 2, 4, 0), + overworld_frame(gObjectEventPic_FatMan, 2, 4, 1), + overworld_frame(gObjectEventPic_FatMan, 2, 4, 2), + overworld_frame(gObjectEventPic_FatMan, 2, 4, 3), + overworld_frame(gObjectEventPic_FatMan, 2, 4, 4), + overworld_frame(gObjectEventPic_FatMan, 2, 4, 5), + overworld_frame(gObjectEventPic_FatMan, 2, 4, 6), + overworld_frame(gObjectEventPic_FatMan, 2, 4, 7), + overworld_frame(gObjectEventPic_FatMan, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_BaldingMan[] = { + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 0), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 1), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 2), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 3), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 4), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 5), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 6), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 7), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 8), + overworld_frame(gObjectEventPic_BaldingMan, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Woman2[] = { + overworld_frame(gObjectEventPic_Woman2, 2, 4, 0), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 1), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 2), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 3), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 4), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 5), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 6), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 7), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 8), + overworld_frame(gObjectEventPic_Woman2, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_OldMan1[] = { + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 0), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 1), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 2), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 3), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 4), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 5), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 6), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 7), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 8), + overworld_frame(gObjectEventPic_OldMan1, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_WorkerM[] = { + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 0), + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 1), + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 2), + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 3), + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 4), + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 5), + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 6), + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 7), + overworld_frame(gObjectEventPic_WorkerM, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_WorkerF[] = { + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 0), + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 1), + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 2), + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 3), + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 4), + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 5), + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 6), + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 7), + overworld_frame(gObjectEventPic_WorkerF, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Beauty[] = { + overworld_frame(gObjectEventPic_Beauty, 2, 4, 0), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 1), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 2), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 3), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 4), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 5), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 6), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 7), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 8), + overworld_frame(gObjectEventPic_Beauty, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Chef[] = { + overworld_frame(gObjectEventPic_Chef, 2, 4, 0), + overworld_frame(gObjectEventPic_Chef, 2, 4, 1), + overworld_frame(gObjectEventPic_Chef, 2, 4, 2), + overworld_frame(gObjectEventPic_Chef, 2, 4, 3), + overworld_frame(gObjectEventPic_Chef, 2, 4, 4), + overworld_frame(gObjectEventPic_Chef, 2, 4, 5), + overworld_frame(gObjectEventPic_Chef, 2, 4, 6), + overworld_frame(gObjectEventPic_Chef, 2, 4, 7), + overworld_frame(gObjectEventPic_Chef, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_OldMan2[] = { + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 0), + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 1), + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 2), + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 0), + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 0), + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 1), + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 1), + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 2), + overworld_frame(gObjectEventPic_OldMan2, 2, 4, 2), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_OldManLyingDown[] = { + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), + overworld_frame(gObjectEventPic_OldManLyingDown, 4, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_OldWoman[] = { + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 0), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 1), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 2), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 3), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 4), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 5), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 6), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 7), + overworld_frame(gObjectEventPic_OldWoman, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Camper[] = { + overworld_frame(gObjectEventPic_Camper, 2, 4, 0), + overworld_frame(gObjectEventPic_Camper, 2, 4, 1), + overworld_frame(gObjectEventPic_Camper, 2, 4, 2), + overworld_frame(gObjectEventPic_Camper, 2, 4, 3), + overworld_frame(gObjectEventPic_Camper, 2, 4, 4), + overworld_frame(gObjectEventPic_Camper, 2, 4, 5), + overworld_frame(gObjectEventPic_Camper, 2, 4, 6), + overworld_frame(gObjectEventPic_Camper, 2, 4, 7), + overworld_frame(gObjectEventPic_Camper, 2, 4, 8), + overworld_frame(gObjectEventPic_Camper, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Picnicker[] = { + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 0), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 1), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 2), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 3), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 4), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 5), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 6), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 7), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 8), + overworld_frame(gObjectEventPic_Picnicker, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_CooltrainerM[] = { + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 0), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 1), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 2), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 3), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 4), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 5), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 6), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 7), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 8), + overworld_frame(gObjectEventPic_CooltrainerM, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_CooltrainerF[] = { + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 0), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 1), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 2), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 3), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 4), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 5), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 6), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 7), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 8), + overworld_frame(gObjectEventPic_CooltrainerF, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Boy[] = { + overworld_frame(gObjectEventPic_Boy, 2, 4, 0), + overworld_frame(gObjectEventPic_Boy, 2, 4, 1), + overworld_frame(gObjectEventPic_Boy, 2, 4, 2), + overworld_frame(gObjectEventPic_Boy, 2, 4, 3), + overworld_frame(gObjectEventPic_Boy, 2, 4, 4), + overworld_frame(gObjectEventPic_Boy, 2, 4, 5), + overworld_frame(gObjectEventPic_Boy, 2, 4, 6), + overworld_frame(gObjectEventPic_Boy, 2, 4, 7), + overworld_frame(gObjectEventPic_Boy, 2, 4, 8), + overworld_frame(gObjectEventPic_Boy, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_SuperNerd[] = { + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 0), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 1), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 2), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 3), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 4), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 5), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 6), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 7), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 8), + overworld_frame(gObjectEventPic_SuperNerd, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Channeler[] = { + overworld_frame(gObjectEventPic_Channeler, 2, 4, 0), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 1), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 2), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 3), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 4), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 5), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 6), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 7), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 8), + overworld_frame(gObjectEventPic_Channeler, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RocketF[] = { + overworld_frame(gObjectEventPic_RocketF, 2, 4, 0), + overworld_frame(gObjectEventPic_RocketF, 2, 4, 1), + overworld_frame(gObjectEventPic_RocketF, 2, 4, 2), + overworld_frame(gObjectEventPic_RocketF, 2, 4, 3), + overworld_frame(gObjectEventPic_RocketF, 2, 4, 4), + overworld_frame(gObjectEventPic_RocketF, 2, 4, 5), + overworld_frame(gObjectEventPic_RocketF, 2, 4, 6), + overworld_frame(gObjectEventPic_RocketF, 2, 4, 7), + overworld_frame(gObjectEventPic_RocketF, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_SwimmerMWater[] = { + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 0), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 1), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 2), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 3), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 4), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 5), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 6), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 7), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 8), + overworld_frame(gObjectEventPic_SwimmerMWater, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_SwimmerFWater[] = { + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 0), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 1), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 2), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 3), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 4), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 5), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 6), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 7), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 8), + overworld_frame(gObjectEventPic_SwimmerFWater, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_SwimmerMLand[] = { + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 0), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 1), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 2), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 3), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 4), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 5), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 6), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 7), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 8), + overworld_frame(gObjectEventPic_SwimmerMLand, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_SwimmerFLand[] = { + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 0), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 1), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 2), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 3), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 4), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 5), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 6), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 7), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 8), + overworld_frame(gObjectEventPic_SwimmerFLand, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Blackbelt[] = { + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 0), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 1), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 2), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 3), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 4), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 5), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 6), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 7), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 8), + overworld_frame(gObjectEventPic_Blackbelt, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Scientist[] = { + overworld_frame(gObjectEventPic_Scientist, 2, 4, 0), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 1), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 2), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 3), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 4), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 5), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 6), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 7), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 8), + overworld_frame(gObjectEventPic_Scientist, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Gentleman[] = { + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 0), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 1), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 2), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 3), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 4), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 5), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 6), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 7), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 8), + overworld_frame(gObjectEventPic_Gentleman, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Sailor[] = { + overworld_frame(gObjectEventPic_Sailor, 2, 4, 0), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 1), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 2), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 3), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 4), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 5), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 6), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 7), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 8), + overworld_frame(gObjectEventPic_Sailor, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Captain[] = { + overworld_frame(gObjectEventPic_Captain, 2, 4, 0), + overworld_frame(gObjectEventPic_Captain, 2, 4, 1), + overworld_frame(gObjectEventPic_Captain, 2, 4, 2), + overworld_frame(gObjectEventPic_Captain, 2, 4, 3), + overworld_frame(gObjectEventPic_Captain, 2, 4, 4), + overworld_frame(gObjectEventPic_Captain, 2, 4, 5), + overworld_frame(gObjectEventPic_Captain, 2, 4, 6), + overworld_frame(gObjectEventPic_Captain, 2, 4, 7), + overworld_frame(gObjectEventPic_Captain, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Fisher[] = { + overworld_frame(gObjectEventPic_Fisher, 2, 4, 0), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 1), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 2), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 3), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 4), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 5), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 6), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 7), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 8), + overworld_frame(gObjectEventPic_Fisher, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_TeachyTVHost[] = { + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 0), + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 1), + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 2), + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 3), + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 4), + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 5), + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 6), + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 7), + overworld_frame(gObjectEventPic_TeachyTVHost, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_UnusedWoman[] = { + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 0), + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 1), + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 2), + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 3), + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 4), + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 5), + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 6), + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 7), + overworld_frame(gObjectEventPic_UnusedWoman, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_TuberF[] = { + overworld_frame(gObjectEventPic_TuberF, 2, 2, 0), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 1), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 2), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 3), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 4), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 5), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 6), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 7), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 8), + overworld_frame(gObjectEventPic_TuberF, 2, 2, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_TuberMWater[] = { + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 0), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 1), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 2), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 3), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 4), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 5), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 6), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 7), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 8), + overworld_frame(gObjectEventPic_TuberMWater, 2, 2, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_TuberMLand[] = { + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 0), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 1), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 2), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 3), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 4), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 5), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 6), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 7), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 8), + overworld_frame(gObjectEventPic_TuberMLand, 2, 2, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Hiker[] = { + overworld_frame(gObjectEventPic_Hiker, 2, 4, 0), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 1), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 2), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 3), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 4), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 5), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 6), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 7), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 8), + overworld_frame(gObjectEventPic_Hiker, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Biker[] = { + overworld_frame(gObjectEventPic_Biker, 4, 4, 0), + overworld_frame(gObjectEventPic_Biker, 4, 4, 1), + overworld_frame(gObjectEventPic_Biker, 4, 4, 2), + overworld_frame(gObjectEventPic_Biker, 4, 4, 3), + overworld_frame(gObjectEventPic_Biker, 4, 4, 4), + overworld_frame(gObjectEventPic_Biker, 4, 4, 5), + overworld_frame(gObjectEventPic_Biker, 4, 4, 6), + overworld_frame(gObjectEventPic_Biker, 4, 4, 7), + overworld_frame(gObjectEventPic_Biker, 4, 4, 8), + overworld_frame(gObjectEventPic_Biker, 4, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GymGuy[] = { + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 0), + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 1), + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 2), + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 3), + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 4), + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 5), + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 6), + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 7), + overworld_frame(gObjectEventPic_GymGuy, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Nurse[] = { + overworld_frame(gObjectEventPic_Nurse, 2, 4, 0), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 1), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 2), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 0), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 0), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 1), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 1), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 2), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 2), + overworld_frame(gObjectEventPic_Nurse, 2, 4, 3), +}; + +const struct SpriteFrameImage gObjectEventPicTable_UnusedMaleReceptionist[] = { + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 2), + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 2), + overworld_frame(gObjectEventPic_UnusedMaleReceptionist, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_ItemBall[] = { + overworld_frame(gObjectEventPic_ItemBall, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_ProfOak[] = { + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 0), + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 1), + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 2), + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 3), + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 4), + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 5), + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 6), + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 7), + overworld_frame(gObjectEventPic_ProfOak, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Man[] = { + overworld_frame(gObjectEventPic_Man, 2, 4, 0), + overworld_frame(gObjectEventPic_Man, 2, 4, 1), + overworld_frame(gObjectEventPic_Man, 2, 4, 2), + overworld_frame(gObjectEventPic_Man, 2, 4, 3), + overworld_frame(gObjectEventPic_Man, 2, 4, 4), + overworld_frame(gObjectEventPic_Man, 2, 4, 5), + overworld_frame(gObjectEventPic_Man, 2, 4, 6), + overworld_frame(gObjectEventPic_Man, 2, 4, 7), + overworld_frame(gObjectEventPic_Man, 2, 4, 8), + overworld_frame(gObjectEventPic_Man, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Rocker[] = { + overworld_frame(gObjectEventPic_Rocker, 2, 4, 0), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 1), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 2), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 3), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 4), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 5), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 6), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 7), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 8), + overworld_frame(gObjectEventPic_Rocker, 2, 4, 9), +}; + +const struct SpriteFrameImage gObjectEventPicTable_MrFuji[] = { + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 0), + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 1), + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 2), + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 3), + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 4), + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 5), + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 6), + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 7), + overworld_frame(gObjectEventPic_MrFuji, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Bruno[] = { + overworld_frame(gObjectEventPic_Bruno, 2, 4, 0), + overworld_frame(gObjectEventPic_Bruno, 2, 4, 1), + overworld_frame(gObjectEventPic_Bruno, 2, 4, 2), + overworld_frame(gObjectEventPic_Bruno, 2, 4, 0), + overworld_frame(gObjectEventPic_Bruno, 2, 4, 0), + overworld_frame(gObjectEventPic_Bruno, 2, 4, 1), + overworld_frame(gObjectEventPic_Bruno, 2, 4, 1), + overworld_frame(gObjectEventPic_Bruno, 2, 4, 2), + overworld_frame(gObjectEventPic_Bruno, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_CutTree[] = { + overworld_frame(gObjectEventPic_CutTree, 2, 2, 0), + overworld_frame(gObjectEventPic_CutTree, 2, 2, 1), + overworld_frame(gObjectEventPic_CutTree, 2, 2, 2), + overworld_frame(gObjectEventPic_CutTree, 2, 2, 3), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Clerk[] = { + overworld_frame(gObjectEventPic_Clerk, 2, 4, 0), + overworld_frame(gObjectEventPic_Clerk, 2, 4, 1), + overworld_frame(gObjectEventPic_Clerk, 2, 4, 2), + overworld_frame(gObjectEventPic_Clerk, 2, 4, 3), + overworld_frame(gObjectEventPic_Clerk, 2, 4, 4), + overworld_frame(gObjectEventPic_Clerk, 2, 4, 5), + overworld_frame(gObjectEventPic_Clerk, 2, 4, 6), + overworld_frame(gObjectEventPic_Clerk, 2, 4, 7), + overworld_frame(gObjectEventPic_Clerk, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_MGDeliveryman[] = { + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 0), + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 1), + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 2), + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 0), + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 0), + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 1), + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 1), + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 2), + overworld_frame(gObjectEventPic_MGDeliveryman, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_TrainerTowerDude[] = { + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 0), + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 1), + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 2), + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 0), + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 0), + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 1), + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 1), + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 2), + overworld_frame(gObjectEventPic_TrainerTowerDude, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_CableClubReceptionist[] = { + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 2), + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 2), + overworld_frame(gObjectEventPic_CableClubReceptionist, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_UnionRoomReceptionist[] = { + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 2), + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 0), + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 1), + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 2), + overworld_frame(gObjectEventPic_UnionRoomReceptionist, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RockSmashRock[] = { + overworld_frame(gObjectEventPic_RockSmashRock, 2, 2, 0), + overworld_frame(gObjectEventPic_RockSmashRock, 2, 2, 1), + overworld_frame(gObjectEventPic_RockSmashRock, 2, 2, 2), + overworld_frame(gObjectEventPic_RockSmashRock, 2, 2, 3), +}; + +const struct SpriteFrameImage gObjectEventPicTable_StrengthBoulder[] = { + overworld_frame(gObjectEventPic_StrengthBoulder, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RocketM[] = { + overworld_frame(gObjectEventPic_RocketM, 2, 4, 0), + overworld_frame(gObjectEventPic_RocketM, 2, 4, 1), + overworld_frame(gObjectEventPic_RocketM, 2, 4, 2), + overworld_frame(gObjectEventPic_RocketM, 2, 4, 3), + overworld_frame(gObjectEventPic_RocketM, 2, 4, 4), + overworld_frame(gObjectEventPic_RocketM, 2, 4, 5), + overworld_frame(gObjectEventPic_RocketM, 2, 4, 6), + overworld_frame(gObjectEventPic_RocketM, 2, 4, 7), + overworld_frame(gObjectEventPic_RocketM, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Celio[] = { + overworld_frame(gObjectEventPic_Celio, 2, 4, 0), + overworld_frame(gObjectEventPic_Celio, 2, 4, 1), + overworld_frame(gObjectEventPic_Celio, 2, 4, 2), + overworld_frame(gObjectEventPic_Celio, 2, 4, 3), + overworld_frame(gObjectEventPic_Celio, 2, 4, 4), + overworld_frame(gObjectEventPic_Celio, 2, 4, 5), + overworld_frame(gObjectEventPic_Celio, 2, 4, 6), + overworld_frame(gObjectEventPic_Celio, 2, 4, 7), + overworld_frame(gObjectEventPic_Celio, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Agatha[] = { + overworld_frame(gObjectEventPic_Agatha, 2, 4, 0), + overworld_frame(gObjectEventPic_Agatha, 2, 4, 1), + overworld_frame(gObjectEventPic_Agatha, 2, 4, 2), + overworld_frame(gObjectEventPic_Agatha, 2, 4, 0), + overworld_frame(gObjectEventPic_Agatha, 2, 4, 0), + overworld_frame(gObjectEventPic_Agatha, 2, 4, 1), + overworld_frame(gObjectEventPic_Agatha, 2, 4, 1), + overworld_frame(gObjectEventPic_Agatha, 2, 4, 2), + overworld_frame(gObjectEventPic_Agatha, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Brock[] = { + overworld_frame(gObjectEventPic_Brock, 2, 4, 0), + overworld_frame(gObjectEventPic_Brock, 2, 4, 1), + overworld_frame(gObjectEventPic_Brock, 2, 4, 2), + overworld_frame(gObjectEventPic_Brock, 2, 4, 0), + overworld_frame(gObjectEventPic_Brock, 2, 4, 0), + overworld_frame(gObjectEventPic_Brock, 2, 4, 1), + overworld_frame(gObjectEventPic_Brock, 2, 4, 1), + overworld_frame(gObjectEventPic_Brock, 2, 4, 2), + overworld_frame(gObjectEventPic_Brock, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Misty[] = { + overworld_frame(gObjectEventPic_Misty, 2, 4, 0), + overworld_frame(gObjectEventPic_Misty, 2, 4, 1), + overworld_frame(gObjectEventPic_Misty, 2, 4, 2), + overworld_frame(gObjectEventPic_Misty, 2, 4, 0), + overworld_frame(gObjectEventPic_Misty, 2, 4, 0), + overworld_frame(gObjectEventPic_Misty, 2, 4, 1), + overworld_frame(gObjectEventPic_Misty, 2, 4, 1), + overworld_frame(gObjectEventPic_Misty, 2, 4, 2), + overworld_frame(gObjectEventPic_Misty, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_LtSurge[] = { + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 0), + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 1), + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 2), + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 0), + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 0), + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 1), + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 1), + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 2), + overworld_frame(gObjectEventPic_LtSurge, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Erika[] = { + overworld_frame(gObjectEventPic_Erika, 2, 4, 0), + overworld_frame(gObjectEventPic_Erika, 2, 4, 1), + overworld_frame(gObjectEventPic_Erika, 2, 4, 2), + overworld_frame(gObjectEventPic_Erika, 2, 4, 0), + overworld_frame(gObjectEventPic_Erika, 2, 4, 0), + overworld_frame(gObjectEventPic_Erika, 2, 4, 1), + overworld_frame(gObjectEventPic_Erika, 2, 4, 1), + overworld_frame(gObjectEventPic_Erika, 2, 4, 2), + overworld_frame(gObjectEventPic_Erika, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Koga[] = { + overworld_frame(gObjectEventPic_Koga, 2, 4, 0), + overworld_frame(gObjectEventPic_Koga, 2, 4, 1), + overworld_frame(gObjectEventPic_Koga, 2, 4, 2), + overworld_frame(gObjectEventPic_Koga, 2, 4, 0), + overworld_frame(gObjectEventPic_Koga, 2, 4, 0), + overworld_frame(gObjectEventPic_Koga, 2, 4, 1), + overworld_frame(gObjectEventPic_Koga, 2, 4, 1), + overworld_frame(gObjectEventPic_Koga, 2, 4, 2), + overworld_frame(gObjectEventPic_Koga, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Giovanni[] = { + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 0), + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 1), + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 2), + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 3), + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 4), + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 5), + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 6), + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 7), + overworld_frame(gObjectEventPic_Giovanni, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Blaine[] = { + overworld_frame(gObjectEventPic_Blaine, 2, 4, 0), + overworld_frame(gObjectEventPic_Blaine, 2, 4, 1), + overworld_frame(gObjectEventPic_Blaine, 2, 4, 2), + overworld_frame(gObjectEventPic_Blaine, 2, 4, 0), + overworld_frame(gObjectEventPic_Blaine, 2, 4, 0), + overworld_frame(gObjectEventPic_Blaine, 2, 4, 1), + overworld_frame(gObjectEventPic_Blaine, 2, 4, 1), + overworld_frame(gObjectEventPic_Blaine, 2, 4, 2), + overworld_frame(gObjectEventPic_Blaine, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Sabrina[] = { + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 0), + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 1), + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 2), + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 0), + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 0), + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 1), + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 1), + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 2), + overworld_frame(gObjectEventPic_Sabrina, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Bill[] = { + overworld_frame(gObjectEventPic_Bill, 2, 4, 0), + overworld_frame(gObjectEventPic_Bill, 2, 4, 1), + overworld_frame(gObjectEventPic_Bill, 2, 4, 2), + overworld_frame(gObjectEventPic_Bill, 2, 4, 3), + overworld_frame(gObjectEventPic_Bill, 2, 4, 4), + overworld_frame(gObjectEventPic_Bill, 2, 4, 5), + overworld_frame(gObjectEventPic_Bill, 2, 4, 6), + overworld_frame(gObjectEventPic_Bill, 2, 4, 7), + overworld_frame(gObjectEventPic_Bill, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Daisy[] = { + overworld_frame(gObjectEventPic_Daisy, 2, 4, 0), + overworld_frame(gObjectEventPic_Daisy, 2, 4, 1), + overworld_frame(gObjectEventPic_Daisy, 2, 4, 2), + overworld_frame(gObjectEventPic_Daisy, 2, 4, 3), + overworld_frame(gObjectEventPic_Daisy, 2, 4, 4), + overworld_frame(gObjectEventPic_Daisy, 2, 4, 5), + overworld_frame(gObjectEventPic_Daisy, 2, 4, 6), + overworld_frame(gObjectEventPic_Daisy, 2, 4, 7), + overworld_frame(gObjectEventPic_Daisy, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Lorelei[] = { + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 0), + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 1), + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 2), + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 3), + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 4), + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 5), + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 6), + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 7), + overworld_frame(gObjectEventPic_Lorelei, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Lance[] = { + overworld_frame(gObjectEventPic_Lance, 2, 4, 0), + overworld_frame(gObjectEventPic_Lance, 2, 4, 1), + overworld_frame(gObjectEventPic_Lance, 2, 4, 2), + overworld_frame(gObjectEventPic_Lance, 2, 4, 0), + overworld_frame(gObjectEventPic_Lance, 2, 4, 0), + overworld_frame(gObjectEventPic_Lance, 2, 4, 1), + overworld_frame(gObjectEventPic_Lance, 2, 4, 1), + overworld_frame(gObjectEventPic_Lance, 2, 4, 2), + overworld_frame(gObjectEventPic_Lance, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Blue[] = { + overworld_frame(gObjectEventPic_Blue, 2, 4, 0), + overworld_frame(gObjectEventPic_Blue, 2, 4, 1), + overworld_frame(gObjectEventPic_Blue, 2, 4, 2), + overworld_frame(gObjectEventPic_Blue, 2, 4, 3), + overworld_frame(gObjectEventPic_Blue, 2, 4, 4), + overworld_frame(gObjectEventPic_Blue, 2, 4, 5), + overworld_frame(gObjectEventPic_Blue, 2, 4, 6), + overworld_frame(gObjectEventPic_Blue, 2, 4, 7), + overworld_frame(gObjectEventPic_Blue, 2, 4, 8), +}; + +const struct SpriteFrameImage gObjectEventPicTable_RedFish[] = { + overworld_frame(gObjectEventPic_RedFish, 4, 4, 0), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 1), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 2), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 3), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 4), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 5), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 6), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 7), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 8), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 9), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 10), + overworld_frame(gObjectEventPic_RedFish, 4, 4, 11), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GreenFish[] = { + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 0), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 1), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 2), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 3), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 4), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 5), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 6), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 7), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 8), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 9), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 10), + overworld_frame(gObjectEventPic_GreenFish, 4, 4, 11), +}; + +const struct SpriteFrameImage gObjectEventPicTable_TownMap[] = { + overworld_frame(gObjectEventPic_TownMap, 2, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Pokedex[] = { + overworld_frame(gObjectEventPic_Pokedex, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GBAKid[] = { + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 0), + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 1), + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 2), + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 0), + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 0), + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 1), + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 1), + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 2), + overworld_frame(gObjectEventPic_GBAKid, 2, 4, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Fossil[] = { + overworld_frame(gObjectEventPic_Fossil, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Ruby[] = { + overworld_frame(gObjectEventPic_Ruby, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Sapphire[] = { + overworld_frame(gObjectEventPic_Sapphire, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_OldAmber[] = { + overworld_frame(gObjectEventPic_OldAmber, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_GymSign[] = { + overworld_frame(gObjectEventPic_GymSign, 2, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Sign[] = { + overworld_frame(gObjectEventPic_Sign, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_WoodenSign[] = { + overworld_frame(gObjectEventPic_WoodenSign, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Clipboard[] = { + overworld_frame(gObjectEventPic_Clipboard, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_BirthIslandStone[] = { + overworld_frame(gObjectEventPic_BirthIslandStone, 4, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_LaprasDoll[] = { + overworld_frame(gObjectEventPic_LaprasDoll, 4, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Seagallop[] = { + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), + overworld_frame(gObjectEventPic_Seagallop, 4, 16, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_SSAnne[] = { + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), + overworld_frame(gObjectEventPic_SSAnne, 8, 16, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Snorlax[] = { + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), + overworld_frame(gObjectEventPic_Snorlax, 4, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Spearow[] = { + overworld_frame(gObjectEventPic_Spearow, 2, 2, 0), + overworld_frame(gObjectEventPic_Spearow, 2, 2, 1), + overworld_frame(gObjectEventPic_Spearow, 2, 2, 2), + overworld_frame(gObjectEventPic_Spearow, 2, 2, 0), + overworld_frame(gObjectEventPic_Spearow, 2, 2, 0), + overworld_frame(gObjectEventPic_Spearow, 2, 2, 1), + overworld_frame(gObjectEventPic_Spearow, 2, 2, 1), + overworld_frame(gObjectEventPic_Spearow, 2, 2, 2), + overworld_frame(gObjectEventPic_Spearow, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Pidgeot[] = { + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 0), + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 1), + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 2), + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 0), + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 0), + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 1), + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 1), + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 2), + overworld_frame(gObjectEventPic_Pidgeot, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Omanyte[] = { + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 0), + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 1), + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 2), + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 0), + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 0), + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 1), + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 1), + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 2), + overworld_frame(gObjectEventPic_Omanyte, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Kangaskhan[] = { + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 0), + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 1), + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 2), + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 0), + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 0), + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 1), + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 1), + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 2), + overworld_frame(gObjectEventPic_Kangaskhan, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Psyduck[] = { + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 0), + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 1), + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 2), + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 0), + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 0), + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 1), + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 1), + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 2), + overworld_frame(gObjectEventPic_Psyduck, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_NidoranF[] = { + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 0), + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 1), + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 2), + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 0), + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 0), + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 1), + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 1), + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 2), + overworld_frame(gObjectEventPic_NidoranF, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_NidoranM[] = { + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 0), + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 1), + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 2), + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 0), + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 0), + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 1), + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 1), + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 2), + overworld_frame(gObjectEventPic_NidoranM, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Nidorino[] = { + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 0), + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 1), + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 2), + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 0), + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 0), + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 1), + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 1), + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 2), + overworld_frame(gObjectEventPic_Nidorino, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Meowth[] = { + overworld_frame(gObjectEventPic_Meowth, 2, 2, 0), + overworld_frame(gObjectEventPic_Meowth, 2, 2, 1), + overworld_frame(gObjectEventPic_Meowth, 2, 2, 2), + overworld_frame(gObjectEventPic_Meowth, 2, 2, 0), + overworld_frame(gObjectEventPic_Meowth, 2, 2, 0), + overworld_frame(gObjectEventPic_Meowth, 2, 2, 1), + overworld_frame(gObjectEventPic_Meowth, 2, 2, 1), + overworld_frame(gObjectEventPic_Meowth, 2, 2, 2), + overworld_frame(gObjectEventPic_Meowth, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Seel[] = { + overworld_frame(gObjectEventPic_Seel, 2, 2, 0), + overworld_frame(gObjectEventPic_Seel, 2, 2, 1), + overworld_frame(gObjectEventPic_Seel, 2, 2, 2), + overworld_frame(gObjectEventPic_Seel, 2, 2, 0), + overworld_frame(gObjectEventPic_Seel, 2, 2, 0), + overworld_frame(gObjectEventPic_Seel, 2, 2, 1), + overworld_frame(gObjectEventPic_Seel, 2, 2, 1), + overworld_frame(gObjectEventPic_Seel, 2, 2, 2), + overworld_frame(gObjectEventPic_Seel, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Voltorb[] = { + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 0), + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 1), + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 2), + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 0), + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 0), + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 1), + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 1), + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 2), + overworld_frame(gObjectEventPic_Voltorb, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Slowpoke[] = { + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 0), + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 1), + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 2), + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 0), + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 0), + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 1), + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 1), + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 2), + overworld_frame(gObjectEventPic_Slowpoke, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Slowbro[] = { + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 0), + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 1), + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 2), + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 0), + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 0), + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 1), + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 1), + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 2), + overworld_frame(gObjectEventPic_Slowbro, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Machop[] = { + overworld_frame(gObjectEventPic_Machop, 2, 2, 0), + overworld_frame(gObjectEventPic_Machop, 2, 2, 1), + overworld_frame(gObjectEventPic_Machop, 2, 2, 2), + overworld_frame(gObjectEventPic_Machop, 2, 2, 0), + overworld_frame(gObjectEventPic_Machop, 2, 2, 0), + overworld_frame(gObjectEventPic_Machop, 2, 2, 1), + overworld_frame(gObjectEventPic_Machop, 2, 2, 1), + overworld_frame(gObjectEventPic_Machop, 2, 2, 2), + overworld_frame(gObjectEventPic_Machop, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Wigglytuff[] = { + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 0), + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 1), + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 2), + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 0), + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 0), + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 1), + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 1), + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 2), + overworld_frame(gObjectEventPic_Wigglytuff, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Doduo[] = { + overworld_frame(gObjectEventPic_Doduo, 2, 2, 0), + overworld_frame(gObjectEventPic_Doduo, 2, 2, 1), + overworld_frame(gObjectEventPic_Doduo, 2, 2, 2), + overworld_frame(gObjectEventPic_Doduo, 2, 2, 0), + overworld_frame(gObjectEventPic_Doduo, 2, 2, 0), + overworld_frame(gObjectEventPic_Doduo, 2, 2, 1), + overworld_frame(gObjectEventPic_Doduo, 2, 2, 1), + overworld_frame(gObjectEventPic_Doduo, 2, 2, 2), + overworld_frame(gObjectEventPic_Doduo, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Fearow[] = { + overworld_frame(gObjectEventPic_Fearow, 2, 2, 0), + overworld_frame(gObjectEventPic_Fearow, 2, 2, 1), + overworld_frame(gObjectEventPic_Fearow, 2, 2, 2), + overworld_frame(gObjectEventPic_Fearow, 2, 2, 0), + overworld_frame(gObjectEventPic_Fearow, 2, 2, 0), + overworld_frame(gObjectEventPic_Fearow, 2, 2, 1), + overworld_frame(gObjectEventPic_Fearow, 2, 2, 1), + overworld_frame(gObjectEventPic_Fearow, 2, 2, 2), + overworld_frame(gObjectEventPic_Fearow, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Lapras[] = { + overworld_frame(gObjectEventPic_Lapras, 2, 2, 0), + overworld_frame(gObjectEventPic_Lapras, 2, 2, 1), + overworld_frame(gObjectEventPic_Lapras, 2, 2, 2), + overworld_frame(gObjectEventPic_Lapras, 2, 2, 0), + overworld_frame(gObjectEventPic_Lapras, 2, 2, 0), + overworld_frame(gObjectEventPic_Lapras, 2, 2, 1), + overworld_frame(gObjectEventPic_Lapras, 2, 2, 1), + overworld_frame(gObjectEventPic_Lapras, 2, 2, 2), + overworld_frame(gObjectEventPic_Lapras, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Zapdos[] = { + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), + overworld_frame(gObjectEventPic_Zapdos, 4, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Moltres[] = { + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), + overworld_frame(gObjectEventPic_Moltres, 4, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Articuno[] = { + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), + overworld_frame(gObjectEventPic_Articuno, 4, 4, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_DeoxysD[] = { + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 1), + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 1), + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysD, 4, 4, 1), +}; + +const struct SpriteFrameImage gObjectEventPicTable_DeoxysA[] = { + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 1), + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 1), + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysA, 4, 4, 1), +}; + +const struct SpriteFrameImage gObjectEventPicTable_DeoxysN[] = { + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 1), + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 1), + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 0), + overworld_frame(gObjectEventPic_DeoxysN, 4, 4, 1), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Mewtwo[] = { + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), + overworld_frame(gObjectEventPic_Mewtwo, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Mew[] = { + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), + overworld_frame(gObjectEventPic_Mew, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Entei[] = { + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), + overworld_frame(gObjectEventPic_Entei, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Raikou[] = { + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), + overworld_frame(gObjectEventPic_Raikou, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Suicune[] = { + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), + overworld_frame(gObjectEventPic_Suicune, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Lugia[] = { + overworld_frame(gObjectEventPic_Lugia, 4, 4, 0), + overworld_frame(gObjectEventPic_Lugia, 4, 4, 0), + overworld_frame(gObjectEventPic_Lugia, 4, 4, 0), + overworld_frame(gObjectEventPic_Lugia, 4, 4, 0), + overworld_frame(gObjectEventPic_Lugia, 4, 4, 1), + overworld_frame(gObjectEventPic_Lugia, 4, 4, 0), + overworld_frame(gObjectEventPic_Lugia, 4, 4, 1), + overworld_frame(gObjectEventPic_Lugia, 4, 4, 0), + overworld_frame(gObjectEventPic_Lugia, 4, 4, 1), +}; + +const struct SpriteFrameImage gObjectEventPicTable_HoOh[] = { + overworld_frame(gObjectEventPic_HoOh, 4, 4, 0), + overworld_frame(gObjectEventPic_HoOh, 4, 4, 0), + overworld_frame(gObjectEventPic_HoOh, 4, 4, 0), + overworld_frame(gObjectEventPic_HoOh, 4, 4, 0), + overworld_frame(gObjectEventPic_HoOh, 4, 4, 1), + overworld_frame(gObjectEventPic_HoOh, 4, 4, 0), + overworld_frame(gObjectEventPic_HoOh, 4, 4, 1), + overworld_frame(gObjectEventPic_HoOh, 4, 4, 0), + overworld_frame(gObjectEventPic_HoOh, 4, 4, 1), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Celebi[] = { + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), + overworld_frame(gObjectEventPic_Celebi, 2, 2, 0), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Cubone[] = { + overworld_frame(gObjectEventPic_Cubone, 2, 2, 0), + overworld_frame(gObjectEventPic_Cubone, 2, 2, 1), + overworld_frame(gObjectEventPic_Cubone, 2, 2, 2), + overworld_frame(gObjectEventPic_Cubone, 2, 2, 0), + overworld_frame(gObjectEventPic_Cubone, 2, 2, 0), + overworld_frame(gObjectEventPic_Cubone, 2, 2, 1), + overworld_frame(gObjectEventPic_Cubone, 2, 2, 1), + overworld_frame(gObjectEventPic_Cubone, 2, 2, 2), + overworld_frame(gObjectEventPic_Cubone, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Poliwrath[] = { + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 0), + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 1), + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 2), + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 0), + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 0), + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 1), + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 1), + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 2), + overworld_frame(gObjectEventPic_Poliwrath, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Chansey[] = { + overworld_frame(gObjectEventPic_Chansey, 2, 2, 0), + overworld_frame(gObjectEventPic_Chansey, 2, 2, 1), + overworld_frame(gObjectEventPic_Chansey, 2, 2, 2), + overworld_frame(gObjectEventPic_Chansey, 2, 2, 0), + overworld_frame(gObjectEventPic_Chansey, 2, 2, 0), + overworld_frame(gObjectEventPic_Chansey, 2, 2, 1), + overworld_frame(gObjectEventPic_Chansey, 2, 2, 1), + overworld_frame(gObjectEventPic_Chansey, 2, 2, 2), + overworld_frame(gObjectEventPic_Chansey, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Pikachu[] = { + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 0), + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 1), + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 2), + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 0), + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 0), + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 1), + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 1), + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 2), + overworld_frame(gObjectEventPic_Pikachu, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Jigglypuff[] = { + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 0), + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 1), + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 2), + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 0), + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 0), + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 1), + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 1), + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 2), + overworld_frame(gObjectEventPic_Jigglypuff, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Pidgey[] = { + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 0), + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 1), + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 2), + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 0), + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 0), + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 1), + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 1), + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 2), + overworld_frame(gObjectEventPic_Pidgey, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Clefairy[] = { + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 0), + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 1), + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 2), + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 0), + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 0), + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 1), + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 1), + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 2), + overworld_frame(gObjectEventPic_Clefairy, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Machoke[] = { + overworld_frame(gObjectEventPic_Machoke, 2, 2, 0), + overworld_frame(gObjectEventPic_Machoke, 2, 2, 1), + overworld_frame(gObjectEventPic_Machoke, 2, 2, 2), + overworld_frame(gObjectEventPic_Machoke, 2, 2, 0), + overworld_frame(gObjectEventPic_Machoke, 2, 2, 0), + overworld_frame(gObjectEventPic_Machoke, 2, 2, 1), + overworld_frame(gObjectEventPic_Machoke, 2, 2, 1), + overworld_frame(gObjectEventPic_Machoke, 2, 2, 2), + overworld_frame(gObjectEventPic_Machoke, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Kabuto[] = { + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 0), + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 1), + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 2), + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 0), + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 0), + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 1), + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 1), + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 2), + overworld_frame(gObjectEventPic_Kabuto, 2, 2, 2), +}; + +const struct SpriteFrameImage gObjectEventPicTable_Mom[] = { + overworld_frame(gObjectEventPic_Mom, 2, 4, 0), + overworld_frame(gObjectEventPic_Mom, 2, 4, 1), + overworld_frame(gObjectEventPic_Mom, 2, 4, 2), + overworld_frame(gObjectEventPic_Mom, 2, 4, 0), + overworld_frame(gObjectEventPic_Mom, 2, 4, 0), + overworld_frame(gObjectEventPic_Mom, 2, 4, 1), + overworld_frame(gObjectEventPic_Mom, 2, 4, 1), + overworld_frame(gObjectEventPic_Mom, 2, 4, 2), + overworld_frame(gObjectEventPic_Mom, 2, 4, 2), +}; diff --git a/src/data/object_events/object_event_subsprites.h b/src/data/object_events/object_event_subsprites.h new file mode 100644 index 000000000..76b4f6576 --- /dev/null +++ b/src/data/object_events/object_event_subsprites.h @@ -0,0 +1,1645 @@ +const struct Subsprite gObjectEventSpriteOamTable_16x16_0[] = { + { + .x = -8, + .y = -8, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x16_1[] = { + { + .x = -8, + .y = -8, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 1 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x16_2[] = { + { + .x = -8, + .y = -8, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -8, + .y = 0, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 2, + .priority = 3 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x16_3[] = { + { + .x = -8, + .y = -8, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -8, + .y = -8, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 3 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x16_4[] = { + { + .x = -8, + .y = -8, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 1 + }, + { + .x = -8, + .y = -8, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 3 + } +}; + +const struct SubspriteTable gObjectEventSpriteOamTables_16x16[] = { + {0, NULL}, + {1, gObjectEventSpriteOamTable_16x16_0}, + {1, gObjectEventSpriteOamTable_16x16_1}, + {2, gObjectEventSpriteOamTable_16x16_2}, + {2, gObjectEventSpriteOamTable_16x16_3}, + {2, gObjectEventSpriteOamTable_16x16_4}, +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x32_0[] = { + { + .x = -8, + .y = -16, + .shape = SPRITE_SHAPE(16x32), + .size = SPRITE_SIZE(16x32), + .tileOffset = 0, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x32_1[] = { + { + .x = -8, + .y = -16, + .shape = SPRITE_SHAPE(16x32), + .size = SPRITE_SIZE(16x32), + .tileOffset = 0, + .priority = 1 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x32_2[] = { + { + .x = -8, + .y = -16, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -8, + .y = 0, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 4, + .priority = 2 + }, + { + .x = -8, + .y = 8, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 6, + .priority = 3 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x32_3[] = { + { + .x = -8, + .y = -16, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -8, + .y = 0, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 4, + .priority = 3 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_16x32_4[] = { + { + .x = -8, + .y = -16, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 0, + .priority = 1 + }, + { + .x = -8, + .y = 0, + .shape = SPRITE_SHAPE(16x16), + .size = SPRITE_SIZE(16x16), + .tileOffset = 4, + .priority = 3 + } +}; + +const struct SubspriteTable gObjectEventSpriteOamTables_16x32[] = { + {0, NULL}, + {1, gObjectEventSpriteOamTable_16x32_0}, + {1, gObjectEventSpriteOamTable_16x32_1}, + {3, gObjectEventSpriteOamTable_16x32_2}, + {2, gObjectEventSpriteOamTable_16x32_3}, + {2, gObjectEventSpriteOamTable_16x32_4}, +}; + +const struct Subsprite gObjectEventSpriteOamTable_32x32_0[] = { + { + .x = -16, + .y = -16, + .shape = SPRITE_SHAPE(32x32), + .size = SPRITE_SIZE(32x32), + .tileOffset = 0, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_32x32_1[] = { + { + .x = -16, + .y = -16, + .shape = SPRITE_SHAPE(32x32), + .size = SPRITE_SIZE(32x32), + .tileOffset = 0, + .priority = 1 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_32x32_2[] = { + { + .x = -16, + .y = -16, + .shape = SPRITE_SHAPE(32x16), + .size = SPRITE_SIZE(32x16), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -16, + .y = 0, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 8, + .priority = 2 + }, + { + .x = -16, + .y = 8, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 12, + .priority = 3 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_32x32_3[] = { + { + .x = -16, + .y = -16, + .shape = SPRITE_SHAPE(32x16), + .size = SPRITE_SIZE(32x16), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -16, + .y = 0, + .shape = SPRITE_SHAPE(32x16), + .size = SPRITE_SIZE(32x16), + .tileOffset = 8, + .priority = 3 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_32x32_4[] = { + { + .x = -16, + .y = -16, + .shape = SPRITE_SHAPE(32x16), + .size = SPRITE_SIZE(32x16), + .tileOffset = 0, + .priority = 1 + }, + { + .x = -16, + .y = 0, + .shape = SPRITE_SHAPE(32x16), + .size = SPRITE_SIZE(32x16), + .tileOffset = 8, + .priority = 3 + } +}; + +const struct SubspriteTable gObjectEventSpriteOamTables_32x32[] = { + {0, NULL}, + {1, gObjectEventSpriteOamTable_32x32_0}, + {1, gObjectEventSpriteOamTable_32x32_1}, + {3, gObjectEventSpriteOamTable_32x32_2}, + {2, gObjectEventSpriteOamTable_32x32_3}, + {2, gObjectEventSpriteOamTable_32x32_4}, +}; + +const struct Subsprite gObjectEventSpriteOamTable_48x48[] = { + { + .x = -24, + .y = -24, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 2 + }, + { + .x = 8, + .y = -24, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 4, + .priority = 2 + }, + { + .x = -24, + .y = -16, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 6, + .priority = 2 + }, + { + .x = 8, + .y = -16, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 10, + .priority = 2 + }, + { + .x = -24, + .y = -8, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 12, + .priority = 2 + }, + { + .x = 8, + .y = -8, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 16, + .priority = 2 + }, + { + .x = -24, + .y = 0, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 18, + .priority = 2 + }, + { + .x = 8, + .y = 0, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 22, + .priority = 2 + }, + { + .x = -24, + .y = 8, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 24, + .priority = 2 + }, + { + .x = 8, + .y = 8, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 28, + .priority = 2 + }, + { + .x = -24, + .y = 16, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 30, + .priority = 2 + }, + { + .x = 8, + .y = 16, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 34, + .priority = 2 + } +}; + +// Unused. Used by the moving truck in RS +const struct SubspriteTable gObjectEventSpriteOamTables_48x48[] = { + {12, gObjectEventSpriteOamTable_48x48}, + {12, gObjectEventSpriteOamTable_48x48}, + {12, gObjectEventSpriteOamTable_48x48}, + {12, gObjectEventSpriteOamTable_48x48}, + {12, gObjectEventSpriteOamTable_48x48}, + {12, gObjectEventSpriteOamTable_48x48}, +}; + +const struct Subsprite gObjectEventSpriteOamTable_64x32_0[] = { + { + .x = -32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 0, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_64x32_1[] = { + { + .x = -32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 0, + .priority = 1 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_64x32_2[] = { + { + .x = -32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 0, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_64x32_3[] = { + { + .x = -32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 0, + .priority = 2 + } +}; + +// Unused +const struct SubspriteTable gObjectEventSpriteOamTables_64x32[] = { + {0, NULL}, + {1, gObjectEventSpriteOamTable_64x32_0}, + {1, gObjectEventSpriteOamTable_64x32_1}, + {1, gObjectEventSpriteOamTable_64x32_2}, + {1, gObjectEventSpriteOamTable_64x32_3}, + {1, gObjectEventSpriteOamTable_64x32_3}, +}; + +const struct Subsprite gObjectEventSpriteOamTable_64x64_0[] = { + { + .x = -32, + .y = -32, + .shape = SPRITE_SHAPE(64x64), + .size = SPRITE_SIZE(64x64), + .tileOffset = 0, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_64x64_1[] = { + { + .x = -32, + .y = -32, + .shape = SPRITE_SHAPE(64x64), + .size = SPRITE_SIZE(64x64), + .tileOffset = 0, + .priority = 1 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_64x64_2[] = { + { + .x = -32, + .y = -32, + .shape = SPRITE_SHAPE(64x64), + .size = SPRITE_SIZE(64x64), + .tileOffset = 0, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_64x64_3[] = { + { + .x = -32, + .y = -32, + .shape = SPRITE_SHAPE(64x64), + .size = SPRITE_SIZE(64x64), + .tileOffset = 0, + .priority = 2 + } +}; + +const struct SubspriteTable gObjectEventSpriteOamTables_64x64[] = { + {0, NULL}, + {1, gObjectEventSpriteOamTable_64x64_0}, + {1, gObjectEventSpriteOamTable_64x64_1}, + {1, gObjectEventSpriteOamTable_64x64_2}, + {1, gObjectEventSpriteOamTable_64x64_3}, + {1, gObjectEventSpriteOamTable_64x64_3}, +}; + +const struct Subsprite gObjectEventSpriteOamTable_96x40_0[] = { + { + .x = -48, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 2 + }, + { + .x = 16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 8, + .priority = 2 + }, + { + .x = -48, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 12, + .priority = 2 + }, + { + .x = -16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 16, + .priority = 2 + }, + { + .x = 16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 20, + .priority = 2 + }, + { + .x = -48, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 24, + .priority = 2 + }, + { + .x = -16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 28, + .priority = 2 + }, + { + .x = 16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 32, + .priority = 2 + }, + { + .x = -48, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 36, + .priority = 2 + }, + { + .x = -16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 40, + .priority = 2 + }, + { + .x = 16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 44, + .priority = 2 + }, + { + .x = -48, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 48, + .priority = 2 + }, + { + .x = -16, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 52, + .priority = 2 + }, + { + .x = 16, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 56, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_96x40_1[] = { + { + .x = -48, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 1 + }, + { + .x = -16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 1 + }, + { + .x = 16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 8, + .priority = 1 + }, + { + .x = -48, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 12, + .priority = 1 + }, + { + .x = -16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 16, + .priority = 1 + }, + { + .x = 16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 20, + .priority = 1 + }, + { + .x = -48, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 24, + .priority = 1 + }, + { + .x = -16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 28, + .priority = 1 + }, + { + .x = 16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 32, + .priority = 1 + }, + { + .x = -48, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 36, + .priority = 1 + }, + { + .x = -16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 40, + .priority = 1 + }, + { + .x = 16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 44, + .priority = 1 + }, + { + .x = -48, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 48, + .priority = 1 + }, + { + .x = -16, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 52, + .priority = 1 + }, + { + .x = 16, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 56, + .priority = 1 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_96x40_2[] = { + { + .x = -48, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 2 + }, + { + .x = 16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 8, + .priority = 2 + }, + { + .x = -48, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 12, + .priority = 2 + }, + { + .x = -16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 16, + .priority = 2 + }, + { + .x = 16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 20, + .priority = 2 + }, + { + .x = -48, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 24, + .priority = 2 + }, + { + .x = -16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 28, + .priority = 2 + }, + { + .x = 16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 32, + .priority = 2 + }, + { + .x = -48, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 36, + .priority = 2 + }, + { + .x = -16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 40, + .priority = 2 + }, + { + .x = 16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 44, + .priority = 2 + }, + { + .x = -48, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 48, + .priority = 2 + }, + { + .x = -16, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 52, + .priority = 2 + }, + { + .x = 16, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 56, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_96x40_3[] = { + { + .x = -48, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 1 + }, + { + .x = -16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 1 + }, + { + .x = 16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 8, + .priority = 1 + }, + { + .x = -48, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 12, + .priority = 1 + }, + { + .x = -16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 16, + .priority = 1 + }, + { + .x = 16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 20, + .priority = 1 + }, + { + .x = -48, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 24, + .priority = 2 + }, + { + .x = -16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 28, + .priority = 2 + }, + { + .x = 16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 32, + .priority = 2 + }, + { + .x = -48, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 36, + .priority = 2 + }, + { + .x = -16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 40, + .priority = 2 + }, + { + .x = 16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 44, + .priority = 2 + }, + { + .x = -48, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 48, + .priority = 2 + }, + { + .x = -16, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 52, + .priority = 2 + }, + { + .x = 16, + .y = 12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 56, + .priority = 2 + } +}; + +// Unused. Used by the SS Tidal in RS +const struct SubspriteTable gObjectEventSpriteOamTables_96x40[] = { + {15, gObjectEventSpriteOamTable_96x40_0}, + {15, gObjectEventSpriteOamTable_96x40_0}, + {15, gObjectEventSpriteOamTable_96x40_1}, + {15, gObjectEventSpriteOamTable_96x40_2}, + {15, gObjectEventSpriteOamTable_96x40_3}, + {15, gObjectEventSpriteOamTable_96x40_3}, +}; + +const struct Subsprite gObjectEventSpriteOamTable_128x64_0[] = { + { + .x = -32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 0, + .priority = 2 + }, + { + .x = 32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 32, + .priority = 2 + }, + { + .x = -32, + .y = 16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 64, + .priority = 2 + }, + { + .x = 32, + .y = 16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 96, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_128x64_1[] = { + { + .x = -32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 0, + .priority = 1 + }, + { + .x = 32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 32, + .priority = 1 + }, + { + .x = -32, + .y = 16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 64, + .priority = 1 + }, + { + .x = 32, + .y = 16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 96, + .priority = 1 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_128x64_2[] = { + { + .x = -32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 0, + .priority = 1 + }, + { + .x = 32, + .y = -16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 32, + .priority = 1 + }, + { + .x = -32, + .y = 16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 64, + .priority = 2 + }, + { + .x = 32, + .y = 16, + .shape = SPRITE_SHAPE(64x32), + .size = SPRITE_SIZE(64x32), + .tileOffset = 96, + .priority = 2 + } +}; + +const struct SubspriteTable gObjectEventSpriteOamTables_128x64[] = { + {4, gObjectEventSpriteOamTable_128x64_0}, + {4, gObjectEventSpriteOamTable_128x64_0}, + {4, gObjectEventSpriteOamTable_128x64_1}, + {4, gObjectEventSpriteOamTable_128x64_2}, + {4, gObjectEventSpriteOamTable_128x64_2}, + {4, gObjectEventSpriteOamTable_128x64_2}, +}; + +const struct Subsprite gObjectEventSpriteOamTable_88x32_0[] = { + { + .x = -48, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 2 + }, + { + .x = 16, + .y = -20, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 8, + .priority = 2 + }, + { + .x = 32, + .y = -20, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 10, + .priority = 2 + }, + { + .x = -48, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 11, + .priority = 2 + }, + { + .x = -16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 15, + .priority = 2 + }, + { + .x = 16, + .y = -12, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 19, + .priority = 2 + }, + { + .x = 32, + .y = -12, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 21, + .priority = 2 + }, + { + .x = -48, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 22, + .priority = 2 + }, + { + .x = -16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 26, + .priority = 2 + }, + { + .x = 16, + .y = -4, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 30, + .priority = 2 + }, + { + .x = 32, + .y = -4, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 32, + .priority = 2 + }, + { + .x = -48, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 33, + .priority = 2 + }, + { + .x = -16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 37, + .priority = 2 + }, + { + .x = 16, + .y = 4, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 41, + .priority = 2 + }, + { + .x = 32, + .y = 4, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 43, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_88x32_1[] = { + { + .x = -48, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 1 + }, + { + .x = -16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 1 + }, + { + .x = 16, + .y = -20, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 8, + .priority = 1 + }, + { + .x = 32, + .y = -20, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 10, + .priority = 1 + }, + { + .x = -48, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 11, + .priority = 1 + }, + { + .x = -16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 15, + .priority = 1 + }, + { + .x = 16, + .y = -12, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 19, + .priority = 1 + }, + { + .x = 32, + .y = -12, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 21, + .priority = 1 + }, + { + .x = -48, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 22, + .priority = 1 + }, + { + .x = -16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 26, + .priority = 1 + }, + { + .x = 16, + .y = -4, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 30, + .priority = 1 + }, + { + .x = 32, + .y = -4, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 32, + .priority = 1 + }, + { + .x = -48, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 33, + .priority = 1 + }, + { + .x = -16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 37, + .priority = 1 + }, + { + .x = 16, + .y = 4, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 41, + .priority = 1 + }, + { + .x = 32, + .y = 4, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 43, + .priority = 1 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_88x32_2[] = { + { + .x = -48, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 2 + }, + { + .x = -16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 2 + }, + { + .x = 16, + .y = -20, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 8, + .priority = 2 + }, + { + .x = 32, + .y = -20, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 10, + .priority = 2 + }, + { + .x = -48, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 11, + .priority = 2 + }, + { + .x = -16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 15, + .priority = 2 + }, + { + .x = 16, + .y = -12, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 19, + .priority = 2 + }, + { + .x = 32, + .y = -12, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 21, + .priority = 2 + }, + { + .x = -48, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 22, + .priority = 2 + }, + { + .x = -16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 26, + .priority = 2 + }, + { + .x = 16, + .y = -4, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 30, + .priority = 2 + }, + { + .x = 32, + .y = -4, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 32, + .priority = 2 + }, + { + .x = -48, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 33, + .priority = 2 + }, + { + .x = -16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 37, + .priority = 2 + }, + { + .x = 16, + .y = 4, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 41, + .priority = 2 + }, + { + .x = 32, + .y = 4, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 43, + .priority = 2 + } +}; + +const struct Subsprite gObjectEventSpriteOamTable_88x32_3[] = { + { + .x = -48, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 1 + }, + { + .x = -16, + .y = -20, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 1 + }, + { + .x = 16, + .y = -20, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 8, + .priority = 1 + }, + { + .x = 32, + .y = -20, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 10, + .priority = 1 + }, + { + .x = -48, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 11, + .priority = 1 + }, + { + .x = -16, + .y = -12, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 15, + .priority = 1 + }, + { + .x = 16, + .y = -12, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 19, + .priority = 1 + }, + { + .x = 32, + .y = -12, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 21, + .priority = 1 + }, + { + .x = -48, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 22, + .priority = 2 + }, + { + .x = -16, + .y = -4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 26, + .priority = 2 + }, + { + .x = 16, + .y = -4, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 30, + .priority = 2 + }, + { + .x = 32, + .y = -4, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 32, + .priority = 2 + }, + { + .x = -48, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 33, + .priority = 2 + }, + { + .x = -16, + .y = 4, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 37, + .priority = 2 + }, + { + .x = 16, + .y = 4, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 41, + .priority = 2 + }, + { + .x = 32, + .y = 4, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 43, + .priority = 2 + } +}; + +// Unused. Used by the submarine shadow in RS +const struct SubspriteTable gObjectEventSpriteOamTables_88x32[] = { + {16, gObjectEventSpriteOamTable_88x32_0}, + {16, gObjectEventSpriteOamTable_88x32_0}, + {16, gObjectEventSpriteOamTable_88x32_1}, + {16, gObjectEventSpriteOamTable_88x32_2}, + {16, gObjectEventSpriteOamTable_88x32_3}, + {16, gObjectEventSpriteOamTable_88x32_3}, +}; diff --git a/src/daycare.c b/src/daycare.c index e07c2a234..1e50a7c09 100644 --- a/src/daycare.c +++ b/src/daycare.c @@ -1766,7 +1766,7 @@ static void Task_EggHatch(u8 taskID) { CleanupOverworldWindowsAndTilemaps(); SetMainCallback2(CB2_EggHatch_0); - gFieldCallback = FieldCallback_ReturnToEventScript2; + gFieldCallback = FieldCB_ContinueScriptHandleMusic; DestroyTask(taskID); } } diff --git a/src/decoration.c b/src/decoration.c new file mode 100644 index 000000000..4903735f0 --- /dev/null +++ b/src/decoration.c @@ -0,0 +1,7 @@ +#include "global.h" +#include "decoration.h" +#include "constants/decorations.h" + +#include "data/decoration/tiles.h" +#include "data/decoration/description.h" +#include "data/decoration/header.h" diff --git a/src/diploma.c b/src/diploma.c index f702eebd5..5c653d071 100644 --- a/src/diploma.c +++ b/src/diploma.c @@ -193,7 +193,7 @@ static void Task_DiplomaReturnToOverworld(u8 taskId) DestroyTask(taskId); FreeAllWindowBuffers(); FREE_AND_SET_NULL(gDiploma); - SetMainCallback2(CB2_Overworld); + SetMainCallback2(sub_80568FC); } static void DiplomaBgInit(void) diff --git a/src/dynamic_placeholder_text_util.c b/src/dynamic_placeholder_text_util.c index 921612cfc..174a1c5d5 100644 --- a/src/dynamic_placeholder_text_util.c +++ b/src/dynamic_placeholder_text_util.c @@ -10,11 +10,11 @@ static const u8 sTextColorTable[] = // [LOW_NYBBLE / 2] = 0xXY, // HIGH_NYBBLE [OBJ_EVENT_GFX_RED_NORMAL / 2] = 0x00, // OBJ_EVENT_GFX_RED_BIKE [OBJ_EVENT_GFX_RED_SURF / 2] = 0x00, // OBJ_EVENT_GFX_RED_ITEM - [OBJ_EVENT_GFX_RED_FISH / 2] = 0x00, // OBJ_EVENT_GFX_RED_ITEM_COPY - [OBJ_EVENT_GFX_RED_VS_SEEKER / 2] = 0x10, // OBJ_EVENT_GFX_GREEN_NORMAL + [OBJ_EVENT_GFX_RED_FISH / 2] = 0x00, // OBJ_EVENT_GFX_RED_VS_SEEKER + [OBJ_EVENT_GFX_RED_VS_SEEKER_BIKE / 2] = 0x10, // OBJ_EVENT_GFX_GREEN_NORMAL [OBJ_EVENT_GFX_GREEN_BIKE / 2] = 0x11, // OBJ_EVENT_GFX_GREEN_SURF [OBJ_EVENT_GFX_GREEN_ITEM / 2] = 0x11, // OBJ_EVENT_GFX_GREEN_FISH - [OBJ_EVENT_GFX_GREEN_ITEM_COPY / 2] = 0x11, // OBJ_EVENT_GFX_GREEN_VS_SEEKER + [OBJ_EVENT_GFX_GREEN_VS_SEEKER / 2] = 0x11, // OBJ_EVENT_GFX_GREEN_VS_SEEKER_BIKE [OBJ_EVENT_GFX_RS_BRENDAN / 2] = 0x10, // OBJ_EVENT_GFX_RS_MAY [OBJ_EVENT_GFX_LITTLE_BOY / 2] = 0x10, // OBJ_EVENT_GFX_LITTLE_GIRL [OBJ_EVENT_GFX_YOUNGSTER / 2] = 0x00, // OBJ_EVENT_GFX_BOY @@ -26,8 +26,8 @@ static const u8 sTextColorTable[] = [OBJ_EVENT_GFX_BALDING_MAN / 2] = 0x10, // OBJ_EVENT_GFX_WOMAN_3 [OBJ_EVENT_GFX_OLD_MAN_1 / 2] = 0x00, // OBJ_EVENT_GFX_OLD_MAN_2 [OBJ_EVENT_GFX_OLD_MAN_LYING_DOWN / 2] = 0x10, // OBJ_EVENT_GFX_OLD_WOMAN - [OBJ_EVENT_GFX_TUBER_M_1 / 2] = 0x10, // OBJ_EVENT_GFX_TUBER_F - [OBJ_EVENT_GFX_TUBER_M_2 / 2] = 0x00, // OBJ_EVENT_GFX_CAMPER + [OBJ_EVENT_GFX_TUBER_M_WATER / 2] = 0x10, // OBJ_EVENT_GFX_TUBER_F + [OBJ_EVENT_GFX_TUBER_M_LAND / 2] = 0x00, // OBJ_EVENT_GFX_CAMPER [OBJ_EVENT_GFX_PICNICKER / 2] = 0x01, // OBJ_EVENT_GFX_COOLTRAINER_M [OBJ_EVENT_GFX_COOLTRAINER_F / 2] = 0x01, // OBJ_EVENT_GFX_SWIMMER_M_WATER [OBJ_EVENT_GFX_SWIMMER_F_WATER / 2] = 0x01, // OBJ_EVENT_GFX_SWIMMER_M_LAND @@ -56,7 +56,7 @@ static const u8 sTextColorTable[] = [OBJ_EVENT_GFX_TEACHY_TV_HOST / 2] = 0x00, // OBJ_EVENT_GFX_GYM_GUY [OBJ_EVENT_GFX_ITEM_BALL / 2] = 0x33, // OBJ_EVENT_GFX_TOWN_MAP [OBJ_EVENT_GFX_POKEDEX / 2] = 0x33, // OBJ_EVENT_GFX_CUT_TREE - [OBJ_EVENT_GFX_ROCK_SMASH_ROCK / 2] = 0x33, // OBJ_EVENT_GFX_STRENGTH_BOULDER + [OBJ_EVENT_GFX_ROCK_SMASH_ROCK / 2] = 0x33, // OBJ_EVENT_GFX_PUSHABLE_BOULDER [OBJ_EVENT_GFX_FOSSIL / 2] = 0x33, // OBJ_EVENT_GFX_RUBY [OBJ_EVENT_GFX_SAPPHIRE / 2] = 0x33, // OBJ_EVENT_GFX_OLD_AMBER [OBJ_EVENT_GFX_GYM_SIGN / 2] = 0x33, // OBJ_EVENT_GFX_SIGN diff --git a/src/easy_chat_2.c b/src/easy_chat_2.c index 4b3c70b67..948b7c39f 100644 --- a/src/easy_chat_2.c +++ b/src/easy_chat_2.c @@ -279,7 +279,7 @@ void ShowEasyChatScreen(void) default: return; } - DoEasyChatScreen(gSpecialVar_0x8004, words, sub_80568C4); + DoEasyChatScreen(gSpecialVar_0x8004, words, CB2_ReturnToFieldContinueScript); } static const u16 sECPhrase_MysteryEventIsExciting[] = { diff --git a/src/event_data.c b/src/event_data.c index a162e8701..c012a4a59 100644 --- a/src/event_data.c +++ b/src/event_data.c @@ -38,13 +38,13 @@ void InitEventData(void) memset(sSpecialFlags, 0, SPECIAL_FLAGS_COUNT); } -void sub_806E110(void) +void ClearTempFieldEventData(void) { memset(gSaveBlock1Ptr->flags, 0, 4); memset(gSaveBlock1Ptr->vars, 0, 16 * 2); FlagClear(FLAG_SYS_WHITE_FLUTE_ACTIVE); FlagClear(FLAG_SYS_BLACK_FLUTE_ACTIVE); - FlagClear(FLAG_SYS_STRENGTH_ACTIVE); + FlagClear(FLAG_SYS_USE_STRENGTH); FlagClear(FLAG_SYS_SPECIAL_WILD_BATTLE); FlagClear(FLAG_SYS_INFORMED_OF_LOCAL_WIRELESS_PLAYER); } diff --git a/src/event_object_lock.c b/src/event_object_lock.c index a72845ac7..aa9a99895 100644 --- a/src/event_object_lock.c +++ b/src/event_object_lock.c @@ -28,7 +28,7 @@ bool8 sub_8069590(void) return FALSE; else { - sub_805C780(); + StopPlayerAvatar(); return TRUE; } } @@ -65,7 +65,7 @@ bool8 sub_8069648(void) return FALSE; else { - sub_805C780(); + StopPlayerAvatar(); return TRUE; } } diff --git a/src/event_object_movement.c b/src/event_object_movement.c index a399ddf5e..5361d05dc 100644 --- a/src/event_object_movement.c +++ b/src/event_object_movement.c @@ -78,10 +78,10 @@ static void sub_805EFF4(struct ObjectEvent *); static u8 sub_805F510(const struct SpritePalette *); static u8 FindObjectEventPaletteIndexByTag(u16); static bool8 ObjectEventDoesZCoordMatch(struct ObjectEvent *, u8); -/*static*/ void ObjectCB_CameraObject(struct Sprite *); -/*static*/ void CameraObject_0(struct Sprite *); -/*static*/ void CameraObject_1(struct Sprite *); -/*static*/ void CameraObject_2(struct Sprite *); +static void ObjectCB_CameraObject(struct Sprite *); +static void CameraObject_0(struct Sprite *); +static void CameraObject_1(struct Sprite *); +static void CameraObject_2(struct Sprite *); static struct ObjectEventTemplate *FindObjectEventTemplateByLocalId(u8 localId, struct ObjectEventTemplate *templates, u8 count); static void ClearObjectEventMovement(struct ObjectEvent *, struct Sprite *); static void ObjectEventSetSingleMovement(struct ObjectEvent *, struct Sprite *, u8); @@ -95,102 +95,63 @@ static u8 sub_8063304(struct ObjectEvent *, struct Sprite *); static u8 sub_8063324(struct ObjectEvent *, struct Sprite *); static u8 sub_8063344(struct ObjectEvent *, struct Sprite *); static void sub_8064544(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x9B_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x9C_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x9D_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x9E_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x08_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x09_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x0A_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x0B_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x0D_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x0C_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x0E_1(struct ObjectEvent *, struct Sprite *); -u8 MovementActionFunc_x0F_1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkNormalDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkNormalUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkNormalLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkNormalRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_Jump2Down_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_Jump2Up_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_Jump2Left_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_Jump2Right_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkFastDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkFastUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkFastLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkFastRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_xA0_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_xA1_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_xA2_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_xA3_1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_RideWaterCurrentDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_RideWaterCurrentUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_RideWaterCurrentLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_RideWaterCurrentRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkFastestDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkFastestUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkFastestLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkFastestRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_SlideDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_SlideUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_SlideLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_SlideRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_PlayerRunDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_PlayerRunUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_PlayerRunLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_PlayerRunRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_x41_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_x42_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_x43_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_x44_1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpSpecialDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpSpecialUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpSpecialLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_xA6_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_xA7_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_xA8_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_xA9_1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpInPlaceDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpInPlaceUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpInPlaceLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpInPlaceRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpInPlaceDownUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpInPlaceUpDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpInPlaceLeftRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_JumpInPlaceRightLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_RevealTrainer_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkDownStartAffine_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_WalkDownAffine_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieHopFaceDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieHopFaceUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieHopFaceRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieHopDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieHopUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieHopLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieHopRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieJumpDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieJumpUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieJumpLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieJumpRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroPopWheelieMoveDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroPopWheelieMoveUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroPopWheelieMoveRight_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieMoveDown_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieMoveUp_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieMoveLeft_Step1(struct ObjectEvent *, struct Sprite *); -u8 MovementAction_AcroWheelieMoveRight_Step1(struct ObjectEvent *, struct Sprite *);; -bool8 MovementActionFunc_x94_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_x95_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_x96_1(struct ObjectEvent *, struct Sprite *); -bool8 MovementActionFunc_x97_1(struct ObjectEvent *, struct Sprite *); static void DoObjectUnionRoomWarpYDisplacement(struct Sprite * sprite); +static void MovementType_None(struct Sprite *); +static void MovementType_LookAround(struct Sprite *); +static void MovementType_WanderAround(struct Sprite *); +static void MovementType_WanderUpAndDown(struct Sprite *); +static void MovementType_WanderLeftAndRight(struct Sprite *); +static void MovementType_FaceDirection(struct Sprite *); +static void MovementType_FaceDownAndUp(struct Sprite *); +static void MovementType_FaceLeftAndRight(struct Sprite *); +static void MovementType_FaceUpAndLeft(struct Sprite *); +static void MovementType_FaceUpAndRight(struct Sprite *); +static void MovementType_FaceDownAndLeft(struct Sprite *); +static void MovementType_FaceDownAndRight(struct Sprite *); +static void MovementType_FaceDownUpAndLeft(struct Sprite *); +static void MovementType_FaceDownUpAndRight(struct Sprite *); +static void MovementType_FaceUpRightAndLeft(struct Sprite *); +static void MovementType_FaceDownRightAndLeft(struct Sprite *); +static void MovementType_RotateCounterclockwise(struct Sprite *); +static void MovementType_RotateClockwise(struct Sprite *); +static void MovementType_WalkBackAndForth(struct Sprite *); +static void MovementType_WalkSequenceUpRightLeftDown(struct Sprite *); +static void MovementType_WalkSequenceRightLeftDownUp(struct Sprite *); +static void MovementType_WalkSequenceDownUpRightLeft(struct Sprite *); +static void MovementType_WalkSequenceLeftDownUpRight(struct Sprite *); +static void MovementType_WalkSequenceUpLeftRightDown(struct Sprite *); +static void MovementType_WalkSequenceLeftRightDownUp(struct Sprite *); +static void MovementType_WalkSequenceDownUpLeftRight(struct Sprite *); +static void MovementType_WalkSequenceRightDownUpLeft(struct Sprite *); +static void MovementType_WalkSequenceLeftUpDownRight(struct Sprite *); +static void MovementType_WalkSequenceUpDownRightLeft(struct Sprite *); +static void MovementType_WalkSequenceRightLeftUpDown(struct Sprite *); +static void MovementType_WalkSequenceDownRightLeftUp(struct Sprite *); +static void MovementType_WalkSequenceRightUpDownLeft(struct Sprite *); +static void MovementType_WalkSequenceUpDownLeftRight(struct Sprite *); +static void MovementType_WalkSequenceLeftRightUpDown(struct Sprite *); +static void MovementType_WalkSequenceDownLeftRightUp(struct Sprite *); +static void MovementType_WalkSequenceUpLeftDownRight(struct Sprite *); +static void MovementType_WalkSequenceDownRightUpLeft(struct Sprite *); +static void MovementType_WalkSequenceLeftDownRightUp(struct Sprite *); +static void MovementType_WalkSequenceRightUpLeftDown(struct Sprite *); +static void MovementType_WalkSequenceUpRightDownLeft(struct Sprite *); +static void MovementType_WalkSequenceDownLeftUpRight(struct Sprite *); +static void MovementType_WalkSequenceLeftUpRightDown(struct Sprite *); +static void MovementType_WalkSequenceRightDownLeftUp(struct Sprite *); +static void MovementType_CopyPlayer(struct Sprite *); +static void MovementType_TreeDisguise(struct Sprite *); +static void MovementType_MountainDisguise(struct Sprite *); +static void MovementType_CopyPlayerInGrass(struct Sprite *); +static void MovementType_Hidden(struct Sprite *); +static void MovementType_WalkInPlace(struct Sprite *); +static void MovementType_WalkSlowlyInPlace(struct Sprite *); +static void MovementType_JogInPlace(struct Sprite *); +static void MovementType_Invisible(struct Sprite *); +static void sub_8063298(struct Sprite *); +static void sub_80632BC(struct Sprite *); +static void sub_80632E0(struct Sprite *); +static void MovementType_WanderAroundDuplicate(struct Sprite *); #define movement_type_def(setup, table) \ static u8 setup##_callback(struct ObjectEvent *, struct Sprite *); \ @@ -217,175 +178,1045 @@ static u8 setup##_callback(struct ObjectEvent *objectEvent, struct Sprite *sprit EWRAM_DATA u8 sCurrentReflectionType = 0; EWRAM_DATA u16 sCurrentSpecialObjectPaletteTag = 0; -extern const u8 gRangedMovementTypes[NUM_FIELD_MAP_OBJECT_TEMPLATES]; -extern const u8 gInitialMovementTypeFacingDirections[NUM_FIELD_MAP_OBJECT_TEMPLATES]; -extern void (*const sMovementTypeCallbacks[])(struct Sprite *); -extern const struct ObjectEventGraphicsInfo *const gObjectEventGraphicsInfoPointers[NUM_OBJ_EVENT_GFX]; -extern const struct SpritePalette sObjectEventSpritePalettes[]; -extern const struct PairedPalettes gPlayerReflectionPaletteSets[]; -extern const u8 gReflectionEffectPaletteMap[]; -extern const struct PairedPalettes gSpecialObjectReflectionPaletteSets[]; -extern const struct SpriteTemplate gCameraSpriteTemplate; -extern void (*const gCameraObjectFuncs[3])(struct Sprite *); -extern const u16 *const gObjectPaletteTagSets[]; - -extern u8 (*const gMovementTypeFuncs_WanderAround[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_WanderAroundDuplicate[])(struct ObjectEvent *, struct Sprite *); -extern const s16 gMovementDelaysMedium[]; -extern const u8 gStandardDirections[4]; -extern u8 (*const gGetVectorDirectionFuncs[])(s16, s16, s16, s16); -extern u8 (*const gMovementTypeFuncs_LookAround[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_WanderUpAndDown[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpAndDownDirections[2]; -extern u8 (*const gMovementTypeFuncs_WanderLeftAndRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gLeftAndRightDirections[2]; -extern u8 (*const gMovementTypeFuncs_FaceDirection[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_FaceDownAndUp[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_FaceLeftAndRight[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_FaceUpAndLeft[])(struct ObjectEvent *, struct Sprite *); -extern const s16 gMovementDelaysShort[]; -extern const u8 gUpAndLeftDirections[2]; -extern u8 (*const gMovementTypeFuncs_FaceUpAndRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpAndRightDirections[2]; -extern u8 (*const gMovementTypeFuncs_FaceDownAndLeft[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownAndLeftDirections[2]; -extern u8 (*const gMovementTypeFuncs_FaceDownAndRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownAndRightDirections[2]; -extern u8 (*const gMovementTypeFuncs_FaceDownUpAndLeft[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownUpAndLeftDirections[4]; -extern u8 (*const gMovementTypeFuncs_FaceDownUpAndRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownUpAndRightDirections[4]; -extern u8 (*const gMovementTypeFuncs_FaceUpLeftAndRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpLeftAndRightDirections[4]; -extern u8 (*const gMovementTypeFuncs_FaceDownLeftAndRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownLeftAndRightDirections[4]; -extern u8 (*const gMovementTypeFuncs_RotateCounterclockwise[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gCounterclockwiseDirections[5]; -extern u8 (*const gMovementTypeFuncs_RotateClockwise[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gClockwiseDirections[5]; -extern u8 (*const gMovementTypeFuncs_WalkBackAndForth[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_WalkSequenceUpRightLeftDown[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpRightLeftDownDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceRightLeftDownUp[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gRightLeftDownUpDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceDownUpRightLeft[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownUpRightLeftDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceLeftDownUpRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gLeftDownUpRightDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceUpLeftRightDown[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpLeftRightDownDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceLeftRightDownUp[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gLeftRightDownUpDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceDownUpLeftRight[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_WalkSequenceRightDownUpLeft[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gRightDownUpLeftDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceLeftUpDownRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gLeftUpDownRightDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceUpDownRightLeft[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpDownRightLeftDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceRightLeftUpDown[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gRightLeftUpDownDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceDownRightLeftUp[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownRightLeftUpDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceRightUpDownLeft[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gRightUpDownLeftDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceUpDownLeftRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpDownLeftRightDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceLeftRightUpDown[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gLeftRightUpDownDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceDownLeftRightUp[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownLeftRightUpDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceUpLeftDownRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpLeftDownRightDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceDownRightUpLeft[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownRightUpLeftDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceLeftDownRightUp[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gLeftDownRightUpDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceRightUpLeftDown[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gRightUpLeftDownDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceUpRightDownLeft[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gUpRightDownLeftDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceDownLeftUpRight[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gDownLeftUpRightDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceLeftUpRightDown[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gLeftUpRightDownDirections[4]; -extern u8 (*const gMovementTypeFuncs_WalkSequenceRightDownLeftUp[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gRightDownLeftUpDirections[4]; -extern u8 (*const gMovementTypeFuncs_CopyPlayer[])(struct ObjectEvent *, struct Sprite *); -extern bool8 (*const gCopyPlayerMovementFuncs[])(struct ObjectEvent *, struct Sprite *, u8, bool8(u8)); -extern u8 (*const gMovementTypeFuncs_CopyPlayerInGrass[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_Hidden[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_WalkInPlace[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_WalkSlowlyInPlace[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_JogInPlace[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gMovementTypeFuncs_Invisible[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gUnknown_83A63F0[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gUnknown_83A63FC[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gUnknown_83A6404[])(struct ObjectEvent *, struct Sprite *); -extern const u8 gFaceDirectionAnimNums[]; -extern const u8 gMoveDirectionAnimNums[]; -extern const u8 gMoveDirectionFastAnimNums[]; -extern const u8 gMoveDirectionFasterAnimNums[]; -extern const u8 gMoveDirectionFastestAnimNums[]; -extern const u8 gJumpSpecialDirectionAnimNums[]; -extern const u8 gAcroWheelieDirectionAnimNums[]; -extern const u8 gUnrefAnimNums_080634A0[]; -extern const u8 gAcroEndWheelieDirectionAnimNums[]; -extern const u8 gAcroUnusedActionDirectionAnimNums[]; -extern const u8 gAcroWheeliePedalDirectionAnimNums[]; -extern const u8 gFishingDirectionAnimNums[]; -extern const u8 gFishingNoCatchDirectionAnimNums[]; -extern const u8 gFishingBiteDirectionAnimNums[]; -extern const u8 gUnknown_83A648A[]; -extern const u8 gRunningDirectionAnimNums[]; -extern const struct UnkStruct_083A3698 gUnknown_83A3698[]; -extern const u8 gTrainerFacingDirectionMovementTypes[]; -extern bool8 (*const gOppositeDirectionBlockedMetatileFuncs[])(u8); -extern bool8 (*const gDirectionBlockedMetatileFuncs[])(u8); -extern const struct Coords16 sDirectionToVectors[]; -extern const u8 gFaceDirectionMovementActions[5]; -extern const u8 gWalkSlowMovementActions[5]; -extern const u8 gUnknown_83A64F6[]; -extern const u8 gUnknown_83A64FB[5]; -extern const u8 gUnknown_83A6500[5]; -extern const u8 gUnknown_83A6505[5]; -extern const u8 gUnknown_83A650A[5]; -extern const u8 gUnknown_83A650F[5]; -extern const u8 gUnknown_83A6514[5]; -extern const u8 gUnknown_83A6519[5]; -extern const u8 gUnknown_83A651E[5]; -extern const u8 gUnknown_83A6523[5]; -extern const u8 gUnknown_83A6528[5]; -extern const u8 gUnknown_83A652D[5]; -extern const u8 gUnknown_83A6532[5]; -extern const u8 gUnknown_83A6537[5]; -extern const u8 gUnknown_83A653C[5]; -extern const u8 gUnknown_83A6541[5]; -extern const u8 gUnknown_83A6546[5]; -extern const u8 gUnknown_83A654B[5]; -extern const u8 gUnknown_83A6550[5]; -extern const u8 gUnknown_83A6555[5]; -extern const u8 gUnknown_83A655A[5]; -extern const u8 gUnknown_83A655F[5]; -extern const u8 gUnknown_83A6564[5]; -extern const u8 gUnknown_83A6569[5]; -extern const u8 gUnknown_83A656E[5]; -extern const u8 gUnknown_83A6573[5]; -extern const u8 gUnknown_83A6578[5]; -extern const u8 gUnknown_83A657D[5]; -extern const u8 gUnknown_83A6582[5]; -extern const u8 gUnknown_83A6587[5]; -extern const u8 gUnknown_83A658C[5]; -extern const u8 gOppositeDirections[8]; -extern const u8 gUnknown_83A6599[][4]; -extern const u8 gUnknown_83A65A9[][4]; -extern u8 (*const *const gMovementActionFuncs[])(struct ObjectEvent *, struct Sprite *); -extern u8 (*const gUnknown_83A6884[5])(u8); -extern const s16 gUnknown_83A6958[3]; -extern const s16 gUnknown_83A695E[3]; +const u8 gReflectionEffectPaletteMap[] = {1, 1, 6, 7, 8, 9, 6, 7, 8, 9, 11, 11, 0, 0, 0, 0}; +const struct SpriteTemplate gCameraSpriteTemplate = { + .tileTag = 0, + .paletteTag = 0xFFFF, + .oam = &gDummyOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = ObjectCB_CameraObject +}; + +void (*const gCameraObjectFuncs[])(struct Sprite *) = { + CameraObject_0, + CameraObject_1, + CameraObject_2, +}; + +#include "data/object_events/object_event_graphics.h" + +static void (*const sMovementTypeCallbacks[])(struct Sprite *) = { + MovementType_None, + MovementType_LookAround, + MovementType_WanderAround, + MovementType_WanderUpAndDown, + MovementType_WanderUpAndDown, + MovementType_WanderLeftAndRight, + MovementType_WanderLeftAndRight, + MovementType_FaceDirection, + MovementType_FaceDirection, + MovementType_FaceDirection, + MovementType_FaceDirection, + MovementType_Player, + NULL, + MovementType_FaceDownAndUp, + MovementType_FaceLeftAndRight, + MovementType_FaceUpAndLeft, + MovementType_FaceUpAndRight, + MovementType_FaceDownAndLeft, + MovementType_FaceDownAndRight, + MovementType_FaceDownUpAndLeft, + MovementType_FaceDownUpAndRight, + MovementType_FaceUpRightAndLeft, + MovementType_FaceDownRightAndLeft, + MovementType_RotateCounterclockwise, + MovementType_RotateClockwise, + MovementType_WalkBackAndForth, + MovementType_WalkBackAndForth, + MovementType_WalkBackAndForth, + MovementType_WalkBackAndForth, + MovementType_WalkSequenceUpRightLeftDown, + MovementType_WalkSequenceRightLeftDownUp, + MovementType_WalkSequenceDownUpRightLeft, + MovementType_WalkSequenceLeftDownUpRight, + MovementType_WalkSequenceUpLeftRightDown, + MovementType_WalkSequenceLeftRightDownUp, + MovementType_WalkSequenceDownUpLeftRight, + MovementType_WalkSequenceRightDownUpLeft, + MovementType_WalkSequenceLeftUpDownRight, + MovementType_WalkSequenceUpDownRightLeft, + MovementType_WalkSequenceRightLeftUpDown, + MovementType_WalkSequenceDownRightLeftUp, + MovementType_WalkSequenceRightUpDownLeft, + MovementType_WalkSequenceUpDownLeftRight, + MovementType_WalkSequenceLeftRightUpDown, + MovementType_WalkSequenceDownLeftRightUp, + MovementType_WalkSequenceUpLeftDownRight, + MovementType_WalkSequenceDownRightUpLeft, + MovementType_WalkSequenceLeftDownRightUp, + MovementType_WalkSequenceRightUpLeftDown, + MovementType_WalkSequenceUpRightDownLeft, + MovementType_WalkSequenceDownLeftUpRight, + MovementType_WalkSequenceLeftUpRightDown, + MovementType_WalkSequenceRightDownLeftUp, + MovementType_CopyPlayer, + MovementType_CopyPlayer, + MovementType_CopyPlayer, + MovementType_CopyPlayer, + MovementType_TreeDisguise, + MovementType_MountainDisguise, + MovementType_CopyPlayerInGrass, + MovementType_CopyPlayerInGrass, + MovementType_CopyPlayerInGrass, + MovementType_CopyPlayerInGrass, + MovementType_Hidden, + MovementType_WalkInPlace, + MovementType_WalkInPlace, + MovementType_WalkInPlace, + MovementType_WalkInPlace, + MovementType_WalkSlowlyInPlace, + MovementType_WalkSlowlyInPlace, + MovementType_WalkSlowlyInPlace, + MovementType_WalkSlowlyInPlace, + MovementType_JogInPlace, + MovementType_JogInPlace, + MovementType_JogInPlace, + MovementType_JogInPlace, + MovementType_Invisible, + sub_8063298, + sub_80632BC, + sub_80632E0, + MovementType_WanderAroundDuplicate, +}; + +const bool8 gRangedMovementTypes[NUM_FIELD_MAP_OBJECT_TEMPLATES] = { + [MOVEMENT_TYPE_NONE] = FALSE, + [MOVEMENT_TYPE_LOOK_AROUND] = FALSE, + [MOVEMENT_TYPE_WANDER_AROUND] = TRUE, + [MOVEMENT_TYPE_WANDER_UP_AND_DOWN] = TRUE, + [MOVEMENT_TYPE_WANDER_DOWN_AND_UP] = TRUE, + [MOVEMENT_TYPE_WANDER_LEFT_AND_RIGHT] = TRUE, + [MOVEMENT_TYPE_WANDER_RIGHT_AND_LEFT] = TRUE, + [MOVEMENT_TYPE_FACE_UP] = FALSE, + [MOVEMENT_TYPE_FACE_DOWN] = FALSE, + [MOVEMENT_TYPE_FACE_LEFT] = FALSE, + [MOVEMENT_TYPE_FACE_RIGHT] = FALSE, + [MOVEMENT_TYPE_PLAYER] = FALSE, + [MOVEMENT_TYPE_BERRY_TREE_GROWTH] = FALSE, + [MOVEMENT_TYPE_FACE_DOWN_AND_UP] = FALSE, + [MOVEMENT_TYPE_FACE_LEFT_AND_RIGHT] = FALSE, + [MOVEMENT_TYPE_FACE_UP_AND_LEFT] = FALSE, + [MOVEMENT_TYPE_FACE_UP_AND_RIGHT] = FALSE, + [MOVEMENT_TYPE_FACE_DOWN_AND_LEFT] = FALSE, + [MOVEMENT_TYPE_FACE_DOWN_AND_RIGHT] = FALSE, + [MOVEMENT_TYPE_FACE_DOWN_UP_AND_LEFT] = FALSE, + [MOVEMENT_TYPE_FACE_DOWN_UP_AND_RIGHT] = FALSE, + [MOVEMENT_TYPE_FACE_UP_LEFT_AND_RIGHT] = FALSE, + [MOVEMENT_TYPE_FACE_DOWN_LEFT_AND_RIGHT] = FALSE, + [MOVEMENT_TYPE_ROTATE_COUNTERCLOCKWISE] = FALSE, + [MOVEMENT_TYPE_ROTATE_CLOCKWISE] = FALSE, + [MOVEMENT_TYPE_WALK_UP_AND_DOWN] = TRUE, + [MOVEMENT_TYPE_WALK_DOWN_AND_UP] = TRUE, + [MOVEMENT_TYPE_WALK_LEFT_AND_RIGHT] = TRUE, + [MOVEMENT_TYPE_WALK_RIGHT_AND_LEFT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_RIGHT_LEFT_DOWN] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_LEFT_DOWN_UP] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_UP_RIGHT_LEFT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_DOWN_UP_RIGHT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_LEFT_RIGHT_DOWN] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_RIGHT_DOWN_UP] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_UP_LEFT_RIGHT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_DOWN_UP_LEFT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_UP_DOWN_RIGHT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_DOWN_RIGHT_LEFT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_LEFT_UP_DOWN] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_RIGHT_LEFT_UP] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_UP_DOWN_LEFT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_DOWN_LEFT_RIGHT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_RIGHT_UP_DOWN] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_LEFT_RIGHT_UP] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_LEFT_DOWN_RIGHT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_RIGHT_UP_LEFT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_DOWN_RIGHT_UP] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_UP_LEFT_DOWN] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_RIGHT_DOWN_LEFT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_LEFT_UP_RIGHT] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_UP_RIGHT_DOWN] = TRUE, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_DOWN_LEFT_UP] = TRUE, + [MOVEMENT_TYPE_COPY_PLAYER] = TRUE, + [MOVEMENT_TYPE_COPY_PLAYER_OPPOSITE] = TRUE, + [MOVEMENT_TYPE_COPY_PLAYER_COUNTERCLOCKWISE] = TRUE, + [MOVEMENT_TYPE_COPY_PLAYER_CLOCKWISE] = TRUE, + [MOVEMENT_TYPE_TREE_DISGUISE] = FALSE, + [MOVEMENT_TYPE_MOUNTAIN_DISGUISE] = FALSE, + [MOVEMENT_TYPE_COPY_PLAYER_IN_GRASS] = TRUE, + [MOVEMENT_TYPE_COPY_PLAYER_OPPOSITE_IN_GRASS] = TRUE, + [MOVEMENT_TYPE_COPY_PLAYER_COUNTERCLOCKWISE_IN_GRASS] = TRUE, + [MOVEMENT_TYPE_COPY_PLAYER_CLOCKWISE_IN_GRASS] = TRUE, + [MOVEMENT_TYPE_HIDDEN] = FALSE, + [MOVEMENT_TYPE_WALK_IN_PLACE_DOWN] = FALSE, + [MOVEMENT_TYPE_WALK_IN_PLACE_UP] = FALSE, + [MOVEMENT_TYPE_WALK_IN_PLACE_LEFT] = FALSE, + [MOVEMENT_TYPE_WALK_IN_PLACE_RIGHT] = FALSE, + [MOVEMENT_TYPE_JOG_IN_PLACE_DOWN] = FALSE, + [MOVEMENT_TYPE_JOG_IN_PLACE_UP] = FALSE, + [MOVEMENT_TYPE_JOG_IN_PLACE_LEFT] = FALSE, + [MOVEMENT_TYPE_JOG_IN_PLACE_RIGHT] = FALSE, + [MOVEMENT_TYPE_RUN_IN_PLACE_DOWN] = FALSE, + [MOVEMENT_TYPE_RUN_IN_PLACE_UP] = FALSE, + [MOVEMENT_TYPE_RUN_IN_PLACE_LEFT] = FALSE, + [MOVEMENT_TYPE_RUN_IN_PLACE_RIGHT] = FALSE, + [MOVEMENT_TYPE_INVISIBLE] = FALSE, + [MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_DOWN] = FALSE, + [MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_UP] = FALSE, + [MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_LEFT] = FALSE, + [MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_RIGHT] = TRUE, +}; + +const u8 gInitialMovementTypeFacingDirections[NUM_FIELD_MAP_OBJECT_TEMPLATES] = { + [MOVEMENT_TYPE_NONE] = DIR_SOUTH, + [MOVEMENT_TYPE_LOOK_AROUND] = DIR_SOUTH, + [MOVEMENT_TYPE_WANDER_AROUND] = DIR_SOUTH, + [MOVEMENT_TYPE_WANDER_UP_AND_DOWN] = DIR_NORTH, + [MOVEMENT_TYPE_WANDER_DOWN_AND_UP] = DIR_SOUTH, + [MOVEMENT_TYPE_WANDER_LEFT_AND_RIGHT] = DIR_WEST, + [MOVEMENT_TYPE_WANDER_RIGHT_AND_LEFT] = DIR_EAST, + [MOVEMENT_TYPE_FACE_UP] = DIR_NORTH, + [MOVEMENT_TYPE_FACE_DOWN] = DIR_SOUTH, + [MOVEMENT_TYPE_FACE_LEFT] = DIR_WEST, + [MOVEMENT_TYPE_FACE_RIGHT] = DIR_EAST, + [MOVEMENT_TYPE_PLAYER] = DIR_SOUTH, + [MOVEMENT_TYPE_BERRY_TREE_GROWTH] = DIR_SOUTH, + [MOVEMENT_TYPE_FACE_DOWN_AND_UP] = DIR_SOUTH, + [MOVEMENT_TYPE_FACE_LEFT_AND_RIGHT] = DIR_WEST, + [MOVEMENT_TYPE_FACE_UP_AND_LEFT] = DIR_NORTH, + [MOVEMENT_TYPE_FACE_UP_AND_RIGHT] = DIR_NORTH, + [MOVEMENT_TYPE_FACE_DOWN_AND_LEFT] = DIR_SOUTH, + [MOVEMENT_TYPE_FACE_DOWN_AND_RIGHT] = DIR_SOUTH, + [MOVEMENT_TYPE_FACE_DOWN_UP_AND_LEFT] = DIR_SOUTH, + [MOVEMENT_TYPE_FACE_DOWN_UP_AND_RIGHT] = DIR_SOUTH, + [MOVEMENT_TYPE_FACE_UP_LEFT_AND_RIGHT] = DIR_NORTH, + [MOVEMENT_TYPE_FACE_DOWN_LEFT_AND_RIGHT] = DIR_SOUTH, + [MOVEMENT_TYPE_ROTATE_COUNTERCLOCKWISE] = DIR_SOUTH, + [MOVEMENT_TYPE_ROTATE_CLOCKWISE] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_UP_AND_DOWN] = DIR_NORTH, + [MOVEMENT_TYPE_WALK_DOWN_AND_UP] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_LEFT_AND_RIGHT] = DIR_WEST, + [MOVEMENT_TYPE_WALK_RIGHT_AND_LEFT] = DIR_EAST, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_RIGHT_LEFT_DOWN] = DIR_NORTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_LEFT_DOWN_UP] = DIR_EAST, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_UP_RIGHT_LEFT] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_DOWN_UP_RIGHT] = DIR_WEST, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_LEFT_RIGHT_DOWN] = DIR_NORTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_RIGHT_DOWN_UP] = DIR_WEST, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_UP_LEFT_RIGHT] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_DOWN_UP_LEFT] = DIR_EAST, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_UP_DOWN_RIGHT] = DIR_WEST, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_DOWN_RIGHT_LEFT] = DIR_NORTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_LEFT_UP_DOWN] = DIR_EAST, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_RIGHT_LEFT_UP] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_UP_DOWN_LEFT] = DIR_EAST, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_DOWN_LEFT_RIGHT] = DIR_NORTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_RIGHT_UP_DOWN] = DIR_WEST, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_LEFT_RIGHT_UP] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_LEFT_DOWN_RIGHT] = DIR_NORTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_RIGHT_UP_LEFT] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_DOWN_RIGHT_UP] = DIR_WEST, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_UP_LEFT_DOWN] = DIR_EAST, + [MOVEMENT_TYPE_WALK_SEQUENCE_UP_RIGHT_DOWN_LEFT] = DIR_NORTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_DOWN_LEFT_UP_RIGHT] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SEQUENCE_LEFT_UP_RIGHT_DOWN] = DIR_WEST, + [MOVEMENT_TYPE_WALK_SEQUENCE_RIGHT_DOWN_LEFT_UP] = DIR_EAST, + [MOVEMENT_TYPE_COPY_PLAYER] = DIR_NORTH, + [MOVEMENT_TYPE_COPY_PLAYER_OPPOSITE] = DIR_SOUTH, + [MOVEMENT_TYPE_COPY_PLAYER_COUNTERCLOCKWISE] = DIR_WEST, + [MOVEMENT_TYPE_COPY_PLAYER_CLOCKWISE] = DIR_EAST, + [MOVEMENT_TYPE_TREE_DISGUISE] = DIR_SOUTH, + [MOVEMENT_TYPE_MOUNTAIN_DISGUISE] = DIR_SOUTH, + [MOVEMENT_TYPE_COPY_PLAYER_IN_GRASS] = DIR_NORTH, + [MOVEMENT_TYPE_COPY_PLAYER_OPPOSITE_IN_GRASS] = DIR_SOUTH, + [MOVEMENT_TYPE_COPY_PLAYER_COUNTERCLOCKWISE_IN_GRASS] = DIR_WEST, + [MOVEMENT_TYPE_COPY_PLAYER_CLOCKWISE_IN_GRASS] = DIR_EAST, + [MOVEMENT_TYPE_HIDDEN] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_IN_PLACE_DOWN] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_IN_PLACE_UP] = DIR_NORTH, + [MOVEMENT_TYPE_WALK_IN_PLACE_LEFT] = DIR_WEST, + [MOVEMENT_TYPE_WALK_IN_PLACE_RIGHT] = DIR_EAST, + [MOVEMENT_TYPE_JOG_IN_PLACE_DOWN] = DIR_SOUTH, + [MOVEMENT_TYPE_JOG_IN_PLACE_UP] = DIR_NORTH, + [MOVEMENT_TYPE_JOG_IN_PLACE_LEFT] = DIR_WEST, + [MOVEMENT_TYPE_JOG_IN_PLACE_RIGHT] = DIR_EAST, + [MOVEMENT_TYPE_RUN_IN_PLACE_DOWN] = DIR_SOUTH, + [MOVEMENT_TYPE_RUN_IN_PLACE_UP] = DIR_NORTH, + [MOVEMENT_TYPE_RUN_IN_PLACE_LEFT] = DIR_WEST, + [MOVEMENT_TYPE_RUN_IN_PLACE_RIGHT] = DIR_EAST, + [MOVEMENT_TYPE_INVISIBLE] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_DOWN] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_UP] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_LEFT] = DIR_SOUTH, + [MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_RIGHT] = DIR_SOUTH, +}; + +#define OBJ_EVENT_PAL_TAG_0 0x1103 +#define OBJ_EVENT_PAL_TAG_1 0x1104 +#define OBJ_EVENT_PAL_TAG_2 0x1105 +#define OBJ_EVENT_PAL_TAG_3 0x1106 +#define OBJ_EVENT_PAL_TAG_4 0x1107 +#define OBJ_EVENT_PAL_TAG_5 0x1108 +#define OBJ_EVENT_PAL_TAG_6 0x1109 +#define OBJ_EVENT_PAL_TAG_7 0x110A +#define OBJ_EVENT_PAL_TAG_8 0x1100 +#define OBJ_EVENT_PAL_TAG_9 0x1101 +#define OBJ_EVENT_PAL_TAG_10 0x1102 +#define OBJ_EVENT_PAL_TAG_11 0x1115 +#define OBJ_EVENT_PAL_TAG_12 0x110B +#define OBJ_EVENT_PAL_TAG_13 0x110C +#define OBJ_EVENT_PAL_TAG_14 0x110D +#define OBJ_EVENT_PAL_TAG_15 0x110E +#define OBJ_EVENT_PAL_TAG_16 0x110F +#define OBJ_EVENT_PAL_TAG_17 0x1110 +#define OBJ_EVENT_PAL_TAG_18 0x1111 +#define OBJ_EVENT_PAL_TAG_19 0x1112 +#define OBJ_EVENT_PAL_TAG_20 0x1113 +#define OBJ_EVENT_PAL_TAG_21 0x1114 +#define OBJ_EVENT_PAL_TAG_22 0x1116 +#define OBJ_EVENT_PAL_TAG_23 0x1117 +#define OBJ_EVENT_PAL_TAG_24 0x1118 +#define OBJ_EVENT_PAL_TAG_25 0x1119 +#define OBJ_EVENT_PAL_TAG_26 0x111B +#define OBJ_EVENT_PAL_TAG_27 0x111C +#define OBJ_EVENT_PAL_TAG_28 0x111D +#define OBJ_EVENT_PAL_TAG_29 0x111E +#define OBJ_EVENT_PAL_TAG_30 0x111F +#define OBJ_EVENT_PAL_TAG_31 0x1120 +#define OBJ_EVENT_PAL_TAG_32 0x1121 +#define OBJ_EVENT_PAL_TAG_33 0x1122 +#define OBJ_EVENT_PAL_TAG_34 0x1123 #define OBJ_EVENT_PAL_TAG_NONE 0x11FF +#include "data/object_events/object_event_graphics_info_pointers.h" +#include "data/field_effects/field_effect_object_template_pointers.h" +#include "data/object_events/object_event_pic_tables.h" +#include "data/object_events/object_event_anims.h" +#include "data/object_events/base_oam.h" +#include "data/object_events/object_event_subsprites.h" +#include "data/object_events/object_event_graphics_info.h" + +static const struct SpritePalette sObjectEventSpritePalettes[] = { + {gUnknown_836D828, OBJ_EVENT_PAL_TAG_0}, + {gUnknown_836D848, OBJ_EVENT_PAL_TAG_1}, + {gUnknown_836D868, OBJ_EVENT_PAL_TAG_2}, + {gUnknown_836D888, OBJ_EVENT_PAL_TAG_3}, + {gUnknown_836D8A8, OBJ_EVENT_PAL_TAG_4}, + {gUnknown_836D8C8, OBJ_EVENT_PAL_TAG_5}, + {gUnknown_836D8E8, OBJ_EVENT_PAL_TAG_6}, + {gUnknown_836D908, OBJ_EVENT_PAL_TAG_7}, + {gUnknown_835B968, OBJ_EVENT_PAL_TAG_8}, + {gUnknown_835E968, OBJ_EVENT_PAL_TAG_9}, + {gUnknown_835E988, OBJ_EVENT_PAL_TAG_10}, + {gUnknown_8398008, OBJ_EVENT_PAL_TAG_12}, + {gUnknown_8398028, OBJ_EVENT_PAL_TAG_13}, + {gUnknown_835B968, OBJ_EVENT_PAL_TAG_17}, + {gUnknown_835E968, OBJ_EVENT_PAL_TAG_18}, + {gUnknown_8394EA8, OBJ_EVENT_PAL_TAG_20}, + {gUnknown_8395AE8, OBJ_EVENT_PAL_TAG_11}, + {gUnknown_83952C8, OBJ_EVENT_PAL_TAG_21}, + {}, +}; + +const u16 gPlayerReflectionPaletteTags[] = { + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_18, + OBJ_EVENT_PAL_TAG_18, + OBJ_EVENT_PAL_TAG_18, + OBJ_EVENT_PAL_TAG_18, +}; + +const u16 gUnknownPaletteTags_83A5200[] = { + OBJ_EVENT_PAL_TAG_22, + OBJ_EVENT_PAL_TAG_22, + OBJ_EVENT_PAL_TAG_22, + OBJ_EVENT_PAL_TAG_22, +}; + +const struct PairedPalettes gPlayerReflectionPaletteSets[] = { + {OBJ_EVENT_PAL_TAG_8, gPlayerReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_17, gPlayerReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_22, gUnknownPaletteTags_83A5200}, + {OBJ_EVENT_PAL_TAG_NONE, NULL}, +}; + +const u16 gUnknownPaletteTags_83A5228[] = { + OBJ_EVENT_PAL_TAG_13, + OBJ_EVENT_PAL_TAG_13, + OBJ_EVENT_PAL_TAG_13, + OBJ_EVENT_PAL_TAG_13, +}; + +const u16 gUnknownPaletteTags_83A5230[] = { + OBJ_EVENT_PAL_TAG_14, + OBJ_EVENT_PAL_TAG_14, + OBJ_EVENT_PAL_TAG_14, + OBJ_EVENT_PAL_TAG_14, +}; + +const u16 gUnknownPaletteTags_83A5238[] = { + OBJ_EVENT_PAL_TAG_15, + OBJ_EVENT_PAL_TAG_15, + OBJ_EVENT_PAL_TAG_15, + OBJ_EVENT_PAL_TAG_15, +}; + +const u16 gUnknownPaletteTags_83A5240[] = { + OBJ_EVENT_PAL_TAG_19, + OBJ_EVENT_PAL_TAG_19, + OBJ_EVENT_PAL_TAG_19, + OBJ_EVENT_PAL_TAG_19, +}; + +const u16 gUnknownPaletteTags_83A5248[] = { + OBJ_EVENT_PAL_TAG_20, + OBJ_EVENT_PAL_TAG_20, + OBJ_EVENT_PAL_TAG_20, + OBJ_EVENT_PAL_TAG_20, +}; + +const u16 gUnknownPaletteTags_83A5250[] = { + OBJ_EVENT_PAL_TAG_21, + OBJ_EVENT_PAL_TAG_21, + OBJ_EVENT_PAL_TAG_21, + OBJ_EVENT_PAL_TAG_21, +}; + +const u16 gUnknownPaletteTags_83A5258[] = { + OBJ_EVENT_PAL_TAG_26, + OBJ_EVENT_PAL_TAG_26, + OBJ_EVENT_PAL_TAG_26, + OBJ_EVENT_PAL_TAG_26, +}; + +const u16 gUnknownPaletteTags_83A5260[] = { + OBJ_EVENT_PAL_TAG_24, + OBJ_EVENT_PAL_TAG_24, + OBJ_EVENT_PAL_TAG_24, + OBJ_EVENT_PAL_TAG_24, +}; + +const u16 gUnknownPaletteTags_83A5268[] = { + 0x111a, + 0x111a, + 0x111a, + 0x111a, +}; + +const u16 gUnknownPaletteTags_83A5270[] = { + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_6, +}; + +const struct PairedPalettes gSpecialObjectReflectionPaletteSets[] = { + {OBJ_EVENT_PAL_TAG_8, gPlayerReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_17, gPlayerReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_12, gUnknownPaletteTags_83A5228}, + {OBJ_EVENT_PAL_TAG_14, gUnknownPaletteTags_83A5230}, + {OBJ_EVENT_PAL_TAG_15, gUnknownPaletteTags_83A5238}, + {OBJ_EVENT_PAL_TAG_19, gUnknownPaletteTags_83A5240}, + {OBJ_EVENT_PAL_TAG_20, gUnknownPaletteTags_83A5248}, + {OBJ_EVENT_PAL_TAG_21, gUnknownPaletteTags_83A5250}, + {OBJ_EVENT_PAL_TAG_23, gUnknownPaletteTags_83A5260}, + {OBJ_EVENT_PAL_TAG_25, gUnknownPaletteTags_83A5268}, + {OBJ_EVENT_PAL_TAG_2, gUnknownPaletteTags_83A5270}, + {OBJ_EVENT_PAL_TAG_26, gUnknownPaletteTags_83A5258}, + {OBJ_EVENT_PAL_TAG_NONE, NULL}, +}; + +const u16 gUnknownPaletteTags_83A52E0[] = { + OBJ_EVENT_PAL_TAG_8, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_0, + OBJ_EVENT_PAL_TAG_1, + OBJ_EVENT_PAL_TAG_2, + OBJ_EVENT_PAL_TAG_3, + OBJ_EVENT_PAL_TAG_4, + OBJ_EVENT_PAL_TAG_5, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_7, +}; + +const u16 gUnknownPaletteTags_83A52F4[] = { + OBJ_EVENT_PAL_TAG_8, + OBJ_EVENT_PAL_TAG_17, + OBJ_EVENT_PAL_TAG_0, + OBJ_EVENT_PAL_TAG_1, + OBJ_EVENT_PAL_TAG_2, + OBJ_EVENT_PAL_TAG_3, + OBJ_EVENT_PAL_TAG_4, + OBJ_EVENT_PAL_TAG_5, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_7, +}; + +const u16 gUnknownPaletteTags_83A5308[] = { + OBJ_EVENT_PAL_TAG_8, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_0, + OBJ_EVENT_PAL_TAG_1, + OBJ_EVENT_PAL_TAG_2, + OBJ_EVENT_PAL_TAG_3, + OBJ_EVENT_PAL_TAG_4, + OBJ_EVENT_PAL_TAG_5, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_7, +}; + +const u16 gUnknownPaletteTags_83A531C[] = { + OBJ_EVENT_PAL_TAG_8, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_0, + OBJ_EVENT_PAL_TAG_1, + OBJ_EVENT_PAL_TAG_2, + OBJ_EVENT_PAL_TAG_3, + OBJ_EVENT_PAL_TAG_4, + OBJ_EVENT_PAL_TAG_5, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_7, +}; + +const u16 *const gObjectPaletteTagSets[] = { + gUnknownPaletteTags_83A52E0, + gUnknownPaletteTags_83A52F4, + gUnknownPaletteTags_83A5308, + gUnknownPaletteTags_83A531C, +}; + +//#include "data/object_events/berry_tree_graphics_tables.h" +#include "data/field_effects/field_effect_objects.h" + +const s16 gMovementDelaysMedium[] = {32, 64, 96, 128}; +const s16 gMovementDelaysLong[] = {32, 64, 128, 192}; +const s16 gMovementDelaysShort[] = {32, 48, 64, 80}; + +#include "data/object_events/movement_type_func_tables.h" + +const u8 gFaceDirectionAnimNums[] = { + [DIR_NONE] = 0x00, + [DIR_SOUTH] = 0x00, + [DIR_NORTH] = 0x01, + [DIR_WEST] = 0x02, + [DIR_EAST] = 0x03, + [DIR_SOUTHWEST] = 0x00, + [DIR_SOUTHEAST] = 0x00, + [DIR_NORTHWEST] = 0x01, + [DIR_NORTHEAST] = 0x01, +}; + +const u8 gMoveDirectionAnimNums[] = { + [DIR_NONE] = 0x4, + [DIR_SOUTH] = 0x4, + [DIR_NORTH] = 0x5, + [DIR_WEST] = 0x6, + [DIR_EAST] = 0x7, + [DIR_SOUTHWEST] = 0x4, + [DIR_SOUTHEAST] = 0x4, + [DIR_NORTHWEST] = 0x5, + [DIR_NORTHEAST] = 0x5, +}; + +const u8 gMoveDirectionFastAnimNums[] = { + [DIR_NONE] = 0x8, + [DIR_SOUTH] = 0x8, + [DIR_NORTH] = 0x9, + [DIR_WEST] = 0xA, + [DIR_EAST] = 0xB, + [DIR_SOUTHWEST] = 0x8, + [DIR_SOUTHEAST] = 0x8, + [DIR_NORTHWEST] = 0x9, + [DIR_NORTHEAST] = 0x9, +}; + +const u8 gMoveDirectionFasterAnimNums[] = { + [DIR_NONE] = 0xC, + [DIR_SOUTH] = 0xC, + [DIR_NORTH] = 0xD, + [DIR_WEST] = 0xE, + [DIR_EAST] = 0xF, + [DIR_SOUTHWEST] = 0xC, + [DIR_SOUTHEAST] = 0xC, + [DIR_NORTHWEST] = 0xD, + [DIR_NORTHEAST] = 0xD, +}; + +const u8 gMoveDirectionFastestAnimNums[] = { + [DIR_NONE] = 0x10, + [DIR_SOUTH] = 0x10, + [DIR_NORTH] = 0x11, + [DIR_WEST] = 0x12, + [DIR_EAST] = 0x13, + [DIR_SOUTHWEST] = 0x10, + [DIR_SOUTHEAST] = 0x10, + [DIR_NORTHWEST] = 0x11, + [DIR_NORTHEAST] = 0x11, +}; + +const u8 gJumpSpecialDirectionAnimNums[] = { + [DIR_NONE] = 0x14, + [DIR_SOUTH] = 0x14, + [DIR_NORTH] = 0x15, + [DIR_WEST] = 0x16, + [DIR_EAST] = 0x17, + [DIR_SOUTHWEST] = 0x14, + [DIR_SOUTHEAST] = 0x14, + [DIR_NORTHWEST] = 0x15, + [DIR_NORTHEAST] = 0x15, +}; + +const u8 gAcroWheelieDirectionAnimNums[] = { + [DIR_NONE] = 0x14, + [DIR_SOUTH] = 0x14, + [DIR_NORTH] = 0x15, + [DIR_WEST] = 0x16, + [DIR_EAST] = 0x17, + [DIR_SOUTHWEST] = 0x14, + [DIR_SOUTHEAST] = 0x14, + [DIR_NORTHWEST] = 0x15, + [DIR_NORTHEAST] = 0x15, +}; + +const u8 gUnrefAnimNums_080634A0[] = { + [DIR_NONE] = 0x18, + [DIR_SOUTH] = 0x18, + [DIR_NORTH] = 0x19, + [DIR_WEST] = 0x1A, + [DIR_EAST] = 0x1B, + [DIR_SOUTHWEST] = 0x18, + [DIR_SOUTHEAST] = 0x18, + [DIR_NORTHWEST] = 0x19, + [DIR_NORTHEAST] = 0x19, +}; + +const u8 gAcroEndWheelieDirectionAnimNums[] = { + [DIR_NONE] = 0x1C, + [DIR_SOUTH] = 0x1C, + [DIR_NORTH] = 0x1D, + [DIR_WEST] = 0x1E, + [DIR_EAST] = 0x1F, + [DIR_SOUTHWEST] = 0x1C, + [DIR_SOUTHEAST] = 0x1C, + [DIR_NORTHWEST] = 0x1D, + [DIR_NORTHEAST] = 0x1D, +}; + +const u8 gUnknown_83A6465[] = { + [DIR_NONE] = 0x18, + [DIR_SOUTH] = 0x18, + [DIR_NORTH] = 0x19, + [DIR_WEST] = 0x1A, + [DIR_EAST] = 0x1B, + [DIR_SOUTHWEST] = 0x18, + [DIR_SOUTHEAST] = 0x19, + [DIR_NORTHWEST] = 0x1A, + [DIR_NORTHEAST] = 0x1B, +}; + +const u8 gAcroUnusedActionDirectionAnimNums[] = { + [DIR_NONE] = 0x20, + [DIR_SOUTH] = 0x20, + [DIR_NORTH] = 0x21, + [DIR_WEST] = 0x22, + [DIR_EAST] = 0x23, + [DIR_SOUTHWEST] = 0x20, + [DIR_SOUTHEAST] = 0x20, + [DIR_NORTHWEST] = 0x21, + [DIR_NORTHEAST] = 0x21, +}; + +const u8 gAcroWheeliePedalDirectionAnimNums[] = { + [DIR_NONE] = 0x24, + [DIR_SOUTH] = 0x24, + [DIR_NORTH] = 0x25, + [DIR_WEST] = 0x26, + [DIR_EAST] = 0x27, + [DIR_SOUTHWEST] = 0x24, + [DIR_SOUTHEAST] = 0x24, + [DIR_NORTHWEST] = 0x25, + [DIR_NORTHEAST] = 0x25, +}; + +const u8 gFishingDirectionAnimNums[] = { + [DIR_NONE] = 0x0, + [DIR_SOUTH] = 0x0, + [DIR_NORTH] = 0x1, + [DIR_WEST] = 0x2, + [DIR_EAST] = 0x3, + [DIR_SOUTHWEST] = 0x0, + [DIR_SOUTHEAST] = 0x0, + [DIR_NORTHWEST] = 0x1, + [DIR_NORTHEAST] = 0x1, +}; + +const u8 gFishingNoCatchDirectionAnimNums[] = { + [DIR_NONE] = 0x4, + [DIR_SOUTH] = 0x4, + [DIR_NORTH] = 0x5, + [DIR_WEST] = 0x6, + [DIR_EAST] = 0x7, + [DIR_SOUTHWEST] = 0x4, + [DIR_SOUTHEAST] = 0x4, + [DIR_NORTHWEST] = 0x5, + [DIR_NORTHEAST] = 0x5, +}; + +const u8 gFishingBiteDirectionAnimNums[] = { + [DIR_NONE] = 0x8, + [DIR_SOUTH] = 0x8, + [DIR_NORTH] = 0x9, + [DIR_WEST] = 0xA, + [DIR_EAST] = 0xB, + [DIR_SOUTHWEST] = 0x8, + [DIR_SOUTHEAST] = 0x8, + [DIR_NORTHWEST] = 0x9, + [DIR_NORTHEAST] = 0x9, +}; + +const u8 gRunningDirectionAnimNums[] = { + [DIR_NONE] = 0x14, + [DIR_SOUTH] = 0x14, + [DIR_NORTH] = 0x15, + [DIR_WEST] = 0x16, + [DIR_EAST] = 0x17, + [DIR_SOUTHWEST] = 0x14, + [DIR_SOUTHEAST] = 0x14, + [DIR_NORTHWEST] = 0x15, + [DIR_NORTHEAST] = 0x15, +}; + +const u8 gTrainerFacingDirectionMovementTypes[] = { + [DIR_NONE] = 0x08, + [DIR_SOUTH] = 0x08, + [DIR_NORTH] = 0x07, + [DIR_WEST] = 0x09, + [DIR_EAST] = 0x0A, + [DIR_SOUTHWEST] = 0x08, + [DIR_SOUTHEAST] = 0x08, + [DIR_NORTHWEST] = 0x07, + [DIR_NORTHEAST] = 0x07, +}; + +bool8 (*const gOppositeDirectionBlockedMetatileFuncs[])(u8) = { + MetatileBehavior_IsSouthBlocked, + MetatileBehavior_IsNorthBlocked, + MetatileBehavior_IsWestBlocked, + MetatileBehavior_IsEastBlocked +}; + +bool8 (*const gDirectionBlockedMetatileFuncs[])(u8) = { + MetatileBehavior_IsNorthBlocked, + MetatileBehavior_IsSouthBlocked, + MetatileBehavior_IsEastBlocked, + MetatileBehavior_IsWestBlocked +}; + +static const struct Coords16 sDirectionToVectors[] = { + [DIR_NONE] = { 0, 0}, + [DIR_SOUTH] = { 0, 1}, + [DIR_NORTH] = { 0, -1}, + [DIR_WEST] = {-1, 0}, + [DIR_EAST] = { 1, 0}, + [DIR_SOUTHWEST] = {-1, 1}, + [DIR_SOUTHEAST] = { 1, 1}, + [DIR_NORTHWEST] = {-1, -1}, + [DIR_NORTHEAST] = { 1, -1}, +}; + +const u8 gFaceDirectionMovementActions[] = { + [DIR_NONE] = MOVEMENT_ACTION_FACE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_FACE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_FACE_UP, + [DIR_WEST] = MOVEMENT_ACTION_FACE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_FACE_RIGHT, +}; + +const u8 gFaceDirectionFastMovementActions[] = { + [DIR_NONE] = MOVEMENT_ACTION_FACE_DOWN_FAST, + [DIR_SOUTH] = MOVEMENT_ACTION_FACE_DOWN_FAST, + [DIR_NORTH] = MOVEMENT_ACTION_FACE_UP_FAST, + [DIR_WEST] = MOVEMENT_ACTION_FACE_LEFT_FAST, + [DIR_EAST] = MOVEMENT_ACTION_FACE_RIGHT_FAST, +}; + +const u8 gUnknown_83A64F6[] = { + [DIR_NONE] = MOVEMENT_ACTION_0x9B, + [DIR_SOUTH] = MOVEMENT_ACTION_0x9B, + [DIR_NORTH] = MOVEMENT_ACTION_0x9C, + [DIR_WEST] = MOVEMENT_ACTION_0x9D, + [DIR_EAST] = MOVEMENT_ACTION_0x9E, +}; + +const u8 gUnknown_83A64FB[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_SLOWEST_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_SLOWEST_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_SLOWEST_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_SLOWEST_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_SLOWEST_RIGHT, +}; + +const u8 gUnknown_83A6500[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_SLOW_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_SLOW_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_SLOW_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_SLOW_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_SLOW_RIGHT, +}; + +const u8 gUnknown_83A6505[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_NORMAL_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_NORMAL_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_NORMAL_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_NORMAL_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_NORMAL_RIGHT, +}; + +const u8 gUnknown_83A650A[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_FAST_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_FAST_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_FAST_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_FAST_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_FAST_RIGHT, +}; + +const u8 gUnknown_83A650F[] = { + [DIR_NONE] = MOVEMENT_ACTION_0xA0, + [DIR_SOUTH] = MOVEMENT_ACTION_0xA0, + [DIR_NORTH] = MOVEMENT_ACTION_0xA1, + [DIR_WEST] = MOVEMENT_ACTION_0xA2, + [DIR_EAST] = MOVEMENT_ACTION_0xA3, +}; + +const u8 gUnknown_83A6514[] = { + [DIR_NONE] = MOVEMENT_ACTION_FACE_DOWN_SLOW, + [DIR_SOUTH] = MOVEMENT_ACTION_FACE_DOWN_SLOW, + [DIR_NORTH] = MOVEMENT_ACTION_FACE_UP_SLOW, + [DIR_WEST] = MOVEMENT_ACTION_FACE_LEFT_SLOW, + [DIR_EAST] = MOVEMENT_ACTION_FACE_RIGHT_SLOW, +}; + +const u8 gUnknown_83A6519[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_FASTEST_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_FASTEST_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_FASTEST_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_FASTEST_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_FASTEST_RIGHT, +}; + +const u8 gUnknown_83A651E[] = { + [DIR_NONE] = MOVEMENT_ACTION_SLIDE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_SLIDE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_SLIDE_UP, + [DIR_WEST] = MOVEMENT_ACTION_SLIDE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_SLIDE_RIGHT, +}; + +const u8 gUnknown_83A6523[] = { + [DIR_NONE] = MOVEMENT_ACTION_PLAYER_RUN_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_PLAYER_RUN_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_PLAYER_RUN_UP, + [DIR_WEST] = MOVEMENT_ACTION_PLAYER_RUN_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_PLAYER_RUN_RIGHT, +}; + +const u8 gUnknown_83A6528[] = { + [DIR_NONE] = MOVEMENT_ACTION_PLAYER_RUN_DOWN_SLOW, + [DIR_SOUTH] = MOVEMENT_ACTION_PLAYER_RUN_DOWN_SLOW, + [DIR_NORTH] = MOVEMENT_ACTION_PLAYER_RUN_UP_SLOW, + [DIR_WEST] = MOVEMENT_ACTION_PLAYER_RUN_LEFT_SLOW, + [DIR_EAST] = MOVEMENT_ACTION_PLAYER_RUN_RIGHT_SLOW, +}; + +const u8 gUnknown_83A652D[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_END_WHEELIE_MOVE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_END_WHEELIE_MOVE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_END_WHEELIE_MOVE_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_END_WHEELIE_MOVE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_END_WHEELIE_MOVE_RIGHT, +}; + +const u8 gUnknown_83A6532[] = { + [DIR_NONE] = MOVEMENT_ACTION_JUMP_2_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_JUMP_2_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_JUMP_2_UP, + [DIR_WEST] = MOVEMENT_ACTION_JUMP_2_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_JUMP_2_RIGHT, +}; + +const u8 gUnknown_83A6537[] = { + [DIR_NONE] = MOVEMENT_ACTION_JUMP_IN_PLACE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_JUMP_IN_PLACE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_JUMP_IN_PLACE_UP, + [DIR_WEST] = MOVEMENT_ACTION_JUMP_IN_PLACE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_JUMP_IN_PLACE_RIGHT, +}; + +const u8 gUnknown_83A653C[] = { + [DIR_NONE] = MOVEMENT_ACTION_JUMP_IN_PLACE_UP_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_JUMP_IN_PLACE_UP_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_JUMP_IN_PLACE_DOWN_UP, + [DIR_WEST] = MOVEMENT_ACTION_JUMP_IN_PLACE_RIGHT_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_JUMP_IN_PLACE_LEFT_RIGHT, +}; + +const u8 gUnknown_83A6541[] = { + [DIR_NONE] = MOVEMENT_ACTION_JUMP_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_JUMP_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_JUMP_UP, + [DIR_WEST] = MOVEMENT_ACTION_JUMP_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_JUMP_RIGHT, +}; + +const u8 gUnknown_83A6546[] = { + [DIR_NONE] = MOVEMENT_ACTION_JUMP_SPECIAL_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_JUMP_SPECIAL_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_JUMP_SPECIAL_UP, + [DIR_WEST] = MOVEMENT_ACTION_JUMP_SPECIAL_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_JUMP_SPECIAL_RIGHT, +}; + +const u8 gUnknown_83A654B[] = { + [DIR_NONE] = MOVEMENT_ACTION_0xA6, + [DIR_SOUTH] = MOVEMENT_ACTION_0xA6, + [DIR_NORTH] = MOVEMENT_ACTION_0xA7, + [DIR_WEST] = MOVEMENT_ACTION_0xA8, + [DIR_EAST] = MOVEMENT_ACTION_0xA9, +}; + +const u8 gUnknown_83A6550[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_IN_PLACE_SLOW_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_IN_PLACE_SLOW_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_IN_PLACE_SLOW_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_IN_PLACE_SLOW_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_IN_PLACE_SLOW_RIGHT, +}; + +const u8 gUnknown_83A6555[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_IN_PLACE_NORMAL_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_IN_PLACE_NORMAL_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_IN_PLACE_NORMAL_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_IN_PLACE_NORMAL_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_IN_PLACE_NORMAL_RIGHT, +}; + +const u8 gUnknown_83A655A[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_IN_PLACE_FAST_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_IN_PLACE_FAST_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_IN_PLACE_FAST_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_IN_PLACE_FAST_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_IN_PLACE_FAST_RIGHT, +}; + +const u8 gUnknown_83A655F[] = { + [DIR_NONE] = MOVEMENT_ACTION_WALK_IN_PLACE_FASTEST_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_WALK_IN_PLACE_FASTEST_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_WALK_IN_PLACE_FASTEST_UP, + [DIR_WEST] = MOVEMENT_ACTION_WALK_IN_PLACE_FASTEST_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_WALK_IN_PLACE_FASTEST_RIGHT, +}; + +const u8 gUnknown_83A6564[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_WHEELIE_FACE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_WHEELIE_FACE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_WHEELIE_FACE_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_WHEELIE_FACE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_WHEELIE_FACE_RIGHT, +}; + +const u8 gUnknown_83A6569[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_RIGHT, +}; + +const u8 gUnknown_83A656E[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_END_WHEELIE_FACE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_END_WHEELIE_FACE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_END_WHEELIE_FACE_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_END_WHEELIE_FACE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_END_WHEELIE_FACE_RIGHT, +}; + +const u8 gUnknown_83A6573[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_FACE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_FACE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_FACE_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_FACE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_FACE_RIGHT, +}; + +const u8 gUnknown_83A6578[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_WHEELIE_HOP_RIGHT, +}; + +const u8 gUnknown_83A657D[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_WHEELIE_JUMP_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_WHEELIE_JUMP_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_WHEELIE_JUMP_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_WHEELIE_JUMP_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_WHEELIE_JUMP_RIGHT, +}; + +const u8 gUnknown_83A6582[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_RIGHT, +}; + +const u8 gUnknown_83A6587[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_MOVE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_MOVE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_MOVE_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_MOVE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_POP_WHEELIE_MOVE_RIGHT, +}; + +const u8 gUnknown_83A658C[] = { + [DIR_NONE] = MOVEMENT_ACTION_ACRO_WHEELIE_MOVE_DOWN, + [DIR_SOUTH] = MOVEMENT_ACTION_ACRO_WHEELIE_MOVE_DOWN, + [DIR_NORTH] = MOVEMENT_ACTION_ACRO_WHEELIE_MOVE_UP, + [DIR_WEST] = MOVEMENT_ACTION_ACRO_WHEELIE_MOVE_LEFT, + [DIR_EAST] = MOVEMENT_ACTION_ACRO_WHEELIE_MOVE_RIGHT, +}; + +const u8 gOppositeDirections[] = { + DIR_NORTH, + DIR_SOUTH, + DIR_EAST, + DIR_WEST, + DIR_NORTHEAST, + DIR_NORTHWEST, + DIR_SOUTHEAST, + DIR_SOUTHWEST, +}; + +const u8 gUnknown_83A6599[][4] = { + {2, 1, 4, 3}, + {1, 2, 3, 4}, + {3, 4, 2, 1}, + {4, 3, 1, 2} +}; + +const u8 gUnknown_83A65A9[][4] = { + {2, 1, 4, 3}, + {1, 2, 3, 4}, + {4, 3, 1, 2}, + {3, 4, 2, 1} +}; + +#include "data/object_events/movement_action_func_tables.h" + static void ClearObjectEvent(struct ObjectEvent *objectEvent) { *objectEvent = (struct ObjectEvent){}; @@ -1491,8 +2322,8 @@ const struct ObjectEventGraphicsInfo *GetObjectEventGraphicsInfo(u8 graphicsId) if (graphicsId >= OBJ_EVENT_GFX_VARS) graphicsId = VarGetObjectEventGraphicsId(graphicsId - OBJ_EVENT_GFX_VARS); - if (graphicsId >= 152) - graphicsId = 16; + if (graphicsId >= NUM_OBJ_EVENT_GFX) + graphicsId = OBJ_EVENT_GFX_LITTLE_BOY; return gObjectEventGraphicsInfoPointers[graphicsId]; } @@ -1804,7 +2635,7 @@ u8 AddCameraObject(u8 linkedSpriteId) return spriteId; } -/*static*/ void ObjectCB_CameraObject(struct Sprite *sprite) +static void ObjectCB_CameraObject(struct Sprite *sprite) { void (*callbacks[NELEMS(gCameraObjectFuncs)])(struct Sprite *); @@ -1812,7 +2643,7 @@ u8 AddCameraObject(u8 linkedSpriteId) callbacks[sprite->data[1]](sprite); } -/*static*/ void CameraObject_0(struct Sprite *sprite) +static void CameraObject_0(struct Sprite *sprite) { sprite->pos1.x = gSprites[sprite->data[0]].pos1.x; sprite->pos1.y = gSprites[sprite->data[0]].pos1.y; @@ -1821,7 +2652,7 @@ u8 AddCameraObject(u8 linkedSpriteId) CameraObject_1(sprite); } -/*static*/ void CameraObject_1(struct Sprite *sprite) +static void CameraObject_1(struct Sprite *sprite) { s16 x = gSprites[sprite->data[0]].pos1.x; s16 y = gSprites[sprite->data[0]].pos1.y; @@ -1832,7 +2663,7 @@ u8 AddCameraObject(u8 linkedSpriteId) sprite->pos1.y = y; } -/*static*/ void CameraObject_2(struct Sprite *sprite) +static void CameraObject_2(struct Sprite *sprite) { sprite->pos1.x = gSprites[sprite->data[0]].pos1.x; sprite->pos1.y = gSprites[sprite->data[0]].pos1.y; @@ -2120,21 +2951,21 @@ movement_type_empty_callback(MovementType_None) movement_type_def(MovementType_WanderAround, gMovementTypeFuncs_WanderAround) movement_type_def(MovementType_WanderAroundDuplicate, gMovementTypeFuncs_WanderAroundDuplicate) -bool8 MovementType_WanderAround_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderAround_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_WanderAround_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderAround_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_WanderAround_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderAround_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (!ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2145,7 +2976,7 @@ bool8 MovementType_WanderAround_Step2(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 MovementType_WanderAround_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderAround_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite)) { @@ -2155,7 +2986,7 @@ bool8 MovementType_WanderAround_Step3(struct ObjectEvent *objectEvent, struct Sp return FALSE; } -bool8 MovementType_WanderAround_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderAround_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; u8 chosenDirection; @@ -2170,7 +3001,7 @@ bool8 MovementType_WanderAround_Step4(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 MovementType_WanderAround_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderAround_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkNormalMovementAction(objectEvent->movementDirection)); objectEvent->singleMovementActive = TRUE; @@ -2178,7 +3009,7 @@ bool8 MovementType_WanderAround_Step5(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 MovementType_WanderAround_Step5Duplicate(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderAround_Step5Duplicate(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, sub_8063F2C(objectEvent->movementDirection)); objectEvent->singleMovementActive = TRUE; @@ -2186,7 +3017,7 @@ bool8 MovementType_WanderAround_Step5Duplicate(struct ObjectEvent *objectEvent, return TRUE; } -bool8 MovementType_WanderAround_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderAround_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2207,7 +3038,7 @@ bool8 ObjectEventIsTrainerAndCloseToPlayer(struct ObjectEvent *objectEvent) s16 minY; s16 maxY; - if (!TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_DASH)) + if (!TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_WATERING)) { return FALSE; } @@ -2229,7 +3060,7 @@ bool8 ObjectEventIsTrainerAndCloseToPlayer(struct ObjectEvent *objectEvent) return TRUE; } -u8 GetVectorDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetVectorDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2252,7 +3083,7 @@ u8 GetVectorDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetLimitedVectorDirection_SouthNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_SouthNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2264,7 +3095,7 @@ u8 GetLimitedVectorDirection_SouthNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetLimitedVectorDirection_WestEast(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_WestEast(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2276,7 +3107,7 @@ u8 GetLimitedVectorDirection_WestEast(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetLimitedVectorDirection_WestNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_WestNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2300,7 +3131,7 @@ u8 GetLimitedVectorDirection_WestNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetLimitedVectorDirection_EastNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_EastNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2324,7 +3155,7 @@ u8 GetLimitedVectorDirection_EastNorth(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetLimitedVectorDirection_WestSouth(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_WestSouth(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2348,7 +3179,7 @@ u8 GetLimitedVectorDirection_WestSouth(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetLimitedVectorDirection_EastSouth(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_EastSouth(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2372,7 +3203,7 @@ u8 GetLimitedVectorDirection_EastSouth(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetLimitedVectorDirection_SouthNorthWest(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_SouthNorthWest(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2384,7 +3215,7 @@ u8 GetLimitedVectorDirection_SouthNorthWest(s16 dx, s16 dy, s16 absdx, s16 absdy return direction; } -u8 GetLimitedVectorDirection_SouthNorthEast(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_SouthNorthEast(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2396,7 +3227,7 @@ u8 GetLimitedVectorDirection_SouthNorthEast(s16 dx, s16 dy, s16 absdx, s16 absdy return direction; } -u8 GetLimitedVectorDirection_NorthWestEast(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_NorthWestEast(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2408,7 +3239,7 @@ u8 GetLimitedVectorDirection_NorthWestEast(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetLimitedVectorDirection_SouthWestEast(s16 dx, s16 dy, s16 absdx, s16 absdy) +static u8 GetLimitedVectorDirection_SouthWestEast(s16 dx, s16 dy, s16 absdx, s16 absdy) { u8 direction; @@ -2447,21 +3278,21 @@ u8 TryGetTrainerEncounterDirection(struct ObjectEvent *objectEvent, u8 movementT movement_type_def(MovementType_LookAround, gMovementTypeFuncs_LookAround) -bool8 MovementType_LookAround_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_LookAround_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_LookAround_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_LookAround_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_LookAround_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_LookAround_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2472,7 +3303,7 @@ bool8 MovementType_LookAround_Step2(struct ObjectEvent *objectEvent, struct Spri return FALSE; } -bool8 MovementType_LookAround_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_LookAround_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -2482,7 +3313,7 @@ bool8 MovementType_LookAround_Step3(struct ObjectEvent *objectEvent, struct Spri return FALSE; } -bool8 MovementType_LookAround_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_LookAround_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; @@ -2498,21 +3329,21 @@ bool8 MovementType_LookAround_Step4(struct ObjectEvent *objectEvent, struct Spri movement_type_def(MovementType_WanderUpAndDown, gMovementTypeFuncs_WanderUpAndDown) -bool8 MovementType_WanderUpAndDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderUpAndDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_WanderUpAndDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderUpAndDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_WanderUpAndDown_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderUpAndDown_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (!ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2523,7 +3354,7 @@ bool8 MovementType_WanderUpAndDown_Step2(struct ObjectEvent *objectEvent, struct return TRUE; } -bool8 MovementType_WanderUpAndDown_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderUpAndDown_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite)) { @@ -2533,7 +3364,7 @@ bool8 MovementType_WanderUpAndDown_Step3(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementType_WanderUpAndDown_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderUpAndDown_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; @@ -2547,7 +3378,7 @@ bool8 MovementType_WanderUpAndDown_Step4(struct ObjectEvent *objectEvent, struct return TRUE; } -bool8 MovementType_WanderUpAndDown_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderUpAndDown_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkNormalMovementAction(objectEvent->movementDirection)); objectEvent->singleMovementActive = TRUE; @@ -2555,7 +3386,7 @@ bool8 MovementType_WanderUpAndDown_Step5(struct ObjectEvent *objectEvent, struct return TRUE; } -bool8 MovementType_WanderUpAndDown_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderUpAndDown_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2567,21 +3398,21 @@ bool8 MovementType_WanderUpAndDown_Step6(struct ObjectEvent *objectEvent, struct movement_type_def(MovementType_WanderLeftAndRight, gMovementTypeFuncs_WanderLeftAndRight) -bool8 MovementType_WanderLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (!ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2592,7 +3423,7 @@ bool8 MovementType_WanderLeftAndRight_Step2(struct ObjectEvent *objectEvent, str return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite)) { @@ -2602,7 +3433,7 @@ bool8 MovementType_WanderLeftAndRight_Step3(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementType_WanderLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; @@ -2616,7 +3447,7 @@ bool8 MovementType_WanderLeftAndRight_Step4(struct ObjectEvent *objectEvent, str return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderLeftAndRight_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkNormalMovementAction(objectEvent->movementDirection)); objectEvent->singleMovementActive = TRUE; @@ -2624,7 +3455,7 @@ bool8 MovementType_WanderLeftAndRight_Step5(struct ObjectEvent *objectEvent, str return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WanderLeftAndRight_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2636,7 +3467,7 @@ bool8 MovementType_WanderLeftAndRight_Step6(struct ObjectEvent *objectEvent, str movement_type_def(MovementType_FaceDirection, gMovementTypeFuncs_FaceDirection) -bool8 MovementType_FaceDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); @@ -2644,7 +3475,7 @@ bool8 MovementType_FaceDirection_Step0(struct ObjectEvent *objectEvent, struct S return TRUE; } -bool8 MovementType_FaceDirection_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDirection_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2654,7 +3485,7 @@ bool8 MovementType_FaceDirection_Step1(struct ObjectEvent *objectEvent, struct S return FALSE; } -bool8 MovementType_FaceDirection_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDirection_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->singleMovementActive = FALSE; return FALSE; @@ -2662,21 +3493,21 @@ bool8 MovementType_FaceDirection_Step2(struct ObjectEvent *objectEvent, struct S movement_type_def(MovementType_FaceDownAndUp, gMovementTypeFuncs_FaceDownAndUp) -bool8 MovementType_FaceDownAndUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownAndUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownAndUp_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndUp_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2687,7 +3518,7 @@ bool8 MovementType_FaceDownAndUp_Step2(struct ObjectEvent *objectEvent, struct S return FALSE; } -bool8 MovementType_FaceDownAndUp_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndUp_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -2697,7 +3528,7 @@ bool8 MovementType_FaceDownAndUp_Step3(struct ObjectEvent *objectEvent, struct S return FALSE; } -bool8 MovementType_FaceDownAndUp_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndUp_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; @@ -2714,21 +3545,21 @@ bool8 MovementType_FaceDownAndUp_Step4(struct ObjectEvent *objectEvent, struct S movement_type_def(MovementType_FaceLeftAndRight, gMovementTypeFuncs_FaceLeftAndRight) -bool8 MovementType_FaceLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2739,7 +3570,7 @@ bool8 MovementType_FaceLeftAndRight_Step2(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementType_FaceLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -2749,7 +3580,7 @@ bool8 MovementType_FaceLeftAndRight_Step3(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementType_FaceLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; @@ -2766,21 +3597,21 @@ bool8 MovementType_FaceLeftAndRight_Step4(struct ObjectEvent *objectEvent, struc movement_type_def(MovementType_FaceUpAndLeft, gMovementTypeFuncs_FaceUpAndLeft) -bool8 MovementType_FaceUpAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceUpAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2791,7 +3622,7 @@ bool8 MovementType_FaceUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct S return FALSE; } -bool8 MovementType_FaceUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -2801,7 +3632,7 @@ bool8 MovementType_FaceUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct S return FALSE; } -bool8 MovementType_FaceUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; @@ -2818,21 +3649,21 @@ bool8 MovementType_FaceUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct S movement_type_def(MovementType_FaceUpAndRight, gMovementTypeFuncs_FaceUpAndRight) -bool8 MovementType_FaceUpAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceUpAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceUpAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2843,7 +3674,7 @@ bool8 MovementType_FaceUpAndRight_Step2(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementType_FaceUpAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -2853,7 +3684,7 @@ bool8 MovementType_FaceUpAndRight_Step3(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementType_FaceUpAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; @@ -2870,21 +3701,21 @@ bool8 MovementType_FaceUpAndRight_Step4(struct ObjectEvent *objectEvent, struct movement_type_def(MovementType_FaceDownAndLeft, gMovementTypeFuncs_FaceDownAndLeft) -bool8 MovementType_FaceDownAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2895,7 +3726,7 @@ bool8 MovementType_FaceDownAndLeft_Step2(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementType_FaceDownAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -2905,7 +3736,7 @@ bool8 MovementType_FaceDownAndLeft_Step3(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementType_FaceDownAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; @@ -2922,21 +3753,21 @@ bool8 MovementType_FaceDownAndLeft_Step4(struct ObjectEvent *objectEvent, struct movement_type_def(MovementType_FaceDownAndRight, gMovementTypeFuncs_FaceDownAndRight) -bool8 MovementType_FaceDownAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2947,7 +3778,7 @@ bool8 MovementType_FaceDownAndRight_Step2(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementType_FaceDownAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -2957,7 +3788,7 @@ bool8 MovementType_FaceDownAndRight_Step3(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementType_FaceDownAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; @@ -2974,21 +3805,21 @@ bool8 MovementType_FaceDownAndRight_Step4(struct ObjectEvent *objectEvent, struc movement_type_def(MovementType_FaceDownUpAndLeft, gMovementTypeFuncs_FaceDownUpAndLeft) -bool8 MovementType_FaceDownUpAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownUpAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -2999,7 +3830,7 @@ bool8 MovementType_FaceDownUpAndLeft_Step2(struct ObjectEvent *objectEvent, stru return FALSE; } -bool8 MovementType_FaceDownUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -3009,7 +3840,7 @@ bool8 MovementType_FaceDownUpAndLeft_Step3(struct ObjectEvent *objectEvent, stru return FALSE; } -bool8 MovementType_FaceDownUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; @@ -3026,21 +3857,21 @@ bool8 MovementType_FaceDownUpAndLeft_Step4(struct ObjectEvent *objectEvent, stru movement_type_def(MovementType_FaceDownUpAndRight, gMovementTypeFuncs_FaceDownUpAndRight) -bool8 MovementType_FaceDownUpAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownUpAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownUpAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3051,7 +3882,7 @@ bool8 MovementType_FaceDownUpAndRight_Step2(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementType_FaceDownUpAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -3061,7 +3892,7 @@ bool8 MovementType_FaceDownUpAndRight_Step3(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementType_FaceDownUpAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownUpAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; @@ -3078,21 +3909,21 @@ bool8 MovementType_FaceDownUpAndRight_Step4(struct ObjectEvent *objectEvent, str movement_type_def(MovementType_FaceUpRightAndLeft, gMovementTypeFuncs_FaceUpLeftAndRight) -bool8 MovementType_FaceUpLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceUpLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceUpLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3103,7 +3934,7 @@ bool8 MovementType_FaceUpLeftAndRight_Step2(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementType_FaceUpLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -3113,7 +3944,7 @@ bool8 MovementType_FaceUpLeftAndRight_Step3(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementType_FaceUpLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceUpLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; @@ -3130,21 +3961,21 @@ bool8 MovementType_FaceUpLeftAndRight_Step4(struct ObjectEvent *objectEvent, str movement_type_def(MovementType_FaceDownRightAndLeft, gMovementTypeFuncs_FaceDownLeftAndRight) -bool8 MovementType_FaceDownLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3155,7 +3986,7 @@ bool8 MovementType_FaceDownLeftAndRight_Step2(struct ObjectEvent *objectEvent, s return FALSE; } -bool8 MovementType_FaceDownLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -3165,7 +3996,7 @@ bool8 MovementType_FaceDownLeftAndRight_Step3(struct ObjectEvent *objectEvent, s return FALSE; } -bool8 MovementType_FaceDownLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_FaceDownLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; @@ -3182,7 +4013,7 @@ bool8 MovementType_FaceDownLeftAndRight_Step4(struct ObjectEvent *objectEvent, s movement_type_def(MovementType_RotateCounterclockwise, gMovementTypeFuncs_RotateCounterclockwise) -bool8 MovementType_RotateCounterclockwise_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_RotateCounterclockwise_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); @@ -3190,7 +4021,7 @@ bool8 MovementType_RotateCounterclockwise_Step0(struct ObjectEvent *objectEvent, return TRUE; } -bool8 MovementType_RotateCounterclockwise_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_RotateCounterclockwise_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3200,7 +4031,7 @@ bool8 MovementType_RotateCounterclockwise_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementType_RotateCounterclockwise_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_RotateCounterclockwise_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -3209,7 +4040,7 @@ bool8 MovementType_RotateCounterclockwise_Step2(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementType_RotateCounterclockwise_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_RotateCounterclockwise_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[5]; @@ -3226,7 +4057,7 @@ bool8 MovementType_RotateCounterclockwise_Step3(struct ObjectEvent *objectEvent, movement_type_def(MovementType_RotateClockwise, gMovementTypeFuncs_RotateClockwise) -bool8 MovementType_RotateClockwise_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_RotateClockwise_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); @@ -3234,7 +4065,7 @@ bool8 MovementType_RotateClockwise_Step0(struct ObjectEvent *objectEvent, struct return TRUE; } -bool8 MovementType_RotateClockwise_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_RotateClockwise_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3244,7 +4075,7 @@ bool8 MovementType_RotateClockwise_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementType_RotateClockwise_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_RotateClockwise_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { @@ -3253,7 +4084,7 @@ bool8 MovementType_RotateClockwise_Step2(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementType_RotateClockwise_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_RotateClockwise_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[5]; @@ -3270,14 +4101,14 @@ bool8 MovementType_RotateClockwise_Step3(struct ObjectEvent *objectEvent, struct movement_type_def(MovementType_WalkBackAndForth, gMovementTypeFuncs_WalkBackAndForth) -bool8 MovementType_WalkBackAndForth_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WalkBackAndForth_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_WalkBackAndForth_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WalkBackAndForth_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; @@ -3291,7 +4122,7 @@ bool8 MovementType_WalkBackAndForth_Step1(struct ObjectEvent *objectEvent, struc return TRUE; } -bool8 MovementType_WalkBackAndForth_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WalkBackAndForth_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { bool8 collision; u8 movementActionId; @@ -3320,7 +4151,7 @@ bool8 MovementType_WalkBackAndForth_Step2(struct ObjectEvent *objectEvent, struc return TRUE; } -bool8 MovementType_WalkBackAndForth_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WalkBackAndForth_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3330,7 +4161,7 @@ bool8 MovementType_WalkBackAndForth_Step3(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementType_WalkSequence_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WalkSequence_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; @@ -3365,7 +4196,7 @@ bool8 MoveNextDirectionInSequence(struct ObjectEvent *objectEvent, struct Sprite return TRUE; } -bool8 MovementType_WalkSequence_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WalkSequence_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3689,7 +4520,7 @@ u8 MovementType_WalkSequenceRightDownLeftUp_Step1(struct ObjectEvent *objectEven movement_type_def(MovementType_CopyPlayer, gMovementTypeFuncs_CopyPlayer) -bool8 MovementType_CopyPlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_CopyPlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); if (objectEvent->directionSequenceIndex == 0) @@ -3700,7 +4531,7 @@ bool8 MovementType_CopyPlayer_Step0(struct ObjectEvent *objectEvent, struct Spri return TRUE; } -bool8 MovementType_CopyPlayer_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_CopyPlayer_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (gObjectEvents[gPlayerAvatar.objectEventId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == T_TILE_CENTER) { @@ -3709,7 +4540,7 @@ bool8 MovementType_CopyPlayer_Step1(struct ObjectEvent *objectEvent, struct Spri return gCopyPlayerMovementFuncs[PlayerGetCopyableMovement()](objectEvent, sprite, GetPlayerMovementDirection(), NULL); } -bool8 MovementType_CopyPlayer_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_CopyPlayer_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3719,12 +4550,12 @@ bool8 MovementType_CopyPlayer_Step2(struct ObjectEvent *objectEvent, struct Spri return FALSE; } -bool8 CopyablePlayerMovement_None(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 CopyablePlayerMovement_None(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { return FALSE; } -bool8 CopyablePlayerMovement_FaceDirection(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 CopyablePlayerMovement_FaceDirection(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, playerDirection))); objectEvent->singleMovementActive = TRUE; @@ -3732,7 +4563,7 @@ bool8 CopyablePlayerMovement_FaceDirection(struct ObjectEvent *objectEvent, stru return TRUE; } -bool8 CopyablePlayerMovement_GoSpeed0(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 CopyablePlayerMovement_GoSpeed0(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; @@ -3751,7 +4582,7 @@ bool8 CopyablePlayerMovement_GoSpeed0(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 CopyablePlayerMovement_GoSpeed1(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 CopyablePlayerMovement_GoSpeed1(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; @@ -3770,7 +4601,7 @@ bool8 CopyablePlayerMovement_GoSpeed1(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 CopyablePlayerMovement_GoSpeed2(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 CopyablePlayerMovement_GoSpeed2(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; @@ -3789,7 +4620,7 @@ bool8 CopyablePlayerMovement_GoSpeed2(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 CopyablePlayerMovement_Slide(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 CopyablePlayerMovement_Slide(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; @@ -3808,7 +4639,7 @@ bool8 CopyablePlayerMovement_Slide(struct ObjectEvent *objectEvent, struct Sprit return TRUE; } -bool8 cph_IM_DIFFERENT(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 cph_IM_DIFFERENT(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; @@ -3820,7 +4651,7 @@ bool8 cph_IM_DIFFERENT(struct ObjectEvent *objectEvent, struct Sprite *sprite, u return TRUE; } -bool8 CopyablePlayerMovement_GoSpeed4(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 CopyablePlayerMovement_GoSpeed4(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; @@ -3839,7 +4670,7 @@ bool8 CopyablePlayerMovement_GoSpeed4(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 CopyablePlayerMovement_Jump(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +static bool8 CopyablePlayerMovement_Jump(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; @@ -3862,7 +4693,7 @@ bool8 CopyablePlayerMovement_Jump(struct ObjectEvent *objectEvent, struct Sprite movement_type_def(MovementType_CopyPlayerInGrass, gMovementTypeFuncs_CopyPlayerInGrass) -bool8 MovementType_CopyPlayerInGrass_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_CopyPlayerInGrass_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (gObjectEvents[gPlayerAvatar.objectEventId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == T_TILE_CENTER) { @@ -3871,7 +4702,7 @@ bool8 MovementType_CopyPlayerInGrass_Step1(struct ObjectEvent *objectEvent, stru return gCopyPlayerMovementFuncs[PlayerGetCopyableMovement()](objectEvent, sprite, GetPlayerMovementDirection(), MetatileBehavior_IsPokeGrass); } -void MovementType_TreeDisguise(struct Sprite *sprite) +static void MovementType_TreeDisguise(struct Sprite *sprite) { struct ObjectEvent *objectEvent; @@ -3892,7 +4723,7 @@ static bool8 MovementType_Disguise_Callback(struct ObjectEvent *objectEvent, str return FALSE; } -void MovementType_MountainDisguise(struct Sprite *sprite) +static void MovementType_MountainDisguise(struct Sprite *sprite) { struct ObjectEvent *objectEvent; @@ -3907,7 +4738,7 @@ void MovementType_MountainDisguise(struct Sprite *sprite) UpdateObjectEventCurrentMovement(&gObjectEvents[sprite->data[0]], sprite, MovementType_Disguise_Callback); } -void MovementType_Hidden(struct Sprite *sprite) +static void MovementType_Hidden(struct Sprite *sprite) { if (!sprite->data[7]) { @@ -3924,13 +4755,13 @@ static bool8 MovementType_Hidden_Callback(struct ObjectEvent *objectEvent, struc return gMovementTypeFuncs_Hidden[sprite->data[1]](objectEvent, sprite); } -bool8 MovementType_Hidden_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_Hidden_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); return FALSE; } -bool8 MovementType_MoveInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_MoveInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3941,7 +4772,7 @@ bool8 MovementType_MoveInPlace_Step1(struct ObjectEvent *objectEvent, struct Spr movement_type_def(MovementType_WalkInPlace, gMovementTypeFuncs_WalkInPlace) -bool8 MovementType_WalkInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WalkInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkInPlaceNormalMovementAction(objectEvent->facingDirection)); @@ -3951,7 +4782,7 @@ bool8 MovementType_WalkInPlace_Step0(struct ObjectEvent *objectEvent, struct Spr movement_type_def(MovementType_WalkSlowlyInPlace, gMovementTypeFuncs_WalkSlowlyInPlace) -bool8 MovementType_WalkSlowlyInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_WalkSlowlyInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkInPlaceSlowMovementAction(objectEvent->facingDirection)); @@ -3961,7 +4792,7 @@ bool8 MovementType_WalkSlowlyInPlace_Step0(struct ObjectEvent *objectEvent, stru movement_type_def(MovementType_JogInPlace, gMovementTypeFuncs_JogInPlace) -bool8 MovementType_JogInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_JogInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkInPlaceFastMovementAction(objectEvent->facingDirection)); @@ -3971,7 +4802,7 @@ bool8 MovementType_JogInPlace_Step0(struct ObjectEvent *objectEvent, struct Spri movement_type_def(MovementType_Invisible, gMovementTypeFuncs_Invisible) -bool8 MovementType_Invisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_Invisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); @@ -3980,7 +4811,7 @@ bool8 MovementType_Invisible_Step0(struct ObjectEvent *objectEvent, struct Sprit return TRUE; } -bool8 MovementType_Invisible_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_Invisible_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -3990,7 +4821,7 @@ bool8 MovementType_Invisible_Step1(struct ObjectEvent *objectEvent, struct Sprit return FALSE; } -bool8 MovementType_Invisible_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementType_Invisible_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->singleMovementActive = FALSE; return FALSE; @@ -4026,7 +4857,7 @@ static u8 sub_8063344(struct ObjectEvent *objectEvent, struct Sprite *sprite) return gUnknown_83A6404[sprite->data[1]](objectEvent, sprite); } -bool8 sub_8063364(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 sub_8063364(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, 0x98); @@ -4034,7 +4865,7 @@ bool8 sub_8063364(struct ObjectEvent *objectEvent, struct Sprite *sprite) return TRUE; } -bool8 sub_8063384(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 sub_8063384(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -4044,13 +4875,13 @@ bool8 sub_8063384(struct ObjectEvent *objectEvent, struct Sprite *sprite) return FALSE; } -bool8 sub_80633A4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 sub_80633A4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->singleMovementActive = FALSE; return FALSE; } -bool8 sub_80633B4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 sub_80633B4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, 0x99); @@ -4058,7 +4889,7 @@ bool8 sub_80633B4(struct ObjectEvent *objectEvent, struct Sprite *sprite) return FALSE; } -bool8 sub_80633D4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 sub_80633D4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ClearObjectEventMovement(objectEvent, sprite); ObjectEventSetSingleMovement(objectEvent, sprite, 0x9A); @@ -4066,7 +4897,7 @@ bool8 sub_80633D4(struct ObjectEvent *objectEvent, struct Sprite *sprite) return FALSE; } -bool8 sub_80633F4(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 sub_80633F4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { @@ -4094,17 +4925,17 @@ u8 GetMoveDirectionAnimNum(u8 direction) return gMoveDirectionAnimNums[direction]; } -u8 GetMoveDirectionFastAnimNum(u8 direction) +static u8 GetMoveDirectionFastAnimNum(u8 direction) { return gMoveDirectionFastAnimNums[direction]; } -u8 GetMoveDirectionFasterAnimNum(u8 direction) +static u8 GetMoveDirectionFasterAnimNum(u8 direction) { return gMoveDirectionFasterAnimNums[direction]; } -u8 GetMoveDirectionFastestAnimNum(u8 direction) +static u8 GetMoveDirectionFastestAnimNum(u8 direction) { return gMoveDirectionFastestAnimNums[direction]; } @@ -4129,6 +4960,11 @@ u8 GetAcroEndWheelieDirectionAnimNum(u8 direction) return gAcroEndWheelieDirectionAnimNums[direction]; } +u8 sub_80634C0(u8 direction) +{ + return gUnknown_83A6465[direction]; +} + u8 GetAcroUnusedActionDirectionAnimNum(u8 direction) { return gAcroUnusedActionDirectionAnimNums[direction]; @@ -4154,11 +4990,6 @@ u8 GetFishingBiteDirectionAnimNum(u8 direction) return gFishingBiteDirectionAnimNums[direction]; } -u8 sub_8063510(u8 direction) -{ - return gUnknown_83A648A[direction]; -} - u8 GetRunningDirectionAnimNum(u8 direction) { return gRunningDirectionAnimNums[direction]; @@ -4602,7 +5433,7 @@ u8 name(u32 idx) \ } dirn_to_anim(GetFaceDirectionMovementAction, gFaceDirectionMovementActions); -dirn_to_anim(GetWalkSlowMovementAction, gWalkSlowMovementActions); +dirn_to_anim(GetFaceDirectionFastMovementAction, gFaceDirectionFastMovementActions); u8 sub_8063F10(u32 idx) { @@ -4616,19 +5447,19 @@ u8 sub_8063F10(u32 idx) } dirn_to_anim(sub_8063F2C, gUnknown_83A64FB); -dirn_to_anim(sub_8063F58, gUnknown_83A6500); +dirn_to_anim(GetWalkSlowMovementAction, gUnknown_83A6500); dirn_to_anim(GetWalkNormalMovementAction, gUnknown_83A6505); dirn_to_anim(GetWalkFastMovementAction, gUnknown_83A650A); dirn_to_anim(sub_8063FDC, gUnknown_83A650F); dirn_to_anim(sub_8064008, gUnknown_83A6514); dirn_to_anim(GetWalkFastestMovementAction, gUnknown_83A6519); dirn_to_anim(GetSlideMovementAction, gUnknown_83A651E); -dirn_to_anim(sub_806408C, gUnknown_83A6523); -dirn_to_anim(sub_80640B8, gUnknown_83A6528); +dirn_to_anim(GetPlayerRunMovementAction, gUnknown_83A6523); +dirn_to_anim(GetPlayerRunSlowMovementAction, gUnknown_83A6528); dirn_to_anim(sub_80640E4, gUnknown_83A652D); dirn_to_anim(GetJump2MovementAction, gUnknown_83A6532); dirn_to_anim(GetJumpInPlaceMovementAction, gUnknown_83A6537); -dirn_to_anim(sub_8064168, gUnknown_83A653C); +dirn_to_anim(GetJumpInPlaceTurnAroundMovementAction, gUnknown_83A653C); dirn_to_anim(GetJumpMovementAction, gUnknown_83A6541); dirn_to_anim(sub_80641C0, gUnknown_83A6546); dirn_to_anim(sub_80641EC, gUnknown_83A654B); @@ -4642,15 +5473,15 @@ bool8 ObjectEventFaceOppositeDirection(struct ObjectEvent *objectEvent, u8 direc return ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(GetOppositeDirection(direction))); } -dirn_to_anim(sub_80642F4, gUnknown_83A6564); -dirn_to_anim(sub_8064320, gUnknown_83A6569); -dirn_to_anim(sub_806434C, gUnknown_83A656E); -dirn_to_anim(sub_8064378, gUnknown_83A6573); -dirn_to_anim(sub_80643A4, gUnknown_83A6578); -dirn_to_anim(sub_80643D0, gUnknown_83A657D); -dirn_to_anim(sub_80643FC, gUnknown_83A6582); -dirn_to_anim(sub_8064428, gUnknown_83A6587); -dirn_to_anim(sub_8064454, gUnknown_83A658C); +dirn_to_anim(GetAcroWheelieFaceDirectionMovementAction, gUnknown_83A6564); +dirn_to_anim(GetAcroPopWheelieFaceDirectionMovementAction, gUnknown_83A6569); +dirn_to_anim(GetAcroEndWheelieFaceDirectionMovementAction, gUnknown_83A656E); +dirn_to_anim(GetAcroWheelieHopFaceDirectionMovementAction, gUnknown_83A6573); +dirn_to_anim(GetAcroWheelieHopDirectionMovementAction, gUnknown_83A6578); +dirn_to_anim(GetAcroWheelieJumpDirectionMovementAction, gUnknown_83A657D); +dirn_to_anim(GetAcroWheelieInPlaceDirectionMovementAction, gUnknown_83A6582); +dirn_to_anim(GetAcroPopWheelieMoveDirectionMovementAction, gUnknown_83A6587); +dirn_to_anim(GetAcroWheelieMoveDirectionMovementAction, gUnknown_83A658C); u8 GetOppositeDirection(u8 direction) { @@ -4734,25 +5565,25 @@ static void FaceDirection(struct ObjectEvent *objectEvent, struct Sprite *sprite sprite->data[2] = 1; } -bool8 MovementAction_FaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_FaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { FaceDirection(objectEvent, sprite, DIR_SOUTH); return TRUE; } -bool8 MovementAction_FaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_FaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { FaceDirection(objectEvent, sprite, DIR_NORTH); return TRUE; } -bool8 MovementAction_FaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_FaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { FaceDirection(objectEvent, sprite, DIR_WEST); return TRUE; } -bool8 MovementAction_FaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_FaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { FaceDirection(objectEvent, sprite, DIR_EAST); return TRUE; @@ -4869,13 +5700,13 @@ bool8 sub_8064930(struct ObjectEvent *objectEvent, struct Sprite *sprite) return FALSE; } -bool8 MovementActionFunc_x9B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064904(objectEvent, sprite, DIR_SOUTH); return MovementActionFunc_x9B_1(objectEvent, sprite); } -bool8 MovementActionFunc_x9B_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9B_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8064930(objectEvent, sprite)) { @@ -4885,13 +5716,13 @@ bool8 MovementActionFunc_x9B_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x9C_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9C_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064904(objectEvent, sprite, DIR_NORTH); return MovementActionFunc_x9C_1(objectEvent, sprite); } -bool8 MovementActionFunc_x9C_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9C_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8064930(objectEvent, sprite)) { @@ -4901,13 +5732,13 @@ bool8 MovementActionFunc_x9C_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x9D_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9D_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064904(objectEvent, sprite, DIR_WEST); return MovementActionFunc_x9D_1(objectEvent, sprite); } -bool8 MovementActionFunc_x9D_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9D_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8064930(objectEvent, sprite)) { @@ -4917,13 +5748,13 @@ bool8 MovementActionFunc_x9D_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x9E_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9E_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064904(objectEvent, sprite, DIR_EAST); return MovementActionFunc_x9E_1(objectEvent, sprite); } -bool8 MovementActionFunc_x9E_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9E_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8064930(objectEvent, sprite)) { @@ -4933,13 +5764,13 @@ bool8 MovementActionFunc_x9E_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x08_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x08_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064830(objectEvent, sprite, DIR_SOUTH); return MovementActionFunc_x08_1(objectEvent, sprite); } -bool8 MovementActionFunc_x08_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x08_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (an_walk_any_2(objectEvent, sprite)) { @@ -4949,13 +5780,13 @@ bool8 MovementActionFunc_x08_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x09_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x09_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064830(objectEvent, sprite, DIR_NORTH); return MovementActionFunc_x09_1(objectEvent, sprite); } -bool8 MovementActionFunc_x09_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x09_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (an_walk_any_2(objectEvent, sprite)) { @@ -4965,13 +5796,13 @@ bool8 MovementActionFunc_x09_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x0A_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0A_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064830(objectEvent, sprite, DIR_WEST); return MovementActionFunc_x0A_1(objectEvent, sprite); } -bool8 MovementActionFunc_x0A_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0A_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (an_walk_any_2(objectEvent, sprite)) { @@ -4981,13 +5812,13 @@ bool8 MovementActionFunc_x0A_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x0B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064830(objectEvent, sprite, DIR_EAST); return MovementActionFunc_x0B_1(objectEvent, sprite); } -bool8 MovementActionFunc_x0B_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0B_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (an_walk_any_2(objectEvent, sprite)) { @@ -5031,13 +5862,13 @@ bool8 sub_8064C04(struct ObjectEvent *objectEvent, struct Sprite *sprite) return FALSE; } -bool8 MovementActionFunc_x0D_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0D_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064BD8(objectEvent, sprite, DIR_NORTH); return MovementActionFunc_x0D_1(objectEvent, sprite); } -bool8 MovementActionFunc_x0D_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0D_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8064C04(objectEvent, sprite)) { @@ -5047,13 +5878,13 @@ bool8 MovementActionFunc_x0D_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x0C_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0C_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064BD8(objectEvent, sprite, DIR_SOUTH); return MovementActionFunc_x0C_1(objectEvent, sprite); } -bool8 MovementActionFunc_x0C_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0C_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8064C04(objectEvent, sprite)) { @@ -5063,13 +5894,13 @@ bool8 MovementActionFunc_x0C_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x0E_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0E_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064BD8(objectEvent, sprite, DIR_WEST); return MovementActionFunc_x0E_1(objectEvent, sprite); } -bool8 MovementActionFunc_x0E_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0E_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8064C04(objectEvent, sprite)) { @@ -5079,13 +5910,13 @@ bool8 MovementActionFunc_x0E_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x0F_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0F_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064BD8(objectEvent, sprite, DIR_EAST); return MovementActionFunc_x0F_1(objectEvent, sprite); } -bool8 MovementActionFunc_x0F_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x0F_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8064C04(objectEvent, sprite)) { @@ -5095,13 +5926,13 @@ bool8 MovementActionFunc_x0F_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementAction_WalkNormalDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkNormalDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_SOUTH, 0); return MovementAction_WalkNormalDown_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkNormalDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkNormalDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5111,13 +5942,13 @@ bool8 MovementAction_WalkNormalDown_Step1(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementAction_WalkNormalUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkNormalUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_NORTH, 0); return MovementAction_WalkNormalUp_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkNormalUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkNormalUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5127,13 +5958,13 @@ bool8 MovementAction_WalkNormalUp_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_WalkNormalLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkNormalLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_WEST, 0); return MovementAction_WalkNormalLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkNormalLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkNormalLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5143,13 +5974,13 @@ bool8 MovementAction_WalkNormalLeft_Step1(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementAction_WalkNormalRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkNormalRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_EAST, 0); return MovementAction_WalkNormalRight_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkNormalRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkNormalRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5255,13 +6086,13 @@ bool8 sub_8065058(struct ObjectEvent *objectEvent, struct Sprite *sprite) } } -bool8 MovementAction_Jump2Down_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Jump2Down_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_SOUTH, 2, 0); return MovementAction_Jump2Down_Step1(objectEvent, sprite); } -bool8 MovementAction_Jump2Down_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Jump2Down_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -5272,13 +6103,13 @@ bool8 MovementAction_Jump2Down_Step1(struct ObjectEvent *objectEvent, struct Spr return FALSE; } -bool8 MovementAction_Jump2Up_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Jump2Up_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_NORTH, 2, 0); return MovementAction_Jump2Up_Step1(objectEvent, sprite); } -bool8 MovementAction_Jump2Up_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Jump2Up_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -5289,13 +6120,13 @@ bool8 MovementAction_Jump2Up_Step1(struct ObjectEvent *objectEvent, struct Sprit return FALSE; } -bool8 MovementAction_Jump2Left_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Jump2Left_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_WEST, 2, 0); return MovementAction_Jump2Left_Step1(objectEvent, sprite); } -bool8 MovementAction_Jump2Left_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Jump2Left_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -5306,13 +6137,13 @@ bool8 MovementAction_Jump2Left_Step1(struct ObjectEvent *objectEvent, struct Spr return FALSE; } -bool8 MovementAction_Jump2Right_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Jump2Right_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_EAST, 2, 0); return MovementAction_Jump2Right_Step1(objectEvent, sprite); } -bool8 MovementAction_Jump2Right_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Jump2Right_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -5329,7 +6160,7 @@ void sub_8065208(struct Sprite *sprite, u16 duration) sprite->data[3] = duration; } -bool8 MovementAction_Delay_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Delay_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (--sprite->data[3] == 0) { @@ -5339,43 +6170,43 @@ bool8 MovementAction_Delay_Step1(struct ObjectEvent *objectEvent, struct Sprite return FALSE; } -bool8 MovementAction_Delay1_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Delay1_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065208(sprite, 1); return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_Delay2_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Delay2_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065208(sprite, 2); return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_Delay4_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Delay4_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065208(sprite, 4); return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_Delay8_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Delay8_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065208(sprite, 8); return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_Delay16_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_Delay16_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065208(sprite, 16); return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_SOUTH, 1); return MovementAction_WalkFastDown_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5385,13 +6216,13 @@ bool8 MovementAction_WalkFastDown_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_WalkFastUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_NORTH, 1); return MovementAction_WalkFastUp_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5401,13 +6232,13 @@ bool8 MovementAction_WalkFastUp_Step1(struct ObjectEvent *objectEvent, struct Sp return FALSE; } -bool8 MovementAction_WalkFastLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_WEST, 1); return MovementAction_WalkFastLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5417,13 +6248,13 @@ bool8 MovementAction_WalkFastLeft_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_WalkFastRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_EAST, 1); return MovementAction_WalkFastRight_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5453,7 +6284,7 @@ u8 MovementActionFunc_xA0_0(struct ObjectEvent *objectEvent, struct Sprite *spri return MovementActionFunc_xA0_1(objectEvent, sprite); } -bool8 MovementActionFunc_xA0_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA0_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { AnimateSprite(sprite); if (sub_80653CC(objectEvent, sprite)) @@ -5473,7 +6304,7 @@ u8 MovementActionFunc_xA1_0(struct ObjectEvent *objectEvent, struct Sprite *spri return MovementActionFunc_xA1_1(objectEvent, sprite); } -bool8 MovementActionFunc_xA1_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA1_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { AnimateSprite(sprite); if (sub_80653CC(objectEvent, sprite)) @@ -5493,7 +6324,7 @@ u8 MovementActionFunc_xA2_0(struct ObjectEvent *objectEvent, struct Sprite *spri return MovementActionFunc_xA2_1(objectEvent, sprite); } -bool8 MovementActionFunc_xA2_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA2_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { AnimateSprite(sprite); if (sub_80653CC(objectEvent, sprite)) @@ -5513,7 +6344,7 @@ u8 MovementActionFunc_xA3_0(struct ObjectEvent *objectEvent, struct Sprite *spri return MovementActionFunc_xA3_1(objectEvent, sprite); } -bool8 MovementActionFunc_xA3_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA3_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { AnimateSprite(sprite); if (sub_80653CC(objectEvent, sprite)) @@ -5581,7 +6412,7 @@ void sub_80656C4(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 dire sprite->data[3] = duration; } -bool8 MovementAction_WalkInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (--sprite->data[3] == 0) { @@ -5592,7 +6423,7 @@ bool8 MovementAction_WalkInPlace_Step1(struct ObjectEvent *objectEvent, struct S return FALSE; } -bool8 MovementAction_WalkInPlaceSlow_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceSlow_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sprite->data[3] & 1) { @@ -5601,109 +6432,109 @@ bool8 MovementAction_WalkInPlaceSlow_Step1(struct ObjectEvent *objectEvent, stru return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceSlowDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceSlowDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_SOUTH, GetMoveDirectionAnimNum(DIR_SOUTH), 32); return MovementAction_WalkInPlaceSlow_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceSlowUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceSlowUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_NORTH, GetMoveDirectionAnimNum(DIR_NORTH), 32); return MovementAction_WalkInPlaceSlow_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceSlowLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceSlowLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_WEST, GetMoveDirectionAnimNum(DIR_WEST), 32); return MovementAction_WalkInPlaceSlow_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceSlowRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceSlowRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_EAST, GetMoveDirectionAnimNum(DIR_EAST), 32); return MovementAction_WalkInPlaceSlow_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceNormalDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceNormalDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_SOUTH, GetMoveDirectionAnimNum(DIR_SOUTH), 16); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceNormalUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceNormalUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_NORTH, GetMoveDirectionAnimNum(DIR_NORTH), 16); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceNormalLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceNormalLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_WEST, GetMoveDirectionAnimNum(DIR_WEST), 16); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceNormalRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceNormalRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_EAST, GetMoveDirectionAnimNum(DIR_EAST), 16); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceFastDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_SOUTH, GetMoveDirectionFastAnimNum(DIR_SOUTH), 8); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceFastUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_NORTH, GetMoveDirectionFastAnimNum(DIR_NORTH), 8); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceFastLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_WEST, GetMoveDirectionFastAnimNum(DIR_WEST), 8); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceFastRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_EAST, GetMoveDirectionFastAnimNum(DIR_EAST), 8); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastestDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceFastestDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_SOUTH, GetMoveDirectionFasterAnimNum(DIR_SOUTH), 4); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastestUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceFastestUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_NORTH, GetMoveDirectionFasterAnimNum(DIR_NORTH), 4); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastestLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceFastestLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_WEST, GetMoveDirectionFasterAnimNum(DIR_WEST), 4); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastestRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkInPlaceFastestRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80656C4(objectEvent, sprite, DIR_EAST, GetMoveDirectionFasterAnimNum(DIR_EAST), 4); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RideWaterCurrentDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_SOUTH, 2); return MovementAction_RideWaterCurrentDown_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RideWaterCurrentDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5713,13 +6544,13 @@ bool8 MovementAction_RideWaterCurrentDown_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_RideWaterCurrentUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RideWaterCurrentUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_NORTH, 2); return MovementAction_RideWaterCurrentUp_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RideWaterCurrentUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5729,13 +6560,13 @@ bool8 MovementAction_RideWaterCurrentUp_Step1(struct ObjectEvent *objectEvent, s return FALSE; } -bool8 MovementAction_RideWaterCurrentLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RideWaterCurrentLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_WEST, 2); return MovementAction_RideWaterCurrentLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RideWaterCurrentLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5745,13 +6576,13 @@ bool8 MovementAction_RideWaterCurrentLeft_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_RideWaterCurrentRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RideWaterCurrentRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_EAST, 2); return MovementAction_RideWaterCurrentRight_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RideWaterCurrentRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5761,13 +6592,13 @@ bool8 MovementAction_RideWaterCurrentRight_Step1(struct ObjectEvent *objectEvent return FALSE; } -bool8 MovementAction_WalkFastestDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastestDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_SOUTH, 3); return MovementAction_WalkFastestDown_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastestDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastestDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5777,13 +6608,13 @@ bool8 MovementAction_WalkFastestDown_Step1(struct ObjectEvent *objectEvent, stru return FALSE; } -bool8 MovementAction_WalkFastestUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastestUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_NORTH, 3); return MovementAction_WalkFastestUp_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastestUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastestUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5793,13 +6624,13 @@ bool8 MovementAction_WalkFastestUp_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_WalkFastestLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastestLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_WEST, 3); return MovementAction_WalkFastestLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastestLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastestLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5809,13 +6640,13 @@ bool8 MovementAction_WalkFastestLeft_Step1(struct ObjectEvent *objectEvent, stru return FALSE; } -bool8 MovementAction_WalkFastestRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastestRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_EAST, 3); return MovementAction_WalkFastestRight_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastestRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkFastestRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5825,13 +6656,13 @@ bool8 MovementAction_WalkFastestRight_Step1(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementAction_SlideDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SlideDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_SOUTH, 4); return MovementAction_SlideDown_Step1(objectEvent, sprite); } -bool8 MovementAction_SlideDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SlideDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5841,13 +6672,13 @@ bool8 MovementAction_SlideDown_Step1(struct ObjectEvent *objectEvent, struct Spr return FALSE; } -bool8 MovementAction_SlideUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SlideUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_NORTH, 4); return MovementAction_SlideUp_Step1(objectEvent, sprite); } -bool8 MovementAction_SlideUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SlideUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5857,13 +6688,13 @@ bool8 MovementAction_SlideUp_Step1(struct ObjectEvent *objectEvent, struct Sprit return FALSE; } -bool8 MovementAction_SlideLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SlideLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_WEST, 4); return MovementAction_SlideLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_SlideLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SlideLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5873,13 +6704,13 @@ bool8 MovementAction_SlideLeft_Step1(struct ObjectEvent *objectEvent, struct Spr return FALSE; } -bool8 MovementAction_SlideRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SlideRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { do_go_anim(objectEvent, sprite, DIR_EAST, 4); return MovementAction_SlideRight_Step1(objectEvent, sprite); } -bool8 MovementAction_SlideRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SlideRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5889,13 +6720,13 @@ bool8 MovementAction_SlideRight_Step1(struct ObjectEvent *objectEvent, struct Sp return FALSE; } -bool8 MovementAction_PlayerRunDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PlayerRunDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartRunningAnim(objectEvent, sprite, DIR_SOUTH); return MovementAction_PlayerRunDown_Step1(objectEvent, sprite); } -bool8 MovementAction_PlayerRunDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PlayerRunDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5905,13 +6736,13 @@ bool8 MovementAction_PlayerRunDown_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_PlayerRunUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PlayerRunUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartRunningAnim(objectEvent, sprite, DIR_NORTH); return MovementAction_PlayerRunUp_Step1(objectEvent, sprite); } -bool8 MovementAction_PlayerRunUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PlayerRunUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5921,13 +6752,13 @@ bool8 MovementAction_PlayerRunUp_Step1(struct ObjectEvent *objectEvent, struct S return FALSE; } -bool8 MovementAction_PlayerRunLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PlayerRunLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartRunningAnim(objectEvent, sprite, DIR_WEST); return MovementAction_PlayerRunLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_PlayerRunLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PlayerRunLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5937,13 +6768,13 @@ bool8 MovementAction_PlayerRunLeft_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_PlayerRunRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PlayerRunRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartRunningAnim(objectEvent, sprite, DIR_EAST); return MovementAction_PlayerRunRight_Step1(objectEvent, sprite); } -bool8 MovementAction_PlayerRunRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PlayerRunRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -5987,13 +6818,13 @@ bool8 sub_8065F8C(struct ObjectEvent *objectEvent, struct Sprite *sprite) return FALSE; } -bool8 MovementActionFunc_x41_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x41_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065F60(objectEvent, sprite, DIR_SOUTH); return MovementActionFunc_x41_1(objectEvent, sprite); } -bool8 MovementActionFunc_x41_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x41_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065F8C(objectEvent, sprite)) { @@ -6003,13 +6834,13 @@ bool8 MovementActionFunc_x41_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x42_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x42_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065F60(objectEvent, sprite, DIR_NORTH); return MovementActionFunc_x42_1(objectEvent, sprite); } -bool8 MovementActionFunc_x42_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x42_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065F8C(objectEvent, sprite)) { @@ -6019,13 +6850,13 @@ bool8 MovementActionFunc_x42_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x43_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x43_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065F60(objectEvent, sprite, DIR_WEST); return MovementActionFunc_x43_1(objectEvent, sprite); } -bool8 MovementActionFunc_x43_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x43_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065F8C(objectEvent, sprite)) { @@ -6035,13 +6866,13 @@ bool8 MovementActionFunc_x43_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x44_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x44_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8065F60(objectEvent, sprite, DIR_SOUTH); return MovementActionFunc_x44_1(objectEvent, sprite); } -bool8 MovementActionFunc_x44_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x44_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065F8C(objectEvent, sprite)) { @@ -6058,13 +6889,13 @@ void StartSpriteAnimInDirection(struct ObjectEvent *objectEvent, struct Sprite * sprite->data[2] = 1; } -bool8 MovementAction_StartAnimInDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_StartAnimInDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, objectEvent->movementDirection, sprite->animNum); return FALSE; } -bool8 MovementAction_WaitSpriteAnim(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WaitSpriteAnim(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (SpriteAnimEnded(sprite)) { @@ -6080,13 +6911,13 @@ void sub_8066128(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 dire StartSpriteAnim(sprite, GetJumpSpecialDirectionAnimNum(direction)); } -bool8 MovementAction_JumpSpecialDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpSpecialDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066128(objectEvent, sprite, DIR_SOUTH); return MovementAction_JumpSpecialDown_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpSpecialDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpSpecialDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065040(objectEvent, sprite)) { @@ -6097,13 +6928,13 @@ bool8 MovementAction_JumpSpecialDown_Step1(struct ObjectEvent *objectEvent, stru return FALSE; } -bool8 MovementAction_JumpSpecialUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpSpecialUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066128(objectEvent, sprite, DIR_NORTH); return MovementAction_JumpSpecialUp_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpSpecialUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpSpecialUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065040(objectEvent, sprite)) { @@ -6114,13 +6945,13 @@ bool8 MovementAction_JumpSpecialUp_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_JumpSpecialLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpSpecialLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066128(objectEvent, sprite, DIR_WEST); return MovementAction_JumpSpecialLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpSpecialLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpSpecialLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065040(objectEvent, sprite)) { @@ -6131,13 +6962,13 @@ bool8 MovementAction_JumpSpecialLeft_Step1(struct ObjectEvent *objectEvent, stru return FALSE; } -bool8 MovementAction_JumpSpecialRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpSpecialRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066128(objectEvent, sprite, DIR_EAST); return MovementAction_JumpSpecialRight_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065040(objectEvent, sprite)) { @@ -6148,13 +6979,13 @@ bool8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementActionFunc_xA6_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA6_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066128(objectEvent, sprite, DIR_SOUTH); return MovementActionFunc_xA6_1(objectEvent, sprite); } -bool8 MovementActionFunc_xA6_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA6_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065040(objectEvent, sprite)) { @@ -6164,13 +6995,13 @@ bool8 MovementActionFunc_xA6_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_xA7_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA7_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066128(objectEvent, sprite, DIR_NORTH); return MovementActionFunc_xA7_1(objectEvent, sprite); } -bool8 MovementActionFunc_xA7_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA7_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065040(objectEvent, sprite)) { @@ -6180,13 +7011,13 @@ bool8 MovementActionFunc_xA7_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_xA8_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA8_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066128(objectEvent, sprite, DIR_WEST); return MovementActionFunc_xA8_1(objectEvent, sprite); } -bool8 MovementActionFunc_xA8_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA8_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065040(objectEvent, sprite)) { @@ -6196,13 +7027,13 @@ bool8 MovementActionFunc_xA8_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_xA9_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA9_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066128(objectEvent, sprite, DIR_EAST); return MovementActionFunc_xA9_1(objectEvent, sprite); } -bool8 MovementActionFunc_xA9_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA9_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065040(objectEvent, sprite)) { @@ -6212,7 +7043,7 @@ bool8 MovementActionFunc_xA9_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementAction_FacePlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_FacePlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 playerObjectId; @@ -6224,7 +7055,7 @@ bool8 MovementAction_FacePlayer_Step0(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 MovementAction_FaceAwayPlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_FaceAwayPlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 playerObjectId; @@ -6236,27 +7067,27 @@ bool8 MovementAction_FaceAwayPlayer_Step0(struct ObjectEvent *objectEvent, struc return TRUE; } -bool8 MovementAction_LockFacingDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_LockFacingDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->facingDirectionLocked = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_UnlockFacingDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_UnlockFacingDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->facingDirectionLocked = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_JumpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_SOUTH, 1, 2); return MovementAction_JumpDown_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6267,13 +7098,13 @@ bool8 MovementAction_JumpDown_Step1(struct ObjectEvent *objectEvent, struct Spri return FALSE; } -bool8 MovementAction_JumpUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_NORTH, 1, 2); return MovementAction_JumpUp_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6284,13 +7115,13 @@ bool8 MovementAction_JumpUp_Step1(struct ObjectEvent *objectEvent, struct Sprite return FALSE; } -bool8 MovementAction_JumpLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_WEST, 1, 2); return MovementAction_JumpLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6301,13 +7132,13 @@ bool8 MovementAction_JumpLeft_Step1(struct ObjectEvent *objectEvent, struct Spri return FALSE; } -bool8 MovementAction_JumpRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_EAST, 1, 2); return MovementAction_JumpRight_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6318,13 +7149,13 @@ bool8 MovementAction_JumpRight_Step1(struct ObjectEvent *objectEvent, struct Spr return FALSE; } -bool8 MovementAction_JumpInPlaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_SOUTH, 0, 0); return MovementAction_JumpInPlaceDown_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6335,13 +7166,13 @@ bool8 MovementAction_JumpInPlaceDown_Step1(struct ObjectEvent *objectEvent, stru return FALSE; } -bool8 MovementAction_JumpInPlaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_NORTH, 0, 0); return MovementAction_JumpInPlaceUp_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6352,13 +7183,13 @@ bool8 MovementAction_JumpInPlaceUp_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_JumpInPlaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_WEST, 0, 0); return MovementAction_JumpInPlaceLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6369,13 +7200,13 @@ bool8 MovementAction_JumpInPlaceLeft_Step1(struct ObjectEvent *objectEvent, stru return FALSE; } -bool8 MovementAction_JumpInPlaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_EAST, 0, 0); return MovementAction_JumpInPlaceRight_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6386,13 +7217,13 @@ bool8 MovementAction_JumpInPlaceRight_Step1(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementAction_JumpInPlaceDownUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceDownUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_SOUTH, 0, 2); return MovementAction_JumpInPlaceDownUp_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceDownUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceDownUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065058(objectEvent, sprite)) { @@ -6403,13 +7234,13 @@ bool8 MovementAction_JumpInPlaceDownUp_Step1(struct ObjectEvent *objectEvent, st return FALSE; } -bool8 MovementAction_JumpInPlaceUpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceUpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_NORTH, 0, 2); return MovementAction_JumpInPlaceUpDown_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceUpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceUpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065058(objectEvent, sprite)) { @@ -6420,13 +7251,13 @@ bool8 MovementAction_JumpInPlaceUpDown_Step1(struct ObjectEvent *objectEvent, st return FALSE; } -bool8 MovementAction_JumpInPlaceLeftRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceLeftRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_WEST, 0, 2); return MovementAction_JumpInPlaceLeftRight_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceLeftRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceLeftRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065058(objectEvent, sprite)) { @@ -6437,13 +7268,13 @@ bool8 MovementAction_JumpInPlaceLeftRight_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_JumpInPlaceRightLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceRightLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { maybe_shadow_1(objectEvent, sprite, DIR_EAST, 0, 2); return MovementAction_JumpInPlaceRightLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceRightLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_JumpInPlaceRightLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065058(objectEvent, sprite)) { @@ -6454,61 +7285,61 @@ bool8 MovementAction_JumpInPlaceRightLeft_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_FaceOriginalDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_FaceOriginalDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { FaceDirection(objectEvent, sprite, gInitialMovementTypeFacingDirections[objectEvent->movementType]); return TRUE; } -bool8 MovementAction_NurseJoyBowDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_NurseJoyBowDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, 0x14); return FALSE; } -bool8 MovementAction_EnableJumpLandingGroundEffect_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_EnableJumpLandingGroundEffect_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->disableJumpLandingGroundEffect = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_DisableJumpLandingGroundEffect_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_DisableJumpLandingGroundEffect_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->disableJumpLandingGroundEffect = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_DisableAnimation_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_DisableAnimation_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->inanimate = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_RestoreAnimation_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RestoreAnimation_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->inanimate = GetObjectEventGraphicsInfo(objectEvent->graphicsId)->inanimate; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_SetInvisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SetInvisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->invisible = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_SetVisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SetVisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->invisible = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_EmoteExclamationMark_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_EmoteExclamationMark_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON); @@ -6516,7 +7347,7 @@ bool8 MovementAction_EmoteExclamationMark_Step0(struct ObjectEvent *objectEvent, return TRUE; } -bool8 MovementAction_EmoteQuestionMark_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_EmoteQuestionMark_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_QUESTION_MARK_ICON); @@ -6524,7 +7355,7 @@ bool8 MovementAction_EmoteQuestionMark_Step0(struct ObjectEvent *objectEvent, st return TRUE; } -bool8 MovementAction_EmoteHeart_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_EmoteHeart_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_X_ICON); @@ -6532,7 +7363,7 @@ bool8 MovementAction_EmoteHeart_Step0(struct ObjectEvent *objectEvent, struct Sp return TRUE; } -bool8 do_double_excl_bubble(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 do_double_excl_bubble(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_DOUBLE_EXCL_MARK_ICON); @@ -6540,7 +7371,7 @@ bool8 do_double_excl_bubble(struct ObjectEvent *objectEvent, struct Sprite *spri return TRUE; } -bool8 do_smile_bubble(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 do_smile_bubble(struct ObjectEvent *objectEvent, struct Sprite *sprite) { ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_SMILEY_FACE_ICON); @@ -6548,7 +7379,7 @@ bool8 do_smile_bubble(struct ObjectEvent *objectEvent, struct Sprite *sprite) return TRUE; } -bool8 MovementAction_RevealTrainer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RevealTrainer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (objectEvent->movementType == MOVEMENT_TYPE_HIDDEN) { @@ -6565,7 +7396,7 @@ bool8 MovementAction_RevealTrainer_Step0(struct ObjectEvent *objectEvent, struct return MovementAction_RevealTrainer_Step1(objectEvent, sprite); } -bool8 MovementAction_RevealTrainer_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RevealTrainer_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_80DCBE0(objectEvent)) { @@ -6575,14 +7406,14 @@ bool8 MovementAction_RevealTrainer_Step1(struct ObjectEvent *objectEvent, struct return FALSE; } -bool8 MovementAction_RockSmashBreak_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RockSmashBreak_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { SetAndStartSpriteAnim(sprite, 1, 0); sprite->data[2] = 1; return FALSE; } -bool8 MovementAction_RockSmashBreak_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RockSmashBreak_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (SpriteAnimEnded(sprite)) { @@ -6592,7 +7423,7 @@ bool8 MovementAction_RockSmashBreak_Step1(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementAction_RockSmashBreak_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_RockSmashBreak_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->invisible ^= TRUE; if (WaitForMovementDelay(sprite)) @@ -6603,14 +7434,14 @@ bool8 MovementAction_RockSmashBreak_Step2(struct ObjectEvent *objectEvent, struc return FALSE; } -bool8 MovementAction_CutTree_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_CutTree_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { SetAndStartSpriteAnim(sprite, 1, 0); sprite->data[2] = 1; return FALSE; } -bool8 MovementAction_CutTree_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_CutTree_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (SpriteAnimEnded(sprite)) { @@ -6620,7 +7451,7 @@ bool8 MovementAction_CutTree_Step1(struct ObjectEvent *objectEvent, struct Sprit return FALSE; } -bool8 MovementAction_CutTree_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_CutTree_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->invisible ^= TRUE; if (WaitForMovementDelay(sprite)) @@ -6631,21 +7462,21 @@ bool8 MovementAction_CutTree_Step2(struct ObjectEvent *objectEvent, struct Sprit return FALSE; } -bool8 MovementAction_SetFixedPriority_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_SetFixedPriority_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->fixedPriority = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_ClearFixedPriority_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_ClearFixedPriority_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { objectEvent->fixedPriority = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_InitAffineAnim_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_InitAffineAnim_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; InitSpriteAffineAnim(sprite); @@ -6654,7 +7485,7 @@ bool8 MovementAction_InitAffineAnim_Step0(struct ObjectEvent *objectEvent, struc return TRUE; } -bool8 MovementAction_ClearAffineAnim_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_ClearAffineAnim_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { FreeOamMatrix(sprite->oam.matrixNum); sprite->oam.affineMode = ST_OAM_AFFINE_OFF; @@ -6662,7 +7493,7 @@ bool8 MovementAction_ClearAffineAnim_Step0(struct ObjectEvent *objectEvent, stru return TRUE; } -bool8 MovementAction_WalkDownStartAffine_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkDownStartAffine_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064830(objectEvent, sprite, DIR_SOUTH); sprite->affineAnimPaused = FALSE; @@ -6670,7 +7501,7 @@ bool8 MovementAction_WalkDownStartAffine_Step0(struct ObjectEvent *objectEvent, return MovementAction_WalkDownStartAffine_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkDownStartAffine_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkDownStartAffine_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (an_walk_any_2(objectEvent, sprite)) { @@ -6681,7 +7512,7 @@ bool8 MovementAction_WalkDownStartAffine_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_WalkDownAffine_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkDownAffine_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8064830(objectEvent, sprite, DIR_SOUTH); sprite->affineAnimPaused = FALSE; @@ -6689,7 +7520,7 @@ bool8 MovementAction_WalkDownAffine_Step0(struct ObjectEvent *objectEvent, struc return MovementAction_WalkDownAffine_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkDownAffine_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_WalkDownAffine_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (an_walk_any_2(objectEvent, sprite)) { @@ -6704,104 +7535,104 @@ void sub_8066C70(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 dire { SetObjectEventDirection(objectEvent, direction); ShiftStillObjectEventCoords(objectEvent); - obj_npc_animation_step(objectEvent, sprite, GetFishingDirectionAnimNum(direction)); + obj_npc_animation_step(objectEvent, sprite, GetAcroWheeliePedalDirectionAnimNum(direction)); sprite->animPaused = TRUE; sprite->data[2] = 1; } -bool8 MovementActionFunc_x70_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x70_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066C70(objectEvent, sprite, DIR_SOUTH); return TRUE; } -bool8 MovementActionFunc_x71_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x71_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066C70(objectEvent, sprite, DIR_NORTH); return TRUE; } -bool8 MovementActionFunc_x72_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x72_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066C70(objectEvent, sprite, DIR_WEST); return TRUE; } -bool8 MovementActionFunc_x73_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x73_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066C70(objectEvent, sprite, DIR_EAST); return TRUE; } -bool8 MovementAction_AcroPopWheelieDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, GetAcroWheelieDirectionAnimNum(DIR_SOUTH)); return FALSE; } -bool8 MovementAction_AcroPopWheelieUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_NORTH, GetAcroWheelieDirectionAnimNum(DIR_NORTH)); return FALSE; } -bool8 MovementAction_AcroPopWheelieLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_WEST, GetAcroWheelieDirectionAnimNum(DIR_WEST)); return FALSE; } -bool8 MovementAction_AcroPopWheelieRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_EAST, GetAcroWheelieDirectionAnimNum(DIR_EAST)); return FALSE; } -bool8 MovementAction_AcroEndWheelieFaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroEndWheelieFaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, GetAcroEndWheelieDirectionAnimNum(DIR_SOUTH)); return FALSE; } -bool8 MovementAction_AcroEndWheelieFaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroEndWheelieFaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_NORTH, GetAcroEndWheelieDirectionAnimNum(DIR_NORTH)); return FALSE; } -bool8 MovementAction_AcroEndWheelieFaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroEndWheelieFaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_WEST, GetAcroEndWheelieDirectionAnimNum(DIR_WEST)); return FALSE; } -bool8 MovementAction_AcroEndWheelieFaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroEndWheelieFaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnimInDirection(objectEvent, sprite, DIR_EAST, GetAcroEndWheelieDirectionAnimNum(DIR_EAST)); return FALSE; } -bool8 MovementAction_UnusedAcroActionDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_UnusedAcroActionDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, GetAcroWheeliePedalDirectionAnimNum(DIR_SOUTH)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, GetAcroUnusedActionDirectionAnimNum(DIR_SOUTH)); return FALSE; } -bool8 MovementAction_UnusedAcroActionUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_UnusedAcroActionUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(objectEvent, sprite, DIR_NORTH, GetAcroWheeliePedalDirectionAnimNum(DIR_NORTH)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_NORTH, GetAcroUnusedActionDirectionAnimNum(DIR_NORTH)); return FALSE; } -bool8 MovementAction_UnusedAcroActionLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_UnusedAcroActionLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(objectEvent, sprite, DIR_WEST, GetAcroWheeliePedalDirectionAnimNum(DIR_WEST)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_WEST, GetAcroUnusedActionDirectionAnimNum(DIR_WEST)); return FALSE; } -bool8 MovementAction_UnusedAcroActionRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_UnusedAcroActionRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(objectEvent, sprite, DIR_EAST, GetAcroWheeliePedalDirectionAnimNum(DIR_EAST)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_EAST, GetAcroUnusedActionDirectionAnimNum(DIR_EAST)); return FALSE; } @@ -6812,13 +7643,13 @@ void sub_8066EA0(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 dire DoShadowFieldEffect(objectEvent); } -bool8 MovementAction_AcroWheelieHopFaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopFaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_SOUTH, 0, 1); return MovementAction_AcroWheelieHopFaceDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopFaceDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopFaceDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6829,13 +7660,13 @@ bool8 MovementAction_AcroWheelieHopFaceDown_Step1(struct ObjectEvent *objectEven return FALSE; } -bool8 MovementAction_AcroWheelieHopFaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopFaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_NORTH, 0, 1); return MovementAction_AcroWheelieHopFaceUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopFaceUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopFaceUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6846,13 +7677,13 @@ bool8 MovementAction_AcroWheelieHopFaceUp_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_AcroWheelieHopFaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopFaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_WEST, 0, 1); return MovementAction_AcroWheelieHopFaceLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6863,13 +7694,13 @@ bool8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct ObjectEvent *objectEven return FALSE; } -bool8 MovementAction_AcroWheelieHopFaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopFaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_EAST, 0, 1); return MovementAction_AcroWheelieHopFaceRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopFaceRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopFaceRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6880,13 +7711,13 @@ bool8 MovementAction_AcroWheelieHopFaceRight_Step1(struct ObjectEvent *objectEve return FALSE; } -bool8 MovementAction_AcroWheelieHopDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_SOUTH, 1, 1); return MovementAction_AcroWheelieHopDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6897,13 +7728,13 @@ bool8 MovementAction_AcroWheelieHopDown_Step1(struct ObjectEvent *objectEvent, s return FALSE; } -bool8 MovementAction_AcroWheelieHopUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_NORTH, 1, 1); return MovementAction_AcroWheelieHopUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6914,13 +7745,13 @@ bool8 MovementAction_AcroWheelieHopUp_Step1(struct ObjectEvent *objectEvent, str return FALSE; } -bool8 MovementAction_AcroWheelieHopLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_WEST, 1, 1); return MovementAction_AcroWheelieHopLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6931,13 +7762,13 @@ bool8 MovementAction_AcroWheelieHopLeft_Step1(struct ObjectEvent *objectEvent, s return FALSE; } -bool8 MovementAction_AcroWheelieHopRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_EAST, 1, 1); return MovementAction_AcroWheelieHopRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieHopRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6948,13 +7779,13 @@ bool8 MovementAction_AcroWheelieHopRight_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_AcroWheelieJumpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieJumpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_SOUTH, 2, 0); return MovementAction_AcroWheelieJumpDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieJumpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieJumpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6965,13 +7796,13 @@ bool8 MovementAction_AcroWheelieJumpDown_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_AcroWheelieJumpUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieJumpUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_NORTH, 2, 0); return MovementAction_AcroWheelieJumpUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieJumpUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieJumpUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6982,13 +7813,13 @@ bool8 MovementAction_AcroWheelieJumpUp_Step1(struct ObjectEvent *objectEvent, st return FALSE; } -bool8 MovementAction_AcroWheelieJumpLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieJumpLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_WEST, 2, 0); return MovementAction_AcroWheelieJumpLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieJumpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieJumpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -6999,13 +7830,13 @@ bool8 MovementAction_AcroWheelieJumpLeft_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_AcroWheelieJumpRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieJumpRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8066EA0(objectEvent, sprite, DIR_EAST, 2, 0); return MovementAction_AcroWheelieJumpRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieJumpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieJumpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_8065028(objectEvent, sprite)) { @@ -7016,27 +7847,27 @@ bool8 MovementAction_AcroWheelieJumpRight_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementActionFunc_x88_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x88_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80656C4(objectEvent, sprite, DIR_SOUTH, GetFishingDirectionAnimNum(DIR_SOUTH), 8); + sub_80656C4(objectEvent, sprite, DIR_SOUTH, GetAcroWheeliePedalDirectionAnimNum(DIR_SOUTH), 8); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementActionFunc_x89_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x89_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80656C4(objectEvent, sprite, DIR_NORTH, GetFishingDirectionAnimNum(DIR_NORTH), 8); + sub_80656C4(objectEvent, sprite, DIR_NORTH, GetAcroWheeliePedalDirectionAnimNum(DIR_NORTH), 8); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementActionFunc_x8A_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x8A_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80656C4(objectEvent, sprite, DIR_WEST, GetFishingDirectionAnimNum(DIR_WEST), 8); + sub_80656C4(objectEvent, sprite, DIR_WEST, GetAcroWheeliePedalDirectionAnimNum(DIR_WEST), 8); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementActionFunc_x8B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x8B_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80656C4(objectEvent, sprite, DIR_EAST, GetFishingDirectionAnimNum(DIR_EAST), 8); + sub_80656C4(objectEvent, sprite, DIR_EAST, GetAcroWheeliePedalDirectionAnimNum(DIR_EAST), 8); return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } @@ -7047,13 +7878,13 @@ void sub_80673E4(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 dire SeekSpriteAnim(sprite, 0); } -bool8 MovementAction_AcroPopWheelieMoveDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieMoveDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80673E4(objectEvent, sprite, DIR_SOUTH, 1); return MovementAction_AcroPopWheelieMoveDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7063,13 +7894,13 @@ bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct ObjectEvent *objectEven return FALSE; } -bool8 MovementAction_AcroPopWheelieMoveUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieMoveUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80673E4(objectEvent, sprite, DIR_NORTH, 1); return MovementAction_AcroPopWheelieMoveUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7079,13 +7910,13 @@ bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_AcroPopWheelieMoveLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieMoveLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80673E4(objectEvent, sprite, DIR_WEST, 1); return MovementAction_AcroPopWheelieMoveLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7095,13 +7926,13 @@ bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct ObjectEvent *objectEven return FALSE; } -bool8 MovementAction_AcroPopWheelieMoveRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieMoveRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_80673E4(objectEvent, sprite, DIR_EAST, 1); return MovementAction_AcroPopWheelieMoveRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7114,16 +7945,16 @@ bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct ObjectEvent *objectEve void sub_806751C(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 speed) { npc_apply_direction(objectEvent, sprite, direction, speed); - npc_apply_anim_looping(objectEvent, sprite, GetFishingDirectionAnimNum(objectEvent->facingDirection)); + npc_apply_anim_looping(objectEvent, sprite, GetAcroWheeliePedalDirectionAnimNum(objectEvent->facingDirection)); } -bool8 MovementAction_AcroWheelieMoveDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieMoveDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_806751C(objectEvent, sprite, DIR_SOUTH, 1); return MovementAction_AcroWheelieMoveDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieMoveDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieMoveDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7133,13 +7964,13 @@ bool8 MovementAction_AcroWheelieMoveDown_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_AcroWheelieMoveUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieMoveUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_806751C(objectEvent, sprite, DIR_NORTH, 1); return MovementAction_AcroWheelieMoveUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7149,13 +7980,13 @@ bool8 MovementAction_AcroWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, st return FALSE; } -bool8 MovementAction_AcroWheelieMoveLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieMoveLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_806751C(objectEvent, sprite, DIR_WEST, 1); return MovementAction_AcroWheelieMoveLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7165,13 +7996,13 @@ bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct ObjectEvent *objectEvent, return FALSE; } -bool8 MovementAction_AcroWheelieMoveRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieMoveRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_806751C(objectEvent, sprite, DIR_EAST, 1); return MovementAction_AcroWheelieMoveRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieMoveRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_AcroWheelieMoveRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7184,17 +8015,17 @@ bool8 MovementAction_AcroWheelieMoveRight_Step1(struct ObjectEvent *objectEvent, void sub_806764C(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 speed) { npc_apply_direction(objectEvent, sprite, direction, speed); - npc_apply_anim_looping(objectEvent, sprite, GetAcroUnusedActionDirectionAnimNum(objectEvent->facingDirection)); + npc_apply_anim_looping(objectEvent, sprite, sub_80634C0(objectEvent->facingDirection)); SeekSpriteAnim(sprite, 0); } -bool8 MovementActionFunc_x94_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x94_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_806764C(objectEvent, sprite, DIR_SOUTH, 1); return MovementActionFunc_x94_1(objectEvent, sprite); } -bool8 MovementActionFunc_x94_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x94_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7204,13 +8035,13 @@ bool8 MovementActionFunc_x94_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x95_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x95_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_806764C(objectEvent, sprite, DIR_NORTH, 1); return MovementActionFunc_x95_1(objectEvent, sprite); } -bool8 MovementActionFunc_x95_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x95_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7220,13 +8051,13 @@ bool8 MovementActionFunc_x95_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x96_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x96_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_806764C(objectEvent, sprite, DIR_WEST, 1); return MovementActionFunc_x96_1(objectEvent, sprite); } -bool8 MovementActionFunc_x96_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x96_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7236,13 +8067,13 @@ bool8 MovementActionFunc_x96_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x97_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x97_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_806764C(objectEvent, sprite, DIR_EAST, 1); return MovementActionFunc_x97_1(objectEvent, sprite); } -bool8 MovementActionFunc_x97_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x97_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { @@ -7252,7 +8083,7 @@ bool8 MovementActionFunc_x97_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x98_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x98_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnim(sprite, 20); sprite->animPaused = FALSE; @@ -7265,12 +8096,12 @@ bool8 MovementActionFunc_x98_0(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x98_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x98_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { return sprite->animEnded; } -bool8 MovementActionFunc_x99_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x99_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { s32 y; switch (sprite->data[7]) @@ -7317,7 +8148,7 @@ bool8 MovementActionFunc_x99_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x9A_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9A_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { bool8 ret; sprite->data[7] = (sprite->data[7] + 4) & 0xFF; @@ -7329,7 +8160,7 @@ bool8 MovementActionFunc_x9A_1(struct ObjectEvent *objectEvent, struct Sprite *s return ret; } -bool8 MovementActionFunc_x9F_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9F_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { StartSpriteAnim(sprite, 28); sprite->animPaused = FALSE; @@ -7338,7 +8169,7 @@ bool8 MovementActionFunc_x9F_0(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_x9F_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_x9F_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { return sprite->animEnded; } @@ -7348,20 +8179,20 @@ u8 MovementAction_Finish(struct ObjectEvent *objectEvent, struct Sprite *sprite) return TRUE; } -bool8 MovementAction_PauseSpriteAnim(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementAction_PauseSpriteAnim(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->animPaused = TRUE; return TRUE; } -bool8 MovementActionFunc_xA4_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA4_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->pos2.y = 0; sprite->data[2]++; return FALSE; } -bool8 MovementActionFunc_xA4_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA4_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->pos2.y -= 8; if (sprite->pos2.y == -160) @@ -7369,14 +8200,14 @@ bool8 MovementActionFunc_xA4_1(struct ObjectEvent *objectEvent, struct Sprite *s return FALSE; } -bool8 MovementActionFunc_xA5_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA5_0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->pos2.y = -160; sprite->data[2]++; return FALSE; } -bool8 MovementActionFunc_xA5_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) +static bool8 MovementActionFunc_xA5_1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->pos2.y += 8; if (sprite->pos2.y == 0) diff --git a/src/field_camera.c b/src/field_camera.c index 40ab8f464..f383b2a27 100644 --- a/src/field_camera.c +++ b/src/field_camera.c @@ -7,7 +7,7 @@ #include "new_menu_helpers.h" #include "overworld.h" -EWRAM_DATA bool8 gUnusedBikeCameraAheadPanback = FALSE; +EWRAM_DATA bool8 gBikeCameraAheadPanback = FALSE; // Static type declarations struct FieldCameraOffset @@ -531,7 +531,7 @@ static void CameraPanningCB_PanAhead(void) { u8 var; - if (gUnusedBikeCameraAheadPanback == FALSE) + if (gBikeCameraAheadPanback == FALSE) { InstallCameraPanAheadCallback(); } diff --git a/src/field_control_avatar.c b/src/field_control_avatar.c index 89b90ca92..286f7519a 100644 --- a/src/field_control_avatar.c +++ b/src/field_control_avatar.c @@ -105,11 +105,11 @@ void FieldGetPlayerInput(struct FieldInput *input, u16 newKeys, u16 heldKeys) { if (GetPlayerSpeed() != 4) { - if ((newKeys & START_BUTTON) && !(gPlayerAvatar.flags & 0x40)) + if ((newKeys & START_BUTTON) && !(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_FISHING)) input->pressedStartButton = TRUE; if (gQuestLogState != QL_STATE_2 && gQuestLogState != QL_STATE_3) { - if (!(gPlayerAvatar.flags & 0x40)) + if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_FISHING)) { if (newKeys & SELECT_BUTTON) input->pressedSelectButton = TRUE; @@ -308,7 +308,7 @@ void FieldInput_HandleCancelSignpost(struct FieldInput * input) { if (input->dpadDirection != 0 && GetPlayerFacingDirection() != input->dpadDirection) { - if (sub_80699D4() == TRUE) + if (IsMsgBoxWalkawayDisabled() == TRUE) return; if (input->dpadDirection == DIR_NORTH) RegisterQuestLogInput(QL_INPUT_UP); @@ -625,7 +625,7 @@ static bool8 TryStartStepBasedScript(struct MapPosition *position, u16 metatileB return TRUE; if (TryStartStepCountScript(metatileBehavior) == TRUE) return TRUE; - if (!(gPlayerAvatar.flags & 0x40) && !MetatileBehavior_IsForcedMovementTile(metatileBehavior) && UpdateRepelCounter() == TRUE) + if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_FISHING) && !MetatileBehavior_IsForcedMovementTile(metatileBehavior) && UpdateRepelCounter() == TRUE) return TRUE; return FALSE; } @@ -655,11 +655,11 @@ static bool8 TryStartStepCountScript(u16 metatileBehavior) UpdateHappinessStepCounter(); - if (!(gPlayerAvatar.flags & 0x40) && !MetatileBehavior_IsForcedMovementTile(metatileBehavior)) + if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_FISHING) && !MetatileBehavior_IsForcedMovementTile(metatileBehavior)) { - if (sub_810C4EC() == TRUE) + if (UpdateVsSeekerStepCounter() == TRUE) { - ScriptContext1_SetupScript(gUnknown_81A8CED); + ScriptContext1_SetupScript(EventScript_VsSeekerChargingDone); return TRUE; } else if (UpdatePoisonStepCounter() == TRUE) @@ -839,7 +839,7 @@ static bool8 TryArrowWarp(struct MapPosition *position, u16 metatileBehavior, u8 else if (sub_806DB84(metatileBehavior, direction) == TRUE) { delay = 0; - if (gPlayerAvatar.flags & 6) + if (gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE)) { SetPlayerAvatarTransitionFlags(1); delay = 12; @@ -906,7 +906,7 @@ static bool8 IsWarpMetatileBehavior(u16 metatileBehavior) return TRUE; if (MetatileBehavior_IsEscalator(metatileBehavior) == TRUE) return TRUE; - if (MetatileBehavior_IsCaveDoor(metatileBehavior) == TRUE) + if (MetatileBehavior_IsNonAnimDoor(metatileBehavior) == TRUE) return TRUE; if (MetatileBehavior_IsLavaridgeB1FWarp(metatileBehavior) == TRUE) return TRUE; @@ -1086,7 +1086,7 @@ void sub_806DE70(u16 x, u16 y) { if (events[i].x + 7 == x && events[i].y + 7 == y) { - sub_8112364(); + QuestLog_OnInteractionWithSpecialNpc(); ScriptContext1_SetupScript(events[i].script); ScriptContext2_Enable(); } diff --git a/src/field_effect.c b/src/field_effect.c index 082aee32d..b8269ae46 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -2064,7 +2064,7 @@ static void EscapeRopeFieldEffect_Step1(struct Task * task) if (data[4] == 1 && !gPaletteFade.active && BGMusicStopped() == TRUE) { SetObjectEventDirection(playerObj, task->data[15]); - sub_80555E0(); + SetWarpDestinationToEscapeWarp(); WarpIntoMap(); gFieldCallback = FieldCallback_EscapeRopeExit; SetMainCallback2(CB2_LoadMap); @@ -2331,7 +2331,7 @@ static void TeleportFieldEffectTask4(struct Task * task) { if (BGMusicStopped() == TRUE) { - copy_saved_warp3_bank_and_enter_x_to_warp1(); + SetWarpDestinationToLastHealLocation(); WarpIntoMap(); SetMainCallback2(CB2_LoadMap); gFieldCallback = FieldCallback_TeleportIn; @@ -2888,8 +2888,8 @@ u8 FldEff_UseSurf(void) { u8 taskId = CreateTask(Task_FldEffUseSurf, 0xff); gTasks[taskId].data[15] = gFieldEffectArguments[0]; - sav1_reset_battle_music_maybe(); - if (sub_8056124(MUS_NAMINORI)) + Overworld_ClearSavedMusic(); + if (Overworld_MusicCanOverrideMapMusic(MUS_NAMINORI)) Overworld_ChangeMusicTo(MUS_NAMINORI); return FALSE; } diff --git a/src/field_fadetransition.c b/src/field_fadetransition.c index 10d6b3d72..bf5ab0ab3 100644 --- a/src/field_fadetransition.c +++ b/src/field_fadetransition.c @@ -29,9 +29,9 @@ static void sub_807DF4C(u8 a0); static void sub_807DFBC(u8 taskId); static void task_map_chg_seq_0807E20C(u8 taskId); static void task_map_chg_seq_0807E2CC(u8 taskId); -static void sub_807E31C(u8 taskId); +static void Task_TeleportWarpIn(u8 taskId); static void sub_807E718(u8 taskId); -static void sub_807E784(u8 taskId); +static void Task_TeleportWarp(u8 taskId); static void sub_807E80C(u8 taskId); static void sub_807E980(u8 taskId); static void sub_807EB64(u16, s16*, s16*); @@ -94,7 +94,7 @@ void FadeInFromBlack(void) void WarpFadeOutScreen(void) { - const struct MapHeader *header = warp1_get_mapheader(); + const struct MapHeader *header = GetDestinationWarpMapHeader(); if (header->regionMapSectionId != gMapHeader.regionMapSectionId && MapHasPreviewScreen(header->regionMapSectionId, MPS_TYPE_CAVE)) FadeScreen(FADE_TO_BLACK, 0); else @@ -113,7 +113,7 @@ void WarpFadeOutScreen(void) static void sub_807DC70(void) { - switch (MapTransitionIsEnter(GetCurrentMapType(), warp1_get_mapheader()->mapType)) + switch (MapTransitionIsEnter(GetCurrentMapType(), GetDestinationWarpMapHeader()->mapType)) { case FALSE: FadeScreen(FADE_TO_BLACK, 3); @@ -126,12 +126,12 @@ static void sub_807DC70(void) static void sub_807DCB0(bool8 arg) { - sub_805CB04(!arg); + SetPlayerInvisibility(!arg); } static void task0A_nop_for_a_while(u8 taskId) { - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) DestroyTask(taskId); } @@ -145,14 +145,14 @@ void sub_807DCE4(void) static void task0A_asap_script_env_2_enable_and_set_ctx_running(u8 taskId) { - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) { DestroyTask(taskId); EnableBothScriptContexts(); } } -void FieldCallback_ReturnToEventScript2(void) +void FieldCB_ContinueScriptHandleMusic(void) { ScriptContext2_Enable(); Overworld_PlaySpecialMapMusic(); @@ -160,7 +160,7 @@ void FieldCallback_ReturnToEventScript2(void) CreateTask(task0A_asap_script_env_2_enable_and_set_ctx_running, 10); } -void sub_807DD44(void) +void FieldCB_ContinueScript(void) { ScriptContext2_Enable(); FadeInFromBlack(); @@ -184,7 +184,7 @@ static void task_mpl_807DD60(u8 taskId) } break; case 2: - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) { ScriptContext2_Disable(); DestroyTask(taskId); @@ -193,7 +193,7 @@ static void task_mpl_807DD60(u8 taskId) } } -void FieldCB_ReturnToFieldWiredLink(void) +void FieldCB_ReturnToFieldCableLink(void) { ScriptContext2_Enable(); Overworld_PlaySpecialMapMusic(); @@ -218,7 +218,7 @@ static void sub_807DDF0(u8 taskId) } break; case 2: - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) { sub_8009FE8(); ScriptContext2_Disable(); @@ -260,7 +260,7 @@ static void sub_807DE78(bool8 a0) else { sub_807DF4C(a0); - if (MetatileBehavior_IsCaveDoor(behavior) == TRUE) + if (MetatileBehavior_IsNonAnimDoor(behavior) == TRUE) func = task_map_chg_seq_0807E20C; else if (MetatileBehavior_IsUnknownWarp6C_to_6F(behavior) == TRUE) { @@ -284,7 +284,7 @@ static void sub_807DF4C(bool8 a0) FadeInFromBlack(); } -void sub_807DF64(void) +void FieldCB_DefaultWarpExit(void) { Overworld_PlaySpecialMapMusic(); sub_8111CF0(); @@ -292,7 +292,7 @@ void sub_807DF64(void) ScriptContext2_Enable(); } -void sub_807DF7C(void) +void FieldCB_WarpExitFadeFromBlack(void) { Overworld_PlaySpecialMapMusic(); sub_8111CF0(); @@ -300,13 +300,13 @@ void sub_807DF7C(void) ScriptContext2_Enable(); } -static void sub_807DF94(void) +static void FieldCB_TeleportWarpIn(void) { Overworld_PlaySpecialMapMusic(); WarpFadeInScreen(); sub_8111CF0(); PlaySE(SE_TK_WARPOUT); - CreateTask(sub_807E31C, 10); + CreateTask(Task_TeleportWarpIn, 10); ScriptContext2_Enable(); } @@ -363,7 +363,7 @@ static void sub_807DFBC(u8 taskId) } break; case 9: - if (sub_807E418() && walkrun_is_standing_still() && !FieldIsDoorAnimationRunning() && !FuncIsActiveTask(Task_BarnDoorWipe)) + if (FieldFadeTransitionBackgroundEffectIsFinished() && walkrun_is_standing_still() && !FieldIsDoorAnimationRunning() && !FuncIsActiveTask(Task_BarnDoorWipe)) { ObjectEventClearHeldMovementIfFinished(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)]); task->data[0] = 4; @@ -371,7 +371,7 @@ static void sub_807DFBC(u8 taskId) break; // Legacy RS case 1: - if (sub_807E418()) + if (FieldFadeTransitionBackgroundEffectIsFinished()) { sub_807DCB0(TRUE); ObjectEventSetHeldMovement(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)], MOVEMENT_ACTION_WALK_NORMAL_DOWN); @@ -413,7 +413,7 @@ static void task_map_chg_seq_0807E20C(u8 taskId) task->data[0] = 1; break; case 1: - if (sub_807E418()) + if (FieldFadeTransitionBackgroundEffectIsFinished()) { sub_807DCB0(TRUE); ObjectEventSetHeldMovement(&gObjectEvents[GetObjectEventIdByLocalIdAndMap(0xFF, 0, 0)], GetWalkNormalMovementAction(GetPlayerFacingDirection())); @@ -444,7 +444,7 @@ static void task_map_chg_seq_0807E2CC(u8 taskId) gTasks[taskId].data[0]++; break; case 1: - if (sub_807E418()) + if (FieldFadeTransitionBackgroundEffectIsFinished()) { UnfreezeObjectEvents(); ScriptContext2_Disable(); @@ -454,18 +454,18 @@ static void task_map_chg_seq_0807E2CC(u8 taskId) } } -static void sub_807E31C(u8 taskId) +static void Task_TeleportWarpIn(u8 taskId) { switch (gTasks[taskId].data[0]) { case 0: FreezeObjectEvents(); ScriptContext2_Enable(); - sub_805DC04(); + StartTeleportInPlayerAnim(); gTasks[taskId].data[0]++; break; case 1: - if (sub_807E418() && sub_805DC24() != TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() && WaitTeleportInPlayerAnim() != TRUE) { UnfreezeObjectEvents(); ScriptContext2_Disable(); @@ -477,7 +477,7 @@ static void sub_807E31C(u8 taskId) static void Task_WaitFadeAndCreateStartMenuTask(u8 taskId) { - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) { DestroyTask(taskId); CreateTask(Task_StartMenuHandleInput, 80); @@ -491,7 +491,7 @@ void FadeTransition_FadeInOnReturnToStartMenu(void) ScriptContext2_Enable(); } -bool8 FieldCB2_ReturnToStartMenuInit(void) +bool8 FieldCB_ReturnToFieldOpenStartMenu(void) { SetUpReturnToStartMenu(); return FALSE; @@ -499,7 +499,7 @@ bool8 FieldCB2_ReturnToStartMenuInit(void) static void task_mpl_807E3C8(u8 taskId) { - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) { ScriptContext2_Disable(); DestroyTask(taskId); @@ -515,12 +515,12 @@ void sub_807E3EC(void) CreateTask(task_mpl_807E3C8, 10); } -static bool32 sub_807E40C(void) +static bool32 WaitWarpFadeOutScreen(void) { return gPaletteFade.active; } -bool32 sub_807E418(void) +bool32 FieldFadeTransitionBackgroundEffectIsFinished(void) { if (IsWeatherNotFadingIn() == TRUE && ForestMapPreviewScreenIsRunning()) return TRUE; @@ -535,7 +535,7 @@ void DoWarp(void) WarpFadeOutScreen(); PlayRainStoppingSoundEffect(); PlaySE(SE_KAIDAN); - gFieldCallback = sub_807DF64; + gFieldCallback = FieldCB_DefaultWarpExit; CreateTask(sub_807E718, 10); } @@ -545,7 +545,7 @@ void DoDiveWarp(void) TryFadeOutOldMapMusic(); WarpFadeOutScreen(); PlayRainStoppingSoundEffect(); - gFieldCallback = sub_807DF64; + gFieldCallback = FieldCB_DefaultWarpExit; CreateTask(sub_807E718, 10); } @@ -560,7 +560,7 @@ void sub_807E4A0(u16 metatileBehavior, u16 delay) void DoDoorWarp(void) { ScriptContext2_Enable(); - gFieldCallback = sub_807DF64; + gFieldCallback = FieldCB_DefaultWarpExit; CreateTask(sub_807E80C, 10); } @@ -568,14 +568,14 @@ void sub_807E500(void) { ScriptContext2_Enable(); CreateTask(sub_807E718, 10); - gFieldCallback = sub_807DF94; + gFieldCallback = FieldCB_TeleportWarpIn; } void DoUnionRoomWarp(void) { ScriptContext2_Enable(); - gFieldCallback = sub_807DF64; - CreateTask(sub_807E784, 10); + gFieldCallback = FieldCB_DefaultWarpExit; + CreateTask(Task_TeleportWarp, 10); } void DoFallWarp(void) @@ -606,8 +606,8 @@ void DoTeleportWarp(void) { ScriptContext2_Enable(); TryFadeOutOldMapMusic(); - CreateTask(sub_807E784, 10); - gFieldCallback = sub_807DF94; + CreateTask(Task_TeleportWarp, 10); + gFieldCallback = FieldCB_TeleportWarpIn; } void sub_807E5C4(void) @@ -628,7 +628,7 @@ static void sub_807E5EC(u8 taskId) task->data[0]++; break; case 1: - if (!sub_807E40C() && BGMusicStopped()) + if (!WaitWarpFadeOutScreen() && BGMusicStopped()) task->data[0]++; break; case 2: @@ -661,7 +661,7 @@ static void sub_807E678(u8 taskId) data[0]++; break; case 1: - if (!sub_807E40C() && BGMusicStopped()) + if (!WaitWarpFadeOutScreen() && BGMusicStopped()) { Link_TryStartSend5FFF(); data[0]++; @@ -694,7 +694,7 @@ static void sub_807E718(u8 taskId) task->data[0]++; break; case 1: - if (!sub_807E40C() && BGMusicStopped()) + if (!WaitWarpFadeOutScreen() && BGMusicStopped()) task->data[0]++; break; case 2: @@ -705,7 +705,7 @@ static void sub_807E718(u8 taskId) } } -static void sub_807E784(u8 taskId) +static void Task_TeleportWarp(u8 taskId) { struct Task *task = &gTasks[taskId]; switch (task->data[0]) @@ -714,18 +714,18 @@ static void sub_807E784(u8 taskId) FreezeObjectEvents(); ScriptContext2_Enable(); PlaySE(SE_TK_WARPIN); - sub_805DAB0(); + StartTeleportWarpOutPlayerAnim(); task->data[0]++; break; case 1: - if (!sub_805DAD0()) + if (!WaitTeleportWarpOutPlayerAnim()) { WarpFadeOutScreen(); task->data[0]++; } break; case 2: - if (!sub_807E40C() && BGMusicStopped()) + if (!WaitWarpFadeOutScreen() && BGMusicStopped()) task->data[0]++; break; case 3: @@ -829,11 +829,11 @@ static void sub_807E980(u8 taskId) break; case 3: sub_807EAC4(data[2], data[3], &data[4], &data[5], &data[6]); - if (!sub_807E40C() && BGMusicStopped()) + if (!WaitWarpFadeOutScreen() && BGMusicStopped()) data[0]++; break; default: - gFieldCallback = sub_807DF64; + gFieldCallback = FieldCB_DefaultWarpExit; WarpIntoMap(); SetMainCallback2(CB2_LoadMap); DestroyTask(taskId); @@ -898,7 +898,7 @@ static void sub_807EC34(u8 taskId) switch (data[0]) { default: - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) { CameraObjectReset1(); ScriptContext2_Disable(); diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c new file mode 100644 index 000000000..7e3ba59fe --- /dev/null +++ b/src/field_player_avatar.c @@ -0,0 +1,2164 @@ +#include "global.h" +#include "gflib.h" +#include "bike.h" +#include "event_data.h" +#include "event_object_movement.h" +#include "fieldmap.h" +#include "field_camera.h" +#include "field_control_avatar.h" +#include "field_effect.h" +#include "field_effect_helpers.h" +#include "field_player_avatar.h" +#include "help_system.h" +#include "metatile_behavior.h" +#include "new_menu_helpers.h" +#include "overworld.h" +#include "party_menu.h" +#include "quest_log.h" +#include "quest_log_player.h" +#include "random.h" +#include "script.h" +#include "strings.h" +#include "wild_encounter.h" +#include "constants/event_object_movement.h" +#include "constants/event_objects.h" +#include "constants/songs.h" +#include "constants/flags.h" +#include "constants/metatile_behaviors.h" +#include "constants/species.h" +#include "constants/moves.h" + +static EWRAM_DATA struct ObjectEvent * gUnknown_2036E30 = NULL; +static EWRAM_DATA u8 sTeleportSavedFacingDirection = DIR_NONE; +EWRAM_DATA struct ObjectEvent gObjectEvents[OBJECT_EVENTS_COUNT] = {}; +EWRAM_DATA struct PlayerAvatar gPlayerAvatar = {}; + +static u8 ObjectEventCB2_NoMovement2(struct ObjectEvent * object, struct Sprite * sprite); +static bool8 sub_805B528(void); +static bool8 TryInterruptObjectEventSpecialAnim(struct ObjectEvent * playerObjEvent, u8 direction); +static void npc_clear_strange_bits(struct ObjectEvent * playerObjEvent); +static bool8 TryDoMetatileBehaviorForcedMovement(void); +static void MovePlayerAvatarUsingKeypadInput(u8 direction, u16 newKeys, u16 heldKeys); +static void PlayerAllowForcedMovementIfMovingSameDirection(void); +static bool8 ForcedMovement_None(void); +static bool8 ForcedMovement_Slip(void); +static bool8 ForcedMovement_WalkSouth(void); +static bool8 ForcedMovement_WalkNorth(void); +static bool8 ForcedMovement_WalkWest(void); +static bool8 ForcedMovement_WalkEast(void); +static bool8 ForcedMovement_SpinRight(void); +static bool8 ForcedMovement_SpinLeft(void); +static bool8 ForcedMovement_SpinUp(void); +static bool8 ForcedMovement_SpinDown(void); +static void PlaySpinSound(void); +static bool8 ForcedMovement_PushedSouthByCurrent(void); +static bool8 ForcedMovement_PushedNorthByCurrent(void); +static bool8 ForcedMovement_PushedWestByCurrent(void); +static bool8 ForcedMovement_PushedEastByCurrent(void); +static bool8 ForcedMovement_SlideSouth(void); +static bool8 ForcedMovement_SlideNorth(void); +static bool8 ForcedMovement_SlideWest(void); +static bool8 ForcedMovement_SlideEast(void); +static bool8 ForcedMovement_0xBB(void); +static bool8 ForcedMovement_0xBC(void); +static u8 CheckMovementInputNotOnBike(u8 direction); +static void PlayerNotOnBikeNotMoving(u8 direction, u16 heldKeys); +static void PlayerNotOnBikeTurningInPlace(u8 direction, u16 heldKeys); +static void PlayerNotOnBikeMoving(u8 direction, u16 heldKeys); +static u8 CheckForPlayerAvatarCollision(u8 direction); +static bool8 CanStopSurfing(s16 x, s16 y, u8 direction); +static bool8 ShouldJumpLedge(s16 x, s16 y, u8 direction); +static bool8 TryPushBoulder(s16 x, s16 y, u8 direction); +static void CheckAcroBikeCollision(s16 x, s16 y, u8 metatileBehavior, u8 *collision); +static void DoPlayerAvatarTransition(void); +static void PlayerAvatarTransition_Dummy(struct ObjectEvent * playerObject); +static void PlayerAvatarTransition_Normal(struct ObjectEvent * playerObject); +static void PlayerAvatarTransition_Bike(struct ObjectEvent * playerObject); +static void PlayerAvatarTransition_Surfing(struct ObjectEvent * playerObject); +static void PlayerAvatarTransition_Underwater(struct ObjectEvent * playerObject); +static void PlayerAvatarTransition_ReturnToField(struct ObjectEvent * playerObject); +static bool8 PlayerIsAnimActive(void); +static bool8 PlayerCheckIfAnimFinishedOrInactive(void); +static bool8 player_is_anim_in_certain_ranges(void); +static bool8 sub_805BF58(void); +static void PlayCollisionSoundIfNotFacingWarp(u8 direction); +static void PlayerGoSpin(u8 direction); +static void sub_805C2CC(u8 metatileBehavior); +static bool8 MetatileAtCoordsIsWaterTile(s16 x, s16 y); +static void sub_805CC40(struct ObjectEvent * playerObjEvent); +static void StartStrengthAnim(u8 objectEventId, u8 direction); +static void Task_BumpBoulder(u8 taskId); +static bool8 sub_805CD64(struct Task * task, struct ObjectEvent * playerObj, struct ObjectEvent * boulderObj); +static bool8 do_boulder_dust(struct Task * task, struct ObjectEvent * playerObj, struct ObjectEvent * boulderObj); +static bool8 sub_805CE20(struct Task * task, struct ObjectEvent * playerObj, struct ObjectEvent * boulderObj); +static void DoPlayerMatJump(void); +static void DoPlayerAvatarSecretBaseMatJump(u8 taskId); +static bool8 PlayerAvatar_DoSecretBaseMatJump(struct Task * task, struct ObjectEvent * playerObj); +static void DoPlayerMatSpin(void); +static void PlayerAvatar_DoSecretBaseMatSpin(u8 taskId); +static bool8 PlayerAvatar_SecretBaseMatSpinStep0(struct Task * task, struct ObjectEvent * playerObj); +static bool8 PlayerAvatar_SecretBaseMatSpinStep1(struct Task * task, struct ObjectEvent * playerObj); +static bool8 PlayerAvatar_SecretBaseMatSpinStep2(struct Task * task, struct ObjectEvent * playerObj); +static bool8 PlayerAvatar_SecretBaseMatSpinStep3(struct Task * task, struct ObjectEvent * playerObj); +static void CreateStopSurfingTask(u8 direction); +static void Task_StopSurfingInit(u8 taskId); +static void Task_WaitStopSurfing(u8 taskId); +static void Task_Fishing(u8 taskId); +static bool8 Fishing1(struct Task * task); +static bool8 Fishing2(struct Task * task); +static bool8 Fishing3(struct Task * task); +static bool8 Fishing4(struct Task * task); +static bool8 Fishing5(struct Task * task); +static bool8 Fishing6(struct Task * task); +static bool8 Fishing7(struct Task * task); +static bool8 Fishing8(struct Task * task); +static bool8 Fishing9(struct Task * task); +static bool8 Fishing10(struct Task * task); +static bool8 Fishing11(struct Task * task); +static bool8 Fishing12(struct Task * task); +static bool8 Fishing13(struct Task * task); +static bool8 Fishing14(struct Task * task); +static bool8 Fishing15(struct Task * task); +static bool8 Fishing16(struct Task * task); +static void Task_TeleportWarpOutPlayerAnim(u8 taskId); +static void Task_TeleportWarpInPlayerAnim(u8 taskId); +static u8 TeleportAnim_RotatePlayer(struct ObjectEvent * object, s16 *timer); + +void MovementType_Player(struct Sprite *sprite) +{ + UpdateObjectEventCurrentMovement(&gObjectEvents[sprite->data[0]], sprite, ObjectEventCB2_NoMovement2); +} + +static u8 ObjectEventCB2_NoMovement2(struct ObjectEvent * object, struct Sprite * sprite) +{ + return 0; +} + +void player_step(u8 direction, u16 newKeys, u16 heldKeys) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + sub_805CC40(playerObjEvent); + if (!gPlayerAvatar.preventStep && !sub_805B528()) + { + if (!TryInterruptObjectEventSpecialAnim(playerObjEvent, direction)) + { + npc_clear_strange_bits(playerObjEvent); + DoPlayerAvatarTransition(); + if (!TryDoMetatileBehaviorForcedMovement()) + { + MovePlayerAvatarUsingKeypadInput(direction, newKeys, heldKeys); + PlayerAllowForcedMovementIfMovingSameDirection(); + } + } + } +} + +static bool8 TryInterruptObjectEventSpecialAnim(struct ObjectEvent *playerObjEvent, u8 direction) +{ + + if (ObjectEventIsMovementOverridden(playerObjEvent) + && !ObjectEventClearHeldMovementIfFinished(playerObjEvent)) + { + u8 heldMovementActionId = ObjectEventGetHeldMovementActionId(playerObjEvent); + if (heldMovementActionId > MOVEMENT_ACTION_WALK_FAST_RIGHT && heldMovementActionId < MOVEMENT_ACTION_WALK_IN_PLACE_NORMAL_DOWN) + { + if (direction != DIR_NONE && playerObjEvent->movementDirection != direction) + { + ObjectEventClearHeldMovement(playerObjEvent); + return FALSE; + } + } + + return TRUE; + } + + return FALSE; +} + +static void npc_clear_strange_bits(struct ObjectEvent *objEvent) +{ + objEvent->inanimate = FALSE; + objEvent->disableAnim = FALSE; + objEvent->facingDirectionLocked = FALSE; + gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_WATERING; +} + +static void MovePlayerAvatarUsingKeypadInput(u8 direction, u16 newKeys, u16 heldKeys) +{ + if ((gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_MACH_BIKE) + || (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_ACRO_BIKE)) + MovePlayerOnBike(direction, newKeys, heldKeys); + else + MovePlayerNotOnBike(direction, heldKeys); +} + +static void PlayerAllowForcedMovementIfMovingSameDirection(void) +{ + if (gPlayerAvatar.runningState == MOVING) + gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_FIELD_MOVE; +} + +static bool8 sub_805B528(void) +{ + if ((gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_FISHING) && MetatileBehavior_IsSpinTile(gPlayerAvatar.lastSpinTile)) + { + gUnknown_2036E30 = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (gUnknown_2036E30->heldMovementFinished) + { + if (MetatileBehavior_IsStopSpinning(gUnknown_2036E30->currentMetatileBehavior)) + { + return FALSE; + } + if (MetatileBehavior_IsSpinTile(gUnknown_2036E30->currentMetatileBehavior)) + { + gPlayerAvatar.lastSpinTile = gUnknown_2036E30->currentMetatileBehavior; + } + ObjectEventClearHeldMovement(gUnknown_2036E30); + sub_805C2CC(gPlayerAvatar.lastSpinTile); + } + return TRUE; + } + return FALSE; +} + +static const struct { + bool8 (*unk0)(u8 metatileBehavior); + bool8 (*unk4)(void); +} sForcedMovementFuncs[] = { + {MetatileBehavior_IsUnknownMovement48, ForcedMovement_Slip}, + {MetatileBehavior_IsIce_2, ForcedMovement_Slip}, + {MetatileBehavior_IsWalkSouth, ForcedMovement_WalkSouth}, + {MetatileBehavior_IsWalkNorth, ForcedMovement_WalkNorth}, + {MetatileBehavior_IsWalkWest, ForcedMovement_WalkWest}, + {MetatileBehavior_IsWalkEast, ForcedMovement_WalkEast}, + {MetatileBehavior_IsSouthwardCurrent, ForcedMovement_PushedSouthByCurrent}, + {MetatileBehavior_IsNorthwardCurrent, ForcedMovement_PushedNorthByCurrent}, + {MetatileBehavior_IsWestwardCurrent, ForcedMovement_PushedWestByCurrent}, + {MetatileBehavior_IsEastwardCurrent, ForcedMovement_PushedEastByCurrent}, + {MetatileBehavior_IsSpinRight, ForcedMovement_SpinRight}, + {MetatileBehavior_IsSpinLeft, ForcedMovement_SpinLeft}, + {MetatileBehavior_IsSpinUp, ForcedMovement_SpinUp}, + {MetatileBehavior_IsSpinDown, ForcedMovement_SpinDown}, + {MetatileBehavior_IsSlideSouth, ForcedMovement_SlideSouth}, + {MetatileBehavior_IsSlideNorth, ForcedMovement_SlideNorth}, + {MetatileBehavior_IsSlideWest, ForcedMovement_SlideWest}, + {MetatileBehavior_IsSlideEast, ForcedMovement_SlideEast}, + {MetatileBehavior_IsWaterfall, ForcedMovement_PushedSouthByCurrent}, + {MetatileBehavior_UnusedReturnFalse_7, ForcedMovement_0xBB}, + {MetatileBehavior_UnusedReturnFalse_8, ForcedMovement_0xBC}, + {NULL, ForcedMovement_None}, +}; + +static bool8 TryDoMetatileBehaviorForcedMovement(void) +{ + int i; + u8 behavior; + if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_FIELD_MOVE)) + { + behavior = gObjectEvents[gPlayerAvatar.objectEventId].currentMetatileBehavior; + for (i = 0; sForcedMovementFuncs[i].unk0 != NULL; i++) + { + if (sForcedMovementFuncs[i].unk0(behavior)) + { + gPlayerAvatar.lastSpinTile = behavior; + return sForcedMovementFuncs[i].unk4(); + } + } + return sForcedMovementFuncs[i].unk4(); + } + else + { + for (i = 0; sForcedMovementFuncs[i].unk0 != NULL; i++) + ; + return sForcedMovementFuncs[i].unk4(); + } +} + +static bool8 ForcedMovement_None(void) +{ + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_FISHING) + { + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + playerObjEvent->facingDirectionLocked = FALSE; + playerObjEvent->enableAnim = TRUE; + SetObjectEventDirection(playerObjEvent, playerObjEvent->facingDirection); + gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_FISHING; + } + return FALSE; +} + +static u8 DoForcedMovement(u8 direction, MovementAction movementAction) +{ + struct PlayerAvatar *playerAvatar = &gPlayerAvatar; + u8 collision = CheckForPlayerAvatarCollision(direction); + + playerAvatar->flags |= PLAYER_AVATAR_FLAG_FISHING; + if (collision) + { + ForcedMovement_None(); + if (collision < COLLISION_STOP_SURFING) + { + return 0; + } + else + { + if (collision == COLLISION_LEDGE_JUMP) + PlayerJumpLedge(direction); + playerAvatar->flags |= PLAYER_AVATAR_FLAG_FISHING; + playerAvatar->runningState = MOVING; + return 1; + } + } + else + { + playerAvatar->runningState = MOVING; + movementAction(direction); + return 1; + } +} + +static u8 DoForcedMovementInCurrentDirection(MovementAction movementAction) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + playerObjEvent->disableAnim = TRUE; + return DoForcedMovement(playerObjEvent->movementDirection, movementAction); +} + +static bool8 ForcedMovement_Slip(void) +{ + return DoForcedMovementInCurrentDirection(PlayerGoSpeed2); +} + +static bool8 ForcedMovement_WalkSouth(void) +{ + return DoForcedMovement(DIR_SOUTH, PlayerGoSpeed1); +} + +static bool8 ForcedMovement_WalkNorth(void) +{ + return DoForcedMovement(DIR_NORTH, PlayerGoSpeed1); +} + +static bool8 ForcedMovement_WalkWest(void) +{ + return DoForcedMovement(DIR_WEST, PlayerGoSpeed1); +} + +static bool8 ForcedMovement_WalkEast(void) +{ + return DoForcedMovement(DIR_EAST, PlayerGoSpeed1); +} + +static bool8 ForcedMovement_SpinRight(void) +{ + PlaySpinSound(); + return DoForcedMovement(DIR_EAST, PlayerGoSpin); +} + +static bool8 ForcedMovement_SpinLeft(void) +{ + PlaySpinSound(); + return DoForcedMovement(DIR_WEST, PlayerGoSpin); +} + +static bool8 ForcedMovement_SpinUp(void) +{ + PlaySpinSound(); + return DoForcedMovement(DIR_NORTH, PlayerGoSpin); +} + +static bool8 ForcedMovement_SpinDown(void) +{ + PlaySpinSound(); + return DoForcedMovement(DIR_SOUTH, PlayerGoSpin); +} + +static void PlaySpinSound(void) +{ + PlaySE(SE_W013B); +} + +static bool8 ForcedMovement_PushedSouthByCurrent(void) +{ + return DoForcedMovement(DIR_SOUTH, PlayerRideWaterCurrent); +} + +static bool8 ForcedMovement_PushedNorthByCurrent(void) +{ + return DoForcedMovement(DIR_NORTH, PlayerRideWaterCurrent); +} + +static bool8 ForcedMovement_PushedWestByCurrent(void) +{ + return DoForcedMovement(DIR_WEST, PlayerRideWaterCurrent); +} + +static bool8 ForcedMovement_PushedEastByCurrent(void) +{ + return DoForcedMovement(DIR_EAST, PlayerRideWaterCurrent); +} + +static u8 ForcedMovement_Slide(u8 direction, MovementAction movementAction) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + playerObjEvent->disableAnim = TRUE; + playerObjEvent->facingDirectionLocked = TRUE; + return DoForcedMovement(direction, movementAction); +} + +static bool8 ForcedMovement_SlideSouth(void) +{ + return ForcedMovement_Slide(DIR_SOUTH, PlayerGoSpeed2); +} + +static bool8 ForcedMovement_SlideNorth(void) +{ + return ForcedMovement_Slide(DIR_NORTH, PlayerGoSpeed2); +} + +static bool8 ForcedMovement_SlideWest(void) +{ + return ForcedMovement_Slide(DIR_WEST, PlayerGoSpeed2); +} + +static bool8 ForcedMovement_SlideEast(void) +{ + return ForcedMovement_Slide(DIR_EAST, PlayerGoSpeed2); +} + +static bool8 ForcedMovement_0xBB(void) +{ + DoPlayerMatJump(); + return TRUE; +} + +static bool8 ForcedMovement_0xBC(void) +{ + DoPlayerMatSpin(); + return TRUE; +} + +static void (*const gUnknown_835B814[])(u8, u16) = { + PlayerNotOnBikeNotMoving, + PlayerNotOnBikeTurningInPlace, + PlayerNotOnBikeMoving +}; + +void MovePlayerNotOnBike(u8 direction, u16 heldKeys) +{ + gUnknown_835B814[CheckMovementInputNotOnBike(direction)](direction, heldKeys); +} + +static u8 CheckMovementInputNotOnBike(u8 direction) +{ + if (direction == DIR_NONE) + { + gPlayerAvatar.runningState = NOT_MOVING; + return 0; + } + else if (direction != GetPlayerMovementDirection() && gPlayerAvatar.runningState != MOVING) + { + gPlayerAvatar.runningState = TURN_DIRECTION; + return 1; + } + else + { + gPlayerAvatar.runningState = MOVING; + return 2; + } +} + +static void PlayerNotOnBikeNotMoving(u8 direction, u16 heldKeys) +{ + PlayerFaceDirection(GetPlayerFacingDirection()); +} + +static void PlayerNotOnBikeTurningInPlace(u8 direction, u16 heldKeys) +{ + PlayerTurnInPlace(direction); +} + +static void PlayerNotOnBikeMoving(u8 direction, u16 heldKeys) +{ + u8 collision = CheckForPlayerAvatarCollision(direction); + + if (collision != COLLISION_NONE) + { + if (collision == COLLISION_LEDGE_JUMP) + { + PlayerJumpLedge(direction); + } + else if (collision == COLLISION_UNKNOWN_WARP_6C_6D_6E_6F) + { + PlayerFaceDirection(direction); + } + else if (collision != COLLISION_STOP_SURFING && collision != COLLISION_LEDGE_JUMP && collision != COLLISION_PUSHED_BOULDER && collision != COLLISION_UNKNOWN_WARP_6C_6D_6E_6F) + { + PlayerNotOnBikeCollide(direction); + } + return; + } + + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING) + { + // speed 2 is fast, same speed as running + PlayerGoSpeed2(direction); + return; + } + + if ((heldKeys & B_BUTTON) && FlagGet(FLAG_SYS_B_DASH) + && !IsRunningDisallowed(gObjectEvents[gPlayerAvatar.objectEventId].currentMetatileBehavior)) + { + if (PlayerIsMovingOnRockStairs(direction)) + PlayerRunSlow(direction); + else + PlayerRun(direction); + gPlayerAvatar.flags |= PLAYER_AVATAR_FLAG_WATERING; + return; + } + else + { + if (PlayerIsMovingOnRockStairs(direction)) + PlayerGoSlow(direction); + else + PlayerGoSpeed1(direction); + } +} + +bool32 PlayerIsMovingOnRockStairs(u8 direction) +{ + struct ObjectEvent * objectEvent; + s16 x, y; + + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + x = objectEvent->currentCoords.x; + y = objectEvent->currentCoords.y; + switch (direction) + { + case DIR_NORTH: + return MetatileBehavior_IsRockStairs(MapGridGetMetatileBehaviorAt(x, y)); + case DIR_SOUTH: + MoveCoords(DIR_SOUTH, &x, &y); + return MetatileBehavior_IsRockStairs(MapGridGetMetatileBehaviorAt(x, y)); + default: + return FALSE; + } +} + +static u8 CheckForPlayerAvatarCollision(u8 direction) +{ + s16 x, y; + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + x = playerObjEvent->currentCoords.x; + y = playerObjEvent->currentCoords.y; + if (sub_806DB84(MapGridGetMetatileBehaviorAt(x, y), direction)) + return 8; + MoveCoords(direction, &x, &y); + return CheckForObjectEventCollision(playerObjEvent, x, y, direction, MapGridGetMetatileBehaviorAt(x, y)); +} + +u8 CheckForObjectEventCollision(struct ObjectEvent *objectEvent, s16 x, s16 y, u8 direction, u8 metatileBehavior) +{ + u8 collision = GetCollisionAtCoords(objectEvent, x, y, direction); + if (collision == COLLISION_ELEVATION_MISMATCH && CanStopSurfing(x, y, direction)) + return COLLISION_STOP_SURFING; + + if (ShouldJumpLedge(x, y, direction)) + { + IncrementGameStat(GAME_STAT_JUMPED_DOWN_LEDGES); + return COLLISION_LEDGE_JUMP; + } + if (collision == COLLISION_OBJECT_EVENT && TryPushBoulder(x, y, direction)) + return COLLISION_PUSHED_BOULDER; + + if (collision == COLLISION_NONE) + { + CheckAcroBikeCollision(x, y, metatileBehavior, &collision); + } + return collision; +} + +static const u8 gUnknown_835B820[] = { + MOVEMENT_ACTION_FACE_DOWN_FAST, + MOVEMENT_ACTION_FACE_DOWN_FAST, + MOVEMENT_ACTION_FACE_UP_FAST, + MOVEMENT_ACTION_FACE_LEFT_FAST, + MOVEMENT_ACTION_FACE_RIGHT_FAST +}; + +static bool8 CanStopSurfing(s16 x, s16 y, u8 direction) +{ + if ((gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING) + && MapGridGetZCoordAt(x, y) == 3 + && GetObjectEventIdByXYZ(x, y, 3) == OBJECT_EVENTS_COUNT) + { + sub_811278C(gUnknown_835B820[direction], 16); + CreateStopSurfingTask(direction); + return TRUE; + } + else + { + return FALSE; + } +} + +static bool8 ShouldJumpLedge(s16 x, s16 y, u8 z) +{ + if (GetLedgeJumpDirection(x, y, z) != 0) + return TRUE; + else + return FALSE; +} + +static bool8 TryPushBoulder(s16 x, s16 y, u8 direction) +{ + u8 objectEventId; + u8 direction_ = direction; + if (!FlagGet(FLAG_SYS_USE_STRENGTH)) + return FALSE; + + objectEventId = GetObjectEventIdByXY(x, y); + if (objectEventId == OBJECT_EVENTS_COUNT) + return FALSE; + + if (gObjectEvents[objectEventId].graphicsId != OBJ_EVENT_GFX_PUSHABLE_BOULDER) + return FALSE; + + x = gObjectEvents[objectEventId].currentCoords.x; + y = gObjectEvents[objectEventId].currentCoords.y; + MoveCoords(direction_, &x, &y); + if (MapGridGetMetatileBehaviorAt(x, y) == MB_FALL_WARP || (GetCollisionAtCoords(&gObjectEvents[objectEventId], x, y, direction_) == COLLISION_NONE && !MetatileBehavior_IsNonAnimDoor(MapGridGetMetatileBehaviorAt(x, y)))) + { + StartStrengthAnim(objectEventId, direction_); + return TRUE; + } + else + { + return FALSE; + } +} + +static bool8 (*const gUnknown_835B828[])(u8) = { + MetatileBehavior_IsBumpySlope, + MetatileBehavior_IsIsolatedVerticalRail, + MetatileBehavior_IsIsolatedHorizontalRail, + MetatileBehavior_IsVerticalRail, + MetatileBehavior_IsHorizontalRail +}; + +static const u8 gUnknown_835B83C[] = { + COLLISION_WHEELIE_HOP, + COLLISION_ISOLATED_VERTICAL_RAIL, + COLLISION_ISOLATED_HORIZONTAL_RAIL, + COLLISION_VERTICAL_RAIL, + COLLISION_HORIZONTAL_RAIL, +}; + +static void CheckAcroBikeCollision(s16 x, s16 y, u8 metatileBehavior, u8 *collision) +{ + u8 i; + + for (i = 0; i < NELEMS(gUnknown_835B828); i++) + { + if (gUnknown_835B828[i](metatileBehavior)) + { + *collision = gUnknown_835B83C[i]; + return; + } + } +} + +void SetPlayerAvatarTransitionFlags(bool16 flags) +{ + gPlayerAvatar.transitionFlags |= flags; + DoPlayerAvatarTransition(); +} + +static void (*const gUnknown_835B844[])(struct ObjectEvent *) = { + [PLAYER_AVATAR_STATE_NORMAL] = PlayerAvatarTransition_Normal, + [PLAYER_AVATAR_STATE_MACH_BIKE] = PlayerAvatarTransition_Bike, + [PLAYER_AVATAR_STATE_ACRO_BIKE] = PlayerAvatarTransition_Bike, + [PLAYER_AVATAR_STATE_SURFING] = PlayerAvatarTransition_Surfing, + [PLAYER_AVATAR_STATE_UNDERWATER] = PlayerAvatarTransition_Underwater, + [PLAYER_AVATAR_STATE_FIELD_MOVE] = PlayerAvatarTransition_ReturnToField, + [PLAYER_AVATAR_STATE_FISHING] = PlayerAvatarTransition_Dummy, + [PLAYER_AVATAR_STATE_WATERING] = PlayerAvatarTransition_Dummy +}; + +static void DoPlayerAvatarTransition(void) +{ + u8 i; + u8 flags = gPlayerAvatar.transitionFlags; + + if (flags != 0) + { + for (i = 0; i < NELEMS(gUnknown_835B844); i++, flags >>= 1) + { + if (flags & 1) + gUnknown_835B844[i](&gObjectEvents[gPlayerAvatar.objectEventId]); + } + gPlayerAvatar.transitionFlags = 0; + } +} + +static void PlayerAvatarTransition_Dummy(struct ObjectEvent * playerObjEvent) +{ + +} + +static void PlayerAvatarTransition_Normal(struct ObjectEvent * playerObjEvent) +{ + sub_8150474(0); + sub_8150498(0); +} + +static void PlayerAvatarTransition_Bike(struct ObjectEvent * playerObjEvent) +{ + sub_8150474(1); + sub_8150498(1); + InitPlayerAvatarBikeState(0, 0); +} + +static void PlayerAvatarTransition_Surfing(struct ObjectEvent * playerObjEvent) +{ + sub_8150474(3); + sub_8150498(3); +} + +static void PlayerAvatarTransition_Underwater(struct ObjectEvent * playerObjEvent) +{ + +} + +static void PlayerAvatarTransition_ReturnToField(struct ObjectEvent * playerObjEvent) +{ + gPlayerAvatar.flags |= PLAYER_AVATAR_FLAG_FIELD_MOVE; +} + +void sub_805BEB8(void) +{ + gPlayerAvatar.tileTransitionState = T_NOT_MOVING; + if (PlayerIsAnimActive()) + { + if (!PlayerCheckIfAnimFinishedOrInactive()) + { + if (!player_is_anim_in_certain_ranges()) + gPlayerAvatar.tileTransitionState = T_TILE_TRANSITION; + } + else + { + if (!sub_805BF58()) + gPlayerAvatar.tileTransitionState = T_TILE_CENTER; + } + } +} + +static bool8 player_is_anim_in_certain_ranges(void) +{ + u8 movementActionId = gObjectEvents[gPlayerAvatar.objectEventId].movementActionId; + + if (movementActionId <= MOVEMENT_ACTION_FACE_RIGHT_FAST + || (movementActionId >= MOVEMENT_ACTION_DELAY_1 && movementActionId <= MOVEMENT_ACTION_DELAY_16) + || (movementActionId >= MOVEMENT_ACTION_WALK_IN_PLACE_SLOW_DOWN && movementActionId <= MOVEMENT_ACTION_WALK_IN_PLACE_FASTEST_RIGHT) + || (movementActionId >= MOVEMENT_ACTION_ACRO_WHEELIE_FACE_DOWN && movementActionId <= MOVEMENT_ACTION_ACRO_END_WHEELIE_FACE_RIGHT) + || (movementActionId >= MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_DOWN && movementActionId <= MOVEMENT_ACTION_ACRO_WHEELIE_IN_PLACE_RIGHT)) + return TRUE; + else + return FALSE; +} + +static bool8 sub_805BF58(void) +{ + if (player_is_anim_in_certain_ranges() && gPlayerAvatar.runningState != TURN_DIRECTION) + return TRUE; + else + return FALSE; +} + +static bool8 PlayerIsAnimActive(void) +{ + return ObjectEventIsMovementOverridden(&gObjectEvents[gPlayerAvatar.objectEventId]); +} + +static bool8 PlayerCheckIfAnimFinishedOrInactive(void) +{ + return ObjectEventCheckHeldMovementStatus(&gObjectEvents[gPlayerAvatar.objectEventId]); +} + +static void PlayerSetCopyableMovement(u8 a) +{ + gObjectEvents[gPlayerAvatar.objectEventId].playerCopyableMovement = a; +} + +u8 PlayerGetCopyableMovement(void) +{ + return gObjectEvents[gPlayerAvatar.objectEventId].playerCopyableMovement; +} + +static void PlayerForceSetHeldMovement(u8 a) +{ + ObjectEventForceSetHeldMovement(&gObjectEvents[gPlayerAvatar.objectEventId], a); +} + +static void PlayerSetAnimId(u8 movementActionId, u8 copyableMovement) +{ + if (!PlayerIsAnimActive()) + { + PlayerSetCopyableMovement(copyableMovement); + if (!ObjectEventSetHeldMovement(&gObjectEvents[gPlayerAvatar.objectEventId], movementActionId)) + sub_8112628(movementActionId); + } +} + +static void sub_805C06C(struct ObjectEvent * objectEvent, u8 movementAction) +{ + if (!ObjectEventSetHeldMovement(&gObjectEvents[gPlayerAvatar.objectEventId], movementAction)) + sub_81126AC(movementAction, 0); +} + +static void sub_805C0A4(struct ObjectEvent * objectEvent, u8 movementAction) +{ + if (!ObjectEventSetHeldMovement(objectEvent, movementAction)) + sub_8112588(objectEvent->localId, objectEvent->mapNum, objectEvent->mapGroup, movementAction, 32); +} + +void sub_805C0D4(u8 direction) +{ + PlayerSetAnimId(sub_8063F2C(direction), 2); +} + +void PlayerGoSlow(u8 direction) +{ + PlayerSetAnimId(GetWalkSlowMovementAction(direction), 2); +} + +void PlayerGoSpeed1(u8 direction) +{ + PlayerSetAnimId(GetWalkNormalMovementAction(direction), 2); +} + +void PlayerGoSpeed2(u8 direction) +{ + PlayerSetAnimId(GetWalkFastMovementAction(direction), 2); +} + +void sub_805C134(u8 direction) +{ + PlayerSetAnimId(sub_8063FDC(direction), 2); +} + +void PlayerRideWaterCurrent(u8 direction) +{ + PlayerSetAnimId(sub_8064008(direction), 2); +} + +void sub_805C164(u8 direction) +{ + PlayerSetAnimId(GetWalkFastestMovementAction(direction), 2); +} + +void PlayerRun(u8 direction) +{ + PlayerSetAnimId(GetPlayerRunMovementAction(direction), 2); +} + +void PlayerRunSlow(u8 direction) +{ + PlayerSetAnimId(GetPlayerRunSlowMovementAction(direction), 2); +} + +void PlayerOnBikeCollide(u8 direction) +{ + PlayCollisionSoundIfNotFacingWarp(direction); + PlayerSetAnimId(GetWalkInPlaceNormalMovementAction(direction), 2); +} + +void PlayerNotOnBikeCollide(u8 direction) +{ + PlayCollisionSoundIfNotFacingWarp(direction); + PlayerSetAnimId(GetStepInPlaceDelay32AnimId(direction), 2); +} + +void PlayerFaceDirection(u8 direction) +{ + PlayerSetAnimId(GetFaceDirectionMovementAction(direction), 1); +} + +void PlayerFaceDirectionFast(u8 direction) +{ + PlayerSetAnimId(GetFaceDirectionFastMovementAction(direction), 1); +} + +void PlayerTurnInPlace(u8 direction) +{ + PlayerSetAnimId(GetWalkInPlaceSlowMovementAction(direction), 1); +} + +void PlayerJumpLedge(u8 direction) +{ + PlaySE(SE_DANSA); + PlayerSetAnimId(GetJump2MovementAction(direction), 8); +} + +void sub_805C260(void) +{ + PlayerSetAnimId(MOVEMENT_ACTION_0x9F, 0); +} + +void sub_805C270(void) +{ + if (gPlayerAvatar.tileTransitionState == T_TILE_CENTER || gPlayerAvatar.tileTransitionState == T_NOT_MOVING) + { + if (player_should_look_direction_be_enforced_upon_movement()) + PlayerForceSetHeldMovement(GetFaceDirectionMovementAction(gObjectEvents[gPlayerAvatar.objectEventId].facingDirection)); + } +} + +static void PlayerGoSpin(u8 direction) +{ + PlayerSetAnimId(sub_80640E4(direction), 3); +} + +static void sub_805C2CC(u8 metatileBehavior) +{ + int i; + + for (i = 0; sForcedMovementFuncs[i].unk0 != NULL; i++) + { + if (sForcedMovementFuncs[i].unk0(metatileBehavior)) + sForcedMovementFuncs[i].unk4(); + } +} + +static void PlayerIdleWheelie(u8 direction) +{ + PlayerSetAnimId(GetAcroWheelieFaceDirectionMovementAction(direction), 1); +} + +static void PlayerStartWheelie(u8 direction) +{ + PlayerSetAnimId(GetAcroPopWheelieFaceDirectionMovementAction(direction), 1); +} + +static void PlayerEndWheelie(u8 direction) +{ + PlayerSetAnimId(GetAcroEndWheelieFaceDirectionMovementAction(direction), 1); +} + +static void PlayerStandingHoppingWheelie(u8 direction) +{ + PlaySE(SE_JITE_PYOKO); + PlayerSetAnimId(GetAcroWheelieHopFaceDirectionMovementAction(direction), 1); +} + +static void PlayerMovingHoppingWheelie(u8 direction) +{ + PlaySE(SE_JITE_PYOKO); + PlayerSetAnimId(GetAcroWheelieHopDirectionMovementAction(direction), 2); +} + +static void PlayerLedgeHoppingWheelie(u8 direction) +{ + PlaySE(SE_JITE_PYOKO); + PlayerSetAnimId(GetAcroWheelieJumpDirectionMovementAction(direction), 8); +} + +static void PlayerAcroTurnJump(u8 direction) +{ + PlaySE(SE_JITE_PYOKO); + PlayerSetAnimId(GetJumpInPlaceTurnAroundMovementAction(direction), 1); +} + +static void PlayerAcroWheelieCollide(u8 direction) +{ + PlaySE(SE_WALL_HIT); + PlayerSetAnimId(GetAcroWheelieInPlaceDirectionMovementAction(direction), 2); +} + +static void sub_805C408(u8 direction) +{ + PlayerSetAnimId(GetAcroPopWheelieMoveDirectionMovementAction(direction), 2); +} + +static void sub_805C420(u8 direction) +{ + PlayerSetAnimId(GetAcroWheelieMoveDirectionMovementAction(direction), 2); +} + +static bool8 (*const sArrowWarpMetatileBehaviorChecks[])(u8) = { + MetatileBehavior_IsSouthArrowWarp, + MetatileBehavior_IsNorthArrowWarp, + MetatileBehavior_IsWestArrowWarp, + MetatileBehavior_IsEastArrowWarp +}; + +static void PlayCollisionSoundIfNotFacingWarp(u8 direction) +{ + s16 x, y; + u8 metatileBehavior = gObjectEvents[gPlayerAvatar.objectEventId].currentMetatileBehavior; + + if (!sArrowWarpMetatileBehaviorChecks[direction - 1](metatileBehavior)) + { + if (direction == DIR_WEST) + { + if (MetatileBehavior_IsUnknownWarp6D(metatileBehavior) || MetatileBehavior_IsUnknownWarp6F(metatileBehavior)) + return; + } + if (direction == DIR_EAST) + { + if (MetatileBehavior_IsUnknownWarp6C(metatileBehavior) || MetatileBehavior_IsUnknownWarp6E(metatileBehavior)) + return; + } + if (direction == DIR_NORTH) + { + PlayerGetDestCoords(&x, &y); + MoveCoords(DIR_NORTH, &x, &y); + metatileBehavior = MapGridGetMetatileBehaviorAt(x, y); + if (MetatileBehavior_IsWarpDoor(metatileBehavior)) + return; + } + PlaySE(SE_WALL_HIT); + } +} + +void GetXYCoordsOneStepInFrontOfPlayer(s16 *x, s16 *y) +{ + *x = gObjectEvents[gPlayerAvatar.objectEventId].currentCoords.x; + *y = gObjectEvents[gPlayerAvatar.objectEventId].currentCoords.y; + MoveCoords(GetPlayerFacingDirection(), x, y); +} + +void PlayerGetDestCoords(s16 *x, s16 *y) +{ + *x = gObjectEvents[gPlayerAvatar.objectEventId].currentCoords.x; + *y = gObjectEvents[gPlayerAvatar.objectEventId].currentCoords.y; +} + +u8 player_get_pos_including_state_based_drift(s16 *x, s16 *y) +{ + struct ObjectEvent *object = &gObjectEvents[gPlayerAvatar.objectEventId]; + + if (object->heldMovementActive && !object->heldMovementFinished && !gSprites[object->spriteId].data[2]) + { + *x = object->currentCoords.x; + *y = object->currentCoords.y; + + switch (object->movementActionId) + { + case MOVEMENT_ACTION_WALK_NORMAL_DOWN: + case MOVEMENT_ACTION_PLAYER_RUN_DOWN: + (*y)++; + return TRUE; + case MOVEMENT_ACTION_WALK_NORMAL_UP: + case MOVEMENT_ACTION_PLAYER_RUN_UP: + (*y)--; + return TRUE; + case MOVEMENT_ACTION_WALK_NORMAL_LEFT: + case MOVEMENT_ACTION_PLAYER_RUN_LEFT: + (*x)--; + return TRUE; + case MOVEMENT_ACTION_WALK_NORMAL_RIGHT: + case MOVEMENT_ACTION_PLAYER_RUN_RIGHT: + (*x)++; + return TRUE; + } + } + + *x = -1; + *y = -1; + return FALSE; +} + +u8 GetPlayerFacingDirection(void) +{ + return gObjectEvents[gPlayerAvatar.objectEventId].facingDirection; +} + +u8 GetPlayerMovementDirection(void) +{ + return gObjectEvents[gPlayerAvatar.objectEventId].movementDirection; +} + +u8 PlayerGetZCoord(void) +{ + return gObjectEvents[gPlayerAvatar.objectEventId].previousElevation; +} + +void MovePlayerToMapCoords(s16 x, s16 y) +{ + MoveObjectEventToMapCoords(&gObjectEvents[gPlayerAvatar.objectEventId], x, y); +} + +u8 TestPlayerAvatarFlags(u8 bm) +{ + return gPlayerAvatar.flags & bm; +} + +u8 GetPlayerAvatarFlags(void) +{ + return gPlayerAvatar.flags; +} + +u8 GetPlayerAvatarObjectId(void) +{ + return gPlayerAvatar.spriteId; +} + +void sub_805C774(void) +{ + ForcedMovement_None(); +} + +void StopPlayerAvatar(void) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + npc_clear_strange_bits(playerObjEvent); + SetObjectEventDirection(playerObjEvent, playerObjEvent->facingDirection); + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE)) + { + Bike_HandleBumpySlopeJump(); + Bike_UpdateBikeCounterSpeed(0); + } +} + +static const u8 sPlayerAvatarGfxIds[][2] = { + {OBJ_EVENT_GFX_RED_NORMAL, OBJ_EVENT_GFX_GREEN_NORMAL}, + {OBJ_EVENT_GFX_RED_BIKE, OBJ_EVENT_GFX_GREEN_BIKE}, + {OBJ_EVENT_GFX_RED_SURF, OBJ_EVENT_GFX_GREEN_SURF}, + {OBJ_EVENT_GFX_RED_ITEM, OBJ_EVENT_GFX_GREEN_ITEM}, + {OBJ_EVENT_GFX_RED_FISH, OBJ_EVENT_GFX_GREEN_FISH}, + {OBJ_EVENT_GFX_RED_VS_SEEKER, OBJ_EVENT_GFX_GREEN_VS_SEEKER}, +}; + +static const u8 sHoennLinkPartnerGfxIds[] = { + OBJ_EVENT_GFX_RS_BRENDAN, + OBJ_EVENT_GFX_RS_MAY +}; + +u8 GetRivalAvatarGraphicsIdByStateIdAndGender(u8 state, u8 gender) +{ + return GetPlayerAvatarGraphicsIdByStateIdAndGender(state, gender); +} + +u8 GetPlayerAvatarGraphicsIdByStateIdAndGender(u8 state, u8 gender) +{ + return sPlayerAvatarGfxIds[state][gender]; +} + +u8 GetRSAvatarGraphicsIdByGender(u8 gender) +{ + return sHoennLinkPartnerGfxIds[gender]; +} + +u8 GetPlayerAvatarGraphicsIdByStateId(u8 state) +{ + return GetPlayerAvatarGraphicsIdByStateIdAndGender(state, gPlayerAvatar.gender); +} + +u8 GetPlayerAvatarGenderByGraphicsId(u8 gfxId) +{ + switch (gfxId) + { + case OBJ_EVENT_GFX_GREEN_NORMAL: + case OBJ_EVENT_GFX_GREEN_BIKE: + case OBJ_EVENT_GFX_GREEN_SURF: + case OBJ_EVENT_GFX_GREEN_ITEM: + case OBJ_EVENT_GFX_GREEN_FISH: + return FEMALE; + default: + return MALE; + } +} + +bool8 PartyHasMonWithSurf(void) +{ + u8 i; + + if (!TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING)) + { + for (i = 0; i < PARTY_SIZE; i++) + { + if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) == SPECIES_NONE) + break; + if (MonKnowsMove(&gPlayerParty[i], MOVE_SURF)) + return TRUE; + } + } + return FALSE; +} + +bool8 IsPlayerSurfingNorth(void) +{ + if (GetPlayerMovementDirection() == DIR_NORTH && TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING)) + return TRUE; + else + return FALSE; +} + +bool8 IsPlayerFacingSurfableFishableWater(void) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + s16 x = playerObjEvent->currentCoords.x; + s16 y = playerObjEvent->currentCoords.y; + + MoveCoords(playerObjEvent->facingDirection, &x, &y); + if (GetCollisionAtCoords(playerObjEvent, x, y, playerObjEvent->facingDirection) == COLLISION_ELEVATION_MISMATCH + && PlayerGetZCoord() == 3 + && MetatileAtCoordsIsWaterTile(x, y) == TRUE) + return TRUE; + else + return FALSE; +} + +bool8 MetatileAtCoordsIsWaterTile(s16 x, s16 y) +{ + return TestMetatileAttributeBit(MapGridGetMetatileAttributeAt(x, y, METATILE_ATTRIBUTE_TERRAIN), TILE_TERRAIN_WATER); +} + +void ClearPlayerAvatarInfo(void) +{ + gPlayerAvatar = (struct PlayerAvatar){}; +} + +void SetPlayerAvatarStateMask(u8 flags) +{ + gPlayerAvatar.flags &= (PLAYER_AVATAR_FLAG_WATERING | PLAYER_AVATAR_FLAG_FISHING | PLAYER_AVATAR_FLAG_FIELD_MOVE); + gPlayerAvatar.flags |= flags; +} + +static const u8 gUnknown_835B882[][3][2] = { + // Male + { + {OBJ_EVENT_GFX_RED_NORMAL, PLAYER_AVATAR_FLAG_ON_FOOT}, + {OBJ_EVENT_GFX_RED_BIKE, PLAYER_AVATAR_FLAG_MACH_BIKE}, + {OBJ_EVENT_GFX_RED_SURF, PLAYER_AVATAR_FLAG_SURFING}, + }, + // Female + { + {OBJ_EVENT_GFX_GREEN_NORMAL, PLAYER_AVATAR_FLAG_ON_FOOT}, + {OBJ_EVENT_GFX_GREEN_BIKE, PLAYER_AVATAR_FLAG_MACH_BIKE}, + {OBJ_EVENT_GFX_GREEN_SURF, PLAYER_AVATAR_FLAG_SURFING}, + } +}; + +u8 GetPlayerAvatarStateTransitionByGraphicsId(u8 graphicsId, u8 gender) +{ + u8 i; + + for (i = 0; i < NELEMS(*gUnknown_835B882); i++) + { + if (gUnknown_835B882[gender][i][0] == graphicsId) + return gUnknown_835B882[gender][i][1]; + } + return 1; +} + +u8 GetPlayerAvatarGraphicsIdByCurrentState(void) +{ + u8 i; + u8 r5 = gPlayerAvatar.flags; + + for (i = 0; i < NELEMS(*gUnknown_835B882); i++) + { + if (gUnknown_835B882[gPlayerAvatar.gender][i][1] & r5) + return gUnknown_835B882[gPlayerAvatar.gender][i][0]; + } + return 0; +} + +void SetPlayerAvatarExtraStateTransition(u8 graphicsId, u8 b) +{ + u8 unk = GetPlayerAvatarStateTransitionByGraphicsId(graphicsId, gPlayerAvatar.gender); + + gPlayerAvatar.transitionFlags |= unk | b; + DoPlayerAvatarTransition(); +} + +void InitPlayerAvatar(s16 x, s16 y, u8 direction, u8 gender) +{ + struct ObjectEventTemplate playerObjEventTemplate; + u8 objectEventId; + struct ObjectEvent *objectEvent; + + playerObjEventTemplate.localId = OBJ_EVENT_ID_PLAYER; + playerObjEventTemplate.graphicsId = GetPlayerAvatarGraphicsIdByStateIdAndGender(PLAYER_AVATAR_STATE_NORMAL, gender); + playerObjEventTemplate.x = x - 7; + playerObjEventTemplate.y = y - 7; + playerObjEventTemplate.elevation = 0; + playerObjEventTemplate.movementType = MOVEMENT_TYPE_PLAYER; + playerObjEventTemplate.movementRangeX = 0; + playerObjEventTemplate.movementRangeY = 0; + playerObjEventTemplate.trainerType = 0; + playerObjEventTemplate.trainerRange_berryTreeId = 0; + playerObjEventTemplate.script = NULL; + playerObjEventTemplate.flagId = 0; + objectEventId = SpawnSpecialObjectEvent(&playerObjEventTemplate); + objectEvent = &gObjectEvents[objectEventId]; + objectEvent->isPlayer = 1; + objectEvent->warpArrowSpriteId = CreateWarpArrowSprite(); + ObjectEventTurn(objectEvent, direction); + ClearPlayerAvatarInfo(); + gPlayerAvatar.runningState = NOT_MOVING; + gPlayerAvatar.tileTransitionState = T_NOT_MOVING; + gPlayerAvatar.objectEventId = objectEventId; + gPlayerAvatar.spriteId = objectEvent->spriteId; + gPlayerAvatar.gender = gender; + SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_FIELD_MOVE | PLAYER_AVATAR_FLAG_ON_FOOT); +} + +void SetPlayerInvisibility(bool8 invisible) +{ + gObjectEvents[gPlayerAvatar.objectEventId].invisible = invisible; + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING)) + gSprites[gObjectEvents[gPlayerAvatar.objectEventId].fieldEffectSpriteId].invisible = invisible; +} + +void sub_805CB70(void) +{ + ObjectEventSetGraphicsId(&gObjectEvents[gPlayerAvatar.objectEventId], GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_SURFING)); + StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], 0); +} + +static const u8 gUnknown_835B88E[] = { + OBJ_EVENT_GFX_RED_VS_SEEKER_BIKE, + OBJ_EVENT_GFX_GREEN_VS_SEEKER_BIKE +}; + +u8 sub_805CBB8(void) +{ + if (gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE)) + return gUnknown_835B88E[gPlayerAvatar.gender]; + else + return GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_FIELD_MOVE); +} + +void sub_805CBE8(void) +{ + ObjectEventSetGraphicsId(&gObjectEvents[gPlayerAvatar.objectEventId], sub_805CBB8()); + StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], 0); +} + +void sub_805CC2C(u8 direction) +{ + sub_8150498(2); +} + +void nullsub_24(u8 direction) +{ + +} + +static void nullsub_25(void) +{ + +} + +static bool8 (*const sArrowWarpMetatileBehaviorChecks2[])(u8) = { + MetatileBehavior_IsSouthArrowWarp, + MetatileBehavior_IsNorthArrowWarp, + MetatileBehavior_IsWestArrowWarp, + MetatileBehavior_IsEastArrowWarp +}; + +static void sub_805CC40(struct ObjectEvent *objectEvent) +{ + s16 x; + s16 y; + u8 direction; + u8 metatileBehavior = objectEvent->currentMetatileBehavior; + + for (x = 0, direction = DIR_SOUTH; x < 4; x++, direction++) + { + if (sArrowWarpMetatileBehaviorChecks2[x](metatileBehavior) && direction == objectEvent->movementDirection) + { + x = objectEvent->currentCoords.x; + y = objectEvent->currentCoords.y; + MoveCoords(direction, &x, &y); + ShowWarpArrowSprite(objectEvent->warpArrowSpriteId, direction, x, y); + return; + } + } + SetSpriteInvisible(objectEvent->warpArrowSpriteId); +} + +static bool8 (*const gUnknown_835B8A0[])(struct Task * task, struct ObjectEvent * playerObj, struct ObjectEvent * boulderObj) = { + sub_805CD64, + do_boulder_dust, + sub_805CE20 +}; + +static void StartStrengthAnim(u8 a, u8 b) +{ + u8 taskId = CreateTask(Task_BumpBoulder, 0xFF); + + gTasks[taskId].data[1] = a; + gTasks[taskId].data[2] = b; + Task_BumpBoulder(taskId); +} + +static void Task_BumpBoulder(u8 taskId) +{ + while (gUnknown_835B8A0[gTasks[taskId].data[0]](&gTasks[taskId], + &gObjectEvents[gPlayerAvatar.objectEventId], + &gObjectEvents[gTasks[taskId].data[1]])) + ; +} + +static bool8 sub_805CD64(struct Task *task, struct ObjectEvent *playerObject, struct ObjectEvent *strengthObject) +{ + ScriptContext2_Enable(); + gPlayerAvatar.preventStep = TRUE; + task->data[0]++; + return FALSE; +} + +static bool8 do_boulder_dust(struct Task *task, struct ObjectEvent *playerObject, struct ObjectEvent *strengthObject) +{ + if (!ObjectEventIsMovementOverridden(playerObject) + && !ObjectEventIsMovementOverridden(strengthObject)) + { + ObjectEventClearHeldMovementIfFinished(playerObject); + ObjectEventClearHeldMovementIfFinished(strengthObject); + sub_805C06C(playerObject, GetWalkInPlaceNormalMovementAction((u8)task->data[2])); + sub_805C0A4(strengthObject, sub_8063F2C((u8)task->data[2])); + gFieldEffectArguments[0] = strengthObject->currentCoords.x; + gFieldEffectArguments[1] = strengthObject->currentCoords.y; + gFieldEffectArguments[2] = strengthObject->previousElevation; + gFieldEffectArguments[3] = gSprites[strengthObject->spriteId].oam.priority; + FieldEffectStart(FLDEFF_DUST); + PlaySE(SE_W070); + task->data[0]++; + } + return FALSE; +} + +static bool8 sub_805CE20(struct Task *task, struct ObjectEvent *playerObject, struct ObjectEvent *strengthObject) +{ + if (ObjectEventCheckHeldMovementStatus(playerObject) + && ObjectEventCheckHeldMovementStatus(strengthObject)) + { + ObjectEventClearHeldMovementIfFinished(playerObject); + ObjectEventClearHeldMovementIfFinished(strengthObject); + sub_806DE28(strengthObject); + sub_806DE70(strengthObject->currentCoords.x, strengthObject->currentCoords.y); + gPlayerAvatar.preventStep = FALSE; + ScriptContext2_Disable(); + DestroyTask(FindTaskIdByFunc(Task_BumpBoulder)); + } + return FALSE; +} + +static bool8 (*const sPlayerAvatarSecretBaseMatJump[])(struct Task *, struct ObjectEvent *) = { + PlayerAvatar_DoSecretBaseMatJump +}; + +static void DoPlayerMatJump(void) +{ + DoPlayerAvatarSecretBaseMatJump(CreateTask(DoPlayerAvatarSecretBaseMatJump, 0xFF)); +} + +static void DoPlayerAvatarSecretBaseMatJump(u8 taskId) +{ + while (sPlayerAvatarSecretBaseMatJump[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId])) + ; +} + +// because data[0] is used to call this, it can be inferred that there may have been multiple mat jump functions at one point, so the name for these groups of functions is appropriate in assuming the sole use of mat jump. +static bool8 PlayerAvatar_DoSecretBaseMatJump(struct Task *task, struct ObjectEvent *objectEvent) +{ + gPlayerAvatar.preventStep = TRUE; + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + PlaySE(SE_DANSA); + sub_805C06C(objectEvent, GetJumpInPlaceMovementAction(objectEvent->facingDirection)); + task->data[1]++; + if (task->data[1] > 1) + { + gPlayerAvatar.preventStep = FALSE; + gPlayerAvatar.transitionFlags |= PLAYER_AVATAR_FLAG_FIELD_MOVE; + DestroyTask(FindTaskIdByFunc(DoPlayerAvatarSecretBaseMatJump)); + } + } + return FALSE; +} + +static bool8 (*const sPlayerAvatarSecretBaseMatSpin[])(struct Task * task, struct ObjectEvent * playerObj) = { + PlayerAvatar_SecretBaseMatSpinStep0, + PlayerAvatar_SecretBaseMatSpinStep1, + PlayerAvatar_SecretBaseMatSpinStep2, + PlayerAvatar_SecretBaseMatSpinStep3, +}; + +static void DoPlayerMatSpin(void) +{ + u8 taskId = CreateTask(PlayerAvatar_DoSecretBaseMatSpin, 0xFF); + + PlayerAvatar_DoSecretBaseMatSpin(taskId); +} + +static void PlayerAvatar_DoSecretBaseMatSpin(u8 taskId) +{ + while (sPlayerAvatarSecretBaseMatSpin[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId])) + ; +} + +static bool8 PlayerAvatar_SecretBaseMatSpinStep0(struct Task *task, struct ObjectEvent *objectEvent) +{ + task->data[0]++; + task->data[1] = objectEvent->movementDirection; + gPlayerAvatar.preventStep = TRUE; + ScriptContext2_Enable(); + PlaySE(SE_TK_WARPIN); + return TRUE; +} + +static bool8 PlayerAvatar_SecretBaseMatSpinStep1(struct Task *task, struct ObjectEvent *objectEvent) +{ + u8 directions[] = {DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH}; + + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + u8 direction; + + sub_805C06C(objectEvent, GetFaceDirectionMovementAction(direction = directions[objectEvent->movementDirection - 1])); + if (direction == (u8)task->data[1]) + task->data[2]++; + task->data[0]++; + if (task->data[2] > 3 && direction == GetOppositeDirection(task->data[1])) + task->data[0]++; + } + return FALSE; +} + +static bool8 PlayerAvatar_SecretBaseMatSpinStep2(struct Task *task, struct ObjectEvent *objectEvent) +{ + const u8 actions[] = { + MOVEMENT_ACTION_DELAY_1, + MOVEMENT_ACTION_DELAY_1, + MOVEMENT_ACTION_DELAY_2, + MOVEMENT_ACTION_DELAY_4, + MOVEMENT_ACTION_DELAY_8, + }; + + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + sub_805C06C(objectEvent, actions[task->data[2]]); + task->data[0] = 1; + } + return FALSE; +} + +static bool8 PlayerAvatar_SecretBaseMatSpinStep3(struct Task *task, struct ObjectEvent *objectEvent) +{ + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + sub_805C06C(objectEvent, sub_8063F2C(GetOppositeDirection(task->data[1]))); + ScriptContext2_Disable(); + gPlayerAvatar.preventStep = FALSE; + DestroyTask(FindTaskIdByFunc(PlayerAvatar_DoSecretBaseMatSpin)); + } + return FALSE; +} + +static void CreateStopSurfingTask(u8 direction) +{ + u8 taskId; + + ScriptContext2_Enable(); + FreezeObjectEvents(); + Overworld_ClearSavedMusic(); + Overworld_ChangeMusicToDefault(); + gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_SURFING; + gPlayerAvatar.flags |= PLAYER_AVATAR_FLAG_ON_FOOT; + gPlayerAvatar.preventStep = TRUE; + taskId = CreateTask(Task_StopSurfingInit, 0xFF); + gTasks[taskId].data[0] = direction; + Task_StopSurfingInit(taskId); +} + +void CreateStopSurfingTask_NoMusicChange(u8 direction) +{ + u8 taskId; + + ScriptContext2_Enable(); + FreezeObjectEvents(); + gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_SURFING; + gPlayerAvatar.flags |= PLAYER_AVATAR_FLAG_ON_FOOT; + gPlayerAvatar.preventStep = TRUE; + taskId = CreateTask(Task_StopSurfingInit, 0xFF); + gTasks[taskId].data[0] = direction; + Task_StopSurfingInit(taskId); +} + +void SeafoamIslandsB4F_CurrentDumpsPlayerOnLand(void) +{ + if (gUnknown_3005E88 != 1 && gUnknown_3005E88 != 3) + { + sub_811278C(gUnknown_835B820[DIR_NORTH], 16); + CreateStopSurfingTask(DIR_NORTH); + } +} + +static void Task_StopSurfingInit(u8 taskId) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + if (ObjectEventIsMovementOverridden(playerObjEvent)) + { + if (!ObjectEventClearHeldMovementIfFinished(playerObjEvent)) + return; + } + sub_80DC44C(playerObjEvent->fieldEffectSpriteId, 2); + sub_805C06C(playerObjEvent, sub_80641EC((u8)gTasks[taskId].data[0])); + gTasks[taskId].func = Task_WaitStopSurfing; +} + +static void Task_WaitStopSurfing(u8 taskId) +{ + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + if (ObjectEventClearHeldMovementIfFinished(playerObjEvent)) + { + ObjectEventSetGraphicsId(playerObjEvent, GetPlayerAvatarGraphicsIdByStateId(PLAYER_AVATAR_STATE_NORMAL)); + sub_805C06C(playerObjEvent, GetFaceDirectionMovementAction(playerObjEvent->facingDirection)); + gPlayerAvatar.preventStep = FALSE; + ScriptContext2_Disable(); + UnfreezeObjectEvents(); + DestroySprite(&gSprites[playerObjEvent->fieldEffectSpriteId]); + DestroyTask(taskId); + SetHelpContextForMap(); + } +} + +static bool8 (*const sFishingStateFuncs[])(struct Task *) = +{ + Fishing1, + Fishing2, + Fishing3, + Fishing4, + Fishing5, + Fishing6, + Fishing7, + Fishing8, + Fishing9, + Fishing10, + Fishing11, + Fishing12, + Fishing13, + Fishing14, + Fishing15, + Fishing16, +}; + +#define tStep data[0] +#define tFrameCounter data[1] +#define tNumDots data[2] +#define tDotsRequired data[3] +#define tRoundsPlayed data[12] +#define tMinRoundsRequired data[13] +#define tPlayerGfxId data[14] +#define tFishingRod data[15] + +#define FISHING_START_ROUND 3 +#define FISHING_GOT_BITE 6 +#define FISHING_ON_HOOK 9 +#define FISHING_NO_BITE 11 +#define FISHING_GOT_AWAY 12 +#define FISHING_SHOW_RESULT 13 + +void StartFishing(u8 rod) +{ + u8 taskId = CreateTask(Task_Fishing, 0xFF); + + gTasks[taskId].tFishingRod = rod; + Task_Fishing(taskId); + if (sub_8150474(2) == TRUE) + sub_8112C9C(); +} + + +static void Task_Fishing(u8 taskId) +{ + while (sFishingStateFuncs[gTasks[taskId].tStep](&gTasks[taskId])) + ; +} + +static bool8 Fishing1(struct Task *task) +{ + ScriptContext2_Enable(); + gPlayerAvatar.preventStep = TRUE; + task->tStep++; + return FALSE; +} + +static bool8 Fishing2(struct Task *task) +{ + struct ObjectEvent *playerObjEvent; + const s16 arr1[] = {1, 1, 1}; + const s16 arr2[] = {1, 3, 6}; + + task->tRoundsPlayed = 0; + task->tMinRoundsRequired = arr1[task->tFishingRod] + (Random() % arr2[task->tFishingRod]); + task->tPlayerGfxId = gObjectEvents[gPlayerAvatar.objectEventId].graphicsId; + playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + ObjectEventClearHeldMovementIfActive(playerObjEvent); + playerObjEvent->enableAnim = 1; + sub_805CC2C(playerObjEvent->facingDirection); + task->tStep++; + return FALSE; +} + +static bool8 Fishing3(struct Task *task) +{ + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + + // Wait one second + task->tFrameCounter++; + if (task->tFrameCounter >= 60) + task->tStep++; + return FALSE; +} + +static bool8 Fishing4(struct Task *task) +{ + u32 randVal; + + sub_80F7768(0, TRUE); + task->tStep++; + task->tFrameCounter = 0; + task->tNumDots = 0; + randVal = Random(); + randVal %= 10; + task->tDotsRequired = randVal + 1; + if (task->tRoundsPlayed == 0) + task->tDotsRequired = randVal + 4; + if (task->tDotsRequired >= 10) + task->tDotsRequired = 10; + return TRUE; +} + +// Play a round of the dot game +static bool8 Fishing5(struct Task *task) +{ + static const u8 dot[] = _("·"); + + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + task->tFrameCounter++; + if (task->tFrameCounter >= 20) + { + task->tFrameCounter = 0; + if (task->tNumDots >= task->tDotsRequired) + { + task->tStep++; + if (task->tRoundsPlayed != 0) + task->tStep++; + task->tRoundsPlayed++; + } + else + { + AddTextPrinterParameterized(0, 2, dot, task->tNumDots * 12, 1, 0, NULL); + task->tNumDots++; + } + } + return FALSE; +} + +// Determine if fish bites +static bool8 Fishing6(struct Task *task) +{ + bool8 bite; + + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + task->tStep++; + bite = FALSE; + + if (!DoesCurrentMapHaveFishingMons() || Random() & 1) + { + task->tStep = FISHING_NO_BITE; + } + else + { + StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetFishingBiteDirectionAnimNum(GetPlayerFacingDirection())); + } + return TRUE; +} + +// Oh! A Bite! +static bool8 Fishing7(struct Task *task) +{ + task->tStep += 3; + return FALSE; +} + +// We have a bite. Now, wait for the player to press A, or the timer to expire. +static bool8 Fishing8(struct Task *task) +{ + const s16 reelTimeouts[3] = {36, 33, 30}; + + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + task->tFrameCounter++; + if (task->tFrameCounter >= reelTimeouts[task->tFishingRod]) + task->tStep = FISHING_GOT_AWAY; + else if (gMain.newKeys & A_BUTTON) + task->tStep++; + return FALSE; +} + +// Determine if we're going to play the dot game again +static bool8 Fishing9(struct Task *task) +{ + const s16 arr[][2] = + { + {0, 0}, + {40, 10}, + {70, 30} + }; + + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + task->tStep++; + if (task->tRoundsPlayed < task->tMinRoundsRequired) + { + task->tStep = FISHING_START_ROUND; + } + else if (task->tRoundsPlayed < 2) + { + // probability of having to play another round + s16 probability = Random() % 100; + + if (arr[task->tFishingRod][task->tRoundsPlayed] > probability) + task->tStep = FISHING_START_ROUND; + } + return FALSE; +} + +static bool8 Fishing10(struct Task *task) +{ + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + FillWindowPixelBuffer(0, PIXEL_FILL(1)); + AddTextPrinterParameterized2(0, 2, gText_PokemonOnHook, 1, 0, TEXT_COLOR_DARK_GREY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GREY); + task->tStep++; + task->tFrameCounter = 0; + return FALSE; +} + +static bool8 Fishing11(struct Task *task) +{ + if (task->tFrameCounter == 0) + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + + RunTextPrinters(); + + if (task->tFrameCounter == 0) + { + if (!IsTextPrinterActive(0)) + { + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + ObjectEventSetGraphicsId(playerObjEvent, task->tPlayerGfxId); + ObjectEventTurn(playerObjEvent, playerObjEvent->movementDirection); + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING) + sub_80DC4A4(gObjectEvents[gPlayerAvatar.objectEventId].fieldEffectSpriteId, 0, 0); + gSprites[gPlayerAvatar.spriteId].pos2.x = 0; + gSprites[gPlayerAvatar.spriteId].pos2.y = 0; + ClearDialogWindowAndFrame(0, TRUE); + task->tFrameCounter++; + return FALSE; + } + } + + if (task->tFrameCounter != 0) + { + gPlayerAvatar.preventStep = FALSE; + ScriptContext2_Disable(); + FishingWildEncounter(task->tFishingRod); + DestroyTask(FindTaskIdByFunc(Task_Fishing)); + } + return FALSE; +} + +// Not even a nibble +static bool8 Fishing12(struct Task *task) +{ + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetFishingNoCatchDirectionAnimNum(GetPlayerFacingDirection())); + FillWindowPixelBuffer(0, PIXEL_FILL(1)); + AddTextPrinterParameterized2(0, 2, gText_NotEvenANibble, 1, NULL, TEXT_COLOR_DARK_GREY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GREY); + task->tStep = FISHING_SHOW_RESULT; + return TRUE; +} + +// It got away +static bool8 Fishing13(struct Task *task) +{ + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + StartSpriteAnim(&gSprites[gPlayerAvatar.spriteId], GetFishingNoCatchDirectionAnimNum(GetPlayerFacingDirection())); + AddTextPrinterParameterized2(0, 2, gText_ItGotAway, 1, NULL, TEXT_COLOR_DARK_GREY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GREY); + task->tStep++; + return TRUE; +} + +// Wait one second +static bool8 Fishing14(struct Task *task) +{ + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + task->tStep++; + return FALSE; +} + +static bool8 Fishing15(struct Task *task) +{ + AlignFishingAnimationFrames(&gSprites[gPlayerAvatar.spriteId]); + if (gSprites[gPlayerAvatar.spriteId].animEnded) + { + struct ObjectEvent *playerObjEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + + ObjectEventSetGraphicsId(playerObjEvent, task->tPlayerGfxId); + ObjectEventTurn(playerObjEvent, playerObjEvent->movementDirection); + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING) + sub_80DC4A4(gObjectEvents[gPlayerAvatar.objectEventId].fieldEffectSpriteId, 0, 0); + gSprites[gPlayerAvatar.spriteId].pos2.x = 0; + gSprites[gPlayerAvatar.spriteId].pos2.y = 0; + task->tStep++; + } + return FALSE; +} + +static bool8 Fishing16(struct Task *task) +{ + RunTextPrinters(); + if (!IsTextPrinterActive(0)) + { + gPlayerAvatar.preventStep = FALSE; + ScriptContext2_Disable(); + UnfreezeObjectEvents(); + ClearDialogWindowAndFrame(0, TRUE); + DestroyTask(FindTaskIdByFunc(Task_Fishing)); + } + return FALSE; +} + +#undef tStep +#undef tFrameCounter +#undef tFishingRod + +void AlignFishingAnimationFrames(struct Sprite * playerSprite) +{ + u8 animCmdIndex; + u8 animType; + + AnimateSprite(playerSprite); + playerSprite->pos2.x = 0; + playerSprite->pos2.y = 0; + animCmdIndex = playerSprite->animCmdIndex; + if (playerSprite->anims[playerSprite->animNum][animCmdIndex].type == -1) + { + animCmdIndex--; + } + else + { + playerSprite->animDelayCounter++; + if (playerSprite->anims[playerSprite->animNum][animCmdIndex].type == -1) + animCmdIndex--; + } + animType = playerSprite->anims[playerSprite->animNum][animCmdIndex].type; + if (animType == 1 || animType == 2 || animType == 3) + { + playerSprite->pos2.x = 8; + if (GetPlayerFacingDirection() == 3) + playerSprite->pos2.x = -8; + } + if (animType == 5) + playerSprite->pos2.y = -8; + if (animType == 10 || animType == 11) + playerSprite->pos2.y = 8; + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING) + sub_80DC4A4(gObjectEvents[gPlayerAvatar.objectEventId].fieldEffectSpriteId, 1, playerSprite->pos2.y); +} + +#define tState data[0] +#define tRotationTimer data[1] +#define tDeltaY data[2] +#define tYdeflection data[3] +#define tYpos data[4] +#define tFinalFacingDirection data[5] +#define tPriority data[6] +#define tSubpriority data[7] +#define tLandingDelay data[8] + +static const u8 sTeleportFacingDirectionSequence[] = { + [DIR_SOUTH] = DIR_WEST, + [DIR_WEST] = DIR_NORTH, + [DIR_NORTH] = DIR_EAST, + [DIR_EAST] = DIR_SOUTH, + [DIR_NONE] = DIR_SOUTH, +}; + +void StartTeleportWarpOutPlayerAnim(void) +{ + u8 taskId = CreateTask(Task_TeleportWarpOutPlayerAnim, 0); + Task_TeleportWarpOutPlayerAnim(taskId); +} + +bool32 WaitTeleportWarpOutPlayerAnim(void) +{ + return FuncIsActiveTask(Task_TeleportWarpOutPlayerAnim); +} + +void SavePlayerFacingDirectionForTeleport(u8 direction) +{ + sTeleportSavedFacingDirection = direction; +} + +static u8 GetTeleportSavedFacingDirection(void) +{ + if (sTeleportSavedFacingDirection == DIR_NONE) + return DIR_SOUTH; + else + return sTeleportSavedFacingDirection; +} + +static void Task_TeleportWarpOutPlayerAnim(u8 taskId) +{ + struct ObjectEvent *object = &gObjectEvents[gPlayerAvatar.objectEventId]; + struct Sprite *sprite = &gSprites[object->spriteId]; + s16 *data = gTasks[taskId].data; + + switch (tState) + { + case 0: + if (!ObjectEventClearHeldMovementIfFinished(object)) + { + return; + } + + SavePlayerFacingDirectionForTeleport(object->facingDirection); + tRotationTimer = 0; + tDeltaY = 1; + tYdeflection = (u16)(sprite->pos1.y + sprite->pos2.y) * 16; + sprite->pos2.y = 0; + CameraObjectReset2(); + object->fixedPriority = TRUE; + sprite->oam.priority = 0; + sprite->subpriority = 0; + sprite->subspriteMode = SUBSPRITES_OFF; + tState++; + case 1: + TeleportAnim_RotatePlayer(object, &tRotationTimer); + tYdeflection -= tDeltaY; + tDeltaY += 3; + sprite->pos1.y = tYdeflection >> 4; + if (sprite->pos1.y + (s16)gTotalCameraPixelOffsetY < -32) + { + tState++; + } + break; + case 2: + DestroyTask(taskId); + break; + } +} + +void StartTeleportInPlayerAnim(void) +{ + u8 taskId = CreateTask(Task_TeleportWarpInPlayerAnim, 0); + Task_TeleportWarpInPlayerAnim(taskId); +} + +bool32 WaitTeleportInPlayerAnim(void) +{ + return FuncIsActiveTask(Task_TeleportWarpInPlayerAnim); +} + +static void Task_TeleportWarpInPlayerAnim(u8 taskId) +{ + struct ObjectEvent *object = &gObjectEvents[gPlayerAvatar.objectEventId]; + struct Sprite *sprite = &gSprites[object->spriteId]; + s16 *data = gTasks[taskId].data; + + switch (tState) + { + case 0: + tFinalFacingDirection = GetTeleportSavedFacingDirection(); + ObjectEventForceSetHeldMovement(object, GetFaceDirectionMovementAction(sTeleportFacingDirectionSequence[tFinalFacingDirection])); + tRotationTimer = 0; + tDeltaY = 116; + tYpos = sprite->pos1.y; + tPriority = sprite->oam.priority; + tSubpriority = sprite->subpriority; + tYdeflection = -((u16)sprite->pos2.y + 32) * 16; + sprite->pos2.y = 0; + CameraObjectReset2(); + object->fixedPriority = TRUE; + sprite->oam.priority = 1; + sprite->subpriority = 0; + sprite->subspriteMode = SUBSPRITES_OFF; + tState++; + case 1: + TeleportAnim_RotatePlayer(object, &tRotationTimer); + tYdeflection += tDeltaY; + tDeltaY -= 3; + if (tDeltaY < 4) + { + tDeltaY = 4; + } + sprite->pos1.y = tYdeflection >> 4; + if (sprite->pos1.y >= tYpos) + { + sprite->pos1.y = tYpos; + tLandingDelay = 0; + tState++; + } + break; + case 2: + TeleportAnim_RotatePlayer(object, &tRotationTimer); + tLandingDelay++; + if (tLandingDelay > 8) + { + tState++; + } + break; + case 3: + if (tFinalFacingDirection == TeleportAnim_RotatePlayer(object, &tRotationTimer)) + { + object->fixedPriority = 0; + sprite->oam.priority = tPriority; + sprite->subpriority = tSubpriority; + CameraObjectReset1(); + DestroyTask(taskId); + } + break; + } +} + +static u8 TeleportAnim_RotatePlayer(struct ObjectEvent *object, s16 *a1) +{ + if (*a1 < 8 && ++(*a1) < 8) + { + return object->facingDirection; + } + + if (!ObjectEventCheckHeldMovementStatus(object)) + { + return object->facingDirection; + } + + ObjectEventForceSetHeldMovement(object, GetFaceDirectionMovementAction(sTeleportFacingDirectionSequence[object->facingDirection])); + *a1 = 0; + return sTeleportFacingDirectionSequence[object->facingDirection]; +} + +#undef tLandingDelay +#undef tSubpriority +#undef tPriority +#undef tFinalFacingDirection +#undef tYpos +#undef tYdeflection +#undef tDeltaY +#undef tRotationTimer +#undef tState diff --git a/src/field_screen_effect.c b/src/field_screen_effect.c index 85739ad24..22043ed2d 100644 --- a/src/field_screen_effect.c +++ b/src/field_screen_effect.c @@ -360,7 +360,7 @@ static void Task_BarnDoorWipeChild(u8 taskId) #undef DIR_WIPE_OUT #undef tChildOffset -static bool8 sub_807F3A4(u8 taskId, const u8 *text, u8 x, u8 y) +static bool8 PrintWhiteOutRecoveryMessage(u8 taskId, const u8 *text, u8 x, u8 y) { u8 windowId = gTasks[taskId].data[1]; @@ -385,7 +385,7 @@ static bool8 sub_807F3A4(u8 taskId, const u8 *text, u8 x, u8 y) return FALSE; } -static void sub_807F45C(u8 taskId) +static void Task_RushInjuredPokemonToCenter(u8 taskId) { u8 windowId; const struct HealLocation *loc; @@ -399,7 +399,7 @@ static void sub_807F45C(u8 taskId) FillWindowPixelBuffer(windowId, PIXEL_FILL(0)); PutWindowTilemap(windowId); CopyWindowToVram(windowId, 3); - loc = GetHealLocationPointer(1); + loc = GetHealLocation(1); if (gSaveBlock1Ptr->lastHealLocation.mapGroup == loc->group && gSaveBlock1Ptr->lastHealLocation.mapNum == loc->map && gSaveBlock1Ptr->lastHealLocation.warpId == -1 @@ -410,14 +410,14 @@ static void sub_807F45C(u8 taskId) gTasks[taskId].data[0] = 1; break; case 1: - if (sub_807F3A4(taskId, gUnknown_841B554, 2, 8)) + if (PrintWhiteOutRecoveryMessage(taskId, gText_PlayerScurriedToCenter, 2, 8)) { ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], 2); ++gTasks[taskId].data[0]; } break; case 4: - if (sub_807F3A4(taskId, gUnknown_841B5B6, 2, 8)) + if (PrintWhiteOutRecoveryMessage(taskId, gText_PlayerScurriedBackHome, 2, 8)) { ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], 2); ++gTasks[taskId].data[0]; @@ -434,14 +434,14 @@ static void sub_807F45C(u8 taskId) ++gTasks[taskId].data[0]; break; case 3: - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) { DestroyTask(taskId); ScriptContext1_SetupScript(EventScript_AfterWhiteOutHeal); } break; case 6: - if (sub_807E418() == TRUE) + if (FieldFadeTransitionBackgroundEffectIsFinished() == TRUE) { DestroyTask(taskId); ScriptContext1_SetupScript(EventScript_AfterWhiteOutMomHeal); @@ -450,12 +450,12 @@ static void sub_807F45C(u8 taskId) } } -void sub_807F5F0(void) +void FieldCB_RushInjuredPokemonToCenter(void) { u8 taskId; ScriptContext2_Enable(); palette_bg_faded_fill_black(); - taskId = CreateTask(sub_807F45C, 10); + taskId = CreateTask(Task_RushInjuredPokemonToCenter, 10); gTasks[taskId].data[0] = 0; } diff --git a/src/field_specials.c b/src/field_specials.c index 59c026b78..4089f68e8 100644 --- a/src/field_specials.c +++ b/src/field_specials.c @@ -95,7 +95,7 @@ static u8 *const sStringVarPtrs[] = { void ShowDiploma(void) { - sub_8112364(); + QuestLog_OnInteractionWithSpecialNpc(); SetMainCallback2(CB2_ShowDiploma); ScriptContext2_Enable(); } @@ -108,7 +108,7 @@ void ForcePlayerOntoBike(void) Overworld_ChangeMusicTo(MUS_CYCLING); } -void nullsub_74(void) +void ResetCyclingRoadChallengeData(void) { } @@ -187,7 +187,7 @@ u8 GetLeadMonFriendship(void) void ShowTownMap(void) { - sub_8112364(); + QuestLog_OnInteractionWithSpecialNpc(); sub_80BFF50(1, CB2_ReturnToFieldContinueScriptPlayMapMusic); } @@ -840,9 +840,9 @@ static const u8 sElevatorWindowAnimDuration[] = { void GetElevatorFloor(void) { u16 floor = 4; - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(SILPH_CO_1F): floor = 4; @@ -888,9 +888,9 @@ void GetElevatorFloor(void) break; } } - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(CELADON_CITY_DEPARTMENT_STORE_1F): floor = 4; @@ -909,9 +909,9 @@ void GetElevatorFloor(void) break; } } - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(TRAINER_TOWER_1F): case MAP_NUM(TRAINER_TOWER_2F): @@ -937,9 +937,9 @@ u16 InitElevatorFloorSelectMenuPos(void) sElevatorScroll = 0; sElevatorCursorPos = 0; - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(SILPH_CO_11F): sElevatorScroll = 0; @@ -999,9 +999,9 @@ u16 InitElevatorFloorSelectMenuPos(void) break; } } - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(CELADON_CITY_DEPARTMENT_STORE_5F): sElevatorScroll = 0; @@ -1025,9 +1025,9 @@ u16 InitElevatorFloorSelectMenuPos(void) break; } } - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(TRAINER_TOWER_1F): case MAP_NUM(TRAINER_TOWER_2F): @@ -2037,10 +2037,10 @@ const u16 sPokeCenter1FMaps[] = { MAP_UNDEFINED }; -bool8 sub_80CC87C(void) +bool8 UsedPokemonCenterWarp(void) { s32 i; - u16 mapno = (gUnknown_2031DB4.mapGroup << 8) + gUnknown_2031DB4.mapNum; + u16 mapno = (gLastUsedWarp.mapGroup << 8) + gLastUsedWarp.mapNum; for (i = 0; sPokeCenter1FMaps[i] != MAP_UNDEFINED; i++) { if (sPokeCenter1FMaps[i] == mapno) diff --git a/src/field_tasks.c b/src/field_tasks.c index 6bd4b6f46..4c7b93f20 100644 --- a/src/field_tasks.c +++ b/src/field_tasks.c @@ -63,7 +63,7 @@ static void Task_RunTimeBasedEvents(u8 taskId) { if (gQuestLogState != 2 && gQuestLogState != 3) { - sub_8056078(&data[1], &data[2]); + UpdateAmbientCry(&data[1], &data[2]); } } } diff --git a/src/fieldmap.c b/src/fieldmap.c index 53a97629f..60c6f3dae 100644 --- a/src/fieldmap.c +++ b/src/fieldmap.c @@ -370,7 +370,7 @@ union Block s32 xprime; \ s32 yprime; \ \ - struct MapLayout *mapLayout = gMapHeader.mapLayout; \ + const struct MapLayout *mapLayout = gMapHeader.mapLayout; \ \ xprime = x - 7; \ xprime += 8 * mapLayout->borderWidth; \ @@ -485,7 +485,7 @@ void MapGridSetMetatileImpassabilityAt(s32 x, s32 y, bool32 arg2) } } -u32 GetBehaviorByMetatileIdAndMapLayout(struct MapLayout *mapLayout, u16 metatile, u8 attr) +u32 GetBehaviorByMetatileIdAndMapLayout(const struct MapLayout *mapLayout, u16 metatile, u8 attr) { u32 * attributes; @@ -732,7 +732,7 @@ bool8 CameraMove(s32 x, s32 y) old_y = gSaveBlock1Ptr->pos.y; connection = sub_8059600(direction, gSaveBlock1Ptr->pos.x, gSaveBlock1Ptr->pos.y); sub_80594AC(connection, direction, x, y); - sub_8055864(connection->mapGroup, connection->mapNum); + LoadMapFromCameraTransition(connection->mapGroup, connection->mapNum); gCamera.active = TRUE; gCamera.x = old_x - gSaveBlock1Ptr->pos.x; gCamera.y = old_y - gSaveBlock1Ptr->pos.y; diff --git a/src/fldeff_strength.c b/src/fldeff_strength.c index c6b92b28c..c9a0fd1d5 100644 --- a/src/fldeff_strength.c +++ b/src/fldeff_strength.c @@ -13,7 +13,7 @@ static void ShowMonCB_UseStrength(void); bool8 SetUpFieldMove_Strength(void) { - if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) || CheckObjectGraphicsInFrontOfPlayer(OBJ_EVENT_GFX_STRENGTH_BOULDER) != TRUE) + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) || CheckObjectGraphicsInFrontOfPlayer(OBJ_EVENT_GFX_PUSHABLE_BOULDER) != TRUE) { return FALSE; } diff --git a/src/ghost.c b/src/ghost.c index 793c9838c..35dcd267b 100644 --- a/src/ghost.c +++ b/src/ghost.c @@ -984,7 +984,7 @@ static void sub_80B6468(u8 taskId) right = 240; top = 0; bottom = 112; - selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0); + selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0); BeginNormalPaletteFade(selectedPalettes, 0, 16, 16, RGB(0, 0, 0)); gTasks[taskId].func = sub_80B65F0; } diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c index 2284cbc3f..14f399f24 100644 --- a/src/hall_of_fame.c +++ b/src/hall_of_fame.c @@ -431,7 +431,7 @@ static void Task_Hof_InitTeamSaveData(u8 taskId) u16 i; struct HallofFameTeam* lastSavedTeam = (struct HallofFameTeam *)(gDecompressionBuffer); - sub_8112450(); + SaveQuestLogData(); if (!gHasHallOfFameRecords) { memset(gDecompressionBuffer, 0, 0x2000); @@ -706,7 +706,7 @@ static void Task_Hof_HandleExit(u8 taskId) static void SetWarpsToRollCredits(void) { VarSet(VAR_MAP_SCENE_INDIGO_PLATEAU_EXTERIOR, 1); - FlagSet(FLAG_SPECIAL_FLAG_0x4000); + FlagSet(FLAG_DONT_SHOW_MAP_NAME_POPUP); gDisableMapMusicChangeOnMapLoad = 2; SetWarpDestination(MAP_GROUP(INDIGO_PLATEAU_EXTERIOR), MAP_NUM(INDIGO_PLATEAU_EXTERIOR), -1, 11, 6); DoWarp(); diff --git a/src/heal_location.c b/src/heal_location.c index a8ac8cb46..ae02c7844 100644 --- a/src/heal_location.c +++ b/src/heal_location.c @@ -50,7 +50,7 @@ static const struct HealLocation * GetHealLocationPointerFromMapGroupAndNum(u16 return &sSpawnPoints[i - 1]; } -const struct HealLocation * GetHealLocationPointer(u32 idx) +const struct HealLocation * GetHealLocation(u32 idx) { if (idx == 0) return NULL; diff --git a/src/intro.c b/src/intro.c index 837d4f905..ec15d7473 100644 --- a/src/intro.c +++ b/src/intro.c @@ -1,10 +1,6 @@ #include "global.h" +#include "gflib.h" #include "m4a.h" -#include "malloc.h" -#include "bg.h" -#include "palette.h" -#include "main.h" -#include "gpu_regs.h" #include "task.h" #include "scanline_effect.h" #include "libgcnmultiboot.h" @@ -12,7 +8,6 @@ #include "link.h" #include "menu.h" #include "save.h" -#include "sound.h" #include "new_game.h" #include "title_screen.h" #include "decompress.h" @@ -21,29 +16,30 @@ #include "constants/songs.h" #include "constants/species.h" +struct IntroSequenceData; + +typedef void (*IntroCallback)(struct IntroSequenceData *); + struct IntroSequenceData { - void (*field_0000)(struct IntroSequenceData *); - u8 field_0004; - u8 field_0005; - u8 field_0006; - u16 field_0008; - u16 field_000A; - u8 filler_000C[6]; - u16 field_0012; - struct Sprite * field_0014; - struct Sprite * field_0018; - struct Sprite * field_001C; - struct Sprite * field_0020; - struct Sprite * field_0024; - struct Sprite * field_0028[4]; + IntroCallback callback; + u8 state; + u8 taskId; + bool8 gengarAttackLanded; + u16 data[6]; + struct Sprite * gameFreakLogoArtSprite; + struct Sprite * nidorinoAnimSprite; + struct Sprite * gengarStaticSprite; + struct Sprite * nidorinoStaticSprite; + struct Sprite * grassSprite; + struct Sprite * gengarBackSpriteArray[4]; u8 filler_0038[0x4]; - u8 field_003C[0x400]; - u8 field_043C[0x400]; + u8 gamefreakLogoArtSpriteTiles[0x400]; + u8 gamefreakTextBitmap[0x400]; u8 filler_083C[0x2080]; }; // size: 0x28BC -static EWRAM_DATA struct GcmbStruct gUnknown_203AAD4 = {0}; +static EWRAM_DATA struct GcmbStruct sGcmb = {0}; static EWRAM_DATA u16 gUnknown_203AB00 = 0; static EWRAM_DATA u16 gUnknown_203AB02 = 0; static EWRAM_DATA u16 gUnknown_203AB04 = 0; @@ -63,182 +59,177 @@ static EWRAM_DATA u16 gUnknown_203AB1E = 0; static EWRAM_DATA u16 gUnknown_203AB20 = 0; static EWRAM_DATA u16 gUnknown_203AB22 = 0; static EWRAM_DATA u16 gUnknown_203AB24 = 0; -static EWRAM_DATA u16 gUnknown_203AB26 = 0; -static EWRAM_DATA u32 gUnknown_203AB28 = 0; -static EWRAM_DATA s16 gUnknown_203AB2C = 0; -static EWRAM_DATA u16 gUnknown_203AB2E = 0; -static EWRAM_DATA u32 gUnknown_203AB30 = 0; - -static void sub_80EC870(void); -static void sub_80EC9D4(void); -static void sub_80EC9EC(void); -static void sub_80ECA00(void); -static void sub_80ECA70(void); -static void sub_80ECAB0(u8 taskId); -static void sub_80ECAA8(struct IntroSequenceData * ptr, void (*cb)(struct IntroSequenceData *)); -static void sub_80ECAF0(struct IntroSequenceData * ptr); -static void sub_80ECB98(struct IntroSequenceData * ptr); -static void sub_80ECC3C(struct IntroSequenceData * ptr); -static void sub_80ECCA8(struct IntroSequenceData * ptr); -static void sub_80ECD60(struct IntroSequenceData * ptr); -static void sub_80ECEA4(struct IntroSequenceData * ptr); -static void sub_80ED0AC(u8 taskId); -static void sub_80ED118(void); -static void sub_80ED140(u8 taskId); -static void sub_80ED188(struct IntroSequenceData * ptr); -static void sub_80ED40C(u8 taskId); -static void sub_80ED428(u8 taskId); -static void sub_80ED444(struct IntroSequenceData * ptr); -static void sub_80ED4A0(struct IntroSequenceData * ptr); -static void sub_80ED4C0(struct IntroSequenceData * ptr); -static void sub_80ED6D8(void); -static void sub_80ED714(u8 taskId); -static void sub_80ED7D4(struct IntroSequenceData * ptr); -static void sub_80ED818(struct Sprite * sprite); -static void sub_80ED898(struct IntroSequenceData * ptr); -static void sub_80EDAF0(struct IntroSequenceData * ptr); -static void sub_80EDB70(struct IntroSequenceData * ptr); -static void sub_80EDBAC(struct IntroSequenceData * ptr); -static void sub_80EDBE8(struct IntroSequenceData * ptr); -static void sub_80EDC40(void); -static void sub_80EDDF0(void); -static void sub_80EDE04(u8 taskId); -static void sub_80EDED8(void); -static void sub_80EDEEC(u8 taskId); -static struct Sprite * sub_80EDF68(void); -static void sub_80EDF94(struct IntroSequenceData * ptr); -static void sub_80EE024(u8 taskId); -static void sub_80EE160(void); -static void sub_80EE1C4(struct Sprite * sprite); -static void sub_80EE200(u8 taskId); -static void sub_80EE29C(struct Sprite * sprite); -static void sub_80EE350(struct Sprite * sprite); -static void sub_80EE40C(struct Sprite * sprite); -static void sub_80EE4DC(struct Sprite * sprite); -static void sub_80EE4F8(struct IntroSequenceData * ptr); -static void sub_80EE528(struct Sprite * sprite, s16 a1, s16 a2, u16 a3); -static void sub_80EE580(struct Sprite * sprite); -static bool32 sub_80EE5C8(struct IntroSequenceData * ptr); -static void sub_80EE5E4(struct IntroSequenceData * ptr); -static void sub_80EE610(struct Sprite * sprite); -static void sub_80EE6A4(struct IntroSequenceData * ptr); -static void sub_80EE704(struct Sprite * sprite); -static bool8 sub_80EE850(struct IntroSequenceData * ptr); -static void sub_80EE864(s16 a1, s16 a2, s16 a3); -static void sub_80EE8E4(struct Sprite * sprite); -static void sub_80EE970(struct Sprite * sprite, u16 a1, s16 a2, u8 a3); -static void sub_80EE9D4(struct Sprite * sprite); -static void sub_80EEA94(struct IntroSequenceData * ptr); -static void sub_80EEB08(struct Sprite * sprite); -static void sub_80EEBE4(void); + +static void CB2_SetUpIntro(void); +static void CB2_Intro(void); +static void VBlankCB_Intro(void); +static void Intro_ResetGpuRegs(void); +static void StartIntroSequence(void); +static void Task_CallIntroCallback(u8 taskId); +static void SetIntroCB(struct IntroSequenceData * ptr, IntroCallback cb); +static void IntroCB_Init(struct IntroSequenceData * ptr); +static void IntroCB_OpenWin1ToTheaterDimensions(struct IntroSequenceData * ptr); +static void IntroCB_GameFreakStar(struct IntroSequenceData * ptr); +static void IntroCB_GameFreakScene_RevealGameFreakText(struct IntroSequenceData * ptr); +static void IntroCB_GameFreakScene_CreateGameFreakLogo(struct IntroSequenceData * ptr); +static void IntroCB_FightScene(struct IntroSequenceData * ptr); +static void Task_FightScene1_GrassyFieldAnim(u8 taskId); +static void FightScene1_SignalEndGrassyFieldAnim(void); +static void Task_FightScene1_ZoomEffect(u8 taskId); +static void IntroCB_FightScene2(struct IntroSequenceData * ptr); +static void Task_FightScene2_CameraHorizPanEffect(u8 taskId); +static void Task_FightScene2_CameraVertPanEffect(u8 taskId); +static void CreateMonStaticSprites(struct IntroSequenceData * ptr); +static void DestroyStaticMonSprites(struct IntroSequenceData * ptr); +static void IntroCB_FightScene3(struct IntroSequenceData * ptr); +static void FightScene3_StartBg1Scroll(void); +static void Task_FightScene3_ForestBgScroll(u8 taskId); +static void CreateGrassSprite(struct IntroSequenceData * ptr); +static void SpriteCB_Grass(struct Sprite * sprite); +static void IntroCB_FightScene4(struct IntroSequenceData * ptr); +static void CreateGengarBackSprite(struct IntroSequenceData * ptr); +static void FightScene4_StartNidorinoAffineAnim(struct IntroSequenceData * ptr); +static void FightScene4_StartGengarAffineAnim(struct IntroSequenceData * ptr); +static void IntroCB_CleanUp(struct IntroSequenceData * ptr); +static void GameFreakScene_LoadGfxCreateStar(void); +static void GameFreakScene_StartTrailingSparkleSpawner(void); +static void Task_GameFreakScene_TrailingSparkleSpawner(u8 taskId); +static void GameFreakScene_StartRevealGameFreakTextSparklesSpawner(void); +static void Task_RevealGameFreakTextSparklesSpawner(u8 taskId); +static struct Sprite * CreateGameFreakLogoArtSprite(void); +static void FightScene4_StartGengarAttack(struct IntroSequenceData * ptr); +static void Task_FightScene4_GengarAttack(u8 taskId); +static void FightScene4_CreateGengarSwipeSprites(void); +static void SpriteCB_GengarSwipe(struct Sprite * sprite); +static void Task_FightScene3_Bg0Scroll(u8 taskId); +static void SpriteCB_LargeStar(struct Sprite * sprite); +static void SpriteCB_TrailingSparkles(struct Sprite * sprite); +static void SpriteCB_TrailingSparkles2(struct Sprite * sprite); +static void SpriteCB_RevealGameFreakTextSparkles(struct Sprite * sprite); +static void CreateNidorinoAnimSprite(struct IntroSequenceData * ptr); +static void StartNidorinoAnimSpriteSlideIn(struct Sprite * sprite, s16 x0, s16 x1, u16 speed); +static void SpriteCB_NidorinoAnimSpriteSlideIn(struct Sprite * sprite); +static bool32 IsNidorinoAnimSpriteSlideInRunning(struct IntroSequenceData * ptr); +static void FightScene4_NidorinoRearsUp(struct IntroSequenceData * ptr); +static void SpriteCB_NidorinoRearsUp(struct Sprite * sprite); +static void FightScene4_StartNidorinoRecoilAnim(struct IntroSequenceData * ptr); +static void SpriteCB_NidorinoRecoil(struct Sprite * sprite); +static bool8 FightScene4_NidorinoAnimIsRunning(struct IntroSequenceData * ptr); +static void CreateNidorinoRecoilDustSprites(s16 a1, s16 a2, s16 a3); +static void SpriteCB_NidorinoRecoilDust(struct Sprite * sprite); +static void StartSpriteHopToPosAnim(struct Sprite * sprite, u16 a1, s16 a2, u8 a3); +static void SpriteCB_HopToPos(struct Sprite * sprite); +static void StartNidorinoAnim_LaunchSelfAtGengarAnim(struct IntroSequenceData * ptr); +static void SpriteCB_NidorinoAnim_LaunchSelfAtGengar(struct Sprite * sprite); +static void LoadFightSceneSpriteTilesAndPals(void); #if REVISION >= 1 -static void sub_rev1_80EDFAC(void); +static void Rev1_GameFreakScene_CreatePresentsText(void); #else -#define sub_rev1_80EDFAC() +#define Rev1_GameFreakScene_CreatePresentsText() #endif extern const u32 gMultiBootProgram_PokemonColosseum_Start[]; -static const u16 gUnknown_8402260[] = INCBIN_U16("graphics/intro/unk_8402260.gbapal"); -static const u8 gUnknown_8402280[] = INCBIN_U8("graphics/intro/unk_8402280.4bpp.lz"); -static const u8 gUnknown_84024E4[] = INCBIN_U8("graphics/intro/unk_84024E4.bin.lz"); -static const u16 gUnknown_8402630[] = INCBIN_U16("graphics/intro/unk_8402630.gbapal"); -static const u8 gUnknown_8402650[] = INCBIN_U8("graphics/intro/unk_8402650.4bpp.lz"); -static const u8 gUnknown_8402668[] = INCBIN_U8("graphics/intro/unk_8402668.bin.lz"); -static const u16 gUnknown_840270C[] = INCBIN_U16("graphics/intro/unk_840270C.gbapal"); -static const u8 gUnknown_840272C[] = INCBIN_U8("graphics/intro/unk_840272C.4bpp.lz"); -static const u32 gUnknown_84028F8[] = INCBIN_U32("graphics/intro/unk_84028F8.bin.lz"); -static const u16 gUnknown_8402A44[] = INCBIN_U16("graphics/intro/unk_8402A64.gbapal"); -static const u32 gUnknown_8402A64[] = INCBIN_U32("graphics/intro/unk_8402A64.4bpp.lz"); -static const u16 gUnknown_8402ABC[] = INCBIN_U16("graphics/intro/unk_8402ADC.gbapal"); -static const u32 gUnknown_8402ADC[] = INCBIN_U32("graphics/intro/unk_8402ADC.4bpp.lz"); -static const u32 gUnknown_8402B2C[] = INCBIN_U32("graphics/intro/unk_8402B2C.4bpp.lz"); -static const u32 gUnknown_8402CD4[] = INCBIN_U32("graphics/intro/unk_8402CD4.4bpp.lz"); -static const u16 gUnknown_8402D34[] = INCBIN_U16("graphics/intro/unk_8402D34.gbapal"); -static const u8 gUnknown_8402D54[] = INCBIN_U8("graphics/intro/unk_8402D54.4bpp.lz"); -static const u8 gUnknown_8403FE8[] = INCBIN_U8("graphics/intro/unk_8403FE8.bin.lz"); -static const u16 gUnknown_84048CC[] = INCBIN_U16("graphics/intro/unk_84048CC.gbapal"); -static const u8 gUnknown_84048EC[] = INCBIN_U8("graphics/intro/unk_84048EC.4bpp.lz"); -static const u8 gUnknown_8404F7C[] = INCBIN_U8("graphics/intro/unk_8404F7C.bin.lz"); -static const u16 gUnknown_84053B4[] = INCBIN_U16("graphics/intro/unk_84053B4.gbapal"); -static const u8 gUnknown_8405414[] = INCBIN_U8("graphics/intro/unk_8405414.4bpp.lz"); -static const u8 gUnknown_8405890[] = INCBIN_U8("graphics/intro/unk_8405890.bin.lz"); -static const u16 gUnknown_8405B08[] = INCBIN_U16("graphics/intro/unk_8405B08.gbapal"); -static const u8 gUnknown_8405B28[] = INCBIN_U8("graphics/intro/unk_8405B28.4bpp.lz"); -static const u8 gUnknown_8405CDC[] = INCBIN_U8("graphics/intro/unk_8405CDC.bin.lz"); -static const u16 gUnknown_8405DA4[] = INCBIN_U16("graphics/intro/unk_8405DA4.gbapal"); -static const u8 gUnknown_8405DC4[] = INCBIN_U8("graphics/intro/unk_8405DC4.4bpp.lz"); -static const u8 gUnknown_840644C[] = INCBIN_U8("graphics/intro/unk_840644C.bin.lz"); -static const u16 gUnknown_8406634[] = INCBIN_U16("graphics/intro/unk_8406634.gbapal"); -static const u8 gUnknown_8406654[] = INCBIN_U8("graphics/intro/unk_8406654.4bpp.lz"); -static const u8 gUnknown_84071D0[] = INCBIN_U8("graphics/intro/unk_84071D0.bin.lz"); -static const u16 gUnknown_8407430[] = INCBIN_U16("graphics/intro/unk_8407430.gbapal"); -static const u8 gUnknown_8407470[] = INCBIN_U8("graphics/intro/unk_8407470.4bpp.lz"); -static const u8 gUnknown_8407A50[] = INCBIN_U8("graphics/intro/unk_8407A50.bin.lz"); -static const u8 gUnknown_8407B9C[] = INCBIN_U8("graphics/intro/unk_8407B9C.4bpp.lz"); -static const u8 gUnknown_8408D98[] = INCBIN_U8("graphics/intro/unk_8408D98.bin.lz"); -static const u32 gUnknown_840926C[] = INCBIN_U32("graphics/intro/unk_840926C.4bpp.lz"); -static const u16 gUnknown_84096AC[] = INCBIN_U16("graphics/intro/unk_84096AC.gbapal"); -static const u32 gUnknown_84096CC[] = INCBIN_U32("graphics/intro/unk_84096CC.4bpp.lz"); -static const u16 gUnknown_8409A1C[] = INCBIN_U16("graphics/intro/unk_8409A1C.gbapal"); -static const u32 gUnknown_8409A3C[] = INCBIN_U32("graphics/intro/unk_8409A3C.4bpp.lz"); -static const u32 gUnknown_8409D20[] = INCBIN_U32("graphics/intro/unk_8409D20.4bpp.lz"); -static const u32 gUnknown_840A3E4[] = INCBIN_U32("graphics/intro/unk_840A3E4.4bpp.lz"); -static const u16 gUnknown_840B834[] = INCBIN_U16("graphics/intro/unk_840B834.gbapal"); -static const u16 gUnknown_840B854[] = INCBIN_U16("graphics/intro/unk_840B854.gbapal"); -static const u32 gUnknown_840B874[] = INCBIN_U32("graphics/intro/unk_840B874.4bpp.lz"); -static const u32 gUnknown_840BAE0[] = INCBIN_U32("graphics/intro/unk_840BAE0.4bpp.lz"); - -static const struct BgTemplate gUnknown_840BB80[] = { +static const u16 sCopyrightGraphicsPal[] = INCBIN_U16("graphics/intro/unk_8402260.gbapal"); +static const u8 sCopyrightGraphicsTiles[] = INCBIN_U8("graphics/intro/unk_8402280.4bpp.lz"); +static const u8 sCopyrightGraphicsMap[] = INCBIN_U8("graphics/intro/unk_84024E4.bin.lz"); +static const u16 sBg3Pal_GameFreakPresents[] = INCBIN_U16("graphics/intro/unk_8402630.gbapal"); +static const u8 sBg3Tiles_GameFreakPresents[] = INCBIN_U8("graphics/intro/unk_8402650.4bpp.lz"); +static const u8 sBg3Map_GameFreakPresents[] = INCBIN_U8("graphics/intro/unk_8402668.bin.lz"); +static const u16 sSpritePals_GameFreakPresents[] = INCBIN_U16("graphics/intro/unk_840270C.gbapal"); +static const u8 sBlit_GameFreakText[] = INCBIN_U8("graphics/intro/unk_840272C.4bpp.lz"); +static const u32 sSpriteTiles_GameFreakLogoArt[] = INCBIN_U32("graphics/intro/unk_84028F8.4bpp.lz"); +static const u16 sSpritePals_LargeStar[] = INCBIN_U16("graphics/intro/unk_8402A64.gbapal"); +static const u32 sSpriteTiles_LargeStar[] = INCBIN_U32("graphics/intro/unk_8402A64.4bpp.lz"); +static const u16 sSpritePals_Sparkles[] = INCBIN_U16("graphics/intro/unk_8402ADC.gbapal"); +static const u32 sSpriteTiles_TrailingSparkles[] = INCBIN_U32("graphics/intro/unk_8402ADC.4bpp.lz"); +static const u32 sSpriteTiles_RevealGameFreakTextSparkles[] = INCBIN_U32("graphics/intro/unk_8402B2C.4bpp.lz"); +static const u32 sSpriteTiles_PresentsText[] = INCBIN_U32("graphics/intro/unk_8402CD4.4bpp.lz"); +static const u16 sBg0Pal_FightScene1[] = INCBIN_U16("graphics/intro/unk_8402D34.gbapal"); +static const u8 sBg0Tiles_FightScene1[] = INCBIN_U8("graphics/intro/unk_8402D54.4bpp.lz"); +static const u8 sBg0Map_FightScene1[] = INCBIN_U8("graphics/intro/unk_8403FE8.bin.lz"); +static const u16 sBg1Pal_FightScene1[] = INCBIN_U16("graphics/intro/unk_84048CC.gbapal"); +static const u8 sBg1Tiles_FightScene1[] = INCBIN_U8("graphics/intro/unk_84048EC.4bpp.lz"); +static const u8 sBg1Map_FightScene1[] = INCBIN_U8("graphics/intro/unk_8404F7C.bin.lz"); +static const u16 sBg3Pal_FightScene2[] = INCBIN_U16("graphics/intro/unk_84053B4.gbapal"); +static const u8 sBg3Tiles_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405414.4bpp.lz"); +static const u8 sBg3Map_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405890.bin.lz"); +static const u16 sBg0Pal_FightScene2[] = INCBIN_U16("graphics/intro/unk_8405B08.gbapal"); +static const u8 sBg0Tiles_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405B28.4bpp.lz"); +static const u8 sBg0Map_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405CDC.bin.lz"); +static const u16 sSpritePals_Gengar[] = INCBIN_U16("graphics/intro/unk_8405DA4.gbapal"); +static const u8 sBg2Tiles_FightScene2[] = INCBIN_U8("graphics/intro/unk_8405DC4.4bpp.lz"); +static const u8 sBg2Map_FightScene2[] = INCBIN_U8("graphics/intro/unk_840644C.bin.lz"); +static const u16 sBg1Pal_FightScene2[] = INCBIN_U16("graphics/intro/unk_8406634.gbapal"); +static const u8 sBg1Tiles_FightScene2[] = INCBIN_U8("graphics/intro/unk_8406654.4bpp.lz"); +static const u8 sBg1Map_FightScene2[] = INCBIN_U8("graphics/intro/unk_84071D0.bin.lz"); +static const u16 sBg1Pal_FightScene3[] = INCBIN_U16("graphics/intro/unk_8407430.gbapal"); +static const u8 sBg1Tiles_FightScene3[] = INCBIN_U8("graphics/intro/unk_8407470.4bpp.lz"); +static const u8 sBg1Map_FightScene3[] = INCBIN_U8("graphics/intro/unk_8407A50.bin.lz"); +static const u8 sBg0Tiles_FightScene3[] = INCBIN_U8("graphics/intro/unk_8407B9C.4bpp.lz"); +static const u8 sBg0Map_FightScene3[] = INCBIN_U8("graphics/intro/unk_8408D98.bin.lz"); +static const u32 sSpriteTiles_GengarStatic[] = INCBIN_U32("graphics/intro/unk_840926C.4bpp.lz"); +static const u16 sSpritePals_Nidorino[] = INCBIN_U16("graphics/intro/unk_84096AC.gbapal"); +static const u32 sSpriteTiles_NidorinoStatic[] = INCBIN_U32("graphics/intro/unk_84096CC.4bpp.lz"); +static const u16 sSpritePals_Grass[] = INCBIN_U16("graphics/intro/unk_8409A1C.gbapal"); +static const u32 sSpriteTiles_Grass[] = INCBIN_U32("graphics/intro/unk_8409A3C.4bpp.lz"); +static const u32 sSpriteTiles_GengarBack[] = INCBIN_U32("graphics/intro/unk_8409D20.4bpp.lz"); +static const u32 sSpriteTiles_NidorinoAnim[] = INCBIN_U32("graphics/intro/unk_840A3E4.4bpp.lz"); +static const u16 sSpritePals_GengarSwipe[] = INCBIN_U16("graphics/intro/unk_840B834.gbapal"); +static const u16 sSpritePals_NidorinoRecoilDust[] = INCBIN_U16("graphics/intro/unk_840B854.gbapal"); +static const u32 sSpriteTiles_GengarSwipe[] = INCBIN_U32("graphics/intro/unk_840B874.4bpp.lz"); +static const u32 sSpriteTiles_NidorinoRecoilDust[] = INCBIN_U32("graphics/intro/unk_840BAE0.4bpp.lz"); + +static const struct BgTemplate sBgTemplates_GameFreakScene[] = { { 3, 3, 31, 0, 0, 3, 0x000 }, { 2, 3, 30, 0, 0, 2, 0x010 } }; -static const struct BgTemplate gUnknown_840BB88[] = { +static const struct BgTemplate sBgTemplates_FightScene1[] = { { 0, 0, 28, 2, 0, 0, 0x000 }, { 1, 1, 30, 2, 0, 0, 0x000 } }; -static const struct BgTemplate gUnknown_840BB90[] = { +static const struct BgTemplate sBgTemplates_FightScene2[] = { { 3, 1, 30, 2, 0, 3, 0x000 }, { 0, 0, 29, 0, 0, 0, 0x000 }, { 2, 3, 27, 0, 0, 2, 0x000 }, { 1, 2, 28, 0, 0, 1, 0x000 } }; -static const struct BgTemplate gUnknown_840BBA0[] = { +static const struct BgTemplate sBgTemplates_FightScene3[] = { { 1, 0, 29, 0, 0, 1, 0x000 }, { 0, 1, 30, 2, 0, 0, 0x000 } }; -static const struct WindowTemplate gUnknown_840BBA8[] = { +static const struct WindowTemplate sWindowTemplate[] = { { 2, 6, 4, 18, 9, 0xD, 0x000 }, DUMMY_WIN_TEMPLATE }; -static const u8 gUnknown_840BBB8[][2] = { +static const u8 sGengarBackSpritePos2UpdateMods[][2] = { {0x3f, 0x3f}, {0x00, 0x3f}, {0x3f, 0x00}, {0x00, 0x00} }; -static const struct CompressedSpriteSheet gUnknown_840BBC0[] = { - {gUnknown_8402A64, 0x0080, 0}, - {gUnknown_8402ADC, 0x0080, 1}, - {gUnknown_8402B2C, 0x0800, 2}, - {gUnknown_84028F8, 0x0400, 3}, - {gUnknown_8402CD4, 0x0100, 4} +static const struct CompressedSpriteSheet sSpriteSheets_GameFreakScene[] = { + {sSpriteTiles_LargeStar, 0x0080, 0}, + {sSpriteTiles_TrailingSparkles, 0x0080, 1}, + {sSpriteTiles_RevealGameFreakTextSparkles, 0x0800, 2}, + {sSpriteTiles_GameFreakLogoArt, 0x0400, 3}, + {sSpriteTiles_PresentsText, 0x0100, 4} }; -static const struct SpritePalette gUnknown_840BBE8[] = { - {gUnknown_8402A44, 0}, - {gUnknown_8402ABC, 1}, - {gUnknown_840270C, 3}, +static const struct SpritePalette sSpritePalettes_GameFreakScene[] = { + {sSpritePals_LargeStar, 0}, + {sSpritePals_Sparkles, 1}, + {sSpritePals_GameFreakPresents, 3}, {0} }; -static const struct Coords16 gUnknown_840BC08[] = { +static const struct Coords16 sTrailingSparkleCoords[] = { {0x0048, 0x0050}, {0x0088, 0x004a}, {0x00a8, 0x0050}, @@ -275,9 +266,9 @@ static const union AnimCmd *const gAnimCmdTable_840BC64[] = { gAnimCmd_840BC50 }; -static const struct SpriteTemplate gUnknown_840BC6C = {0, 0, &gOamData_840BC2C, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, sub_80EE29C}; +static const struct SpriteTemplate sSpriteTemplate_LargeStar = {0, 0, &gOamData_840BC2C, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCB_LargeStar}; -static const struct SpriteTemplate gUnknown_840BC84 = {1, 1, &gOamData_840BC34, gAnimCmdTable_840BC64, NULL, gDummySpriteAffineAnimTable, sub_80EE350}; +static const struct SpriteTemplate sSpriteTemplate_TrailingSparkles = {1, 1, &gOamData_840BC34, gAnimCmdTable_840BC64, NULL, gDummySpriteAffineAnimTable, SpriteCB_TrailingSparkles}; static const struct OamData gOamData_840BC9C = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_2, .tileNum = 0x000, .priority = 2, .paletteNum = 0 }; @@ -293,15 +284,15 @@ static const union AnimCmd *const gAnimCmdTable_840BCB8[] = { gAnimCmd_840BCA4 }; -static const struct SpriteTemplate gUnknown_840BCBC = {2, 1, &gOamData_840BC9C, gAnimCmdTable_840BCB8, NULL, gDummySpriteAffineAnimTable, sub_80EE4DC}; +static const struct SpriteTemplate sSpriteTemplate_RevealGameFreakTextSparkles = {2, 1, &gOamData_840BC9C, gAnimCmdTable_840BCB8, NULL, gDummySpriteAffineAnimTable, SpriteCB_RevealGameFreakTextSparkles}; static const struct OamData gOamData_840BCD4 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_BLEND, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_V_RECTANGLE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 3, .paletteNum = 0 }; -static const struct SpriteTemplate gUnknown_840BCDC = {3, 3, &gOamData_840BCD4, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; +static const struct SpriteTemplate sSpriteTemplate_GameFreakLogoArt = {3, 3, &gOamData_840BCD4, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; static const struct OamData gOamData_840BCF4 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_BLEND, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_H_RECTANGLE, .matrixNum = 0, .size = ST_OAM_SIZE_1, .tileNum = 0x000, .priority = 3, .paletteNum = 0 }; -static const struct SpriteTemplate gUnknown_840BCFC = {4, 3, &gOamData_840BCF4, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; +static const struct SpriteTemplate sSpriteTemplate_PresentsText = {4, 3, &gOamData_840BCF4, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; static const struct OamData gOamData_840BD14 = { .affineMode = ST_OAM_AFFINE_DOUBLE, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 1, .paletteNum = 0 }; @@ -330,7 +321,7 @@ static const union AnimCmd gAnimCmd_840BD3C[] = { ANIMCMD_END }; -static const union AnimCmd *const gAnimCmdTable_840BD44[] = { +static const union AnimCmd *const sAnimTable_NidorinoAnim[] = { gAnimCmd_840BD1C, gAnimCmd_840BD24, gAnimCmd_840BD2C, @@ -349,18 +340,18 @@ static const union AffineAnimCmd gAffineAnimCmd_840BD68[] = { AFFINEANIMCMD_END }; -static const union AffineAnimCmd *const gAffineAnimCmdTable_840BD80[] = { +static const union AffineAnimCmd *const sAffineAnimTable_NidorinoAnim[] = { gAffineAnimCmd_840BD58, gAffineAnimCmd_840BD68 }; -static const struct SpriteTemplate gUnknown_840BD88 = {5, 7, &gOamData_840BD14, gAnimCmdTable_840BD44, NULL, gAffineAnimCmdTable_840BD80, SpriteCallbackDummy}; +static const struct SpriteTemplate sSpriteTemplate_NidorinoAnim = {5, 7, &gOamData_840BD14, sAnimTable_NidorinoAnim, NULL, sAffineAnimTable_NidorinoAnim, SpriteCallbackDummy}; static const struct OamData gOamData_840BDA0 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 1, .paletteNum = 0 }; -static const struct SpriteTemplate gUnknown_840BDA8 = {7, 7, &gOamData_840BDA0, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; +static const struct SpriteTemplate sSpriteTemplate_NidorinoStatic = {7, 7, &gOamData_840BDA0, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; -static const struct SpriteTemplate gUnknown_840BDC0 = {6, 6, &gOamData_840BDA0, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; +static const struct SpriteTemplate sSpriteTemplate_GengarStatic = {6, 6, &gOamData_840BDA0, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; static const struct OamData gOamData_840BDD8 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_H_RECTANGLE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 0, .paletteNum = 0 }; @@ -380,7 +371,7 @@ static const union AnimCmd *const gAnimCmdTable_840BDF4[] = { gAnimCmds_840BDE8 }; -static const struct SpriteTemplate gUnknown_840BDFC = {8, 8, &gOamData_840BDD8, gAnimCmdTable_840BDF4, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; +static const struct SpriteTemplate sSpriteTemplate_Grass = {8, 8, &gOamData_840BDD8, gAnimCmdTable_840BDF4, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy}; static const struct OamData gOamData_840BE14 = { .affineMode = ST_OAM_AFFINE_DOUBLE, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 1, .paletteNum = 0 }; @@ -411,7 +402,7 @@ static const union AnimCmd *const gAnimCmdTable_840BE3C[] = { gAnimCmd_840BE34 }; -static const struct SpriteTemplate gUnknown_840BE4C = {9, 6, &gOamData_840BE14, gAnimCmdTable_840BE3C, NULL, gAffineAnimCmdTable_840BD80, SpriteCallbackDummy}; +static const struct SpriteTemplate sSpriteTemplate_GengarBack = {9, 6, &gOamData_840BE14, gAnimCmdTable_840BE3C, NULL, sAffineAnimTable_NidorinoAnim, SpriteCallbackDummy}; static const struct OamData gOamData_840BE64 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_V_RECTANGLE, .matrixNum = 0, .size = ST_OAM_SIZE_3, .tileNum = 0x000, .priority = 1, .paletteNum = 0 }; @@ -432,7 +423,7 @@ static const union AnimCmd *const gAnimCmdTable_840BE84[] = { gAnimCmd_840BE78 }; -static const struct SpriteTemplate gUnknown_840BE8C = {10, 10, &gOamData_840BE64, gAnimCmdTable_840BE84, NULL, gDummySpriteAffineAnimTable, sub_80EE1C4}; +static const struct SpriteTemplate sSpriteTemplate_GengarSwipe = {10, 10, &gOamData_840BE64, gAnimCmdTable_840BE84, NULL, gDummySpriteAffineAnimTable, SpriteCB_GengarSwipe}; static const struct OamData gOamData_840BEA4 = { .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = ST_OAM_SQUARE, .matrixNum = 0, .size = ST_OAM_SIZE_1, .tileNum = 0x000, .priority = 1, .paletteNum = 0 }; @@ -448,58 +439,60 @@ static const union AnimCmd *const gAnimCmdTable_840BEC0[] = { gAnimCmd_840BEAC }; -static const struct SpriteTemplate gUnknown_840BEC4 = {11, 11, &gOamData_840BEA4, gAnimCmdTable_840BEC0, NULL, gDummySpriteAffineAnimTable, sub_80EE8E4}; +static const struct SpriteTemplate sSpriteTemplate_NidorinoRecoilDust = {11, 11, &gOamData_840BEA4, gAnimCmdTable_840BEC0, NULL, gDummySpriteAffineAnimTable, SpriteCB_NidorinoRecoilDust}; -static const struct CompressedSpriteSheet gUnknown_840BEDC[] = { - {gUnknown_840926C, 0x0800, 6}, - {gUnknown_84096CC, 0x0800, 7}, - {gUnknown_840A3E4, 0x2800, 5}, - {gUnknown_8409A3C, 0x0800, 8}, - {gUnknown_8409D20, 0x1800, 9}, - {gUnknown_840B874, 0x0a00, 10}, - {gUnknown_840BAE0, 0x0200, 11} +static const struct CompressedSpriteSheet sFightSceneSpriteSheets[] = { + {sSpriteTiles_GengarStatic, 0x0800, 6}, + {sSpriteTiles_NidorinoStatic, 0x0800, 7}, + {sSpriteTiles_NidorinoAnim, 0x2800, 5}, + {sSpriteTiles_Grass, 0x0800, 8}, + {sSpriteTiles_GengarBack, 0x1800, 9}, + {sSpriteTiles_GengarSwipe, 0x0a00, 10}, + {sSpriteTiles_NidorinoRecoilDust, 0x0200, 11} }; // POTENTIAL UB -// This array is passed to LoadSpritePalettes in sub_80EEBE4. +// This array is passed to LoadSpritePalettes in LoadFightSceneSpriteTilesAndPals. // LoadSpritePalettes uses a {0} entry to signal end of array. // Because such an entry is absent in this case, the function // continues reading into the next .rodata section. -static const struct SpritePalette gUnknown_840BF14[] = { - {gUnknown_8405DA4, 6}, - {gUnknown_84096AC, 7}, - {gUnknown_8409A1C, 8}, - {gUnknown_840B834, 10}, - {gUnknown_840B854, 11}, - // {0} +static const struct SpritePalette sFightSceneSpritePalettes[] = { + {sSpritePals_Gengar, 6}, + {sSpritePals_Nidorino, 7}, + {sSpritePals_Grass, 8}, + {sSpritePals_GengarSwipe, 10}, + {sSpritePals_NidorinoRecoilDust, 11}, +#ifdef BUGFIX + {0} +#endif }; -static void sub_80EC5A4(void) +static void VBlankCB_Copyright(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -static void sub_80EC5B8(void) +static void CB2_WaitFadeBeforeSetUpIntro(void) { if (!UpdatePaletteFade()) - SetMainCallback2(sub_80EC870); + SetMainCallback2(CB2_SetUpIntro); } -static void load_copyright_graphics(u16 a, u16 b, u16 c) +static void load_copyright_graphics(u16 charBase, u16 screenBase, u16 palOffset) { - LZ77UnCompVram(gUnknown_8402280, (void *)BG_VRAM + a); - LZ77UnCompVram(gUnknown_84024E4, (void *)BG_VRAM + b); - LoadPalette(gUnknown_8402260, c, 0x20); + LZ77UnCompVram(sCopyrightGraphicsTiles, (void *)BG_VRAM + charBase); + LZ77UnCompVram(sCopyrightGraphicsMap, (void *)BG_VRAM + screenBase); + LoadPalette(sCopyrightGraphicsPal, palOffset, 0x20); } static void SerialCb_CopyrightScreen(void) { - GameCubeMultiBoot_HandleSerialInterrupt(&gUnknown_203AAD4); + GameCubeMultiBoot_HandleSerialInterrupt(&sGcmb); } -static bool8 sub_80EC62C(void) +static bool8 RunCopyrightScreen(void) { switch (gMain.state) { @@ -516,26 +509,27 @@ static bool8 sub_80EC62C(void) DmaFill32(3, 0, OAM, OAM_SIZE); DmaFill16(3, 0, PLTT + sizeof(vu16), PLTT_SIZE - sizeof(vu16)); ResetPaletteFade(); - load_copyright_graphics(0, 0x3800, 0); + load_copyright_graphics(0 * BG_CHAR_SIZE, 7 * BG_SCREEN_SIZE, 0); ScanlineEffect_Stop(); ResetTasks(); ResetSpriteData(); - FreeAllSpritePalettes();BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0xFFFF); - SetGpuReg(REG_OFFSET_BG0CNT, 0x700); + FreeAllSpritePalettes(); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0xFFFF); + SetGpuReg(REG_OFFSET_BG0CNT, BGCNT_PRIORITY(0) | BGCNT_CHARBASE(0) | BGCNT_16COLOR | BGCNT_SCREENBASE(7)); EnableInterrupts(INTR_FLAG_VBLANK); - SetVBlankCallback(sub_80EC5A4); + SetVBlankCallback(VBlankCB_Copyright); SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON); SetSerialCallback(SerialCb_CopyrightScreen); - GameCubeMultiBoot_Init(&gUnknown_203AAD4); + GameCubeMultiBoot_Init(&sGcmb); // fallthrough default: UpdatePaletteFade(); gMain.state++; - GameCubeMultiBoot_Main(&gUnknown_203AAD4); + GameCubeMultiBoot_Main(&sGcmb); break; case 140: - GameCubeMultiBoot_Main(&gUnknown_203AAD4); - if (gUnknown_203AAD4.gcmb_field_2 != 1) + GameCubeMultiBoot_Main(&sGcmb); + if (sGcmb.gcmb_field_2 != 1) { BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); gMain.state++; @@ -545,16 +539,17 @@ static bool8 sub_80EC62C(void) if (!UpdatePaletteFade()) { gMain.state++; - if (gUnknown_203AAD4.gcmb_field_2 != 0) + if (sGcmb.gcmb_field_2 != 0) { - if (gUnknown_203AAD4.gcmb_field_2 == 2) + if (sGcmb.gcmb_field_2 == 2) { + // Gc6e if (*((u32 *)0x020000AC) == 0x65366347) { CpuCopy16(gMultiBootProgram_PokemonColosseum_Start, (void *)EWRAM_START, 0x28000); *((u32 *)0x020000AC) = 0x65366347; } - GameCubeMultiBoot_ExecuteProgram(&gUnknown_203AAD4); + GameCubeMultiBoot_ExecuteProgram(&sGcmb); } } else @@ -567,7 +562,7 @@ static bool8 sub_80EC62C(void) break; case 142: ResetSerial(); - SetMainCallback2(sub_80EC5B8); + SetMainCallback2(CB2_WaitFadeBeforeSetUpIntro); break; } return TRUE; @@ -575,7 +570,7 @@ static bool8 sub_80EC62C(void) void c2_copyright_1(void) { - if (!sub_80EC62C()) + if (!RunCopyrightScreen()) { ResetMenuAndMonGlobals(); Save_ResetSaveCounters(); @@ -586,12 +581,12 @@ void c2_copyright_1(void) } } -void sub_80EC864(void) +void CB2_CopyrightScreen(void) { - sub_80EC62C(); + RunCopyrightScreen(); } -static void sub_80EC870(void) +static void CB2_SetUpIntro(void) { switch (gMain.state) { @@ -606,34 +601,34 @@ static void sub_80EC870(void) ResetSpriteData(); ResetPaletteFade(); ResetTempTileDataBuffers(); - sub_80ECA00(); + Intro_ResetGpuRegs(); DmaFill16(3, 0, VRAM, VRAM_SIZE); DmaFill32(3, 0, OAM, OAM_SIZE); DmaFill16(3, 0, PLTT, PLTT_SIZE); - FillPalette(0, 0, 0x400); - ResetBgsAndClearDma3BusyFlags(0); - InitBgsFromTemplates(0, gUnknown_840BB80, NELEMS(gUnknown_840BB80)); + FillPalette(RGB_BLACK, 0, 0x400); + ResetBgsAndClearDma3BusyFlags(FALSE); + InitBgsFromTemplates(0, sBgTemplates_GameFreakScene, NELEMS(sBgTemplates_GameFreakScene)); break; case 1: - LoadPalette(gUnknown_8402630, 0x00, 0x20); - DecompressAndCopyTileDataToVram(3, gUnknown_8402650, 0, 0, 0); - DecompressAndCopyTileDataToVram(3, gUnknown_8402668, 0, 0, 1); - LoadPalette(gUnknown_840270C, 0xD0, 0x20); + LoadPalette(sBg3Pal_GameFreakPresents, 0x00, 0x20); + DecompressAndCopyTileDataToVram(3, sBg3Tiles_GameFreakPresents, 0, 0, 0); + DecompressAndCopyTileDataToVram(3, sBg3Map_GameFreakPresents, 0, 0, 1); + LoadPalette(sSpritePals_GameFreakPresents, 0xD0, 0x20); break; case 2: if (!FreeTempTileDataBuffersIfPossible()) { - sub_80ECA70(); + StartIntroSequence(); BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK); - SetMainCallback2(sub_80EC9D4); - SetVBlankCallback(sub_80EC9EC); + SetMainCallback2(CB2_Intro); + SetVBlankCallback(VBlankCB_Intro); } return; } gMain.state++; } -static void sub_80EC9D4(void) +static void CB2_Intro(void) { RunTasks(); AnimateSprites(); @@ -641,14 +636,14 @@ static void sub_80EC9D4(void) UpdatePaletteFade(); } -static void sub_80EC9EC(void) +static void VBlankCB_Intro(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -static void sub_80ECA00(void) +static void Intro_ResetGpuRegs(void) { SetGpuReg(REG_OFFSET_DISPCNT, 0); SetGpuReg(REG_OFFSET_BLDCNT, 0); @@ -665,53 +660,53 @@ static void sub_80ECA00(void) SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON); } -static void sub_80ECA70(void) +static void StartIntroSequence(void) { struct IntroSequenceData * ptr = Alloc(sizeof(struct IntroSequenceData)); - sub_80ECAA8(ptr, sub_80ECAF0); - ptr->field_0005 = CreateTask(sub_80ECAB0, 3); - SetWordTaskArg(ptr->field_0005, 0, (uintptr_t)ptr); + SetIntroCB(ptr, IntroCB_Init); + ptr->taskId = CreateTask(Task_CallIntroCallback, 3); + SetWordTaskArg(ptr->taskId, 0, (uintptr_t)ptr); } -static void sub_80ECAA8(struct IntroSequenceData * ptr, void (*cb)(struct IntroSequenceData *)) +static void SetIntroCB(struct IntroSequenceData * ptr, IntroCallback cb) { - ptr->field_0000 = cb; - ptr->field_0004 = 0; + ptr->callback = cb; + ptr->state = 0; } -static void sub_80ECAB0(u8 taskId) +static void Task_CallIntroCallback(u8 taskId) { struct IntroSequenceData * ptr = (void *)GetWordTaskArg(taskId, 0); - if (JOY_NEW(A_BUTTON | START_BUTTON | SELECT_BUTTON) && ptr->field_0000 != sub_80EDBE8) - sub_80ECAA8(ptr, sub_80EDBE8); - ptr->field_0000(ptr); + if (JOY_NEW(A_BUTTON | START_BUTTON | SELECT_BUTTON) && ptr->callback != IntroCB_CleanUp) + SetIntroCB(ptr, IntroCB_CleanUp); + ptr->callback(ptr); } -static void sub_80ECAF0(struct IntroSequenceData * this) +static void IntroCB_Init(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: - InitWindows(gUnknown_840BBA8); - LZ77UnCompWram(gUnknown_840272C, this->field_043C); - LZ77UnCompWram(gUnknown_84028F8, this->field_003C); + InitWindows(sWindowTemplate); + LZ77UnCompWram(sBlit_GameFreakText, this->gamefreakTextBitmap); + LZ77UnCompWram(sSpriteTiles_GameFreakLogoArt, this->gamefreakLogoArtSpriteTiles); FillBgTilemapBufferRect(2, 0x000, 0, 0, 32, 32, 0x11); - FillWindowPixelBuffer(0, 0x00); - BlitBitmapToWindow(0, this->field_043C, 0, 40, 144, 16); + FillWindowPixelBuffer(0, PIXEL_FILL(0)); + BlitBitmapToWindow(0, this->gamefreakTextBitmap, 0, 40, 144, 16); PutWindowTilemap(0); CopyWindowToVram(0, 3); - this->field_0004++; + this->state++; break; case 1: if (!IsDma3ManagerBusyWithBgCopy()) - sub_80ECAA8(this, sub_80ECB98); + SetIntroCB(this, IntroCB_OpenWin1ToTheaterDimensions); break; } } -static void sub_80ECB98(struct IntroSequenceData * this) +static void IntroCB_OpenWin1ToTheaterDimensions(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON); @@ -719,232 +714,232 @@ static void sub_80ECB98(struct IntroSequenceData * this) SetGpuReg(REG_OFFSET_WINOUT, 0x0000); SetGpuReg(REG_OFFSET_WIN1H, 0x00F0); SetGpuReg(REG_OFFSET_WIN1V, 0x0000); - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; break; case 1: ShowBg(3); BlendPalettes(0xFFFFFFFF, 0x00, RGB_BLACK); - this->field_0004++; + this->state++; break; case 2: - this->field_0012 += 8; - if (this->field_0012 >= 0x30) - this->field_0012 = 0x30; - SetGpuReg(REG_OFFSET_WIN1V, ((0x50 - this->field_0012) << 8) | (0x50 + this->field_0012)); - if (this->field_0012 == 0x30) - sub_80ECAA8(this, sub_80ECC3C); + this->data[5] += 8; + if (this->data[5] >= 0x30) + this->data[5] = 0x30; + SetGpuReg(REG_OFFSET_WIN1V, ((0x50 - this->data[5]) << 8) | (0x50 + this->data[5])); + if (this->data[5] == 0x30) + SetIntroCB(this, IntroCB_GameFreakStar); break; } } -static void sub_80ECC3C(struct IntroSequenceData * this) +static void IntroCB_GameFreakStar(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: PlaySE(MUS_TITLEROG); - sub_80EDC40(); - this->field_0012 = 0; - this->field_0004++; + GameFreakScene_LoadGfxCreateStar(); + this->data[5] = 0; + this->state++; break; case 1: - this->field_0012++; - if (this->field_0012 == 30) + this->data[5]++; + if (this->data[5] == 30) { - sub_80EDDF0(); - this->field_0012 = 0; - this->field_0004++; + GameFreakScene_StartTrailingSparkleSpawner(); + this->data[5] = 0; + this->state++; } break; case 2: - this->field_0012++; - if (this->field_0012 == 90) - sub_80ECAA8(this, sub_80ECCA8); + this->data[5]++; + if (this->data[5] == 90) + SetIntroCB(this, IntroCB_GameFreakScene_RevealGameFreakText); break; } } -static void sub_80ECCA8(struct IntroSequenceData * this) +static void IntroCB_GameFreakScene_RevealGameFreakText(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: - sub_80EDED8(); - this->field_0012 = 0; - this->field_0004++; + GameFreakScene_StartRevealGameFreakTextSparklesSpawner(); + this->data[5] = 0; + this->state++; break; case 1: - this->field_0012++; - if (this->field_0012 >= 40) - this->field_0004++; + this->data[5]++; + if (this->data[5] >= 40) + this->state++; break; case 2: SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG0 | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_BG2 | BLDCNT_TGT2_BG3 | BLDCNT_TGT2_OBJ | BLDCNT_TGT2_BD); StartBlendTask(0, 16, 16, 0, 48, 0); - this->field_0004++; + this->state++; break; case 3: ShowBg(2); - this->field_0004++; + this->state++; break; case 4: if (!IsBlendTaskActive()) { SetGpuReg(REG_OFFSET_BLDCNT, 0); - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; } break; case 5: - this->field_0012++; - if (this->field_0012 > 50) - sub_80ECAA8(this, sub_80ECD60); + this->data[5]++; + if (this->data[5] > 50) + SetIntroCB(this, IntroCB_GameFreakScene_CreateGameFreakLogo); break; } } -static void sub_80ECD60(struct IntroSequenceData * this) +static void IntroCB_GameFreakScene_CreateGameFreakLogo(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_OBJ | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG0 | BLDCNT_TGT2_BG1 | BLDCNT_TGT2_BG2 | BLDCNT_TGT2_BG3 | BLDCNT_TGT2_OBJ | BLDCNT_TGT2_BD); StartBlendTask(0, 16, 16, 0, 16, 0); - this->field_0008 = 0; - this->field_000A = 16; - this->field_0012 = 0; - this->field_0004++; + this->data[0] = 0; + this->data[1] = 16; + this->data[5] = 0; + this->state++; break; case 1: - this->field_0014 = sub_80EDF68(); - this->field_0004++; + this->gameFreakLogoArtSprite = CreateGameFreakLogoArtSprite(); + this->state++; break; case 2: if (!IsBlendTaskActive()) { - BlitBitmapToWindow(0, this->field_003C, 0x38, 0x06, 0x20, 0x40); - BlitBitmapToWindow(0, this->field_043C, 0x00, 0x28, 0x90, 0x10); + BlitBitmapToWindow(0, this->gamefreakLogoArtSpriteTiles, 0x38, 0x06, 0x20, 0x40); + BlitBitmapToWindow(0, this->gamefreakTextBitmap, 0x00, 0x28, 0x90, 0x10); CopyWindowToVram(0, 2); - this->field_0004++; + this->state++; } break; case 3: if (!IsDma3ManagerBusyWithBgCopy()) { - DestroySprite(this->field_0014); - sub_rev1_80EDFAC(); - this->field_0012 = 0; - this->field_0004++; + DestroySprite(this->gameFreakLogoArtSprite); + Rev1_GameFreakScene_CreatePresentsText(); + this->data[5] = 0; + this->state++; } break; case 4: - this->field_0012++; - if (this->field_0012 > 90) + this->data[5]++; + if (this->data[5] > 90) { SetGpuRegBits(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2); StartBlendTask(16, 0, 0, 16, 20, 0); - this->field_0004++; + this->state++; } break; case 5: if (!IsBlendTaskActive()) { HideBg(2); - this->field_0004++; + this->state++; } break; case 6: ResetSpriteData(); FreeAllSpritePalettes(); - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; break; case 7: - this->field_0012++; - if (this->field_0012 > 20) + this->data[5]++; + if (this->data[5] > 20) { SetGpuReg(REG_OFFSET_BLDCNT, 0); - sub_80ECAA8(this, sub_80ECEA4); + SetIntroCB(this, IntroCB_FightScene); } break; } } -static void sub_80ECEA4(struct IntroSequenceData * this) +static void IntroCB_FightScene(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: SetVBlankCallback(NULL); - LoadPalette(gUnknown_8402D34, 0x10, 0x20); - LoadPalette(gUnknown_84048CC, 0x20, 0x20); - BlendPalettes(0x06, 0x10, RGB_WHITE); - InitBgsFromTemplates(0, gUnknown_840BB88, NELEMS(gUnknown_840BB88)); - DecompressAndCopyTileDataToVram(1, gUnknown_84048EC, 0, 0, 0); - DecompressAndCopyTileDataToVram(1, gUnknown_8404F7C, 0, 0, 1); + LoadPalette(sBg0Pal_FightScene1, 0x10, 0x20); + LoadPalette(sBg1Pal_FightScene1, 0x20, 0x20); + BlendPalettes(0x00000006, 0x10, RGB_WHITE); + InitBgsFromTemplates(0, sBgTemplates_FightScene1, NELEMS(sBgTemplates_FightScene1)); + DecompressAndCopyTileDataToVram(1, sBg1Tiles_FightScene1, 0, 0, 0); + DecompressAndCopyTileDataToVram(1, sBg1Map_FightScene1, 0, 0, 1); ShowBg(1); HideBg(0); HideBg(2); HideBg(3); - sub_80EEBE4(); - SetVBlankCallback(sub_80EC9EC); - this->field_0004++; + LoadFightSceneSpriteTilesAndPals(); + SetVBlankCallback(VBlankCB_Intro); + this->state++; break; case 1: if (!FreeTempTileDataBuffersIfPossible()) { - DecompressAndCopyTileDataToVram(0, gUnknown_8402D54, 0, 0, 0); - DecompressAndCopyTileDataToVram(0, gUnknown_8403FE8, 0, 0, 1); + DecompressAndCopyTileDataToVram(0, sBg0Tiles_FightScene1, 0, 0, 0); + DecompressAndCopyTileDataToVram(0, sBg0Map_FightScene1, 0, 0, 1); ResetBgPositions(); ShowBg(1); - this->field_0004++; + this->state++; } break; case 2: if (!FreeTempTileDataBuffersIfPossible()) { ShowBg(0); - CreateTask(sub_80ED0AC, 0); + CreateTask(Task_FightScene1_GrassyFieldAnim, 0); BeginNormalPaletteFade(0x00000006, -2, 16, 0, RGB_WHITE); - this->field_0004++; + this->state++; } break; case 3: if (!gPaletteFade.active) { m4aSongNumStart(MUS_DEMO); - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; } break; case 4: - this->field_0012++; - if (this->field_0012 == 20) + this->data[5]++; + if (this->data[5] == 20) { - CreateTask(sub_80ED140, 0); - sub_80ED118(); + CreateTask(Task_FightScene1_ZoomEffect, 0); + FightScene1_SignalEndGrassyFieldAnim(); } - if (this->field_0012 >= 30) + if (this->data[5] >= 30) { - BlendPalettes(-2, 16, RGB_WHITE); - DestroyTask(FindTaskIdByFunc(sub_80ED0AC)); - DestroyTask(FindTaskIdByFunc(sub_80ED140)); - sub_80ECAA8(this, sub_80ED188); + BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE); + DestroyTask(FindTaskIdByFunc(Task_FightScene1_GrassyFieldAnim)); + DestroyTask(FindTaskIdByFunc(Task_FightScene1_ZoomEffect)); + SetIntroCB(this, IntroCB_FightScene2); } break; case 5: if (!gPaletteFade.active) { - DestroyTask(FindTaskIdByFunc(sub_80ED0AC)); - DestroyTask(FindTaskIdByFunc(sub_80ED140)); - sub_80ECAA8(this, sub_80ED188); + DestroyTask(FindTaskIdByFunc(Task_FightScene1_GrassyFieldAnim)); + DestroyTask(FindTaskIdByFunc(Task_FightScene1_ZoomEffect)); + SetIntroCB(this, IntroCB_FightScene2); } break; } } -static void sub_80ED0AC(u8 taskId) +static void Task_FightScene1_GrassyFieldAnim(u8 taskId) { s16 * data = gTasks[taskId].data; @@ -964,13 +959,13 @@ static void sub_80ED0AC(u8 taskId) } } -static void sub_80ED118(void) +static void FightScene1_SignalEndGrassyFieldAnim(void) { - u8 taskId = FindTaskIdByFunc(sub_80ED0AC); + u8 taskId = FindTaskIdByFunc(Task_FightScene1_GrassyFieldAnim); gTasks[taskId].data[2] = TRUE; } -static void sub_80ED140(u8 taskId) +static void Task_FightScene1_ZoomEffect(u8 taskId) { s16 * data = gTasks[taskId].data; @@ -984,146 +979,146 @@ static void sub_80ED140(u8 taskId) } } -static void sub_80ED188(struct IntroSequenceData * this) +static void IntroCB_FightScene2(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE); - InitBgsFromTemplates(0, gUnknown_840BB90, NELEMS(gUnknown_840BB90)); - DecompressAndCopyTileDataToVram(3, gUnknown_8405414, 0, 0, 0); - DecompressAndCopyTileDataToVram(3, gUnknown_8405890, 0, 0, 1); + InitBgsFromTemplates(0, sBgTemplates_FightScene2, NELEMS(sBgTemplates_FightScene2)); + DecompressAndCopyTileDataToVram(3, sBg3Tiles_FightScene2, 0, 0, 0); + DecompressAndCopyTileDataToVram(3, sBg3Map_FightScene2, 0, 0, 1); ShowBg(3); - this->field_0004++; + this->state++; break; case 1: if (!FreeTempTileDataBuffersIfPossible()) { SetVBlankCallback(NULL); - LoadPalette(gUnknown_84053B4, 0x10, 0x60); - LoadPalette(gUnknown_8405DA4, 0x50, 0x20); - LoadPalette(gUnknown_8406634, 0x60, 0x20); + LoadPalette(sBg3Pal_FightScene2, 0x10, 0x60); + LoadPalette(sSpritePals_Gengar, 0x50, 0x20); + LoadPalette(sBg1Pal_FightScene2, 0x60, 0x20); BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE); - DecompressAndCopyTileDataToVram(0, gUnknown_8405B28, 0, 0, 0); - DecompressAndCopyTileDataToVram(0, gUnknown_8405CDC, 0, 0, 1); - DecompressAndCopyTileDataToVram(1, gUnknown_8406654, 0, 0, 0); - DecompressAndCopyTileDataToVram(1, gUnknown_84071D0, 0, 0, 1); - DecompressAndCopyTileDataToVram(2, gUnknown_8405DC4, 0, 0, 0); - DecompressAndCopyTileDataToVram(2, gUnknown_840644C, 0, 0, 1); + DecompressAndCopyTileDataToVram(0, sBg0Tiles_FightScene2, 0, 0, 0); + DecompressAndCopyTileDataToVram(0, sBg0Map_FightScene2, 0, 0, 1); + DecompressAndCopyTileDataToVram(1, sBg1Tiles_FightScene2, 0, 0, 0); + DecompressAndCopyTileDataToVram(1, sBg1Map_FightScene2, 0, 0, 1); + DecompressAndCopyTileDataToVram(2, sBg2Tiles_FightScene2, 0, 0, 0); + DecompressAndCopyTileDataToVram(2, sBg2Map_FightScene2, 0, 0, 1); ResetBgPositions(); ShowBg(0); HideBg(1); HideBg(2); ChangeBgY(2, 0x0001CE00, 0); ChangeBgY(1, 0x00002800, 0); - CreateTask(sub_80ED40C, 0); - sub_80ED444(this); + CreateTask(Task_FightScene2_CameraHorizPanEffect, 0); + CreateMonStaticSprites(this); BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE); - SetVBlankCallback(sub_80EC9EC); - this->field_0004++; + SetVBlankCallback(VBlankCB_Intro); + this->state++; } break; case 2: if (!FreeTempTileDataBuffersIfPossible()) { BeginNormalPaletteFade(0xFFFFFFFE, -2, 16, 0, RGB_WHITE); - this->field_0004++; + this->state++; } break; case 3: if (!gPaletteFade.active) { - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; } break; case 4: - this->field_0012++; - if (this->field_0012 >= 60) + this->data[5]++; + if (this->data[5] >= 60) { - this->field_0012 = 0; - DestroyTask(FindTaskIdByFunc(sub_80ED40C)); - sub_80ED4A0(this); - CreateTask(sub_80ED428, 0); + this->data[5] = 0; + DestroyTask(FindTaskIdByFunc(Task_FightScene2_CameraHorizPanEffect)); + DestroyStaticMonSprites(this); + CreateTask(Task_FightScene2_CameraVertPanEffect, 0); ChangeBgY(3, 0x00010000, 0); HideBg(0); ShowBg(3); ShowBg(1); ShowBg(2); - this->field_0004++; + this->state++; } break; case 5: if (!IsDma3ManagerBusyWithBgCopy()) { - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; } break; case 6: - this->field_0012++; - if (this->field_0012 >= 60) + this->data[5]++; + if (this->data[5] >= 60) { - DestroyTask(FindTaskIdByFunc(sub_80ED428)); - sub_80ECAA8(this, sub_80ED4C0); + DestroyTask(FindTaskIdByFunc(Task_FightScene2_CameraVertPanEffect)); + SetIntroCB(this, IntroCB_FightScene3); } break; } } -static void sub_80ED40C(u8 taskId) +static void Task_FightScene2_CameraHorizPanEffect(u8 taskId) { ChangeBgX(3, 0x0E0, 2); ChangeBgX(0, 0x110, 1); } -static void sub_80ED428(u8 taskId) +static void Task_FightScene2_CameraVertPanEffect(u8 taskId) { ChangeBgY(2, 0x020, 1); ChangeBgY(1, 0x024, 2); } -static void sub_80ED444(struct IntroSequenceData * this) +static void CreateMonStaticSprites(struct IntroSequenceData * this) { u8 spriteId; - this->field_001C = NULL; - this->field_0020 = NULL; + this->gengarStaticSprite = NULL; + this->nidorinoStaticSprite = NULL; - spriteId = CreateSprite(&gUnknown_840BDA8, 168, 80, 11); + spriteId = CreateSprite(&sSpriteTemplate_NidorinoStatic, 168, 80, 11); if (spriteId != MAX_SPRITES) - this->field_0020 = &gSprites[spriteId]; + this->nidorinoStaticSprite = &gSprites[spriteId]; - spriteId = CreateSprite(&gUnknown_840BDC0, 72, 80, 12); + spriteId = CreateSprite(&sSpriteTemplate_GengarStatic, 72, 80, 12); if (spriteId != MAX_SPRITES) - this->field_001C = &gSprites[spriteId]; + this->gengarStaticSprite = &gSprites[spriteId]; } -static void sub_80ED4A0(struct IntroSequenceData * this) +static void DestroyStaticMonSprites(struct IntroSequenceData * this) { - if (this->field_001C != NULL) - DestroySprite(this->field_001C); - if (this->field_0020 != NULL) - DestroySprite(this->field_0020); + if (this->gengarStaticSprite != NULL) + DestroySprite(this->gengarStaticSprite); + if (this->nidorinoStaticSprite != NULL) + DestroySprite(this->nidorinoStaticSprite); } -static void sub_80ED4C0(struct IntroSequenceData * this) +static void IntroCB_FightScene3(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: - LoadPalette(gUnknown_8407430, 0x10, 0x40); - LoadPalette(gUnknown_8405DA4, 0x50, 0x20); + LoadPalette(sBg1Pal_FightScene3, 0x10, 0x40); + LoadPalette(sSpritePals_Gengar, 0x50, 0x20); BlendPalettes(0xFFFFFFFE, 16, RGB_WHITE); - InitBgsFromTemplates(0, gUnknown_840BBA0, NELEMS(gUnknown_840BBA0)); - DecompressAndCopyTileDataToVram(1, gUnknown_8407470, 0, 0, 0); - DecompressAndCopyTileDataToVram(1, gUnknown_8407A50, 0, 0, 1); + InitBgsFromTemplates(0, sBgTemplates_FightScene3, NELEMS(sBgTemplates_FightScene3)); + DecompressAndCopyTileDataToVram(1, sBg1Tiles_FightScene3, 0, 0, 0); + DecompressAndCopyTileDataToVram(1, sBg1Map_FightScene3, 0, 0, 1); ShowBg(1); HideBg(0); HideBg(2); HideBg(3); ResetBgPositions(); - this->field_0004++; + this->state++; SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); SetGpuRegBits(REG_OFFSET_WININ, 0x12); ClearGpuRegBits(REG_OFFSET_WININ, 0x01); @@ -1134,13 +1129,13 @@ static void sub_80ED4C0(struct IntroSequenceData * this) case 1: if (!FreeTempTileDataBuffersIfPossible()) { - DecompressAndCopyTileDataToVram(0, gUnknown_8407B9C, 0, 0, 0); - DecompressAndCopyTileDataToVram(0, gUnknown_8408D98, 0, 0, 1); + DecompressAndCopyTileDataToVram(0, sBg0Tiles_FightScene3, 0, 0, 0); + DecompressAndCopyTileDataToVram(0, sBg0Map_FightScene3, 0, 0, 1); gUnknown_203AB00 = 4; gUnknown_203AB02 = 52; ChangeBgX(0, 0x00001800, 0); ChangeBgY(0, 0x0001F000, 0); - this->field_0004++; + this->state++; } break; case 2: @@ -1148,26 +1143,26 @@ static void sub_80ED4C0(struct IntroSequenceData * this) { BlendPalettes(0xFFFFFFFE, 0, RGB_WHITE); ShowBg(0); - CreateTask(sub_80ED714, 0); - sub_80EE4F8(this); - sub_80EE528(this->field_0018, 0, 0xB4, 0x34); - CreateTask(sub_80EE200, 0); - sub_80ED6D8(); - this->field_0012 = 0; - this->field_0004++; + CreateTask(Task_FightScene3_ForestBgScroll, 0); + CreateNidorinoAnimSprite(this); + StartNidorinoAnimSpriteSlideIn(this->nidorinoAnimSprite, 0, 0xB4, 0x34); + CreateTask(Task_FightScene3_Bg0Scroll, 0); + FightScene3_StartBg1Scroll(); + this->data[5] = 0; + this->state++; } break; case 3: - this->field_0012++; - if (this->field_0012 == 16) - sub_80ED7D4(this); - if (!sub_80EE5C8(this) && !FuncIsActiveTask(sub_80EE200)) - sub_80ECAA8(this, sub_80ED898); + this->data[5]++; + if (this->data[5] == 16) + CreateGrassSprite(this); + if (!IsNidorinoAnimSpriteSlideInRunning(this) && !FuncIsActiveTask(Task_FightScene3_Bg0Scroll)) + SetIntroCB(this, IntroCB_FightScene4); break; } } -static void sub_80ED69C(u8 taskId) +static void Task_FightScene3_Bg1Scroll(u8 taskId) { if (gTasks[taskId].data[0] == 0) ChangeBgX(1, 0x400, 2); @@ -1175,18 +1170,18 @@ static void sub_80ED69C(u8 taskId) ChangeBgX(1, 0x020, 2); } -static void sub_80ED6D8(void) +static void FightScene3_StartBg1Scroll(void) { - CreateTask(sub_80ED69C, 0); + CreateTask(Task_FightScene3_Bg1Scroll, 0); } -static void sub_80ED6EC(void) +static void FightScene3_SlowBg1Scroll(void) { - u8 taskId = FindTaskIdByFunc(sub_80ED69C); + u8 taskId = FindTaskIdByFunc(Task_FightScene3_Bg1Scroll); gTasks[taskId].data[0] = 1; } -static void sub_80ED714(u8 taskId) +static void Task_FightScene3_ForestBgScroll(u8 taskId) { s16 * data = gTasks[taskId].data; if (data[0] == 0) @@ -1201,37 +1196,37 @@ static void sub_80ED714(u8 taskId) } } -static void sub_80ED760(void) +static void FightScene3_PauseForestBgScroll(void) { - u8 taskId = FindTaskIdByFunc(sub_80ED714); + u8 taskId = FindTaskIdByFunc(Task_FightScene3_ForestBgScroll); gTasks[taskId].data[0] = 1; } -static void sub_80ED788(void) +static void FightScene3_ResumeForestBgScroll(void) { - u8 taskId = FindTaskIdByFunc(sub_80ED714); + u8 taskId = FindTaskIdByFunc(Task_FightScene3_ForestBgScroll); gTasks[taskId].data[0] = 0; } -static u8 sub_80ED7B0(void) +static bool8 FightScene3_GetForestBgScrollState(void) { - u8 taskId = FindTaskIdByFunc(sub_80ED714); + u8 taskId = FindTaskIdByFunc(Task_FightScene3_ForestBgScroll); return gTasks[taskId].data[2]; } -static void sub_80ED7D4(struct IntroSequenceData * this) +static void CreateGrassSprite(struct IntroSequenceData * this) { - u8 spriteId = CreateSprite(&gUnknown_840BDFC, 296, 112, 7); + u8 spriteId = CreateSprite(&sSpriteTemplate_Grass, 296, 112, 7); if (spriteId != MAX_SPRITES) { - this->field_0024 = &gSprites[spriteId]; - this->field_0024->callback = sub_80ED818; + this->grassSprite = &gSprites[spriteId]; + this->grassSprite->callback = SpriteCB_Grass; } else - this->field_0024 = NULL; + this->grassSprite = NULL; } -static void sub_80ED818(struct Sprite * sprite) +static void SpriteCB_Grass(struct Sprite * sprite) { s16 * data = sprite->data; @@ -1247,7 +1242,7 @@ static void sub_80ED818(struct Sprite * sprite) sprite->pos1.x = data[1] >> 5; if (sprite->pos1.x <= 52) { - sub_80ED6EC(); + FightScene3_SlowBg1Scroll(); data[0]++; } break; @@ -1264,206 +1259,207 @@ static void sub_80ED818(struct Sprite * sprite) } } -static void sub_80ED898(struct IntroSequenceData * this) +static void IntroCB_FightScene4(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; break; case 1: - this->field_0012++; - if (this->field_0012 > 30) + this->data[5]++; + if (this->data[5] > 30) { - sub_80EE5E4(this); - this->field_0004++; + FightScene4_NidorinoRearsUp(this); + this->state++; } break; case 2: - if (!sub_80EE850(this)) + if (!FightScene4_NidorinoAnimIsRunning(this)) { - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; } break; case 3: - this->field_0012++; - if (this->field_0012 > 30) + this->data[5]++; + if (this->data[5] > 30) { - sub_80ED760(); - sub_80EDF94(this); - this->field_0012 = 0; - this->field_0004++; + FightScene3_PauseForestBgScroll(); + FightScene4_StartGengarAttack(this); + this->data[5] = 0; + this->state++; } break; case 4: - if (this->field_0006) + if (this->gengarAttackLanded) { - sub_80EE6A4(this); - this->field_0004++; + FightScene4_StartNidorinoRecoilAnim(this); + this->state++; } break; case 5: - if (!sub_80EE850(this)) + if (!FightScene4_NidorinoAnimIsRunning(this)) { - sub_80ED788(); - this->field_0012 = 0; - this->field_0004++; + FightScene3_ResumeForestBgScroll(); + this->data[5] = 0; + this->state++; } break; case 6: - this->field_0012++; - if (this->field_0012 > 16) + this->data[5]++; + if (this->data[5] > 16) { - sub_80EE970(this->field_0018, 8, 12, 5); - this->field_0004++; + StartSpriteHopToPosAnim(this->nidorinoAnimSprite, 8, 12, 5); + this->state++; } break; case 7: - if (!sub_80EE850(this)) + if (!FightScene4_NidorinoAnimIsRunning(this)) { - sub_80EE970(this->field_0018, 8, 12, 5); - this->field_0004++; + StartSpriteHopToPosAnim(this->nidorinoAnimSprite, 8, 12, 5); + this->state++; } break; case 8: - if (!sub_80EE850(this)) + if (!FightScene4_NidorinoAnimIsRunning(this)) { - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; } break; case 9: - this->field_0012++; - if (this->field_0012 > 20) + this->data[5]++; + if (this->data[5] > 20) { - sub_80EEA94(this); - this->field_0012 = 0; - this->field_0004++; + StartNidorinoAnim_LaunchSelfAtGengarAnim(this); + this->data[5] = 0; + this->state++; } break; case 10: - if (!sub_80ED7B0()) + if (!FightScene3_GetForestBgScrollState()) { - sub_80ED760(); - sub_80EDAF0(this); - this->field_0004++; + FightScene3_PauseForestBgScroll(); + CreateGengarBackSprite(this); + this->state++; } break; case 11: HideBg(0); - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; break; case 12: - this->field_0012++; - if (this->field_0012 == 48) + this->data[5]++; + if (this->data[5] == 48) BeginNormalPaletteFade(0x00000006, 2, 0, 16, RGB_WHITE); - if (this->field_0012 > 120) + if (this->data[5] > 120) { - sub_80EDB70(this); - sub_80EDBAC(this); - this->field_0004++; - this->field_0012 = 0; + FightScene4_StartNidorinoAffineAnim(this); + FightScene4_StartGengarAffineAnim(this); + this->state++; + this->data[5] = 0; } break; case 13: - this->field_0012++; - if (this->field_0012 > 8) + this->data[5]++; + if (this->data[5] > 8) { CpuFill16(RGB_WHITE, gPlttBufferUnfaded + 16, 64); BeginNormalPaletteFade(0xFFFFFFFE, -2, 0, 16, RGB_BLACK); - this->field_0004++; + this->state++; } break; case 14: if (!gPaletteFade.active) { - this->field_0012 = 0; - this->field_0004++; + this->data[5] = 0; + this->state++; } break; case 15: - this->field_0012++; - if (this->field_0012 > 60) - sub_80ECAA8(this, sub_80EDBE8); + this->data[5]++; + if (this->data[5] > 60) + SetIntroCB(this, IntroCB_CleanUp); break; default: if (JOY_NEW(R_BUTTON)) { BlendPalettes(0xFFFF0064, 0, RGB_WHITE); - this->field_0018->pos2.x = 0; - this->field_0018->pos1.x = 0xB4; - this->field_0004 = 1; - this->field_0012 = 30; + this->nidorinoAnimSprite->pos2.x = 0; + this->nidorinoAnimSprite->pos1.x = 0xB4; + this->state = 1; + this->data[5] = 30; } break; } } -static void sub_80EDAD8(struct Sprite * sprite) +static void FightScene_CalcCenterToCornerVec(struct Sprite * sprite) { CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode); } -static void sub_80EDAF0(struct IntroSequenceData * this) +static void CreateGengarBackSprite(struct IntroSequenceData * this) { int i; + // Not using a subsprite table for this for (i = 0; i < 4; i++) { int x = (i & 1) * 48 + 49; int y = (i / 2) * 64 + 72; - u8 spriteId = CreateSprite(&gUnknown_840BE4C, x, y, 8); + u8 spriteId = CreateSprite(&sSpriteTemplate_GengarBack, x, y, 8); if (spriteId != MAX_SPRITES) { StartSpriteAnim(&gSprites[spriteId], i); - this->field_0028[i] = &gSprites[spriteId]; + this->gengarBackSpriteArray[i] = &gSprites[spriteId]; if (i & 1) - this->field_0028[i]->oam.shape = ST_OAM_V_RECTANGLE; - sub_80EDAD8(this->field_0028[i]); + this->gengarBackSpriteArray[i]->oam.shape = ST_OAM_V_RECTANGLE; + FightScene_CalcCenterToCornerVec(this->gengarBackSpriteArray[i]); } } } -static void sub_80EDB70(struct IntroSequenceData * this) +static void FightScene4_StartNidorinoAffineAnim(struct IntroSequenceData * this) { - this->field_0018->pos1.x += this->field_0018->pos2.x; - this->field_0018->pos1.y += this->field_0018->pos2.y; - obj_pos2_update_enable(this->field_0018, 0, 0x2A); - this->field_0018->callback = SpriteCallbackDummy; - StartSpriteAffineAnim(this->field_0018, 1); + this->nidorinoAnimSprite->pos1.x += this->nidorinoAnimSprite->pos2.x; + this->nidorinoAnimSprite->pos1.y += this->nidorinoAnimSprite->pos2.y; + obj_pos2_update_enable(this->nidorinoAnimSprite, 0, 0x2A); + this->nidorinoAnimSprite->callback = SpriteCallbackDummy; + StartSpriteAffineAnim(this->nidorinoAnimSprite, 1); } -static void nullsub_83(struct Sprite * sprite) +static void SpriteCB_DummyButNotDummy(struct Sprite * sprite) { } -static void sub_80EDBAC(struct IntroSequenceData * this) +static void FightScene4_StartGengarAffineAnim(struct IntroSequenceData * this) { int i; for (i = 0; i < 4; i++) { - StartSpriteAffineAnim(this->field_0028[i], 1); - this->field_0028[i]->callback = nullsub_83; - obj_pos2_update_enable(this->field_0028[i], gUnknown_840BBB8[i][0], gUnknown_840BBB8[i][1]); + StartSpriteAffineAnim(this->gengarBackSpriteArray[i], 1); + this->gengarBackSpriteArray[i]->callback = SpriteCB_DummyButNotDummy; + obj_pos2_update_enable(this->gengarBackSpriteArray[i], sGengarBackSpritePos2UpdateMods[i][0], sGengarBackSpritePos2UpdateMods[i][1]); } } -static void sub_80EDBE8(struct IntroSequenceData * this) +static void IntroCB_CleanUp(struct IntroSequenceData * this) { - switch (this->field_0004) + switch (this->state) { case 0: FillPalette(RGB_BLACK, 0, 0x400); - this->field_0004++; + this->state++; break; case 1: if (!FreeTempTileDataBuffersIfPossible()) { - DestroyTask(this->field_0005); + DestroyTask(this->taskId); Free(this); DisableInterrupts(INTR_FLAG_HBLANK); SetHBlankCallback(NULL); @@ -1473,16 +1469,17 @@ static void sub_80EDBE8(struct IntroSequenceData * this) } } -static void sub_80EDC40(void) +static void GameFreakScene_LoadGfxCreateStar(void) { int i; u8 spriteId; + static EWRAM_DATA u32 gUnknown_203AB28 = 0; - for (i = 0; i < NELEMS(gUnknown_840BBC0); i++) + for (i = 0; i < NELEMS(sSpriteSheets_GameFreakScene); i++) { - LoadCompressedSpriteSheet(&gUnknown_840BBC0[i]); + LoadCompressedSpriteSheet(&sSpriteSheets_GameFreakScene[i]); } - LoadSpritePalettes(gUnknown_840BBE8); + LoadSpritePalettes(sSpritePalettes_GameFreakScene); gUnknown_203AB0E = 0x60; gUnknown_203AB10 = 0x10; gUnknown_203AB12 = 0x07; @@ -1496,19 +1493,21 @@ static void sub_80EDC40(void) gUnknown_203AB24 = 0x05; if (gUnknown_203AB28 == 0) gUnknown_203AB28 = 354128453; - spriteId = CreateSprite(&gUnknown_840BC6C, 0xF8, 0x37, 0); + spriteId = CreateSprite(&sSpriteTemplate_LargeStar, 0xF8, 0x37, 0); if (spriteId != MAX_SPRITES) { gSprites[spriteId].data[0] = 0xF80; gSprites[spriteId].data[1] = 0x370; gSprites[spriteId].data[2] = gUnknown_203AB0E; gSprites[spriteId].data[3] = gUnknown_203AB10; - StoreWordInTwoHalfwords(&gSprites[spriteId].data[6], gUnknown_203AB28); + StoreWordInTwoHalfwords((u16 *)&gSprites[spriteId].data[6], gUnknown_203AB28); } } -static void sub_80EDD28(s16 x, s16 y, u16 a2) +static void GameFreakScene_TrailingSparklesGen(s16 x, s16 y, u16 a2) { + static EWRAM_DATA s16 gUnknown_203AB2C = 0; + u8 spriteId; s16 r4 = (a2 & gUnknown_203AB12) + 2; s16 r2 = gUnknown_203AB2C; @@ -1519,7 +1518,7 @@ static void sub_80EDD28(s16 x, s16 y, u16 a2) y += r2; if (x >= 1 && x <= 0xEF) { - spriteId = CreateSprite(&gUnknown_840BC84, x, y, 1); + spriteId = CreateSprite(&sSpriteTemplate_TrailingSparkles, x, y, 1); if (spriteId != MAX_SPRITES) { gSprites[spriteId].data[0] = x << gUnknown_203AB22; @@ -1530,12 +1529,12 @@ static void sub_80EDD28(s16 x, s16 y, u16 a2) } } -static void sub_80EDDF0(void) +static void GameFreakScene_StartTrailingSparkleSpawner(void) { - CreateTask(sub_80EDE04, 1); + CreateTask(Task_GameFreakScene_TrailingSparkleSpawner, 1); } -static void sub_80EDE04(u8 taskId) +static void Task_GameFreakScene_TrailingSparkleSpawner(u8 taskId) { s16 * data = gTasks[taskId].data; u8 r6; @@ -1546,16 +1545,16 @@ static void sub_80EDE04(u8 taskId) { data[2] = 0; r6 = data[0]; - spriteId = CreateSprite(&gUnknown_840BC84, gUnknown_840BC08[r6].x, gUnknown_840BC08[r6].y, 2); + spriteId = CreateSprite(&sSpriteTemplate_TrailingSparkles, sTrailingSparkleCoords[r6].x, sTrailingSparkleCoords[r6].y, 2); StartSpriteAnim(&gSprites[spriteId], 1); - gSprites[spriteId].callback = sub_80EE40C; - gSprites[spriteId].data[1] = gUnknown_840BC08[r6].y << 4; + gSprites[spriteId].callback = SpriteCB_TrailingSparkles2; + gSprites[spriteId].data[1] = sTrailingSparkleCoords[r6].y << 4; gSprites[spriteId].data[2] = 120; gSprites[spriteId].data[3] = data[1]; if (gSprites[spriteId].data[3] < 0) gSprites[spriteId].data[3] = 1; data[0]++; - if (data[0] < 0 || data[0] > 8) + if (data[0] >= NELEMS(sTrailingSparkleCoords)) { data[1]++; if (data[1] > 1) @@ -1566,12 +1565,12 @@ static void sub_80EDE04(u8 taskId) } } -static void sub_80EDED8(void) +static void GameFreakScene_StartRevealGameFreakTextSparklesSpawner(void) { - CreateTask(sub_80EDEEC, 2); + CreateTask(Task_RevealGameFreakTextSparklesSpawner, 2); } -static void sub_80EDEEC(u8 taskId) +static void Task_RevealGameFreakTextSparklesSpawner(u8 taskId) { s16 * data = gTasks[taskId].data; u8 r2; @@ -1580,9 +1579,9 @@ static void sub_80EDEEC(u8 taskId) { r2 = data[1]; data[1] += 4; - if (data[1] < 0 || data[1] > 8) - data[1] -= 9; - CreateSprite(&gUnknown_840BCBC, gUnknown_840BC08[r2].x, gUnknown_840BC08[r2].y, 3); + if (data[1] >= NELEMS(sTrailingSparkleCoords)) + data[1] -= NELEMS(sTrailingSparkleCoords); + CreateSprite(&sSpriteTemplate_RevealGameFreakTextSparkles, sTrailingSparkleCoords[r2].x, sTrailingSparkleCoords[r2].y, 3); data[2]++; if (data[2] > 8) DestroyTask(taskId); @@ -1592,34 +1591,34 @@ static void sub_80EDEEC(u8 taskId) data[0] = 0; } -static struct Sprite * sub_80EDF68(void) +static struct Sprite * CreateGameFreakLogoArtSprite(void) { - u8 spriteId = CreateSprite(&gUnknown_840BCDC, 120, 70, 4); + u8 spriteId = CreateSprite(&sSpriteTemplate_GameFreakLogoArt, 120, 70, 4); return &gSprites[spriteId]; } #if REVISION >= 1 -static void sub_rev1_80EDFAC(void) +static void Rev1_GameFreakScene_CreatePresentsText(void) { int i; for (i = 0; i < 2; i++) { - gSprites[CreateSprite(&gUnknown_840BCFC, 0x68 + 32 * i, 0x6c, 5)].oam.tileNum += i * 4; + gSprites[CreateSprite(&sSpriteTemplate_PresentsText, 0x68 + 32 * i, 0x6c, 5)].oam.tileNum += i * 4; } } #endif -static void sub_80EDF94(struct IntroSequenceData * this) +static void FightScene4_StartGengarAttack(struct IntroSequenceData * this) { u8 taskId; - this->field_0006 = 0; - taskId = CreateTask(sub_80EE024, 4); + this->gengarAttackLanded = FALSE; + taskId = CreateTask(Task_FightScene4_GengarAttack, 4); SetWordTaskArg(taskId, 5, (uintptr_t)this); gTasks[taskId].data[3] = 64; gTasks[taskId].data[4] = GetBgX(0); } -static void sub_80EDFD8(int a, int b, int c, int d) +static void FightScene4_ApplyGengarAnim(int a, int b, int c, int d) { ChangeBgY(0, (a << 15) + 0x1F000, 0); ChangeBgX(0, d, 0); @@ -1627,7 +1626,7 @@ static void sub_80EDFD8(int a, int b, int c, int d) ChangeBgY(0, c << 8, 2); } -static void sub_80EE024(u8 taskId) +static void Task_FightScene4_GengarAttack(u8 taskId) { s16 * data = gTasks[taskId].data; int b, c; @@ -1653,7 +1652,7 @@ static void sub_80EE024(u8 taskId) case 2: data[1]++; if (data[1] == 14) - ((struct IntroSequenceData *)GetWordTaskArg(taskId, 5))->field_0006 = 1; + ((struct IntroSequenceData *)GetWordTaskArg(taskId, 5))->gengarAttackLanded = TRUE; if (data[1] > 15) { data[1] = 0; @@ -1665,7 +1664,7 @@ static void sub_80EE024(u8 taskId) data[1]++; if (data[1] == 4) { - sub_80EE160(); + FightScene4_CreateGengarSwipeSprites(); data[8] = 32; data[9] = 48; data[7] = 3; @@ -1694,34 +1693,35 @@ static void sub_80EE024(u8 taskId) angle = data[3]; b = -((gSineTable[angle + 0x40] * data[9]) >> 8); c = data[8] - ((gSineTable[angle] * data[8]) >> 8); - sub_80EDFD8(data[7], b, c, data[4]); + FightScene4_ApplyGengarAnim(data[7], b, c, data[4]); } -static void sub_80EE160(void) +static void FightScene4_CreateGengarSwipeSprites(void) { u8 spriteId; - spriteId = CreateSprite(&gUnknown_840BE8C, 132, 78, 6); - spriteId = CreateSprite(&gUnknown_840BE8C, 132, 118, 6); + spriteId = CreateSprite(&sSpriteTemplate_GengarSwipe, 132, 78, 6); + spriteId = CreateSprite(&sSpriteTemplate_GengarSwipe, 132, 118, 6); if (spriteId != MAX_SPRITES) { gSprites[spriteId].oam.shape = ST_OAM_H_RECTANGLE; gSprites[spriteId].oam.size = ST_OAM_SIZE_2; - sub_80EDAD8(&gSprites[spriteId]); + FightScene_CalcCenterToCornerVec(&gSprites[spriteId]); StartSpriteAnim(&gSprites[spriteId], 1); } } -static void sub_80EE1C4(struct Sprite * sprite) +static void SpriteCB_GengarSwipe(struct Sprite * sprite) { sprite->invisible ^= TRUE; if (sprite->animEnded) DestroySprite(sprite); } -static void sub_80EE200(u8 taskId) +static void Task_FightScene3_Bg0Scroll(u8 taskId) { s16 * data = gTasks[taskId].data; + static EWRAM_DATA u32 gUnknown_203AB30 = 0; switch (data[0]) { @@ -1745,7 +1745,7 @@ static void sub_80EE200(u8 taskId) } } -static void sub_80EE29C(struct Sprite * sprite) +static void SpriteCB_LargeStar(struct Sprite * sprite) { u32 v; sprite->data[0] -= sprite->data[2]; @@ -1761,13 +1761,13 @@ static void sub_80EE29C(struct Sprite * sprite) v = v * 1103515245 + 24691; StoreWordInTwoHalfwords(&sprite->data[6], v); v >>= 16; - sub_80EDD28(sprite->pos1.x, sprite->pos1.y + sprite->pos2.y, v); + GameFreakScene_TrailingSparklesGen(sprite->pos1.x, sprite->pos1.y + sprite->pos2.y, v); } if (sprite->pos1.x < -8) DestroySprite(sprite); } -static void sub_80EE350(struct Sprite * sprite) +static void SpriteCB_TrailingSparkles(struct Sprite * sprite) { u32 v; @@ -1790,7 +1790,7 @@ static void sub_80EE350(struct Sprite * sprite) DestroySprite(sprite); } -static void sub_80EE40C(struct Sprite * sprite) +static void SpriteCB_TrailingSparkles2(struct Sprite * sprite) { if (sprite->data[2]) { @@ -1839,31 +1839,31 @@ static void sub_80EE40C(struct Sprite * sprite) } } -static void sub_80EE4DC(struct Sprite * sprite) +static void SpriteCB_RevealGameFreakTextSparkles(struct Sprite * sprite) { if (sprite->animEnded) DestroySprite(sprite); } -static void sub_80EE4F8(struct IntroSequenceData * this) +static void CreateNidorinoAnimSprite(struct IntroSequenceData * this) { - u8 spriteId = CreateSprite(&gUnknown_840BD88, 0, 0, 9); - this->field_0018 = &gSprites[spriteId]; + u8 spriteId = CreateSprite(&sSpriteTemplate_NidorinoAnim, 0, 0, 9); + this->nidorinoAnimSprite = &gSprites[spriteId]; } -static void sub_80EE528(struct Sprite * sprite, s16 a1, s16 a2, u16 a3) +static void StartNidorinoAnimSpriteSlideIn(struct Sprite * sprite, s16 x0, s16 x1, u16 speed) { - sprite->data[0] = a1 << 4; - sprite->data[1] = ((a2 - a1) << 4) / a3; - sprite->data[2] = a3; - sprite->data[3] = a2; + sprite->data[0] = x0 << 4; + sprite->data[1] = ((x1 - x0) << 4) / speed; + sprite->data[2] = speed; + sprite->data[3] = x1; sprite->data[4] = 0; - sprite->pos1.x = a1; + sprite->pos1.x = x0; sprite->pos1.y = 100; - sprite->callback = sub_80EE580; + sprite->callback = SpriteCB_NidorinoAnimSpriteSlideIn; } -static void sub_80EE580(struct Sprite * sprite) +static void SpriteCB_NidorinoAnimSpriteSlideIn(struct Sprite * sprite) { sprite->data[4]++; if (sprite->data[4] >= 40) @@ -1880,21 +1880,21 @@ static void sub_80EE580(struct Sprite * sprite) } } -static bool32 sub_80EE5C8(struct IntroSequenceData * ptr) +static bool32 IsNidorinoAnimSpriteSlideInRunning(struct IntroSequenceData * ptr) { - return ptr->field_0018->callback == sub_80EE580 ? TRUE : FALSE; + return ptr->nidorinoAnimSprite->callback == SpriteCB_NidorinoAnimSpriteSlideIn ? TRUE : FALSE; } -static void sub_80EE5E4(struct IntroSequenceData * ptr) +static void FightScene4_NidorinoRearsUp(struct IntroSequenceData * ptr) { - StartSpriteAnim(ptr->field_0018, 2); - ptr->field_0018->data[0] = 0; - ptr->field_0018->data[1] = 0; - ptr->field_0018->pos2.y = 3; - ptr->field_0018->callback = sub_80EE610; + StartSpriteAnim(ptr->nidorinoAnimSprite, 2); + ptr->nidorinoAnimSprite->data[0] = 0; + ptr->nidorinoAnimSprite->data[1] = 0; + ptr->nidorinoAnimSprite->pos2.y = 3; + ptr->nidorinoAnimSprite->callback = SpriteCB_NidorinoRearsUp; } -static void sub_80EE610(struct Sprite * sprite) +static void SpriteCB_NidorinoRearsUp(struct Sprite * sprite) { switch (sprite->data[0]) { @@ -1930,23 +1930,23 @@ static void sub_80EE610(struct Sprite * sprite) } } -static void sub_80EE6A4(struct IntroSequenceData * ptr) +static void FightScene4_StartNidorinoRecoilAnim(struct IntroSequenceData * ptr) { gUnknown_203AB0A = 16; gUnknown_203AB04 = 3; gUnknown_203AB08 = 5; gUnknown_203AB06 = 0; - StartSpriteAnim(ptr->field_0018, 2); - ptr->field_0018->data[0] = 0; - ptr->field_0018->data[1] = 0; - ptr->field_0018->data[2] = 0; - ptr->field_0018->data[3] = 0; - ptr->field_0018->data[4] = 0; - ptr->field_0018->data[7] = 40; - ptr->field_0018->callback = sub_80EE704; + StartSpriteAnim(ptr->nidorinoAnimSprite, 2); + ptr->nidorinoAnimSprite->data[0] = 0; + ptr->nidorinoAnimSprite->data[1] = 0; + ptr->nidorinoAnimSprite->data[2] = 0; + ptr->nidorinoAnimSprite->data[3] = 0; + ptr->nidorinoAnimSprite->data[4] = 0; + ptr->nidorinoAnimSprite->data[7] = 40; + ptr->nidorinoAnimSprite->callback = SpriteCB_NidorinoRecoil; } -static void sub_80EE704(struct Sprite * sprite) +static void SpriteCB_NidorinoRecoil(struct Sprite * sprite) { switch (sprite->data[0]) { @@ -1985,7 +1985,7 @@ static void sub_80EE704(struct Sprite * sprite) sprite->data[1]++; if (sprite->data[1] > 6) { - sub_80EE864(sprite->pos1.x + sprite->pos2.x, sprite->pos1.y + sprite->pos2.y, sprite->data[6]); + CreateNidorinoRecoilDustSprites(sprite->pos1.x + sprite->pos2.x, sprite->pos1.y + sprite->pos2.y, sprite->data[6]); sprite->data[6] *= 1103515245; } if (sprite->data[1] > 12) @@ -1999,36 +1999,36 @@ static void sub_80EE704(struct Sprite * sprite) sprite->data[1]++; if (sprite->data[1] > 16) { - sub_80EE970(sprite, gUnknown_203AB0A, -sprite->pos2.x, 4); + StartSpriteHopToPosAnim(sprite, gUnknown_203AB0A, -sprite->pos2.x, 4); } break; } } -static bool8 sub_80EE850(struct IntroSequenceData * ptr) +static bool8 FightScene4_NidorinoAnimIsRunning(struct IntroSequenceData * ptr) { - return ptr->field_0018->callback == SpriteCallbackDummy ? FALSE : TRUE; + return ptr->nidorinoAnimSprite->callback == SpriteCallbackDummy ? FALSE : TRUE; } -static void sub_80EE864(s16 a1, s16 a2, s16 a3) +static void CreateNidorinoRecoilDustSprites(s16 x, s16 y, s16 seed) { int i; u8 spriteId; for (i = 0; i < 2; i++) { - spriteId = CreateSprite(&gUnknown_840BEC4, a1 - 22, a2 + 24, 10); + spriteId = CreateSprite(&sSpriteTemplate_NidorinoRecoilDust, x - 22, y + 24, 10); if (spriteId != MAX_SPRITES) { - gSprites[spriteId].data[3] = (a3 % 13) + 8; - gSprites[spriteId].data[4] = a3 % 3; + gSprites[spriteId].data[3] = (seed % 13) + 8; + gSprites[spriteId].data[4] = seed % 3; gSprites[spriteId].data[7] = i; - a3 *= 1103515245; + seed *= 1103515245; } } } -static void sub_80EE8E4(struct Sprite * sprite) +static void SpriteCB_NidorinoRecoilDust(struct Sprite * sprite) { s16 * data = sprite->data; @@ -2056,7 +2056,7 @@ static void sub_80EE8E4(struct Sprite * sprite) } } -static void sub_80EE970(struct Sprite * sprite, u16 a1, s16 a2, u8 a3) +static void StartSpriteHopToPosAnim(struct Sprite * sprite, u16 a1, s16 a2, u8 a3) { sprite->data[0] = 0; sprite->data[1] = a1; @@ -2067,10 +2067,10 @@ static void sub_80EE970(struct Sprite * sprite, u16 a1, s16 a2, u8 a3) sprite->data[6] = 0; sprite->data[7] = a3; StartSpriteAnim(sprite, 2); - sprite->callback = sub_80EE9D4; + sprite->callback = SpriteCB_HopToPos; } -static void sub_80EE9D4(struct Sprite * sprite) +static void SpriteCB_HopToPos(struct Sprite * sprite) { switch (sprite->data[0]) { @@ -2117,26 +2117,26 @@ static void sub_80EE9D4(struct Sprite * sprite) } } -static void sub_80EEA94(struct IntroSequenceData * ptr) +static void StartNidorinoAnim_LaunchSelfAtGengarAnim(struct IntroSequenceData * ptr) { - ptr->field_0018->data[0] = 0; - ptr->field_0018->data[1] = 0; - ptr->field_0018->data[2] = 0; - ptr->field_0018->data[3] = 0; - ptr->field_0018->data[4] = 0; - ptr->field_0018->data[5] = 0; - ptr->field_0018->pos1.x += ptr->field_0018->pos2.x; - ptr->field_0018->pos2.x = 0; + ptr->nidorinoAnimSprite->data[0] = 0; + ptr->nidorinoAnimSprite->data[1] = 0; + ptr->nidorinoAnimSprite->data[2] = 0; + ptr->nidorinoAnimSprite->data[3] = 0; + ptr->nidorinoAnimSprite->data[4] = 0; + ptr->nidorinoAnimSprite->data[5] = 0; + ptr->nidorinoAnimSprite->pos1.x += ptr->nidorinoAnimSprite->pos2.x; + ptr->nidorinoAnimSprite->pos2.x = 0; gUnknown_203AB0C = 0x24; gUnknown_203AB06 = 0x28; gUnknown_203AB04 = 0x03; gUnknown_203AB08 = 0x04; - ptr->field_0018->data[7] = 36; - StartSpriteAnim(ptr->field_0018, 2); - ptr->field_0018->callback = sub_80EEB08; + ptr->nidorinoAnimSprite->data[7] = 36; + StartSpriteAnim(ptr->nidorinoAnimSprite, 2); + ptr->nidorinoAnimSprite->callback = SpriteCB_NidorinoAnim_LaunchSelfAtGengar; } -static void sub_80EEB08(struct Sprite * sprite) +static void SpriteCB_NidorinoAnim_LaunchSelfAtGengar(struct Sprite * sprite) { switch (sprite->data[0]) { @@ -2178,15 +2178,15 @@ static void sub_80EEB08(struct Sprite * sprite) } } -static void sub_80EEBE4(void) +static void LoadFightSceneSpriteTilesAndPals(void) { int i; - for (i = 0; i < NELEMS(gUnknown_840BEDC); i++) + for (i = 0; i < NELEMS(sFightSceneSpriteSheets); i++) { - LoadCompressedSpriteSheet(&gUnknown_840BEDC[i]); + LoadCompressedSpriteSheet(&sFightSceneSpriteSheets[i]); } - // gUnknown_840BF14 is not properly terminated, so this + // sFightSceneSpritePalettes is not properly terminated, so this // call exhibits undefined behavior. - LoadSpritePalettes(gUnknown_840BF14); + LoadSpritePalettes(sFightSceneSpritePalettes); } diff --git a/src/item_menu.c b/src/item_menu.c index e048b4b78..ebad0640d 100644 --- a/src/item_menu.c +++ b/src/item_menu.c @@ -377,7 +377,7 @@ static void CB2_OpenBagMenu(void) { while (1) { - if ((u8)sub_80BF72C() == TRUE) + if ((u8)MenuHelpers_CallLinkSomething() == TRUE) break; if (LoadBagMenuGraphics() == TRUE) break; @@ -1050,7 +1050,7 @@ static void Task_BagMenu_HandleInput(u8 taskId) return; if (FuncIsActiveTask(Task_AnimateWin0v) == TRUE) return; - if ((u8)sub_80BF72C() == TRUE) + if ((u8)MenuHelpers_CallLinkSomething() == TRUE) return; switch (ProcessPocketSwitchInput(taskId, gBagMenuState.pocket)) { @@ -1244,7 +1244,7 @@ static void Task_MoveItemInPocket_HandleInput(u8 taskId) s32 input; u16 itemsAbove; u16 cursorPos; - if ((u8)sub_80BF72C() == TRUE) + if ((u8)MenuHelpers_CallLinkSomething() == TRUE) return; input = ListMenu_ProcessInput(data[0]); ListMenuGetScrollAndRow(data[0], &gBagMenuState.cursorPos[gBagMenuState.pocket], &gBagMenuState.itemsAbove[gBagMenuState.pocket]); @@ -1447,7 +1447,7 @@ static void Task_ItemContext_FieldOrBattle(u8 taskId) static void Task_FieldItemContextMenuHandleInput(u8 taskId) { s8 input; - if ((u8)sub_80BF72C() != TRUE) + if ((u8)MenuHelpers_CallLinkSomething() != TRUE) { input = Menu_ProcessInputNoWrapAround(); switch (input) @@ -2036,7 +2036,7 @@ bool8 UseRegisteredKeyItemOnField(void) ScriptContext2_Enable(); FreezeObjectEvents(); sub_805C270(); - sub_805C780(); + StopPlayerAvatar(); gSpecialVar_ItemId = gSaveBlock1Ptr->registeredItem; taskId = CreateTask(ItemId_GetFieldFunc(gSaveBlock1Ptr->registeredItem), 8); gTasks[taskId].data[3] = 1; diff --git a/src/item_pc.c b/src/item_pc.c index af57d9f03..1fda50d6f 100644 --- a/src/item_pc.c +++ b/src/item_pc.c @@ -385,7 +385,7 @@ static bool8 ItemPc_DoGfxSetup(void) gMain.state++; break; case 20: - if ((u8)sub_80BF72C() != TRUE) + if ((u8)MenuHelpers_CallLinkSomething() != TRUE) gMain.state++; break; default: diff --git a/src/item_use.c b/src/item_use.c index 6f81ee0e3..45bed65e8 100644 --- a/src/item_use.c +++ b/src/item_use.c @@ -263,12 +263,12 @@ void FieldUseFunc_MachBike(u8 taskId) behavior = MapGridGetMetatileBehaviorAt(x, y); if (FlagGet(FLAG_SYS_ON_CYCLING_ROAD) == TRUE - || MetatileBehavior_ReturnFalse_17(behavior) == TRUE - || MetatileBehavior_ReturnFalse_18(behavior) == TRUE - || MetatileBehavior_ReturnFalse_15(behavior) == TRUE - || MetatileBehavior_ReturnFalse_16(behavior) == TRUE) + || MetatileBehavior_IsVerticalRail(behavior) == TRUE + || MetatileBehavior_IsHorizontalRail(behavior) == TRUE + || MetatileBehavior_IsIsolatedVerticalRail(behavior) == TRUE + || MetatileBehavior_IsIsolatedHorizontalRail(behavior) == TRUE) sub_80A10C4(taskId, gTasks[taskId].data[3], 2, gUnknown_8416451); - else if (sub_8055C9C() == TRUE && !sub_80BD540()) + else if (Overworld_IsBikingAllowed() == TRUE && !MetatileAtPlayerPositionForbidsBiking()) { sItemUseOnFieldCB = ItemUseOnFieldCB_Bicycle; sub_80A103C(taskId); @@ -308,7 +308,7 @@ static bool8 ItemUseCheckFunc_Rod(void) if (MetatileBehavior_IsWaterfall(behavior)) return FALSE; - if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_4)) + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_UNDERWATER)) return FALSE; if (!TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING)) { @@ -327,7 +327,7 @@ static bool8 ItemUseCheckFunc_Rod(void) static void ItemUseOnFieldCB_Rod(u8 taskId) { - sub_805D2C0(ItemId_GetSecondaryId(gSpecialVar_ItemId)); + StartFishing(ItemId_GetSecondaryId(gSpecialVar_ItemId)); DestroyTask(taskId); } @@ -618,7 +618,7 @@ static void sub_80A1B48(u8 taskId) bool8 CanUseEscapeRopeOnCurrMap(void) { - if (gMapHeader.escapeRope & 1) + if (gMapHeader.flags & MAP_ALLOW_ESCAPE_ROPE) return TRUE; else return FALSE; diff --git a/src/itemfinder.c b/src/itemfinder.c index 5d6950acc..51a670b0f 100644 --- a/src/itemfinder.c +++ b/src/itemfinder.c @@ -15,7 +15,7 @@ static void Task_NoResponse_CleanUp(u8 taskId); static void Task_ItemfinderResponseSoundsAndAnims(u8 taskId); static void Task_ItemfinderUnderfootSoundsAndAnims(u8 taskId); -static bool8 HiddenItemIsWithinRangeOfPlayer(struct MapEvents * events, u8 taskId); +static bool8 HiddenItemIsWithinRangeOfPlayer(const struct MapEvents * events, u8 taskId); static void SetUnderfootHiddenItem(u8 taskId, u32 hiddenItem); static void SetNormalHiddenItem(u8 taskId); static void FindHiddenItemsInConnectedMaps(u8 taskId); @@ -199,7 +199,7 @@ static void Task_ItemfinderUnderfootSoundsAndAnims(u8 taskId) tDingTimer++; } -static bool8 HiddenItemIsWithinRangeOfPlayer(struct MapEvents * events, u8 taskId) +static bool8 HiddenItemIsWithinRangeOfPlayer(const struct MapEvents * events, u8 taskId) { s16 x, y, i, dx, dy; PlayerGetDestCoords(&x, &y); @@ -284,7 +284,7 @@ static void SetNormalHiddenItem(u8 taskId) } } -static bool8 HiddenItemAtPos(struct MapEvents * events, s16 x, s16 y) +static bool8 HiddenItemAtPos(const struct MapEvents * events, s16 x, s16 y) { u8 bgEventCount = events->bgEventCount; struct BgEvent * bgEvents = events->bgEvents; diff --git a/src/learn_move.c b/src/learn_move.c index 8a2f5781b..8cf10cffa 100644 --- a/src/learn_move.c +++ b/src/learn_move.c @@ -286,7 +286,7 @@ static void Task_InitMoveRelearnerMenu(u8 taskId) if (!gPaletteFade.active) { SetMainCallback2(CB2_MoveRelearner_Init); - gFieldCallback = FieldCallback_ReturnToEventScript2; + gFieldCallback = FieldCB_ContinueScriptHandleMusic; DestroyTask(taskId); } } diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index 2259e9214..15ffb4813 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -201,7 +201,7 @@ void ResetLinkRfuGFLayer(void) } ResetSendDataManager(&Rfu.cmd_8800_sendbuf); RFU_queue_20_70_reset(&Rfu.unk_124); - RFU_queue_40_14_reset(&Rfu.unk_9e8); + RFU_queue_40_14_reset(&Rfu.sendQueue); CpuFill16(0, gSendCmd, sizeof gSendCmd); CpuFill16(0, gRecvCmds, sizeof gRecvCmds); CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers); @@ -659,7 +659,7 @@ static void sub_80F906C(void) } if (Rfu.unk_c3c == 0) { - RFU_queue_40_14_send(&Rfu.unk_9e8, Rfu.unk_4c); + RFU_queue_40_14_send(&Rfu.sendQueue, Rfu.unk_4c); RFU_queue_2_14_recv(&Rfu.unk_c1c, Rfu.unk_4c); } } @@ -881,7 +881,7 @@ static bool32 RfuProcessEnqueuedRecvBlock(void) Rfu.unk_cd0--; CallRfuFunc(); sub_80F94BC(gSendCmd, sp48); - RFU_queue_40_14_recv(&Rfu.unk_9e8, sp48); + RFU_queue_40_14_recv(&Rfu.sendQueue, sp48); for (i = 0; i < CMD_LENGTH - 1; i++) gSendCmd[i] = 0; } @@ -909,7 +909,7 @@ static void HandleSendFailure(u8 unused, u32 flags) j++;j--; // Needed to match; } - RFU_queue_40_14_recv(&Rfu.unk_9e8, sResendBlock8); + RFU_queue_40_14_recv(&Rfu.sendQueue, sResendBlock8); Rfu.cmd_8800_sendbuf.failedFlags |= (1 << i); } flags >>= 1; @@ -1853,11 +1853,11 @@ static void RfuCheckErrorStatus(void) gWirelessCommType = 2; SetMainCallback2(CB2_LinkError); gMain.savedCallback = CB2_LinkError; - SetLinkErrorFromRfu((Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.unk_124.count, Rfu.unk_9e8.count, RfuGetErrorStatus() == 2); + SetLinkErrorFromRfu((Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.unk_124.count, Rfu.sendQueue.count, RfuGetErrorStatus() == 2); Rfu.errorState = 2; CloseLink(); } - else if (Rfu.unk_9e8.full == 1 || Rfu.unk_124.full == 1) + else if (Rfu.sendQueue.full == 1 || Rfu.unk_124.full == 1) { if (lman.childClockSlave_flag) rfu_LMAN_requestChangeAgbClockMaster(); @@ -2851,7 +2851,7 @@ static const char gUnknown_843EEA8[][8] = { static u32 sub_80FC44C(void) { - return Rfu.unk_9e8.count; + return Rfu.sendQueue.count; } u32 GetRfuRecvQueueLength(void) diff --git a/src/link_rfu_3.c b/src/link_rfu_3.c index d3f6e93db..8382f1dab 100644 --- a/src/link_rfu_3.c +++ b/src/link_rfu_3.c @@ -184,7 +184,7 @@ void RFU_queue_20_70_reset(struct UnkRfuStruct_2_Sub_124 *queue) queue->full = 0; } -void RFU_queue_40_14_reset(struct UnkRfuStruct_2_Sub_9e8 *ptr) +void RFU_queue_40_14_reset(struct RfuSendQueue *ptr) { s32 i; s32 j; @@ -260,7 +260,7 @@ void RFU_queue_20_70_recv(struct UnkRfuStruct_2_Sub_124 *queue, u8 *data) } } -void RFU_queue_40_14_recv(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *data) +void RFU_queue_40_14_recv(struct RfuSendQueue *queue, u8 *data) { s32 i; u16 imeBak; @@ -325,7 +325,7 @@ bool8 RFU_queue_20_70_send(struct UnkRfuStruct_2_Sub_124 *queue, u8 *dest) return TRUE; } -bool8 RFU_queue_40_14_send(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *dest) +bool8 RFU_queue_40_14_send(struct RfuSendQueue *queue, u8 *dest) { s32 i; u16 imeBak; diff --git a/src/load_save.c b/src/load_save.c index 7ab28ffc3..9dff59928 100644 --- a/src/load_save.c +++ b/src/load_save.c @@ -127,24 +127,24 @@ void MoveSaveBlocks_ResetHeap(void) gSaveBlock2Ptr->encryptionKey = encryptionKey; } -u32 sav2_x1_query_bit1(void) +u32 UseContinueGameWarp(void) { return gSaveBlock2Ptr->specialSaveWarpFlags & CONTINUE_GAME_WARP; } -void sav2_x9_clear_bit1(void) +void ClearContinueGameWarpStatus(void) { gSaveBlock2Ptr->specialSaveWarpFlags &= ~CONTINUE_GAME_WARP; } -void sub_804C1AC(void) +void SetContinueGameWarpStatus(void) { gSaveBlock2Ptr->specialSaveWarpFlags |= CONTINUE_GAME_WARP; } void SetContinueGameWarpStatusToDynamicWarp(void) { - sub_8055778(0); + SetContinueGameWarpToDynamicWarp(0); gSaveBlock2Ptr->specialSaveWarpFlags |= CONTINUE_GAME_WARP; } @@ -286,7 +286,7 @@ void ApplyNewEncryptionKeyToAllEncryptedData(u32 encryptionKey) for(i = 0; i < NUM_TOWER_CHALLENGE_TYPES; i++) ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->trainerTower[i].bestTime, encryptionKey); - sub_8054F38(encryptionKey); + ApplyNewEncryptionKeyToGameStats(encryptionKey); ApplyNewEncryptionKeyToBagItems_(encryptionKey); ApplyNewEncryptionKeyToBerryPowder(encryptionKey); ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->money, encryptionKey); diff --git a/src/mail.c b/src/mail.c index b5c0343b3..9a28fae41 100644 --- a/src/mail.c +++ b/src/mail.c @@ -588,7 +588,7 @@ static bool8 DoInitMailView(void) } break; case 15: - if (sub_8058244() == TRUE) + if (Overworld_LinkRecvQueueLengthMoreThan2() == TRUE) return FALSE; break; case 16: diff --git a/src/map_name_popup.c b/src/map_name_popup.c index 10e549cbd..6f7fa5d3c 100644 --- a/src/map_name_popup.c +++ b/src/map_name_popup.c @@ -18,26 +18,36 @@ static u16 MapNamePopupCreateWindow(bool32 palIntoFadedBuffer); static void MapNamePopupPrintMapNameOnWindow(u16 windowId); static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 flags); -void CreateMapNamePopupIfNotAlreadyRunning(bool32 palIntoFadedBuffer) +#define tState data[0] +#define tTimer data[1] +#define tPos data[2] +#define tReshow data[3] +#define tWindowId data[4] +#define tWindowExists data[5] +#define tWindowCleared data[6] +#define tWindowDestroyed data[7] +#define tPalIntoFadedBuffer data[8] + +void ShowMapNamePopup(bool32 palIntoFadedBuffer) { u8 taskId; - if (FlagGet(FLAG_SPECIAL_FLAG_0x4000) != TRUE && !(gQuestLogState == 2 || gQuestLogState == 3)) + if (FlagGet(FLAG_DONT_SHOW_MAP_NAME_POPUP) != TRUE && !(gQuestLogState == QL_STATE_2 || gQuestLogState == QL_STATE_3)) { taskId = FindTaskIdByFunc(Task_MapNamePopup); if (taskId == 0xFF) { taskId = CreateTask(Task_MapNamePopup, 90); - ChangeBgX(0, 0x00000000, 0); - ChangeBgY(0, 0xFFFFEF7F, 0); - gTasks[taskId].data[0] = 0; - gTasks[taskId].data[2] = 0; - gTasks[taskId].data[8] = palIntoFadedBuffer; + ChangeBgX(0, 0x0000, 0); + ChangeBgY(0, -0x1081, 0); + gTasks[taskId].tState = 0; + gTasks[taskId].tPos = 0; + gTasks[taskId].tPalIntoFadedBuffer = palIntoFadedBuffer; } else { - if (gTasks[taskId].data[0] != 4) - gTasks[taskId].data[0] = 4; - gTasks[taskId].data[3] = 1; + if (gTasks[taskId].tState != 4) + gTasks[taskId].tState = 4; + gTasks[taskId].tReshow = TRUE; } } } @@ -45,71 +55,71 @@ void CreateMapNamePopupIfNotAlreadyRunning(bool32 palIntoFadedBuffer) static void Task_MapNamePopup(u8 taskId) { struct Task * task = &gTasks[taskId]; - switch (task->data[0]) + switch (task->tState) { case 0: - task->data[4] = MapNamePopupCreateWindow(task->data[8]); - task->data[5] = 1; - task->data[0] = 1; + task->tWindowId = MapNamePopupCreateWindow(task->tPalIntoFadedBuffer); + task->tWindowExists = TRUE; + task->tState = 1; break; case 1: if (IsDma3ManagerBusyWithBgCopy()) break; // fallthrough case 2: - task->data[2] -= 2; - if (task->data[2] <= -24) + task->tPos -= 2; + if (task->tPos <= -24) { - task->data[0] = 3; - task->data[1] = 0; + task->tState = 3; + task->tTimer = 0; } break; case 3: - task->data[1]++; - if (task->data[1] > 120) + task->tTimer++; + if (task->tTimer > 120) { - task->data[1] = 0; - task->data[0] = 4; + task->tTimer = 0; + task->tState = 4; } break; case 4: - task->data[2] += 2; - if (task->data[2] >= 0) + task->tPos += 2; + if (task->tPos >= 0) { - if (task->data[3]) + if (task->tReshow) { - MapNamePopupPrintMapNameOnWindow(task->data[4]); - CopyWindowToVram(task->data[4], 2); - task->data[0] = 1; - task->data[3] = 0; + MapNamePopupPrintMapNameOnWindow(task->tWindowId); + CopyWindowToVram(task->tWindowId, 2); + task->tState = 1; + task->tReshow = FALSE; } else { - task->data[0] = 6; + task->tState = 6; return; } } case 5: break; case 6: - if (task->data[5] && !task->data[6]) + if (task->tWindowExists && !task->tWindowCleared) { - rbox_fill_rectangle(task->data[4]); - CopyWindowToVram(task->data[4], 1); - task->data[6] = 1; + rbox_fill_rectangle(task->tWindowId); + CopyWindowToVram(task->tWindowId, 1); + task->tWindowCleared = TRUE; } - task->data[0] = 7; + task->tState = 7; return; case 7: if (!IsDma3ManagerBusyWithBgCopy()) { - if (task->data[5]) + if (task->tWindowExists) { - RemoveWindow(task->data[4]); - task->data[5] = 0; - task->data[7] = 1; + RemoveWindow(task->tWindowId); + task->tWindowExists = FALSE; + task->tWindowDestroyed = TRUE; } - task->data[0] = 8; + task->tState = 8; ChangeBgY(0, 0x00000000, 0); } return; @@ -117,7 +127,7 @@ static void Task_MapNamePopup(u8 taskId) DestroyTask(taskId); return; } - SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]); + SetGpuReg(REG_OFFSET_BG0VOFS, task->tPos); } void DismissMapNamePopup(void) @@ -128,8 +138,8 @@ void DismissMapNamePopup(void) if (taskId != 0xFF) { data = gTasks[taskId].data; - if (data[0] < 6) - data[0] = 6; + if (tState < 6) + tState = 6; } } @@ -151,15 +161,16 @@ static u16 MapNamePopupCreateWindow(bool32 palintoFadedBuffer) }; u16 windowId; u16 r6 = 0x01D; - if (gMapHeader.flags != 0) + if (gMapHeader.floorNum != 0) { - if (gMapHeader.flags != 0x7F) + if (gMapHeader.floorNum != 0x7F) { windowTemplate.width += 5; r6 = 0x027; } else { + // ROOFTOP windowTemplate.width += 8; r6 = 0x02D; } @@ -187,30 +198,40 @@ static void MapNamePopupPrintMapNameOnWindow(u16 windowId) u32 maxWidth = 112; u32 xpos; u8 *ptr = GetMapName(mapName, gMapHeader.regionMapSectionId, 0); - if (gMapHeader.flags != 0) + if (gMapHeader.floorNum != 0) { - ptr = MapNamePopupAppendFloorNum(ptr, gMapHeader.flags); - maxWidth = gMapHeader.flags != 0x7F ? 152 : 176; + ptr = MapNamePopupAppendFloorNum(ptr, gMapHeader.floorNum); + maxWidth = gMapHeader.floorNum != 0x7F ? 152 : 176; } xpos = (maxWidth - GetStringWidth(2, mapName, -1)) / 2; FillWindowPixelBuffer(windowId, PIXEL_FILL(1)); - AddTextPrinterParameterized(windowId, 2, mapName, xpos, 2, 0xFF, NULL); + AddTextPrinterParameterized(windowId, 2, mapName, xpos, 2, TEXT_SPEED_FF, NULL); } -static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 flags) +static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 floorNum) { - if (flags == 0) + if (floorNum == 0) return dest; *dest++ = CHAR_SPACE; - if (flags == 0x7F) - return StringCopy(dest, gUnknown_841D18D); - if (flags < 0) + if (floorNum == 0x7F) + return StringCopy(dest, gText_Rooftop2); + if (floorNum < 0) { *dest++ = CHAR_B; - flags *= -1; + floorNum *= -1; } - dest = ConvertIntToDecimalStringN(dest, flags, STR_CONV_MODE_LEFT_ALIGN, 2); + dest = ConvertIntToDecimalStringN(dest, floorNum, STR_CONV_MODE_LEFT_ALIGN, 2); *dest++ = CHAR_F; *dest = EOS; return dest; } + +#undef tPalIntoFadedBuffer +#undef tWindowDestroyed +#undef tWindowCleared +#undef tWindowExists +#undef tWindowId +#undef tReshow +#undef tPos +#undef tTimer +#undef tState diff --git a/src/menu_helpers.c b/src/menu_helpers.c index dedd7aa9e..8e63ea99d 100644 --- a/src/menu_helpers.c +++ b/src/menu_helpers.c @@ -125,17 +125,17 @@ bool8 MenuHelpers_LinkSomething(void) return FALSE; } -bool32 sub_80BF72C(void) +bool32 MenuHelpers_CallLinkSomething(void) { if (!MenuHelpers_LinkSomething()) return FALSE; else - return (u8)sub_8058244(); + return (u8)Overworld_LinkRecvQueueLengthMoreThan2(); } bool8 sub_80BF748(void) { - if ((u8)sub_80BF72C() == TRUE) + if ((u8)MenuHelpers_CallLinkSomething() == TRUE) return TRUE; else if (sub_800B270() != TRUE) return FALSE; diff --git a/src/metatile_behavior.c b/src/metatile_behavior.c index d6a983744..77c839b89 100644 --- a/src/metatile_behavior.c +++ b/src/metatile_behavior.c @@ -191,7 +191,7 @@ bool8 MetatileBehavior_IsLadder(u8 metatileBehavior) return FALSE; } -bool8 MetatileBehavior_IsCaveDoor(u8 metatileBehavior) +bool8 MetatileBehavior_IsNonAnimDoor(u8 metatileBehavior) { if(metatileBehavior == MB_CAVE_DOOR) return TRUE; @@ -199,7 +199,7 @@ bool8 MetatileBehavior_IsCaveDoor(u8 metatileBehavior) return FALSE; } -bool8 MetatileBehavior_ReturnFalse_2(u8 metatileBehavior) { return FALSE; } +bool8 MetatileBehavior_IsDeepSouthWarp(u8 metatileBehavior) { return FALSE; } bool8 MetatileBehavior_IsSurfable(u8 metatileBehavior) { @@ -664,7 +664,7 @@ bool8 MetatileBehavior_IsFallWarp(u8 metatileBehavior) bool8 MetatileBehavior_ReturnFalse_13(u8 metatileBehavior){ return FALSE; } -bool8 MetatileBehavior_IsCyclingRoadPullDownTile(u8 metatileBehavior) +bool32 MetatileBehavior_IsCyclingRoadPullDownTile(u8 metatileBehavior) { if(metatileBehavior >= MB_CYCLING_ROAD_PULL_DOWN && metatileBehavior <= MB_CYCLING_ROAD_PULL_DOWN_GRASS) return TRUE; @@ -677,11 +677,11 @@ bool8 MetatileBehavior_IsCyclingRoadPullDownTileGrass(u8 metatileBehavior) return metatileBehavior == MB_CYCLING_ROAD_PULL_DOWN_GRASS; } -bool8 MetatileBehavior_ReturnFalse_14(u8 metatileBehavior) { return FALSE; } -bool8 MetatileBehavior_ReturnFalse_15(u8 metatileBehavior) { return FALSE; } -bool8 MetatileBehavior_ReturnFalse_16(u8 metatileBehavior) { return FALSE; } -bool8 MetatileBehavior_ReturnFalse_17(u8 metatileBehavior) { return FALSE; } -bool8 MetatileBehavior_ReturnFalse_18(u8 metatileBehavior) { return FALSE; } +bool8 MetatileBehavior_IsBumpySlope(u8 metatileBehavior) { return FALSE; } +bool8 MetatileBehavior_IsIsolatedVerticalRail(u8 metatileBehavior) { return FALSE; } +bool8 MetatileBehavior_IsIsolatedHorizontalRail(u8 metatileBehavior) { return FALSE; } +bool8 MetatileBehavior_IsVerticalRail(u8 metatileBehavior) { return FALSE; } +bool8 MetatileBehavior_IsHorizontalRail(u8 metatileBehavior) { return FALSE; } bool8 MetatileBehavior_IsSeaweed(u8 metatileBehavior) { @@ -750,7 +750,7 @@ bool8 TestMetatileAttributeBit(u8 arg1, u8 arg2) return FALSE; } -bool8 MetatileBehavior_UnusedIsSpinRight(u8 metatileBehavior) +bool8 MetatileBehavior_IsSpinRight(u8 metatileBehavior) { if(metatileBehavior == MB_SPIN_RIGHT) return TRUE; @@ -758,7 +758,7 @@ bool8 MetatileBehavior_UnusedIsSpinRight(u8 metatileBehavior) return FALSE; } -bool8 MetatileBehavior_UnusedIsSpinLeft(u8 metatileBehavior) +bool8 MetatileBehavior_IsSpinLeft(u8 metatileBehavior) { if(metatileBehavior == MB_SPIN_LEFT) return TRUE; @@ -766,7 +766,7 @@ bool8 MetatileBehavior_UnusedIsSpinLeft(u8 metatileBehavior) return FALSE; } -bool8 MetatileBehavior_UnusedIsSpinUp(u8 metatileBehavior) +bool8 MetatileBehavior_IsSpinUp(u8 metatileBehavior) { if(metatileBehavior == MB_SPIN_UP) return TRUE; @@ -774,7 +774,7 @@ bool8 MetatileBehavior_UnusedIsSpinUp(u8 metatileBehavior) return FALSE; } -bool8 MetatileBehavior_UnusedIsSpinDown(u8 metatileBehavior) +bool8 MetatileBehavior_IsSpinDown(u8 metatileBehavior) { if(metatileBehavior == MB_SPIN_DOWN) return TRUE; diff --git a/src/naming_screen.c b/src/naming_screen.c index b8b121535..1a41c8c0b 100644 --- a/src/naming_screen.c +++ b/src/naming_screen.c @@ -1300,7 +1300,7 @@ static void NamingScreen_CreatePlayerIcon(void) u8 rivalGfxId; u8 spriteId; - rivalGfxId = sub_805C7C8(0, sNamingScreenData->monSpecies); + rivalGfxId = GetRivalAvatarGraphicsIdByStateIdAndGender(0, sNamingScreenData->monSpecies); spriteId = AddPseudoObjectEvent(rivalGfxId, SpriteCallbackDummy, 0x38, 0x25, 0); gSprites[spriteId].oam.priority = 3; StartSpriteAnim(&gSprites[spriteId], 4); diff --git a/src/new_menu_helpers.c b/src/new_menu_helpers.c index 959370398..78bc6b7a4 100644 --- a/src/new_menu_helpers.c +++ b/src/new_menu_helpers.c @@ -457,7 +457,7 @@ void AddTextPrinterWithCustomSpeedForMessage(bool8 allowSkippingDelayWithButtonP void LoadStdWindowFrameGfx(void) { - if (gQuestLogState == 2) + if (gQuestLogState == QL_STATE_2) { gTextFlags.autoScroll = 1; TextWindow_LoadTilesStdFrame1(0, DLG_WINDOW_BASE_TILE_NUM); @@ -495,8 +495,8 @@ void ClearDialogWindowAndFrame(u8 windowId, bool8 copyToVram) ClearWindowTilemap(windowId); if (copyToVram == TRUE) CopyWindowToVram(windowId, 3); - if (gQuestLogState == 2) - sub_8111134(); + if (gQuestLogState == QL_STATE_2) + CommitQuestLogWindow1(); } void ClearStdWindowAndFrame(u8 windowId, bool8 copyToVram) @@ -527,7 +527,7 @@ static void WindowFunc_DrawStandardFrame(u8 bg, u8 tilemapLeft, u8 tilemapTop, u static void WindowFunc_DrawDialogueFrame(u8 bg, u8 tilemapLeft, u8 tilemapTop, u8 width, u8 height, u8 paletteNum) { - if (!IsMsgSignPost() || gQuestLogState == 2) + if (!IsMsgSignPost() || gQuestLogState == QL_STATE_2) { FillBgTilemapBufferRect(bg, DLG_WINDOW_BASE_TILE_NUM + 0, tilemapLeft - 2, tilemapTop - 1, 1, 1, DLG_WINDOW_PALETTE_NUM); FillBgTilemapBufferRect(bg, DLG_WINDOW_BASE_TILE_NUM + 1, tilemapLeft - 1, tilemapTop - 1, 1, 1, DLG_WINDOW_PALETTE_NUM); @@ -611,7 +611,7 @@ void SetStdWindowBorderStyle(u8 windowId, bool8 copyToVram) void sub_80F7768(u8 windowId, bool8 copyToVram) { - if (gQuestLogState == 2) + if (gQuestLogState == QL_STATE_2) { gTextFlags.autoScroll = 1; TextWindow_LoadTilesStdFrame1(0, DLG_WINDOW_BASE_TILE_NUM); diff --git a/src/normal.c b/src/normal.c index 4e045340f..366219c72 100644 --- a/src/normal.c +++ b/src/normal.c @@ -326,7 +326,7 @@ u32 UnpackSelectedBattleAnimPalettes(s16 selector) u8 arg5 = (selector >> 5) & 1; u8 arg6 = (selector >> 6) & 1; - return sub_8075BE8(battleBackground, attacker, target, attackerPartner, targetPartner, arg5, arg6); + return SelectBattleAnimSpriteAndBgPalettes(battleBackground, attacker, target, attackerPartner, targetPartner, arg5, arg6); } static void AnimSimplePaletteBlendStep(struct Sprite *sprite) @@ -406,7 +406,7 @@ static void sub_80B9B8C(struct Sprite *sprite) sprite->callback(sprite); } -void sub_80B9BDC(u8 taskId) +void AnimTask_CurseBlendEffect(u8 taskId) { gTasks[taskId].data[0] = gBattleAnimArgs[0]; gTasks[taskId].data[1] = gBattleAnimArgs[1]; @@ -659,7 +659,7 @@ void sub_80BA0E8(u8 taskId) u8 targetBattler = gBattleAnimTarget; if (gBattleAnimArgs[0] & 0x100) - selectedPalettes = sub_8075BE8(1, 0, 0, 0, 0, 0, 0); + selectedPalettes = SelectBattleAnimSpriteAndBgPalettes(1, 0, 0, 0, 0, 0, 0); if (gBattleAnimArgs[1] & 0x100) selectedPalettes |= (0x10000 << attackerBattler); if (gBattleAnimArgs[2] & 0x100) diff --git a/src/option_menu.c b/src/option_menu.c index 56a4ec877..54cca0501 100644 --- a/src/option_menu.c +++ b/src/option_menu.c @@ -43,11 +43,10 @@ enum struct OptionMenu { /*0x00*/ u16 option[MENUITEM_COUNT]; - /*0x0E*/ u16 unkE; - /*0x10*/ u8 state3; + /*0x0E*/ u16 cursorPos; + /*0x10*/ u8 loadState; /*0x11*/ u8 state; - /*0x12*/ u8 state2; - /*0x13*/ u8 unk13; + /*0x12*/ u8 loadPaletteState; }; static EWRAM_DATA struct OptionMenu *sOptionMenuPtr = NULL; @@ -68,9 +67,9 @@ static u8 OptionMenu_ProcessInput(void); static void BufferOptionMenuString(u8 selection); static void CloseAndSaveOptionMenu(u8 taskId); static void PrintOptionMenuHeader(void); -static void sub_8088C0C(void); +static void DrawOptionMenuBg(void); static void LoadOptionMenuItemNames(void); -static void sub_8088DE0(u16 selection); +static void UpdateSettingSelectionDisplay(u16 selection); // Data Definitions static const struct WindowTemplate sOptionMenuWinTemplates[] = @@ -208,10 +207,10 @@ void CB2_OptionsMenuFromStartMenu(void) if (gMain.savedCallback == NULL) gMain.savedCallback = CB2_ReturnToFieldWithOpenMenu; sOptionMenuPtr = AllocZeroed(sizeof(struct OptionMenu)); - sOptionMenuPtr->state3 = 0; - sOptionMenuPtr->state2 = 0; + sOptionMenuPtr->loadState = 0; + sOptionMenuPtr->loadPaletteState = 0; sOptionMenuPtr->state = 0; - sOptionMenuPtr->unkE = 0; + sOptionMenuPtr->cursorPos = 0; sOptionMenuPtr->option[MENUITEM_TEXTSPEED] = gSaveBlock2Ptr->optionsTextSpeed; sOptionMenuPtr->option[MENUITEM_BATTLESCENE] = gSaveBlock2Ptr->optionsBattleSceneOff; sOptionMenuPtr->option[MENUITEM_BATTLESTYLE] = gSaveBlock2Ptr->optionsBattleStyle; @@ -262,7 +261,7 @@ static void CB2_OptionMenu(void) PrintOptionMenuHeader(); break; case 5: - sub_8088C0C(); + DrawOptionMenuBg(); break; case 6: LoadOptionMenuItemNames(); @@ -272,7 +271,7 @@ static void CB2_OptionMenu(void) BufferOptionMenuString(i); break; case 8: - sub_8088DE0(sOptionMenuPtr->unkE); + UpdateSettingSelectionDisplay(sOptionMenuPtr->cursorPos); break; case 9: OptionMenu_PickSwitchCancel(); @@ -340,7 +339,7 @@ static void OptionMenu_ResetSpriteData(void) static bool8 LoadOptionMenuPalette(void) { - switch (sOptionMenuPtr->state2) + switch (sOptionMenuPtr->loadPaletteState) { case 0: LoadBgTiles(1, GetUserFrameGraphicsInfo(sOptionMenuPtr->option[MENUITEM_FRAMETYPE])->tiles, 0x120, 0x1AA); @@ -358,51 +357,55 @@ static bool8 LoadOptionMenuPalette(void) default: return TRUE; } - sOptionMenuPtr->state2++; + sOptionMenuPtr->loadPaletteState++; return FALSE; } static void Task_OptionMenu(u8 taskId) { - switch (sOptionMenuPtr->state3) + switch (sOptionMenuPtr->loadState) { case 0: BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, RGB_BLACK); OptionMenu_SetVBlankCallback(); - sOptionMenuPtr->state3++; + sOptionMenuPtr->loadState++; + break; + case 1: + if (gPaletteFade.active) + return; + sOptionMenuPtr->loadState++; break; case 2: - if (sub_80BF72C() == TRUE) + if (MenuHelpers_CallLinkSomething() == TRUE) break; switch (OptionMenu_ProcessInput()) { case 0: break; case 1: - sOptionMenuPtr->state3++; + sOptionMenuPtr->loadState++; break; case 2: LoadBgTiles(1, GetUserFrameGraphicsInfo(sOptionMenuPtr->option[MENUITEM_FRAMETYPE])->tiles, 0x120, 0x1AA); LoadPalette(GetUserFrameGraphicsInfo(sOptionMenuPtr->option[MENUITEM_FRAMETYPE])->palette, 0x20, 0x20); - BufferOptionMenuString(sOptionMenuPtr->unkE); + BufferOptionMenuString(sOptionMenuPtr->cursorPos); break; case 3: - sub_8088DE0(sOptionMenuPtr->unkE); + UpdateSettingSelectionDisplay(sOptionMenuPtr->cursorPos); break; case 4: - BufferOptionMenuString(sOptionMenuPtr->unkE); + BufferOptionMenuString(sOptionMenuPtr->cursorPos); break; } break; case 3: BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK); - sOptionMenuPtr->state3++; + sOptionMenuPtr->loadState++; break; - case 1: case 4: if (gPaletteFade.active) return; - sOptionMenuPtr->state3++; + sOptionMenuPtr->loadState++; break; case 5: CloseAndSaveOptionMenu(taskId); @@ -416,43 +419,43 @@ static u8 OptionMenu_ProcessInput(void) u16* curr; if (JOY_REPT(DPAD_RIGHT)) { - current = sOptionMenuPtr->option[(sOptionMenuPtr->unkE)]; - if (current == (sOptionMenuItemCounts[sOptionMenuPtr->unkE] - 1)) - sOptionMenuPtr->option[sOptionMenuPtr->unkE] = 0; + current = sOptionMenuPtr->option[(sOptionMenuPtr->cursorPos)]; + if (current == (sOptionMenuItemCounts[sOptionMenuPtr->cursorPos] - 1)) + sOptionMenuPtr->option[sOptionMenuPtr->cursorPos] = 0; else - sOptionMenuPtr->option[sOptionMenuPtr->unkE] = current + 1; - if (sOptionMenuPtr->unkE == MENUITEM_FRAMETYPE) + sOptionMenuPtr->option[sOptionMenuPtr->cursorPos] = current + 1; + if (sOptionMenuPtr->cursorPos == MENUITEM_FRAMETYPE) return 2; else return 4; } else if (JOY_REPT(DPAD_LEFT)) { - curr = &sOptionMenuPtr->option[sOptionMenuPtr->unkE]; + curr = &sOptionMenuPtr->option[sOptionMenuPtr->cursorPos]; if (*curr == 0) - *curr = sOptionMenuItemCounts[sOptionMenuPtr->unkE] - 1; + *curr = sOptionMenuItemCounts[sOptionMenuPtr->cursorPos] - 1; else --*curr; - if (sOptionMenuPtr->unkE == MENUITEM_FRAMETYPE) + if (sOptionMenuPtr->cursorPos == MENUITEM_FRAMETYPE) return 2; else return 4; } else if (JOY_REPT(DPAD_UP)) { - if (sOptionMenuPtr->unkE == MENUITEM_TEXTSPEED) - sOptionMenuPtr->unkE = MENUITEM_CANCEL; + if (sOptionMenuPtr->cursorPos == MENUITEM_TEXTSPEED) + sOptionMenuPtr->cursorPos = MENUITEM_CANCEL; else - sOptionMenuPtr->unkE = sOptionMenuPtr->unkE - 1; + sOptionMenuPtr->cursorPos = sOptionMenuPtr->cursorPos - 1; return 3; } else if (JOY_REPT(DPAD_DOWN)) { - if (sOptionMenuPtr->unkE == MENUITEM_CANCEL) - sOptionMenuPtr->unkE = MENUITEM_TEXTSPEED; + if (sOptionMenuPtr->cursorPos == MENUITEM_CANCEL) + sOptionMenuPtr->cursorPos = MENUITEM_TEXTSPEED; else - sOptionMenuPtr->unkE = sOptionMenuPtr->unkE + 1; + sOptionMenuPtr->cursorPos = sOptionMenuPtr->cursorPos + 1; return 3; } else if (JOY_NEW(B_BUTTON) || JOY_NEW(A_BUTTON)) @@ -509,7 +512,7 @@ static void BufferOptionMenuString(u8 selection) static void CloseAndSaveOptionMenu(u8 taskId) { - gFieldCallback = sub_807DF64; + gFieldCallback = FieldCB_DefaultWarpExit; SetMainCallback2(gMain.savedCallback); FreeAllWindowBuffers(); gSaveBlock2Ptr->optionsTextSpeed = sOptionMenuPtr->option[MENUITEM_TEXTSPEED]; @@ -531,7 +534,7 @@ static void PrintOptionMenuHeader(void) CopyWindowToVram(0, 3); } -static void sub_8088C0C(void) +static void DrawOptionMenuBg(void) { u8 h; h = 2; @@ -566,12 +569,12 @@ static void LoadOptionMenuItemNames(void) } } -static void sub_8088DE0(u16 selection) +static void UpdateSettingSelectionDisplay(u16 selection) { - u16 v1, v2; + u16 maxLetterHeight, y; - v1 = GetFontAttribute(2, FONTATTR_MAX_LETTER_HEIGHT); - v2 = selection * (v1 - 1) + 0x3A; - SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(v2, v2 + v1)); + maxLetterHeight = GetFontAttribute(2, FONTATTR_MAX_LETTER_HEIGHT); + y = selection * (maxLetterHeight - 1) + 0x3A; + SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(y, y + maxLetterHeight)); SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(0x10, 0xE0)); } diff --git a/src/overworld.c b/src/overworld.c new file mode 100644 index 000000000..a4a6213e6 --- /dev/null +++ b/src/overworld.c @@ -0,0 +1,3553 @@ +#include "global.h" +#include "gflib.h" +#include "bg_regs.h" +#include "cable_club.h" +#include "credits.h" +#include "event_data.h" +#include "event_object_movement.h" +#include "event_scripts.h" +#include "field_camera.h" +#include "field_control_avatar.h" +#include "field_effect.h" +#include "field_fadetransition.h" +#include "field_message_box.h" +#include "field_player_avatar.h" +#include "field_screen_effect.h" +#include "field_specials.h" +#include "field_tasks.h" +#include "field_weather.h" +#include "fieldmap.h" +#include "fldeff.h" +#include "heal_location.h" +#include "help_system.h" +#include "link.h" +#include "link_rfu.h" +#include "load_save.h" +#include "m4a.h" +#include "map_name_popup.h" +#include "map_preview_screen.h" +#include "metatile_behavior.h" +#include "money.h" +#include "new_game.h" +#include "new_menu_helpers.h" +#include "overworld.h" +#include "play_time.h" +#include "quest_log.h" +#include "quest_log_objects.h" +#include "random.h" +#include "renewable_hidden_items.h" +#include "roamer.h" +#include "safari_zone.h" +#include "save_location.h" +#include "scanline_effect.h" +#include "script.h" +#include "script_pokemon_util.h" +#include "start_menu.h" +#include "tileset_anims.h" +#include "trainer_pokemon_sprites.h" +#include "vs_seeker.h" +#include "wild_encounter.h" +#include "constants/maps.h" +#include "constants/flags.h" +#include "constants/species.h" +#include "constants/region_map_sections.h" +#include "constants/songs.h" + +#define PLAYER_TRADING_STATE_IDLE 0x80 +#define PLAYER_TRADING_STATE_BUSY 0x81 +#define PLAYER_TRADING_STATE_UNK_2 0x82 +#define PLAYER_TRADING_STATE_EXITING_ROOM 0x83 + +#define FACING_NONE 0 +#define FACING_UP 1 +#define FACING_DOWN 2 +#define FACING_LEFT 3 +#define FACING_RIGHT 4 +#define FACING_FORCED_UP 7 +#define FACING_FORCED_DOWN 8 +#define FACING_FORCED_LEFT 9 +#define FACING_FORCED_RIGHT 10 + +typedef u16 (*KeyInterCB)(u32 key); + +struct InitialPlayerAvatarState +{ + u8 transitionFlags; + u8 direction; + bool8 unk2; +}; + +struct TradeRoomPlayer +{ + u8 playerId; + bool8 isLocalPlayer; + u8 c; + u8 facing; + struct MapPosition pos; + u16 field_C; +}; + +EWRAM_DATA struct WarpData gLastUsedWarp = {}; +static EWRAM_DATA struct WarpData sWarpDestination = {}; +static EWRAM_DATA struct WarpData sFixedDiveWarp = {}; +static EWRAM_DATA struct WarpData sFixedHoleWarp = {}; + +// File boundary perhaps? +static EWRAM_DATA struct InitialPlayerAvatarState sInitialPlayerAvatarState = {}; + +// File boundary perhaps? +EWRAM_DATA bool8 gDisableMapMusicChangeOnMapLoad = FALSE; +static EWRAM_DATA u16 sAmbientCrySpecies = SPECIES_NONE; +static EWRAM_DATA bool8 sIsAmbientCryWaterMon = FALSE; + +// File boundary perhaps? +ALIGNED(4) EWRAM_DATA bool8 gUnknown_2031DE0 = FALSE; +static EWRAM_DATA const struct CreditsOverworldCmd *sCreditsOverworld_Script = NULL; +static EWRAM_DATA s16 sCreditsOverworld_CmdLength = 0; +static EWRAM_DATA s16 sCreditsOverworld_CmdIndex = 0; + +// File boundary perhaps? +EWRAM_DATA struct LinkPlayerObjectEvent gLinkPlayerObjectEvents[4] = {}; + +u16 *gBGTilemapBuffers1; +u16 *gBGTilemapBuffers2; +u16 *gBGTilemapBuffers3; +void (*gFieldCallback)(void); +bool8 (*gFieldCallback2)(void); +u16 gHeldKeyCodeToSend; +u8 gLocalLinkPlayerId; +u8 gFieldLinkPlayerCount; + +static u8 sPlayerTradingStates[4]; +static KeyInterCB sPlayerKeyInterceptCallback; +static bool8 sReceivingFromLink; +static u8 sRfuKeepAliveTimer; + +static u8 CountBadgesForOverworldWhiteOutLossCalculation(void); +static void Overworld_ResetStateAfterWhitingOut(void); +static void Overworld_SetWhiteoutRespawnPoint(void); +static u8 GetAdjustedInitialTransitionFlags(struct InitialPlayerAvatarState *playerStruct, u16 metatileBehavior, u8 mapType); +static u8 GetAdjustedInitialDirection(struct InitialPlayerAvatarState *playerStruct, u8 transitionFlags, u16 metatileBehavior, u8 mapType); +static u16 GetCenterScreenMetatileBehavior(void); +static void SetDefaultFlashLevel(void); +static void Overworld_TryMapConnectionMusicTransition(void); +static void ChooseAmbientCrySpecies(void); + +static void CB2_Overworld(void); +static void CB2_LoadMap2(void); +static void c2_80567AC(void); +static void CB2_ReturnToFieldLocal(void); +static void CB2_ReturnToFieldLink(void); +static void FieldClearVBlankHBlankCallbacks(void); +static void SetFieldVBlankCallback(void); +static void VBlankCB_Field(void); + +static bool32 map_loading_iteration_3(u8 *state); +static bool32 sub_8056CD8(u8 *state); +static bool32 map_loading_iteration_2_link(u8 *state); +static void do_load_map_stuff_loop(u8 *state); +static void MoveSaveBlocks_ResetHeap_(void); +static void sub_8056E80(void); +static void sub_8056F08(void); +static void InitOverworldGraphicsRegisters(void); +static void sub_8057024(bool32 a0); +static void sub_8057074(void); +static void mli4_mapscripts_and_other(void); +static void sub_8057100(void); +static void sub_8057114(void); +static void SetCameraToTrackGuestPlayer(void); +static void SetCameraToTrackGuestPlayer_2(void); +static void sub_8057178(void); +static void sub_80571A8(void); +static void CreateLinkPlayerSprites(void); +static void sub_80572D8(void); +static void sub_8057300(u8 *state); +static bool32 sub_8057314(u8 *state); +static bool32 SetUpScrollSceneForCredits(u8 *state, u8 unused); +static bool8 MapLdr_Credits(void); +static void CameraCB_CreditsPan(struct CameraObject * camera); +static void Task_OvwldCredits_FadeOut(u8 taskId); +static void Task_OvwldCredits_WaitFade(u8 taskId); + +static void CB1_UpdateLinkState(void); +static void ResetAllMultiplayerState(void); +static void ClearAllPlayerKeys(void); +static void SetKeyInterceptCallback(KeyInterCB callback); +static void ResetAllTradingStates(void); +static void UpdateAllLinkPlayers(u16 *linkKeys, s32 selfId); +static void UpdateHeldKeyCode(u16 interceptedKeys); +static u32 GetLinkSendQueueLength(void); +static u16 GetDirectionForDpadKey(u16 key); +static void SetPlayerFacingDirection(u8 linkPlayerId, u8 setFacing); +static void ResetPlayerHeldKeys(u16 *linkKeys); +static u16 KeyInterCB_SelfIdle(u32 linkPlayerId); +static u16 KeyInterCB_DeferToEventScript(u32 linkPlayerId); +static u16 KeyInterCB_DeferToRecvQueue(u32 linkPlayerId); +static u16 KeyInterCB_DeferToSendQueue(u32 linkPlayerId); +static void LoadTradeRoomPlayer(s32 i, s32 selfId, struct TradeRoomPlayer * trainer); +static bool32 PlayerIsAtSouthExit(struct TradeRoomPlayer * player); +static const u8 *TryGetTileEventScript(struct TradeRoomPlayer * player); +static const u8 *TryInteractWithPlayer(struct TradeRoomPlayer * player); +static bool32 sub_8057FEC(struct TradeRoomPlayer * player); +static bool32 sub_8058004(struct TradeRoomPlayer * player); +static u16 GetDirectionForEventScript(const u8 *script); +static void sub_80581BC(void); +static void CreateConfirmLeaveTradeRoomPrompt(void); +static void InitLinkRoomStartMenuScript(void); +static void InitMenuBasedScript(const u8 *script); +static void sub_80581DC(const u8 *script); +static void sub_8058230(void); +static void SpawnLinkPlayerObjectEvent(u8 i, s16 x, s16 y, u8 gender); +static void InitLinkPlayerObjectEventPos(struct ObjectEvent *objEvent, s16 x, s16 y); +static u8 GetSpriteForLinkedPlayer(u8 linkPlayerId); +static void GetLinkPlayerCoords(u8 linkPlayerId, u16 *x, u16 *y); +static u8 GetLinkPlayerFacingDirection(u8 linkPlayerId); +static u8 GetLinkPlayerElevation(u8 linkPlayerId); +static u8 GetLinkPlayerIdAt(s16 x, s16 y); +static void CreateLinkPlayerSprite(u8 i, u8 version); +static u8 MovementEventModeCB_Normal(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 MovementEventModeCB_Ignored(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 MovementEventModeCB_Normal_2(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 FacingHandler_DoNothing(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 FacingHandler_DpadMovement(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 FacingHandler_ForcedFacingChange(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static void MovementStatusHandler_EnterFreeMode(struct LinkPlayerObjectEvent *, struct ObjectEvent *); +static void MovementStatusHandler_TryAdvanceScript(struct LinkPlayerObjectEvent *, struct ObjectEvent *); +static u8 FlipVerticalAndClearForced(u8 newFacing, u8 oldFacing); +static u8 LinkPlayerDetectCollision(u8 selfObjEventId, u8 a2, s16 x, s16 y); +static void SpriteCB_LinkPlayer(struct Sprite * sprite); + +extern const struct MapLayout * gMapLayouts[]; +extern const struct MapHeader *const *gMapGroups[]; + +// Routines related to game state on warping in + +static const u8 sWhiteOutMoneyLossMultipliers[] = { + 2, + 4, + 6, + 9, + 12, + 16, + 20, + 25, + 30 +}; + +static const u16 sWhiteOutMoneyLossBadgeFlagIDs[] = { + FLAG_BADGE01_GET, + FLAG_BADGE02_GET, + FLAG_BADGE03_GET, + FLAG_BADGE04_GET, + FLAG_BADGE05_GET, + FLAG_BADGE06_GET, + FLAG_BADGE07_GET, + FLAG_BADGE08_GET +}; + +static void DoWhiteOut(void) +{ + ScriptContext2_RunNewScript(EventScript_ResetEliteFourEnd); + RemoveMoney(&gSaveBlock1Ptr->money, ComputeWhiteOutMoneyLoss()); + HealPlayerParty(); + Overworld_ResetStateAfterWhitingOut(); + Overworld_SetWhiteoutRespawnPoint(); + WarpIntoMap(); +} + +u32 ComputeWhiteOutMoneyLoss(void) +{ + u8 nbadges = CountBadgesForOverworldWhiteOutLossCalculation(); + u8 toplevel = GetPlayerPartyHighestLevel(); + u32 losings = toplevel * 4 * sWhiteOutMoneyLossMultipliers[nbadges]; + u32 money = GetMoney(&gSaveBlock1Ptr->money); + if (losings > money) + losings = money; + return losings; +} + +void OverworldWhiteOutGetMoneyLoss(void) +{ + u32 losings = ComputeWhiteOutMoneyLoss(); + ConvertIntToDecimalStringN(gStringVar1, losings, STR_CONV_MODE_LEFT_ALIGN, CountDigits(losings)); +} + +static u8 CountBadgesForOverworldWhiteOutLossCalculation(void) +{ + int i; + u8 nbadges = 0; + for (i = 0; i < NELEMS(sWhiteOutMoneyLossBadgeFlagIDs); i++) + { + if (FlagGet(sWhiteOutMoneyLossBadgeFlagIDs[i])) + nbadges++; + } + return nbadges; +} + +void Overworld_ResetStateAfterFly(void) +{ + ResetInitialPlayerAvatarState(); + FlagClear(FLAG_SYS_ON_CYCLING_ROAD); + VarSet(VAR_MAP_SCENE_ROUTE16, 0); + FlagClear(FLAG_SYS_CRUISE_MODE); + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + FlagClear(FLAG_SYS_USE_STRENGTH); + FlagClear(FLAG_SYS_FLASH_ACTIVE); + FlagClear(FLAG_0x808); + VarSet(VAR_0x404D, 0); +} + +void Overworld_ResetStateAfterTeleport(void) +{ + ResetInitialPlayerAvatarState(); + FlagClear(FLAG_SYS_ON_CYCLING_ROAD); + VarSet(VAR_MAP_SCENE_ROUTE16, 0); + FlagClear(FLAG_SYS_CRUISE_MODE); + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + FlagClear(FLAG_SYS_USE_STRENGTH); + FlagClear(FLAG_SYS_FLASH_ACTIVE); + FlagClear(FLAG_0x808); + VarSet(VAR_0x404D, 0); +} + +void Overworld_ResetStateAfterDigEscRope(void) +{ + ResetInitialPlayerAvatarState(); + FlagClear(FLAG_SYS_ON_CYCLING_ROAD); + VarSet(VAR_MAP_SCENE_ROUTE16, 0); + FlagClear(FLAG_SYS_CRUISE_MODE); + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + FlagClear(FLAG_SYS_USE_STRENGTH); + FlagClear(FLAG_SYS_FLASH_ACTIVE); + FlagClear(FLAG_0x808); + VarSet(VAR_0x404D, 0); +} + +static void Overworld_ResetStateAfterWhitingOut(void) +{ + ResetInitialPlayerAvatarState(); + FlagClear(FLAG_SYS_ON_CYCLING_ROAD); + VarSet(VAR_MAP_SCENE_ROUTE16, 0); + FlagClear(FLAG_SYS_CRUISE_MODE); + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + FlagClear(FLAG_SYS_USE_STRENGTH); + FlagClear(FLAG_SYS_FLASH_ACTIVE); + FlagClear(FLAG_0x808); + VarSet(VAR_0x404D, 0); +} + +static void sub_8054E40(void) +{ + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + ChooseAmbientCrySpecies(); + UpdateLocationHistoryForRoamer(); + RoamerMoveToOtherLocationSet(); +} + +// Routines related to game stats + +void ResetGameStats(void) +{ + int i; + + for (i = 0; i < NUM_GAME_STATS; i++) + { + gSaveBlock1Ptr->gameStats[i] = 0; + } +} + +void IncrementGameStat(u8 statId) +{ + u32 statVal; + if (statId >= NUM_USED_GAME_STATS) + return; + statVal = GetGameStat(statId); + if (statVal < 0xFFFFFF) + statVal++; + else + statVal = 0xFFFFFF; + SetGameStat(statId, statVal); +} + +u32 GetGameStat(u8 statId) +{ + if (statId >= NUM_USED_GAME_STATS) + return 0; + else + return gSaveBlock1Ptr->gameStats[statId] ^ gSaveBlock2Ptr->encryptionKey; +} + +void SetGameStat(u8 statId, u32 statVal) +{ + if (statId >= NUM_USED_GAME_STATS) + return; + gSaveBlock1Ptr->gameStats[statId] = statVal ^ gSaveBlock2Ptr->encryptionKey; +} + +void ApplyNewEncryptionKeyToGameStats(u32 newKey) +{ + u8 i; + for (i = 0; i < NUM_GAME_STATS; i++) + { + ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->gameStats[i], newKey); + } +} + +// Routines related to object events + +static void sub_8054F68(void) +{ + u8 i, j; + u8 mapGroup; + u8 mapNum; + u8 localId; + const struct MapHeader * linkedMap; + + for (i = 0, j = 0; i < gMapHeader.events->objectEventCount; i++) + { + if (gMapHeader.events->objectEvents[i].unk2 == 0xFF) + { + localId = gMapHeader.events->objectEvents[i].elevation; + mapNum = gMapHeader.events->objectEvents[i].trainerType; + mapGroup = gMapHeader.events->objectEvents[i].trainerRange_berryTreeId; + linkedMap = Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum); + gSaveBlock1Ptr->objectEventTemplates[j] = linkedMap->events->objectEvents[localId - 1]; + gSaveBlock1Ptr->objectEventTemplates[j].localId = gMapHeader.events->objectEvents[i].localId; + gSaveBlock1Ptr->objectEventTemplates[j].x = gMapHeader.events->objectEvents[i].x; + gSaveBlock1Ptr->objectEventTemplates[j].y = gMapHeader.events->objectEvents[i].y; + gSaveBlock1Ptr->objectEventTemplates[j].elevation = localId; + gSaveBlock1Ptr->objectEventTemplates[j].trainerType = mapNum; + gSaveBlock1Ptr->objectEventTemplates[j].trainerRange_berryTreeId = mapGroup; + gSaveBlock1Ptr->objectEventTemplates[j].unk2 = 0xFF; + j++; + } + else + { + gSaveBlock1Ptr->objectEventTemplates[j] = gMapHeader.events->objectEvents[i]; + j++; + } + } +} + +static void LoadSaveblockObjEventScripts(void) +{ + int i; + const struct ObjectEventTemplate * src = gMapHeader.events->objectEvents; + struct ObjectEventTemplate * savObjTemplates = gSaveBlock1Ptr->objectEventTemplates; + + for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++) + { + savObjTemplates[i].script = src[i].script; + } +} + +void Overworld_SetMapObjTemplateCoords(u8 localId, s16 x, s16 y) +{ + int i; + struct ObjectEventTemplate * savObjTemplates = gSaveBlock1Ptr->objectEventTemplates; + for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++) + { + if (savObjTemplates[i].localId == localId) + { + savObjTemplates[i].x = x; + savObjTemplates[i].y = y; + break; + } + } +} + +void Overworld_SetObjEventTemplateMovementType(u8 localId, u8 movementType) +{ + s32 i; + + struct ObjectEventTemplate *savObjTemplates = gSaveBlock1Ptr->objectEventTemplates; + for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++) + { + struct ObjectEventTemplate *objectEventTemplate = &savObjTemplates[i]; + if (objectEventTemplate->localId == localId) + { + objectEventTemplate->movementType = movementType; + return; + } + } +} + +// Routines related to the map layout + +static void mapdata_load_assets_to_gpu_and_full_redraw(void) +{ + move_tilemap_camera_to_upper_left_corner(); + copy_map_tileset1_tileset2_to_vram(gMapHeader.mapLayout); + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + DrawWholeMapView(); + InitTilesetAnimations(); +} + +static const struct MapLayout *GetMapLayout(void) +{ + u16 mapLayoutId = gSaveBlock1Ptr->mapLayoutId; + if (mapLayoutId) + return gMapLayouts[mapLayoutId - 1]; + return NULL; +} + +// Routines related to warps + +static const struct WarpData sDummyWarpData = { + .mapGroup = MAP_GROUP(UNDEFINED), + .mapNum = MAP_NUM(UNDEFINED), + .warpId = 0xFF, + .x = -1, + .y = -1 +}; + +static void ApplyCurrentWarp(void) +{ + gLastUsedWarp = gSaveBlock1Ptr->location; + gSaveBlock1Ptr->location = sWarpDestination; + sFixedDiveWarp = sDummyWarpData; + sFixedHoleWarp = sDummyWarpData; +} + +static void SetWarpData(struct WarpData *warp, s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + warp->mapGroup = mapGroup; + warp->mapNum = mapNum; + warp->warpId = warpId; + warp->x = x; + warp->y = y; +} + +static bool32 IsDummyWarp(struct WarpData *warp) +{ + if (warp->mapGroup != -1) + return FALSE; + else if (warp->mapNum != -1) + return FALSE; + else if (warp->warpId != -1) + return FALSE; + else if (warp->x != -1) + return FALSE; + else if (warp->y != -1) + return FALSE; + else + return TRUE; +} + +struct MapHeader const *const Overworld_GetMapHeaderByGroupAndId(u16 mapGroup, u16 mapNum) +{ + return gMapGroups[mapGroup][mapNum]; +} + +struct MapHeader const *const GetDestinationWarpMapHeader(void) +{ + return Overworld_GetMapHeaderByGroupAndId(sWarpDestination.mapGroup, sWarpDestination.mapNum); +} + +static void LoadCurrentMapData(void) +{ + gMapHeader = *Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); + gSaveBlock1Ptr->mapLayoutId = gMapHeader.mapLayoutId; + gMapHeader.mapLayout = GetMapLayout(); +} + +static void LoadSaveblockMapHeader(void) +{ + gMapHeader = *Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); + gMapHeader.mapLayout = GetMapLayout(); +} + +static void SetPlayerCoordsFromWarp(void) +{ + if (gSaveBlock1Ptr->location.warpId >= 0 && gSaveBlock1Ptr->location.warpId < gMapHeader.events->warpCount) + { + gSaveBlock1Ptr->pos.x = gMapHeader.events->warps[gSaveBlock1Ptr->location.warpId].x; + gSaveBlock1Ptr->pos.y = gMapHeader.events->warps[gSaveBlock1Ptr->location.warpId].y; + } + else if (gSaveBlock1Ptr->location.x >= 0 && gSaveBlock1Ptr->location.y >= 0) + { + gSaveBlock1Ptr->pos.x = gSaveBlock1Ptr->location.x; + gSaveBlock1Ptr->pos.y = gSaveBlock1Ptr->location.y; + } + else + { + gSaveBlock1Ptr->pos.x = gMapHeader.mapLayout->width / 2; + gSaveBlock1Ptr->pos.y = gMapHeader.mapLayout->height / 2; + } +} + +void WarpIntoMap(void) +{ + ApplyCurrentWarp(); + LoadCurrentMapData(); + SetPlayerCoordsFromWarp(); +} + +void SetWarpDestination(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&sWarpDestination, mapGroup, mapNum, warpId, x, y); +} + +void SetWarpDestinationToMapWarp(s8 mapGroup, s8 mapNum, s8 warpId) +{ + SetWarpDestination(mapGroup, mapNum, warpId, -1, -1); +} + +void SetDynamicWarp(s32 unused, s8 mapGroup, s8 mapNum, s8 warpId) +{ + SetWarpData(&gSaveBlock1Ptr->dynamicWarp, mapGroup, mapNum, warpId, gSaveBlock1Ptr->pos.x, gSaveBlock1Ptr->pos.y); +} + +void SetDynamicWarpWithCoords(s32 unused, s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&gSaveBlock1Ptr->dynamicWarp, mapGroup, mapNum, warpId, x, y); +} + +void SetWarpDestinationToDynamicWarp(u8 unusedWarpId) +{ + sWarpDestination = gSaveBlock1Ptr->dynamicWarp; +} + +void SetWarpDestinationToHealLocation(u8 healLocationId) +{ + const struct HealLocation *warp = GetHealLocation(healLocationId); + if (warp) + SetWarpDestination(warp->group, warp->map, -1, warp->x, warp->y); +} + +void SetWarpDestinationToLastHealLocation(void) +{ + sWarpDestination = gSaveBlock1Ptr->lastHealLocation; +} + +static void Overworld_SetWhiteoutRespawnPoint(void) +{ + SetWhiteoutRespawnWarpAndHealerNpc(&sWarpDestination); +} + +void SetLastHealLocationWarp(u8 healLocationId) +{ + const struct HealLocation *healLocation = GetHealLocation(healLocationId); + if (healLocation) + SetWarpData(&gSaveBlock1Ptr->lastHealLocation, healLocation->group, healLocation->map, -1, healLocation->x, healLocation->y); +} + +void UpdateEscapeWarp(s16 x, s16 y) +{ + u8 currMapType = GetCurrentMapType(); + u8 destMapType = GetMapTypeByGroupAndId(sWarpDestination.mapGroup, sWarpDestination.mapNum); + u8 delta; + if (IsMapTypeOutdoors(currMapType) && IsMapTypeOutdoors(destMapType) != TRUE && !(gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(VIRIDIAN_FOREST) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(VIRIDIAN_FOREST))) + { + delta = GetPlayerFacingDirection() != DIR_SOUTH; + SetEscapeWarp(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, x - 7, y - 7 + delta); + } +} + +void SetEscapeWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&gSaveBlock1Ptr->escapeWarp, mapGroup, mapNum, warpId, x, y); +} + +void SetWarpDestinationToEscapeWarp(void) +{ + sWarpDestination = gSaveBlock1Ptr->escapeWarp; +} + +void SetFixedDiveWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&sFixedDiveWarp, mapGroup, mapNum, warpId, x, y); +} + +static void SetWarpDestinationToDiveWarp(void) +{ + sWarpDestination = sFixedDiveWarp; +} + +void SetFixedHoleWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&sFixedHoleWarp, mapGroup, mapNum, warpId, x, y); +} + +void SetWarpDestinationToFixedHoleWarp(s16 x, s16 y) +{ + if (IsDummyWarp(&sFixedHoleWarp) == TRUE) + sWarpDestination = gLastUsedWarp; + else + SetWarpDestination(sFixedHoleWarp.mapGroup, sFixedHoleWarp.mapNum, -1, x, y); +} + +static void SetWarpDestinationToContinueGameWarp(void) +{ + sWarpDestination = gSaveBlock1Ptr->continueGameWarp; +} + +static void SetContinueGameWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&gSaveBlock1Ptr->continueGameWarp, mapGroup, mapNum, warpId, x, y); +} + +void SetContinueGameWarpToHealLocation(u8 healLocationId) +{ + const struct HealLocation *warp = GetHealLocation(healLocationId); + if (warp) + SetWarpData(&gSaveBlock1Ptr->continueGameWarp, warp->group, warp->map, -1, warp->x, warp->y); +} + +void SetContinueGameWarpToDynamicWarp(int unused) +{ + gSaveBlock1Ptr->continueGameWarp = gSaveBlock1Ptr->dynamicWarp; +} + +static const struct MapConnection * GetMapConnection(u8 dir) +{ + s32 i; + s32 count = gMapHeader.connections->count; + const struct MapConnection *connection = gMapHeader.connections->connections; + + if (connection == NULL) + return NULL; + + for(i = 0; i < count; i++, connection++) + if (connection->direction == dir) + return connection; + + return NULL; +} + +static bool8 SetDiveWarp(u8 dir, u16 x, u16 y) +{ + const struct MapConnection *connection = GetMapConnection(dir); + + if (connection != NULL) + { + SetWarpDestination(connection->mapGroup, connection->mapNum, -1, x, y); + } + else + { + RunOnDiveWarpMapScript(); + if (IsDummyWarp(&sFixedDiveWarp)) + return FALSE; + SetWarpDestinationToDiveWarp(); + } + return TRUE; +} + +bool8 SetDiveWarpEmerge(u16 x, u16 y) +{ + return SetDiveWarp(CONNECTION_EMERGE, x, y); +} + +bool8 SetDiveWarpDive(u16 x, u16 y) +{ + return SetDiveWarp(CONNECTION_DIVE, x, y); +} + +// Map loaders + +void LoadMapFromCameraTransition(u8 mapGroup, u8 mapNum) +{ + int paletteIndex; + + SetWarpDestination(mapGroup, mapNum, -1, -1, -1); + Overworld_TryMapConnectionMusicTransition(); + ApplyCurrentWarp(); + LoadCurrentMapData(); + sub_8054F68(); + TrySetMapSaveWarpStatus(); + ClearTempFieldEventData(); + ResetCyclingRoadChallengeData(); + RestartWildEncounterImmunitySteps(); + TryUpdateRandomTrainerRematches(mapGroup, mapNum); + SetSav1WeatherFromCurrMapHeader(); + ChooseAmbientCrySpecies(); + SetDefaultFlashLevel(); + Overworld_ClearSavedMusic(); + RunOnTransitionMapScript(); + TryRegenerateRenewableHiddenItems(); + InitMap(); + copy_map_tileset2_to_vram_2(gMapHeader.mapLayout); + apply_map_tileset2_palette(gMapHeader.mapLayout); + for (paletteIndex = 7; paletteIndex < 13; paletteIndex++) + ApplyWeatherGammaShiftToPal(paletteIndex); + InitSecondaryTilesetAnimation(); + UpdateLocationHistoryForRoamer(); + RoamerMove(); + sub_8110920(); + DoCurrentWeather(); + ResetFieldTasksArgs(); + RunOnResumeMapScript(); + if (GetLastUsedWarpMapSectionId() != gMapHeader.regionMapSectionId) + ShowMapNamePopup(TRUE); +} + +static void mli0_load_map(bool32 a1) +{ + bool8 isOutdoors; + + LoadCurrentMapData(); + sub_8054F68(); + isOutdoors = IsMapTypeOutdoors(gMapHeader.mapType); + + TrySetMapSaveWarpStatus(); + ClearTempFieldEventData(); + ResetCyclingRoadChallengeData(); + RestartWildEncounterImmunitySteps(); + TryUpdateRandomTrainerRematches(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); + SetSav1WeatherFromCurrMapHeader(); + ChooseAmbientCrySpecies(); + if (isOutdoors) + FlagClear(FLAG_SYS_FLASH_ACTIVE); + SetDefaultFlashLevel(); + Overworld_ClearSavedMusic(); + RunOnTransitionMapScript(); + TryRegenerateRenewableHiddenItems(); + UpdateLocationHistoryForRoamer(); + RoamerMoveToOtherLocationSet(); + sub_8110920(); + InitMap(); +} + +static void sub_80559A8(void) +{ + bool8 isOutdoors; + + LoadCurrentMapData(); + sub_8054F68(); + isOutdoors = IsMapTypeOutdoors(gMapHeader.mapType); + TrySetMapSaveWarpStatus(); + SetSav1WeatherFromCurrMapHeader(); + ChooseAmbientCrySpecies(); + SetDefaultFlashLevel(); + sub_8110920(); + sub_8111708(); + LoadSaveblockMapHeader(); + InitMap(); +} + +// Routines related to the initial player avatar state + +void ResetInitialPlayerAvatarState(void) +{ + sInitialPlayerAvatarState.direction = DIR_SOUTH; + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT; + sInitialPlayerAvatarState.unk2 = FALSE; +} + +static void SetInitialPlayerAvatarStateWithDirection(u8 dirn) +{ + sInitialPlayerAvatarState.direction = dirn; + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT; + sInitialPlayerAvatarState.unk2 = TRUE; +} + +void StoreInitialPlayerAvatarState(void) +{ + sInitialPlayerAvatarState.direction = GetPlayerFacingDirection(); + + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE)) + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_MACH_BIKE; + else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_ACRO_BIKE)) + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ACRO_BIKE; + else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING)) + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_SURFING; + else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_UNDERWATER)) + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_UNDERWATER; + else + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT; + sInitialPlayerAvatarState.unk2 = FALSE; +} + +struct InitialPlayerAvatarState *GetInitialPlayerAvatarState(void) +{ + struct InitialPlayerAvatarState playerStruct; + u8 mapType = GetCurrentMapType(); + u16 metatileBehavior = GetCenterScreenMetatileBehavior(); + u8 transitionFlags = GetAdjustedInitialTransitionFlags(&sInitialPlayerAvatarState, metatileBehavior, mapType); + playerStruct.transitionFlags = transitionFlags; + playerStruct.direction = GetAdjustedInitialDirection(&sInitialPlayerAvatarState, transitionFlags, metatileBehavior, mapType); + playerStruct.unk2 = FALSE; + sInitialPlayerAvatarState = playerStruct; + return &sInitialPlayerAvatarState; +} + +static u8 GetAdjustedInitialTransitionFlags(struct InitialPlayerAvatarState *playerStruct, u16 metatileBehavior, u8 mapType) +{ + if (mapType != MAP_TYPE_INDOOR && FlagGet(FLAG_SYS_CRUISE_MODE)) + return PLAYER_AVATAR_FLAG_ON_FOOT; + else if (mapType == MAP_TYPE_UNDERWATER) + return PLAYER_AVATAR_FLAG_UNDERWATER; + else if (sub_8055B38(metatileBehavior) == TRUE) + return PLAYER_AVATAR_FLAG_ON_FOOT; + else if (MetatileBehavior_IsSurfable(metatileBehavior) == TRUE) + return PLAYER_AVATAR_FLAG_SURFING; + else if (Overworld_IsBikingAllowed() != TRUE) + return PLAYER_AVATAR_FLAG_ON_FOOT; + else if (playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_MACH_BIKE) + return PLAYER_AVATAR_FLAG_MACH_BIKE; + else if (playerStruct->transitionFlags != PLAYER_AVATAR_FLAG_ACRO_BIKE) + return PLAYER_AVATAR_FLAG_ON_FOOT; + else + return PLAYER_AVATAR_FLAG_ACRO_BIKE; +} + +bool8 sub_8055B38(u16 metatileBehavior) +{ + if (MetatileBehavior_IsSurfable(metatileBehavior) != TRUE) + return FALSE; + if ((gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEAFOAM_ISLANDS_B3F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEAFOAM_ISLANDS_B3F)) || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEAFOAM_ISLANDS_B4F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEAFOAM_ISLANDS_B4F))) + return TRUE; + return FALSE; +} + +static u8 GetAdjustedInitialDirection(struct InitialPlayerAvatarState *playerStruct, u8 transitionFlags, u16 metatileBehavior, u8 mapType) +{ + if (FlagGet(FLAG_SYS_CRUISE_MODE) && mapType == MAP_TYPE_OCEAN_ROUTE) + return DIR_EAST; + else if (MetatileBehavior_IsDeepSouthWarp(metatileBehavior) == TRUE) + return DIR_NORTH; + else if (MetatileBehavior_IsNonAnimDoor(metatileBehavior) == TRUE || MetatileBehavior_IsWarpDoor_2(metatileBehavior) == TRUE) + return DIR_SOUTH; + else if (MetatileBehavior_IsSouthArrowWarp(metatileBehavior) == TRUE) + return DIR_NORTH; + else if (MetatileBehavior_IsNorthArrowWarp(metatileBehavior) == TRUE) + return DIR_SOUTH; + else if (MetatileBehavior_IsWestArrowWarp(metatileBehavior) == TRUE) + return DIR_EAST; + else if (MetatileBehavior_IsEastArrowWarp(metatileBehavior) == TRUE) + return DIR_WEST; + else if (MetatileBehavior_IsUnknownWarp6C(metatileBehavior) == TRUE || MetatileBehavior_IsUnknownWarp6E(metatileBehavior) == TRUE) + return DIR_WEST; + else if (MetatileBehavior_IsUnknownWarp6D(metatileBehavior) == TRUE || MetatileBehavior_IsUnknownWarp6F(metatileBehavior) == TRUE) + return DIR_EAST; + else if ((playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_UNDERWATER && transitionFlags == PLAYER_AVATAR_FLAG_SURFING) + || (playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_SURFING && transitionFlags == PLAYER_AVATAR_FLAG_UNDERWATER )) + return playerStruct->direction; + else if (MetatileBehavior_IsLadder(metatileBehavior) == TRUE) + return playerStruct->direction; + else if (playerStruct->unk2) + return playerStruct->direction; + else + return DIR_SOUTH; +} + +static u16 GetCenterScreenMetatileBehavior(void) +{ + return MapGridGetMetatileBehaviorAt(gSaveBlock1Ptr->pos.x + 7, gSaveBlock1Ptr->pos.y + 7); +} + +// Routines related to flash level and map perms + +bool32 Overworld_IsBikingAllowed(void) +{ + if (!gMapHeader.bikingAllowed) + return FALSE; + else + return TRUE; +} + +static void SetDefaultFlashLevel(void) +{ + if (!gMapHeader.cave) + gSaveBlock1Ptr->flashLevel = 0; + else if (FlagGet(FLAG_SYS_FLASH_ACTIVE)) + gSaveBlock1Ptr->flashLevel = 0; + else + gSaveBlock1Ptr->flashLevel = gMaxFlashLevel; +} + +void Overworld_SetFlashLevel(s32 flashLevel) +{ + if (flashLevel < 0 || flashLevel > gMaxFlashLevel) + flashLevel = 0; + gSaveBlock1Ptr->flashLevel = flashLevel; +} + +u8 Overworld_GetFlashLevel(void) +{ + return gSaveBlock1Ptr->flashLevel; +} + +void SetCurrentMapLayout(u16 mapLayoutId) +{ + gSaveBlock1Ptr->mapLayoutId = mapLayoutId; + gMapHeader.mapLayout = GetMapLayout(); +} + +void sub_8055D5C(struct WarpData * warp) +{ + sWarpDestination = *warp; +} + +// Routines related to map music + +static u16 GetLocationMusic(struct WarpData * warp) +{ + return Overworld_GetMapHeaderByGroupAndId(warp->mapGroup, warp->mapNum)->music; +} + +static u16 GetCurrLocationDefaultMusic(void) +{ + u16 music; + music = GetLocationMusic(&gSaveBlock1Ptr->location); + return music; +} + +static u16 GetWarpDestinationMusic(void) +{ + u16 music = GetLocationMusic(&sWarpDestination); + return music; +} + +void Overworld_ResetMapMusic(void) +{ + ResetMapMusic(); +} + +void Overworld_PlaySpecialMapMusic(void) +{ + u16 music; + s16 x, y; + + if (gDisableMapMusicChangeOnMapLoad == 1) + { + StopMapMusic(); + return; + } + if (gDisableMapMusicChangeOnMapLoad == 2) + { + return; + } + if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(POKEMON_LEAGUE_CHAMPIONS_ROOM) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(POKEMON_LEAGUE_CHAMPIONS_ROOM)) + { + PlayerGetDestCoords(&x, &y); + if (y - 7 < 11 && gMPlayInfo_BGM.songHeader == &mus_win_gym) + { + FadeInBGM(4); + return; + } + } + + music = GetCurrLocationDefaultMusic(); + + if (gSaveBlock1Ptr->savedMusic) + music = gSaveBlock1Ptr->savedMusic; + else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && Overworld_MusicCanOverrideMapMusic(MUS_NAMINORI)) + music = MUS_NAMINORI; + + if (music != GetCurrentMapMusic()) + PlayNewMapMusic(music); +} + +void Overworld_SetSavedMusic(u16 songNum) +{ + gSaveBlock1Ptr->savedMusic = songNum; +} + +void Overworld_ClearSavedMusic(void) +{ + gSaveBlock1Ptr->savedMusic = 0; +} + +static void Overworld_TryMapConnectionMusicTransition(void) +{ + u16 newMusic; + u16 currentMusic; + + if (gDisableMapMusicChangeOnMapLoad == 1) + { + StopMapMusic(); + return; + } + if (gDisableMapMusicChangeOnMapLoad == 2) + { + return; + } + + if (FlagGet(FLAG_DONT_TRANSITION_MUSIC) != TRUE) + { + newMusic = GetWarpDestinationMusic(); + currentMusic = GetCurrentMapMusic(); + if (currentMusic == MUS_NAMINORI) + return; + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && Overworld_MusicCanOverrideMapMusic(MUS_NAMINORI)) + newMusic = MUS_NAMINORI; + if (newMusic != currentMusic) + { + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE)) + FadeOutAndFadeInNewMapMusic(newMusic, 4, 4); + else + FadeOutAndPlayNewMapMusic(newMusic, 8); + } + } +} + +void Overworld_ChangeMusicToDefault(void) +{ + u16 currentMusic = GetCurrentMapMusic(); + if (currentMusic != GetCurrLocationDefaultMusic()) + FadeOutAndPlayNewMapMusic(GetCurrLocationDefaultMusic(), 8); +} + +void Overworld_ChangeMusicTo(u16 newMusic) +{ + u16 currentMusic = GetCurrentMapMusic(); + if (currentMusic != newMusic) + FadeOutAndPlayNewMapMusic(newMusic, 8); +} + +static u8 GetMapMusicFadeoutSpeed(void) +{ + const struct MapHeader *mapHeader = GetDestinationWarpMapHeader(); + if (IsMapTypeIndoors(mapHeader->mapType) == TRUE) + return 2; + else + return 4; +} + +void TryFadeOutOldMapMusic(void) +{ + u16 warpMusic = GetWarpDestinationMusic(); + if (FlagGet(FLAG_DONT_TRANSITION_MUSIC) != TRUE && warpMusic != GetCurrentMapMusic()) + { + FadeOutMapMusic(GetMapMusicFadeoutSpeed()); + } +} + +bool8 BGMusicStopped(void) +{ + return IsNotWaitingForBGMStop(); +} + +void Overworld_FadeOutMapMusic(void) +{ + FadeOutMapMusic(4); +} + +static void PlayAmbientCry(void) +{ + s16 x, y; + s8 pan; + s8 volume; + + PlayerGetDestCoords(&x, &y); + if (sIsAmbientCryWaterMon == TRUE + && !MetatileBehavior_IsSurfable(MapGridGetMetatileBehaviorAt(x, y))) + return; + pan = (Random() % 88) + 212; + volume = (Random() % 30) + 50; + + if (gDisableMapMusicChangeOnMapLoad == 1) + { + StopMapMusic(); + return; + } + if (gDisableMapMusicChangeOnMapLoad == 2) + { + return; + } + + PlayCry2(sAmbientCrySpecies, pan, volume, 1); +} + +void UpdateAmbientCry(s16 *state, u16 *delayCounter) +{ + u8 i, monsCount, divBy; + + switch (*state) + { + case 0: + if (sAmbientCrySpecies == SPECIES_NONE) + *state = 4; + else + *state = 1; + break; + case 1: + *delayCounter = (Random() % 2400) + 1200; + *state = 3; + break; + case 2: + *delayCounter = (Random() % 1200) + 1200; + *state = 3; + break; + case 3: + (*delayCounter)--; + if (*delayCounter == 0) + { + PlayAmbientCry(); + *state = 2; + } + break; + case 4: + break; + } +} + +static void ChooseAmbientCrySpecies(void) +{ + sAmbientCrySpecies = GetLocalWildMon(&sIsAmbientCryWaterMon); +} + +bool32 Overworld_MusicCanOverrideMapMusic(u16 music) +{ + if (music == MUS_CYCLING || music == MUS_NAMINORI) + { + if (gMapHeader.regionMapSectionId == MAPSEC_KANTO_VICTORY_ROAD || gMapHeader.regionMapSectionId == MAPSEC_ROUTE_23 || gMapHeader.regionMapSectionId == MAPSEC_INDIGO_PLATEAU) + return FALSE; + } + return TRUE; +} + +u8 GetMapTypeByGroupAndId(s8 mapGroup, s8 mapNum) +{ + return Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum)->mapType; +} + +static u8 GetMapTypeByWarpData(struct WarpData *warp) +{ + return GetMapTypeByGroupAndId(warp->mapGroup, warp->mapNum); +} + +u8 GetCurrentMapType(void) +{ + return GetMapTypeByWarpData(&gSaveBlock1Ptr->location); +} + +u8 GetLastUsedWarpMapType(void) +{ + return GetMapTypeByWarpData(&gLastUsedWarp); +} + +u8 GetLastUsedWarpMapSectionId(void) +{ + return Overworld_GetMapHeaderByGroupAndId(gLastUsedWarp.mapGroup, gLastUsedWarp.mapNum)->regionMapSectionId; +} + +bool8 IsMapTypeOutdoors(u8 mapType) +{ + if (mapType == MAP_TYPE_ROUTE + || mapType == MAP_TYPE_TOWN + || mapType == MAP_TYPE_UNDERWATER + || mapType == MAP_TYPE_CITY + || mapType == MAP_TYPE_OCEAN_ROUTE) + return TRUE; + else + return FALSE; +} + +bool8 Overworld_MapTypeAllowsTeleportAndFly(u8 mapType) +{ + if (mapType == MAP_TYPE_ROUTE + || mapType == MAP_TYPE_TOWN + || mapType == MAP_TYPE_OCEAN_ROUTE + || mapType == MAP_TYPE_CITY) + return TRUE; + else + return FALSE; +} + +bool8 IsMapTypeIndoors(u8 mapType) +{ + if (mapType == MAP_TYPE_INDOOR + || mapType == MAP_TYPE_SECRET_BASE) + return TRUE; + else + return FALSE; +} + +static u8 GetSavedWarpRegionMapSectionId(void) +{ + return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->dynamicWarp.mapGroup, gSaveBlock1Ptr->dynamicWarp.mapNum)->regionMapSectionId; +} + +u8 GetCurrentRegionMapSectionId(void) +{ + return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)->regionMapSectionId; +} + +u8 GetCurrentMapBattleScene(void) +{ + return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)->battleType; +} + +static const int sUnusedData[] = { + 1200, + 3600, + 1200, + 2400, + 50, + 80, + -44, + 44 +}; + +const struct UCoords32 gDirectionToVectors[] = { + { 0u, 0u}, + { 0u, 1u}, + { 0u, -1u}, + {-1u, 0u}, + { 1u, 0u}, + {-1u, 1u}, + { 1u, 1u}, + {-1u, -1u}, + { 1u, -1u}, +}; + +static const struct BgTemplate sOverworldBgTemplates[] = { + { + .bg = 0, + .charBaseIndex = 2, + .mapBaseIndex = 31, + .screenSize = 0, + .paletteMode = 0, + .priority = 0, + .baseTile = 0x000 + }, { + .bg = 1, + .charBaseIndex = 0, + .mapBaseIndex = 29, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0x000 + }, { + .bg = 2, + .charBaseIndex = 0, + .mapBaseIndex = 28, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0x000 + }, { + .bg = 3, + .charBaseIndex = 0, + .mapBaseIndex = 30, + .screenSize = 0, + .paletteMode = 0, + .priority = 3, + .baseTile = 0x000 + } +}; + +static void InitOverworldBgs(void) +{ + MoveSaveBlocks_ResetHeap_(); + sub_8056E80(); + ResetBgsAndClearDma3BusyFlags(FALSE); + InitBgsFromTemplates(0, sOverworldBgTemplates, NELEMS(sOverworldBgTemplates)); + SetBgAttribute(1, BG_ATTR_MOSAIC, TRUE); + SetBgAttribute(2, BG_ATTR_MOSAIC, TRUE); + SetBgAttribute(3, BG_ATTR_MOSAIC, TRUE); + gBGTilemapBuffers2 = AllocZeroed(BG_SCREEN_SIZE); + gBGTilemapBuffers1 = AllocZeroed(BG_SCREEN_SIZE); + gBGTilemapBuffers3 = AllocZeroed(BG_SCREEN_SIZE); + SetBgTilemapBuffer(1, gBGTilemapBuffers2); + SetBgTilemapBuffer(2, gBGTilemapBuffers1); + SetBgTilemapBuffer(3, gBGTilemapBuffers3); + InitStandardTextBoxWindows(); + ResetBg0(); + sub_8069348(); +} + +static void InitOverworldBgs_NoResetHeap(void) +{ + ResetBgsAndClearDma3BusyFlags(FALSE); + InitBgsFromTemplates(0, sOverworldBgTemplates, NELEMS(sOverworldBgTemplates)); + SetBgAttribute(1, BG_ATTR_MOSAIC, TRUE); + SetBgAttribute(2, BG_ATTR_MOSAIC, TRUE); + SetBgAttribute(3, BG_ATTR_MOSAIC, TRUE); + gBGTilemapBuffers2 = AllocZeroed(BG_SCREEN_SIZE); + gBGTilemapBuffers1 = AllocZeroed(BG_SCREEN_SIZE); + gBGTilemapBuffers3 = AllocZeroed(BG_SCREEN_SIZE); + SetBgTilemapBuffer(1, gBGTilemapBuffers2); + SetBgTilemapBuffer(2, gBGTilemapBuffers1); + SetBgTilemapBuffer(3, gBGTilemapBuffers3); + InitStandardTextBoxWindows(); + ResetBg0(); + sub_8069348(); +} + +void CleanupOverworldWindowsAndTilemaps(void) +{ + FreeAllOverworldWindowBuffers(); + Free(gBGTilemapBuffers3); + Free(gBGTilemapBuffers1); + Free(gBGTilemapBuffers2); +} + +static void ResetSafariZoneFlag_(void) +{ + ResetSafariZoneFlag(); +} + +bool32 IsUpdateLinkStateCBActive(void) +{ + if (gMain.callback1 == CB1_UpdateLinkState) + return TRUE; + else + return FALSE; +} + +static void DoCB1_Overworld(u16 newKeys, u16 heldKeys) +{ + struct FieldInput fieldInput; + + sub_8112B3C(); + sub_805BEB8(); + FieldClearPlayerInput(&fieldInput); + FieldGetPlayerInput(&fieldInput, newKeys, heldKeys); + FieldInput_HandleCancelSignpost(&fieldInput); + if (!ScriptContext2_IsEnabled()) + { + if (ProcessPlayerFieldInput(&fieldInput) == TRUE) + { + if (gUnknown_3005E88 == 2) + sub_81127F8(&gInputToStoreInQuestLogMaybe); + ScriptContext2_Enable(); + DismissMapNamePopup(); + } + else + { + player_step(fieldInput.dpadDirection, newKeys, heldKeys); + } + } + RunQuestLogCB(); +} + +static void DoCB1_Overworld_QuestLogPlayback(void) +{ + struct FieldInput fieldInput; + + sub_8112B3C(); + sub_805BEB8(); + sub_8111C68(); + FieldClearPlayerInput(&fieldInput); + fieldInput = gQuestLogFieldInput; + FieldInput_HandleCancelSignpost(&fieldInput); + if (!ScriptContext2_IsEnabled()) + { + if (ProcessPlayerFieldInput(&fieldInput) == TRUE) + { + ScriptContext2_Enable(); + DismissMapNamePopup(); + } + else + { + RunQuestLogCB(); + } + } + else if (sub_8111CD0() == TRUE) + { + RunQuestLogCB(); + } + FieldClearPlayerInput(&gQuestLogFieldInput); +} + +void CB1_Overworld(void) +{ + if (gMain.callback2 == CB2_Overworld) + { + if (sub_8112CAC() == TRUE || gQuestLogState == QL_STATE_2) + DoCB1_Overworld_QuestLogPlayback(); + else + DoCB1_Overworld(gMain.newKeys, gMain.heldKeys); + } +} + +static void OverworldBasic(void) +{ + ScriptContext2_RunScript(); + RunTasks(); + AnimateSprites(); + CameraUpdate(); + sub_8115798(); + UpdateCameraPanning(); + BuildOamBuffer(); + UpdatePaletteFade(); + UpdateTilesetAnimations(); + DoScheduledBgTilemapCopiesToVram(); +} + +// This CB2 is used when starting +void CB2_OverworldBasic(void) +{ + OverworldBasic(); +} + +static void CB2_Overworld(void) +{ + bool32 fading = !!gPaletteFade.active; + if (fading) + SetVBlankCallback(NULL); + OverworldBasic(); + if (fading) + SetFieldVBlankCallback(); +} + +void SetMainCallback1(MainCallback cb) +{ + gMain.callback1 = cb; +} + +static bool8 map_post_load_hook_exec(void) +{ + if (gFieldCallback2) + { + if (!gFieldCallback2()) + { + return FALSE; + } + else + { + gFieldCallback2 = NULL; + gFieldCallback = NULL; + } + } + else + { + if (gFieldCallback) + gFieldCallback(); + else + FieldCB_DefaultWarpExit(); + + gFieldCallback = NULL; + } + + return TRUE; +} + +void CB2_NewGame(void) +{ + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + ResetSafariZoneFlag_(); + NewGameInitData(); + ResetInitialPlayerAvatarState(); + PlayTimeCounter_Start(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + gFieldCallback = FieldCB_WarpExitFadeFromBlack; + gFieldCallback2 = NULL; + do_load_map_stuff_loop(&gMain.state); + SetFieldVBlankCallback(); + SetMainCallback1(CB1_Overworld); + SetMainCallback2(CB2_Overworld); +} + +void CB2_WhiteOut(void) +{ + u8 val; + + if (++gMain.state >= 120) + { + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + ResetSafariZoneFlag_(); + DoWhiteOut(); + SetInitialPlayerAvatarStateWithDirection(DIR_NORTH); + ScriptContext1_Init(); + ScriptContext2_Disable(); + gFieldCallback = FieldCB_RushInjuredPokemonToCenter; + val = 0; + do_load_map_stuff_loop(&val); + QuestLog_OnInteractionWithSpecialNpc(); + SetFieldVBlankCallback(); + SetMainCallback1(CB1_Overworld); + SetMainCallback2(CB2_Overworld); + } +} + +void CB2_LoadMap(void) +{ + FieldClearVBlankHBlankCallbacks(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + SetMainCallback1(NULL); + SetMainCallback2(CB2_DoChangeMap); + gMain.savedCallback = CB2_LoadMap2; +} + +static void CB2_LoadMap2(void) +{ + do_load_map_stuff_loop(&gMain.state); + if (sub_8113748() == TRUE) + { + sub_81119C8(); + } + else + { + SetFieldVBlankCallback(); + SetMainCallback1(CB1_Overworld); + SetMainCallback2(CB2_Overworld); + } +} + +void CB2_ReturnToFieldCableClub(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback = FieldCB_ReturnToFieldWirelessLink; + SetMainCallback2(c2_80567AC); +} + +static void c2_80567AC(void) +{ + if (map_loading_iteration_3(&gMain.state)) + { + SetFieldVBlankCallback(); + SetMainCallback1(CB1_UpdateLinkState); + ResetAllMultiplayerState(); + SetMainCallback2(CB2_Overworld); + } +} + +void CB2_ReturnToField(void) +{ + if (IsUpdateLinkStateCBActive() == TRUE) + { + SetMainCallback2(CB2_ReturnToFieldLink); + } + else + { + FieldClearVBlankHBlankCallbacks(); + SetMainCallback2(CB2_ReturnToFieldLocal); + } +} + +static void CB2_ReturnToFieldLocal(void) +{ + if (sub_8056CD8(&gMain.state)) + { + SetFieldVBlankCallback(); + SetMainCallback2(CB2_Overworld); + } +} + +static void CB2_ReturnToFieldLink(void) +{ + if (!Overworld_LinkRecvQueueLengthMoreThan2() && map_loading_iteration_2_link(&gMain.state)) + SetMainCallback2(CB2_Overworld); +} + +void CB2_ReturnToFieldFromMultiplayer(void) +{ + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + SetMainCallback1(CB1_UpdateLinkState); + ResetAllMultiplayerState(); + + if (gWirelessCommType != 0) + gFieldCallback = FieldCB_ReturnToFieldWirelessLink; + else + gFieldCallback = FieldCB_ReturnToFieldCableLink; + + ScriptContext1_Init(); + ScriptContext2_Disable(); + CB2_ReturnToField(); +} + +void CB2_ReturnToFieldWithOpenMenu(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback2 = FieldCB_ReturnToFieldOpenStartMenu; + CB2_ReturnToField(); +} + +void CB2_ReturnToFieldContinueScript(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback = FieldCB_ContinueScript; + CB2_ReturnToField(); +} + +void CB2_ReturnToFieldContinueScriptPlayMapMusic(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback = FieldCB_ContinueScriptHandleMusic; + CB2_ReturnToField(); +} + +void sub_80568FC(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback = FieldCB_WarpExitFadeFromBlack; + CB2_ReturnToField(); +} + +static void sub_8056918(void) +{ + if (SHOW_MAP_NAME_ENABLED) + ShowMapNamePopup(FALSE); + FieldCB_WarpExitFadeFromBlack(); +} + +void CB2_ContinueSavedGame(void) +{ + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + ResetSafariZoneFlag_(); + LoadSaveblockMapHeader(); + LoadSaveblockObjEventScripts(); + UnfreezeObjectEvents(); + sub_8054E40(); + InitMapFromSavedGame(); + PlayTimeCounter_Start(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + gFieldCallback2 = NULL; + gUnknown_2031DE0 = TRUE; + if (UseContinueGameWarp() == TRUE) + { + ClearContinueGameWarpStatus(); + SetWarpDestinationToContinueGameWarp(); + WarpIntoMap(); + SetMainCallback2(CB2_LoadMap); + } + else + { + gFieldCallback = sub_8056918; + SetMainCallback1(CB1_Overworld); + CB2_ReturnToField(); + } +} + +static void FieldClearVBlankHBlankCallbacks(void) +{ + if (UsedPokemonCenterWarp() == TRUE) + CloseLink(); + + if (gWirelessCommType != 0) + { + EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_VCOUNT | INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL); + DisableInterrupts(INTR_FLAG_HBLANK); + } + else + { + DisableInterrupts(INTR_FLAG_HBLANK); + EnableInterrupts(INTR_FLAG_VBLANK); + } + + SetVBlankCallback(NULL); + SetHBlankCallback(NULL); +} + +static void SetFieldVBlankCallback(void) +{ + SetVBlankCallback(VBlankCB_Field); +} + +static void VBlankCB_Field(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + ScanlineEffect_InitHBlankDmaTransfer(); + FieldUpdateBgTilemapScroll(); + TransferPlttBuffer(); + TransferTilesetAnimsBuffer(); +} + +static void InitCurrentFlashLevelScanlineEffect(void) +{ + u8 flashLevel = Overworld_GetFlashLevel(); + if (flashLevel != 0) + { + WriteFlashScanlineEffectBuffer(flashLevel); + ScanlineEffect_SetParams((struct ScanlineEffectParams){ + .dmaDest = ®_WIN0H, + .dmaControl = (2 >> 1) | ((DMA_16BIT | DMA_DEST_RELOAD | DMA_SRC_INC | DMA_REPEAT | DMA_START_HBLANK | DMA_ENABLE) << 16), + .initState = 1, + .unused9 = 0 + }); + } +} + +static bool32 map_loading_iteration_3(u8 *state) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + (*state)++; + break; + case 1: + mli0_load_map(TRUE); + (*state)++; + break; + case 2: + sub_8057024(TRUE); + (*state)++; + break; + case 3: + sub_8057178(); + sub_8057074(); + sub_80571A8(); + SetCameraToTrackGuestPlayer(); + SetHelpContextForMap(); + (*state)++; + break; + case 4: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 5: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 6: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 7: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 8: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 9: + DrawWholeMapView(); + (*state)++; + break; + case 10: + InitTilesetAnimations(); + (*state)++; + break; + case 11: + if (gWirelessCommType != 0) + { + LoadWirelessStatusIndicatorSpriteGfx(); + CreateWirelessStatusIndicatorSprite(0, 0); + } + (*state)++; + break; + case 12: + if (map_post_load_hook_exec()) + (*state)++; + break; + case 13: + return TRUE; + } + + return FALSE; +} + +static bool32 load_map_stuff(u8 *state, bool32 a1) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + FieldClearVBlankHBlankCallbacks(); + mli0_load_map(a1); + (*state)++; + break; + case 1: + sub_8111F14(); + (*state)++; + break; + case 2: + sub_8057024(a1); + (*state)++; + break; + case 3: + if (sub_8113748() == TRUE) + return TRUE; + (*state)++; + break; + case 4: + mli4_mapscripts_and_other(); + sub_8057114(); + if (gQuestLogState != QL_STATE_2) + { + sub_80CC534(); + sub_80CC59C(); + } + SetHelpContextForMap(); + (*state)++; + break; + case 5: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 6: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 7: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 8: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 9: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 10: + DrawWholeMapView(); + (*state)++; + break; + case 11: + InitTilesetAnimations(); + (*state)++; + break; + case 12: + if (GetLastUsedWarpMapSectionId() != gMapHeader.regionMapSectionId && MapHasPreviewScreen_HandleQLState2(gMapHeader.regionMapSectionId, MPS_TYPE_FOREST) == TRUE) + { + MapPreview_LoadGfx(gMapHeader.regionMapSectionId); + MapPreview_StartForestTransition(gMapHeader.regionMapSectionId); + } + else if (SHOW_MAP_NAME_ENABLED) + { + ShowMapNamePopup(FALSE); + } + (*state)++; + break; + case 13: + if (map_post_load_hook_exec()) + (*state)++; + break; + case 14: + return TRUE; + } + return FALSE; +} + +static bool32 sub_8056CD8(u8 *state) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + sub_8111F14(); + sub_8057024(FALSE); + sub_8057100(); + sub_8057114(); + (*state)++; + break; + case 1: + (*state)++; + break; + case 2: + sub_8056F08(); + SetHelpContextForMap(); + (*state)++; + break; + case 3: + if (map_post_load_hook_exec()) + (*state)++; + break; + case 4: + return TRUE; + } + return FALSE; +} + +static bool32 map_loading_iteration_2_link(u8 *state) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + FieldClearVBlankHBlankCallbacks(); + (*state)++; + break; + case 1: + sub_8111F14(); + sub_8057024(1); + (*state)++; + break; + case 2: + CreateLinkPlayerSprites(); + sub_8057100(); + SetCameraToTrackGuestPlayer_2(); + SetHelpContextForMap(); + (*state)++; + break; + case 3: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 4: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 5: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 6: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 7: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 8: + DrawWholeMapView(); + (*state)++; + break; + case 9: + InitTilesetAnimations(); + (*state)++; + break; + case 10: + (*state)++; + break; + case 11: + if (gWirelessCommType != 0) + { + LoadWirelessStatusIndicatorSpriteGfx(); + CreateWirelessStatusIndicatorSprite(0, 0); + } + (*state)++; + break; + case 12: + if (map_post_load_hook_exec()) + (*state)++; + break; + case 13: + SetFieldVBlankCallback(); + (*state)++; + return TRUE; + } + + return FALSE; +} + +static void do_load_map_stuff_loop(u8 *state) +{ + while (!load_map_stuff(state, FALSE)) + ; +} + +static void MoveSaveBlocks_ResetHeap_(void) +{ + MoveSaveBlocks_ResetHeap(); +} + +static void sub_8056E80(void) +{ + SetGpuReg(REG_OFFSET_DISPCNT, 0); + ScanlineEffect_Stop(); + + DmaClear16(3, PLTT + 2, PLTT_SIZE - 2); + DmaFillLarge16(3, 0, (void *)(VRAM + 0x0), 0x18000, 0x1000); + ResetOamRange(0, 128); + LoadOam(); +} + +static void sub_8056F08(void) +{ + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + mapdata_load_assets_to_gpu_and_full_redraw(); +} + +static void InitOverworldGraphicsRegisters(void) +{ + ClearScheduledBgCopiesToVram(); + ResetTempTileDataBuffers(); + SetGpuReg(REG_OFFSET_MOSAIC, 0); + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WINOBJ_BG0); + SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(0, 255)); + SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(0, 255)); + SetGpuReg(REG_OFFSET_WIN1H, WIN_RANGE(255, 255)); + SetGpuReg(REG_OFFSET_WIN1V, WIN_RANGE(255, 255)); + SetGpuReg(REG_OFFSET_BLDCNT, gOverworldBackgroundLayerFlags[1] | gOverworldBackgroundLayerFlags[2] | gOverworldBackgroundLayerFlags[3] + | BLDCNT_TGT2_OBJ | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(13, 7)); + ScheduleBgCopyTilemapToVram(1); + ScheduleBgCopyTilemapToVram(2); + ScheduleBgCopyTilemapToVram(3); + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | 0x20 | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON | DISPCNT_WIN1_ON); + ShowBg(0); + ShowBg(1); + ShowBg(2); + ShowBg(3); + ChangeBgX(0, 0, 0); + ChangeBgY(0, 0, 0); + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ChangeBgX(2, 0, 0); + ChangeBgY(2, 0, 0); + ChangeBgX(3, 0, 0); + ChangeBgY(3, 0, 0); +} + +static void sub_8057024(u32 a1) +{ + ResetTasks(); + ResetSpriteData(); + ResetPaletteFade(); + ScanlineEffect_Clear(); + ResetAllPicSprites(); + ResetCameraUpdateInfo(); + InstallCameraPanAheadCallback(); + if (!a1) + InitObjectEventPalettes(0); + else + InitObjectEventPalettes(1); + + FieldEffectActiveListClear(); + StartWeather(); + ResumePausedWeather(); + if (!a1) + SetUpFieldTasks(); + RunOnResumeMapScript(); +} + +static void sub_8057074(void) +{ + gTotalCameraPixelOffsetX = 0; + gTotalCameraPixelOffsetY = 0; + ResetObjectEvents(); + TrySpawnObjectEvents(0, 0); + TryRunOnWarpIntoMapScript(); +} + +static void mli4_mapscripts_and_other(void) +{ + s16 x, y; + struct InitialPlayerAvatarState *player; + + gTotalCameraPixelOffsetX = 0; + gTotalCameraPixelOffsetY = 0; + ResetObjectEvents(); + GetCameraFocusCoords(&x, &y); + player = GetInitialPlayerAvatarState(); + InitPlayerAvatar(x, y, player->direction, gSaveBlock2Ptr->playerGender); + SetPlayerAvatarTransitionFlags(player->transitionFlags); + ResetInitialPlayerAvatarState(); + TrySpawnObjectEvents(0, 0); + TryRunOnWarpIntoMapScript(); +} + +static void sub_8057100(void) +{ + sub_805EDF0(0, 0); + RunOnReturnToFieldMapScript(); +} + +static void sub_8057114(void) +{ + gObjectEvents[gPlayerAvatar.objectEventId].trackedByCamera = TRUE; + InitCameraUpdateCallback(gPlayerAvatar.spriteId); +} + +static void SetCameraToTrackGuestPlayer(void) +{ + InitCameraUpdateCallback(GetSpriteForLinkedPlayer(gLocalLinkPlayerId)); +} + +// Duplicate function. +static void SetCameraToTrackGuestPlayer_2(void) +{ + InitCameraUpdateCallback(GetSpriteForLinkedPlayer(gLocalLinkPlayerId)); +} + +static void sub_8057178(void) +{ + u16 x, y; + GetCameraFocusCoords(&x, &y); + + // This is a hack of some kind; it's undone in sub_8086B14, which is called + // soon after this function. + SetCameraFocusCoords(x + gLocalLinkPlayerId, y); +} + +static void sub_80571A8(void) +{ + u16 i; + u16 x, y; + + GetCameraFocusCoords(&x, &y); + x -= gLocalLinkPlayerId; + + for (i = 0; i < gFieldLinkPlayerCount; i++) + { + SpawnLinkPlayerObjectEvent(i, i + x, y, gLinkPlayers[i].gender); + CreateLinkPlayerSprite(i, gLinkPlayers[i].version); + } + + ClearAllPlayerKeys(); +} + +static void CreateLinkPlayerSprites(void) +{ + u16 i; + for (i = 0; i < gFieldLinkPlayerCount; i++) + CreateLinkPlayerSprite(i, gLinkPlayers[i].version); +} + +// Quest Log + +void sub_805726C(void) +{ + FieldClearVBlankHBlankCallbacks(); + gUnknown_2036E28 = 1; + ScriptContext1_Init(); + ScriptContext2_Disable(); + SetMainCallback1(NULL); + SetMainCallback2(CB2_DoChangeMap); + gMain.savedCallback = sub_80572D8; +} + +void sub_80572A8(void) +{ + FieldClearVBlankHBlankCallbacks(); + gUnknown_2036E28 = 1; + LoadSaveblockMapHeader(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + SetMainCallback1(NULL); + SetMainCallback2(sub_80572D8); +} + +static void sub_80572D8(void) +{ + sub_8057300(&gMain.state); + SetFieldVBlankCallback(); + SetMainCallback1(CB1_Overworld); + SetMainCallback2(CB2_Overworld); +} + +static void sub_8057300(u8 *state) +{ + while (!sub_8057314(state)) + ; +} + +static bool32 sub_8057314(u8 *state) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + FieldClearVBlankHBlankCallbacks(); + sub_8111F14(); + sub_81113E4(); + sub_8111438(); + if (sub_8110AC8() == 2) + { + gUnknown_2031DE0 = FALSE; + mli0_load_map(FALSE); + } + else + { + gUnknown_2031DE0 = TRUE; + sub_80559A8(); + } + (*state)++; + break; + case 1: + sub_8110FCC(); + (*state)++; + break; + case 2: + sub_8057024(0); + (*state)++; + break; + case 3: + sub_8057100(); + sub_8057114(); + (*state)++; + break; + case 4: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 5: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 6: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 7: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 8: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 9: + DrawWholeMapView(); + (*state)++; + break; + case 10: + InitTilesetAnimations(); + sub_815A540(); + (*state)++; + break; + default: + if (map_post_load_hook_exec()) + return TRUE; + break; + } + return FALSE; +} + +void sub_8057430(void) +{ + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + gUnknown_2036E28 = 3; + ResetSafariZoneFlag_(); + LoadSaveblockMapHeader(); + LoadSaveblockObjEventScripts(); + UnfreezeObjectEvents(); + sub_8054E40(); + InitMapFromSavedGame(); + PlayTimeCounter_Start(); + ScriptContext1_Init(); + gUnknown_2031DE0 = TRUE; + if (UseContinueGameWarp() == TRUE) + { + ClearContinueGameWarpStatus(); + SetWarpDestinationToContinueGameWarp(); + WarpIntoMap(); + SetMainCallback2(CB2_LoadMap); + } + else + { + SetMainCallback1(CB1_Overworld); + CB2_ReturnToField(); + } +} + +// Credits + +void Overworld_CreditsMainCB(void) +{ + bool8 fading = !!gPaletteFade.active; + if (fading) + SetVBlankCallback(NULL); + RunTasks(); + AnimateSprites(); + sub_805ACF0(); + UpdateCameraPanning(); + BuildOamBuffer(); + UpdatePaletteFade(); + UpdateTilesetAnimations(); + DoScheduledBgTilemapCopiesToVram(); + if (fading) + SetFieldVBlankCallback(); +} + +static bool8 FieldCB2_Credits_WaitFade(void) +{ + if (gPaletteFade.active) + return TRUE; + else + return FALSE; +} + +bool32 Overworld_DoScrollSceneForCredits(u8 *state_p, const struct CreditsOverworldCmd * script, u8 a2) +{ + sCreditsOverworld_Script = script; + gUnknown_2036E28 = a2; + return SetUpScrollSceneForCredits(state_p, 0); +} + +static bool32 SetUpScrollSceneForCredits(u8 *state, u8 unused) +{ + struct WarpData warp; + switch (*state) + { + case 0: + sCreditsOverworld_CmdIndex = 0; + sCreditsOverworld_CmdLength = 0; + (*state)++; + return FALSE; + case 1: + warp.mapGroup = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2; + warp.mapNum = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4; + warp.warpId = -1; + sCreditsOverworld_CmdIndex++; + warp.x = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0; + warp.y = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2; + sWarpDestination = warp; + sCreditsOverworld_CmdLength = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4; + WarpIntoMap(); + gPaletteFade.bufferTransferDisabled = TRUE; + ScriptContext1_Init(); + ScriptContext2_Disable(); + SetMainCallback1(NULL); + gFieldCallback2 = FieldCB2_Credits_WaitFade; + gMain.state = 0; + (*state)++; + return FALSE; + case 2: + if (MapLdr_Credits()) + { + (*state)++; + return FALSE; + } + break; + case 3: + gFieldCamera.callback = CameraCB_CreditsPan; + SetFieldVBlankCallback(); + *state = 0; + return TRUE; + } + return FALSE; +} + +static bool8 MapLdr_Credits(void) +{ + u8 *state = &gMain.state; + switch (*state) + { + case 0: + InitOverworldBgs_NoResetHeap(); + mli0_load_map(FALSE); + (*state)++; + break; + case 1: + ScanlineEffect_Clear(); + ResetAllPicSprites(); + ResetCameraUpdateInfo(); + InstallCameraPanAheadCallback(); + FieldEffectActiveListClear(); + StartWeather(); + ResumePausedWeather(); + SetUpFieldTasks(); + RunOnResumeMapScript(); + (*state)++; + break; + case 2: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 3: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 4: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 5: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 6: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 7: + DrawWholeMapView(); + (*state)++; + break; + case 8: + InitTilesetAnimations(); + gPaletteFade.bufferTransferDisabled = FALSE; + FadeSelectedPals(FADE_FROM_BLACK, 0, 0x3FFFFFFF); + (*state)++; + break; + default: + return TRUE; + } + return FALSE; +} + +static void CameraCB_CreditsPan(struct CameraObject * camera) +{ + if (sCreditsOverworld_CmdLength == 0) + { + sCreditsOverworld_CmdIndex++; + switch (sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0) + { + case CREDITSOVWLDCMD_FC: + case CREDITSOVWLDCMD_LOADMAP: + return; + case CREDITSOVWLDCMD_FF: + camera->movementSpeedX = 0; + camera->movementSpeedY = 0; + camera->callback = NULL; + CreateTask(Task_OvwldCredits_FadeOut, 0); + return; + case CREDITSOVWLDCMD_FB: + camera->movementSpeedX = 0; + camera->movementSpeedY = 0; + camera->callback = NULL; + break; + case CREDITSOVWLDCMD_END: + camera->movementSpeedX = 0; + camera->movementSpeedY = 0; + camera->callback = NULL; + return; + default: + sCreditsOverworld_CmdLength = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4; + camera->movementSpeedX = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0; + camera->movementSpeedY = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2; + break; + } + } + if (sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0 == 0xFF) + { + camera->movementSpeedX = 0; + camera->movementSpeedY = 0; + } + else + sCreditsOverworld_CmdLength--; +} + +static void Task_OvwldCredits_FadeOut(u8 taskId) +{ + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); + gTasks[taskId].func = Task_OvwldCredits_WaitFade; +} + +static void Task_OvwldCredits_WaitFade(u8 taskId) +{ + if (!gPaletteFade.active) + { + CleanupOverworldWindowsAndTilemaps(); + SetMainCallback2(CB2_LoadMap); + DestroyTask(taskId); + } +} + +// Link related + +static u8 (*const sLinkPlayerMovementModes[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8) = { + MovementEventModeCB_Normal, // MOVEMENT_MODE_FREE + MovementEventModeCB_Ignored, // MOVEMENT_MODE_FROZEN + MovementEventModeCB_Normal_2, // MOVEMENT_MODE_SCRIPTED +}; + +// These handlers return TRUE if the movement was scripted and successful, and FALSE otherwise. +static bool8 (*const sLinkPlayerFacingHandlers[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8) = { + FacingHandler_DoNothing, + FacingHandler_DpadMovement, + FacingHandler_DpadMovement, + FacingHandler_DpadMovement, + FacingHandler_DpadMovement, + FacingHandler_DoNothing, + FacingHandler_DoNothing, + FacingHandler_ForcedFacingChange, + FacingHandler_ForcedFacingChange, + FacingHandler_ForcedFacingChange, + FacingHandler_ForcedFacingChange, +}; + +// These handlers are run after an attempted movement. +static void (*const sMovementStatusHandler[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *) = { + // FALSE: + MovementStatusHandler_EnterFreeMode, + // TRUE: + MovementStatusHandler_TryAdvanceScript, +}; + +static void CB1_UpdateLinkState(void) +{ + if (gWirelessCommType == 0 || !IsRfuRecvQueueEmpty() || !IsSendingKeysToLink()) + { + u8 selfId = gLocalLinkPlayerId; + UpdateAllLinkPlayers(gLinkPartnersHeldKeys, selfId); + + // Note: Because guestId is between 0 and 4, while the smallest key code is + // LINK_KEY_CODE_EMPTY, this is functionally equivalent to `sPlayerKeyInterceptCallback(0)`. + // It is expecting the callback to be KeyInterCB_SelfIdle, and that will + // completely ignore any input parameters. + // + // UpdateHeldKeyCode performs a sanity check on its input; if + // sPlayerKeyInterceptCallback echoes back the argument, which is selfId, then + // it'll use LINK_KEY_CODE_EMPTY instead. + // + // Note 2: There are some key intercept callbacks that treat the key as a player + // ID. It's so hacky. + UpdateHeldKeyCode(sPlayerKeyInterceptCallback(selfId)); + ClearAllPlayerKeys(); + } +} + +static void ResetAllMultiplayerState(void) +{ + ResetAllTradingStates(); + SetKeyInterceptCallback(KeyInterCB_SelfIdle); +} + +static void ClearAllPlayerKeys(void) +{ + ResetPlayerHeldKeys(gLinkPartnersHeldKeys); +} + +static void SetKeyInterceptCallback(KeyInterCB func) +{ + sRfuKeepAliveTimer = 0; + sPlayerKeyInterceptCallback = func; +} + +// Once every ~60 frames, if the link state hasn't changed (timer reset by calls +// to SetKeyInterceptCallback), it does a bunch of sanity checks on the connection. +// I'm not sure if sRfuKeepAliveTimer is reset in the process, though; rfu stuff is +// still undocumented. +static void CheckRfuKeepAliveTimer(void) +{ + if (gWirelessCommType != 0 && ++sRfuKeepAliveTimer > 60) + LinkRfu_FatalError(); +} + +static void ResetAllTradingStates(void) +{ + s32 i; + for (i = 0; i < 4; i++) + sPlayerTradingStates[i] = PLAYER_TRADING_STATE_IDLE; +} + +// Returns true if all connected players are in tradingState. +static bool32 AreAllPlayersInTradingState(u16 tradingState) +{ + s32 i; + s32 count = gFieldLinkPlayerCount; + + for (i = 0; i < count; i++) + if (sPlayerTradingStates[i] != tradingState) + return FALSE; + return TRUE; +} + +static bool32 IsAnyPlayerInTradingState(u16 tradingState) +{ + s32 i; + s32 count = gFieldLinkPlayerCount; + + for (i = 0; i < count; i++) + if (sPlayerTradingStates[i] == tradingState) + return TRUE; + return FALSE; +} + +static void HandleLinkPlayerKeyInput(u32 playerId, u16 key, struct TradeRoomPlayer *trainer, u16 *forceFacing) +{ + const u8 *script; + + if (sPlayerTradingStates[playerId] == PLAYER_TRADING_STATE_IDLE) + { + script = TryGetTileEventScript(trainer); + if (script) + { + *forceFacing = GetDirectionForEventScript(script); + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + sub_80581DC(script); + } + return; + } + if (IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + sub_8058230(); + } + return; + } + + switch (key) + { + case LINK_KEY_CODE_START_BUTTON: + if (sub_8058004(trainer)) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + InitLinkRoomStartMenuScript(); + } + } + break; + case LINK_KEY_CODE_DPAD_DOWN: + if (PlayerIsAtSouthExit(trainer) == TRUE) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + CreateConfirmLeaveTradeRoomPrompt(); + } + } + break; + case LINK_KEY_CODE_A_BUTTON: + script = TryInteractWithPlayer(trainer); + if (script) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + InitMenuBasedScript(script); + } + } + break; + case LINK_KEY_CODE_HANDLE_RECV_QUEUE: + if (sub_8057FEC(trainer)) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToRecvQueue); + sub_80581BC(); + } + } + break; + case LINK_KEY_CODE_HANDLE_SEND_QUEUE: + if (sub_8057FEC(trainer)) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToSendQueue); + sub_80581BC(); + } + } + break; + } + } + + switch (key) + { + case LINK_KEY_CODE_EXIT_ROOM: + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_EXITING_ROOM; + break; + case LINK_KEY_CODE_UNK_2: + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_UNK_2; + break; + case LINK_KEY_CODE_UNK_4: + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_IDLE; + if (trainer->isLocalPlayer) + SetKeyInterceptCallback(KeyInterCB_SelfIdle); + break; + case LINK_KEY_CODE_UNK_7: + if (sPlayerTradingStates[playerId] == PLAYER_TRADING_STATE_UNK_2) + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + break; + } +} + +static void UpdateAllLinkPlayers(u16 *keys, s32 selfId) +{ + struct TradeRoomPlayer trainer; + s32 i; + + for (i = 0; i < MAX_LINK_PLAYERS; i++) + { + u8 key = keys[i]; + u16 setFacing = FACING_NONE; + LoadTradeRoomPlayer(i, selfId, &trainer); + HandleLinkPlayerKeyInput(i, key, &trainer, &setFacing); + if (sPlayerTradingStates[i] == PLAYER_TRADING_STATE_IDLE) + setFacing = GetDirectionForDpadKey(key); + SetPlayerFacingDirection(i, setFacing); + } +} + +static void UpdateHeldKeyCode(u16 key) +{ + if (key >= LINK_KEY_CODE_EMPTY && key < LINK_KEY_CODE_UNK_8) + gHeldKeyCodeToSend = key; + else + gHeldKeyCodeToSend = LINK_KEY_CODE_EMPTY; + + if (gWirelessCommType != 0 + && GetLinkSendQueueLength() > 1 + && IsUpdateLinkStateCBActive() == TRUE + && IsSendingKeysToLink() == TRUE) + { + switch (key) + { + case LINK_KEY_CODE_EMPTY: + case LINK_KEY_CODE_DPAD_DOWN: + case LINK_KEY_CODE_DPAD_UP: + case LINK_KEY_CODE_DPAD_LEFT: + case LINK_KEY_CODE_DPAD_RIGHT: + case LINK_KEY_CODE_START_BUTTON: + case LINK_KEY_CODE_A_BUTTON: + gHeldKeyCodeToSend = LINK_KEY_CODE_NULL; + break; + } + } +} + +static u16 KeyInterCB_ReadButtons(u32 key) +{ + if (JOY_HELD(DPAD_UP)) + return LINK_KEY_CODE_DPAD_UP; + else if (JOY_HELD(DPAD_DOWN)) + return LINK_KEY_CODE_DPAD_DOWN; + else if (JOY_HELD(DPAD_LEFT)) + return LINK_KEY_CODE_DPAD_LEFT; + else if (JOY_HELD(DPAD_RIGHT)) + return LINK_KEY_CODE_DPAD_RIGHT; + else if (JOY_NEW(START_BUTTON)) + return LINK_KEY_CODE_START_BUTTON; + else if (JOY_NEW(A_BUTTON)) + return LINK_KEY_CODE_A_BUTTON; + else + return LINK_KEY_CODE_EMPTY; +} + +static u16 GetDirectionForDpadKey(u16 a1) +{ + switch (a1) + { + case LINK_KEY_CODE_DPAD_RIGHT: + return FACING_RIGHT; + case LINK_KEY_CODE_DPAD_LEFT: + return FACING_LEFT; + case LINK_KEY_CODE_DPAD_UP: + return FACING_UP; + case LINK_KEY_CODE_DPAD_DOWN: + return FACING_DOWN; + default: + return FACING_NONE; + } +} + +// Overwrites the keys with 0x11 +static void ResetPlayerHeldKeys(u16 *keys) +{ + s32 i; + for (i = 0; i < 4; i++) + keys[i] = LINK_KEY_CODE_EMPTY; +} + +static u16 KeyInterCB_SelfIdle(u32 key) +{ + if (ScriptContext2_IsEnabled() == TRUE) + return LINK_KEY_CODE_EMPTY; + if (GetLinkRecvQueueLength() > 4) + return LINK_KEY_CODE_HANDLE_RECV_QUEUE; + if (GetLinkSendQueueLength() <= 4) + return KeyInterCB_ReadButtons(key); + return LINK_KEY_CODE_HANDLE_SEND_QUEUE; +} + +static u16 sub_8057D98(u32 key) +{ + CheckRfuKeepAliveTimer(); + return LINK_KEY_CODE_EMPTY; +} + +// Ignore the player's inputs as long as there is an event script +// in ScriptContext2. +static u16 KeyInterCB_DeferToEventScript(u32 key) +{ + u16 retVal; + if (ScriptContext2_IsEnabled() == TRUE) + { + retVal = LINK_KEY_CODE_EMPTY; + } + else + { + retVal = LINK_KEY_CODE_UNK_4; + SetKeyInterceptCallback(sub_8057D98); + } + return retVal; +} + +// Ignore the player's inputs as long as there are events being recived. +static u16 KeyInterCB_DeferToRecvQueue(u32 key) +{ + u16 retVal; + if (GetLinkRecvQueueLength() > 2) + { + retVal = LINK_KEY_CODE_EMPTY; + } + else + { + retVal = LINK_KEY_CODE_UNK_4; + ScriptContext2_Disable(); + SetKeyInterceptCallback(sub_8057D98); + } + return retVal; +} + +// Ignore the player's inputs as long as there are events being sent. +static u16 KeyInterCB_DeferToSendQueue(u32 key) +{ + u16 retVal; + if (GetLinkSendQueueLength() > 2) + { + retVal = LINK_KEY_CODE_EMPTY; + } + else + { + retVal = LINK_KEY_CODE_UNK_4; + ScriptContext2_Disable(); + SetKeyInterceptCallback(sub_8057D98); + } + return retVal; +} + +static u16 KeyInterCB_DoNothingAndKeepAlive(u32 key) +{ + CheckRfuKeepAliveTimer(); + return LINK_KEY_CODE_EMPTY; +} + +static u16 sub_8057E1C(u32 keyOrPlayerId) +{ + if (sPlayerTradingStates[keyOrPlayerId] == PLAYER_TRADING_STATE_UNK_2) + { + if (JOY_NEW(B_BUTTON)) + { + SetKeyInterceptCallback(KeyInterCB_DoNothingAndKeepAlive); + return LINK_KEY_CODE_UNK_7; + } + else + { + return LINK_KEY_CODE_EMPTY; + } + } + else + { + CheckRfuKeepAliveTimer(); + return LINK_KEY_CODE_EMPTY; + } +} + +static u16 sub_8057E58(u32 a1) +{ + SetKeyInterceptCallback(sub_8057E1C); + return LINK_KEY_CODE_UNK_2; +} + +static u16 KeyInterCB_SendNothing(u32 key) +{ + return LINK_KEY_CODE_EMPTY; +} + +static u16 KeyInterCB_WaitForPlayersToExit(u32 keyOrPlayerId) +{ + // keyOrPlayerId could be any keycode. This callback does no sanity checking + // on the size of the key. It's assuming that it is being called from + // CB1_UpdateLinkState. + if (sPlayerTradingStates[keyOrPlayerId] != PLAYER_TRADING_STATE_EXITING_ROOM) + CheckRfuKeepAliveTimer(); + if (AreAllPlayersInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE) + { + ScriptContext1_SetupScript(CableClub_EventScript_DoLinkRoomExit); + SetKeyInterceptCallback(KeyInterCB_SendNothing); + } + return LINK_KEY_CODE_EMPTY; +} + +static u16 KeyInterCB_SendExitRoomKey(u32 key) +{ + SetKeyInterceptCallback(KeyInterCB_WaitForPlayersToExit); + return LINK_KEY_CODE_EXIT_ROOM; +} + +// Duplicate function. +static u16 KeyInterCB_SendNothing_2(u32 key) +{ + return LINK_KEY_CODE_EMPTY; +} + +u32 sub_8057EC0(void) +{ + if (IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE) + return 2; + if (sPlayerKeyInterceptCallback == sub_8057E1C && sPlayerTradingStates[gLocalLinkPlayerId] != PLAYER_TRADING_STATE_UNK_2) + return 0; + if (sPlayerKeyInterceptCallback == KeyInterCB_DoNothingAndKeepAlive && sPlayerTradingStates[gLocalLinkPlayerId] == PLAYER_TRADING_STATE_BUSY) + return 2; + if (AreAllPlayersInTradingState(PLAYER_TRADING_STATE_UNK_2) != FALSE) + return 1; + return 0; +} + +static bool32 sub_8057F28(void) +{ + return IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM); +} + +u16 sub_8057F34(void) +{ + SetKeyInterceptCallback(sub_8057E58); + return 0; +} + +u16 sub_8057F48(void) +{ + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + return 0; +} + +// The exit room key will be sent at the next opportunity. +// The return value is meaningless. +u16 QueueExitLinkRoomKey(void) +{ + SetKeyInterceptCallback(KeyInterCB_SendExitRoomKey); + return 0; +} + +u16 sub_8057F70(void) +{ + SetKeyInterceptCallback(KeyInterCB_SendNothing_2); + return 0; +} + +static void LoadTradeRoomPlayer(s32 linkPlayerId, s32 myPlayerId, struct TradeRoomPlayer *trainer) +{ + s16 x, y; + + trainer->playerId = linkPlayerId; + trainer->isLocalPlayer = (linkPlayerId == myPlayerId) ? TRUE : FALSE; + trainer->c = gLinkPlayerObjectEvents[linkPlayerId].movementMode; + trainer->facing = GetLinkPlayerFacingDirection(linkPlayerId); + GetLinkPlayerCoords(linkPlayerId, &x, &y); + trainer->pos.x = x; + trainer->pos.y = y; + trainer->pos.height = GetLinkPlayerElevation(linkPlayerId); + trainer->field_C = MapGridGetMetatileBehaviorAt(x, y); +} + +static bool32 sub_8057FEC(struct TradeRoomPlayer *player) +{ + u8 v1 = player->c; + if (v1 == MOVEMENT_MODE_SCRIPTED || v1 == MOVEMENT_MODE_FREE) + return TRUE; + else + return FALSE; +} + +// Duplicate function. +static bool32 sub_8058004(struct TradeRoomPlayer *player) +{ + u8 v1 = player->c; + if (v1 == MOVEMENT_MODE_SCRIPTED || v1 == MOVEMENT_MODE_FREE) + return TRUE; + else + return FALSE; +} + +static const u8 *TryGetTileEventScript(struct TradeRoomPlayer *player) +{ + if (player->c != MOVEMENT_MODE_SCRIPTED) + return FACING_NONE; + return GetCoordEventScriptAtMapPosition(&player->pos); +} + +static bool32 PlayerIsAtSouthExit(struct TradeRoomPlayer *player) +{ + if (player->c != MOVEMENT_MODE_SCRIPTED && player->c != MOVEMENT_MODE_FREE) + return FALSE; + else if (!MetatileBehavior_IsSouthArrowWarp(player->field_C)) + return FALSE; + else if (player->facing != DIR_SOUTH) + return FALSE; + else + return TRUE; +} + +static const u8 *TryInteractWithPlayer(struct TradeRoomPlayer *player) +{ + struct MapPosition otherPlayerPos; + u8 linkPlayerId; + + if (player->c != MOVEMENT_MODE_FREE && player->c != MOVEMENT_MODE_SCRIPTED) + return FACING_NONE; + + otherPlayerPos = player->pos; + otherPlayerPos.x += gDirectionToVectors[player->facing].x; + otherPlayerPos.y += gDirectionToVectors[player->facing].y; + otherPlayerPos.height = 0; + linkPlayerId = GetLinkPlayerIdAt(otherPlayerPos.x, otherPlayerPos.y); + + if (linkPlayerId != 4) + { + if (!player->isLocalPlayer) + return CableClub_EventScript_TooBusyToNotice; + else if (sPlayerTradingStates[linkPlayerId] != PLAYER_TRADING_STATE_IDLE) + return CableClub_EventScript_TooBusyToNotice; + else if (!GetSeeingLinkPlayerCardMsg(linkPlayerId)) + return CableClub_EventScript_ReadTrainerCard; + else + return CableClub_EventScript_ReadTrainerCardColored; + } + + return GetInteractedLinkPlayerScript(&otherPlayerPos, player->field_C, player->facing); +} + +// This returns which direction to force the player to look when one of +// these event scripts runs. +static u16 GetDirectionForEventScript(const u8 *script) +{ + if (script == BattleColosseum_4P_EventScript_PlayerSpot0) + return FACING_FORCED_RIGHT; + else if (script == BattleColosseum_4P_EventScript_PlayerSpot1) + return FACING_FORCED_LEFT; + else if (script == BattleColosseum_4P_EventScript_PlayerSpot2) + return FACING_FORCED_RIGHT; + else if (script == BattleColosseum_4P_EventScript_PlayerSpot3) + return FACING_FORCED_LEFT; + else if (script == RecordCenter_EventScript_Spot0) + return FACING_FORCED_RIGHT; + else if (script == RecordCenter_EventScript_Spot1) + return FACING_FORCED_LEFT; + else if (script == RecordCenter_EventScript_Spot2) + return FACING_FORCED_RIGHT; + else if (script == RecordCenter_EventScript_Spot3) + return FACING_FORCED_LEFT; + else if (script == BattleColosseum_2P_EventScript_PlayerSpot0) + return FACING_FORCED_RIGHT; + else if (script == BattleColosseum_2P_EventScript_PlayerSpot1) + return FACING_FORCED_LEFT; + else if (script == TradeCenter_EventScript_Chair0) + return FACING_FORCED_RIGHT; + else if (script == TradeCenter_EventScript_Chair1) + return FACING_FORCED_LEFT; + else + return FACING_NONE; +} + +static void sub_80581BC(void) +{ + ScriptContext2_Enable(); +} + +static void InitLinkRoomStartMenuScript(void) +{ + PlaySE(SE_WIN_OPEN); + ShowStartMenu(); + ScriptContext2_Enable(); +} + +static void sub_80581DC(const u8 *script) +{ + PlaySE(SE_SELECT); + ScriptContext1_SetupScript(script); + ScriptContext2_Enable(); +} + +static void CreateConfirmLeaveTradeRoomPrompt(void) +{ + PlaySE(SE_WIN_OPEN); + ScriptContext1_SetupScript(TradeCenter_ConfirmLeaveRoom); + ScriptContext2_Enable(); +} + +static void InitMenuBasedScript(const u8 *script) +{ + PlaySE(SE_SELECT); + ScriptContext1_SetupScript(script); + ScriptContext2_Enable(); +} + +static void sub_8058230(void) +{ + ScriptContext1_SetupScript(TradeCenter_TerminateLink); + ScriptContext2_Enable(); +} + +bool32 Overworld_LinkRecvQueueLengthMoreThan2(void) +{ + if (!IsUpdateLinkStateCBActive()) + return FALSE; + if (GetLinkRecvQueueLength() >= 3) + sReceivingFromLink = TRUE; + else + sReceivingFromLink = FALSE; + return sReceivingFromLink; +} + +bool32 sub_8058274(void) +{ + u8 temp; + + if (GetLinkRecvQueueLength() < 2) + return FALSE; + else if (IsUpdateLinkStateCBActive() != TRUE) + return FALSE; + else if (IsSendingKeysToLink() != TRUE) + return FALSE; + else if (sPlayerKeyInterceptCallback == KeyInterCB_DeferToRecvQueue) + return TRUE; + else if (sPlayerKeyInterceptCallback != KeyInterCB_DeferToEventScript) + return FALSE; + + temp = sReceivingFromLink; + sReceivingFromLink = FALSE; + + if (temp == TRUE) + return TRUE; + else if (gPaletteFade.active && gPaletteFade.softwareFadeFinishing) + return TRUE; + else + return FALSE; +} + +bool32 sub_80582E0(void) +{ + if (GetLinkSendQueueLength() < 2) + return FALSE; + else if (IsUpdateLinkStateCBActive() != TRUE) + return FALSE; + else if (IsSendingKeysToLink() != TRUE) + return FALSE; + else if (sPlayerKeyInterceptCallback == KeyInterCB_DeferToSendQueue) + return TRUE; + else + return FALSE; +} + +bool32 sub_8058318(void) +{ + if (gWirelessCommType != 0) + return FALSE; + else if (!IsSendingKeysToLink()) + return FALSE; + else + return TRUE; +} + +static u32 GetLinkSendQueueLength(void) +{ + if (gWirelessCommType != 0) + return Rfu.sendQueue.count; + else + return gLink.sendQueue.count; +} + +static void ZeroLinkPlayerObjectEvent(struct LinkPlayerObjectEvent *linkPlayerObjEvent) +{ + memset(linkPlayerObjEvent, 0, sizeof(struct LinkPlayerObjectEvent)); +} + +void ClearLinkPlayerObjectEvents(void) +{ + memset(gLinkPlayerObjectEvents, 0, sizeof(gLinkPlayerObjectEvents)); +} + +static void ZeroObjectEvent(struct ObjectEvent *objEvent) +{ + memset(objEvent, 0, sizeof(struct ObjectEvent)); +} + +static void SpawnLinkPlayerObjectEvent(u8 linkPlayerId, s16 x, s16 y, u8 a4) +{ + u8 objEventId = GetFirstInactiveObjectEventId(); + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId]; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + + ZeroLinkPlayerObjectEvent(linkPlayerObjEvent); + ZeroObjectEvent(objEvent); + + linkPlayerObjEvent->active = TRUE; + linkPlayerObjEvent->linkPlayerId = linkPlayerId; + linkPlayerObjEvent->objEventId = objEventId; + linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FREE; + + objEvent->active = TRUE; + objEvent->singleMovementActive = a4; + objEvent->range.as_byte = 2; + objEvent->spriteId = MAX_SPRITES; + + InitLinkPlayerObjectEventPos(objEvent, x, y); +} + +static void InitLinkPlayerObjectEventPos(struct ObjectEvent *objEvent, s16 x, s16 y) +{ + objEvent->currentCoords.x = x; + objEvent->currentCoords.y = y; + objEvent->previousCoords.x = x; + objEvent->previousCoords.y = y; + SetSpritePosToMapCoords(x, y, &objEvent->initialCoords.x, &objEvent->initialCoords.y); + objEvent->initialCoords.x += 8; + ObjectEventUpdateZCoord(objEvent); +} + +static void sub_8058488(u8 linkPlayerId, u8 a2) +{ + if (gLinkPlayerObjectEvents[linkPlayerId].active) + { + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + objEvent->range.as_byte = a2; + } +} + +static void sub_80584B8(u8 linkPlayerId) +{ + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId]; + u8 objEventId = linkPlayerObjEvent->objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + if (objEvent->spriteId != MAX_SPRITES) + DestroySprite(&gSprites[objEvent->spriteId]); + linkPlayerObjEvent->active = FALSE; + objEvent->active = FALSE; +} + +// Returns the spriteId corresponding to this player. +static u8 GetSpriteForLinkedPlayer(u8 linkPlayerId) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + return objEvent->spriteId; +} + +static void GetLinkPlayerCoords(u8 linkPlayerId, u16 *x, u16 *y) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + *x = objEvent->currentCoords.x; + *y = objEvent->currentCoords.y; +} + +static u8 GetLinkPlayerFacingDirection(u8 linkPlayerId) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + return objEvent->range.as_byte; +} + +static u8 GetLinkPlayerElevation(u8 linkPlayerId) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + return objEvent->currentElevation; +} + +static s32 sub_8058590(u8 linkPlayerId) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + return 16 - (s8)objEvent->directionSequenceIndex; +} + +static u8 GetLinkPlayerIdAt(s16 x, s16 y) +{ + u8 i; + for (i = 0; i < MAX_LINK_PLAYERS; i++) + { + if (gLinkPlayerObjectEvents[i].active + && (gLinkPlayerObjectEvents[i].movementMode == 0 || gLinkPlayerObjectEvents[i].movementMode == 2)) + { + struct ObjectEvent *objEvent = &gObjectEvents[gLinkPlayerObjectEvents[i].objEventId]; + if (objEvent->currentCoords.x == x && objEvent->currentCoords.y == y) + return i; + } + } + return 4; +} + +static void SetPlayerFacingDirection(u8 linkPlayerId, u8 facing) +{ + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId]; + u8 objEventId = linkPlayerObjEvent->objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + + if (linkPlayerObjEvent->active) + { + if (facing > FACING_FORCED_RIGHT) + { + objEvent->triggerGroundEffectsOnMove = TRUE; + } + else + { + // This is a hack to split this code onto two separate lines, without declaring a local variable. + // C++ style inline variables would be nice here. +#define TEMP sLinkPlayerMovementModes[linkPlayerObjEvent->movementMode](linkPlayerObjEvent, objEvent, facing) + + sMovementStatusHandler[TEMP](linkPlayerObjEvent, objEvent); + + // Clean up the hack. +#undef TEMP + } + } +} + +static u8 MovementEventModeCB_Normal(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + return sLinkPlayerFacingHandlers[a3](linkPlayerObjEvent, objEvent, a3); +} + +static u8 MovementEventModeCB_Ignored(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + return FACING_UP; +} + +// Duplicate Function +static u8 MovementEventModeCB_Normal_2(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + return sLinkPlayerFacingHandlers[a3](linkPlayerObjEvent, objEvent, a3); +} + +static bool8 FacingHandler_DoNothing(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + return FALSE; +} + +static bool8 FacingHandler_DpadMovement(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + s16 x, y; + + objEvent->range.as_byte = FlipVerticalAndClearForced(a3, objEvent->range.as_byte); + ObjectEventMoveDestCoords(objEvent, objEvent->range.as_byte, &x, &y); + + if (LinkPlayerDetectCollision(linkPlayerObjEvent->objEventId, objEvent->range.as_byte, x, y)) + { + return FALSE; + } + else + { + objEvent->directionSequenceIndex = 16; + ShiftObjectEventCoords(objEvent, x, y); + ObjectEventUpdateZCoord(objEvent); + return TRUE; + } +} + +static bool8 FacingHandler_ForcedFacingChange(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + objEvent->range.as_byte = FlipVerticalAndClearForced(a3, objEvent->range.as_byte); + return FALSE; +} + +// This is called every time a free movement happens. Most of the time it's a No-Op. +static void MovementStatusHandler_EnterFreeMode(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent) +{ + linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FREE; +} + +static void MovementStatusHandler_TryAdvanceScript(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent) +{ + objEvent->directionSequenceIndex--; + linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FROZEN; + MoveCoords(objEvent->range.as_byte, &objEvent->initialCoords.x, &objEvent->initialCoords.y); + if (!objEvent->directionSequenceIndex) + { + ShiftStillObjectEventCoords(objEvent); + linkPlayerObjEvent->movementMode = MOVEMENT_MODE_SCRIPTED; + } +} + +// Flip Up/Down facing codes. If newFacing doesn't specify a direction, default +// to oldFacing. Note that this clears also the "FORCED" part of the facing code, +// even for Left/Right codes. +static u8 FlipVerticalAndClearForced(u8 newFacing, u8 oldFacing) +{ + switch (newFacing) + { + case FACING_UP: + case FACING_FORCED_UP: + return DIR_NORTH; + case FACING_DOWN: + case FACING_FORCED_DOWN: + return DIR_SOUTH; + case FACING_LEFT: + case FACING_FORCED_LEFT: + return DIR_WEST; + case FACING_RIGHT: + case FACING_FORCED_RIGHT: + return DIR_EAST; + } + return oldFacing; +} + +static bool8 LinkPlayerDetectCollision(u8 selfObjEventId, u8 a2, s16 x, s16 y) +{ + u8 i; + for (i = 0; i < 16; i++) + { + if (i != selfObjEventId) + { + if ((gObjectEvents[i].currentCoords.x == x && gObjectEvents[i].currentCoords.y == y) + || (gObjectEvents[i].previousCoords.x == x && gObjectEvents[i].previousCoords.y == y)) + { + return TRUE; + } + } + } + return MapGridIsImpassableAt(x, y); +} + +static void CreateLinkPlayerSprite(u8 linkPlayerId, u8 gameVersion) +{ + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId]; + u8 objEventId = linkPlayerObjEvent->objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + struct Sprite *sprite; + + if (linkPlayerObjEvent->active) + { + if (gameVersion == VERSION_FIRE_RED || gameVersion == VERSION_LEAF_GREEN) + { + objEvent->spriteId = AddPseudoObjectEvent( + GetRivalAvatarGraphicsIdByStateIdAndGender(PLAYER_AVATAR_STATE_NORMAL, objEvent->singleMovementActive), + SpriteCB_LinkPlayer, 0, 0, 0); + } + else + { + objEvent->spriteId = AddPseudoObjectEvent(GetRSAvatarGraphicsIdByGender(objEvent->singleMovementActive), SpriteCB_LinkPlayer, 0, 0, 0); + } + + sprite = &gSprites[objEvent->spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->data[0] = linkPlayerId; + objEvent->triggerGroundEffectsOnMove = FALSE; + } +} + +static void SpriteCB_LinkPlayer(struct Sprite *sprite) +{ + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[sprite->data[0]]; + struct ObjectEvent *objEvent = &gObjectEvents[linkPlayerObjEvent->objEventId]; + sprite->pos1.x = objEvent->initialCoords.x; + sprite->pos1.y = objEvent->initialCoords.y; + SetObjectSubpriorityByZCoord(objEvent->previousElevation, sprite, 1); + sprite->oam.priority = ZCoordToPriority(objEvent->previousElevation); + + if (!linkPlayerObjEvent->movementMode != MOVEMENT_MODE_FREE) + StartSpriteAnim(sprite, GetFaceDirectionAnimNum(objEvent->range.as_byte)); + else + StartSpriteAnimIfDifferent(sprite, GetMoveDirectionAnimNum(objEvent->range.as_byte)); + + UpdateObjectEventSpriteVisibility(sprite, 0); + if (objEvent->triggerGroundEffectsOnMove) + { + sprite->invisible = ((sprite->data[7] & 4) >> 2); + sprite->data[7]++; + } +} diff --git a/src/party_menu_specials.c b/src/party_menu_specials.c index aba11a534..48406da9a 100644 --- a/src/party_menu_specials.c +++ b/src/party_menu_specials.c @@ -47,7 +47,7 @@ void SelectMoveDeleterMove(void) { ShowSelectMovePokemonSummaryScreen(gPlayerParty, gSpecialVar_0x8004, gPlayerPartyCount - 1, CB2_ReturnToField, 0); sub_8138B38(3); - gFieldCallback = FieldCallback_ReturnToEventScript2; + gFieldCallback = FieldCB_ContinueScriptHandleMusic; } void GetNumMovesSelectedMonHas(void) diff --git a/src/pokemon_jump_2.c b/src/pokemon_jump_2.c index aa1238e3f..9f2f9e404 100644 --- a/src/pokemon_jump_2.c +++ b/src/pokemon_jump_2.c @@ -1883,7 +1883,7 @@ static int sub_81497A8(void) static bool32 sub_8149804(void) { - return !Rfu.unk_124.count && !Rfu.unk_9e8.count; + return !Rfu.unk_124.count && !Rfu.sendQueue.count; } static int sub_8149834(u8 *arg0) diff --git a/src/post_battle_event_funcs.c b/src/post_battle_event_funcs.c index 86406fa2a..7d154f815 100644 --- a/src/post_battle_event_funcs.c +++ b/src/post_battle_event_funcs.c @@ -28,8 +28,8 @@ bool8 EnterHallOfFame(void) { SetGameStat(GAME_STAT_FIRST_HOF_PLAY_TIME, (gSaveBlock2Ptr->playTimeHours << 16) | (gSaveBlock2Ptr->playTimeMinutes << 8) | gSaveBlock2Ptr->playTimeSeconds); } - sub_804C1AC(); - sub_8055738(SPAWN_PALLET_TOWN); + SetContinueGameWarpStatus(); + SetContinueGameWarpToHealLocation(SPAWN_PALLET_TOWN); gaveAtLeastOneRibbon = FALSE; for (i = 0, r7 = &ribbonState; i < PARTY_SIZE; i++) { diff --git a/src/quest_log.c b/src/quest_log.c index bc8e67a6b..51e09e899 100644 --- a/src/quest_log.c +++ b/src/quest_log.c @@ -43,8 +43,7 @@ #include "constants/species.h" #include "constants/items.h" #include "constants/field_weather.h" - -u8 gUnknown_3005E88; +#include "constants/event_object_movement.h" struct TrainerFanClub { @@ -69,7 +68,7 @@ struct UnkStruct_203AE94 u8 unk_3; }; -struct UnkStruct_203AE98 +struct QuestLogEntry { u8 unk_0; u8 unk_1; @@ -94,9 +93,9 @@ struct UnkStruct_203B044 }; u8 gUnknown_3005E88; -u16 sNumQuestLogs; -struct UnkStruct_3005E90 gUnknown_3005E90; -struct UnkStruct_203AE98 * gUnknown_3005E94; +u16 sNumEventsInLogEntry; +struct FieldInput gQuestLogFieldInput; +struct QuestLogEntry * sCurQuestLogEntry; static struct UnkStruct_300201C * sFlagOrVarRecords; static u16 sNumFlagsOrVars; @@ -105,44 +104,44 @@ static EWRAM_DATA u8 sCurrentSceneNum = 0; static EWRAM_DATA u8 sNumScenes = 0; EWRAM_DATA u8 gQuestLogState = 0; static EWRAM_DATA u16 gUnknown_203ADFC = 0; -static EWRAM_DATA u8 gUnknown_203ADFE[3] = {0}; +static EWRAM_DATA u8 sQuestLogHeaderWindowIds[3] = {0}; static EWRAM_DATA u16 *gUnknown_203AE04 = NULL; -static EWRAM_DATA u16 *gUnknown_203AE08 = NULL; +static EWRAM_DATA u16 *sEventRecordingPointer = NULL; static EWRAM_DATA u16 *gUnknown_203AE0C[32] = {NULL}; static EWRAM_DATA void (* sQuestLogCB)(void) = NULL; static EWRAM_DATA u16 *gUnknown_203AE90 = NULL; static EWRAM_DATA struct UnkStruct_203AE94 gUnknown_203AE94 = {0}; -static EWRAM_DATA struct UnkStruct_203AE98 gUnknown_203AE98[32] = {0}; -static EWRAM_DATA u16 sQuestLogIdx = 0; +static EWRAM_DATA struct QuestLogEntry sQuestLogSceneRecordBuffer[32] = {0}; +static EWRAM_DATA u16 sQuestLogCursor = 0; static EWRAM_DATA u8 sMovementScripts[64][2] = {{0}}; -static EWRAM_DATA u16 gUnknown_203B01A = 0; +static EWRAM_DATA u16 sNextStepDelay = 0; static EWRAM_DATA u16 gUnknown_203B01C = 0; static EWRAM_DATA u16 sFlagOrVarPlayhead = 0; static EWRAM_DATA u8 sHelpMessageWindowId = 0; static EWRAM_DATA struct UnkStruct_203B024 gUnknown_203B024 = {0}; static EWRAM_DATA struct UnkStruct_203B044 gUnknown_203B044 = {0}; static EWRAM_DATA u8 gUnknown_203B048 = 0; -static EWRAM_DATA u8 gUnknown_203B049 = 0; +static EWRAM_DATA bool8 sNewlyEnteredMap = FALSE; static EWRAM_DATA u8 gUnknown_203B04A = 0; -static EWRAM_DATA bool8 gUnknown_203B04B = 0; +static EWRAM_DATA bool8 gUnknown_203B04B = FALSE; static void sub_8110A00(void); static void sub_8110A3C(void); -static void sub_8110BB0(u8); -static void sub_8110BE8(u8); -static void sub_8110E3C(void); -static void sub_8110D94(void); -static void sub_8110E20(void); -static void sub_8110D48(u8); -static u8 sub_8110E68(struct UnkStruct_203AE98 *); +static void SetPlayerInitialCoordsAtScene(u8); +static void SetNPCInitialCoordsAtScene(u8); +static void TryRecordEvent39_GoToNextScene(void); +static void BackUpTrainerRematchesToVars(void); +static void BackUpMapLayoutToVar(void); +static void SetGameStateAtScene(u8); +static u8 TryRecordQuestLogEntrySequence(struct QuestLogEntry *); static void sub_8110F90(u8); -static void sub_8111150(u8); +static void QuestLogPlaybackSetObjectEventTemplates(u8); static void sub_8111368(void); static void QuestLog_GetSaneMonCounts(void); static u16 QuestLog_GetSanePartyCount(void); static u16 QuestLog_GetSaneBoxCount(void); static void sub_8111688(void); -static void sub_811175C(u8, struct UnkStruct_203AE98 *); +static void sub_811175C(u8, struct QuestLogEntry *); static void sub_81118F4(s8); static void QuestLog_AdvancePlayhead(void); static void QuestLog_StartFinalScene(void); @@ -163,9 +162,9 @@ static void Task_EndQuestLog(u8); static bool8 sub_81121D8(u8); static void sub_811229C(void); static void sub_8112888(u8); -static void sub_8112940(u8, struct UnkStruct_203AE98 *, u16); +static void SetUpQuestLogEntry(u8, struct QuestLogEntry *, u16); static bool8 sub_8112CEC(void); -static bool8 sub_8112D1C(void); +static bool8 RecordHeadAtEndOfEntry(void); static void TryLoseFansFromPlayTimeAfterLinkBattle(struct TrainerFanClub *); static void UpdateTrainerFanClubGameClear(struct TrainerFanClub *); static u8 PlayerGainRandomTrainerFan(struct TrainerFanClub *); @@ -183,7 +182,7 @@ static bool8 sub_81137E4(u16, const u16 *); static u16 *sub_8113828(u16, const u16 *); static bool8 TrySetLinkQuestLogEvent(u16, const u16 *); static bool8 TrySetTrainerBattleQuestLogEvent(u16, const u16 *); -static void sub_8113A1C(u16); +static void TryRecordEvent41_IncCursor(u16); static void sub_811381C(void); static bool8 IsQuestLogEventWithSpecialEncounterSpecies(u16, const u16 *); static u16 *QuestLog_SkipCommand(u16 *, u16 **); @@ -193,14 +192,14 @@ static bool8 sub_8113B44(const u16 *); static void sub_8113B88(void); static void sub_8113B94(u16); static void sub_8113BD8(void); -static u16 *sub_8113BF4(u16 *); -static u16 *sub_8113C20(u16 *, struct UnkStruct_203AE98 *); -static u16 *sub_8113C5C(u16 *, u16); -static u16 *sub_8113C8C(u16 *, struct UnkStruct_203AE98 *); -static u16 *sub_8113CC8(u16 *, struct UnkStruct_203AE98 *); -static u16 *sub_8113D08(u16 *, struct UnkStruct_203AE98 *); -static u16 *sub_8113D48(u16 *, struct UnkStruct_203AE98 *); -static u16 *sub_8113D94(u16 *, struct UnkStruct_203AE98 *); +static u16 *TryRecordEvent39_NoParams(u16 *); +static u16 *sub_8113C20(u16 *, struct QuestLogEntry *); +static u16 *TryRecordEvent41(u16 *, u16); +static u16 *sub_8113C8C(u16 *, struct QuestLogEntry *); +static u16 *sub_8113CC8(u16 *, struct QuestLogEntry *); +static u16 *sub_8113D08(u16 *, struct QuestLogEntry *); +static u16 *sub_8113D48(u16 *, struct QuestLogEntry *); +static u16 *sub_8113D94(u16 *, struct QuestLogEntry *); static u16 *BufferQuestLogData_SwitchedPartyOrder(u16 *, const u16 *); static u16 *BufferQuestLogData_UsedItem(u16 *, const u16 *); static u16 *BufferQuestLogData_GaveHeldItemFromPartyMenu(u16 *, const u16 *); @@ -282,7 +281,7 @@ static bool8 sub_81153A8(u16, const u16 *); static bool8 sub_81153E4(u16, const u16 *); static void BufferLinkPartnersName(u8 *); -static const struct WindowTemplate gUnknown_845661C[3] = { +static const struct WindowTemplate sQuestLogHeaderWindowTemplates[3] = { { 0, 0, 0, 30, 2, 15, 0x0e9 }, { 0, 0, 18, 30, 2, 15, 0x0ad }, { 0, 0, 14, 30, 6, 15, 0x14c } @@ -301,9 +300,9 @@ void sub_8110840(void * oldPointer) gUnknown_203AE04 = (void *)gUnknown_203AE04 + offset; if (gQuestLogState != 0) { - if (gUnknown_203AE08) - gUnknown_203AE08 = (void *)gUnknown_203AE08 + offset; - if (gQuestLogState == 2) + if (sEventRecordingPointer) + sEventRecordingPointer = (void *)sEventRecordingPointer + offset; + if (gQuestLogState == QL_STATE_2) { int r3; for (r3 = 0; r3 < (int)NELEMS(gUnknown_203AE0C); r3++) @@ -319,13 +318,13 @@ void ResetQuestLog(void) sCurrentSceneNum = 0; gQuestLogState = 0; sQuestLogCB = NULL; - gUnknown_203AE08 = NULL; + sEventRecordingPointer = NULL; gUnknown_203AE04 = NULL; sub_8113BD8(); sub_81138F8(); } -void sub_81108F0(u8 a0) +static void DestroySav1QuestLogEntry(u8 a0) { memset(gSaveBlock1Ptr->questLog + a0, 0, sizeof(struct QuestLog)); gUnknown_203AE04 = NULL; @@ -352,12 +351,12 @@ bool8 sub_8110944(const void * a0, size_t cmdSize) return TRUE; } -bool8 sub_8110988(u16 *a0, size_t a1) +static bool8 WillCommandOfSizeFitInSav1Record(u16 *cursor, size_t size) { - void * r2 = gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_568; - void * r0 = gSaveBlock1Ptr->questLog[sCurrentSceneNum].end; - r0 -= a1; - if ((void *)a0 < r2 || (void *)a0 > r0) + void * start = gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_568; + void * end = gSaveBlock1Ptr->questLog[sCurrentSceneNum].end; + end -= size; + if ((void *)cursor < start || (void *)cursor > end) return FALSE; return TRUE; } @@ -373,10 +372,10 @@ static void SetQuestLogState(u8 state) static void sub_8110A00(void) { - if (sub_8110E68(gUnknown_203AE98) != 1) + if (TryRecordQuestLogEntrySequence(sQuestLogSceneRecordBuffer) != 1) { gUnknown_3005E88 = 0; - sub_8110E3C(); + TryRecordEvent39_GoToNextScene(); gQuestLogState = 0; sQuestLogCB = NULL; } @@ -389,7 +388,7 @@ static void sub_8110A3C(void) if (gUnknown_203AE94.unk_0_6 == 0) { - if (gUnknown_3005E88 || gUnknown_203AE94.unk_0_0 == 1 || (gUnknown_203AE94.unk_1 < 32 && gUnknown_203AE0C[gUnknown_203AE94.unk_1])) + if (gUnknown_3005E88 || gUnknown_203AE94.unk_0_0 == 1 || (gUnknown_203AE94.unk_1 < NELEMS(gUnknown_203AE0C) && gUnknown_203AE0C[gUnknown_203AE94.unk_1] != NULL)) sub_8111AD8(); else { @@ -410,31 +409,31 @@ u8 sub_8110AC8(void) return gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_000; } -void sub_8110AEC(u16 eventId) +static void StartRecordingQuestLogEntry(u16 eventId) { if (sCurrentSceneNum >= QUEST_LOG_SCENE_COUNT) sCurrentSceneNum = 0; - sub_81108F0(sCurrentSceneNum); + DestroySav1QuestLogEntry(sCurrentSceneNum); sub_8113B88(); - gUnknown_203AE08 = gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_568; + sEventRecordingPointer = gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_568; if (IS_LINK_QL_EVENT(eventId) || eventId == QL_EVENT_DEPARTED) gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_000 = 2; else gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_000 = 1; QuestLog_GetSaneMonCounts(); - sub_8110BB0(sCurrentSceneNum); - sub_8110BE8(sCurrentSceneNum); - sub_8110D94(); - sub_8110E20(); - sub_8110D48(sCurrentSceneNum); + SetPlayerInitialCoordsAtScene(sCurrentSceneNum); + SetNPCInitialCoordsAtScene(sCurrentSceneNum); + BackUpTrainerRematchesToVars(); + BackUpMapLayoutToVar(); + SetGameStateAtScene(sCurrentSceneNum); gUnknown_203ADFC = 0; - sub_8112940(2, gUnknown_203AE98, 0x100); - sub_8110E68(gUnknown_203AE98); - SetQuestLogState(1); + SetUpQuestLogEntry(2, sQuestLogSceneRecordBuffer, 0x100); + TryRecordQuestLogEntrySequence(sQuestLogSceneRecordBuffer); + SetQuestLogState(QL_STATE_1); } -static void sub_8110BB0(u8 sceneNum) +static void SetPlayerInitialCoordsAtScene(u8 sceneNum) { struct QuestLog * questLog = &gSaveBlock1Ptr->questLog[sceneNum]; questLog->mapGroup = gSaveBlock1Ptr->location.mapGroup; @@ -444,7 +443,7 @@ static void sub_8110BB0(u8 sceneNum) questLog->y = gSaveBlock1Ptr->pos.y; } -static void sub_8110BE8(u8 sceneNum) +static void SetNPCInitialCoordsAtScene(u8 sceneNum) { struct QuestLog * questLog = &gSaveBlock1Ptr->questLog[sceneNum]; u16 i; @@ -478,7 +477,7 @@ static void sub_8110BE8(u8 sceneNum) } } -static void sub_8110D48(u8 sceneNum) +static void SetGameStateAtScene(u8 sceneNum) { struct QuestLog * questLog = &gSaveBlock1Ptr->questLog[sceneNum]; @@ -486,7 +485,7 @@ static void sub_8110D48(u8 sceneNum) CpuCopy16(gSaveBlock1Ptr->vars, questLog->vars, VARS_COUNT * sizeof(u16)); } -static void sub_8110D94(void) +static void BackUpTrainerRematchesToVars(void) { u16 i, j; u16 sp0[4]; @@ -501,41 +500,41 @@ static void sub_8110D94(void) sp0[i] += (1 << j); } } - VarSet(VAR_0x40AA + i, sp0[i]); + VarSet(VAR_QLBAK_TRAINER_REMATCHES + i, sp0[i]); } } -static void sub_8110E20(void) +static void BackUpMapLayoutToVar(void) { - VarSet(VAR_0x40AE, gSaveBlock1Ptr->mapLayoutId); + VarSet(VAR_QLBAK_MAP_LAYOUT, gSaveBlock1Ptr->mapLayoutId); } -static void sub_8110E3C(void) +static void TryRecordEvent39_GoToNextScene(void) { - sub_8113BF4(gUnknown_203AE08); + TryRecordEvent39_NoParams(sEventRecordingPointer); if (++sCurrentSceneNum >= QUEST_LOG_SCENE_COUNT) sCurrentSceneNum = 0; } -static bool8 sub_8110E68(struct UnkStruct_203AE98 * a0) +static bool8 TryRecordQuestLogEntrySequence(struct QuestLogEntry * entry) { u16 i; - for (i = gUnknown_203ADFC; i < sQuestLogIdx; i++) + for (i = gUnknown_203ADFC; i < sQuestLogCursor; i++) { - if (gUnknown_203AE08 == NULL) + if (sEventRecordingPointer == NULL) return FALSE; - switch (a0[i].unk_6) + switch (entry[i].unk_6) { case 0: case 1: - gUnknown_203AE08 = sub_8113D48(gUnknown_203AE08, &a0[i]); + sEventRecordingPointer = sub_8113D48(sEventRecordingPointer, &entry[i]); break; default: - gUnknown_203AE08 = sub_8113CC8(gUnknown_203AE08, &a0[i]); + sEventRecordingPointer = sub_8113CC8(sEventRecordingPointer, &entry[i]); break; } - if (gUnknown_203AE08 == NULL) + if (sEventRecordingPointer == NULL) { gUnknown_3005E88 = 0; return FALSE; @@ -544,10 +543,10 @@ static bool8 sub_8110E68(struct UnkStruct_203AE98 * a0) if (gUnknown_3005E88 == 0) { - gUnknown_203AE08 = sub_8113BF4(gUnknown_203AE08); + sEventRecordingPointer = TryRecordEvent39_NoParams(sEventRecordingPointer); return FALSE; } - gUnknown_203ADFC = sQuestLogIdx; + gUnknown_203ADFC = sQuestLogCursor; return TRUE; } @@ -589,17 +588,17 @@ static void sub_8110F90(u8 unused) void sub_8110FCC(void) { - sub_811175C(sCurrentSceneNum, gUnknown_203AE98); + sub_811175C(sCurrentSceneNum, sQuestLogSceneRecordBuffer); sub_8113B88(); - sub_8112940(1, gUnknown_203AE98, 0x100); - sub_8111150(sCurrentSceneNum); + SetUpQuestLogEntry(1, sQuestLogSceneRecordBuffer, 0x100); + QuestLogPlaybackSetObjectEventTemplates(sCurrentSceneNum); } bool8 sub_8111000(void) { LoadPalette(stdpal_get(4), 0xF0, 0x20); - SetQuestLogState(2); - sub_807DF64(); + SetQuestLogState(QL_STATE_2); + FieldCB_DefaultWarpExit(); gUnknown_203AE94 = (struct UnkStruct_203AE94){}; gUnknown_203AE94.unk_0_0 = 2; return 1; @@ -608,8 +607,8 @@ bool8 sub_8111000(void) bool8 sub_8111038(void) { LoadPalette(stdpal_get(4), 0xF0, 0x20); - SetQuestLogState(2); - sub_807DF7C(); + SetQuestLogState(QL_STATE_2); + FieldCB_WarpExitFadeFromBlack(); gUnknown_203AE94 = (struct UnkStruct_203AE94){}; gUnknown_203AE94.unk_0_0 = 2; return 1; @@ -619,10 +618,10 @@ void DrawPreviouslyOnQuestHeader(u8 sceneNum) { u8 i; - for (i = 0; i < 3; i++) + for (i = 0; i < NELEMS(sQuestLogHeaderWindowTemplates); i++) { - gUnknown_203ADFE[i] = AddWindow(&gUnknown_845661C[i]); - FillWindowPixelRect(gUnknown_203ADFE[i], 15, 0, 0, gUnknown_845661C[i].width * 8, gUnknown_845661C[i].height * 8); + sQuestLogHeaderWindowIds[i] = AddWindow(&sQuestLogHeaderWindowTemplates[i]); + FillWindowPixelRect(sQuestLogHeaderWindowIds[i], 15, 0, 0, sQuestLogHeaderWindowTemplates[i].width * 8, sQuestLogHeaderWindowTemplates[i].height * 8); } StringExpandPlaceholders(gStringVar4, gText_QuestLog_PreviouslyOnYourQuest); @@ -634,21 +633,21 @@ void DrawPreviouslyOnQuestHeader(u8 sceneNum) StringAppend(gStringVar4, gStringVar1); } - AddTextPrinterParameterized4(gUnknown_203ADFE[0], 2, 2, 2, 1, 2, sTextColors, 0, gStringVar4); - PutWindowTilemap(gUnknown_203ADFE[0]); - PutWindowTilemap(gUnknown_203ADFE[1]); - CopyWindowToVram(gUnknown_203ADFE[0], 2); - CopyWindowToVram(gUnknown_203ADFE[2], 2); - CopyWindowToVram(gUnknown_203ADFE[1], 3); + AddTextPrinterParameterized4(sQuestLogHeaderWindowIds[0], 2, 2, 2, 1, 2, sTextColors, 0, gStringVar4); + PutWindowTilemap(sQuestLogHeaderWindowIds[0]); + PutWindowTilemap(sQuestLogHeaderWindowIds[1]); + CopyWindowToVram(sQuestLogHeaderWindowIds[0], 2); + CopyWindowToVram(sQuestLogHeaderWindowIds[2], 2); + CopyWindowToVram(sQuestLogHeaderWindowIds[1], 3); } -void sub_8111134(void) +void CommitQuestLogWindow1(void) { - PutWindowTilemap(gUnknown_203ADFE[1]); - CopyWindowToVram(gUnknown_203ADFE[1], 1); + PutWindowTilemap(sQuestLogHeaderWindowIds[1]); + CopyWindowToVram(sQuestLogHeaderWindowIds[1], 1); } -static void sub_8111150(u8 sceneNum) +static void QuestLogPlaybackSetObjectEventTemplates(u8 sceneNum) { struct QuestLog *questLog = &gSaveBlock1Ptr->questLog[sceneNum]; u16 i; @@ -667,7 +666,7 @@ static void sub_8111150(u8 sceneNum) gSaveBlock1Ptr->objectEventTemplates[i].movementType = questLog->npcData[i].movementType; } - sub_815A1F8(questLog, gSaveBlock1Ptr->objectEventTemplates); + SetSav1ObjectEventsFromQuestLog(questLog, gSaveBlock1Ptr->objectEventTemplates); } void sub_8111274(u8 sceneNum, bool8 a1) @@ -695,7 +694,7 @@ void sub_8111274(u8 sceneNum, bool8 a1) static void sub_8111368(void) { - gQuestLogState = 2; + gQuestLogState = QL_STATE_2; ResetSpecialVars(); ClearBag(); ClearPCItemSlots(); @@ -847,7 +846,7 @@ static void sub_8111688(void) for (i = 0; i < 4; i++) { - sp0[i] = VarGet(VAR_0x40AA + i); + sp0[i] = VarGet(VAR_QLBAK_TRAINER_REMATCHES + i); for (j = 0; j < 16; j++) { @@ -864,7 +863,7 @@ void sub_8111708(void) { struct MapHeader sp0; - gSaveBlock1Ptr->mapLayoutId = VarGet(VAR_0x40AE); + gSaveBlock1Ptr->mapLayoutId = VarGet(VAR_QLBAK_MAP_LAYOUT); if (gSaveBlock1Ptr->mapLayoutId == 0) { sp0 = *Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); @@ -872,14 +871,14 @@ void sub_8111708(void) } } -static void sub_811175C(u8 sceneNum, struct UnkStruct_203AE98 * a1) +static void sub_811175C(u8 sceneNum, struct QuestLogEntry * a1) { u16 i; u16 *r4; u16 r6 = 0; u16 r9 = 0; - memset(a1, 0, 32 * sizeof(struct UnkStruct_203AE98)); + memset(a1, 0, 32 * sizeof(struct QuestLogEntry)); for (i = 0; i < NELEMS(gUnknown_203AE0C); i++) { gUnknown_203AE0C[i] = NULL; @@ -951,7 +950,7 @@ static void QuestLog_StartFinalScene(void) SetMainCallback2(sub_8057430); gFieldCallback2 = sub_8111F60; FreeAllWindowBuffers(); - gQuestLogState = 3; + gQuestLogState = QL_STATE_3; sQuestLogCB = NULL; } @@ -967,7 +966,7 @@ bool8 QuestLog_SchedulePlaybackCB(void (*callback)(void)) switch (gQuestLogState) { case 1: - sub_8112364(); + QuestLog_OnInteractionWithSpecialNpc(); break; case 2: gUnknown_3005E88 = 3; @@ -1077,7 +1076,7 @@ static u8 sub_8111BD4(void) bool8 sub_8111C2C(void) { - if (gQuestLogState != 2) + if (gQuestLogState != QL_STATE_2) return FALSE; if (gUnknown_3005E88 == 0 || gUnknown_203AE94.unk_0_0 == 1 || gUnknown_203AE94.unk_0_0 == 2) return TRUE; @@ -1088,13 +1087,13 @@ void sub_8111C68(void) { if (gUnknown_203AE94.unk_0_6 == 0) { - if (gMain.newKeys & A_BUTTON) + if (JOY_NEW(A_BUTTON)) { gUnknown_203AE94.unk_0_6 = 2; gUnknown_3005E88 = 0; sub_81118F4(-3); } - else if (gMain.newKeys & B_BUTTON) + else if (JOY_NEW(B_BUTTON)) { gUnknown_203AE94.unk_0_6 = 1; gUnknown_3005E88 = 0; @@ -1112,7 +1111,7 @@ bool8 sub_8111CD0(void) void sub_8111CF0(void) { - if (gQuestLogState == 2) + if (gQuestLogState == QL_STATE_2) DrawPreviouslyOnQuestHeader(sNumScenes); } @@ -1127,9 +1126,9 @@ static void DrawQuestLogSceneDescription(void) numLines++; } - PutWindowTilemap(gUnknown_203ADFE[2]); - sub_8111D90(gUnknown_203ADFE[2]); - AddTextPrinterParameterized4(gUnknown_203ADFE[2], 2, 2, sQuestLogTextLineYCoords[numLines], 1, 0, sTextColors, 0, gStringVar4); + PutWindowTilemap(sQuestLogHeaderWindowIds[2]); + sub_8111D90(sQuestLogHeaderWindowIds[2]); + AddTextPrinterParameterized4(sQuestLogHeaderWindowIds[2], 2, 2, sQuestLogTextLineYCoords[numLines], 1, 0, sTextColors, 0, gStringVar4); ScheduleBgCopyTilemapToVram(0); } @@ -1172,11 +1171,11 @@ static void sub_8111D90(u8 a0) static void QuestLog_CloseTextWindow(void) { - ClearWindowTilemap(gUnknown_203ADFE[2]); - FillWindowPixelRect(gUnknown_203ADFE[2], 15, 0, 0, 0xf0, 0x30); - CopyWindowToVram(gUnknown_203ADFE[2], 2); - PutWindowTilemap(gUnknown_203ADFE[1]); - CopyWindowToVram(gUnknown_203ADFE[1], 1); + ClearWindowTilemap(sQuestLogHeaderWindowIds[2]); + FillWindowPixelRect(sQuestLogHeaderWindowIds[2], 15, 0, 0, 0xf0, 0x30); + CopyWindowToVram(sQuestLogHeaderWindowIds[2], 2); + PutWindowTilemap(sQuestLogHeaderWindowIds[1]); + CopyWindowToVram(sQuestLogHeaderWindowIds[1], 1); } static void QuestLog_SkipToEndOfPlayback(s8 delay) @@ -1194,7 +1193,7 @@ static void QuestLog_WaitFadeAndCancelPlayback(void) { if (gSaveBlock1Ptr->questLog[sCurrentSceneNum].unk_000 == 0) break; - sub_811175C(sCurrentSceneNum, gUnknown_203AE98); + sub_811175C(sCurrentSceneNum, sQuestLogSceneRecordBuffer); } gUnknown_3005E88 = 0; QuestLog_StartFinalScene(); @@ -1203,7 +1202,7 @@ static void QuestLog_WaitFadeAndCancelPlayback(void) void sub_8111F14(void) { - if (gQuestLogState == 3) + if (gQuestLogState == QL_STATE_3) gUnknown_203AE90 = AllocZeroed(0x200 * sizeof(u16)); } @@ -1216,7 +1215,7 @@ static bool8 sub_8111F60(void) { LoadPalette(stdpal_get(4), 0xF0, 0x20); DrawPreviouslyOnQuestHeader(0); - sub_807DF7C(); + FieldCB_WarpExitFadeFromBlack(); CreateTask(sub_8111F8C, 0xFF); return TRUE; } @@ -1229,7 +1228,7 @@ static void sub_8111F8C(u8 taskId) { FreezeObjectEvents(); sub_805C270(); - sub_805C780(); + StopPlayerAvatar(); ScriptContext2_Enable(); task->func = Task_QuestLogScene_SavedGame; } @@ -1261,7 +1260,7 @@ static void Task_WaitAtEndOfQuestLog(u8 taskId) { struct Task *task = &gTasks[taskId]; - if (gMain.newKeys & (A_BUTTON | B_BUTTON) || task->tTimer >= 127 || gUnknown_203AE94.unk_0_6 == 1) + if (JOY_NEW(A_BUTTON | B_BUTTON) || task->tTimer >= 127 || gUnknown_203AE94.unk_0_6 == 1) { QuestLog_CloseTextWindow(); task->tTimer = 0; @@ -1288,7 +1287,7 @@ static void Task_EndQuestLog(u8 taskId) gDisableMapMusicChangeOnMapLoad = 0; Overworld_PlaySpecialMapMusic(); sub_811229C(); - FillWindowPixelRect(gUnknown_203ADFE[0], 0xF, 0, 0, gUnknown_845661C[0].width * 8, gUnknown_845661C[0].height * 8); + FillWindowPixelRect(sQuestLogHeaderWindowIds[0], 0xF, 0, 0, sQuestLogHeaderWindowTemplates[0].width * 8, sQuestLogHeaderWindowTemplates[0].height * 8); tState++; break; case 1: @@ -1296,9 +1295,9 @@ static void Task_EndQuestLog(u8 taskId) { for (i = 0; i < 3; i++) { - ClearWindowTilemap(gUnknown_203ADFE[i]); - CopyWindowToVram(gUnknown_203ADFE[i], 1); - RemoveWindow(gUnknown_203ADFE[i]); + ClearWindowTilemap(sQuestLogHeaderWindowIds[i]); + CopyWindowToVram(sQuestLogHeaderWindowIds[i], 1); + RemoveWindow(sQuestLogHeaderWindowIds[i]); } tTimer = 0; tState++; @@ -1312,7 +1311,7 @@ static void Task_EndQuestLog(u8 taskId) break; default: if (gUnknown_203AE94.unk_0_6 == 1) - CreateMapNamePopupIfNotAlreadyRunning(1); + ShowMapNamePopup(TRUE); CpuCopy16(gUnknown_203AE90, gPlttBufferUnfaded, 0x400); Free(gUnknown_203AE90); gUnknown_203AE94 = (struct UnkStruct_203AE94){}; @@ -1339,10 +1338,10 @@ static bool8 sub_81121D8(u8 taskId) sub_80716F8(gPlttBufferUnfaded + 0x01, gPlttBufferFaded + 0x01, 0xDF, 0x0F - data[1]); sub_80716F8(gPlttBufferUnfaded + 0x100, gPlttBufferFaded + 0x100, 0x100, 0x0F - data[1]); - FillWindowPixelRect(gUnknown_203ADFE[0], 0x00, 0, gUnknown_845661C[0].height * 8 - 1 - data[1], gUnknown_845661C[0].width * 8, 1); - FillWindowPixelRect(gUnknown_203ADFE[1], 0x00, 0, data[1], gUnknown_845661C[1].width * 8, 1); - CopyWindowToVram(gUnknown_203ADFE[0], 2); - CopyWindowToVram(gUnknown_203ADFE[1], 2); + FillWindowPixelRect(sQuestLogHeaderWindowIds[0], 0x00, 0, sQuestLogHeaderWindowTemplates[0].height * 8 - 1 - data[1], sQuestLogHeaderWindowTemplates[0].width * 8, 1); + FillWindowPixelRect(sQuestLogHeaderWindowIds[1], 0x00, 0, data[1], sQuestLogHeaderWindowTemplates[1].width * 8, 1); + CopyWindowToVram(sQuestLogHeaderWindowIds[0], 2); + CopyWindowToVram(sQuestLogHeaderWindowIds[1], 2); data[1]++; return FALSE; } @@ -1362,34 +1361,34 @@ static void sub_811229C(void) void sub_811231C(void) { - if (gQuestLogState == 1) + if (gQuestLogState == QL_STATE_1) { - sub_8110E68(gUnknown_203AE98); - sub_8110E3C(); + TryRecordQuestLogEntrySequence(sQuestLogSceneRecordBuffer); + TryRecordEvent39_GoToNextScene(); gQuestLogState = 0; sQuestLogCB = NULL; gUnknown_203AE04 = NULL; - gUnknown_203AE08 = NULL; + sEventRecordingPointer = NULL; gUnknown_3005E88 = 0; } } -void sub_8112364(void) +void QuestLog_OnInteractionWithSpecialNpc(void) { - if (gUnknown_3005E88 && gQuestLogState == 1) + if (gUnknown_3005E88 && gQuestLogState == QL_STATE_1) { - sub_8110E68(gUnknown_203AE98); - sub_8113A1C(1); - sub_8110E3C(); + TryRecordQuestLogEntrySequence(sQuestLogSceneRecordBuffer); + TryRecordEvent41_IncCursor(1); + TryRecordEvent39_GoToNextScene(); gUnknown_3005E88 = 0; gQuestLogState = 0; sQuestLogCB = NULL; } gUnknown_203AE04 = NULL; - gUnknown_203AE08 = NULL; + sEventRecordingPointer = NULL; } -void sub_81123BC(void) +static void SortQuestLogInSav1(void) { struct QuestLog * buffer = AllocZeroed(QUEST_LOG_SCENE_COUNT * sizeof(struct QuestLog)); u8 i; @@ -1411,12 +1410,12 @@ void sub_81123BC(void) Free(buffer); } -void sub_8112450(void) +void SaveQuestLogData(void) { if (MenuHelpers_LinkSomething() != TRUE) { - sub_8112364(); - sub_81123BC(); + QuestLog_OnInteractionWithSpecialNpc(); + SortQuestLogInSav1(); } } @@ -1448,109 +1447,109 @@ void sub_811246C(struct Sprite *sprite) } } -void sub_81124EC(u8 a0, u8 a1, u8 a2, u8 a3) +void sub_81124EC(u8 a0, u8 a1, u8 a2, u8 movementActionId) { if (!sub_8112CEC()) { - gUnknown_3005E94[sQuestLogIdx].unk_4 = gUnknown_203B01A; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_0 = a0; - gUnknown_3005E94[sQuestLogIdx].unk_1 = a1; - gUnknown_3005E94[sQuestLogIdx].unk_2 = a2; - gUnknown_3005E94[sQuestLogIdx].unk_3 = a3; - sQuestLogIdx++; - gUnknown_203B01A = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = sNextStepDelay; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = a0; + sCurQuestLogEntry[sQuestLogCursor].unk_1 = a1; + sCurQuestLogEntry[sQuestLogCursor].unk_2 = a2; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = movementActionId; + sQuestLogCursor++; + sNextStepDelay = 0; } } -void sub_8112588(u8 a0, u8 a1, u8 a2, u8 a3, u8 a4) +void sub_8112588(u8 localId, u8 mapNum, u8 mapGroup, u8 movementActionId, u8 duration) { - if (!sub_8112D1C()) + if (!RecordHeadAtEndOfEntry()) { - gUnknown_3005E94[sQuestLogIdx].unk_4 = gUnknown_203B01A; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_0 = a0; - gUnknown_3005E94[sQuestLogIdx].unk_1 = a1; - gUnknown_3005E94[sQuestLogIdx].unk_2 = a2; - gUnknown_3005E94[sQuestLogIdx].unk_3 = a3; - sQuestLogIdx++; - gUnknown_203B01A = a4; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = sNextStepDelay; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = localId; + sCurQuestLogEntry[sQuestLogCursor].unk_1 = mapNum; + sCurQuestLogEntry[sQuestLogCursor].unk_2 = mapGroup; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = movementActionId; + sQuestLogCursor++; + sNextStepDelay = duration; } } -void sub_8112628(u8 a0) +void sub_8112628(u8 movementActionId) { if (!sub_8112CEC()) { - if (a0 != gUnknown_3005E94[gUnknown_203B01C].unk_3 || a0 > 3) + if (movementActionId != sCurQuestLogEntry[gUnknown_203B01C].unk_3 || movementActionId > MOVEMENT_ACTION_FACE_RIGHT) { - gUnknown_3005E94[sQuestLogIdx].unk_4 = gUnknown_203B01A; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_0 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_3 = a0; - gUnknown_203B01C = sQuestLogIdx; - sQuestLogIdx++; - gUnknown_203B01A = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = sNextStepDelay; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = movementActionId; + gUnknown_203B01C = sQuestLogCursor; + sQuestLogCursor++; + sNextStepDelay = 0; } } } -void sub_81126AC(u8 a0, u8 a1) +void sub_81126AC(u8 movementActionId, u8 duration) { - if (!sub_8112D1C()) + if (!RecordHeadAtEndOfEntry()) { - gUnknown_3005E94[sQuestLogIdx].unk_4 = gUnknown_203B01A; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_0 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_3 = a0; - gUnknown_203B01C = sQuestLogIdx; - sQuestLogIdx++; - gUnknown_203B01A = a1; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = sNextStepDelay; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = movementActionId; + gUnknown_203B01C = sQuestLogCursor; + sQuestLogCursor++; + sNextStepDelay = duration; } } -void sub_8112720(u8 a0) +void sub_8112720(u8 movementActionId) { - if (!sub_8112D1C()) + if (!RecordHeadAtEndOfEntry()) { - gUnknown_3005E94[sQuestLogIdx].unk_4 = gUnknown_203B01A; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 1; - gUnknown_3005E94[sQuestLogIdx].unk_0 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_3 = a0; - sQuestLogIdx++; - gUnknown_203B01A = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = sNextStepDelay; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 1; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = movementActionId; + sQuestLogCursor++; + sNextStepDelay = 0; } } -void sub_811278C(u8 a0, u8 a1) +void sub_811278C(u8 movementActionId, u8 duration) { - if (!sub_8112D1C()) + if (!RecordHeadAtEndOfEntry()) { - gUnknown_3005E94[sQuestLogIdx].unk_4 = gUnknown_203B01A; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 1; - gUnknown_3005E94[sQuestLogIdx].unk_0 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_3 = a0; - sQuestLogIdx++; - gUnknown_203B01A = a1; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = sNextStepDelay; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 1; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = movementActionId; + sQuestLogCursor++; + sNextStepDelay = duration; } } -void sub_81127F8(struct UnkStruct_3005E90 * a0) +void sub_81127F8(struct FieldInput * a0) { - if (sQuestLogIdx < sNumQuestLogs) + if (sQuestLogCursor < sNumEventsInLogEntry) { u32 r2 = *(u32 *)a0 & 0x00FF00F3; - gUnknown_3005E94[sQuestLogIdx].unk_4 = gUnknown_203B01A; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 2; - gUnknown_3005E94[sQuestLogIdx].unk_0 = r2; - gUnknown_3005E94[sQuestLogIdx].unk_1 = r2 >> 8; - gUnknown_3005E94[sQuestLogIdx].unk_2 = r2 >> 16; - gUnknown_3005E94[sQuestLogIdx].unk_3 = r2 >> 24; - sQuestLogIdx++; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = sNextStepDelay; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 2; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = r2; + sCurQuestLogEntry[sQuestLogCursor].unk_1 = r2 >> 8; + sCurQuestLogEntry[sQuestLogCursor].unk_2 = r2 >> 16; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = r2 >> 24; + sQuestLogCursor++; if (ScriptContext2_IsEnabled()) - gUnknown_203B01A = TRUE; + sNextStepDelay = TRUE; else - gUnknown_203B01A = FALSE; + sNextStepDelay = FALSE; } } @@ -1580,10 +1579,10 @@ void sub_81128BC(u8 a0) gUnknown_3005E88 = 3; else if (r1 == 2) { - gUnknown_3005E94[sQuestLogIdx].unk_4 = gUnknown_203B01A; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 3; - sQuestLogIdx++; - gUnknown_203B01A = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = sNextStepDelay; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 3; + sQuestLogCursor++; + sNextStepDelay = 0; gUnknown_3005E88 = 4; } break; @@ -1596,68 +1595,68 @@ void sub_81128BC(u8 a0) } } -static void sub_8112940(u8 a0, struct UnkStruct_203AE98 *a1, u16 a2) +static void SetUpQuestLogEntry(u8 kind, struct QuestLogEntry *entry, u16 size) { - s32 i; + int i; - switch (a0) + switch (kind) { default: gUnknown_3005E88 = 0; break; case 1: - gUnknown_3005E94 = a1; - sNumQuestLogs = a2 / 8; - for (i = 0; i < 0x40; i++) + sCurQuestLogEntry = entry; + sNumEventsInLogEntry = size / sizeof(*sCurQuestLogEntry); + for (i = 0; i < (s32)NELEMS(sMovementScripts); i++) { sMovementScripts[i][0] |= 0xFF; sMovementScripts[i][1] |= 0xFF; } - sQuestLogIdx = 0; + sQuestLogCursor = 0; gUnknown_203B01C = 0; - gUnknown_3005E90 = (struct UnkStruct_3005E90){}; - gUnknown_203B01A = gUnknown_3005E94[sQuestLogIdx].unk_4; - sMovementScripts[0][0] = gUnknown_3005E94[sQuestLogIdx].unk_3; + gQuestLogFieldInput = (struct FieldInput){}; + sNextStepDelay = sCurQuestLogEntry[sQuestLogCursor].unk_4; + sMovementScripts[0][0] = sCurQuestLogEntry[sQuestLogCursor].unk_3; sMovementScripts[0][1] = 0xFF; gUnknown_3005E88 = 1; break; case 2: - gUnknown_3005E94 = a1; - sNumQuestLogs = a2 / 8; - for (i = 0; i < sNumQuestLogs; i++) + sCurQuestLogEntry = entry; + sNumEventsInLogEntry = size / sizeof(*sCurQuestLogEntry); + for (i = 0; i < sNumEventsInLogEntry; i++) { - gUnknown_3005E94[i] = (struct UnkStruct_203AE98){ 0, 0, 0, 0, 0xFFFF, 0xFF }; + sCurQuestLogEntry[i] = (struct QuestLogEntry){ 0, 0, 0, 0, 0xFFFF, 0xFF }; } - sQuestLogIdx = 0; - gUnknown_203B01A = 0; - gUnknown_3005E94[sQuestLogIdx].unk_4 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_0 = 0; + sQuestLogCursor = 0; + sNextStepDelay = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = 0; switch (GetPlayerFacingDirection()) { case DIR_NONE: case DIR_SOUTH: - gUnknown_3005E94[sQuestLogIdx].unk_3 = DIR_SOUTH - 1; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = MOVEMENT_ACTION_FACE_DOWN; break; case DIR_EAST: - gUnknown_3005E94[sQuestLogIdx].unk_3 = DIR_EAST - 1; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = MOVEMENT_ACTION_FACE_RIGHT; break; case DIR_NORTH: - gUnknown_3005E94[sQuestLogIdx].unk_3 = DIR_NORTH - 1; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = MOVEMENT_ACTION_FACE_UP; break; case DIR_WEST: - gUnknown_3005E94[sQuestLogIdx].unk_3 = DIR_WEST - 1; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = MOVEMENT_ACTION_FACE_LEFT; break; } gUnknown_203B01C = 0; - sQuestLogIdx++; - gUnknown_3005E94[sQuestLogIdx].unk_4 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_6 = 2; - gUnknown_3005E94[sQuestLogIdx].unk_0 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_1 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_2 = 0; - gUnknown_3005E94[sQuestLogIdx].unk_3 = 0; - sQuestLogIdx++; + sQuestLogCursor++; + sCurQuestLogEntry[sQuestLogCursor].unk_4 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_6 = 2; + sCurQuestLogEntry[sQuestLogCursor].unk_0 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_1 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_2 = 0; + sCurQuestLogEntry[sQuestLogCursor].unk_3 = 0; + sQuestLogCursor++; gUnknown_3005E88 = 2; break; } @@ -1672,22 +1671,23 @@ void sub_8112B3C(void) case 1: if (!sub_8112CEC()) { - if (gUnknown_203B01A != 0) - gUnknown_203B01A--; + if (sNextStepDelay != 0) + sNextStepDelay--; else { do { - switch (gUnknown_3005E94[sQuestLogIdx].unk_6) + switch (sCurQuestLogEntry[sQuestLogCursor].unk_6) { case 0: - sMovementScripts[gUnknown_3005E94[sQuestLogIdx].unk_0][0] = gUnknown_3005E94[sQuestLogIdx].unk_3; + sMovementScripts[sCurQuestLogEntry[sQuestLogCursor].unk_0][0] = sCurQuestLogEntry[sQuestLogCursor].unk_3; break; case 1: - sMovementScripts[gUnknown_3005E94[sQuestLogIdx].unk_0][1] = gUnknown_3005E94[sQuestLogIdx].unk_3; + sMovementScripts[sCurQuestLogEntry[sQuestLogCursor].unk_0][1] = sCurQuestLogEntry[sQuestLogCursor].unk_3; break; case 2: - *(u32 *)&gUnknown_3005E90 = ((gUnknown_3005E94[sQuestLogIdx].unk_3 << 24) | (gUnknown_3005E94[sQuestLogIdx].unk_2 << 16) | (gUnknown_3005E94[sQuestLogIdx].unk_1 << 8) | (gUnknown_3005E94[sQuestLogIdx].unk_0 << 0)); + // Player input command + *(u32 *)&gQuestLogFieldInput = ((sCurQuestLogEntry[sQuestLogCursor].unk_3 << 24) | (sCurQuestLogEntry[sQuestLogCursor].unk_2 << 16) | (sCurQuestLogEntry[sQuestLogCursor].unk_1 << 8) | (sCurQuestLogEntry[sQuestLogCursor].unk_0 << 0)); break; case 3: gUnknown_3005E88 = 3; @@ -1700,17 +1700,17 @@ void sub_8112B3C(void) } if (gUnknown_3005E88 == 0) break; - if (++sQuestLogIdx >= sNumQuestLogs) + if (++sQuestLogCursor >= sNumEventsInLogEntry) { gUnknown_3005E88 = 0; break; } - gUnknown_203B01A = gUnknown_3005E94[sQuestLogIdx].unk_4; + sNextStepDelay = sCurQuestLogEntry[sQuestLogCursor].unk_4; } while (gUnknown_3005E88 != 3 - && (gUnknown_203B01A == 0 || gUnknown_203B01A == 0xFFFF)); + && (sNextStepDelay == 0 || sNextStepDelay == 0xFFFF)); } } - else if (sQuestLogIdx >= sNumQuestLogs) + else if (sQuestLogCursor >= sNumEventsInLogEntry) { gUnknown_3005E88 = 0; } @@ -1718,8 +1718,8 @@ void sub_8112B3C(void) case 2: if (ScriptContext2_IsEnabled() != TRUE) { - gUnknown_203B01A++; - if (sQuestLogIdx >= sNumQuestLogs) + sNextStepDelay++; + if (sQuestLogCursor >= sNumEventsInLogEntry) gUnknown_3005E88 = 0; } break; @@ -1732,7 +1732,7 @@ void sub_8112B3C(void) void sub_8112C9C(void) { - gUnknown_203B01A++; + sNextStepDelay++; } u8 sub_8112CAC(void) @@ -1753,14 +1753,14 @@ u8 sub_8112CAC(void) static bool8 sub_8112CEC(void) { - if (sQuestLogIdx >= sNumQuestLogs || ScriptContext2_IsEnabled() == TRUE) + if (sQuestLogCursor >= sNumEventsInLogEntry || ScriptContext2_IsEnabled() == TRUE) return TRUE; return FALSE; } -static bool8 sub_8112D1C(void) +static bool8 RecordHeadAtEndOfEntry(void) { - if (sQuestLogIdx >= sNumQuestLogs) + if (sQuestLogCursor >= sNumEventsInLogEntry) return TRUE; return FALSE; } @@ -1774,9 +1774,9 @@ static const struct UnkStruct_300201C gUnknown_84566A4 = { void * QuestLogGetFlagOrVarPtr(bool8 isFlag, u16 idx) { void * response; - if (sQuestLogIdx == 0) + if (sQuestLogCursor == 0) return NULL; - if (sQuestLogIdx >= sNumQuestLogs) + if (sQuestLogCursor >= sNumEventsInLogEntry) return NULL; if (sFlagOrVarPlayhead >= sNumFlagsOrVars) return NULL; @@ -1792,9 +1792,9 @@ void * QuestLogGetFlagOrVarPtr(bool8 isFlag, u16 idx) void QuestLogSetFlagOrVar(bool8 isFlag, u16 idx, u16 value) { - if (sQuestLogIdx == 0) + if (sQuestLogCursor == 0) return; - if (sQuestLogIdx >= sNumQuestLogs) + if (sQuestLogCursor >= sNumEventsInLogEntry) return; if (sFlagOrVarPlayhead >= sNumFlagsOrVars) return; @@ -1817,7 +1817,7 @@ void sub_8112E3C(u8 a0, struct UnkStruct_300201C * a1, u16 a2) sFlagOrVarPlayhead = 0; if (a0 == 2) { - for (i = 0; i < sNumQuestLogs; i++) + for (i = 0; i < sNumEventsInLogEntry; i++) { sFlagOrVarRecords[i] = gUnknown_84566A4; } @@ -2395,7 +2395,7 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData) return; } sub_811381C(); - if (gQuestLogState == 2) + if (gQuestLogState == QL_STATE_2) return; if (!IS_VALID_QL_EVENT(eventId)) @@ -2431,7 +2431,7 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData) { if (sub_81153A8(eventId, eventData) == FALSE) return; - sub_8110AEC(eventId); + StartRecordingQuestLogEntry(eventId); } } else if (eventId == QL_EVENT_OBTAINED_ITEM) @@ -2442,7 +2442,7 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData) { if (gUnknown_203AE04 == NULL) { - gUnknown_203AE04 = gUnknown_203AE08; + gUnknown_203AE04 = sEventRecordingPointer; r1 = sQuestLogStorageCBs[eventId](gUnknown_203AE04, eventData); } else @@ -2454,7 +2454,7 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData) else { gUnknown_203AE04 = NULL; - r1 = sQuestLogStorageCBs[eventId](gUnknown_203AE08, eventData); + r1 = sQuestLogStorageCBs[eventId](sEventRecordingPointer, eventData); } if (r1 == NULL) @@ -2465,7 +2465,7 @@ void SetQuestLogEvent(u16 eventId, const u16 *eventData) return; } - gUnknown_203AE08 = r1; + sEventRecordingPointer = r1; if (gUnknown_203B048 == 0) return; sub_811231C(); @@ -2513,11 +2513,11 @@ bool8 sub_8113748(void) if (InQuestLogDisabledLocation() != TRUE) return FALSE; - if (gQuestLogState == 2) + if (gQuestLogState == QL_STATE_2) return TRUE; - if (gQuestLogState == 1) - sub_8112364(); + if (gQuestLogState == QL_STATE_1) + QuestLog_OnInteractionWithSpecialNpc(); return FALSE; } @@ -2579,15 +2579,15 @@ static u16 *sub_8113828(u16 eventId, const u16 *eventData) if (sub_81153A8(eventId, eventData) == FALSE) return NULL; - sub_8110AEC(eventId); + StartRecordingQuestLogEntry(eventId); sub_8113B94(eventId); if (eventId == QL_EVENT_DEFEATED_WILD_MON) - gUnknown_203AE04 = gUnknown_203AE08; + gUnknown_203AE04 = sEventRecordingPointer; else gUnknown_203AE04 = NULL; - return sQuestLogStorageCBs[eventId](gUnknown_203AE08, eventData); + return sQuestLogStorageCBs[eventId](sEventRecordingPointer, eventData); } static bool8 TrySetLinkQuestLogEvent(u16 eventId, const u16 *eventData) @@ -2613,15 +2613,15 @@ void sub_81138F8(void) gUnknown_203B024 = (struct UnkStruct_203B024){}; } -void sub_811390C(void) +void QuestLog_StartRecordingInputsAfterDeferredEvent(void) { if (gUnknown_203B024.unk_00 != QL_EVENT_0) { u16 *resp; gUnknown_203B04A = 0; - sub_8110AEC(gUnknown_203B024.unk_00); - resp = sQuestLogStorageCBs[gUnknown_203B024.unk_00](gUnknown_203AE08, gUnknown_203B024.unk_04); - gUnknown_203AE08 = resp; + StartRecordingQuestLogEntry(gUnknown_203B024.unk_00); + resp = sQuestLogStorageCBs[gUnknown_203B024.unk_00](sEventRecordingPointer, gUnknown_203B024.unk_04); + sEventRecordingPointer = resp; sub_81138F8(); } } @@ -2651,21 +2651,21 @@ void sub_81139BC(void) if (gUnknown_3005E88 == 0) { gUnknown_203B04A = 0; - sub_8110AEC(gUnknown_203B024.unk_00); + StartRecordingQuestLogEntry(gUnknown_203B024.unk_00); } sub_8113B94(gUnknown_203B024.unk_00); - resp = sQuestLogStorageCBs[gUnknown_203B024.unk_00](gUnknown_203AE08, gUnknown_203B024.unk_04); - gUnknown_203AE08 = resp; - sub_8113A1C(1); + resp = sQuestLogStorageCBs[gUnknown_203B024.unk_00](sEventRecordingPointer, gUnknown_203B024.unk_04); + sEventRecordingPointer = resp; + TryRecordEvent41_IncCursor(1); sub_81138F8(); sub_811231C(); } } -static void sub_8113A1C(u16 a0) +static void TryRecordEvent41_IncCursor(u16 a0) { - gUnknown_203AE08 = sub_8113C5C(gUnknown_203AE08, a0); - sQuestLogIdx++; + sEventRecordingPointer = TryRecordEvent41(sEventRecordingPointer, a0); + sQuestLogCursor++; } static bool8 IsQuestLogEventWithSpecialEncounterSpecies(u16 eventId, const u16 *eventData) @@ -2806,7 +2806,7 @@ static bool8 sub_8113AE8(const u16 *a0) const u16 *r0 = a0; #endif - if (r0 == NULL || r0[1] > sQuestLogIdx) + if (r0 == NULL || r0[1] > sQuestLogCursor) return FALSE; sQuestLogEventTextBufferCBs[a0[0] & 0xFFF](a0); @@ -2836,11 +2836,11 @@ static void sub_8113B88(void) static void sub_8113B94(u16 eventId) { - if (gUnknown_203B044.unk_0 != (u8)eventId || gUnknown_203B044.unk_2 != sQuestLogIdx) + if (gUnknown_203B044.unk_0 != (u8)eventId || gUnknown_203B044.unk_2 != sQuestLogCursor) { gUnknown_203B044.unk_0 = eventId; gUnknown_203B044.unk_1 = 0; - gUnknown_203B044.unk_2 = sQuestLogIdx; + gUnknown_203B044.unk_2 = sQuestLogCursor; } else if (gUnknown_203B044.unk_1 < 5) gUnknown_203B044.unk_1++; @@ -2848,22 +2848,22 @@ static void sub_8113B94(u16 eventId) static void sub_8113BD8(void) { - gUnknown_203B049 = 0; + sNewlyEnteredMap = FALSE; gUnknown_203B04A = 0; gUnknown_203B04B = FALSE; } -static u16 *sub_8113BF4(u16 *a0) +static u16 *TryRecordEvent39_NoParams(u16 *a0) { - if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_39])) + if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_39])) return NULL; a0[0] = QL_EVENT_39; return a0 + 1; } -static u16 *sub_8113C20(u16 *a0, struct UnkStruct_203AE98 * a1) +static u16 *sub_8113C20(u16 *a0, struct QuestLogEntry * a1) { - if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_39])) + if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_39])) return NULL; a1->unk_6 = 0xFF; a1->unk_4 = 0; @@ -2874,18 +2874,18 @@ static u16 *sub_8113C20(u16 *a0, struct UnkStruct_203AE98 * a1) return a0 + 1; } -static u16 *sub_8113C5C(u16 *a0, u16 a1) +static u16 *TryRecordEvent41(u16 *a0, u16 a1) { - if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_41])) + if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_41])) return NULL; a0[0] = QL_EVENT_41; a0[1] = a1; return a0 + 2; } -static u16 *sub_8113C8C(u16 *a0, struct UnkStruct_203AE98 * a1) +static u16 *sub_8113C8C(u16 *a0, struct QuestLogEntry * a1) { - if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_41])) + if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_41])) return NULL; a1->unk_6 = 0xFE; a1->unk_4 = a0[1]; @@ -2896,11 +2896,11 @@ static u16 *sub_8113C8C(u16 *a0, struct UnkStruct_203AE98 * a1) return a0 + 2; } -static u16 *sub_8113CC8(u16 *a0, struct UnkStruct_203AE98 * a1) +static u16 *sub_8113CC8(u16 *a0, struct QuestLogEntry * a1) { u8 *r6 = (u8 *)a0 + 4; - if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_0])) + if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_0])) return NULL; a0[0] = 0; a0[1] = a1->unk_4; @@ -2911,11 +2911,11 @@ static u16 *sub_8113CC8(u16 *a0, struct UnkStruct_203AE98 * a1) return (u16 *)(r6 + 4); } -static u16 *sub_8113D08(u16 *a0, struct UnkStruct_203AE98 * a1) +static u16 *sub_8113D08(u16 *a0, struct QuestLogEntry * a1) { u8 *r6 = (u8 *)a0 + 4; - if (!sub_8110988(a0, sQuestLogEventCmdSizes[QL_EVENT_0])) + if (!WillCommandOfSizeFitInSav1Record(a0, sQuestLogEventCmdSizes[QL_EVENT_0])) return NULL; a1->unk_6 = 2; a1->unk_4 = a0[1]; @@ -2926,12 +2926,12 @@ static u16 *sub_8113D08(u16 *a0, struct UnkStruct_203AE98 * a1) return (u16 *)(r6 + 4); } -static u16 *sub_8113D48(u16 *a0, struct UnkStruct_203AE98 * a1) +static u16 *sub_8113D48(u16 *a0, struct QuestLogEntry * a1) { u16 *r4 = a0; u8 *r6 = (u8 *)a0 + 4; - if (!sub_8110988(r4, sQuestLogEventCmdSizes[QL_EVENT_2])) + if (!WillCommandOfSizeFitInSav1Record(r4, sQuestLogEventCmdSizes[QL_EVENT_2])) return NULL; if (a1->unk_6 == 0) r4[0] = 2; @@ -2945,12 +2945,12 @@ static u16 *sub_8113D48(u16 *a0, struct UnkStruct_203AE98 * a1) return (u16 *)(r6 + 4); } -static u16 *sub_8113D94(u16 *a0, struct UnkStruct_203AE98 * a1) +static u16 *sub_8113D94(u16 *a0, struct QuestLogEntry * a1) { u16 *r5 = a0; u8 *r6 = (u8 *)a0 + 4; - if (!sub_8110988(r5, sQuestLogEventCmdSizes[QL_EVENT_2])) + if (!WillCommandOfSizeFitInSav1Record(r5, sQuestLogEventCmdSizes[QL_EVENT_2])) return NULL; if (r5[0] == 2) a1->unk_6 = 0; @@ -2999,7 +2999,7 @@ u16 *sub_8113DE0(u16 eventId, u16 *a1) r1 = gUnknown_203B044.unk_1; r5[0] = eventId + (r1 << 12); - r5[1] = sQuestLogIdx; + r5[1] = sQuestLogCursor; r5 = (void *)r5 + (r1 * cmdSize + 4); return r5; } @@ -3244,7 +3244,7 @@ static u16 *BufferQuestLogData_UsedPkmnCenter(u16 *a0, const u16 *eventData) return NULL; r4[0] = QL_EVENT_USED_PKMN_CENTER; - r4[1] = sQuestLogIdx; + r4[1] = sQuestLogCursor; return r4 + 2; } @@ -3260,7 +3260,7 @@ static u16 *BufferQuestLogData_LinkTraded(u16 *a0, const u16 *eventData) u16 *r4 = a0 + 4; a0[0] = QL_EVENT_LINK_TRADED; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; a0[2] = eventData[0]; a0[3] = eventData[1]; eventData += 2; @@ -3305,7 +3305,7 @@ static const u8 *const sBattleOutcomeTexts[] = { static u16 *BufferQuestLogData_LinkBattledSingle(u16 *a0, const u16 *eventData) { a0[0] = QL_EVENT_LINK_BATTLED_SINGLE; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; *((u8 *)a0 + 4) = *((const u8 *)eventData + 0); memcpy((u8 *)a0 + 5, (const u8 *)eventData + 1, PLAYER_NAME_LENGTH); a0 += 6; @@ -3329,7 +3329,7 @@ static const u16 *BufferQuestLogText_LinkBattledSingle(const u16 *a0) static u16 *BufferQuestLogData_LinkBattledDouble(u16 *a0, const u16 *eventData) { a0[0] = QL_EVENT_LINK_BATTLED_DOUBLE; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; *((u8 *)a0 + 4) = *((const u8 *)eventData + 0); memcpy((u8 *)a0 + 5, (const u8 *)eventData + 1, PLAYER_NAME_LENGTH); a0 += 6; @@ -3353,7 +3353,7 @@ static const u16 *BufferQuestLogText_LinkBattledDouble(const u16 *a0) static u16 *BufferQuestLogData_LinkBattledMulti(u16 *a0, const u16 *eventData) { a0[0] = QL_EVENT_LINK_BATTLED_MULTI; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; *((u8 *)a0 + 4) = *((const u8 *)eventData + 0); memcpy((u8 *)a0 + 5, (const u8 *)eventData + 1, PLAYER_NAME_LENGTH); memcpy((u8 *)a0 + 12, (const u8 *)eventData + 8, PLAYER_NAME_LENGTH); @@ -3388,7 +3388,7 @@ static const u16 *BufferQuestLogText_LinkBattledMulti(const u16 *a0) static u16 *BufferQuestLogData_UsedUnionRoom(u16 *a0, const u16 *eventData) { a0[0] = QL_EVENT_USED_UNION_ROOM; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; return a0 + 2; } @@ -3402,7 +3402,7 @@ static const u16 *BufferQuestLogText_UsedUnionRoom(const u16 *a0) static u16 *BufferQuestLogData_UsedUnionRoomChat(u16 *a0, const u16 *eventData) { a0[0] = QL_EVENT_USED_UNION_ROOM_CHAT; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; return a0 + 2; } @@ -3417,7 +3417,7 @@ static u16 *BufferQuestLogData_LinkTradedUnionRoom(u16 *a0, const u16 *eventData { u8 *r4 = (u8 *)(a0 + 4); a0[0] = QL_EVENT_LINK_TRADED_UNION; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; a0[2] = eventData[0]; a0[3] = eventData[1]; memcpy(r4, eventData + 2, PLAYER_NAME_LENGTH); @@ -3441,7 +3441,7 @@ static const u16 *BufferQuestLogText_LinkTradedUnionRoom(const u16 *a0) static u16 *BufferQuestLogData_LinkBattledUnionRoom(u16 *a0, const u16 *eventData) { a0[0] = QL_EVENT_LINK_BATTLED_UNION; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; *(u8 *)&a0[2] = *(const u8 *)&eventData[0]; memcpy((u8 *)a0 + 5, (const u8 *)eventData + 1, PLAYER_NAME_LENGTH); a0 += 6; @@ -3743,7 +3743,7 @@ static u16 *BufferQuestLogData_DefeatedWildMon(u16 *a0, const u16 *eventData) if (r5[0] == 0 && r5[1] == 0) { r4[0] = QL_EVENT_DEFEATED_WILD_MON; - r4[1] = sQuestLogIdx; + r4[1] = sQuestLogCursor; } if (eventData[0]) r4[2] = eventData[0]; @@ -3847,7 +3847,7 @@ static u16 *BufferQuestLogData_DefeatedChampion(u16 *a0, const u16 *eventData) if (!sub_8110944(a0, sQuestLogEventCmdSizes[QL_EVENT_DEFEATED_CHAMPION])) return NULL; a0[0] = 0x2021; - a0[1] = sQuestLogIdx; + a0[1] = sQuestLogCursor; a0[2] = eventData[1]; a0[3] = eventData[2]; *((u8 *)a0 + 8) = *((const u8 *)eventData + 6); @@ -4299,7 +4299,7 @@ void QuestLog_RecordEnteredMap(u16 worldMapFlag) { s32 i; - if (gQuestLogState == 2 || gQuestLogState == 3) + if (gQuestLogState == QL_STATE_2 || gQuestLogState == QL_STATE_3) return; for (i = 0; i < (int)NELEMS(sQuestLogWorldMapFlags); i++) @@ -4308,13 +4308,13 @@ void QuestLog_RecordEnteredMap(u16 worldMapFlag) { if (!FlagGet(worldMapFlag)) { - gUnknown_203B049 = TRUE; + sNewlyEnteredMap = TRUE; break; } else { - gUnknown_203B049 += 0; - gUnknown_203B049 = FALSE; + sNewlyEnteredMap += 0; + sNewlyEnteredMap = FALSE; break; } } @@ -4324,13 +4324,13 @@ void QuestLog_RecordEnteredMap(u16 worldMapFlag) void sub_8115798(void) { u16 sp0; - if (gQuestLogState != 2 && gQuestLogState != 3) + if (gQuestLogState != QL_STATE_2 && gQuestLogState != QL_STATE_3) { - if (gUnknown_203B049) + if (sNewlyEnteredMap) { sp0 = gMapHeader.regionMapSectionId; SetQuestLogEvent(QL_EVENT_ARRIVED, &sp0); - gUnknown_203B049 = FALSE; + sNewlyEnteredMap = FALSE; } } } diff --git a/src/quest_log_objects.c b/src/quest_log_objects.c index 2c17987e8..64b4b7fe5 100644 --- a/src/quest_log_objects.c +++ b/src/quest_log_objects.c @@ -45,7 +45,7 @@ void SetQuestLogObjectEventsData(struct QuestLog * questLog) } } -void sub_815A1F8(const struct QuestLog * questLog, const struct ObjectEventTemplate * templates) +void SetSav1ObjectEventsFromQuestLog(const struct QuestLog * questLog, const struct ObjectEventTemplate * templates) { u32 i, j; const struct QuestLogObjectEvent * questLogObjectEvents = questLog->unk_008; @@ -131,7 +131,7 @@ void sub_815A1F8(const struct QuestLog * questLog, const struct ObjectEventTempl void sub_815A540(void) { - if (gQuestLogState == 2) + if (gQuestLogState == QL_STATE_2) { s16 x, y; diff --git a/src/quest_log_player.c b/src/quest_log_player.c index be40042b3..8abf7fab5 100644 --- a/src/quest_log_player.c +++ b/src/quest_log_player.c @@ -39,7 +39,7 @@ void sub_8150454(u8 a0) gUnknown_8471EDC[a0](); } -bool8 sub_8150474(u8 a0) +bool32 sub_8150474(u8 a0) { if (gUnknown_3005E88 == 2) { @@ -68,7 +68,7 @@ static void sub_81504E8(void) sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(1)); ObjectEventTurn(objectEvent, objectEvent->movementDirection); SetPlayerAvatarStateMask(PLAYER_AVATAR_FLAG_MACH_BIKE); - sub_80BD620(0, 0); + InitPlayerAvatarBikeState(0, 0); } static void sub_8150530(void) @@ -87,7 +87,7 @@ static void sub_8150530(void) else { sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(4)); - StartSpriteAnim(sprite, GetFishingNoCatchDirectionAnimNum(objectEvent->facingDirection)); + StartSpriteAnim(sprite, GetFishingDirectionAnimNum(objectEvent->facingDirection)); } } @@ -102,23 +102,23 @@ static void sub_81505C4(u8 taskId) ObjectEventClearHeldMovementIfActive(objectEvent); objectEvent->enableAnim = TRUE; sub_81507BC(objectEvent, GetPlayerAvatarGraphicsIdByStateId(4)); - StartSpriteAnim(sprite, GetFishingNoCatchDirectionAnimNum(objectEvent->facingDirection)); + StartSpriteAnim(sprite, GetFishingDirectionAnimNum(objectEvent->facingDirection)); gTasks[taskId].data[0]++; gTasks[taskId].data[1] = 0; break; case 1: - sub_805D9C4(sprite); + AlignFishingAnimationFrames(sprite); if (gTasks[taskId].data[1] < 60) gTasks[taskId].data[1]++; else gTasks[taskId].data[0]++; break; case 2: - StartSpriteAnim(sprite, GetFishingBiteDirectionAnimNum(GetPlayerFacingDirection())); + StartSpriteAnim(sprite, GetFishingNoCatchDirectionAnimNum(GetPlayerFacingDirection())); gTasks[taskId].data[0]++; break; case 3: - sub_805D9C4(sprite); + AlignFishingAnimationFrames(sprite); if (sprite->animEnded) { if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)) @@ -177,20 +177,20 @@ static void sub_81507BC(struct ObjectEvent * a0, u8 a1) static void sub_81507CC(void) { - sub_805D154(1); + CreateStopSurfingTask_NoMusicChange(1); } static void sub_81507D8(void) { - sub_805D154(2); + CreateStopSurfingTask_NoMusicChange(2); } static void sub_81507E4(void) { - sub_805D154(3); + CreateStopSurfingTask_NoMusicChange(3); } static void sub_81507F0(void) { - sub_805D154(4); + CreateStopSurfingTask_NoMusicChange(4); } diff --git a/src/region_map.c b/src/region_map.c index 3a902ec0e..f97d67ffc 100644 --- a/src/region_map.c +++ b/src/region_map.c @@ -3471,7 +3471,7 @@ static void GetPlayerPositionOnRegionMap(void) const struct MapHeader * mapHeader; struct WarpData * warp; - switch (get_map_light_level_by_bank_and_number(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)) + switch (GetMapTypeByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)) { default: case 1: @@ -3495,12 +3495,12 @@ static void GetPlayerPositionOnRegionMap(void) y = gSaveBlock1Ptr->escapeWarp.y; break; case 9: - mapHeader = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->warp2.mapGroup, gSaveBlock1Ptr->warp2.mapNum); + mapHeader = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->dynamicWarp.mapGroup, gSaveBlock1Ptr->dynamicWarp.mapNum); gUnknown_20399E4->field_014 = mapHeader->regionMapSectionId; width = mapHeader->mapLayout->width; height = mapHeader->mapLayout->height; - x = gSaveBlock1Ptr->warp2.x; - y = gSaveBlock1Ptr->warp2.y; + x = gSaveBlock1Ptr->dynamicWarp.x; + y = gSaveBlock1Ptr->dynamicWarp.y; break; case 8: if ((gUnknown_20399E4->field_014 = gMapHeader.regionMapSectionId) != MAPSEC_SPECIAL_AREA) @@ -3510,7 +3510,7 @@ static void GetPlayerPositionOnRegionMap(void) } else { - warp = &gSaveBlock1Ptr->warp2; + warp = &gSaveBlock1Ptr->dynamicWarp; mapHeader = Overworld_GetMapHeaderByGroupAndId(warp->mapGroup, warp->mapNum); gUnknown_20399E4->field_014 = mapHeader->regionMapSectionId; } @@ -4318,7 +4318,7 @@ static void sub_80C4F08(u8 taskId) case 4: if ((sub_80C3AC8(0) == 2 || sub_80C3AC8(0) == 4) && GetRegionMapPermission(MAPPERM_3) == TRUE) { - switch (get_map_light_level_by_bank_and_number(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)) + switch (GetMapTypeByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)) { case 4: case 8: @@ -4388,7 +4388,7 @@ static void sub_80C527C(u16 mapsec) u16 idx = mapsec - MAPSECS_KANTO; if (sMapsecToSpawn[idx][2]) { - sub_805546C(sMapsecToSpawn[idx][2]); + SetWarpDestinationToHealLocation(sMapsecToSpawn[idx][2]); SetUsedFlyQuestLogEvent(sMapsecToSpawn[idx]); } else diff --git a/src/save_location.c b/src/save_location.c index 561fd2ff2..1fef9e8cf 100644 --- a/src/save_location.c +++ b/src/save_location.c @@ -93,16 +93,16 @@ void TrySetMapSaveWarpStatus(void) sub_810B7CC(); } -void sub_810B810(void) +void SetUnlockedPokedexFlags(void) { gSaveBlock2Ptr->field_A8 |= 0x1; gSaveBlock2Ptr->field_A8 |= 0x10; gSaveBlock2Ptr->field_A8 |= 0x20; } -void sub_810B82C(void) +void SetPostgameFlags(void) { - gSaveBlock2Ptr->specialSaveWarpFlags |= 0x80; + gSaveBlock2Ptr->specialSaveWarpFlags |= CHAMPION_SAVEWARP; gSaveBlock2Ptr->field_A8 |= 0x2; gSaveBlock2Ptr->field_A8 |= 0x4; gSaveBlock2Ptr->field_A8 |= 0x8; diff --git a/src/scrcmd.c b/src/scrcmd.c index 2b5137f9a..bec0f4942 100644 --- a/src/scrcmd.c +++ b/src/scrcmd.c @@ -802,7 +802,7 @@ bool8 ScrCmd_warpteleport2(struct ScriptContext * ctx) u16 y = VarGet(ScriptReadHalfword(ctx)); SetWarpDestination(mapGroup, mapNum, warpId, x, y); - sub_805DAE4(GetPlayerFacingDirection()); + SavePlayerFacingDirectionForTeleport(GetPlayerFacingDirection()); sub_807E500(); ResetInitialPlayerAvatarState(); return TRUE; @@ -1168,7 +1168,7 @@ bool8 ScrCmd_setobjectmovementtype(struct ScriptContext * ctx) u16 localId = VarGet(ScriptReadHalfword(ctx)); u8 movementType = ScriptReadByte(ctx); - Overworld_SetMapObjTemplateMovementType(localId, movementType); + Overworld_SetObjEventTemplateMovementType(localId, movementType); return FALSE; } diff --git a/src/script.c b/src/script.c index ff74b40bc..097f6d3f3 100644 --- a/src/script.c +++ b/src/script.c @@ -28,7 +28,7 @@ static struct ScriptContext sScriptContext1; static u32 sUnusedVariable2; static struct ScriptContext sScriptContext2; static bool8 sScriptContext2Enabled; -static u8 gUnknown_3000F9D; +static u8 sMsgBoxWalkawayDisabled; static u8 sMsgBoxIsCancelable; static u8 sQuestLogInput; static u8 sQuestLogInputIsDpad; @@ -235,19 +235,19 @@ u8 GetRegisteredQuestLogInput(void) return sQuestLogInput; } -void sub_80699BC(void) +void DisableMsgBoxWalkaway(void) { - gUnknown_3000F9D = TRUE; + sMsgBoxWalkawayDisabled = TRUE; } -void sub_80699C8(void) +void EnableMsgBoxWalkaway(void) { - gUnknown_3000F9D = FALSE; + sMsgBoxWalkawayDisabled = FALSE; } -bool8 sub_80699D4(void) +bool8 IsMsgBoxWalkawayDisabled(void) { - return gUnknown_3000F9D; + return sMsgBoxWalkawayDisabled; } void SetWalkingIntoSignVars(void) @@ -330,7 +330,7 @@ bool8 ScriptContext2_RunScript(void) void ScriptContext1_SetupScript(const u8 *ptr) { ClearMsgBoxCancelableState(); - sub_80699C8(); + EnableMsgBoxWalkaway(); ClearQuestLogInputIsDpadFlag(); InitScriptContext(&sScriptContext1, gScriptCmdTable, gScriptCmdTableEnd); SetupBytecodeScript(&sScriptContext1, ptr); @@ -358,7 +358,7 @@ void ScriptContext2_RunNewScript(const u8 *ptr) u8 *mapheader_get_tagged_pointer(u8 tag) { - u8 *mapScripts = gMapHeader.mapScripts; + const u8 *mapScripts = gMapHeader.mapScripts; if (mapScripts == NULL) return NULL; @@ -370,7 +370,7 @@ u8 *mapheader_get_tagged_pointer(u8 tag) if (*mapScripts == tag) { mapScripts++; - return (u8 *)(mapScripts[0] + (mapScripts[1] << 8) + (mapScripts[2] << 16) + (mapScripts[3] << 24)); + return T2_READ_PTR(mapScripts); } mapScripts += 5; } @@ -379,7 +379,7 @@ u8 *mapheader_get_tagged_pointer(u8 tag) void mapheader_run_script_by_tag(u8 tag) { u8 *ptr = mapheader_get_tagged_pointer(tag); - if (ptr) + if (ptr != NULL) ScriptContext2_RunNewScript(ptr); } @@ -387,7 +387,7 @@ u8 *mapheader_get_first_match_from_tagged_ptr_list(u8 tag) { u8 *ptr = mapheader_get_tagged_pointer(tag); - if (!ptr) + if (ptr == NULL) return NULL; while (1) @@ -411,22 +411,22 @@ void RunOnLoadMapScript(void) mapheader_run_script_by_tag(1); } -void mapheader_run_script_with_tag_x3(void) +void RunOnTransitionMapScript(void) { mapheader_run_script_by_tag(3); } -void mapheader_run_script_with_tag_x5(void) +void RunOnResumeMapScript(void) { mapheader_run_script_by_tag(5); } -void mapheader_run_script_with_tag_x7(void) +void RunOnReturnToFieldMapScript(void) { mapheader_run_script_by_tag(7); } -void mapheader_run_script_with_tag_x6(void) +void RunOnDiveWarpMapScript(void) { mapheader_run_script_by_tag(6); } @@ -447,7 +447,7 @@ bool8 TryRunOnFrameMapScript(void) return 1; } -void mapheader_run_first_tag4_script_list_match(void) +void TryRunOnWarpIntoMapScript(void) { u8 *ptr = mapheader_get_first_match_from_tagged_ptr_list(4); if (ptr) diff --git a/src/seagallop.c b/src/seagallop.c index 1e2234b9c..f7405296f 100644 --- a/src/seagallop.c +++ b/src/seagallop.c @@ -322,7 +322,7 @@ static void Task_Seagallop_3(void) SetWarpDestination(warpInfo[0], warpInfo[1], -1, warpInfo[2], warpInfo[3]); PlayRainStoppingSoundEffect(); PlaySE(SE_KAIDAN); - gFieldCallback = sub_807DF64; + gFieldCallback = FieldCB_DefaultWarpExit; WarpIntoMap(); SetMainCallback2(CB2_LoadMap); ResetInitialPlayerAvatarState(); diff --git a/src/shop.c b/src/shop.c index ddeaf6a68..b84007bed 100644 --- a/src/shop.c +++ b/src/shop.c @@ -120,7 +120,7 @@ static void CB2_InitBuyMenu(void); static bool8 InitShopData(void); static void BuyMenuInitBgs(void); static void BuyMenuDecompressBgGraphics(void); -static void sub_809B10C(bool32 a0); +static void RecolorItemDescriptionBox(bool32 a0); static void BuyMenuDrawGraphics(void); static bool8 BuyMenuBuildListMenuTemplate(void); static void PokeMartWriteNameAndIdAt(struct ListMenuItem *list, u16 index, u8* dst); @@ -134,7 +134,7 @@ static void SetShopExitCallback(void); static void BuyMenuAddScrollIndicatorArrows(void); static void BuyQuantityAddScrollIndicatorArrows(void); static void BuyMenuRemoveScrollIndicatorArrows(void); -static void sub_809B764(void); +static void BuyMenuDrawMapView(void); static void BuyMenuDrawMapBg(void); static void BuyMenuDrawMapMetatile(s16 x, s16 y, const u16 *src, u8 metatileLayerType); static void BuyMenuDrawMapMetatileLayer(u16 *dest, s16 offset1, s16 offset2, const u16 *src); @@ -152,8 +152,8 @@ static void Task_ReturnToItemListAfterItemPurchase(u8 taskId); static void BuyMenuReturnToItemList(u8 taskId); static void ExitBuyMenu(u8 taskId); static void Task_ExitBuyMenu(u8 taskId); -static void nullsub_52(u8 taskId); -static void nullsub_53(void); +static void DebugFunc_PrintPurchaseDetails(u8 taskId); +static void DebugFunc_PrintShopMenuHistoryBeforeClearMaybe(void); static void RecordQuestLogItemPurchase(void); static const struct MenuAction sShopMenuActions_BuySellQuit[] = @@ -496,26 +496,26 @@ static void BuyMenuDecompressBgGraphics(void) Free(pal); } -static void sub_809B10C(bool32 a0) +static void RecolorItemDescriptionBox(bool32 a0) { - u8 v; + u8 paletteNum; if (a0 == FALSE) - v = 0xB; + paletteNum = 0xB; else - v = 6; + paletteNum = 0x6; if ((gShopData.martType) != MART_TYPE_TMHM) - SetBgTilemapPalette(1, 0, 0xE, 0x1E, 6, v); + SetBgTilemapPalette(1, 0, 14, 30, 6, paletteNum); else - SetBgTilemapPalette(1, 0, 0xC, 0x1E, 8, v); + SetBgTilemapPalette(1, 0, 12, 30, 8, paletteNum); ScheduleBgCopyTilemapToVram(1); } static void BuyMenuDrawGraphics(void) { - sub_809B764(); + BuyMenuDrawMapView(); BuyMenuCopyTilemapData(); BuyMenuDrawMoneyBox(); ScheduleBgCopyTilemapToVram(0); @@ -732,7 +732,7 @@ static void BuyMenuRemoveScrollIndicatorArrows(void) gShopData.unk16_11 = 0x1F; } -static void sub_809B764(void) +static void BuyMenuDrawMapView(void) { BuyMenuCollectObjectEventData(); BuyMenuDrawObjectEvents(); @@ -913,7 +913,7 @@ static void Task_BuyMenu(u8 taskId) ClearWindowTilemap(5); BuyMenuRemoveScrollIndicatorArrows(); BuyMenuPrintCursor(tListTaskId, 2); - sub_809B10C(1); + RecolorItemDescriptionBox(1); gShopData.itemPrice = itemid_get_market_price(itemId); if (!IsEnoughMoney(&gSaveBlock1Ptr->money, gShopData.itemPrice)) { @@ -1006,7 +1006,7 @@ static void BuyMenuTryMakePurchase(u8 taskId) if (AddBagItem(tItemId, tItemCount) == TRUE) { BuyMenuDisplayMessage(taskId, gText_HereYouGoThankYou, BuyMenuSubtractMoney); - nullsub_52(taskId); + DebugFunc_PrintPurchaseDetails(taskId); RecordItemPurchase(tItemId, tItemCount, 1); } else @@ -1039,7 +1039,7 @@ static void BuyMenuReturnToItemList(u8 taskId) ClearDialogWindowAndFrameToTransparent(2, 0); BuyMenuPrintCursor(tListTaskId, 1); - sub_809B10C(0); + RecolorItemDescriptionBox(0); PutWindowTilemap(4); PutWindowTilemap(5); if (gShopData.martType == MART_TYPE_TMHM) @@ -1070,11 +1070,11 @@ static void Task_ExitBuyMenu(u8 taskId) } } -static void nullsub_52(u8 taskId) +static void DebugFunc_PrintPurchaseDetails(u8 taskId) { } -static void nullsub_53(void) +static void DebugFunc_PrintShopMenuHistoryBeforeClearMaybe(void) { } @@ -1138,7 +1138,7 @@ void CreatePokemartMenu(const u16 *itemsForSale) SetShopItemsForSale(itemsForSale); CreateShopMenu(MART_TYPE_REGULAR); SetShopMenuCallback(EnableBothScriptContexts); - nullsub_53(); + DebugFunc_PrintShopMenuHistoryBeforeClearMaybe(); memset(&gShopMenuHistory, 0, sizeof(gShopMenuHistory)); gShopMenuHistory[0].unk8 = gMapHeader.regionMapSectionId; gShopMenuHistory[1].unk8 = gMapHeader.regionMapSectionId; diff --git a/src/sprite.c b/src/sprite.c index fd824494b..a71edce1c 100644 --- a/src/sprite.c +++ b/src/sprite.c @@ -1,7 +1,5 @@ #include "global.h" -#include "sprite.h" -#include "main.h" -#include "palette.h" +#include "gflib.h" #define MAX_SPRITE_COPY_REQUESTS 64 diff --git a/src/start_menu.c b/src/start_menu.c index 867e469e0..6fd69d9e0 100644 --- a/src/start_menu.c +++ b/src/start_menu.c @@ -1,7 +1,5 @@ #include "global.h" -#include "palette.h" -#include "bg.h" -#include "gpu_regs.h" +#include "gflib.h" #include "scanline_effect.h" #include "overworld.h" #include "link.h" @@ -17,7 +15,6 @@ #include "menu.h" #include "load_save.h" #include "strings.h" -#include "string_util.h" #include "menu_helpers.h" #include "text_window.h" #include "field_fadetransition.h" @@ -26,7 +23,6 @@ #include "event_object_movement.h" #include "event_object_lock.h" #include "script.h" -#include "sound.h" #include "quest_log.h" #include "new_game.h" #include "event_scripts.h" @@ -395,7 +391,7 @@ void ShowStartMenu(void) { FreezeObjectEvents(); sub_805C270(); - sub_805C780(); + StopPlayerAvatar(); } OpenStartMenuWithFollowupFunc(Task_StartMenuHandleInput); ScriptContext2_Enable(); @@ -779,7 +775,7 @@ static u8 SaveDialogCB_AskOverwriteOrReplacePreviousFileHandleInput(void) static u8 SaveDialogCB_PrintSavingDontTurnOffPower(void) { - sub_8112450(); + SaveQuestLogData(); PrintSaveTextWithFollowupFunc(gText_SavingDontTurnOffThePower, SaveDialogCB_DoSave); return SAVECB_RETURN_CONTINUE; } diff --git a/src/strings.c b/src/strings.c index faf42c86a..de428ddd9 100644 --- a/src/strings.c +++ b/src/strings.c @@ -958,8 +958,8 @@ const u8 gText_Sorry[] = _("SORRY"); const u8 gText_YaySmileEmoji[] = _("YAY{EXTRA 0xF9}"); const u8 gText_ThankYou[] = _("THANK YOU"); const u8 gText_ByeBye[] = _("BYE-BYE!"); -const u8 gUnknown_841B554[] = _("{PLAYER} scurried to a POKéMON CENTER,\nprotecting the exhausted and fainted\nPOKéMON from further harm‥\p"); -const u8 gUnknown_841B5B6[] = _("{PLAYER} scurried back home, protecting\nthe exhausted and fainted POKéMON from\nfurther harm‥\p"); +const u8 gText_PlayerScurriedToCenter[] = _("{PLAYER} scurried to a POKéMON CENTER,\nprotecting the exhausted and fainted\nPOKéMON from further harm‥\p"); +const u8 gText_PlayerScurriedBackHome[] = _("{PLAYER} scurried back home, protecting\nthe exhausted and fainted POKéMON from\nfurther harm‥\p"); const u8 gUnknown_841B60E[] = _("PLAYER: {DYNAMIC 0x00}"); const u8 gUnknown_841B619[] = _("This document is issued in\nrecognition of your magnificent\nachievement - the completion of\nthe {DYNAMIC 0x01} POKéDEX."); const u8 gUnknown_841B684[] = _("GAME FREAK"); @@ -1056,10 +1056,10 @@ const u8 gText_BerryCrush2[] = _("BERRY CRUSH"); const u8 gText_PressingSpeedRankings[] = _("Pressing-Speed Rankings"); const u8 gText_Var1Players[] = _("{STR_VAR_1} PLAYERS"); ALIGNED(4) const u8 gText_Ghost[] = _("GHOST"); -const u8 gUnknown_841D14E[] = _("A POKéMON's on the hook!{PAUSE_UNTIL_PRESS}"); -const u8 gUnknown_841D169[] = _("Not even a nibble‥{PAUSE_UNTIL_PRESS}"); -const u8 gUnknown_841D17E[] = _("It got away‥{PAUSE_UNTIL_PRESS}"); -const u8 gUnknown_841D18D[] = _("ROOFTOP"); +const u8 gText_PokemonOnHook[] = _("A POKéMON's on the hook!{PAUSE_UNTIL_PRESS}"); +const u8 gText_NotEvenANibble[] = _("Not even a nibble‥{PAUSE_UNTIL_PRESS}"); +const u8 gText_ItGotAway[] = _("It got away‥{PAUSE_UNTIL_PRESS}"); +const u8 gText_Rooftop2[] = _("ROOFTOP"); ALIGNED(4) const u8 gString_PokemonFireRed_Staff[] = _("Pokémon FireRed Version\nStaff"); ALIGNED(4) const u8 gString_PokemonLeafGreen_Staff[] = _("Pokémon LeafGreen Version\nStaff"); ALIGNED(4) const u8 gCreditsString_Director[] = _("\n\nDirector\n\n\n\n"); diff --git a/src/title_screen.c b/src/title_screen.c index e1bcf5dd2..14f7a8732 100644 --- a/src/title_screen.c +++ b/src/title_screen.c @@ -668,7 +668,7 @@ static void SetTitleScreenScene_Restart(s16 * data) case 4: HelpSystem_Disable(); DestroyTask(FindTaskIdByFunc(Task_TitleScreenMain)); - SetMainCallback2(sub_80EC864); + SetMainCallback2(CB2_CopyrightScreen); break; } } diff --git a/src/tm_case.c b/src/tm_case.c index 7bb471719..57eee6faf 100644 --- a/src/tm_case.c +++ b/src/tm_case.c @@ -304,7 +304,7 @@ static void CB2_SetUpTMCaseUI_Blocking(void) { while (1) { - if ((u8)sub_80BF72C() == TRUE) + if ((u8)MenuHelpers_CallLinkSomething() == TRUE) break; if (DoSetUpTMCaseUI() == TRUE) break; @@ -733,7 +733,7 @@ static void Task_TMCaseMain(u8 taskId) if (!gPaletteFade.active) { - if ((u8)sub_80BF72C() != TRUE) + if ((u8)MenuHelpers_CallLinkSomething() != TRUE) { input = ListMenu_ProcessInput(data[0]); ListMenuGetScrollAndRow(data[0], &sTMCaseStaticResources.scrollOffset, &sTMCaseStaticResources.selectedRow); @@ -814,7 +814,7 @@ static void Task_TMContextMenu_HandleInput(u8 taskId) { s8 input; - if ((u8)sub_80BF72C() != TRUE) + if ((u8)MenuHelpers_CallLinkSomething() != TRUE) { input = Menu_ProcessInputNoWrapAround(); switch (input) diff --git a/src/trade.c b/src/trade.c index bd6860e85..bb2634613 100644 --- a/src/trade.c +++ b/src/trade.c @@ -2022,7 +2022,7 @@ static void sub_804E944(void) Free(sTradeMenuResourcesPtr); FreeAllWindowBuffers(); DestroyWirelessStatusIndicatorSprite(); - SetMainCallback2(c2_8056854); + SetMainCallback2(CB2_ReturnToFieldFromMultiplayer); } } else @@ -2032,7 +2032,7 @@ static void sub_804E944(void) Free(sSpriteTextTileBuffer); Free(sTradeMenuResourcesPtr); FreeAllWindowBuffers(); - SetMainCallback2(c2_8056854); + SetMainCallback2(CB2_ReturnToFieldFromMultiplayer); } } } diff --git a/src/trade_scene.c b/src/trade_scene.c index d609a9b53..308cd6e5b 100644 --- a/src/trade_scene.c +++ b/src/trade_scene.c @@ -2747,7 +2747,7 @@ static void Task_WaitFadeAndStartInGameTradeAnim(u8 taskId) if (!gPaletteFade.active) { SetMainCallback2(CB2_InitTradeAnim_InGameTrade); - gFieldCallback = FieldCallback_ReturnToEventScript2; + gFieldCallback = FieldCB_ContinueScriptHandleMusic; DestroyTask(taskId); } } diff --git a/src/trainer_card.c b/src/trainer_card.c index df116d379..01bd2c228 100644 --- a/src/trainer_card.c +++ b/src/trainer_card.c @@ -589,7 +589,7 @@ static void Task_TrainerCard(u8 taskId) } break; case STATE_WAIT_FLIP_TO_BACK: - if (IsCardFlipTaskActive() && sub_8058244() != TRUE) + if (IsCardFlipTaskActive() && Overworld_LinkRecvQueueLengthMoreThan2() != TRUE) { PlaySE(SE_CARD3); sTrainerCardDataPtr->mainState = STATE_HANDLE_INPUT_BACK; @@ -647,7 +647,7 @@ static void Task_TrainerCard(u8 taskId) CloseTrainerCard(taskId); break; case STATE_WAIT_FLIP_TO_FRONT: - if (IsCardFlipTaskActive() && sub_8058244() != TRUE) + if (IsCardFlipTaskActive() && Overworld_LinkRecvQueueLengthMoreThan2() != TRUE) { sTrainerCardDataPtr->mainState = STATE_HANDLE_INPUT_FRONT; PlaySE(SE_CARD3); @@ -1727,7 +1727,7 @@ static bool8 Task_AnimateCardFlipDown(struct Task* task) static bool8 Task_DrawFlippedCardSide(struct Task* task) { sTrainerCardDataPtr->allowDMACopy = FALSE; - if (sub_8058244() == TRUE) + if (Overworld_LinkRecvQueueLengthMoreThan2() == TRUE) return FALSE; do diff --git a/src/trainer_see.c b/src/trainer_see.c index 6fad80468..5681c4344 100644 --- a/src/trainer_see.c +++ b/src/trainer_see.c @@ -42,7 +42,7 @@ static void Task_DestroyTrainerApproachTask(u8 taskId); static void SpriteCB_TrainerIcons(struct Sprite * sprite); static void SetIconSpriteData(struct Sprite *sprite, u16 fldEffId, u8 spriteAnimNum); -static const u16 sGfx_Emoticons[] = INCBIN_U16("graphics/object_events/emoticons.4bpp"); +static const u16 sGfx_Emoticons[] = INCBIN_U16("graphics/misc/emoticons.4bpp"); // u8 func(struct ObjectEvent * trainerObj, s16 range, s16 x, s16 y) // range is the maximum distance the trainer can see diff --git a/src/trainer_tower.c b/src/trainer_tower.c index 0c673b5aa..64acbacd8 100644 --- a/src/trainer_tower.c +++ b/src/trainer_tower.c @@ -115,7 +115,7 @@ static const struct SinglesTrainerInfo sSingleBattleTrainerInfo[] = { {OBJ_EVENT_GFX_WOMAN_2, FACILITY_CLASS_AROMA_LADY, FEMALE}, {OBJ_EVENT_GFX_HIKER, FACILITY_CLASS_RUIN_MANIAC, MALE}, {OBJ_EVENT_GFX_TUBER_F, FACILITY_CLASS_TUBER, FEMALE}, - {OBJ_EVENT_GFX_TUBER_M_2, FACILITY_CLASS_TUBER_2, MALE}, + {OBJ_EVENT_GFX_TUBER_M_LAND, FACILITY_CLASS_TUBER_2, MALE}, {OBJ_EVENT_GFX_COOLTRAINER_M, FACILITY_CLASS_COOLTRAINER, MALE}, {OBJ_EVENT_GFX_COOLTRAINER_F, FACILITY_CLASS_COOLTRAINER_2, FEMALE}, {OBJ_EVENT_GFX_SUPER_NERD, FACILITY_CLASS_HEX_MANIAC, MALE}, @@ -202,12 +202,12 @@ static const struct DoublesTrainerInfo sDoubleBattleTrainerInfo[] = { {OBJ_EVENT_GFX_LITTLE_GIRL, OBJ_EVENT_GFX_LITTLE_GIRL, FACILITY_CLASS_TWINS, FEMALE, FEMALE}, {OBJ_EVENT_GFX_BEAUTY, OBJ_EVENT_GFX_MAN, FACILITY_CLASS_YOUNG_COUPLE, FEMALE, MALE}, {OBJ_EVENT_GFX_OLD_MAN_1, OBJ_EVENT_GFX_OLD_WOMAN, FACILITY_CLASS_OLD_COUPLE, MALE, FEMALE}, - {OBJ_EVENT_GFX_TUBER_M_2, OBJ_EVENT_GFX_SWIMMER_F_LAND, FACILITY_CLASS_SIS_AND_BRO, MALE, FEMALE}, + {OBJ_EVENT_GFX_TUBER_M_LAND, OBJ_EVENT_GFX_SWIMMER_F_LAND, FACILITY_CLASS_SIS_AND_BRO, MALE, FEMALE}, {OBJ_EVENT_GFX_LITTLE_GIRL, OBJ_EVENT_GFX_LITTLE_GIRL, FACILITY_CLASS_TWINS_2, FEMALE, FEMALE}, {OBJ_EVENT_GFX_COOLTRAINER_M, OBJ_EVENT_GFX_COOLTRAINER_F, FACILITY_CLASS_COOL_COUPLE, MALE, FEMALE}, {OBJ_EVENT_GFX_BEAUTY, OBJ_EVENT_GFX_MAN, FACILITY_CLASS_YOUNG_COUPLE_2, FEMALE, MALE}, {OBJ_EVENT_GFX_BATTLE_GIRL, OBJ_EVENT_GFX_BLACKBELT, FACILITY_CLASS_CRUSH_KIN, FEMALE, MALE}, - {OBJ_EVENT_GFX_SWIMMER_F_LAND, OBJ_EVENT_GFX_TUBER_M_2, FACILITY_CLASS_SIS_AND_BRO_2, FEMALE, MALE} + {OBJ_EVENT_GFX_SWIMMER_F_LAND, OBJ_EVENT_GFX_TUBER_M_LAND, FACILITY_CLASS_SIS_AND_BRO_2, FEMALE, MALE} }; static const struct TrainerEncounterMusicPairs sTrainerEncounterMusicLUT[105] = { diff --git a/src/vs_seeker.c b/src/vs_seeker.c index 7b67ea8b0..849c599e8 100644 --- a/src/vs_seeker.c +++ b/src/vs_seeker.c @@ -80,7 +80,9 @@ extern u8 gSelectedObjectEvent; // static declarations static EWRAM_DATA struct VsSeekerStruct *sVsSeeker = NULL; -static void sub_810C3B8(u8 taskId); +static void VsSeekerResetInBagStepCounter(void); +static void VsSeekerResetChargingStepCounter(void); +static void Task_ResetObjectsRematchWantedState(u8 taskId); static void sub_810C594(void); static void Task_VsSeeker_1(u8 taskId); static void Task_VsSeeker_2(u8 taskId); @@ -103,6 +105,7 @@ static u8 GetRematchableTrainerLocalId(void); static void StartTrainerObjectMovementScript(struct VsSeekerTrainerInfo *, const u8 *); static u8 GetCurVsSeekerResponse(s32, u16); static void StartAllRespondantIdleMovements(void); +static u8 GetRandomFaceDirectionMovementType(); // rodata static const VsSeekerData sVsSeekerData[] = { @@ -581,16 +584,14 @@ static const u8 gUnknown_8453F67[] = { MOVEMENT_TYPE_FACE_RIGHT }; - // text - -void sub_810C3A4(void) +void VsSeekerFreezeObjectsAfterChargeComplete(void) { - CreateTask(sub_810C3B8, 80); + CreateTask(Task_ResetObjectsRematchWantedState, 80); } -static void sub_810C3B8(u8 taskId) +static void Task_ResetObjectsRematchWantedState(u8 taskId) { struct Task * task = &gTasks[taskId]; u8 i; @@ -618,36 +619,36 @@ static void sub_810C3B8(u8 taskId) if (task->data[0] != 0) { DestroyTask(taskId); - sub_805C780(); + StopPlayerAvatar(); EnableBothScriptContexts(); } } -void sub_810C444(void) +void VsSeekerResetObjectMovementAfterChargeComplete(void) { struct ObjectEventTemplate * templates = gSaveBlock1Ptr->objectEventTemplates; u8 i; - u8 r6; - u8 sp0; + u8 movementType; + u8 objEventId; struct ObjectEvent * objectEvent; for (i = 0; i < gMapHeader.events->objectEventCount; i++) { if ((templates[i].trainerType == 1 || templates[i].trainerType == 3) && (templates[i].movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_DOWN || templates[i].movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_UP || templates[i].movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_LEFT)) { - r6 = sub_810CF54(); - TryGetObjectEventIdByLocalIdAndMap(templates[i].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &sp0); - objectEvent = &gObjectEvents[sp0]; - if (sub_810CF04(sp0) == TRUE) + movementType = GetRandomFaceDirectionMovementType(); + TryGetObjectEventIdByLocalIdAndMap(templates[i].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &objEventId); + objectEvent = &gObjectEvents[objEventId]; + if (sub_810CF04(objEventId) == TRUE) { - SetTrainerMovementType(objectEvent, r6); + SetTrainerMovementType(objectEvent, movementType); } - templates[i].movementType = r6; + templates[i].movementType = movementType; } } } -bool8 sub_810C4EC(void) +bool8 UpdateVsSeekerStepCounter(void) { if (CheckBagHasItem(ITEM_VS_SEEKER, 1) == TRUE) { @@ -672,7 +673,7 @@ bool8 sub_810C4EC(void) if (x == 100) { FlagClear(FLAG_SYS_VS_SEEKER_CHARGING); - sub_810C640(); + VsSeekerResetChargingStepCounter(); sub_810D0D0(); return TRUE; } @@ -681,10 +682,10 @@ bool8 sub_810C4EC(void) return FALSE; } -void sub_810C578(void) +void TryUpdateRandomTrainerRematches(u16 mapGroup, u16 mapNum) { FlagClear(FLAG_SYS_VS_SEEKER_CHARGING); - sub_810C640(); + VsSeekerResetChargingStepCounter(); sub_810D0D0(); sub_810C594(); } @@ -698,34 +699,34 @@ static void sub_810C594(void) struct ObjectEvent * objectEvent = &gObjectEvents[i]; if (objectEvent->movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_DOWN || objectEvent->movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_UP || objectEvent->movementType == MOVEMENT_TYPE_WALK_SLOWLY_IN_PLACE_LEFT) { - u8 r3 = sub_810CF54(); + u8 movementType = GetRandomFaceDirectionMovementType(); if (objectEvent->active && gSprites[objectEvent->spriteId].data[0] == i) { gSprites[objectEvent->spriteId].pos2.x = 0; gSprites[objectEvent->spriteId].pos2.y = 0; - SetTrainerMovementType(objectEvent, r3); + SetTrainerMovementType(objectEvent, movementType); } } } } -void sub_810C604(void) +static void VsSeekerResetInBagStepCounter(void) { gSaveBlock1Ptr->trainerRematchStepCounter &= 0xFF00; } -void sub_810C620(void) +static void VsSeekerSetStepCounterInBagFull(void) { gSaveBlock1Ptr->trainerRematchStepCounter &= 0xFF00; gSaveBlock1Ptr->trainerRematchStepCounter |= 100; } -void sub_810C640(void) +static void VsSeekerResetChargingStepCounter(void) { gSaveBlock1Ptr->trainerRematchStepCounter &= 0x00FF; } -void sub_810C654(void) +static void VsSeekerSetStepCounterFullyCharged(void) { gSaveBlock1Ptr->trainerRematchStepCounter &= 0x00FF; gSaveBlock1Ptr->trainerRematchStepCounter |= (100 << 8); @@ -785,7 +786,7 @@ static void Task_VsSeeker_2(u8 taskId) { data[1] = 0; data[2] = 0; - sub_810C604(); + VsSeekerResetInBagStepCounter(); sVsSeeker->responseCode = GetVsSeekerResponseInArea(sVsSeekerData); ScriptMovement_StartObjectMovementScript(0xFF, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, gUnknown_8453F5C); gTasks[taskId].func = Task_VsSeeker_3; @@ -934,7 +935,7 @@ static u8 GetVsSeekerResponseInArea(const VsSeekerData * a0) { PlaySE(SE_PIN); FlagSet(FLAG_SYS_VS_SEEKER_CHARGING); - sub_810C640(); + VsSeekerResetChargingStepCounter(); return VSSEEKER_RESPONSE_FOUND_REMATCHES; } if (sVsSeeker->trainerHasNotYetBeenFought) @@ -944,7 +945,7 @@ static u8 GetVsSeekerResponseInArea(const VsSeekerData * a0) void sub_810CB90(void) { - u8 sp0 = 0; + u8 objEventId = 0; struct ObjectEventTemplate *r4 = gSaveBlock1Ptr->objectEventTemplates; s32 r9 = sub_810CE10(sVsSeekerData, gTrainerBattleOpponent_A); @@ -958,12 +959,12 @@ void sub_810CB90(void) { struct ObjectEvent *r4_2; - TryGetObjectEventIdByLocalIdAndMap(r4[r8].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &sp0); - r4_2 = &gObjectEvents[sp0]; - sub_810CF54(&r4[r8]); // You are using this function incorrectly. Please consult the manual. + TryGetObjectEventIdByLocalIdAndMap(r4[r8].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &objEventId); + r4_2 = &gObjectEvents[objEventId]; + GetRandomFaceDirectionMovementType(&r4[r8]); // You are using this function incorrectly. Please consult the manual. OverrideMovementTypeForObjectEvent(r4_2, gUnknown_8453F67[r4_2->facingDirection]); gSaveBlock1Ptr->trainerRematches[r4[r8].localId] = 0; - if (gSelectedObjectEvent == sp0) + if (gSelectedObjectEvent == objEventId) r4_2->movementType = gUnknown_8453F67[r4_2->facingDirection]; else r4_2->movementType = MOVEMENT_TYPE_FACE_DOWN; @@ -1113,22 +1114,22 @@ bool8 sub_810CF04(u8 a0) return FALSE; } -u8 sub_810CF54() +static u8 GetRandomFaceDirectionMovementType() { u16 r1 = Random() % 4; switch (r1) { case 0: - return 7; + return MOVEMENT_TYPE_FACE_UP; case 1: - return 8; + return MOVEMENT_TYPE_FACE_DOWN; case 2: - return 9; + return MOVEMENT_TYPE_FACE_LEFT; case 3: - return 10; + return MOVEMENT_TYPE_FACE_RIGHT; default: - return 8; + return MOVEMENT_TYPE_FACE_DOWN; } } @@ -1159,7 +1160,7 @@ static u8 GetRunningBehaviorFromGraphicsId(u8 graphicsId) case OBJ_EVENT_GFX_HIKER: case OBJ_EVENT_GFX_SAILOR: return 0x4e; - case OBJ_EVENT_GFX_TUBER_M_1: + case OBJ_EVENT_GFX_TUBER_M_WATER: case OBJ_EVENT_GFX_SWIMMER_M_WATER: case OBJ_EVENT_GFX_SWIMMER_F_WATER: return 0x4f; |