diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/battle_interface.c | 163 | ||||
| -rw-r--r-- | src/easy_chat.c | 2182 | ||||
| -rw-r--r-- | src/pokenav.c | 736 |
3 files changed, 2732 insertions, 349 deletions
diff --git a/src/battle_interface.c b/src/battle_interface.c index 0eb494db4..4a6ac67f1 100644 --- a/src/battle_interface.c +++ b/src/battle_interface.c @@ -35,125 +35,126 @@ struct TestingBar }; enum -{ - HEALTHBOX_GFX_0, - HEALTHBOX_GFX_1, - HEALTHBOX_GFX_2, - HEALTHBOX_GFX_HP_BAR_GREEN, - HEALTHBOX_GFX_4, - HEALTHBOX_GFX_5, - HEALTHBOX_GFX_6, - HEALTHBOX_GFX_7, - HEALTHBOX_GFX_8, - HEALTHBOX_GFX_9, - HEALTHBOX_GFX_10, - HEALTHBOX_GFX_11, - HEALTHBOX_GFX_12, - HEALTHBOX_GFX_13, - HEALTHBOX_GFX_14, - HEALTHBOX_GFX_15, - HEALTHBOX_GFX_16, - HEALTHBOX_GFX_17, - HEALTHBOX_GFX_18, - HEALTHBOX_GFX_19, - HEALTHBOX_GFX_20, - HEALTHBOX_GFX_STATUS_PSN_BATTLER0, - HEALTHBOX_GFX_22, - HEALTHBOX_GFX_23, - HEALTHBOX_GFX_STATUS_PRZ_BATTLER0, +{ // Corresponds to gHealthboxElementsGfxTable (and the tables after it) in graphics.c + // These are indexes into the tables, which are filled with 8x8 square pixel data. + HEALTHBOX_GFX_0, //hp bar [black section] + HEALTHBOX_GFX_1, //hp bar "H" + HEALTHBOX_GFX_2, //hp bar "P" + HEALTHBOX_GFX_HP_BAR_GREEN, //hp bar [0 pixels] + HEALTHBOX_GFX_4, //hp bar [1 pixels] + HEALTHBOX_GFX_5, //hp bar [2 pixels] + HEALTHBOX_GFX_6, //hp bar [3 pixels] + HEALTHBOX_GFX_7, //hp bar [4 pixels] + HEALTHBOX_GFX_8, //hp bar [5 pixels] + HEALTHBOX_GFX_9, //hp bar [6 pixels] + HEALTHBOX_GFX_10, //hp bar [7 pixels] + HEALTHBOX_GFX_11, //hp bar [8 pixels] + HEALTHBOX_GFX_12, //exp bar [0 pixels] + HEALTHBOX_GFX_13, //exp bar [1 pixels] + HEALTHBOX_GFX_14, //exp bar [2 pixels] + HEALTHBOX_GFX_15, //exp bar [3 pixels] + HEALTHBOX_GFX_16, //exp bar [4 pixels] + HEALTHBOX_GFX_17, //exp bar [5 pixels] + HEALTHBOX_GFX_18, //exp bar [6 pixels] + HEALTHBOX_GFX_19, //exp bar [7 pixels] + HEALTHBOX_GFX_20, //exp bar [8 pixels] + HEALTHBOX_GFX_STATUS_PSN_BATTLER0, //status psn "(P" + HEALTHBOX_GFX_22, //status psn "SN" + HEALTHBOX_GFX_23, //status psn "|)"" + HEALTHBOX_GFX_STATUS_PRZ_BATTLER0, //status prz HEALTHBOX_GFX_25, HEALTHBOX_GFX_26, - HEALTHBOX_GFX_STATUS_SLP_BATTLER0, + HEALTHBOX_GFX_STATUS_SLP_BATTLER0, //status slp HEALTHBOX_GFX_28, HEALTHBOX_GFX_29, - HEALTHBOX_GFX_STATUS_FRZ_BATTLER0, + HEALTHBOX_GFX_STATUS_FRZ_BATTLER0, //status frz HEALTHBOX_GFX_31, HEALTHBOX_GFX_32, - HEALTHBOX_GFX_STATUS_BRN_BATTLER0, + HEALTHBOX_GFX_STATUS_BRN_BATTLER0, //status brn HEALTHBOX_GFX_34, HEALTHBOX_GFX_35, - HEALTHBOX_GFX_36, - HEALTHBOX_GFX_37, - HEALTHBOX_GFX_38, - HEALTHBOX_GFX_39, - HEALTHBOX_GFX_40, - HEALTHBOX_GFX_41, - HEALTHBOX_GFX_42, - HEALTHBOX_GFX_43, - HEALTHBOX_GFX_44, - HEALTHBOX_GFX_45, - HEALTHBOX_GFX_46, - HEALTHBOX_GFX_HP_BAR_YELLOW, - HEALTHBOX_GFX_48, - HEALTHBOX_GFX_49, - HEALTHBOX_GFX_50, - HEALTHBOX_GFX_51, - HEALTHBOX_GFX_52, - HEALTHBOX_GFX_53, - HEALTHBOX_GFX_54, - HEALTHBOX_GFX_55, - HEALTHBOX_GFX_HP_BAR_RED, - HEALTHBOX_GFX_57, - HEALTHBOX_GFX_58, - HEALTHBOX_GFX_59, - HEALTHBOX_GFX_60, - HEALTHBOX_GFX_61, - HEALTHBOX_GFX_62, - HEALTHBOX_GFX_63, - HEALTHBOX_GFX_64, - HEALTHBOX_GFX_65, - HEALTHBOX_GFX_66, - HEALTHBOX_GFX_67, - HEALTHBOX_GFX_68, - HEALTHBOX_GFX_69, - HEALTHBOX_GFX_70, - HEALTHBOX_GFX_STATUS_PSN_BATTLER1, + HEALTHBOX_GFX_36, //misc [Black section] + HEALTHBOX_GFX_37, //misc [Black section] + HEALTHBOX_GFX_38, //misc [Black section] + HEALTHBOX_GFX_39, //misc [Blank Health Window?] + HEALTHBOX_GFX_40, //misc [Blank Health Window?] + HEALTHBOX_GFX_41, //misc [Blank Health Window?] + HEALTHBOX_GFX_42, //misc [Blank Health Window?] + HEALTHBOX_GFX_43, //misc [Top of Health Window?] + HEALTHBOX_GFX_44, //misc [Top of Health Window?] + HEALTHBOX_GFX_45, //misc [Top of Health Window?] + HEALTHBOX_GFX_46, //misc [Blank Health Window?] + HEALTHBOX_GFX_HP_BAR_YELLOW, //hp bar yellow [0 pixels] + HEALTHBOX_GFX_48, //hp bar yellow [1 pixels] + HEALTHBOX_GFX_49, //hp bar yellow [2 pixels] + HEALTHBOX_GFX_50, //hp bar yellow [3 pixels] + HEALTHBOX_GFX_51, //hp bar yellow [4 pixels] + HEALTHBOX_GFX_52, //hp bar yellow [5 pixels] + HEALTHBOX_GFX_53, //hp bar yellow [6 pixels] + HEALTHBOX_GFX_54, //hp bar yellow [7 pixels] + HEALTHBOX_GFX_55, //hp bar yellow [8 pixels] + HEALTHBOX_GFX_HP_BAR_RED, //hp bar red [0 pixels] + HEALTHBOX_GFX_57, //hp bar red [1 pixels] + HEALTHBOX_GFX_58, //hp bar red [2 pixels] + HEALTHBOX_GFX_59, //hp bar red [3 pixels] + HEALTHBOX_GFX_60, //hp bar red [4 pixels] + HEALTHBOX_GFX_61, //hp bar red [5 pixels] + HEALTHBOX_GFX_62, //hp bar red [6 pixels] + HEALTHBOX_GFX_63, //hp bar red [7 pixels] + HEALTHBOX_GFX_64, //hp bar red [8 pixels] + HEALTHBOX_GFX_65, //hp bar frame end + HEALTHBOX_GFX_66, //status ball [full] + HEALTHBOX_GFX_67, //status ball [empty] + HEALTHBOX_GFX_68, //status ball [fainted] + HEALTHBOX_GFX_69, //status ball [statused] + HEALTHBOX_GFX_70, //status ball [unused extra] + HEALTHBOX_GFX_STATUS_PSN_BATTLER1, //status2 "PSN" HEALTHBOX_GFX_72, HEALTHBOX_GFX_73, - HEALTHBOX_GFX_STATUS_PRZ_BATTLER1, + HEALTHBOX_GFX_STATUS_PRZ_BATTLER1, //status2 "PRZ" HEALTHBOX_GFX_75, HEALTHBOX_GFX_76, - HEALTHBOX_GFX_STATUS_SLP_BATTLER1, + HEALTHBOX_GFX_STATUS_SLP_BATTLER1, //status2 "SLP" HEALTHBOX_GFX_78, HEALTHBOX_GFX_79, - HEALTHBOX_GFX_STATUS_FRZ_BATTLER1, + HEALTHBOX_GFX_STATUS_FRZ_BATTLER1, //status2 "FRZ" HEALTHBOX_GFX_81, HEALTHBOX_GFX_82, - HEALTHBOX_GFX_STATUS_BRN_BATTLER1, + HEALTHBOX_GFX_STATUS_BRN_BATTLER1, //status2 "BRN" HEALTHBOX_GFX_84, HEALTHBOX_GFX_85, - HEALTHBOX_GFX_STATUS_PSN_BATTLER2, + HEALTHBOX_GFX_STATUS_PSN_BATTLER2, //status3 "PSN" HEALTHBOX_GFX_87, HEALTHBOX_GFX_88, - HEALTHBOX_GFX_STATUS_PRZ_BATTLER2, + HEALTHBOX_GFX_STATUS_PRZ_BATTLER2, //status3 "PRZ" HEALTHBOX_GFX_90, HEALTHBOX_GFX_91, - HEALTHBOX_GFX_STATUS_SLP_BATTLER2, + HEALTHBOX_GFX_STATUS_SLP_BATTLER2, //status3 "SLP" HEALTHBOX_GFX_93, HEALTHBOX_GFX_94, - HEALTHBOX_GFX_STATUS_FRZ_BATTLER2, + HEALTHBOX_GFX_STATUS_FRZ_BATTLER2, //status3 "FRZ" HEALTHBOX_GFX_96, HEALTHBOX_GFX_97, - HEALTHBOX_GFX_STATUS_BRN_BATTLER2, + HEALTHBOX_GFX_STATUS_BRN_BATTLER2, //status3 "BRN" HEALTHBOX_GFX_99, HEALTHBOX_GFX_100, - HEALTHBOX_GFX_STATUS_PSN_BATTLER3, + HEALTHBOX_GFX_STATUS_PSN_BATTLER3, //status4 "PSN" HEALTHBOX_GFX_102, HEALTHBOX_GFX_103, - HEALTHBOX_GFX_STATUS_PRZ_BATTLER3, + HEALTHBOX_GFX_STATUS_PRZ_BATTLER3, //status4 "PRZ" HEALTHBOX_GFX_105, HEALTHBOX_GFX_106, - HEALTHBOX_GFX_STATUS_SLP_BATTLER3, + HEALTHBOX_GFX_STATUS_SLP_BATTLER3, //status4 "SLP" HEALTHBOX_GFX_108, HEALTHBOX_GFX_109, - HEALTHBOX_GFX_STATUS_FRZ_BATTLER3, + HEALTHBOX_GFX_STATUS_FRZ_BATTLER3, //status4 "FRZ" HEALTHBOX_GFX_111, HEALTHBOX_GFX_112, - HEALTHBOX_GFX_STATUS_BRN_BATTLER3, + HEALTHBOX_GFX_STATUS_BRN_BATTLER3, //status4 "BRN" HEALTHBOX_GFX_114, HEALTHBOX_GFX_115, - HEALTHBOX_GFX_116, - HEALTHBOX_GFX_117, + HEALTHBOX_GFX_116, //unknown_D12FEC + HEALTHBOX_GFX_117, //unknown_D1300C }; extern const u8 *const gNatureNamePointers[]; diff --git a/src/easy_chat.c b/src/easy_chat.c index 5f5d20e16..1b1bd105b 100644 --- a/src/easy_chat.c +++ b/src/easy_chat.c @@ -2,11 +2,16 @@ // Includes #include "global.h" #include "alloc.h" +#include "bg.h" +#include "decompress.h" #include "dewford_trend.h" #include "dynamic_placeholder_text_util.h" #include "easy_chat.h" #include "event_data.h" +#include "event_object_movement.h" #include "field_weather.h" +#include "gpu_regs.h" +#include "graphics.h" #include "international_string_util.h" #include "link.h" #include "main.h" @@ -17,7 +22,9 @@ #include "string_util.h" #include "strings.h" #include "task.h" +#include "text_window.h" #include "window.h" +#include "constants/event_objects.h" #include "constants/flags.h" #include "constants/songs.h" @@ -70,8 +77,46 @@ struct EasyChatScreen /*0x3C*/ u16 ecWordBuffer[9]; }; +struct Unk203A11C +{ + u16 unk0; + u16 windowId; + u16 unk4; + u8 unk6; + u8 unk7; + s8 unk8; + u8 unk9; + u8 unkA; + u8 unkB[0xC1]; + u8 unkCC[0x202]; + u16 unk2CE; + int unk2D0; + int unk2D4; + struct Sprite *unk2D8; + struct Sprite *unk2DC; + struct Sprite *unk2E0; + struct Sprite *unk2E4; + struct Sprite *unk2E8; + struct Sprite *unk2EC; + struct Sprite *unk2F0; + struct Sprite *unk2F4; + struct Sprite *unk2F8; + struct Sprite *unk2FC; + u16 unk300[BG_SCREEN_SIZE / 2]; + u16 unkB00[BG_SCREEN_SIZE / 2]; +}; + +struct Unk08597C30 +{ + u8 unk0_0:5; + u8 unk0_5:3; + u8 unk1; + u8 unk2; + u8 unk3; +}; + EWRAM_DATA struct EasyChatScreen *gEasyChatScreen = NULL; -EWRAM_DATA void *gUnknown_0203A11C = 0; +EWRAM_DATA struct Unk203A11C *gUnknown_0203A11C = 0; EWRAM_DATA void *gUnknown_0203A120 = 0; static void sub_811A2C0(u8); @@ -103,10 +148,10 @@ static u8 sub_811BCC8(u8); static void sub_811BDF0(u8 *); void sub_811BF78(void); static bool8 sub_811BF8C(void); -bool8 sub_811BFA4(void); -void sub_811C13C(void); -/*static*/ void sub_811C158(u16); -/*static*/ bool8 sub_811C170(void); +static bool8 sub_811BFA4(void); +static void sub_811C13C(void); +static void sub_811C158(u16); +static bool8 sub_811C170(void); bool8 sub_811F28C(void); void sub_811F2B8(void); u8 sub_811F3AC(void); @@ -152,7 +197,102 @@ static void sub_811B9A0(void); static u8 sub_811BA1C(void); static int sub_811BF20(void); static u16 sub_811BF40(void); -u8 sub_811CE94(void); +static bool8 sub_811CE94(void); +static void sub_811CF64(void); +static void sub_811CF04(void); +static void sub_811D60C(void); +static void sub_811D424(u16 *); +static void sub_811D230(void); +void sub_811E948(void); +static void sub_811CFCC(void); +static void sub_811D0BC(void); +static void sub_811D2C8(void); +static void sub_811D684(void); +static void sub_811DE90(void); +static void sub_811DEC4(void); +static void sub_811DE5C(u8, u8, u8, u8); +static void sub_811E5D4(void); +static void sub_811E720(void); +static void sub_811E828(void); +static bool8 sub_811C2D4(void); +static bool8 sub_811C30C(void); +static bool8 sub_811C3E4(void); +static bool8 sub_811C48C(void); +static bool8 sub_811C404(void); +static bool8 sub_811C448(void); +static bool8 sub_811C4D0(void); +static bool8 sub_811C518(void); +static bool8 sub_811C554(void); +static bool8 sub_811C620(void); +static bool8 sub_811C830(void); +static bool8 sub_811C8F0(void); +static bool8 sub_811C99C(void); +static bool8 sub_811CA5C(void); +static bool8 sub_811C780(void); +static bool8 sub_811C78C(void); +static bool8 sub_811C7D4(void); +static bool8 sub_811CB18(void); +static bool8 sub_811CB98(void); +static bool8 sub_811CB24(void); +static bool8 sub_811CC90(void); +static bool8 sub_811CC08(void); +static bool8 sub_811C6C0(void); +static bool8 sub_811CD14(void); +static bool8 sub_811CD54(void); +static bool8 sub_811CD94(void); +static bool8 sub_811CDD4(void); +static bool8 sub_811CE14(void); +static bool8 sub_811CE54(void); +static void sub_811DF60(u8, u8); +static int sub_811E920(int); +static void sub_811DF90(void); +static void sub_811D104(u8); +static void sub_811D214(u8); +static void sub_811DFB0(void); +static void sub_811D6D4(void); +static void sub_811D9CC(int); +static void sub_811E3AC(void); +static bool8 sub_811E418(void); +static void sub_811DFC8(void); +static void sub_811E6E0(int); +static bool8 sub_811DAA4(void); +static void sub_811E64C(void); +static void sub_811E050(void); +static void sub_811E4AC(void); +static void sub_811E6B0(void); +static void sub_811E55C(void); +static bool8 sub_811E4D0(void); +static bool8 sub_811E5B8(void); +static void sub_811E578(void); +static void sub_811E088(void); +static void sub_811DDAC(s16, u8); +static bool8 sub_811DE10(void); +static void sub_811D9B4(void); +static void sub_811D698(u32); +static void sub_811E288(void); +static void sub_811E794(void); +static void sub_811E380(void); +static void sub_811E7F8(void); +static void sub_811E30C(void); +static void sub_811D7A4(void); +static void sub_811D7C8(void); +static int sub_811DE48(void); +static void sub_811D7EC(void); +static void sub_811D830(void); +void sub_811D058(u8, u8, const u8 *, u8, u8, u8, u8, u8, u8); +static void sub_811DD84(void); +static void sub_811D6F4(void); +static void sub_811D758(void); +static void sub_811D794(void); +const u8 *sub_811F424(u8); +static void sub_811D864(u8, u8); +static void sub_811D950(u8, u8); +static void sub_811DADC(u8); +static void sub_811DC28(int, int, int, int); +static void sub_811E0EC(s8, s8); +static void sub_811E1A4(s8, s8); +static void sub_811E2DC(struct Sprite *); +static void sub_811E34C(u8, u8); u8 *CopyEasyChatWordPadded(u8 *, u16, u16); extern const struct { @@ -164,6 +304,28 @@ extern const struct EasyChatScreenTemplate gEasyChatScreenTemplates[21]; extern const u8 gUnknown_08597748[][7]; extern const u16 gUnknown_08597764[]; extern const u16 gUnknown_0859776C[][2]; +extern const struct BgTemplate gUnknown_08597C54[4]; +extern const struct WindowTemplate gUnknown_08597C64[]; +extern const u32 gUnknown_08597B54[]; +extern const struct Unk08597C30 gUnknown_08597C30[]; +extern const u16 gUnknown_08597B14[]; +extern const u16 gUnknown_08597B34[]; +extern const u16 gUnknown_08597C1C[]; +extern const u16 gUnknown_08597C24[]; +extern const struct WindowTemplate gUnknown_08597C84; +extern const u8 gUnknown_08597C8C[4]; +extern const u8 *const gUnknown_08597C90[4]; +extern const struct SpriteSheet gUnknown_08597CA0[]; +extern const struct SpritePalette gUnknown_08597CC0[]; +extern const struct CompressedSpriteSheet gUnknown_08597CE8[]; +extern const struct SpriteTemplate gUnknown_08597D18; +extern const struct SpriteTemplate gUnknown_08597D68; +extern const struct SpriteTemplate gUnknown_08597DF0; +extern const struct SpriteTemplate gUnknown_08597DD0; +extern const struct SpriteTemplate gUnknown_08597E48; +extern const struct SpriteTemplate gUnknown_08597E30; +extern const u8 gUnknown_08597D08[]; +extern const u8 gUnknown_08597E60[][4]; void sub_811A20C(u8 kind, u16 *words, MainCallback callback, u8 sizeParam) { @@ -1916,19 +2078,19 @@ u8 sub_811BAC4(void) return gEasyChatScreen->mainCursorRow; } -void sub_811BAD0(const u8 **str1, const u8 **str2) +static void GetEasyChatInstructionsText(const u8 **str1, const u8 **str2) { *str1 = gEasyChatScreenTemplates[gEasyChatScreen->templateId].instructionsText1; *str2 = gEasyChatScreenTemplates[gEasyChatScreen->templateId].instructionsText2; } -void sub_811BB08(const u8 **str1, const u8 **str2) +static void GetEasyChatConfirmText(const u8 **str1, const u8 **str2) { *str1 = gEasyChatScreenTemplates[gEasyChatScreen->templateId].confirmText1; *str2 = gEasyChatScreenTemplates[gEasyChatScreen->templateId].confirmText2; } -void sub_811BB40(const u8 **str1, const u8 **str2) +static void sub_811BB40(const u8 **str1, const u8 **str2) { switch (gEasyChatScreen->kind) { @@ -1949,7 +2111,7 @@ void sub_811BB40(const u8 **str1, const u8 **str2) } -void sub_811BB88(const u8 **str1, const u8 **str2) +static void GetEasyChatConfirmDeletionText(const u8 **str1, const u8 **str2) { *str1 = gText_AllTextBeingEditedWill; *str2 = gText_BeDeletedThatOkay; @@ -2026,7 +2188,7 @@ int sub_811BC2C(void) return 0; } -int sub_811BC70(void) +static int sub_811BC70(void) { return sub_811BA3C(); } @@ -2213,3 +2375,2001 @@ static bool8 sub_811BF8C(void) else return 1; } + +static bool8 sub_811BFA4(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + ResetBgsAndClearDma3BusyFlags(0); + InitBgsFromTemplates(0, gUnknown_08597C54, ARRAY_COUNT(gUnknown_08597C54)); + SetBgTilemapBuffer(3, gUnknown_0203A11C->unkB00); + SetBgTilemapBuffer(1, gUnknown_0203A11C->unk300); + InitWindows(gUnknown_08597C64); + DeactivateAllTextPrinters(); + sub_811CF64(); + sub_811CF04(); + CpuFastFill(0, (void *)VRAM + 0x1000000, 0x400); + break; + case 1: + DecompressAndLoadBgGfxUsingHeap(3, gEasyChatWindow_Gfx, 0, 0, 0); + CopyToBgTilemapBuffer(3, gEasyChatWindow_Tilemap, 0, 0); + sub_811D60C(); + sub_811D424(gUnknown_0203A11C->unk300); + sub_811D230(); + sub_811E948(); + CopyBgTilemapBufferToVram(3); + break; + case 2: + DecompressAndLoadBgGfxUsingHeap(1, gUnknown_08597B54, 0, 0, 0); + CopyBgTilemapBufferToVram(1); + break; + case 3: + sub_811CFCC(); + sub_811D0BC(); + sub_811D2C8(); + sub_811D684(); + break; + case 4: + sub_811DE90(); + if (sub_811BA5C() != 16) + sub_811DEC4(); + break; + case 5: + if (IsDma3ManagerBusyWithBgCopy()) + { + return TRUE; + } + else + { + sub_811DE5C(0, 0, 0, 0); + SetGpuReg(REG_OFFSET_WININ, WIN_RANGE(0, 63)); + SetGpuReg(REG_OFFSET_WINOUT, WIN_RANGE(0, 59)); + ShowBg(3); + ShowBg(1); + ShowBg(2); + ShowBg(0); + sub_811E5D4(); + sub_811E720(); + sub_811E828(); + } + break; + default: + return FALSE; + } + + gUnknown_0203A11C->unk0++; + return TRUE; +} + +static void sub_811C13C(void) +{ + if (gUnknown_0203A11C) + FREE_AND_SET_NULL(gUnknown_0203A11C); +} + +static void sub_811C158(u16 arg0) +{ + gUnknown_0203A11C->unk4 = arg0; + gUnknown_0203A11C->unk0 = 0; + sub_811C170(); +} + +static bool8 sub_811C170(void) +{ + switch (gUnknown_0203A11C->unk4) + { + case 0: return FALSE; + case 1: return sub_811C2D4(); + case 2: return sub_811C30C(); + case 3: return sub_811C3E4(); + case 4: return sub_811C48C(); + case 5: return sub_811C404(); + case 6: return sub_811C448(); + case 7: return sub_811C4D0(); + case 8: return sub_811C518(); + case 9: return sub_811C554(); + case 10: return sub_811C620(); + case 11: return sub_811C830(); + case 12: return sub_811C8F0(); + case 13: return sub_811C99C(); + case 14: return sub_811CA5C(); + case 15: return sub_811C780(); + case 16: return sub_811C78C(); + case 17: return sub_811C7D4(); + case 18: return sub_811CB18(); + case 19: return sub_811CB98(); + case 20: return sub_811CB24(); + case 21: return sub_811CC90(); + case 22: return sub_811CC08(); + case 23: return sub_811C6C0(); + case 24: return FALSE; + case 25: return FALSE; + case 26: return FALSE; + case 27: return FALSE; + case 28: return FALSE; + case 29: return sub_811CD14(); + case 30: return sub_811CD54(); + case 31: return sub_811CD94(); + case 32: return sub_811CDD4(); + case 33: return sub_811CE14(); + case 34: return sub_811CE54(); + default: return FALSE; + } +} + +static bool8 sub_811C2D4(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811D2C8(); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811C30C(void) +{ + u8 i; + u16 *ecWordBuffer; + u16 *ecWord; + u8 var0; + u8 cursorColumn, cursorRow, numColumns; + s16 var1; + int stringWidth; + int trueStringWidth; + u8 var2; + u8 sp0[64]; + + ecWordBuffer = sub_811BA94(); + var0 = sub_811BA68(); + cursorColumn = sub_811BAB8(); + cursorRow = sub_811BAC4(); + numColumns = sub_811BAAC(); + ecWord = &ecWordBuffer[cursorRow * numColumns]; + var1 = 8 * gUnknown_08597C30[var0].unk0_0 + 13; + for (i = 0; i < cursorColumn; i++) + { + if (*ecWord == 0xFFFF) + { + stringWidth = 72; + } + else + { + CopyEasyChatWord(sp0, *ecWord); + stringWidth = GetStringWidth(1, sp0, 0); + } + + trueStringWidth = stringWidth + 17; + var1 += trueStringWidth; + ecWord++; + } + + var2 = 8 * (gUnknown_08597C30[var0].unk0_5 + cursorRow * 2); + sub_811DF60(var1, var2 + 8); + return FALSE; +} + +static bool8 sub_811C3E4(void) +{ + u8 var0 = sub_811E920(sub_811BAB8()); + sub_811DF60(var0, 96); + return FALSE; +} + +static bool8 sub_811C404(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(2); + sub_811D214(1); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811C448(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(3); + sub_811D214(0); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811C48C(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(1); + sub_811D214(1); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811C4D0(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DFB0(); + sub_811D104(0); + sub_811D2C8(); + ShowBg(0); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811C518(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DFB0(); + sub_811D104(0); + sub_811D2C8(); + gUnknown_0203A11C->unk0++; + // Fall through + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811C554(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + HideBg(0); + sub_811DE5C(0, 0, 0, 0); + sub_811D6D4(); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811D9CC(0); + gUnknown_0203A11C->unk0++; + } + break; + case 2: + if (!IsDma3ManagerBusyWithBgCopy() && !sub_811DAA4()) + gUnknown_0203A11C->unk0++; + break; + case 3: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811E3AC(); + gUnknown_0203A11C->unk0++; + } + break; + case 4: + if (!sub_811E418()) + { + sub_811DFC8(); + sub_811E6E0(0); + sub_811E64C(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + default: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811C620(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811E050(); + sub_811E4AC(); + sub_811E6B0(); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (sub_811E4D0() == TRUE) + break; + + sub_811D9CC(1); + gUnknown_0203A11C->unk0++; + // Fall through + case 2: + if (!sub_811DAA4()) + gUnknown_0203A11C->unk0++; + break; + case 3: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811DFB0(); + ShowBg(0); + gUnknown_0203A11C->unk0++; + } + break; + case 4: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811C6C0(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811E050(); + sub_811E6B0(); + sub_811E55C(); + sub_811D9CC(5); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (!sub_811DAA4() && !sub_811E5B8()) + { + sub_811D6D4(); + gUnknown_0203A11C->unk0++; + } + break; + case 2: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811D9CC(6); + sub_811E578(); + gUnknown_0203A11C->unk0++; + } + break; + case 3: + if (!sub_811DAA4() && !sub_811E5B8()) + { + sub_811E64C(); + sub_811DFC8(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 4: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811C780(void) +{ + sub_811E088(); + return FALSE; +} + +static bool8 sub_811C78C(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DDAC(1, 4); + gUnknown_0203A11C->unk0++; + // Fall through + case 1: + if (!sub_811DE10()) + { + sub_811E088(); + sub_811E64C(); + return FALSE; + } + break; + } + + return TRUE; +} + +static bool8 sub_811C7D4(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DDAC(-1, 4); + gUnknown_0203A11C->unk0++; + // Fall through + case 1: + if (!sub_811DE10()) + { + sub_811E64C(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 2: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811C830(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811E050(); + sub_811E4AC(); + sub_811E6B0(); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (!sub_811E4D0()) + { + sub_811D9B4(); + gUnknown_0203A11C->unk0++; + } + break; + case 2: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811D9CC(2); + gUnknown_0203A11C->unk0++; + } + break; + case 3: + if (!sub_811DAA4()) + { + sub_811D698(2); + gUnknown_0203A11C->unk0++; + } + break; + case 4: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811E288(); + sub_811E6E0(1); + sub_811E64C(); + sub_811E794(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 5: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811C8F0(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811D2C8(); + gUnknown_0203A11C->unk0++; + break; + case 1: + sub_811E380(); + sub_811E6B0(); + sub_811E7F8(); + sub_811D9B4(); + gUnknown_0203A11C->unk0++; + break; + case 2: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811D9CC(3); + gUnknown_0203A11C->unk0++; + } + break; + case 3: + if (!sub_811DAA4()) + { + ShowBg(0); + gUnknown_0203A11C->unk0++; + } + break; + case 4: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811DFB0(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 5: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811C99C(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811D2C8(); + gUnknown_0203A11C->unk0++; + break; + case 1: + sub_811E380(); + sub_811E6B0(); + sub_811E7F8(); + sub_811D9B4(); + gUnknown_0203A11C->unk0++; + break; + case 2: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811D9CC(3); + gUnknown_0203A11C->unk0++; + } + break; + case 3: + if (!sub_811DAA4()) + { + sub_811D104(3); + gUnknown_0203A11C->unk0++; + } + break; + case 4: + if (!IsDma3ManagerBusyWithBgCopy()) + { + ShowBg(0); + gUnknown_0203A11C->unk0++; + } + break; + case 5: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811DFB0(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 6: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811CA5C(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811E380(); + sub_811E6B0(); + sub_811E7F8(); + sub_811D9B4(); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811D9CC(4); + gUnknown_0203A11C->unk0++; + } + break; + case 2: + if (!sub_811DAA4()) + { + sub_811D6D4(); + gUnknown_0203A11C->unk0++; + } + break; + case 3: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811E3AC(); + gUnknown_0203A11C->unk0++; + } + break; + case 4: + if (!sub_811E418()) + { + sub_811DFC8(); + sub_811E6E0(0); + sub_811E64C(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + } + + return TRUE; +} + +static bool8 sub_811CB18(void) +{ + sub_811E30C(); + return FALSE; +} + +static bool8 sub_811CB24(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811D7A4(); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811DDAC(1, 4); + gUnknown_0203A11C->unk0++; + } + break; + case 2: + if (!sub_811DE10()) + { + sub_811E30C(); + sub_811E64C(); + sub_811E794(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 3: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811CB98(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811D7C8(); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_811DDAC(-1, 4); + gUnknown_0203A11C->unk0++; + } + break; + case 2: + if (!sub_811DE10()) + { + sub_811E64C(); + sub_811E794(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 3: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811CC08(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811D7EC(); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (!IsDma3ManagerBusyWithBgCopy()) + { + s16 var0 = sub_811BBDC() - sub_811DE48(); + sub_811DDAC(var0, 8); + gUnknown_0203A11C->unk0++; + } + break; + case 2: + if (!sub_811DE10()) + { + sub_811E30C(); + sub_811E64C(); + sub_811E794(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 3: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811CC90(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811D830(); + gUnknown_0203A11C->unk0++; + break; + case 1: + if (!IsDma3ManagerBusyWithBgCopy()) + { + s16 var0 = sub_811BBDC() - sub_811DE48(); + sub_811DDAC(var0, 8); + gUnknown_0203A11C->unk0++; + } + break; + case 2: + if (!sub_811DE10()) + { + sub_811E64C(); + sub_811E794(); + gUnknown_0203A11C->unk0++; + return FALSE; + } + break; + case 3: + return FALSE; + } + + return TRUE; +} + +static bool8 sub_811CD14(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(4); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811CD54(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(5); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811CD94(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(6); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811CDD4(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(7); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811CE14(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(8); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811CE54(void) +{ + switch (gUnknown_0203A11C->unk0) + { + case 0: + sub_811DF90(); + sub_811D104(9); + gUnknown_0203A11C->unk0++; + break; + case 1: + return IsDma3ManagerBusyWithBgCopy(); + } + + return TRUE; +} + +static bool8 sub_811CE94(void) +{ + gUnknown_0203A11C = Alloc(sizeof(*gUnknown_0203A11C)); + if (!gUnknown_0203A11C) + return FALSE; + + gUnknown_0203A11C->unk0 = 0; + gUnknown_0203A11C->unk2D8 = NULL; + gUnknown_0203A11C->unk2DC = NULL; + gUnknown_0203A11C->unk2E0 = NULL; + gUnknown_0203A11C->unk2E4 = NULL; + gUnknown_0203A11C->unk2E8 = NULL; + gUnknown_0203A11C->unk2EC = NULL; + gUnknown_0203A11C->unk2F0 = NULL; + gUnknown_0203A11C->unk2F4 = NULL; + gUnknown_0203A11C->unk2F8 = NULL; + gUnknown_0203A11C->unk2FC = NULL; + gUnknown_0203A11C->unkA = sub_811BC70(); + return TRUE; +} + +static void sub_811CF04(void) +{ + ChangeBgX(3, 0, 0); + ChangeBgY(3, 0, 0); + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ChangeBgX(2, 0, 0); + ChangeBgY(2, 0, 0); + ChangeBgX(0, 0, 0); + ChangeBgY(0, 0, 0); + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON); +} + +static void sub_811CF64(void) +{ + ResetPaletteFade(); + LoadPalette(gEasyChatMode_Pal, 0, 32); + LoadPalette(gUnknown_08597B14, 1 * 16, 32); + LoadPalette(gUnknown_08597B34, 4 * 16, 32); + LoadPalette(gUnknown_08597C1C, 10 * 16, 8); + LoadPalette(gUnknown_08597C24, 11 * 16, 12); + LoadPalette(gUnknown_08597C24, 15 * 16, 12); + LoadPalette(gUnknown_08597C24, 3 * 16, 12); +} + +static void sub_811CFCC(void) +{ + int xOffset; + const u8 *titleText = sub_811BA88(); + if (!titleText) + return; + + xOffset = GetStringCenterAlignXOffset(1, titleText, 144); + FillWindowPixelBuffer(0, 0); + sub_811D058(0, 1, titleText, xOffset, 1, 0xFF, 0, 2, 3); + PutWindowTilemap(0); + CopyWindowToVram(0, 3); +} + +void sub_811D028(u8 windowId, u8 fontId, const u8 *str, u8 x, u8 y, u8 speed, void (*callback)(struct TextPrinterTemplate *, u16)) +{ + AddTextPrinterParameterized(windowId, fontId, str, x, y, speed, callback); +} + +void sub_811D058(u8 windowId, u8 fontId, const u8 *str, u8 left, u8 top, u8 speed, u8 red, u8 green, u8 blue) +{ + u8 color[3]; + color[0] = red; + color[1] = green; + color[2] = blue; + AddTextPrinterParameterized3(windowId, fontId, left, top, color, speed, str); +} + +static void sub_811D0BC(void) +{ + FillBgTilemapBufferRect(0, 0, 0, 0, 32, 20, 17); + LoadUserWindowBorderGfx(1, 1, 0xE0); + sub_8098858(1, 1, 14); + sub_811D104(0); + PutWindowTilemap(1); + CopyBgTilemapBufferToVram(0); +} + +static void sub_811D104(u8 arg0) +{ + const u8 *text2 = NULL; + const u8 *text1 = NULL; + switch (arg0) + { + case 0: + GetEasyChatInstructionsText(&text1, &text2); + break; + case 2: + sub_811BB40(&text1, &text2); + break; + case 3: + GetEasyChatConfirmText(&text1, &text2); + break; + case 1: + GetEasyChatConfirmDeletionText(&text1, &text2); + break; + case 4: + text1 = gText_CreateAQuiz; + break; + case 5: + text1 = gText_SelectTheAnswer; + break; + case 6: + text1 = gText_OnlyOnePhrase; + text2 = gText_OriginalSongWillBeUsed; + break; + case 7: + text1 = gText_LyricsCantBeDeleted; + break; + case 8: + text1 = gText_CombineTwoWordsOrPhrases3; + break; + case 9: + text1 = gText_YouCannotQuitHere; + text2 = gText_SectionMustBeCompleted; + break; + } + + FillWindowPixelBuffer(1, 0x11); + if (text1) + sub_811D028(1, 1, text1, 0, 1, 0xFF, 0); + + if (text2) + sub_811D028(1, 1, text2, 0, 17, 0xFF, 0); + + CopyWindowToVram(1, 3); +} + +static void sub_811D214(u8 initialCursorPos) +{ + CreateYesNoMenu(&gUnknown_08597C84, 1, 14, initialCursorPos); +} + +static void sub_811D230(void) +{ + u8 var0; + struct WindowTemplate template; + + var0 = sub_811BA68(); + template.bg = 3; + template.tilemapLeft = gUnknown_08597C30[var0].unk0_0; + template.tilemapTop = gUnknown_08597C30[var0].unk0_5; + template.width = gUnknown_08597C30[var0].unk1; + template.height = gUnknown_08597C30[var0].unk2; + template.paletteNum = 11; + template.baseBlock = 0x6C; + gUnknown_0203A11C->windowId = AddWindow(&template); + PutWindowTilemap(gUnknown_0203A11C->windowId); +} + +static void sub_811D2C8(void) +{ + u8 spC[4]; + u16 *ecWord; + u8 numColumns, numRows; + u8 *str; + int var0; + int var1; + int i, j, k; + + ecWord = sub_811BA94(); + numColumns = sub_811BAAC(); + numRows = sub_811BAA0(); + var0 = sub_811BA68(); + var1 = 0; + if (var0 == 7) + var1 = 1; + + FillWindowPixelBuffer(gUnknown_0203A11C->windowId, 0x11); + for (i = 0; i < numRows; i++) + { + memcpy(spC, gUnknown_08597C8C, sizeof(gUnknown_08597C8C)); + if (var1) + spC[2] = 6; + + str = gUnknown_0203A11C->unkB; + gUnknown_0203A11C->unkB[0] = EOS; + str = StringAppend(str, spC); + for (j = 0; j < numColumns; j++) + { + if (*ecWord != 0xFFFF) + { + str = CopyEasyChatWord(str, *ecWord); + ecWord++; + } + else + { + ecWord++; + if (!var1) + { + str = WriteColorChangeControlCode(str, 0, 4); + for (k = 0; k < 12; k++) + { + *str = CHAR_HYPHEN; + str++; + } + + str = WriteColorChangeControlCode(str, 0, 2); + } + } + + if (var1) + spC[2] = 3; + + str = StringAppend(str, spC); + if (var0 == 2 || var0 == 7 || var0 == 8) + { + if (j == 0 && i == 4) + break; + } + } + + *str = EOS; + sub_811D028(gUnknown_0203A11C->windowId, 1, gUnknown_0203A11C->unkB, 0, i * 16 + 1, 0xFF, 0); + } + + CopyWindowToVram(gUnknown_0203A11C->windowId, 3); +} + +static void sub_811D424(u16 *tilemap) +{ + u8 var0; + int right, bottom; + int x, y; + + var0 = sub_811BA68(); + CpuFastFill(0, tilemap, BG_SCREEN_SIZE); + if (var0 == 2 || var0 == 8) + { + right = gUnknown_08597C30[var0].unk0_0 + gUnknown_08597C30[var0].unk1; + bottom = gUnknown_08597C30[var0].unk0_5 + gUnknown_08597C30[var0].unk2; + for (y = gUnknown_08597C30[var0].unk0_5; y < bottom; y++) + { + x = gUnknown_08597C30[var0].unk0_0 - 1; + tilemap[y * 32 + x] = 0x1005; + x++; + for (; x < right; x++) + tilemap[y * 32 + x] = 0x1000; + + tilemap[y* 32 + x] = 0x1007; + } + } + else + { + y = gUnknown_08597C30[var0].unk0_5 - 1; + x = gUnknown_08597C30[var0].unk0_0 - 1; + right = gUnknown_08597C30[var0].unk0_0 + gUnknown_08597C30[var0].unk1; + bottom = gUnknown_08597C30[var0].unk0_5 + gUnknown_08597C30[var0].unk2; + tilemap[y * 32 + x] = 0x1001; + x++; + for (; x < right; x++) + tilemap[y * 32 + x] = 0x1002; + + tilemap[y * 32 + x] = 0x1003; + y++; + for (; y < bottom; y++) + { + x = gUnknown_08597C30[var0].unk0_0 - 1; + tilemap[y * 32 + x] = 0x1005; + x++; + for (; x < right; x++) + tilemap[y * 32 + x] = 0x1000; + + tilemap[y* 32 + x] = 0x1007; + } + + x = gUnknown_08597C30[var0].unk0_0 - 1; + tilemap[y * 32 + x] = 0x1009; + x++; + for (; x < right; x++) + tilemap[y * 32 + x] = 0x100A; + + tilemap[y * 32 + x] = 0x100B; + } +} + +static void sub_811D60C(void) +{ + u8 var0; + u16 *tilemap; + + tilemap = GetBgTilemapBuffer(3); + var0 = sub_811BA68(); + switch (gUnknown_08597C30[var0].unk3) + { + case 2: + tilemap += 0x2A0; + CopyToBgTilemapBufferRect(3, tilemap, 0, 11, 32, 2); + break; + case 1: + tilemap += 0x300; + CopyToBgTilemapBufferRect(3, tilemap, 0, 11, 32, 2); + break; + case 3: + CopyToBgTilemapBufferRect(3, tilemap, 0, 10, 32, 4); + break; + } +} + +static void sub_811D684(void) +{ + PutWindowTilemap(2); + CopyBgTilemapBufferToVram(2); +} + +static void sub_811D698(u32 arg0) +{ + sub_811DD84(); + FillWindowPixelBuffer(2, 0x11); + switch (arg0) + { + case 0: + sub_811D6F4(); + break; + case 1: + sub_811D758(); + break; + case 2: + sub_811D794(); + break; + } + + CopyWindowToVram(2, 2); +} + +static void sub_811D6D4(void) +{ + if (!sub_811BBB0()) + sub_811D698(0); + else + sub_811D698(1); +} + +static void sub_811D6F4(void) +{ + int i; + int x, y; + + i = 0; + y = 97; + while (1) + { + for (x = 0; x < 2; x++) + { + u8 index = sub_811F3B8(i++); + if (index == 22) + { + sub_811DDAC(sub_811BBBC(), 0); + return; + } + + sub_811D028(2, 1, sub_811F424(index), x * 84 + 10, y, 0xFF, NULL); + } + + y += 16; + } +} + +static void sub_811D758(void) +{ + u32 i; + + for (i = 0; i < 4; i++) + sub_811D028(2, 1, gUnknown_08597C90[i], 10, 97 + i * 16, 0xFF, NULL); +} + +static void sub_811D794(void) +{ + sub_811D864(0, 4); +} + +static void sub_811D7A4(void) +{ + u8 var0 = sub_811BBDC() + 3; + sub_811D950(var0, 1); + sub_811D864(var0, 1); +} + +static void sub_811D7C8(void) +{ + u8 var0 = sub_811BBDC(); + sub_811D950(var0, 1); + sub_811D864(var0, 1); +} + +static void sub_811D7EC(void) +{ + u8 var0 = sub_811BBDC(); + u8 var1 = var0 + 4; + u8 var2 = sub_811BBE8() + 1; + if (var1 > var2) + var1 = var2; + + if (var0 < var1) + { + u8 var3 = var1 - var0; + sub_811D950(var0, var3); + sub_811D864(var0, var3); + } +} + +static void sub_811D830(void) +{ + u8 var0 = sub_811BBDC(); + u8 var1 = sub_811DE48(); + if (var0 < var1) + { + u8 var2 = var1 - var0; + sub_811D950(var0, var2); + sub_811D864(var0, var2); + } +} + +static void sub_811D864(u8 arg0, u8 arg1) +{ + int i, j; + u16 easyChatWord; + u8 *str; + int y; + int var0; + + var0 = arg0 * 2; + y = (arg0 * 16 + 96) & 0xFF; + y++; + for (i = 0; i < arg1; i++) + { + for (j = 0; j < 2; j++) + { + easyChatWord = sub_811F578(var0++); + if (easyChatWord != 0xFFFF) + { + CopyEasyChatWordPadded(gUnknown_0203A11C->unkCC, easyChatWord, 0); + if (!sub_811BF88(easyChatWord)) + sub_811D028(2, 1, gUnknown_0203A11C->unkCC, (j * 13 + 3) * 8, y, 0xFF, NULL); + else + sub_811D058(2, 1, gUnknown_0203A11C->unkCC, (j * 13 + 3) * 8, y, 0xFF, 1, 5, 3); + } + } + + y += 16; + } + + CopyWindowToVram(2, 2); +} + +static void sub_811D950(u8 arg0, u8 arg1) +{ + int y; + int var0; + int var1; + int var2; + + y = (arg0 * 16 + 96) & 0xFF; + var2 = arg1 * 16; + var0 = y + var2; + if (var0 > 255) + { + var1 = var0 - 256; + var2 = 256 - y; + } + else + { + var1 = 0; + } + + FillWindowPixelRect(2, 0x11, 0, y, 224, var2); + if (var1) + FillWindowPixelRect(2, 0x11, 0, 0, 224, var1); +} + +static void sub_811D9B4(void) +{ + FillWindowPixelBuffer(2, 0x11); + CopyWindowToVram(2, 2); +} + +static void sub_811D9CC(int arg0) +{ + switch (arg0) + { + case 0: + gUnknown_0203A11C->unk6 = 0; + gUnknown_0203A11C->unk7 = 10; + break; + case 1: + gUnknown_0203A11C->unk6 = 9; + gUnknown_0203A11C->unk7 = 0; + break; + case 2: + gUnknown_0203A11C->unk6 = 11; + gUnknown_0203A11C->unk7 = 17; + break; + case 3: + gUnknown_0203A11C->unk6 = 17; + gUnknown_0203A11C->unk7 = 0; + break; + case 4: + gUnknown_0203A11C->unk6 = 17; + gUnknown_0203A11C->unk7 = 10; + break; + case 5: + gUnknown_0203A11C->unk6 = 18; + gUnknown_0203A11C->unk7 = 22; + break; + case 6: + gUnknown_0203A11C->unk6 = 22; + gUnknown_0203A11C->unk7 = 18; + break; + } + + gUnknown_0203A11C->unk8 = gUnknown_0203A11C->unk6 < gUnknown_0203A11C->unk7 ? 1 : -1; +} + +static bool8 sub_811DAA4(void) +{ + u8 var0, var1; + if (gUnknown_0203A11C->unk6 == gUnknown_0203A11C->unk7) + return FALSE; + + gUnknown_0203A11C->unk6 += gUnknown_0203A11C->unk8; + sub_811DADC(gUnknown_0203A11C->unk6); + var0 = gUnknown_0203A11C->unk6; + var1 = gUnknown_0203A11C->unk7; + return (var0 ^ var1) > 0; +} + +static void sub_811DADC(u8 arg0) +{ + FillBgTilemapBufferRect_Palette0(1, 0, 0, 10, 30, 10); + switch (arg0) + { + case 0: + break; + case 1: + sub_811DC28(11, 14, 3, 2); + break; + case 2: + sub_811DC28(9, 14, 7, 2); + break; + case 3: + sub_811DC28(7, 14, 11, 2); + break; + case 4: + sub_811DC28(5, 14, 15, 2); + break; + case 5: + sub_811DC28(3, 14, 19, 2); + break; + case 6: + sub_811DC28(1, 14, 23, 2); + break; + case 11: + sub_811DC28(1, 10, 24, 10); + break; + case 12: + sub_811DC28(1, 10, 25, 10); + break; + case 13: + sub_811DC28(1, 10, 26, 10); + break; + case 14: + sub_811DC28(1, 10, 27, 10); + break; + case 15: + sub_811DC28(1, 10, 28, 10); + break; + case 16: + sub_811DC28(1, 10, 29, 10); + break; + case 17: + sub_811DC28(0, 10, 30, 10); + break; + case 10: + case 18: + sub_811DC28(1, 10, 23, 10); + break; + case 9: + case 19: + sub_811DC28(1, 11, 23, 8); + break; + case 8: + case 20: + sub_811DC28(1, 12, 23, 6); + break; + case 7: + case 21: + sub_811DC28(1, 13, 23, 4); + break; + case 22: + sub_811DC28(1, 14, 23, 2); + break; + } + + CopyBgTilemapBufferToVram(1); +} + +static void sub_811DC28(int left, int top, int width, int height) +{ + u16 *tilemap; + int right; + int bottom; + int x, y; + + tilemap = gUnknown_0203A11C->unk300; + right = left + width - 1; + bottom = top + height - 1; + x = left; + y = top; + tilemap[y * 32 + x] = 0x4001; + x++; + for (; x < right; x++) + tilemap[y * 32 + x] = 0x4002; + + tilemap[y * 32 + x] = 0x4003; + y++; + for (; y < bottom; y++) + { + tilemap[y * 32 + left] = 0x4005; + x = left + 1; + for (; x < right; x++) + tilemap[y * 32 + x] = 0x4000; + + tilemap[y * 32 + x] = 0x4007; + } + + tilemap[y * 32 + left] = 0x4009; + x = left + 1; + for (; x < right; x++) + tilemap[y * 32 + x] = 0x400A; + + tilemap[y * 32 + x] = 0x400B; + sub_811DE5C((left + 1) * 8, (top + 1) * 8, (width - 2) * 8, (height - 2) * 8); +} + +static void sub_811DD84(void) +{ + ChangeBgY(2, 0x800, 0); + gUnknown_0203A11C->unk2CE = 0; +} + +static void sub_811DDAC(s16 arg0, u8 arg1) +{ + int bgY; + s16 var0; + + bgY = GetBgY(2); + gUnknown_0203A11C->unk2CE += arg0; + var0 = arg0 * 16; + bgY += var0 << 8; + if (arg1) + { + gUnknown_0203A11C->unk2D0 = bgY; + gUnknown_0203A11C->unk2D4 = arg1 * 256; + if (var0 < 0) + gUnknown_0203A11C->unk2D4 = -gUnknown_0203A11C->unk2D4; + } + else + { + ChangeBgY(2, bgY, 0); + } +} + +static bool8 sub_811DE10(void) +{ + int bgY; + + bgY = GetBgY(2); + if (bgY == gUnknown_0203A11C->unk2D0) + { + return FALSE; + } + else + { + ChangeBgY(2, gUnknown_0203A11C->unk2D4, 1); + return TRUE; + } +} + +static int sub_811DE48(void) +{ + return gUnknown_0203A11C->unk2CE; +} + +static void sub_811DE5C(u8 left, u8 top, u8 width, u8 height) +{ + u16 horizontalDimensions = WIN_RANGE(left, left + width); + u16 verticalDimensions = WIN_RANGE(top, top + height); + SetGpuReg(REG_OFFSET_WIN0H, horizontalDimensions); + SetGpuReg(REG_OFFSET_WIN0V, verticalDimensions); +} + +static void sub_811DE90(void) +{ + u32 i; + + LoadSpriteSheets(gUnknown_08597CA0); + LoadSpritePalettes(gUnknown_08597CC0); + for (i = 0; i < 4; i++) + LoadCompressedSpriteSheet(&gUnknown_08597CE8[i]); +} + +static void sub_811DEC4(void) +{ + u8 var0 = sub_811BA68(); + int x = gUnknown_08597C30[var0].unk0_0 * 8 + 13; + int y = gUnknown_08597C30[var0].unk0_5 * 8 + 8; + u8 spriteId = CreateSprite(&gUnknown_08597D18, x, y, 2); + gUnknown_0203A11C->unk2D8 = &gSprites[spriteId]; + gSprites[spriteId].data[1] = 1; +} + +void sub_811DF28(struct Sprite *sprite) +{ + if (sprite->data[1]) + { + if (++sprite->data[0] > 2) + { + sprite->data[0] = 0; + if (++sprite->pos2.x > 0) + sprite->pos2.x = -6; + } + } +} + +static void sub_811DF60(u8 x, u8 y) +{ + gUnknown_0203A11C->unk2D8->pos1.x = x; + gUnknown_0203A11C->unk2D8->pos1.y = y; + gUnknown_0203A11C->unk2D8->pos2.x = 0; + gUnknown_0203A11C->unk2D8->data[0] = 0; +} + +static void sub_811DF90(void) +{ + gUnknown_0203A11C->unk2D8->data[0] = 0; + gUnknown_0203A11C->unk2D8->data[1] = 0; + gUnknown_0203A11C->unk2D8->pos2.x = 0; +} + +static void sub_811DFB0(void) +{ + gUnknown_0203A11C->unk2D8->data[1] = 1; +} + +static void sub_811DFC8(void) +{ + u8 spriteId = CreateSprite(&gUnknown_08597D68, 0, 0, 3); + gUnknown_0203A11C->unk2DC = &gSprites[spriteId]; + gUnknown_0203A11C->unk2DC->pos2.x = 32; + + spriteId = CreateSprite(&gUnknown_08597D68, 0, 0, 3); + gUnknown_0203A11C->unk2E0 = &gSprites[spriteId]; + gUnknown_0203A11C->unk2E0->pos2.x = -32; + + gUnknown_0203A11C->unk2DC->hFlip = 1; + sub_811E088(); +} + +static void sub_811E050(void) +{ + DestroySprite(gUnknown_0203A11C->unk2DC); + gUnknown_0203A11C->unk2DC = NULL; + DestroySprite(gUnknown_0203A11C->unk2E0); + gUnknown_0203A11C->unk2E0 = NULL; +} + +static void sub_811E088(void) +{ + u8 var0; + u8 var1; + + if (gUnknown_0203A11C->unk2DC && gUnknown_0203A11C->unk2E0) + { + sub_811BB9C(&var0, &var1); + if (!sub_811BBB0()) + sub_811E0EC(var0, var1); + else + sub_811E1A4(var0, var1); + } +} + +static void sub_811E0EC(s8 arg0, s8 arg1) +{ + if (arg0 != -1) + { + StartSpriteAnim(gUnknown_0203A11C->unk2DC, 0); + gUnknown_0203A11C->unk2DC->pos1.x = arg0 * 84 + 58; + gUnknown_0203A11C->unk2DC->pos1.y = arg1 * 16 + 96; + + StartSpriteAnim(gUnknown_0203A11C->unk2E0, 0); + gUnknown_0203A11C->unk2E0->pos1.x = arg0 * 84 + 58; + gUnknown_0203A11C->unk2E0->pos1.y = arg1 * 16 + 96; + } + else + { + StartSpriteAnim(gUnknown_0203A11C->unk2DC, 1); + gUnknown_0203A11C->unk2DC->pos1.x = 216; + gUnknown_0203A11C->unk2DC->pos1.y = arg1 * 16 + 112; + + StartSpriteAnim(gUnknown_0203A11C->unk2E0, 1); + gUnknown_0203A11C->unk2E0->pos1.x = 216; + gUnknown_0203A11C->unk2E0->pos1.y = arg1 * 16 + 112; + } +} + +static void sub_811E1A4(s8 arg0, s8 arg1) +{ + int anim; + int x, y; + + if (arg0 != -1) + { + y = arg1 * 16 + 96; + x = 32; + if (arg0 == 6 && arg1 == 0) + { + x = 158; + anim = 2; + } + else + { + x += gUnknown_08597D08[(u8)arg0 < 7 ? arg0 : 0]; + anim = 3; + } + + StartSpriteAnim(gUnknown_0203A11C->unk2DC, anim); + gUnknown_0203A11C->unk2DC->pos1.x = x; + gUnknown_0203A11C->unk2DC->pos1.y = y; + + StartSpriteAnim(gUnknown_0203A11C->unk2E0, anim); + gUnknown_0203A11C->unk2E0->pos1.x = x; + gUnknown_0203A11C->unk2E0->pos1.y = y; + } + else + { + StartSpriteAnim(gUnknown_0203A11C->unk2DC, 1); + gUnknown_0203A11C->unk2DC->pos1.x = 216; + gUnknown_0203A11C->unk2DC->pos1.y = arg1 * 16 + 112; + + StartSpriteAnim(gUnknown_0203A11C->unk2E0, 1); + gUnknown_0203A11C->unk2E0->pos1.x = 216; + gUnknown_0203A11C->unk2E0->pos1.y = arg1 * 16 + 112; + } +} + +static void sub_811E288(void) +{ + u8 spriteId = CreateSprite(&gUnknown_08597D18, 0, 0, 4); + gUnknown_0203A11C->unk2E4 = &gSprites[spriteId]; + gUnknown_0203A11C->unk2E4->callback = sub_811E2DC; + gUnknown_0203A11C->unk2E4->oam.priority = 2; + sub_811E30C(); +} + +static void sub_811E2DC(struct Sprite *sprite) +{ + if (++sprite->data[0] > 2) + { + sprite->data[0] = 0; + if (++sprite->pos2.x > 0) + sprite->pos2.x = -6; + } +} + +static void sub_811E30C(void) +{ + s8 var0, var1, x, y; + + sub_811BBC8(&var0, &var1); + x = var0 * 13; + x = x * 8 + 28; + y = var1 * 16 + 96; + sub_811E34C(x, y); +} + +static void sub_811E34C(u8 x, u8 y) +{ + if (gUnknown_0203A11C->unk2E4) + { + gUnknown_0203A11C->unk2E4->pos1.x = x; + gUnknown_0203A11C->unk2E4->pos1.y = y; + gUnknown_0203A11C->unk2E4->pos2.x = 0; + gUnknown_0203A11C->unk2E4->data[0] = 0; + } +} + +static void sub_811E380(void) +{ + if (gUnknown_0203A11C->unk2E4) + { + DestroySprite(gUnknown_0203A11C->unk2E4); + gUnknown_0203A11C->unk2E4 = NULL; + } +} + +static void sub_811E3AC(void) +{ + u8 spriteId = CreateSprite(&gUnknown_08597DF0, 208, 128, 6); + gUnknown_0203A11C->unk2E8 = &gSprites[spriteId]; + gUnknown_0203A11C->unk2E8->pos2.x = -64; + + spriteId = CreateSprite(&gUnknown_08597DD0, 208, 80, 5); + gUnknown_0203A11C->unk2EC = &gSprites[spriteId]; + gUnknown_0203A11C->unk9 = 0; +} + +static bool8 sub_811E418(void) +{ + switch (gUnknown_0203A11C->unk9) + { + default: + return FALSE; + case 0: + gUnknown_0203A11C->unk2E8->pos2.x += 8; + if (gUnknown_0203A11C->unk2E8->pos2.x >= 0) + { + gUnknown_0203A11C->unk2E8->pos2.x = 0; + if (!sub_811BBB0()) + StartSpriteAnim(gUnknown_0203A11C->unk2EC, 1); + else + StartSpriteAnim(gUnknown_0203A11C->unk2EC, 2); + + gUnknown_0203A11C->unk9++; + } + break; + case 1: + if (gUnknown_0203A11C->unk2EC->animEnded) + { + gUnknown_0203A11C->unk9 = 2; + return FALSE; + } + } + + return TRUE; +} + +static void sub_811E4AC(void) +{ + gUnknown_0203A11C->unk9 = 0; + StartSpriteAnim(gUnknown_0203A11C->unk2EC, 3); +} + +static bool8 sub_811E4D0(void) +{ + switch (gUnknown_0203A11C->unk9) + { + default: + return FALSE; + case 0: + if (gUnknown_0203A11C->unk2EC->animEnded) + gUnknown_0203A11C->unk9 = 1; + break; + case 1: + gUnknown_0203A11C->unk2E8->pos2.x -= 8; + if (gUnknown_0203A11C->unk2E8->pos2.x <= -64) + { + DestroySprite(gUnknown_0203A11C->unk2EC); + DestroySprite(gUnknown_0203A11C->unk2E8); + gUnknown_0203A11C->unk2EC = NULL; + gUnknown_0203A11C->unk2E8 = NULL; + gUnknown_0203A11C->unk9++; + return FALSE; + } + } + + return TRUE; +} + +static void sub_811E55C(void) +{ + StartSpriteAnim(gUnknown_0203A11C->unk2EC, 4); +} + +static void sub_811E578(void) +{ + if (!sub_811BBB0()) + StartSpriteAnim(gUnknown_0203A11C->unk2EC, 1); + else + StartSpriteAnim(gUnknown_0203A11C->unk2EC, 2); +} + +static bool8 sub_811E5B8(void) +{ + return !gUnknown_0203A11C->unk2EC->animEnded; +} + +static void sub_811E5D4(void) +{ + u8 spriteId = CreateSprite(&gUnknown_08597E48, 96, 80, 0); + if (spriteId != MAX_SPRITES) + gUnknown_0203A11C->unk2F0 = &gSprites[spriteId]; + + spriteId = CreateSprite(&gUnknown_08597E48, 96, 156, 0); + if (spriteId != MAX_SPRITES) + { + gUnknown_0203A11C->unk2F4 = &gSprites[spriteId]; + gUnknown_0203A11C->unk2F4->vFlip = 1; + } + + sub_811E6B0(); +} + +static void sub_811E64C(void) +{ + gUnknown_0203A11C->unk2F0->invisible = !sub_811BBF8(); + gUnknown_0203A11C->unk2F4->invisible = !sub_811BC2C(); +} + +static void sub_811E6B0(void) +{ + gUnknown_0203A11C->unk2F0->invisible = 1; + gUnknown_0203A11C->unk2F4->invisible = 1; +} + +static void sub_811E6E0(int arg0) +{ + if (!arg0) + { + gUnknown_0203A11C->unk2F0->pos1.x = 96; + gUnknown_0203A11C->unk2F4->pos1.x = 96; + } + else + { + gUnknown_0203A11C->unk2F0->pos1.x = 120; + gUnknown_0203A11C->unk2F4->pos1.x = 120; + } +} + +static void sub_811E720(void) +{ + u8 spriteId = CreateSprite(&gUnknown_08597E30, 220, 84, 1); + if (spriteId != MAX_SPRITES) + gUnknown_0203A11C->unk2F8 = &gSprites[spriteId]; + + spriteId = CreateSprite(&gUnknown_08597E30, 220, 156, 1); + if (spriteId != MAX_SPRITES) + { + gUnknown_0203A11C->unk2FC = &gSprites[spriteId]; + StartSpriteAnim(gUnknown_0203A11C->unk2FC, 1); + } + + sub_811E7F8(); +} + +static void sub_811E794(void) +{ + gUnknown_0203A11C->unk2F8->invisible = !sub_811BBF8(); + gUnknown_0203A11C->unk2FC->invisible = !sub_811BC2C(); +} + +static void sub_811E7F8(void) +{ + gUnknown_0203A11C->unk2F8->invisible = 1; + gUnknown_0203A11C->unk2FC->invisible = 1; +} + +static void sub_811E828(void) +{ + int graphicsId; + u8 spriteId; + + switch (sub_811BCBC()) + { + case 0: + graphicsId = EVENT_OBJ_GFX_REPORTER_M; + break; + case 1: + graphicsId = EVENT_OBJ_GFX_REPORTER_F; + break; + case 2: + graphicsId = EVENT_OBJ_GFX_BOY_1; + break; + default: + return; + } + + if (sub_811BA68() != 4) + return; + + spriteId = AddPseudoEventObject(graphicsId, SpriteCallbackDummy, 76, 40, 0); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].oam.priority = 0; + StartSpriteAnim(&gSprites[spriteId], 2); + } + + spriteId = AddPseudoEventObject( + gSaveBlock2Ptr->playerGender == MALE ? EVENT_OBJ_GFX_RIVAL_BRENDAN_NORMAL : EVENT_OBJ_GFX_RIVAL_MAY_NORMAL, + SpriteCallbackDummy, + 52, + 40, + 0); + + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].oam.priority = 0; + StartSpriteAnim(&gSprites[spriteId], 3); + } +} + +int sub_811E8E4(void) +{ + u8 var0 = sub_811BA68(); + switch (gUnknown_08597C30[var0].unk3) + { + case 1: + return 1; + case 2: + return 2; + case 0: + return 0; + default: + return 3; + } +} + +static int sub_811E920(int arg0) +{ + int var0 = sub_811E8E4(); + if (var0 < 3) + return gUnknown_08597E60[var0][arg0] + 4; + else + return 0; +} diff --git a/src/pokenav.c b/src/pokenav.c index ff687e8dc..d09c3da94 100644 --- a/src/pokenav.c +++ b/src/pokenav.c @@ -13,26 +13,45 @@ #include "bg.h" #include "menu.h" #include "graphics.h" +#include "dma3.h" #include "gba/macro.h" #include "decompress.h" #include "strings.h" #include "constants/rgb.h" +enum +{ + MODE_NORMAL, // Chosen from Start menu. + MODE_FORCE_CALL_1, // Used for the script's special. Has to choose Match Call and make a call. + MODE_FORCE_CALL_2, // Set after making a call, has to exit Pokenav. +}; + #define UNKNOWN_OFFSET 100000 +struct UnknownSubStruct_0203CF40 +{ + void (*unk0)(u32); + u32 (*unk4)(void); + u32 unk8; + u32 unkC; + u32 unk10; + u32 unk14; + struct Sprite *unk18; + struct Sprite *unk1C[2]; + struct Sprite *unk24[2]; + u8 tilemapBuffer[0x1000]; +}; + +#define SUBSTRUCT_COUNT 19 + struct UnknownStruct_0203CF40 { u32 (*field0)(void); u32 field4; - u16 field8; + u16 mode; u16 fieldA; - u32 fieldC; - void *field10[19]; -}; - -struct UnknownStruct_sub_81C76C4 -{ - u32 data[523]; + bool32 hasAnyRibbons; + struct UnknownSubStruct_0203CF40 *field10[SUBSTRUCT_COUNT]; }; extern u32 sub_81C9430(void); @@ -101,34 +120,42 @@ extern u32 sub_81CFE08(void); u32 sub_81C791C(s32 a0); bool32 sub_81C756C(u32 a0); bool32 sub_81C76C4(void); -u32 AnyMonHasRibbon(void); +static bool32 AnyMonHasRibbon(void); u32 sub_81C75E0(void); u32 sub_81C75D4(void); u32 sub_81C76FC(void); u32 sub_81C786C(void); u32 sub_81C7764(s32 a0); -u32 atk47_cmd47(s32 a0); +u32 sub_81C78D4(s32 a0); bool32 sub_81C7738(void); void CopyPaletteIntoBufferUnfaded(const u16 *palette, u32 a1, u32 a2); -void sub_81C7834(u32 (*a0)(void), u32(*a1)(void)); -void sub_81C7360(struct UnknownStruct_0203CF40 *a0); -void sub_81C7650(u32 index); +void sub_81C7834(void *func1, void *func2); +static void InitMainStruct(struct UnknownStruct_0203CF40 *a0); +void FreeSubstruct(u32 index); void sub_81C7850(u32 a0); void sub_81C7BF8(u32 a0); void sub_81C71E4(u8 a0); -void sub_81C7170(u8 a0); +void sub_81C7170(u8 taskId); void sub_81C742C(u8 taskId); void sub_81C7710(void); -void sub_81C75F4(void); -void sub_81C7334(void); -void sub_81C7418(void); -void sub_81C7400(void); +static void InitKeys_(void); +static void FreeVars(void); +static void VblankCb_Pokenav(void); +static void Cb2_Pokenav(void); void sub_81C7C28(void); void sub_81C72BC(void); void sub_81C7B74(void); void sub_81C7C94(void); - - +void sub_81C7F24(u32 arg0); +void sub_81C7E58(u32 arg0); +void sub_81C8110(bool32 arg0); +void sub_81C80D4(bool32 arg0); +void sub_81C803C(u32 arg0, bool32 arg1); +void sub_81C8088(u32 arg0, bool32 arg1); +void sub_81C814C(struct Sprite *sprite, s32 arg1, s32 arg2, s32 arg3); +void sub_81C817C(struct Sprite *sprite); + +// Const rom data. u32 (*const gUnknown_0861F3EC[15][7])(void) = { { @@ -272,15 +299,17 @@ const u16 gUnknown_0861F590[] = INCBIN_U16("graphics/pokenav/icon2.gbapal"); const u32 gUnknown_0861F5B0[] = INCBIN_U32("graphics/pokenav/icon2.4bpp.lz"); const u32 gUnknown_0861F994[] = INCBIN_U32("graphics/pokenav/icon2_unused.4bpp.lz"); -const struct BgTemplate gUnknown_0861FA04 = +const struct BgTemplate gUnknown_0861FA04[] = { - .bg = 0, - .charBaseIndex = 0, - .mapBaseIndex = 5, - .screenSize = 0, - .paletteMode = 0, - .priority = 0, - .baseTile = 0, + { + .bg = 0, + .charBaseIndex = 0, + .mapBaseIndex = 5, + .screenSize = 0, + .paletteMode = 0, + .priority = 0, + .baseTile = 0, + } }; const struct WindowTemplate gUnknown_0861FA08[2] = @@ -305,7 +334,7 @@ const struct WindowTemplate gUnknown_0861FA08[2] = }, }; -const u8 *const (MenuButtonReminders[12]) = +const u8 *const (sMenuButtonReminders[12]) = { gText_Navgear_ClearButtonList, gText_NavgearMap_ZoomedOutButtons, @@ -341,10 +370,6 @@ const struct SpritePalette gUnknown_0861FA54[2] = .data = gUnknown_0861F590, .tag = 0, }, - { - .data = NULL, - .tag = 0, - } }; const struct CompressedSpriteSheet gUnknown_0861FA64 = @@ -358,16 +383,17 @@ extern struct UnknownStruct_0203CF40 *gUnknown_0203CF40; extern u8 gUnknown_0203CF3C; extern const struct SpriteTemplate gUnknown_0861FB04; -u32 sub_81C7078(u32 (*a0)(s32), u32 a1) +// code +u32 sub_81C7078(u32 (*func)(s32), u32 priority) { u16 taskId; if (!is_c1_link_related_active()) - taskId = CreateTask(sub_81C7170, a1); + taskId = CreateTask(sub_81C7170, priority); else - taskId = CreateTask(sub_81C71E4, a1); + taskId = CreateTask(sub_81C71E4, priority); - SetWordTaskArg(taskId, 1, (u32)a0); + SetWordTaskArg(taskId, 1, (u32)func); gTasks[taskId].data[3] = gUnknown_0203CF3C; return ((gUnknown_0203CF3C++) << 16) | taskId; @@ -375,62 +401,52 @@ u32 sub_81C7078(u32 (*a0)(s32), u32 a1) bool32 sub_81C70D8(u32 a0) { - u32 v1 = a0 & 0xFFFF; + u32 taskId = a0 & 0xFFFF; u32 v2 = a0 >> 16; - if (gTasks[v1].isActive - && (gTasks[v1].func == sub_81C7170 || gTasks[v1].func == sub_81C71E4) - && gTasks[v1].data[3] == v2) - { - + + if (gTasks[taskId].isActive + && (gTasks[taskId].func == sub_81C7170 || gTasks[taskId].func == sub_81C71E4) + && gTasks[taskId].data[3] == v2) return TRUE; - } else - { return FALSE; - } } bool32 sub_81C7124(u32 a0) { s32 i; - for (i = 0; i < 16; i++) + for (i = 0; i < NUM_TASKS; i++) { if (gTasks[i].isActive - && (gTasks[i].func == sub_81C7170 || gTasks[i].func == sub_81C71E4)) - { - u32 arg = GetWordTaskArg((u8)i, 1); - if (arg == a0) - return TRUE; - } + && (gTasks[i].func == sub_81C7170 || gTasks[i].func == sub_81C71E4) + && GetWordTaskArg(i, 1) == a0) + return TRUE; } return FALSE; } void sub_81C7170(u8 taskId) { - s16 *dataPtr; - u32 (*func)(u32); - bool32 exitLoop; + u32 (*func)(s32) = (void *)GetWordTaskArg(taskId, 1); + s16 *data = gTasks[taskId].data; + bool32 exitLoop = FALSE; - func = (u32 (*)(u32))GetWordTaskArg(taskId, 1); - dataPtr = gTasks[taskId].data; - exitLoop = FALSE; while (!exitLoop) { - u32 v1 =((u32 (*)(u32))func)(dataPtr[0]); - switch (v1) + u32 var = func(data[0]); + switch (var) { case 1: - dataPtr[0] = dataPtr[0] + 1; + data[0] = data[0] + 1; break; case 0: - dataPtr[0]++; + data[0]++; return; case 4: DestroyTask(taskId); return; default: - dataPtr[0] = v1 - 5; + data[0] = var - 5; break; case 3: break; @@ -471,91 +487,81 @@ void sub_81C71E4(u8 taskId) void CB2_PokeNav(void) { - gUnknown_0203CF40 = Alloc(sizeof(struct UnknownStruct_0203CF40)); + gUnknown_0203CF40 = Alloc(sizeof(*gUnknown_0203CF40)); if (gUnknown_0203CF40 == NULL) { SetMainCallback2(CB2_ReturnToFieldWithOpenMenu); } else { - sub_81C7360(gUnknown_0203CF40); + InitMainStruct(gUnknown_0203CF40); ResetTasks(); SetVBlankCallback(NULL); CreateTask(sub_81C742C, 0); - SetMainCallback2(sub_81C7400); - SetVBlankCallback(sub_81C7418); + SetMainCallback2(Cb2_Pokenav); + SetVBlankCallback(VblankCb_Pokenav); } } -void sub_81C72A4() +void sub_81C72A4(void) { SetMainCallback2(sub_81C72BC); FadeScreen(1, 0); } -void sub_81C72BC() +void sub_81C72BC(void) { UpdatePaletteFade(); - if (!gPaletteFade.active) + if (gPaletteFade.active) + return; + + gUnknown_0203CF40 = Alloc(sizeof(*gUnknown_0203CF40)); + if (gUnknown_0203CF40 == NULL) { - gUnknown_0203CF40 = Alloc(sizeof(struct UnknownStruct_0203CF40)); - if (gUnknown_0203CF40 == NULL) - { - SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic); - } - else - { - sub_81C7360(gUnknown_0203CF40); - gUnknown_0203CF40->field8 = 1; - ResetTasks(); - ResetSpriteData(); - FreeAllSpritePalettes(); - SetVBlankCallback(NULL); - CreateTask(sub_81C742C, 0); - SetMainCallback2(sub_81C7400); - SetVBlankCallback(sub_81C7418); - } + SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic); + } + else + { + InitMainStruct(gUnknown_0203CF40); + gUnknown_0203CF40->mode = MODE_FORCE_CALL_1; + ResetTasks(); + ResetSpriteData(); + FreeAllSpritePalettes(); + SetVBlankCallback(NULL); + CreateTask(sub_81C742C, 0); + SetMainCallback2(Cb2_Pokenav); + SetVBlankCallback(VblankCb_Pokenav); } } -void sub_81C7334() +static void FreeVars(void) { s32 i; - for (i = 0; i < 19; i++) - { - sub_81C7650(i); - } - Free(gUnknown_0203CF40); - gUnknown_0203CF40 = NULL; + for (i = 0; i < SUBSTRUCT_COUNT; i++) + FreeSubstruct(i); + + FREE_AND_SET_NULL(gUnknown_0203CF40); InitKeys(); } // Clears UnknownStruct_0203CF40 -void sub_81C7360(struct UnknownStruct_0203CF40 *a0) +static void InitMainStruct(struct UnknownStruct_0203CF40 *a0) { s32 i; - void **arrayPtr; - void *fill; - fill = NULL; - i = 18; - arrayPtr = &(a0->field10[18]); - for (i; i >= 0; i--) - { - *arrayPtr = fill; - arrayPtr -= 1; - } - a0->field8 = 0; + for (i = 0; i < SUBSTRUCT_COUNT; i++) + a0->field10[i] = NULL; + + a0->mode = MODE_NORMAL; a0->field4 = 0; - a0->fieldC = AnyMonHasRibbon(); + a0->hasAnyRibbons = AnyMonHasRibbon(); a0->field0 = NULL; } -bool32 AnyMonHasRibbon() +static bool32 AnyMonHasRibbon(void) { - s32 i; - s32 j; + s32 i, j; for (i = 0; i < PARTY_SIZE; i++) { @@ -569,7 +575,7 @@ bool32 AnyMonHasRibbon() for (j = 0; j < TOTAL_BOXES_COUNT; j++) { - for (i = 0; i < IN_BOX_COUNT; i++) + for (i = 0; i < IN_BOX_COUNT; i++) { if (CheckBoxMonSanityAt(j, i) && GetBoxMonDataAt(j, i, MON_DATA_RIBBON_COUNT) != 0) @@ -582,7 +588,7 @@ bool32 AnyMonHasRibbon() return FALSE; } -void sub_81C7400() +static void Cb2_Pokenav(void) { RunTasks(); AnimateSprites(); @@ -590,7 +596,7 @@ void sub_81C7400() UpdatePaletteFade(); } -void sub_81C7418() +static void VblankCb_Pokenav(void) { TransferPlttBuffer(); LoadOam(); @@ -599,34 +605,31 @@ void sub_81C7418() void sub_81C742C(u8 taskId) { - s16 *dataPtr; u32 v1; - bool32 v2; - - dataPtr = gTasks[taskId].data; + s16 *data = gTasks[taskId].data; - switch (dataPtr[0]) + switch (data[0]) { case 0: sub_81C76C4(); - dataPtr[0] = 1; + data[0] = 1; break; case 1: if (sub_81C76FC()) break; sub_81C756C(UNKNOWN_OFFSET); - dataPtr[0] = 4; + data[0] = 4; break; case 2: if (sub_81C786C()) break; - dataPtr[0] = 3; + data[0] = 3; case 3: v1 = sub_81C75E0(); if (v1 == -1) { sub_81C7710(); - dataPtr[0] = 5; + data[0] = 5; } else if (v1 >= UNKNOWN_OFFSET) { @@ -634,32 +637,33 @@ void sub_81C742C(u8 taskId) gUnknown_0861F3EC[gUnknown_0203CF40->field4][5](); if (sub_81C756C(v1)) { - dataPtr[0] = 4; + data[0] = 4; } else { sub_81C7710(); - dataPtr[0] = 5; + data[0] = 5; } } else if (v1 != 0) { sub_81C7850(v1); if (sub_81C786C()) - dataPtr[0] = 2; + data[0] = 2; } break; case 4: if (!sub_81C75D4()) - dataPtr[0] = 3; + data[0] = 3; break; case 5: if (!sub_81C7738()) { - v2 = gUnknown_0203CF40->field8 != 0; + bool32 calledFromScript = (gUnknown_0203CF40->mode != MODE_NORMAL); + sub_81C9430(); - sub_81C7334(); - if (v2) + FreeVars(); + if (calledFromScript) SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic); else SetMainCallback2(CB2_ReturnToFieldWithOpenMenu); @@ -670,14 +674,14 @@ void sub_81C742C(u8 taskId) bool32 sub_81C756C(u32 a0) { - u32 index; + u32 index = a0 - UNKNOWN_OFFSET; - index = a0 - UNKNOWN_OFFSET; - sub_81C75F4(); + InitKeys_(); if (!gUnknown_0861F3EC[index][0]()) return FALSE; if (!gUnknown_0861F3EC[index][2]()) return FALSE; + sub_81C7834(gUnknown_0861F3EC[index][3], gUnknown_0861F3EC[index][4]); gUnknown_0203CF40->field0 = gUnknown_0861F3EC[index][1]; gUnknown_0203CF40->field4 = index; @@ -694,52 +698,52 @@ u32 sub_81C75E0(void) return gUnknown_0203CF40->field0(); } -void sub_81C75F4(void) +static void InitKeys_(void) { InitKeys(); } -void IndirectSetVBlankCallback(IntrCallback callback) +void SetVBlankCallback_(IntrCallback callback) { SetVBlankCallback(callback); } -void sub_81C760C(void) +void SetPokenavVBlankCallback(void) { - SetVBlankCallback(sub_81C7418); + SetVBlankCallback(VblankCb_Pokenav); } -void *sub_81C761C(u32 index, u32 size) +void *AllocSubstruct(u32 index, u32 size) { - return gUnknown_0203CF40->field10[index] = (void*)Alloc(size); + return gUnknown_0203CF40->field10[index] = Alloc(size); } -void *sub_81C763C(u32 index) +struct UnknownSubStruct_0203CF40 *GetSubstructPtr(u32 index) { return gUnknown_0203CF40->field10[index]; } -void sub_81C7650(u32 index) +void FreeSubstruct(u32 index) { if (gUnknown_0203CF40->field10[index] != NULL) FREE_AND_SET_NULL(gUnknown_0203CF40->field10[index]); } -u16 sub_81C767C(void) +u16 GetPokenavMode(void) { - return gUnknown_0203CF40->field8; + return gUnknown_0203CF40->mode; } -void sub_81C7688(u16 a0) +void SetPokenavMode(u16 mode) { - gUnknown_0203CF40->field8 = a0; + gUnknown_0203CF40->mode = mode; } void sub_81C7694(u32 a0) { - u32 value; - value = a0; - if (a0 > 4) + u32 value = a0; + + if (value > 4) value = 0; gUnknown_0203CF40->fieldA = value; } @@ -749,34 +753,27 @@ u16 sub_81C76AC(void) return gUnknown_0203CF40->fieldA; } -u32 sub_81C76B8(void) +bool32 CanViewRibbonsMenu(void) { - return gUnknown_0203CF40->fieldC; + return gUnknown_0203CF40->hasAnyRibbons; } bool32 sub_81C76C4(void) { - struct UnknownStruct_sub_81C76C4 *v1; - - v1 = (struct UnknownStruct_sub_81C76C4*)sub_81C761C(0, sizeof(struct UnknownStruct_sub_81C76C4)); - if (v1 == NULL) - { + struct UnknownSubStruct_0203CF40 *structPtr = AllocSubstruct(0, 0x82C); + if (structPtr == NULL) return FALSE; - } - else - { - ResetSpriteData(); - FreeAllSpritePalettes(); - v1->data[3] = sub_81C7078(sub_81C7764, 1); - return TRUE; - } + + ResetSpriteData(); + FreeAllSpritePalettes(); + structPtr->unkC = sub_81C7078(sub_81C7764, 1); + return TRUE; } u32 sub_81C76FC(void) { - u32 *v1; - v1 = sub_81C763C(0); - return sub_81C70D8(v1[3]); + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + return sub_81C70D8(structPtr->unkC); } void sub_81C7710(void) @@ -794,15 +791,14 @@ bool32 sub_81C7738(void) sub_81C7C94(); FreeAllWindowBuffers(); return FALSE; - } else - { - return TRUE; } + + return TRUE; } u32 sub_81C7764(s32 a0) { - u32 *v1; + struct UnknownSubStruct_0203CF40 *structPtr; switch (a0) { @@ -810,14 +806,14 @@ u32 sub_81C7764(s32 a0) SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP); FreeAllWindowBuffers(); ResetBgsAndClearDma3BusyFlags(0); - InitBgsFromTemplates(0, &gUnknown_0861FA04, 1); + InitBgsFromTemplates(0, gUnknown_0861FA04, ARRAY_COUNT(gUnknown_0861FA04)); sub_8199D98(); reset_temp_tile_data_buffers(); return 1; case 1: - v1 = sub_81C763C(0); + structPtr = GetSubstructPtr(0); decompress_and_copy_tile_data_to_vram(0, &gPokenavHeader_Gfx, 0, 0, 0); - SetBgTilemapBuffer(0, &v1[11]); + SetBgTilemapBuffer(0, structPtr->tilemapBuffer); CopyToBgTilemapBuffer(0, &gPokenavHeader_Tilemap, 0, 0); CopyPaletteIntoBufferUnfaded(gPokenavHeader_Pal, 0, 0x20); CopyBgTilemapBufferToVram(0); @@ -825,7 +821,7 @@ u32 sub_81C7764(s32 a0) case 2: if (free_temp_tile_data_buffers_if_possible()) return 2; - + sub_81C7B74(); return 0; case 3: @@ -841,58 +837,46 @@ u32 sub_81C7764(s32 a0) } } -void sub_81C7834(u32 (*a0)(void), u32(*a1)(void)) +void sub_81C7834(void *func1, void *func2) // Fix types later. { - u32 (**v1)(void); - - v1 = sub_81C763C(0); - v1[0] = a0; - v1[1] = a1; - v1[2] = NULL; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + structPtr->unk0 = func1; + structPtr->unk4 = func2; + structPtr->unk8 = 0; } void sub_81C7850(u32 a0) { - void (**v1)(u32); - - v1 = sub_81C763C(0); - v1[2] = NULL; - v1[0](a0); + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + structPtr->unk8 = 0; + structPtr->unk0(a0); } u32 sub_81C786C(void) { - u32 (**v1)(void); - - v1 = sub_81C763C(0); - return v1[1](); + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + return structPtr->unk4(); } void sub_81C7880(void) { - u32 *v1; - - v1 = sub_81C763C(0); - v1[3] = sub_81C7078(atk47_cmd47, 4); + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + structPtr->unkC = sub_81C7078(sub_81C78D4, 4); } void sub_81C78A0(void) { - u32 *v1; - - v1 = sub_81C763C(0); - v1[3] = sub_81C7078(sub_81C791C, 4); + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + structPtr->unkC = sub_81C7078(sub_81C791C, 4); } bool32 sub_81C78C0(void) { - u32 *v1; - - v1 = sub_81C763C(0); - return sub_81C70D8(v1[3]); + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + return sub_81C70D8(structPtr->unkC); } -u32 atk47_cmd47(s32 a0) +u32 sub_81C78D4(s32 a0) { switch (a0) { @@ -903,12 +887,12 @@ u32 atk47_cmd47(s32 a0) case 0: return 0; case 2: - if ((u32)ChangeBgY(0, 384, 1) >= 0x2000) + if (ChangeBgY(0, 384, 1) >= 0x2000u) { ChangeBgY(0, 0x2000, 0); return 4; } - + return 2; } } @@ -923,7 +907,8 @@ u32 sub_81C791C(s32 a0) return 2; } -void CopyPaletteIntoBufferUnfaded(const u16 *palette, u32 bufferOffset, u32 size) { +void CopyPaletteIntoBufferUnfaded(const u16 *palette, u32 bufferOffset, u32 size) +{ CpuCopy16(palette, gPlttBufferUnfaded + bufferOffset, size); } @@ -932,7 +917,7 @@ void sub_81C795C(const struct SpritePalette *palettes) const struct SpritePalette *current; u32 index; - for (current = palettes; current->data != NULL; current++) + for (current = palettes; current->data != NULL; current++) { index = AllocSpritePalette(current->tag); if (index == 0xFF) @@ -953,7 +938,7 @@ void sub_81C7990(u32 a0, u16 a1) } __attribute__((naked)) -void sub_81C79BC(u16 *a0, u16 *a1, u32 a2, u32 a3, u32 unused, u32 a5, u32 a6) +void sub_81C79BC(u16 *a0, u16 *a1, u32 a2, u32 a3, u32 a4, u32 a5) { asm(".syntax unified\n\ push {r4-r7,lr}\n\ @@ -1090,15 +1075,15 @@ _081C7AAE:\n\ void sub_81C7AC0(s32 a0) { - u32 *v1; - v1 = sub_81C763C(0); + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + switch (a0) { case 0: - BeginNormalPaletteFade(v1[5], -2, 0, 16, RGB_BLACK); + BeginNormalPaletteFade(structPtr->unk14, -2, 0, 16, RGB_BLACK); break; case 1: - BeginNormalPaletteFade(v1[5], -2, 16, 0, RGB_BLACK); + BeginNormalPaletteFade(structPtr->unk14, -2, 16, 0, RGB_BLACK); break; case 2: BeginNormalPaletteFade(0xFFFFFFFF, -2, 0, 16, RGB_BLACK); @@ -1119,93 +1104,330 @@ void sub_81C7B40(void) BlendPalettes(0xFFFEFFFE, 16, RGB_BLACK); } -void sub_81C7B54(const struct BgTemplate *a0, s32 a1) +void InitBgTemplates(const struct BgTemplate *templates, s32 count) { s32 i; - if (a1 <= 0) - return; - for (i = a1; i != 0; i--) - { - InitBgFromTemplate(a0++); - } + + for (i = 0; i < count; i++) + InitBgFromTemplate(templates++); } void sub_81C7B74(void) { - u32 *v1; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); - v1 = sub_81C763C(0); InitWindows(&gUnknown_0861FA08[0]); - v1[4] = 0; - sub_81C7BF8(0); - PutWindowTilemap(v1[4]); - CopyWindowToVram(v1[4], 3); // TODO: Use a defined constant here. + structPtr->unk10 = 0; + sub_81C7BF8(structPtr->unk10); + PutWindowTilemap(structPtr->unk10); + CopyWindowToVram(structPtr->unk10, 3); // TODO: Use a defined constant here. } void sub_81C7BA4(u32 a0) { - u32 *v1; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); - v1 = sub_81C763C(0); - sub_81C7BF8(v1[4]); - AddTextPrinterParameterized3(v1[4], 1, 0, 1, gMenuButtonReminderColor, 0, MenuButtonReminders[a0]); + sub_81C7BF8(structPtr->unk10); + AddTextPrinterParameterized3(structPtr->unk10, 1, 0, 1, gMenuButtonReminderColor, 0, sMenuButtonReminders[a0]); } -bool8 sub_81C7BE8(void) +bool32 IsDma3ManagerBusyWithBgCopy_(void) { return IsDma3ManagerBusyWithBgCopy(); } -void sub_81C7BF8(u32 a0) +void sub_81C7BF8(u32 windowId) { - FillWindowPixelBuffer(a0, 0x44); - FillWindowPixelRect(a0, 0x55, 0, 0, 0x80, 1); + FillWindowPixelBuffer(windowId, 0x44); + FillWindowPixelRect(windowId, 0x55, 0, 0, 0x80, 1); } void sub_81C7C28(void) { - u32 *v1; - u32 i; - u8 v2; - u32 v3; - u32 v4; + s32 i; u8 spriteId; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); - v1 = sub_81C763C(0); for (i = 0; i < ARRAY_COUNT(gUnknown_0861FA4C); i++) - { LoadCompressedSpriteSheet(&gUnknown_0861FA4C[i]); - } sub_81C795C(gUnknown_0861FA54); - v2 = IndexOfSpritePaletteTag(0); - v1[5] = ~1 & ~(0x10000 << v2); + structPtr->unk14 = ~1 & ~(0x10000 << IndexOfSpritePaletteTag(0)); spriteId = CreateSprite(&gUnknown_0861FB04, 220, 12, 0); - v1[6] = (u32)(&gSprites[spriteId]); + structPtr->unk18 = &gSprites[spriteId]; } void sub_81C7C94(void) { - void **v1; - v1 = sub_81C763C(0); - DestroySprite(v1[6]); + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + DestroySprite(structPtr->unk18); FreeSpriteTilesByTag(0); FreeSpritePaletteByTag(0); } -void sub_81C7CB4(u16 *a0) +void sub_81C7CB4(struct Sprite *sprite) { - u32 v1; - v1 = GetBgY(0); - a0[19] = (v1 >> 8) * -1; + sprite->pos2.y = (GetBgY(0) / 256u) * -1; } struct Sprite *sub_81C7CCC(void) { - struct Sprite **v1; - struct Sprite *v2; - v1 = sub_81C763C(0); - v2 = v1[6]; - v2->callback = SpriteCallbackDummy; - return v2; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + structPtr->unk18->callback = SpriteCallbackDummy; + return structPtr->unk18; +} + +void sub_81C7CE4(void) +{ + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + structPtr->unk18->pos1.x = 220; + structPtr->unk18->pos1.y = 12; + structPtr->unk18->callback = sub_81C7CB4; + structPtr->unk18->invisible = FALSE; + structPtr->unk18->oam.priority = 0; + structPtr->unk18->subpriority = 0; +} + +extern const struct SpriteTemplate gUnknown_0861FB2C; +extern const struct SpriteTemplate gUnknown_0861FB44; +extern const struct CompressedSpriteSheet gUnknown_0861FA6C[]; + +void sub_81C7D28(void) +{ + s32 i, spriteId; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + LoadCompressedSpriteSheet(&gUnknown_0861FA64); + AllocSpritePalette(1); + AllocSpritePalette(2); + for (i = 0; i < 2; i++) + { + spriteId = CreateSprite(&gUnknown_0861FB2C, 0, 0, 1); + structPtr->unk1C[i] = &gSprites[spriteId]; + structPtr->unk1C[i]->invisible = TRUE; + structPtr->unk1C[i]->pos2.x = i * 64; + + spriteId = CreateSprite(&gUnknown_0861FB44, 0, 0, 2); + structPtr->unk24[i] = &gSprites[spriteId]; + structPtr->unk24[i]->invisible = TRUE; + structPtr->unk24[i]->pos2.x = i * 32; + structPtr->unk24[i]->pos2.y = 18; + structPtr->unk24[i]->oam.tileNum += (i * 8) + 64; + } +} + +void sub_81C7DFC(u32 arg0) +{ + if (arg0 < 6) + sub_81C7E58(arg0); + else + sub_81C7F24(arg0 - 6); +} + +void sub_81C7E14(u32 arg0) +{ + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + if (arg0 == 4) + structPtr->unk1C[1]->oam.tileNum = GetSpriteTileStartByTag(2) + 32; + else + structPtr->unk1C[1]->oam.tileNum = GetSpriteTileStartByTag(2) + 64; +} + +void sub_81C7E58(u32 arg0) +{ + struct UnknownSubStruct_0203CF40 *structPtr; + u32 size, tag; + + if (arg0 >= 6) + return; + + structPtr = GetSubstructPtr(0); + tag = gUnknown_0861FA6C[arg0].tag; + size = GetDecompressedDataSize(gUnknown_0861FA6C[arg0].data); + LoadPalette(&gPokenavLeftHeader_Pal[tag * 16], (IndexOfSpritePaletteTag(1) * 16) + 0x100, 0x20); + LZ77UnCompWram(gUnknown_0861FA6C[arg0].data, gDecompressionBuffer); + RequestDma3Copy(gDecompressionBuffer, (void *)VRAM + 0x10000 + (GetSpriteTileStartByTag(2) * 32), size, 1); + structPtr->unk1C[1]->oam.tileNum = GetSpriteTileStartByTag(2) + gUnknown_0861FA6C[arg0].size; + + if (arg0 == 4 || arg0 == 5) + structPtr->unk1C[1]->pos2.x = 56; + else + structPtr->unk1C[1]->pos2.x = 64; +} + +// Needed to match u32/u16 tag field difference. +struct CompressedSpritePalette_ +{ + const u32 *data; // LZ77 compressed palette data + u32 tag; +}; + +extern const struct CompressedSpritePalette_ gUnknown_0861FA9C[]; + +void sub_81C7F24(u32 arg0) +{ + u32 size, tag; + + if (arg0 >= 7) + return; + + tag = gUnknown_0861FA9C[arg0].tag; + size = GetDecompressedDataSize(gUnknown_0861FA9C[arg0].data); + LoadPalette(&gPokenavLeftHeader_Pal[tag * 16], (IndexOfSpritePaletteTag(2) * 16) + 0x100, 0x20); + LZ77UnCompWram(gUnknown_0861FA9C[arg0].data, &gDecompressionBuffer[0x1000]); + RequestDma3Copy(&gDecompressionBuffer[0x1000], (void *)VRAM + 0x10800 + (GetSpriteTileStartByTag(2) * 32), size, 1); +} + +void sub_81C7FA0(u32 arg0, bool32 arg1, bool32 arg2) +{ + u32 var; + + if (!arg1) + var = 0x30; + else + var = 0x10; + + if (arg0 < 6) + sub_81C803C(var, arg2); + else + sub_81C8088(var, arg2); +} + +void sub_81C7FC4(u32 arg0, bool32 arg1) +{ + if (arg0 < 6) + sub_81C80D4(arg1); + else + sub_81C8110(arg1); +} + +void sub_81C7FDC(void) +{ + s32 i; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + for (i = 0; i < 2; i++) + { + structPtr->unk1C[i]->invisible = TRUE; + structPtr->unk24[i]->invisible = TRUE; + } +} + +bool32 sub_81C8010(void) +{ + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + if (structPtr->unk1C[0]->callback == SpriteCallbackDummy && structPtr->unk24[0]->callback == SpriteCallbackDummy) + return FALSE; + else + return TRUE; +} + +void sub_81C803C(u32 arg0, bool32 arg1) +{ + s32 var1, var2, i; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + if (!arg1) + var1 = -96, var2 = 32; + else + var1 = 256, var2 = 160; + + for (i = 0; i < 2; i++) + { + structPtr->unk1C[i]->pos1.y = arg0; + sub_81C814C(structPtr->unk1C[i], var1, var2, 12); + } +} + +void sub_81C8088(u32 arg0, bool32 arg1) +{ + s32 var1, var2, i; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + if (!arg1) + var1 = -96, var2 = 16; + else + var1 = 256, var2 = 192; + + for (i = 0; i < 2; i++) + { + structPtr->unk24[i]->pos1.y = arg0; + sub_81C814C(structPtr->unk24[i], var1, var2, 12); + } +} + +void sub_81C80D4(bool32 arg0) +{ + s32 var1, var2, i; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + if (!arg0) + var1 = 32, var2 = -96; + else + var1 = 192, var2 = 256; + + for (i = 0; i < 2; i++) + { + sub_81C814C(structPtr->unk1C[i], var1, var2, 12); + } +} + +void sub_81C8110(bool32 arg0) +{ + s32 var1, var2, i; + struct UnknownSubStruct_0203CF40 *structPtr = GetSubstructPtr(0); + + if (!arg0) + var1 = 16, var2 = -96; + else + var1 = 192, var2 = 256; + + for (i = 0; i < 2; i++) + { + sub_81C814C(structPtr->unk24[i], var1, var2, 12); + } +} + +void sub_81C814C(struct Sprite *sprite, s32 arg1, s32 arg2, s32 arg3) +{ + sprite->pos1.x = arg1; + sprite->data[0] = arg1 * 16; + sprite->data[1] = (arg2 - arg1) * 16 / arg3; + sprite->data[2] = arg3; + sprite->data[7] = arg2; + sprite->callback = sub_81C817C; +} + +void sub_81C817C(struct Sprite *sprite) +{ + if (sprite->data[2] != 0) + { + sprite->data[2]--; + sprite->data[0] += sprite->data[1]; + sprite->pos1.x = sprite->data[0] >> 4; + if (sprite->pos1.x < -16 || sprite->pos1.x > 256) + sprite->invisible = TRUE; + else + sprite->invisible = FALSE; + } + else + { + sprite->pos1.x = sprite->data[7]; + sprite->callback = SpriteCallbackDummy; + } +} + +/* +bool32 sub_81C81D4(const void *arg0, void *arg1, s32 arg3) +{ + struct UnknownSubStruct_0203CF40 *structPtr = AllocSubstruct(0x11, 0x8A4); + + if (structPtr == NULL) + return FALSE; } +*/ |