From 8a96aa9e976caef12144e7acfeea9794d3d145df Mon Sep 17 00:00:00 2001 From: GriffinR Date: Sat, 1 Feb 2020 21:19:04 -0500 Subject: Name pokenav files --- include/pokenav.h | 20 +- include/strings.h | 14 +- ld_script.txt | 38 +- src/pokenav_conditions_1.c | 625 ++++++++++++++++++++ src/pokenav_conditions_2.c | 884 +++++++++++++++++++++++++++++ src/pokenav_conditions_3.c | 714 +++++++++++++++++++++++ src/pokenav_match_call_1.c | 516 +++++++++++++++++ src/pokenav_match_call_2.c | 1279 +++++++++++++++++++++++++++++++++++++++++ src/pokenav_menu_handler_1.c | 513 +++++++++++++++++ src/pokenav_menu_handler_2.c | 1284 ++++++++++++++++++++++++++++++++++++++++++ src/pokenav_region_map.c | 729 ++++++++++++++++++++++++ src/pokenav_ribbons_1.c | 732 ++++++++++++++++++++++++ src/pokenav_ribbons_2.c | 1163 ++++++++++++++++++++++++++++++++++++++ src/pokenav_unk_1.c | 513 ----------------- src/pokenav_unk_10.c | 1163 -------------------------------------- src/pokenav_unk_2.c | 1284 ------------------------------------------ src/pokenav_unk_3.c | 516 ----------------- src/pokenav_unk_4.c | 1279 ----------------------------------------- src/pokenav_unk_5.c | 729 ------------------------ src/pokenav_unk_6.c | 625 -------------------- src/pokenav_unk_7.c | 884 ----------------------------- src/pokenav_unk_8.c | 714 ----------------------- src/pokenav_unk_9.c | 732 ------------------------ sym_bss.txt | 6 +- 24 files changed, 8476 insertions(+), 8480 deletions(-) create mode 100644 src/pokenav_conditions_1.c create mode 100644 src/pokenav_conditions_2.c create mode 100644 src/pokenav_conditions_3.c create mode 100755 src/pokenav_match_call_1.c create mode 100755 src/pokenav_match_call_2.c create mode 100644 src/pokenav_menu_handler_1.c create mode 100644 src/pokenav_menu_handler_2.c create mode 100755 src/pokenav_region_map.c create mode 100644 src/pokenav_ribbons_1.c create mode 100644 src/pokenav_ribbons_2.c delete mode 100644 src/pokenav_unk_1.c delete mode 100644 src/pokenav_unk_10.c delete mode 100644 src/pokenav_unk_2.c delete mode 100755 src/pokenav_unk_3.c delete mode 100755 src/pokenav_unk_4.c delete mode 100755 src/pokenav_unk_5.c delete mode 100644 src/pokenav_unk_6.c delete mode 100644 src/pokenav_unk_7.c delete mode 100644 src/pokenav_unk_8.c delete mode 100644 src/pokenav_unk_9.c diff --git a/include/pokenav.h b/include/pokenav.h index 37699c13f..fe5616618 100644 --- a/include/pokenav.h +++ b/include/pokenav.h @@ -297,7 +297,7 @@ bool32 WaitForPokenavShutdownFade(void); void sub_81C7834(void *func1, void *func2); void ShutdownPokenav(void); -// pokenav_unk_1.c +// pokenav_menu_handler_1.c bool32 PokenavCallback_Init_0(void); bool32 PokenavCallback_Init_4(void); bool32 PokenavCallback_Init_5(void); @@ -310,7 +310,7 @@ int GetPokenavCursorPos(void); int GetCurrentMenuItemId(void); u16 GetHelpBarTextId(void); -// pokenav_unk_2.c +// pokenav_menu_handler_2.c bool32 sub_81C9924(void); bool32 sub_81C9940(void); void CreateMenuHandlerLoopedTask(s32 ltIdx); @@ -318,7 +318,7 @@ bool32 sub_81C99C0(void); void sub_81C99D4(void); void sub_81CAADC(void); -// pokenav_unk_3.c +// pokenav_match_call_1.c bool32 PokenavCallback_Init_11(void); u32 sub_81CAB24(void); void sub_81CAB38(void); @@ -340,13 +340,13 @@ int GetIndexDeltaOfNextCheckPageDown(int index); int GetIndexDeltaOfNextCheckPageUp(int index); bool32 IsRematchEntryRegistered(int index); -// pokenav_unk_4.c +// pokenav_match_call_2.c bool32 sub_81CB260(void); void CreateMatchCallLoopedTask(s32 index); u32 sub_81CB2CC(void); void sub_81CB2E0(void); -// pokenav_unk_5.c +// pokenav_region_map.c u32 PokenavCallback_Init_6(void); void sub_81CC524(void); u32 sub_81CC554(void); @@ -355,7 +355,7 @@ void sub_81CC62C(s32); u32 sub_81CC65C(void); void sub_81CC670(void); -// pokenav_unk_6.c +// pokenav_conditions_1.c u32 PokenavCallback_Init_7(void); u32 PokenavCallback_Init_9(void); u32 sub_81CD070(void); @@ -374,14 +374,14 @@ u16 sub_81CDD48(void); void *sub_81CDCB4(u8 id); void *sub_81CDCD4(u8 id); -// pokenav_unk_7.c +// pokenav_conditions_2.c bool32 sub_81CDDD4(void); void sub_81CDE2C(s32); u32 sub_81CDE64(void); void sub_81CECA0(void); u8 sub_81CEF14(void); -// pokenav_unk_8.c +// pokenav_conditions_3.c u32 PokenavCallback_Init_8(void); u32 PokenavCallback_Init_10(void); u32 sub_81CEFDC(void); @@ -392,7 +392,7 @@ void sub_81CF3A0(s32); u32 sub_81CF3D0(void); void sub_81CF3F8(void); -// pokenav_unk_9.c +// pokenav_ribbons_1.c u32 PokenavCallback_Init_12(void); u32 PokenavCallback_Init_14(void); u32 sub_81CFA34(void); @@ -403,7 +403,7 @@ void sub_81CFE40(s32); u32 sub_81CFE70(void); void sub_81CFE98(void); -// pokenav_unk_10.c +// pokenav_ribbons_2.c u32 PokenavCallback_Init_13(void); u32 sub_81D04A0(void); void sub_81D04B8(void); diff --git a/include/strings.h b/include/strings.h index eda1c55e4..5178a0087 100644 --- a/include/strings.h +++ b/include/strings.h @@ -2914,8 +2914,11 @@ extern const u8 gText_NumberRegistered[]; extern const u8 gText_NumberOfBattles[]; extern const u8 gText_Unknown[]; extern const u8 gText_TrainerCloseBy[]; +extern const u8 gText_Call[]; +extern const u8 gText_Check[]; +extern const u8 gText_Cancel6[]; -// pokenav_unk_2 +// Pokenav Menu Handler extern const u8 gText_CheckMapOfHoenn[]; extern const u8 gText_CheckPokemonInDetail[]; extern const u8 gText_CallRegisteredTrainer[]; @@ -2932,15 +2935,8 @@ extern const u8 gText_FindToughPokemon[]; extern const u8 gText_ReturnToConditionMenu[]; extern const u8 gText_NoRibbonWinners[]; -// pokenav_unk_4 -extern const u8 gText_Call[]; -extern const u8 gText_Check[]; -extern const u8 gText_Cancel6[]; - -// pokenav_unk_8 +// Pokenav Ribbons extern const u8 gText_NumberF700[]; - -// pokenav_unk_10 extern const u8 gText_RibbonsF700[]; // use_pokeblock diff --git a/ld_script.txt b/ld_script.txt index b7cb97a17..a4f2bc3dc 100644 --- a/ld_script.txt +++ b/ld_script.txt @@ -307,16 +307,16 @@ SECTIONS { src/pokenav.o(.text); src/pokenav_main_menu.o(.text); src/pokenav_match_call_ui.o(.text); - src/pokenav_unk_1.o(.text); - src/pokenav_unk_2.o(.text); - src/pokenav_unk_3.o(.text); - src/pokenav_unk_4.o(.text); - src/pokenav_unk_5.o(.text); - src/pokenav_unk_6.o(.text); - src/pokenav_unk_7.o(.text); - src/pokenav_unk_8.o(.text); - src/pokenav_unk_9.o(.text); - src/pokenav_unk_10.o(.text); + src/pokenav_menu_handler_1.o(.text); + src/pokenav_menu_handler_2.o(.text); + src/pokenav_match_call_1.o(.text); + src/pokenav_match_call_2.o(.text); + src/pokenav_region_map.o(.text); + src/pokenav_conditions_1.o(.text); + src/pokenav_conditions_2.o(.text); + src/pokenav_conditions_3.o(.text); + src/pokenav_ribbons_1.o(.text); + src/pokenav_ribbons_2.o(.text); src/pokenav_match_call_data.o(.text); src/menu_specialized.o(.text); src/ereader_helpers.o(.text); @@ -664,15 +664,15 @@ SECTIONS { src/pokenav.o(.rodata); src/pokenav_main_menu.o(.rodata); src/pokenav_match_call_ui.o(.rodata); - src/pokenav_unk_1.o(.rodata); - src/pokenav_unk_2.o(.rodata); - src/pokenav_unk_3.o(.rodata); - src/pokenav_unk_4.o(.rodata); - src/pokenav_unk_5.o(.rodata); - src/pokenav_unk_7.o(.rodata); - src/pokenav_unk_8.o(.rodata); - src/pokenav_unk_9.o(.rodata); - src/pokenav_unk_10.o(.rodata); + src/pokenav_menu_handler_1.o(.rodata); + src/pokenav_menu_handler_2.o(.rodata); + src/pokenav_match_call_1.o(.rodata); + src/pokenav_match_call_2.o(.rodata); + src/pokenav_region_map.o(.rodata); + src/pokenav_conditions_2.o(.rodata); + src/pokenav_conditions_3.o(.rodata); + src/pokenav_ribbons_1.o(.rodata); + src/pokenav_ribbons_2.o(.rodata); src/pokenav_match_call_data.o(.rodata); src/menu_specialized.o(.rodata); src/ereader_helpers.o(.rodata); diff --git a/src/pokenav_conditions_1.c b/src/pokenav_conditions_1.c new file mode 100644 index 000000000..70c309992 --- /dev/null +++ b/src/pokenav_conditions_1.c @@ -0,0 +1,625 @@ +#include "global.h" +#include "data.h" +#include "decompress.h" +#include "main.h" +#include "menu_specialized.h" +#include "mon_markings.h" +#include "pokenav.h" +#include "pokemon.h" +#include "pokemon_storage_system.h" +#include "sound.h" +#include "string_util.h" +#include "strings.h" +#include "text.h" +#include "constants/songs.h" +#include "constants/species.h" + +struct PokenavSub11 +{ + u32 monPal[3][0x20]; + u8 fill[0x180]; + u32 monPicGfx[3][0x800]; + u8 unk6300; + s16 unk6302; + u32 (*unk6304)(struct PokenavSub11 *); + u8 fill2[0x6320 - 0x6308]; + u8 unk6320[3][24]; + u8 unk6368[3][64]; + struct UnknownStruct_81D1ED4 unk6428; + u8 unk6780[3]; + u8 unk6783[3]; + s8 unk6786; + s8 unk6787; + s8 unk6788; + s8 unk6789; + u8 unk678A; +}; + +void sub_81CD970(void); +void sub_81CD9F8(void); +u32 sub_81CD08C(struct PokenavSub11 *structPtr); +u32 sub_81CD19C(struct PokenavSub11 *structPtr); +u32 sub_81CD110(struct PokenavSub11 *structPtr); +u8 sub_81CD1E4(struct PokenavSub11 *structPtr); +u8 sub_81CD258(u8 arg0); +void sub_81CD824(s16 arg0, u8 arg1); +void sub_81CDA1C(s16 arg0, u8 arg1); +void sub_81CDB98(s16 arg0, u8 arg1); + +// code +bool32 PokenavCallback_Init_7(void) +{ + struct PokenavSub11 *structPtr = AllocSubstruct(11, sizeof(struct PokenavSub11)); + + if (structPtr == NULL) + return FALSE; + + sub_81D1ED4(&structPtr->unk6428); + sub_81CD970(); + gKeyRepeatStartDelay = 20; + structPtr->unk6304 = sub_81CD08C; + return TRUE; +} + +bool32 PokenavCallback_Init_9(void) +{ + struct PokenavSub11 *structPtr = AllocSubstruct(11, sizeof(struct PokenavSub11)); + + if (structPtr == NULL) + return FALSE; + + sub_81D1ED4(&structPtr->unk6428); + sub_81CD9F8(); + gKeyRepeatStartDelay = 20; + structPtr->unk6304 = sub_81CD08C; + return TRUE; +} + +u32 sub_81CD070(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + + return structPtr->unk6304(structPtr); +} + +u32 sub_81CD08C(struct PokenavSub11 *structPtr) +{ + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + u32 ret = sub_81CD1E4(structPtr); + + if (ret == 0) + { + if (gMain.newKeys & B_BUTTON) + { + PlaySE(SE_SELECT); + structPtr->unk6304 = sub_81CD19C; + ret = 2; + } + else if (gMain.newKeys & A_BUTTON) + { + if (structPtr->unk6300 == 0) + { + if (unkPtr->unk2 == unkPtr->unk0 - 1) + { + PlaySE(SE_SELECT); + structPtr->unk6304 = sub_81CD19C; + ret = 2; + } + } + else + { + PlaySE(SE_SELECT); + ret = 5; + structPtr->unk6304 = sub_81CD110; + } + } + } + + return ret; +} + +u32 sub_81CD110(struct PokenavSub11 *structPtr) +{ + struct PokenavSub18 *unkPtr; + u8 markings; + u32 ret = 0, boxId, monId; + + if (!sub_811FBA4()) + { + structPtr->unk6783[structPtr->unk6786] = sub_81CEF14(); + unkPtr = GetSubstructPtr(18); + boxId = unkPtr->unk4[unkPtr->unk2].boxId; + monId = unkPtr->unk4[unkPtr->unk2].monId; + markings = structPtr->unk6783[structPtr->unk6786]; + + if (boxId == TOTAL_BOXES_COUNT) + SetMonData(&gPlayerParty[monId], MON_DATA_MARKINGS, &markings); + else + SetBoxMonDataAt(boxId, monId, MON_DATA_MARKINGS, &markings); + + structPtr->unk6304 = sub_81CD08C; + ret = 6; + } + + return ret; +} + +u32 sub_81CD19C(struct PokenavSub11 *structPtr) +{ + if (structPtr->unk6300 == 0) + return POKENAV_MENU_2; + else + return POKENAV_MENU_A; +} + +void sub_81CD1C0(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + if (structPtr->unk6300 == 0) + FreePokenavSubstruct(18); + + FreePokenavSubstruct(11); +} + +u8 sub_81CD1E4(struct PokenavSub11 *structPtr) +{ + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + u8 ret = 0; + + if (gMain.heldKeys & DPAD_UP) + { + if (structPtr->unk6300 == 0 || unkPtr->unk2 != 0) + { + PlaySE(SE_SELECT); + ret = sub_81CD258(1); + } + } + else if (gMain.heldKeys & DPAD_DOWN) + { + if (structPtr->unk6300 == 0 || unkPtr->unk2 < unkPtr->unk0 - 1) + { + PlaySE(SE_SELECT); + ret = sub_81CD258(0); + } + } + + return ret; +} + +u8 sub_81CD258(u8 arg0) +{ + u16 r7; + bool8 r6, r0; + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + + r7 = (arg0) ? structPtr->unk6788 : structPtr->unk6787; + sub_81D1F84(&structPtr->unk6428, structPtr->unk6428.unk14[structPtr->unk6786], structPtr->unk6428.unk14[r7]); + r6 = (unkPtr->unk2 != ((sub_81CDD5C() != 0) ? unkPtr->unk0 : unkPtr->unk0 - 1)); + if (arg0) + { + structPtr->unk6788 = structPtr->unk6787; + structPtr->unk6787 = structPtr->unk6786; + structPtr->unk6786 = r7; + structPtr->unk6789 = structPtr->unk6788; + + unkPtr->unk2 = (unkPtr->unk2 == 0) ? unkPtr->unk0 - 1 : unkPtr->unk2 - 1; + structPtr->unk6302 = (unkPtr->unk2 != 0) ? unkPtr->unk2 - 1 : unkPtr->unk0 - 1; + } + else + { + structPtr->unk6787 = structPtr->unk6788; + structPtr->unk6788 = structPtr->unk6786; + structPtr->unk6786 = r7; + structPtr->unk6789 = structPtr->unk6787; + + unkPtr->unk2 = (unkPtr->unk2 < unkPtr->unk0 - 1) ? unkPtr->unk2 + 1 : 0; + structPtr->unk6302 = (unkPtr->unk2 < unkPtr->unk0 - 1) ? unkPtr->unk2 + 1 : 0; + } + + r0 = (unkPtr->unk2 != ((sub_81CDD5C() != 0) ? unkPtr->unk0 : unkPtr->unk0 - 1)); + + if (!r6) + return 3; + else if (!r0) + return 4; + else + return 1; +} + +bool32 sub_81CD3C4(void) +{ + s32 var; + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + + switch (structPtr->unk678A) + { + case 0: + sub_81CD824(unkPtr->unk2, 0); + break; + case 1: + sub_81CDA1C(unkPtr->unk2, 0); + break; + case 2: + sub_81CDB98(unkPtr->unk2, 0); + break; + case 3: + if (unkPtr->unk0 == 1) + { + structPtr->unk6786 = 0; + structPtr->unk6787 = 0; + structPtr->unk6788 = 0; + structPtr->unk678A = 0; + return TRUE; + } + else + { + structPtr->unk6786 = 0; + structPtr->unk6787 = 1; + structPtr->unk6788 = 2; + } + break; + // These were probably ternaries just like cases 7-9, but couldn't match it any other way. + case 4: + var = unkPtr->unk2 + 1; + if (var >= unkPtr->unk0) + var = 0; + sub_81CD824(var, 1); + break; + case 5: + var = unkPtr->unk2 + 1; + if (var >= unkPtr->unk0) + var = 0; + sub_81CDA1C(var, 1); + break; + case 6: + var = unkPtr->unk2 + 1; + if (var >= unkPtr->unk0) + var = 0; + sub_81CDB98(var, 1); + break; + case 7: + sub_81CD824((unkPtr->unk2 - 1 >= 0) ? unkPtr->unk2 - 1 : unkPtr->unk0 - 1, 2); + break; + case 8: + sub_81CDA1C((unkPtr->unk2 - 1 >= 0) ? unkPtr->unk2 - 1 : unkPtr->unk0 - 1, 2); + break; + case 9: + sub_81CDB98((unkPtr->unk2 - 1 >= 0) ? unkPtr->unk2 - 1 : unkPtr->unk0 - 1, 2); + structPtr->unk678A = 0; + return TRUE; + } + + structPtr->unk678A++; + return FALSE; +} + +bool32 sub_81CD548(u8 arg0) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + + switch (arg0) + { + case 0: + sub_81CD824(structPtr->unk6302, structPtr->unk6789); + break; + case 1: + sub_81CDA1C(structPtr->unk6302, structPtr->unk6789); + break; + case 2: + sub_81CDB98(structPtr->unk6302, structPtr->unk6789); + return TRUE; + } + + return FALSE; +} + +u8 *sub_81CD5CC(u8 *dst, const u8 *src, s16 n) +{ + while (*src != EOS) + *dst++ = *src++, n--; + + while (n-- > 0) + *dst++ = CHAR_SPACE; + + *dst = EOS; + return dst; +} + +u8 *sub_81CD624(u8 *str, u16 id, bool8 arg3) +{ + u16 boxId, monId, gender, species, level, lvlDigits; + struct BoxPokemon *boxMon; + u8 *txtPtr, *str_; + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + + boxId = unkPtr->unk4[id].boxId; + monId = unkPtr->unk4[id].monId; + *(str++) = EXT_CTRL_CODE_BEGIN; + *(str++) = 4; + *(str++) = 8; + *(str++) = 0; + *(str++) = 9; + + if (GetBoxOrPartyMonData(boxId, monId, MON_DATA_IS_EGG, NULL)) + return StringCopyPadded(str, gText_EggNickname, CHAR_SPACE, 12); + + GetBoxOrPartyMonData(boxId, monId, MON_DATA_NICKNAME, str); + StringGetEnd10(str); + species = GetBoxOrPartyMonData(boxId, monId, MON_DATA_SPECIES, NULL); + if (boxId == TOTAL_BOXES_COUNT) + { + level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + gender = GetMonGender(&gPlayerParty[monId]); + } + else + { + boxMon = GetBoxedMonPtr(boxId, monId); + gender = GetBoxMonGender(boxMon); + level = GetLevelFromBoxMonExp(boxMon); + } + + if ((species == SPECIES_NIDORAN_F || species == SPECIES_NIDORAN_M) && !StringCompare(str, gSpeciesNames[species])) + gender = MON_GENDERLESS; + + str_ = str; // For some reason, a variable is needed to match. + while (*str_ != EOS) + (str_++); + + *(str_++) = EXT_CTRL_CODE_BEGIN; + *(str_++) = 0x12; + *(str_++) = 0x3C; + switch (gender) + { + default: + *(str_++) = 0x77; + break; + case MON_MALE: + *(str_++) = EXT_CTRL_CODE_BEGIN; + *(str_++) = EXT_CTRL_CODE_COLOR; + *(str_++) = 4; + *(str_++) = EXT_CTRL_CODE_BEGIN; + *(str_++) = 3; + *(str_++) = 5; + *(str_++) = CHAR_MALE; + break; + case MON_FEMALE: + *(str_++) = EXT_CTRL_CODE_BEGIN; + *(str_++) = EXT_CTRL_CODE_COLOR; + *(str_++) = 6; + *(str_++) = EXT_CTRL_CODE_BEGIN; + *(str_++) = 3; + *(str_++) = 7; + *(str_++) = CHAR_FEMALE; + break; + } + + *(str_++) = EXT_CTRL_CODE_BEGIN; + *(str_++) = 4; + *(str_++) = 8; + *(str_++) = 0; + *(str_++) = 9; + *(str_++) = CHAR_SLASH; + *(str_++) = CHAR_SPECIAL_F9; + *(str_++) = CHAR_LV_2; + txtPtr = str_; + str_ = ConvertIntToDecimalStringN(str_, level, STR_CONV_MODE_LEFT_ALIGN, 3); + lvlDigits = str_ - txtPtr; + *(str_++) = CHAR_SPACE; + if (!arg3) + { + lvlDigits = 3 - lvlDigits; + while (lvlDigits-- != 0) + *(str_++) = CHAR_SPACE; + } + + *str_ = EOS; + return str_; +} + +void sub_81CD824(s16 arg0, u8 arg1) +{ + u16 boxId, i; + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + + if (arg0 != (sub_81CDD5C() != 0 ? unkPtr->unk0 : unkPtr->unk0 - 1)) + { + sub_81CD624(structPtr->unk6368[arg1], arg0, FALSE); + boxId = unkPtr->unk4[arg0].boxId; + structPtr->unk6320[arg1][0] = EXT_CTRL_CODE_BEGIN; + structPtr->unk6320[arg1][1] = 4; + structPtr->unk6320[arg1][2] = 8; + structPtr->unk6320[arg1][3] = 0; + structPtr->unk6320[arg1][4] = 9; + if (boxId == TOTAL_BOXES_COUNT) + sub_81CD5CC(&structPtr->unk6320[arg1][5], gText_InParty, 8); + else + sub_81CD5CC(&structPtr->unk6320[arg1][5], GetBoxNamePtr(boxId), 8); + } + else + { + for (i = 0; i < 12; i++) + structPtr->unk6368[arg1][i] = CHAR_SPACE; + structPtr->unk6368[arg1][i] = EOS; + + for (i = 0; i < 8; i++) + structPtr->unk6320[arg1][i] = CHAR_SPACE; + structPtr->unk6320[arg1][i] = EOS; + } +} + +void sub_81CD970(void) +{ + u16 i, count; + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + struct PokenavSub18 *unkPtr = AllocSubstruct(18, sizeof(struct PokenavSub18)); + + structPtr->unk6300 = 0; + for (i = 0, count = 0; i < CalculatePlayerPartyCount(); i++) + { + if (!GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG)) + { + unkPtr->unk4[count].boxId = TOTAL_BOXES_COUNT; + unkPtr->unk4[count].monId = i; + unkPtr->unk4[count].data = 0; + count++; + } + } + + unkPtr->unk4[count].boxId = 0; + unkPtr->unk4[count].monId = 0; + unkPtr->unk4[count].data = 0; + unkPtr->unk2 = 0; + unkPtr->unk0 = count + 1; + structPtr->unk678A = 0; +} + +void sub_81CD9F8(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + structPtr->unk6300 = 1; + structPtr->unk678A = 0; +} + +void sub_81CDA1C(s16 arg0, u8 arg1) +{ + u16 boxId, monId, i; + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + + if (arg0 != (sub_81CDD5C() != 0 ? unkPtr->unk0 : unkPtr->unk0 - 1)) + { + boxId = unkPtr->unk4[arg0].boxId; + monId = unkPtr->unk4[arg0].monId; + structPtr->unk6428.unk0[arg1][0] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_COOL, NULL); + structPtr->unk6428.unk0[arg1][1] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_TOUGH, NULL); + structPtr->unk6428.unk0[arg1][2] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_SMART, NULL); + structPtr->unk6428.unk0[arg1][3] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_CUTE, NULL); + structPtr->unk6428.unk0[arg1][4] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_BEAUTY, NULL); + structPtr->unk6780[arg1] = (GetBoxOrPartyMonData(boxId, monId, MON_DATA_SHEEN, NULL) != 255) + ? GetBoxOrPartyMonData(boxId, monId, MON_DATA_SHEEN, NULL) / 29u + : 9; + structPtr->unk6783[arg1] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_MARKINGS, NULL); + sub_81D2754(structPtr->unk6428.unk0[arg1], structPtr->unk6428.unk14[arg1]); + } + else + { + for (i = 0; i < 5; i++) + { + structPtr->unk6428.unk0[arg1][i] = 0; + structPtr->unk6428.unk14[arg1][i].unk0 = 155; + structPtr->unk6428.unk14[arg1][i].unk2 = 91; + } + } +} + +void sub_81CDB98(s16 arg0, u8 arg1) +{ + u16 boxId, monId, species; + u32 personality, tid; + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + + if (arg0 == (sub_81CDD5C() != 0 ? unkPtr->unk0 : unkPtr->unk0 - 1)) + return; + + boxId = unkPtr->unk4[arg0].boxId; + monId = unkPtr->unk4[arg0].monId; + species = GetBoxOrPartyMonData(boxId, monId, MON_DATA_SPECIES2, NULL); + tid = GetBoxOrPartyMonData(boxId, monId, MON_DATA_OT_ID, NULL); + personality = GetBoxOrPartyMonData(boxId, monId, MON_DATA_PERSONALITY, NULL); + LoadSpecialPokePic(&gMonFrontPicTable[species], structPtr->monPicGfx[arg1], species, personality, TRUE); + LZ77UnCompWram(GetMonSpritePalFromSpeciesAndPersonality(species, tid, personality), structPtr->monPal[arg1]); +} + +u16 sub_81CDC50(void) +{ + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + return unkPtr->unk0; +} + +u16 sub_81CDC60(void) +{ + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + return unkPtr->unk2; +} + +struct UnknownStruct_81D1ED4 *sub_81CDC70(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return &structPtr->unk6428; +} + +u8 sub_81CDC84(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return structPtr->unk6786; +} + +u8 sub_81CDC9C(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return structPtr->unk6302; +} + +void *sub_81CDCB4(u8 id) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return structPtr->monPicGfx[id]; +} + +void *sub_81CDCD4(u8 id) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return structPtr->monPal[id]; +} + +u8 sub_81CDCEC(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return structPtr->unk6789; +} + +u8 *sub_81CDD04(u8 id) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return structPtr->unk6368[id]; +} + +u8 *sub_81CDD24(u8 id) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return structPtr->unk6320[id]; +} + +u16 sub_81CDD48(void) +{ + struct PokenavSub18 *unkPtr = GetSubstructPtr(18); + return unkPtr->unk4[unkPtr->unk2].data; +} + +bool32 sub_81CDD5C(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + if (structPtr->unk6300 == 1) + return TRUE; + else + return FALSE; +} + +u8 sub_81CDD7C(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + if (structPtr->unk6300 == 1) + return structPtr->unk6783[structPtr->unk6786]; + else + return 0; +} + +u8 sub_81CDDB0(void) +{ + struct PokenavSub11 *structPtr = GetSubstructPtr(11); + return structPtr->unk6780[structPtr->unk6786]; +} diff --git a/src/pokenav_conditions_2.c b/src/pokenav_conditions_2.c new file mode 100644 index 000000000..11fdaa425 --- /dev/null +++ b/src/pokenav_conditions_2.c @@ -0,0 +1,884 @@ +#include "global.h" +#include "bg.h" +#include "window.h" +#include "pokenav.h" +#include "decompress.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "menu.h" +#include "menu_specialized.h" +#include "mon_markings.h" +#include "palette.h" +#include "pokenav.h" +#include "scanline_effect.h" +#include "string_util.h" +#include "strings.h" +#include "text.h" + +u32 sub_81CE37C(s32); +u32 sub_81CE2D0(s32); +u32 sub_81CE4D8(s32); +u32 sub_81CE5E4(s32); +u32 sub_81CE6BC(s32); +u32 sub_81CE700(s32); + +BSS_DATA u8 gUnknown_030012BC; + +const u16 gUnknown_086231E8[] = INCBIN_U16("graphics/pokenav/86231E8.gbapal"); +const u16 gUnknown_08623208[] = INCBIN_U16("graphics/pokenav/8623208.gbapal"); +const u32 gUnknown_08623228[] = INCBIN_U32("graphics/pokenav/8623228.4bpp.lz"); +const u32 gUnknown_0862323C[] = INCBIN_U32("graphics/pokenav/862323C.bin.lz"); +const u16 gUnknown_08623338[] = INCBIN_U16("graphics/pokenav/8623338.gbapal"); + +const struct BgTemplate gUnknown_08623358[3] = +{ + { + .bg = 1, + .charBaseIndex = 1, + .mapBaseIndex = 0x1F, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0 + }, + { + .bg = 2, + .charBaseIndex = 3, + .mapBaseIndex = 0x1D, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0 + }, + { + .bg = 3, + .charBaseIndex = 2, + .mapBaseIndex = 0x1E, + .screenSize = 0, + .paletteMode = 0, + .priority = 3, + .baseTile = 0 + } +}; + +const struct WindowTemplate gUnknown_08623364 = +{ + .bg = 1, + .tilemapLeft = 13, + .tilemapTop = 1, + .width = 13, + .height = 4, + .paletteNum = 15, + .baseBlock = 2 +}; + +const struct WindowTemplate gUnknown_0862336C = +{ + .bg = 1, + .tilemapLeft = 1, + .tilemapTop = 6, + .width = 7, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x36 +}; + +const struct WindowTemplate gUnknown_08623374 = +{ + .bg = 1, + .tilemapLeft = 1, + .tilemapTop = 0x1C, + .width = 5, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x44 +}; + +const struct WindowTemplate gUnknown_0862337C = +{ + .bg = 1, + .tilemapLeft = 13, + .tilemapTop = 0x1C, + .width = 3, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x44 +}; + +const LoopedTask gUnknown_08623384[] = +{ + NULL, + sub_81CE37C, + sub_81CE2D0, + sub_81CE4D8, + sub_81CE5E4, + sub_81CE6BC, + sub_81CE700 +}; + +struct Pokenav7Struct +{ + u32 loopedTaskId; + u8 tilemapBuffers[3][BG_SCREEN_SIZE]; + u8 filler[2]; + u8 unk1806[10]; + u32 (*unk1810)(void); + s16 unk1814; + u8 unk1816; + u16 unk1818; + u16 unk181A; + void *unk181C; + u8 unk1820; + u8 unk1821; + u8 unk1822; + u8 unk1823; + struct PokemonMarkMenu monMarks; + struct Sprite *unk28dc; + struct Sprite *unk28e0[10]; + u8 unk2908; + u8 filler2[0x38ac - 0x2909]; +}; + +extern s8 sub_81CDC84(void); // This function's declaration here is different than its definition in pokenav_unk_6. u8/s8 + +u32 sub_81CDE94(s32 state); +u32 sub_81CDE80(void); +void sub_81CED30(u8 var); +void sub_81CE9E4(void); +void sub_81CE934(void); +bool32 sub_81CE754(u8 a0, u16 a1, bool8 a2); +void sub_81CEE44(void); +void sub_81CEE90(void); +void sub_81CEEC8(void); +void sub_81CEE68(void); +void sub_81CEE74(bool8 showBg); + +// code +bool32 sub_81CDDD4(void) +{ + struct Pokenav7Struct *structPtr = AllocSubstruct(0xC, sizeof(struct Pokenav7Struct)); + + if (structPtr == NULL) + return FALSE; + + structPtr->unk1816 = 0xFF; + structPtr->loopedTaskId = CreateLoopedTask(sub_81CDE94, 1); + structPtr->unk1810 = sub_81CDE80; + structPtr->unk2908 = 0; + return TRUE; +} + +void sub_81CDE2C(s32 id) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + structPtr->loopedTaskId = CreateLoopedTask(gUnknown_08623384[id], 1); + structPtr->unk1810 = sub_81CDE80; +} + +u32 sub_81CDE64(void) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + return structPtr->unk1810(); +} + +u32 sub_81CDE80(void) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + return IsLoopedTaskActive(structPtr->loopedTaskId); +} + +u32 sub_81CDE94(s32 state) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + switch (state) + { + case 0: + if (sub_81CD3C4() != TRUE) + return LT_PAUSE; + return LT_INC_AND_PAUSE; + case 1: + InitBgTemplates(gUnknown_08623358, ARRAY_COUNT(gUnknown_08623358)); + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ChangeBgX(2, 0, 0); + ChangeBgY(2, 0, 0); + ChangeBgX(3, 0, 0); + ChangeBgY(3, 0, 0); + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_WIN1_ON | DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON | DISPCNT_BG3_ON); + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG3); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(11, 4)); + decompress_and_copy_tile_data_to_vram(3, gPokenavCondition_Gfx, 0, 0, 0); + return LT_INC_AND_PAUSE; + case 2: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + decompress_and_copy_tile_data_to_vram(2, gUnknown_08623228, 0, 0, 0); + return LT_INC_AND_PAUSE; + case 3: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + + LZ77UnCompVram(gPokenavCondition_Tilemap, structPtr->tilemapBuffers[0]); + SetBgTilemapBuffer(3, structPtr->tilemapBuffers[0]); + if (sub_81CDD5C() == TRUE) + CopyToBgTilemapBufferRect(3, gPokenavOptions_Tilemap, 0, 5, 9, 4); + + CopyBgTilemapBufferToVram(3); + CopyPaletteIntoBufferUnfaded(gPokenavCondition_Pal, 0x10, 0x20); + CopyPaletteIntoBufferUnfaded(gUnknown_08623208, 0xF0, 0x20); + structPtr->unk1814 = -80; + return LT_INC_AND_PAUSE; + case 4: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + + LZ77UnCompVram(gUnknown_0862323C, structPtr->tilemapBuffers[2]); + SetBgTilemapBuffer(2, structPtr->tilemapBuffers[2]); + CopyBgTilemapBufferToVram(2); + CopyPaletteIntoBufferUnfaded(gUnknown_086231E8, 0x30, 0x20); + sub_81D21DC(2); + return LT_INC_AND_PAUSE; + case 5: + sub_8199DF0(1, 0, 0, 1); + sub_8199DF0(1, 17, 1, 1); + CpuFill32(0, structPtr->tilemapBuffers[1], BG_SCREEN_SIZE); + SetBgTilemapBuffer(1, structPtr->tilemapBuffers[1]); + return LT_INC_AND_PAUSE; + case 6: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + + structPtr->unk1820 = AddWindow(&gUnknown_08623364); + if (sub_81CDD5C() == TRUE) + { + structPtr->unk1821 = AddWindow(&gUnknown_0862336C); + structPtr->unk1822 = AddWindow(&gUnknown_08623374); + structPtr->unk1823 = AddWindow(&gUnknown_0862337C); + } + DeactivateAllTextPrinters(); + return LT_INC_AND_PAUSE; + case 7: + sub_81CED30(0); + return LT_INC_AND_PAUSE; + case 8: + sub_81CE9E4(); + return LT_INC_AND_PAUSE; + case 9: + if (sub_81CDD5C() == TRUE) + sub_81CE934(); + return LT_INC_AND_PAUSE; + case 10: + sub_81CE754(0, sub_81CDC84(), TRUE); + return LT_INC_AND_PAUSE; + case 11: + sub_81CE754(1, sub_81CDC84(), TRUE); + return LT_INC_AND_PAUSE; + case 12: + sub_81CE754(2, sub_81CDC84(), TRUE); + return LT_INC_AND_PAUSE; + case 13: + if (sub_81CE754(3, sub_81CDC84(), TRUE) != TRUE) + return LT_PAUSE; + PutWindowTilemap(structPtr->unk1820); + if (sub_81CDD5C() == TRUE) + { + PutWindowTilemap(structPtr->unk1821); + PutWindowTilemap(structPtr->unk1822); + PutWindowTilemap(structPtr->unk1823); + } + return LT_INC_AND_PAUSE; + case 14: + ShowBg(1); + HideBg(2); + ShowBg(3); + if (sub_81CDD5C() == TRUE) + PrintHelpBarText(HELPBAR_CONDITION_MON_STATUS); + return LT_INC_AND_PAUSE; + case 15: + sub_81C7AC0(1); + if (!sub_81CDD5C()) + { + LoadLeftHeaderGfxForIndex(6); + sub_81C7FA0(1, TRUE, 0); + sub_81C7FA0(6, TRUE, 0); + } + return LT_INC_AND_PAUSE; + case 16: + if (IsPaletteFadeActive()) + return LT_PAUSE; + if (!sub_81CDD5C() && sub_81C8010()) + return LT_PAUSE; + SetVBlankCallback_(sub_81CEE44); + return LT_INC_AND_PAUSE; + case 17: + sub_81CEE90(); + sub_81D20AC(sub_81CDC70()); + return LT_INC_AND_PAUSE; + case 18: + if (sub_81D20BC(sub_81CDC70())) + return LT_PAUSE; + return LT_INC_AND_PAUSE; + case 19: + sub_81CEE74(TRUE); + return LT_INC_AND_PAUSE; + case 20: + if (!sub_81D3178(sub_81CDC70(), &structPtr->unk1814)) + { + sub_81D3464(structPtr->unk28e0); + if (sub_81CDD5C() == TRUE || sub_81CDC60() != sub_81CDC50()) + sub_81D3480(structPtr->unk28e0, structPtr->unk1816, sub_81CDDB0()); + + return LT_FINISH; + } + return LT_PAUSE; + } + + return LT_FINISH; +} + +u32 sub_81CE2D0(s32 state) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + switch (state) + { + case 0: + sub_81CEEC8(); + sub_81D3520(structPtr->unk28e0); + return 1; + case 1: + if (sub_81D31A4(sub_81CDC70(), &structPtr->unk1814)) + return 2; + sub_81CEE74(FALSE); + return 1; + case 2: + sub_81C7AC0(0); + if (!sub_81CDD5C()) + sub_81C78A0(); + return 0; + case 3: + if (IsPaletteFadeActive() || MainMenuLoopedTaskIsBusy()) + return 2; + sub_81D354C(structPtr->unk28e0); + HideBg(1); + HideBg(2); + HideBg(3); + return 1; + } + + return LT_FINISH; +} + +u32 sub_81CE37C(s32 state) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + struct UnknownStruct_81D1ED4 *unkPtr = sub_81CDC70(); + + switch (state) + { + case 0: + sub_81CD548(0); + return 1; + case 1: + sub_81CD548(1); + return 1; + case 2: + sub_81CD548(2); + sub_81D3520(structPtr->unk28e0); + return 1; + case 3: + sub_81D2074(unkPtr); + return 1; + case 4: + if (!sub_81D3150(&structPtr->unk1814)) + { + sub_81CED30(sub_81CDC84()); + return 1; + } + return 2; + case 5: + sub_81CE754(0, sub_81CDC84(), FALSE); + return 1; + case 6: + sub_81CE754(1, sub_81CDC84(), FALSE); + return 1; + case 7: + sub_81CE754(2, sub_81CDC84(), FALSE); + return 1; + case 8: + if (sub_81CE754(3, sub_81CDC84(), FALSE) == TRUE) + return 1; + return 2; + case 9: + unkPtr = sub_81CDC70(); + if (!sub_81D3178(unkPtr, &structPtr->unk1814)) + { + sub_81D3464(structPtr->unk28e0); + if (sub_81CDD5C() != TRUE && sub_81CDC60() == sub_81CDC50()) + return 1; + + sub_81D3480(structPtr->unk28e0, structPtr->unk1816, sub_81CDDB0()); + return 1; + } + return 2; + } + + return LT_FINISH; +} + +u32 sub_81CE4D8(s32 state) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + switch (state) + { + case 0: + sub_81CD548(0); + return 1; + case 1: + sub_81CD548(1); + return 1; + case 2: + sub_81CD548(2); + return 1; + case 3: + sub_81CED30(sub_81CDC84()); + return 1; + case 4: + sub_81CE754(0, sub_81CDC84(), FALSE); + return 1; + case 5: + sub_81CE754(1, sub_81CDC84(), FALSE); + return 1; + case 6: + sub_81CE754(2, sub_81CDC84(), FALSE); + return 1; + case 7: + if (sub_81CE754(3, sub_81CDC84(), FALSE) == TRUE) + return 1; + return 2; + case 8: + if (!sub_81D3178(sub_81CDC70(), &structPtr->unk1814)) + { + sub_81D3464(structPtr->unk28e0); + sub_81D3480(structPtr->unk28e0, structPtr->unk1816, sub_81CDDB0()); + return 1; + } + return 2; + } + + return LT_FINISH; +} + +u32 sub_81CE5E4(s32 state) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + switch (state) + { + case 0: + sub_81CD548(0); + return 1; + case 1: + sub_81CD548(1); + return 1; + case 2: + sub_81CD548(2); + sub_81D3520(structPtr->unk28e0); + return 1; + case 3: + if (!sub_81D31A4(sub_81CDC70(), &structPtr->unk1814)) + return 1; + return 2; + case 4: + sub_81CE754(0, sub_81CDC84(), FALSE); + return 1; + case 5: + sub_81CE754(1, sub_81CDC84(), FALSE); + return 1; + case 6: + sub_81CE754(2, sub_81CDC84(), FALSE); + return 1; + case 7: + if (sub_81CE754(3, sub_81CDC84(), FALSE) == TRUE) + return 1; + return 2; + } + + return LT_FINISH; +} + +u32 sub_81CE6BC(s32 state) +{ + switch (state) + { + case 0: + sub_811FAA4(sub_81CDD7C(), 176, 32); + return 1; + case 1: + PrintHelpBarText(HELPBAR_CONDITION_MARKINGS); + return 1; + case 2: + if (WaitForHelpBar() == TRUE) + return 2; + return 1; + } + + return LT_FINISH; +} + +u32 sub_81CE700(s32 state) +{ + switch (state) + { + case 0: + sub_811FAF8(); + return 1; + case 1: + PrintHelpBarText(HELPBAR_CONDITION_MON_STATUS); + return 1; + case 2: + if (WaitForHelpBar() == TRUE) + return 2; + return 1; + } + + return LT_FINISH; +} + +static u8 *UnusedPrintNumberString(u8 *dst, u16 num) +{ + u8 *txtPtr = ConvertIntToDecimalStringN(dst, num, STR_CONV_MODE_RIGHT_ALIGN, 4); + txtPtr = StringCopy(txtPtr, gText_Number2); + + return txtPtr; +} + +bool32 sub_81CE754(u8 a0, u16 a1, bool8 a2) +{ + u8 text[32]; + const u8 *str; + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + switch (a0) + { + case 0: + FillWindowPixelBuffer(structPtr->unk1820, 0); + if (sub_81CDD5C() == TRUE) + FillWindowPixelBuffer(structPtr->unk1821, 0); + break; + case 1: + if (sub_81CDC60() != sub_81CDC50() - 1 || sub_81CDD5C() == TRUE) + { + str = sub_81CDD04(a1); + AddTextPrinterParameterized(structPtr->unk1820, 1, str, 0, 1, 0, NULL); + } + break; + case 2: + if (sub_81CDD5C() == TRUE) + { + str = sub_81CDD24(a1); + AddTextPrinterParameterized(structPtr->unk1820, 1, str, 0, 17, 0, NULL); + text[0] = EXT_CTRL_CODE_BEGIN; + text[1] = 4; + text[2] = 8; + text[3] = 0; + text[4] = 9; + StringCopy(text + 5, gText_Number2); + AddTextPrinterParameterized(structPtr->unk1821, 1, text, 4, 1, 0, NULL); + ConvertIntToDecimalStringN(text + 5, sub_81CDD48(), STR_CONV_MODE_RIGHT_ALIGN, 4); + AddTextPrinterParameterized(structPtr->unk1821, 1, text, 28, 1, 0, NULL); + } + break; + case 3: + switch (structPtr->unk2908) + { + case 0: + if (a2) + CopyWindowToVram(structPtr->unk1820, 3); + else + CopyWindowToVram(structPtr->unk1820, 2); + + if (sub_81CDD5C() == TRUE) + { + structPtr->unk2908++; + return FALSE; + } + else + { + structPtr->unk2908 = 0; + return TRUE; + } + case 1: + if (a2) + CopyWindowToVram(structPtr->unk1821, 3); + else + CopyWindowToVram(structPtr->unk1821, 2); + + structPtr->unk2908 = 0; + return TRUE; + } + } + + return FALSE; +} + +void sub_81CE934(void) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + CopyWindowToVram(structPtr->unk1822, 3); + CopyWindowToVram(structPtr->unk1823, 3); +} + +void sub_81CE964(struct Sprite *sprite) +{ + if (sprite->data[0] == sub_81CDC60()) + StartSpriteAnim(sprite, 0); + else + StartSpriteAnim(sprite, 1); +} + +void sub_81CE990(struct Sprite *sprite) +{ + if (sub_81CDC60() == sub_81CDC50() - 1) + sprite->oam.paletteNum = IndexOfSpritePaletteTag(0x65); + else + sprite->oam.paletteNum = IndexOfSpritePaletteTag(0x66); +} + +void sub_81CE9C8(struct Sprite *sprite) +{ + StartSpriteAnim(sprite, sub_81CDD7C()); +} + +void sub_81CE9E4(void) +{ + struct SpriteSheet sprSheets[4]; + struct SpriteTemplate sprTemplate; + struct SpritePalette sprPals[3]; + struct SpriteSheet sprSheet; + struct Sprite *sprite; + u16 i, spriteId; + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + sub_81D321C(sprSheets, &sprTemplate, sprPals); + if (sub_81CDD5C() == TRUE) + { + structPtr->monMarks.baseTileTag = 0x6A; + structPtr->monMarks.basePaletteTag = 0x6A; + sub_811F90C(&structPtr->monMarks); + sub_811FA90(); + sprite = sub_811FF94(0x69, 0x69, gUnknown_08623338); + sprite->oam.priority = 3; + sprite->pos1.x = 192; + sprite->pos1.y = 32; + sprite->callback = sub_81CE9C8; + structPtr->unk28dc = sprite; + sub_81C7990(IndexOfSpritePaletteTag(0x69), 0); + } + else + { + LoadSpriteSheets(sprSheets); + Pokenav_AllocAndLoadPalettes(sprPals); + for (i = 0; i < sub_81CDC50() - 1; i++) + { + spriteId = CreateSprite(&sprTemplate, 226, (i * 20) + 8, 0); + if (spriteId != MAX_SPRITES) + { + structPtr->unk1806[i] = spriteId; + gSprites[spriteId].data[0] = i; + gSprites[spriteId].callback = sub_81CE964; + } + else + { + structPtr->unk1806[i] = 0xFF; + } + } + + sprTemplate.tileTag = 0x67; + sprTemplate.callback = SpriteCallbackDummy; + for (; i < 6; i++) + { + spriteId = CreateSprite(&sprTemplate, 230, (i * 20) + 8, 0); + if (spriteId != MAX_SPRITES) + { + structPtr->unk1806[i] = spriteId; + gSprites[spriteId].oam.size = 0; + } + else + { + structPtr->unk1806[i] = 0xFF; + } + } + + sprTemplate.tileTag = 0x66; + sprTemplate.callback = sub_81CE990; + spriteId = CreateSprite(&sprTemplate, 222, (i * 20) + 8, 0); + if (spriteId != MAX_SPRITES) + { + structPtr->unk1806[i] = spriteId; + gSprites[spriteId].oam.shape = SPRITE_SHAPE(32x16); + gSprites[spriteId].oam.size = SPRITE_SIZE(32x16); + } + else + { + structPtr->unk1806[i] = 0xFF; + } + } + + sub_81D32B0(&sprSheet, &sprPals[0]); + LoadSpriteSheet(&sprSheet); + sprPals[1].data = NULL; + Pokenav_AllocAndLoadPalettes(sprPals); +} + +void sub_81CEBF4(struct Pokenav7Struct *structPtr) +{ + u8 i; + + if (sub_81CDD5C() == TRUE) + { + DestroySprite(structPtr->unk28dc); + FreeSpriteTilesByTag(0x6A); + FreeSpriteTilesByTag(0x69); + FreeSpritePaletteByTag(0x6A); + FreeSpritePaletteByTag(0x69); + } + else + { + for (i = 0; i < 7; i++) + DestroySprite(&gSprites[structPtr->unk1806[i]]); + + FreeSpriteTilesByTag(0x65); + FreeSpriteTilesByTag(0x66); + FreeSpriteTilesByTag(0x67); + FreeSpritePaletteByTag(0x65); + FreeSpritePaletteByTag(0x66); + } + + if (structPtr->unk1816 != 0xFF) + { + DestroySprite(&gSprites[structPtr->unk1816]); + FreeSpriteTilesByTag(0x64); + FreeSpritePaletteByTag(0x64); + } +} + +void sub_81CECA0(void) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + RemoveWindow(structPtr->unk1820); + if (sub_81CDD5C() == TRUE) + { + RemoveWindow(structPtr->unk1821); + RemoveWindow(structPtr->unk1822); + RemoveWindow(structPtr->unk1823); + } + else + { + sub_81C7FDC(); + } + + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_BG0_ON | DISPCNT_OBJ_1D_MAP); + sub_81CEBF4(structPtr); + sub_81CEE68(); + FreePokenavSubstruct(0xC); +} + +void sub_81CED10(struct Sprite *sprite) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + sprite->pos1.x = structPtr->unk1814 + 38; +} + +void sub_81CED30(u8 var) +{ + struct SpriteTemplate sprTemplate; + struct SpriteSheet sprSheet; + struct SpritePalette sprPal; + u8 spriteId; + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + if (structPtr->unk1816 == 0xFF) + { + sub_81D31D0(&sprSheet, &sprTemplate, &sprPal); + sprSheet.data = sub_81CDCB4(var); + sprPal.data = sub_81CDCD4(var); + structPtr->unk1818 = LoadSpritePalette(&sprPal); + structPtr->unk181A = LoadSpriteSheet(&sprSheet); + spriteId = CreateSprite(&sprTemplate, 38, 104, 0); + structPtr->unk1816 = spriteId; + if (spriteId == MAX_SPRITES) + { + FreeSpriteTilesByTag(0x64); + FreeSpritePaletteByTag(0x64); + structPtr->unk1816 = 0xFF; + } + else + { + structPtr->unk1816 = spriteId; + gSprites[structPtr->unk1816].callback = sub_81CED10; + structPtr->unk181C = (void*)(VRAM) + 0x10000 + (structPtr->unk181A * 32); + structPtr->unk1818 = (structPtr->unk1818 * 16) + 0x100; + } + } + else + { + DmaCopy16Defvars(3, sub_81CDCB4(var), structPtr->unk181C, 0x800); + LoadPalette(sub_81CDCD4(var), structPtr->unk1818, 0x20); + } +} + +void sub_81CEE44(void) +{ + struct UnknownStruct_81D1ED4 *unk = sub_81CDC70(); + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); + sub_81D2108(unk); + ScanlineEffect_InitHBlankDmaTransfer(); +} + +void sub_81CEE68(void) +{ + SetPokenavVBlankCallback(); +} + +void sub_81CEE74(bool8 showBg) +{ + if (showBg) + ShowBg(2); + else + HideBg(2); +} + +void sub_81CEE90(void) +{ + struct UnknownStruct_81D1ED4 *unk = sub_81CDC70(); + u8 id = sub_81CDC84(); + + gUnknown_030012BC = id; + sub_81D1F84(unk, unk->unk14[3], unk->unk14[id]); + sub_81D2074(unk); +} + +void sub_81CEEC8(void) +{ + struct UnknownStruct_81D1ED4 *unk = sub_81CDC70(); + + if (sub_81CDD5C() || sub_81CDC60() != sub_81CDC50() - 1) + sub_81D1F84(unk, unk->unk14[sub_81CDC84()], unk->unk14[3]); +} + +u8 sub_81CEF14(void) +{ + struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); + + if (sub_81CDD5C() == 1) + return structPtr->monMarks.markings; + else + return 0; +} diff --git a/src/pokenav_conditions_3.c b/src/pokenav_conditions_3.c new file mode 100644 index 000000000..9b6ce432b --- /dev/null +++ b/src/pokenav_conditions_3.c @@ -0,0 +1,714 @@ +#include "global.h" +#include "pokenav.h" +#include "bg.h" +#include "menu.h" +#include "window.h" +#include "sound.h" +#include "dynamic_placeholder_text_util.h" +#include "strings.h" +#include "string_util.h" +#include "international_string_util.h" +#include "constants/songs.h" + +struct PokenavSub7 +{ + u32 (*unk0)(struct PokenavSub7 *); + u32 loopedTaskId; + u8 fill1[4]; + s32 unkC; + s32 unk10; + u32 unk14; + u32 unk18; + u32 unk1C; + struct PokenavSub18 *unkPtr; +}; + +struct PokenavSub8 +{ + bool32 (*callback)(void); + u32 ltid; + u16 winid; + bool32 unkC; + u8 buff[BG_SCREEN_SIZE]; +}; // size: 0x810 + +static u32 sub_81CF010(struct PokenavSub7 *structPtr); +static u32 sub_81CF030(struct PokenavSub7 *structPtr); +static u32 sub_81CF0B8(struct PokenavSub7 *structPtr); +static u32 sub_81CF0B0(struct PokenavSub7 *structPtr); +static u32 sub_81CF11C(s32 state); +static u32 sub_81CF134(s32 state); +static u32 sub_81CF1C4(s32 state); +static u32 sub_81CF1D8(s32 state); +static u32 sub_81CF278(s32 state); +static u32 sub_81CF578(s32 state); +static u32 sub_81CF5F0(s32 state); +static u32 sub_81CF668(s32 state); +static u32 sub_81CF6E0(s32 state); +static u32 sub_81CF758(s32 state); +static u32 sub_81CF798(s32 state); +static void sub_81CF2C4(struct PokenavSub7 *structPtr, struct PokenavMonList *item); +static bool32 sub_81CF3E4(void); +static u32 sub_81CF418(s32 state); +static void sub_81CF7C8(struct PokenavSub8 *); +static void sub_81CF7F4(struct PokenavSub8 *); +static void sub_81CF88C(void); +static void sub_81CF8E4(struct PokenavMonList *, u8 *); + +static const u32 gUnknown_086233A0[] = {0x16, 0x17, 0x18, 0x21, 0x2F}; + +static const LoopedTask gUnknown_086233B4[] = +{ + sub_81CF134, + sub_81CF1C4, + sub_81CF1D8, + sub_81CF278 +}; + +static const u16 gUnknown_086233C4[] = INCBIN_U16("graphics/pokenav/condition_search2.gbapal"); +static const u32 gUnknown_086233E4[] = INCBIN_U32("graphics/pokenav/condition_search2.4bpp.lz"); +static const u32 gUnknown_086234AC[] = INCBIN_U32("graphics/pokenav/condition_search2.bin.lz"); +static const u16 gUnknown_08623570[] = INCBIN_U16("graphics/pokenav/8623570.gbapal"); + +static const struct BgTemplate gUnknown_08623590[] = +{ + { + .bg = 1, + .charBaseIndex = 1, + .mapBaseIndex = 0x06, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0 + }, { + .bg = 2, + .charBaseIndex = 2, + .mapBaseIndex = 0x07, + .screenSize = 0, + .paletteMode = 0, + .priority = 3, + .baseTile = 0 + } +}; + +static const LoopedTask gUnknown_08623598[] = +{ + NULL, + sub_81CF578, + sub_81CF5F0, + sub_81CF668, + sub_81CF6E0, + sub_81CF758, + sub_81CF798 +}; + +static const struct WindowTemplate gUnknown_086235B4 = +{ + .bg = 1, + .tilemapLeft = 1, + .tilemapTop = 6, + .width = 7, + .height = 2, + .paletteNum = 1, + .baseBlock = 20 +}; + +static const u8 sText_MaleSymbol[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_RED}{WHITE}{GREEN}♂{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); +static const u8 sText_FemaleSymbol[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_GREEN}{WHITE}{BLUE}♀{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); +static const u8 sText_NoGenderSymbol[] = _("{UNK_SPACER}"); + +bool32 PokenavCallback_Init_8(void) +{ + struct PokenavSub7 *structPtr = AllocSubstruct(7, sizeof(struct PokenavSub7)); + if (structPtr == NULL) + return FALSE; + + structPtr->unkPtr = AllocSubstruct(18, sizeof(struct PokenavSub18)); + if (structPtr->unkPtr == NULL) + return FALSE; + + structPtr->unk0 = sub_81CF010; + structPtr->loopedTaskId = CreateLoopedTask(sub_81CF11C, 1); + structPtr->unk18 = 0; + structPtr->unk14 = gUnknown_086233A0[GetSelectedConditionSearch()]; + return TRUE; +} + +bool32 PokenavCallback_Init_10(void) +{ + struct PokenavSub7 *structPtr = AllocSubstruct(7, sizeof(struct PokenavSub7)); + if (structPtr == NULL) + return FALSE; + + structPtr->unkPtr = GetSubstructPtr(18); + structPtr->unk0 = sub_81CF030; + structPtr->unk18 = 1; + structPtr->unk14 = gUnknown_086233A0[GetSelectedConditionSearch()]; + return TRUE; +} + +u32 sub_81CEFDC(void) +{ + struct PokenavSub7 *structPtr = GetSubstructPtr(7); + return structPtr->unk0(structPtr); +} + +void sub_81CEFF0(void) +{ + struct PokenavSub7 *structPtr = GetSubstructPtr(7); + if (structPtr->unk1C == 0) + FreePokenavSubstruct(18); + FreePokenavSubstruct(7); +} + +static bool32 sub_81CF010(struct PokenavSub7 *structPtr) +{ + if (!IsLoopedTaskActive(structPtr->loopedTaskId)) + structPtr->unk0 = sub_81CF030; + return FALSE; +} + +static u32 sub_81CF030(struct PokenavSub7 *structPtr) +{ + if (gMain.newAndRepeatedKeys & DPAD_UP) + return 1; + else if (gMain.newAndRepeatedKeys & DPAD_DOWN) + return 2; + else if (gMain.newKeys & DPAD_LEFT) + return 3; + else if (gMain.newKeys & DPAD_RIGHT) + return 4; + else if (gMain.newKeys & B_BUTTON) + { + structPtr->unk1C = 0; + structPtr->unk0 = sub_81CF0B0; + return 5; + } + else if (gMain.newKeys & A_BUTTON) + { + structPtr->unkPtr->unk2 = GetSelectedMatchCall(); + structPtr->unk1C = 1; + structPtr->unk0 = sub_81CF0B8; + return 6; + } + else + return 0; +} + +static u32 sub_81CF0B0(struct PokenavSub7 *structPtr) +{ + return 100003; +} + +static u32 sub_81CF0B8(struct PokenavSub7 *structPtr) +{ + return 100009; +} + +static u32 sub_81CF0C0(void) +{ + struct PokenavSub7 *structPtr = GetSubstructPtr(7); + return structPtr->unk18; +} + +static struct PokenavMonList * sub_81CF0D0(void) +{ + struct PokenavSub7 * ptr = GetSubstructPtr(7); + return ptr->unkPtr->unk4; +} + +static u16 sub_81CF0E0(void) +{ + struct PokenavSub7 * ptr = GetSubstructPtr(7); + return ptr->unkPtr->unk0; +} + +static s32 sub_81CF0F0(void) +{ + struct PokenavSub7 * ptr = GetSubstructPtr(7); + s32 i = GetSelectedMatchCall(); + return ptr->unkPtr->unk4[i].data; +} + +static u16 sub_81CF10C(void) +{ + struct PokenavSub7 * ptr = GetSubstructPtr(7); + return ptr->unkPtr->unk2; +} + +static u32 sub_81CF11C(s32 state) +{ + return gUnknown_086233B4[state](state); +} + +static u32 sub_81CF134(s32 state) +{ + s32 i; + struct PokenavMonList item; + struct PokenavSub7 * ptr = GetSubstructPtr(7); + + ptr->unkPtr->unk0 = 0; + ptr->unkPtr->unk2 = 0; + item.boxId = 14; + for (i = 0; i < PARTY_SIZE; i++) + { + struct Pokemon * pokemon = &gPlayerParty[i]; + if (!GetMonData(pokemon, MON_DATA_SANITY_HAS_SPECIES)) + return LT_INC_AND_CONTINUE; + if (!GetMonData(pokemon, MON_DATA_SANITY_IS_EGG)) + { + item.monId = i; + item.data = GetMonData(pokemon, ptr->unk14); + sub_81CF2C4(ptr, &item); + } + } + + return LT_INC_AND_CONTINUE; +} + +static u32 sub_81CF1C4(s32 state) +{ + struct PokenavSub7 * ptr = GetSubstructPtr(7); + ptr->unk10 = 0; + ptr->unkC = 0; + return LT_INC_AND_CONTINUE; +} + +static u32 sub_81CF1D8(s32 state) +{ + struct PokenavSub7 * ptr = GetSubstructPtr(7); + s32 boxId = ptr->unkC; + s32 monId = ptr->unk10; + s32 boxCount = 0; + struct PokenavMonList item; + + while (boxId < TOTAL_BOXES_COUNT) + { + while (monId < IN_BOX_COUNT) + { + if (CheckBoxMonSanityAt(boxId, monId)) + { + item.boxId = boxId; + item.monId = monId; + item.data = GetBoxMonDataAt(boxId, monId, ptr->unk14); + sub_81CF2C4(ptr, &item); + } + boxCount++; + monId++; + if (boxCount > 14) + { + ptr->unkC = boxId; + ptr->unk10 = monId; + return LT_CONTINUE; + } + } + monId = 0; + boxId++; + } + + return LT_INC_AND_CONTINUE; +} + +static u32 sub_81CF278(s32 state) +{ + struct PokenavSub7 * ptr = GetSubstructPtr(7); + s32 r6 = ptr->unkPtr->unk0; + s32 r4 = ptr->unkPtr->unk4[0].data; + s32 i; + ptr->unkPtr->unk4[0].data = 1; + for (i = 1; i < r6; i++) + { + if (ptr->unkPtr->unk4[i].data == r4) + { + ptr->unkPtr->unk4[i].data = ptr->unkPtr->unk4[i - 1].data; + } + else + { + r4 = ptr->unkPtr->unk4[i].data; + ptr->unkPtr->unk4[i].data = i + 1; + } + } + ptr->unk18 = 1; + return LT_FINISH; +} + +static void sub_81CF2C4(struct PokenavSub7 *structPtr, struct PokenavMonList *item) +{ + u32 left = 0; + u32 right = structPtr->unkPtr->unk0; + u32 insertionIdx = left + (right - left) / 2; + + while (right != insertionIdx) + { + if (item->data > structPtr->unkPtr->unk4[insertionIdx].data) + right = insertionIdx; + else + left = insertionIdx + 1; + insertionIdx = left + (right - left) / 2; + } + for (right = structPtr->unkPtr->unk0; right > insertionIdx; right--) + structPtr->unkPtr->unk4[right] = structPtr->unkPtr->unk4[right - 1]; + structPtr->unkPtr->unk4[insertionIdx] = *item; + structPtr->unkPtr->unk0++; +} + +bool32 sub_81CF330(void) +{ + struct PokenavSub8 * unk = AllocSubstruct(8, sizeof(struct PokenavSub8)); + if (unk == NULL) + return FALSE; + unk->ltid = CreateLoopedTask(sub_81CF418, 1); + unk->callback = sub_81CF3E4; + unk->unkC = FALSE; + return TRUE; +} + +bool32 sub_81CF368(void) +{ + struct PokenavSub8 * unk = AllocSubstruct(8, sizeof(struct PokenavSub8)); + if (unk == NULL) + return FALSE; + unk->ltid = CreateLoopedTask(sub_81CF418, 1); + unk->callback = sub_81CF3E4; + unk->unkC = TRUE; + return TRUE; +} + +void sub_81CF3A0(s32 idx) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + unk->ltid = CreateLoopedTask(gUnknown_08623598[idx], 1); + unk->callback = sub_81CF3E4; +} + +bool32 sub_81CF3D0(void) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + return unk->callback(); +} + +bool32 sub_81CF3E4(void) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + return IsLoopedTaskActive(unk->ltid); +} + +void sub_81CF3F8(void) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + sub_81C8234(); + RemoveWindow(unk->winid); + FreePokenavSubstruct(8); +} + +static u32 sub_81CF418(s32 state) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + switch (state) + { + case 0: + InitBgTemplates(gUnknown_08623590, NELEMS(gUnknown_08623590)); + decompress_and_copy_tile_data_to_vram(1, gUnknown_086233E4, 0, 0, 0); + SetBgTilemapBuffer(1, unk->buff); + CopyToBgTilemapBuffer(1, gUnknown_086234AC, 0, 0); + CopyBgTilemapBufferToVram(1); + CopyPaletteIntoBufferUnfaded(gUnknown_086233C4, 0x10, 0x20); + CopyBgTilemapBufferToVram(1); + return LT_INC_AND_PAUSE; + case 1: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + if (!sub_81CF0C0()) + return LT_PAUSE; + return LT_INC_AND_PAUSE; + case 2: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + CopyPaletteIntoBufferUnfaded(gUnknown_08623570, 0x20, 0x20); + sub_81CF88C(); + return LT_INC_AND_PAUSE; + case 3: + if (sub_81C8224()) + return LT_PAUSE; + sub_81CF7C8(unk); + PrintHelpBarText(HELPBAR_CONDITION_MON_LIST); + return LT_INC_AND_PAUSE; + case 4: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ShowBg(1); + ShowBg(2); + HideBg(3); + if (!unk->unkC) + { + u8 r4 = GetSelectedConditionSearch() + POKENAV_MENUITEM_CONDITION_SEARCH_COOL; + LoadLeftHeaderGfxForIndex(r4); + sub_81C7FA0(r4, 1, 0); + sub_81C7FA0(1, 1, 0); + } + sub_81C7AC0(1); + return LT_INC_AND_PAUSE; + case 5: + if (IsPaletteFadeActive()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81CF578(s32 state) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + switch (state) + { + case 0: + switch (MatchCall_MoveCursorUp()) + { + case 0: + return LT_FINISH; + case 1: + PlaySE(SE_SELECT); + return LT_SET_STATE(2); + case 2: + PlaySE(SE_SELECT); + break; + } + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + // fallthrough + case 2: + sub_81CF7F4(unk); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81CF5F0(s32 state) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + switch (state) + { + case 0: + switch (MatchCall_MoveCursorDown()) + { + case 0: + return LT_FINISH; + case 1: + PlaySE(SE_SELECT); + return LT_SET_STATE(2); + case 2: + PlaySE(SE_SELECT); + break; + } + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + // fallthrough + case 2: + sub_81CF7F4(unk); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81CF668(s32 state) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + switch (state) + { + case 0: + switch (MatchCall_PageUp()) + { + case 0: + return LT_FINISH; + case 1: + PlaySE(SE_SELECT); + return LT_SET_STATE(2); + case 2: + PlaySE(SE_SELECT); + break; + } + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + // fallthrough + case 2: + sub_81CF7F4(unk); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81CF6E0(s32 state) +{ + struct PokenavSub8 * unk = GetSubstructPtr(8); + switch (state) + { + case 0: + switch (MatchCall_PageDown()) + { + case 0: + return LT_FINISH; + case 1: + PlaySE(SE_SELECT); + return LT_SET_STATE(2); + case 2: + PlaySE(SE_SELECT); + break; + } + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + // fallthrough + case 2: + sub_81CF7F4(unk); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81CF758(s32 state) +{ + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81C7AC0(0); + sub_81C78A0(); + return LT_INC_AND_PAUSE; + case 1: + if (IsPaletteFadeActive()) + return LT_PAUSE; + if (MainMenuLoopedTaskIsBusy()) + return LT_PAUSE; + sub_81C7FDC(); + break; + } + return LT_FINISH; +} + +static u32 sub_81CF798(s32 state) +{ + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81C7AC0(0); + return LT_INC_AND_PAUSE; + case 1: + if (IsPaletteFadeActive()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static void sub_81CF7C8(struct PokenavSub8 * ptr) +{ + ptr->winid = AddWindow(&gUnknown_086235B4); + PutWindowTilemap(ptr->winid); + CopyWindowToVram(ptr->winid, 1); + sub_81CF7F4(ptr); +} + +static void sub_81CF7F4(struct PokenavSub8 * ptr) +{ + s32 r7 = sub_81CF0F0(); + DynamicPlaceholderTextUtil_Reset(); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1); + *gStringVar1 = EOS; + DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar2, gText_NumberF700); + AddTextPrinterParameterized(ptr->winid, 1, gStringVar2, 4, 1, 0xFF, NULL); + ConvertIntToDecimalStringN(gStringVar1, r7, STR_CONV_MODE_RIGHT_ALIGN, 3); + AddTextPrinterParameterized(ptr->winid, 1, gStringVar1, 34, 1, 0xFF, NULL); + CopyWindowToVram(ptr->winid, 2); +} + +static void sub_81CF88C(void) +{ + struct PokenavListTemplate template; + template.list.monList = sub_81CF0D0(); + template.unk4 = sub_81CF0E0(); + template.unk8 = 4; + template.unk6 = sub_81CF10C(); + template.unk9 = 13; + template.unkA = 17; + template.unkB = 1; + template.unkC = 8; + template.unkD = 2; + template.unkE = 1; + template.listFunc.unk10_1 = sub_81CF8E4; + template.unk14 = NULL; + sub_81C81D4(&gUnknown_08623590[1], &template, 0); +} + +static void sub_81CF8E4(struct PokenavMonList * item, u8 * dest) +{ + u8 gender; + u8 level; + u8 * s; + const u8 * genderStr; + + // Mon is in party + if (item->boxId == TOTAL_BOXES_COUNT) + { + struct Pokemon * mon = &gPlayerParty[item->monId]; + gender = GetMonGender(mon); + level = GetLevelFromMonExp(mon); + GetMonData(mon, MON_DATA_NICKNAME, gStringVar3); + } + // Mon is in PC + else + { + struct BoxPokemon * mon = GetBoxedMonPtr(item->boxId, item->monId); + gender = GetBoxMonGender(mon); + level = GetLevelFromBoxMonExp(mon); + GetBoxMonData(mon, MON_DATA_NICKNAME, gStringVar3); + } + + StringGetEnd10(gStringVar3); + dest = sub_81DB494(dest, 1, gStringVar3, 60); + switch (gender) + { + default: + genderStr = sText_NoGenderSymbol; + break; + case MON_MALE: + genderStr = sText_MaleSymbol; + break; + case MON_FEMALE: + genderStr = sText_FemaleSymbol; + break; + } + s = StringCopy(gStringVar1, genderStr); + *s++ = CHAR_SLASH; + *s++ = CHAR_SPECIAL_F9; + *s++ = CHAR_LV_2; + ConvertIntToDecimalStringN(s, level, STR_CONV_MODE_LEFT_ALIGN, 3); + sub_81DB494(dest, 1, gStringVar1, 40); +} diff --git a/src/pokenav_match_call_1.c b/src/pokenav_match_call_1.c new file mode 100755 index 000000000..28e84b50b --- /dev/null +++ b/src/pokenav_match_call_1.c @@ -0,0 +1,516 @@ +#include "global.h" +#include "battle_setup.h" +#include "data.h" +#include "event_data.h" +#include "gym_leader_rematch.h" +#include "international_string_util.h" +#include "main.h" +#include "match_call.h" +#include "overworld.h" +#include "pokemon.h" +#include "pokenav.h" +#include "sound.h" +#include "string_util.h" +#include "strings.h" +#include "constants/flags.h" +#include "constants/songs.h" + +struct Pokenav3Struct +{ + u16 optionCursorPos; + u16 maxOptionId; + const u8 *matchCallOptions; + u16 headerId; + u16 numRegistered; + u16 unkC; + u32 unk10; + u32 unk14; + u32 (*callback)(struct Pokenav3Struct*); + struct PokenavMatchCallEntries matchCallEntries[MAX_REMATCH_ENTRIES - 1]; +}; + +static u32 CB2_HandleMatchCallInput(struct Pokenav3Struct *); +static u32 sub_81CABFC(struct Pokenav3Struct *); +static u32 CB2_HandleMatchCallOptionsInput(struct Pokenav3Struct *); +static u32 CB2_HandleCheckPageInput(struct Pokenav3Struct *); +static u32 CB2_HandleCallInput(struct Pokenav3Struct *); +static u32 sub_81CAD20(s32); +static bool32 sub_81CB1D0(void); + +#include "data/text/match_call_messages.h" + +static const u8 sMatchCallOptionsNoCheckPage[] = +{ + MATCH_CALL_OPTION_CALL, + MATCH_CALL_OPTION_CANCEL +}; + +static const u8 sMatchCallOptionsHasCheckPage[] = +{ + MATCH_CALL_OPTION_CALL, + MATCH_CALL_OPTION_CHECK, + MATCH_CALL_OPTION_CANCEL +}; + +bool32 PokenavCallback_Init_11(void) +{ + struct Pokenav3Struct *state = AllocSubstruct(5, sizeof(struct Pokenav3Struct)); + if (!state) + return FALSE; + + state->callback = CB2_HandleMatchCallInput; + state->headerId = 0; + state->unk10 = 0; + state->unk14 = CreateLoopedTask(sub_81CAD20, 1); + return TRUE; +} + +u32 sub_81CAB24(void) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + return state->callback(state); +} + +void sub_81CAB38(void) +{ + FreePokenavSubstruct(5); +} + +static u32 CB2_HandleMatchCallInput(struct Pokenav3Struct *state) +{ + int selection; + + if (gMain.newAndRepeatedKeys & DPAD_UP) + return POKENAV_MC_FUNC_UP; + if (gMain.newAndRepeatedKeys & DPAD_DOWN) + return POKENAV_MC_FUNC_DOWN; + if (gMain.newAndRepeatedKeys & DPAD_LEFT) + return POKENAV_MC_FUNC_PG_UP; + if (gMain.newAndRepeatedKeys & DPAD_RIGHT) + return POKENAV_MC_FUNC_PG_DOWN; + + if (gMain.newKeys & A_BUTTON) + { + state->callback = CB2_HandleMatchCallOptionsInput; + state->optionCursorPos = 0; + selection = GetSelectedMatchCall(); + + if (!state->matchCallEntries[selection].isSpecialTrainer || MatchCall_HasCheckPage(state->matchCallEntries[selection].headerId)) + { + state->matchCallOptions = sMatchCallOptionsHasCheckPage; + state->maxOptionId = ARRAY_COUNT(sMatchCallOptionsHasCheckPage) - 1; + } + else + { + state->matchCallOptions = sMatchCallOptionsNoCheckPage; + state->maxOptionId = ARRAY_COUNT(sMatchCallOptionsNoCheckPage) - 1; + } + + return POKENAV_MC_FUNC_SELECT; + } + + if (gMain.newKeys & B_BUTTON) + { + if (GetPokenavMode() != POKENAV_MODE_FORCE_CALL_READY) + { + state->callback = sub_81CABFC; + return POKENAV_MC_FUNC_EXIT; + } + else + { + // Cant exit Match Call menu before calling Mr Stone during tutorial + PlaySE(SE_HAZURE); + } + } + + return POKENAV_MC_FUNC_NONE; +} + +static u32 sub_81CABFC(struct Pokenav3Struct *state) +{ + return POKENAV_MENU_4; +} + +static u32 CB2_HandleMatchCallOptionsInput(struct Pokenav3Struct *state) +{ + if ((gMain.newKeys & DPAD_UP) && state->optionCursorPos) + { + state->optionCursorPos--; + return POKENAV_MC_FUNC_MOVE_OPTIONS_CURSOR; + } + + if ((gMain.newKeys & DPAD_DOWN) && state->optionCursorPos < state->maxOptionId) + { + state->optionCursorPos++; + return POKENAV_MC_FUNC_MOVE_OPTIONS_CURSOR; + } + + if (gMain.newKeys & A_BUTTON) + { + switch (state->matchCallOptions[state->optionCursorPos]) + { + case MATCH_CALL_OPTION_CANCEL: + state->callback = CB2_HandleMatchCallInput; + return POKENAV_MC_FUNC_CANCEL; + case MATCH_CALL_OPTION_CALL: + if (GetPokenavMode() == POKENAV_MODE_FORCE_CALL_READY) + SetPokenavMode(POKENAV_MODE_FORCE_CALL_EXIT); + + state->callback = CB2_HandleCallInput; + if (sub_81CB1D0()) + return POKENAV_MC_FUNC_NEARBY_MSG; + + return POKENAV_MC_FUNC_CALL_MSG; + case MATCH_CALL_OPTION_CHECK: + state->callback = CB2_HandleCheckPageInput; + return POKENAV_MC_FUNC_SHOW_CHECK_PAGE; + } + } + + if (gMain.newKeys & B_BUTTON) + { + state->callback = CB2_HandleMatchCallInput; + return POKENAV_MC_FUNC_CANCEL; + } + + return POKENAV_MC_FUNC_NONE; +} + +static u32 CB2_HandleCheckPageInput(struct Pokenav3Struct *state) +{ + if (gMain.newAndRepeatedKeys & DPAD_UP) + return POKENAV_MC_FUNC_CHECK_PAGE_UP; + if (gMain.newAndRepeatedKeys & DPAD_DOWN) + return POKENAV_MC_FUNC_CHECK_PAGE_DOWN; + + if (gMain.newKeys & B_BUTTON) + { + state->callback = CB2_HandleMatchCallInput; + return POKENAV_MC_FUNC_EXIT_CHECK_PAGE; + } + + return POKENAV_MC_FUNC_NONE; +} + +static u32 CB2_HandleCallInput(struct Pokenav3Struct *state) +{ + if (gMain.newKeys & (A_BUTTON | B_BUTTON)) + { + state->callback = CB2_HandleMatchCallInput; + return POKENAV_MC_FUNC_10; + } + + return POKENAV_MC_FUNC_NONE; +} + +static u32 sub_81CAD20(s32 taskState) +{ + int i, j; + struct Pokenav3Struct *state = GetSubstructPtr(5); + switch (taskState) + { + case 0: + state->headerId = 0; + state->numRegistered = 0; + return LT_INC_AND_CONTINUE; + case 1: + for (i = 0, j = state->headerId; i < 30; i++, j++) + { + if (MatchCall_GetEnabled(j)) + { + state->matchCallEntries[state->numRegistered].headerId = j; + state->matchCallEntries[state->numRegistered].isSpecialTrainer = TRUE; + state->matchCallEntries[state->numRegistered].mapSec = MatchCall_GetMapSec(j); + state->numRegistered++; + } + + if (++state->headerId >= MC_HEADER_COUNT) + { + state->unkC = state->headerId; + state->headerId = 0; + return LT_INC_AND_CONTINUE; + } + } + + return LT_CONTINUE; + case 2: + for (i = 0, j = state->headerId; i < 30; i++, j++) + { + if (!MatchCall_HasRematchId(state->headerId) && IsRematchEntryRegistered(state->headerId)) + { + state->matchCallEntries[state->numRegistered].headerId = state->headerId; + state->matchCallEntries[state->numRegistered].isSpecialTrainer = FALSE; + state->matchCallEntries[state->numRegistered].mapSec = sub_81CB0C8(j); + state->numRegistered++; + } + + if (++state->headerId > REMATCH_TABLE_ENTRIES - 1) + return LT_INC_AND_CONTINUE; + } + + return LT_CONTINUE; + case 3: + state->unk10 = 1; + break; + } + + return LT_FINISH; +} + +bool32 IsRematchEntryRegistered(int rematchIndex) +{ + if (rematchIndex < REMATCH_TABLE_ENTRIES) + return FlagGet(FLAG_MATCH_CALL_REGISTERED + rematchIndex); + + return FALSE; +} + +int sub_81CAE28(void) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + return state->unk10; +} + +int GetNumberRegistered(void) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + return state->numRegistered; +} + +int sub_81CAE48(void) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + return state->unkC; +} + +int unref_sub_81CAE58(void) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + return state->numRegistered - state->unkC; +} + +int unref_sub_81CAE6C(int arg0) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + arg0 += state->unkC; + if (arg0 >= state->numRegistered) + return REMATCH_TABLE_ENTRIES; + + return state->matchCallEntries[arg0].headerId; +} + +struct PokenavMatchCallEntries *sub_81CAE94(void) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + return state->matchCallEntries; +} + +u16 GetMatchCallMapSec(int index) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + return state->matchCallEntries[index].mapSec; +} + +bool32 ShouldDrawRematchPokeballIcon(int index) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + if (!state->matchCallEntries[index].isSpecialTrainer) + index = state->matchCallEntries[index].headerId; + else + index = MatchCall_GetRematchTableIdx(state->matchCallEntries[index].headerId); + + if (index == REMATCH_TABLE_ENTRIES) + return FALSE; + + return gSaveBlock1Ptr->trainerRematches[index] != 0; +} + +int GetMatchCallTrainerPic(int index) +{ + int headerId; + struct Pokenav3Struct *state = GetSubstructPtr(5); + if (!state->matchCallEntries[index].isSpecialTrainer) + { + index = GetTrainerIdxByRematchIdx(state->matchCallEntries[index].headerId); + return gTrainers[index].trainerPic; + } + + headerId = state->matchCallEntries[index].headerId; + index = MatchCall_GetRematchTableIdx(headerId); + if (index != REMATCH_TABLE_ENTRIES) + { + index = GetTrainerIdxByRematchIdx(index); + return gTrainers[index].trainerPic; + } + + index = MatchCall_GetOverrideFacilityClass(headerId); + return gFacilityClassToPicIndex[index]; +} + +const u8 *GetMatchCallMessageText(int index, u8 *arg1) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + *arg1 = 0; + if (!Overworld_MapTypeAllowsTeleportAndFly(gMapHeader.mapType)) + return gText_CallCantBeMadeHere; + + if (!state->matchCallEntries[index].isSpecialTrainer) + *arg1 = SelectMatchCallMessage(GetTrainerIdxByRematchIdx(state->matchCallEntries[index].headerId), gStringVar4); + else + MatchCall_GetMessage(state->matchCallEntries[index].headerId, gStringVar4); + + return gStringVar4; +} + +const u8 *GetMatchCallFlavorText(int index, int checkPageEntry) +{ + int rematchId; + struct Pokenav3Struct *state = GetSubstructPtr(5); + if (state->matchCallEntries[index].isSpecialTrainer) + { + rematchId = MatchCall_GetRematchTableIdx(state->matchCallEntries[index].headerId); + if (rematchId == REMATCH_TABLE_ENTRIES) + return MatchCall_GetOverrideFlavorText(state->matchCallEntries[index].headerId, checkPageEntry); + } + else + { + rematchId = state->matchCallEntries[index].headerId; + } + + return gMatchCallFlavorTexts[rematchId][checkPageEntry]; +} + +u16 GetMatchCallOptionCursorPos(void) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + return state->optionCursorPos; +} + +u16 GetMatchCallOptionId(int optionId) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + if (state->maxOptionId < optionId) + return MATCH_CALL_OPTION_COUNT; + + return state->matchCallOptions[optionId]; +} + +void BufferMatchCallNameAndDesc(struct PokenavMatchCallEntries *matchCallEntry, u8 *str) +{ + const u8 *trainerName; + const u8 *className; + if (!matchCallEntry->isSpecialTrainer) + { + int index = GetTrainerIdxByRematchIdx(matchCallEntry->headerId); + const struct Trainer *trainer = &gTrainers[index]; + int class = trainer->trainerClass; + className = gTrainerClassNames[class]; + trainerName = trainer->trainerName; + } + else + { + MatchCall_GetNameAndDesc(matchCallEntry->headerId, &className, &trainerName); + } + + if (className && trainerName) + { + u8 *str2 = sub_81DB494(str, 7, className, 69); + sub_81DB494(str2, 7, trainerName, 51); + } + else + { + sub_81DB494(str, 7, NULL, 120); + } +} + +u8 sub_81CB0C8(int rematchIndex) +{ + int mapGroup = gRematchTable[rematchIndex].mapGroup; + int mapNum = gRematchTable[rematchIndex].mapNum; + return Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum)->regionMapSectionId; +} + +int GetIndexDeltaOfNextCheckPageDown(int index) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + int count = 1; + while (++index < state->numRegistered) + { + if (!state->matchCallEntries[index].isSpecialTrainer) + return count; + if (MatchCall_HasCheckPage(state->matchCallEntries[index].headerId)) + return count; + + count++; + } + + return 0; +} + +int GetIndexDeltaOfNextCheckPageUp(int index) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + int count = -1; + while (--index >= 0) + { + if (!state->matchCallEntries[index].isSpecialTrainer) + return count; + if (MatchCall_HasCheckPage(state->matchCallEntries[index].headerId)) + return count; + + count--; + } + + return 0; +} + +bool32 unref_sub_81CB16C(void) +{ + int i; + + for (i = 0; i < REMATCH_TABLE_ENTRIES; i++) + { + if (IsRematchEntryRegistered(i) && gSaveBlock1Ptr->trainerRematches[i]) + return TRUE; + } + + for (i = 0; i < MC_HEADER_COUNT; i++) + { + if (MatchCall_GetEnabled(i)) + { + int index = MatchCall_GetRematchTableIdx(i); + if (gSaveBlock1Ptr->trainerRematches[index]) + return TRUE; + } + } + + return FALSE; +} + +static bool32 sub_81CB1D0(void) +{ + struct Pokenav3Struct *state = GetSubstructPtr(5); + int selection = GetSelectedMatchCall(); + if (!state->matchCallEntries[selection].isSpecialTrainer) + { + if (GetMatchCallMapSec(selection) == gMapHeader.regionMapSectionId) + { + if (!gSaveBlock1Ptr->trainerRematches[state->matchCallEntries[selection].headerId]) + return TRUE; + } + } + else + { + if (state->matchCallEntries[selection].headerId == MC_HEADER_WATTSON) + { + if (GetMatchCallMapSec(selection) == gMapHeader.regionMapSectionId + && FlagGet(FLAG_BADGE05_GET) == TRUE) + { + if (!FlagGet(FLAG_WATTSON_REMATCH_AVAILABLE)) + return TRUE; + } + } + } + + return FALSE; +} diff --git a/src/pokenav_match_call_2.c b/src/pokenav_match_call_2.c new file mode 100755 index 000000000..aaa1767aa --- /dev/null +++ b/src/pokenav_match_call_2.c @@ -0,0 +1,1279 @@ +#include "global.h" +#include "bg.h" +#include "data.h" +#include "decompress.h" +#include "dma3.h" +#include "international_string_util.h" +#include "main.h" +#include "match_call.h" +#include "menu.h" +#include "overworld.h" +#include "palette.h" +#include "pokenav.h" +#include "region_map.h" +#include "sound.h" +#include "sprite.h" +#include "string_util.h" +#include "strings.h" +#include "task.h" +#include "text.h" +#include "text_window.h" +#include "trig.h" +#include "window.h" +#include "constants/game_stat.h" +#include "constants/region_map_sections.h" +#include "constants/songs.h" +#include "constants/species.h" + +struct Pokenav4Struct +{ + bool32 (*unk0)(void); + u32 unk4; + u8 filler8[0x6]; + u8 unkE; + u8 unkF; + u16 locWindowId; + u16 infoBoxWindowId; + u16 msgBoxWindowId; + s16 unk16; + u8 unused18; + u8 unk19; + u16 unk1A; + struct Sprite *optionsCursorSprite; + struct Sprite *trainerPicSprite; + u8 unk24[0x800]; + u8 unk824[0x800]; + u8 unk1024[0x800]; + u8 *unk1824; + u8 unk1828[0x800]; + u8 unk2028[0x20]; +}; + +static bool32 sub_81CB310(void); +static u32 sub_81CB324(s32); +static void sub_81CBBB8(void); +static void sub_81CBC1C(void); +static void sub_81CC2B4(void); +static void sub_81CC034(struct Pokenav4Struct *); +static void DrawMatchCallLeftColumnWindows(struct Pokenav4Struct *); +static void UpdateMatchCallInfoBox(struct Pokenav4Struct *); +static void PrintMatchCallLocation(struct Pokenav4Struct *, int); +static void sub_81CC214(void); +static void sub_81CBC38(int); +static void PrintMatchCallSelectionOptions(struct Pokenav4Struct *); +static bool32 sub_81CBFC4(struct Pokenav4Struct *); +static void UpdateCursorGfxPos(struct Pokenav4Struct *, int); +static bool32 IsDma3ManagerBusyWithBgCopy1(struct Pokenav4Struct *); +static void UpdateWindowsReturnToTrainerList(struct Pokenav4Struct *); +static void DrawMsgBoxForMatchCallMsg(struct Pokenav4Struct *); +static bool32 IsDma3ManagerBusyWithBgCopy2(struct Pokenav4Struct *); +static void PrintCallingDots(struct Pokenav4Struct *); +static bool32 WaitForCallingDotsText(struct Pokenav4Struct *); +static void PrintMatchCallMessage(struct Pokenav4Struct *); +static bool32 WaitForMatchCallMessageText(struct Pokenav4Struct *); +static void DrawMsgBoxForCloseByMsg(struct Pokenav4Struct *); +static void PrintTrainerIsCloseBy(struct Pokenav4Struct *); +static bool32 WaitForTrainerIsCloseByText(struct Pokenav4Struct *); +static void DrawSpinningPokenavForCall(struct Pokenav4Struct *); +static bool32 WaitForSpinningPokenav(struct Pokenav4Struct *); +static void UpdateWindowsToShowCheckPage(struct Pokenav4Struct *); +static void LoadCheckPageTrainerPic(struct Pokenav4Struct *); +static bool32 WaitForTrainerPic(struct Pokenav4Struct *); +static void TrainerPicSlideOffscreen(struct Pokenav4Struct *); +static void sub_81CBC64(u8 taskId); +static void TryDrawRematchPokeballIcon(u16 windowId, u32, u32); +static void PrintNumberRegisteredLabel(u16 windowId); +static void PrintNumberRegistered(u16 windowId); +static void PrintNumberOfBattlesLabel(u16 windowId); +static void PrintNumberOfBattles(u16 windowId); +static void PrintMatchCallInfoLabel(u16 windowId, const u8 *str, int top); +static void PrintMatchCallInfoNumber(u16 windowId, const u8 *str, int top); +static void sub_81CC2F0(struct Pokenav4Struct *, int); +static void CloseMatchCallSelectOptionsWindow(struct Pokenav4Struct *); +static struct Sprite *CreateTrainerPicSprite(void); +static void SpriteCB_TrainerPicSlideOnscreen(struct Sprite *sprite); +static void SpriteCB_TrainerPicSlideOffscreen(struct Sprite *sprite); +void SpriteCB_OptionsCursor(struct Sprite *sprite); +u32 MatchCallListCursorDown(s32); +u32 MatchCallListCursorUp(s32); +u32 MatchCallListPageDown(s32); +u32 MatchCallListPageUp(s32); +u32 SelectMatchCallEntry(s32); +u32 MoveMatchCallOptionsCursor(s32); +static u32 CancelMatchCallSelection(s32); +u32 DoMatchCallMessage(s32); +u32 DoTrainerCloseByMessage(s32); +u32 sub_81CB888(s32); +u32 ShowCheckPage(s32); +u32 ShowCheckPageUp(s32); +u32 ShowCheckPageDown(s32); +u32 ExitCheckPage(s32); +u32 ExitMatchCall(s32); + +static const u16 sMatchCallUI_Pal[] = INCBIN_U16("graphics/pokenav/ui_matchcall.gbapal"); +static const u32 sMatchCallUI_Gfx[] = INCBIN_U32("graphics/pokenav/ui_matchcall.4bpp.lz"); +static const u32 sMatchCallUI_Tilemap[] = INCBIN_U32("graphics/pokenav/ui_matchcall.bin.lz"); +static const u16 gUnknown_08622698[] = INCBIN_U16("graphics/pokenav/arrow2.gbapal"); +static const u32 gUnknown_086226B8[] = INCBIN_U32("graphics/pokenav/arrow2.4bpp.lz"); +static const u16 gUnknown_086226E0[] = INCBIN_U16("graphics/pokenav/86226E0.gbapal"); +static const u16 gUnknown_08622700[] = INCBIN_U16("graphics/pokenav/8622700.gbapal"); +static const u16 gUnknown_08622720[] = INCBIN_U16("graphics/pokenav/pokeball_matchcall.gbapal"); +static const u32 gUnknown_08622760[] = INCBIN_U32("graphics/pokenav/pokeball_matchcall.4bpp.lz"); + +const struct BgTemplate gUnknown_0862278C[3] = +{ + { + .bg = 1, + .charBaseIndex = 3, + .mapBaseIndex = 0x1F, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0 + }, + { + .bg = 2, + .charBaseIndex = 2, + .mapBaseIndex = 0x06, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0x80 + }, + { + .bg = 3, + .charBaseIndex = 1, + .mapBaseIndex = 0x07, + .screenSize = 0, + .paletteMode = 0, + .priority = 3, + .baseTile = 0 + } +}; + +static const LoopedTask sMatchCallLoopTaskFuncs[] = +{ + [POKENAV_MC_FUNC_NONE] = NULL, + [POKENAV_MC_FUNC_DOWN] = MatchCallListCursorDown, + [POKENAV_MC_FUNC_UP] = MatchCallListCursorUp, + [POKENAV_MC_FUNC_PG_DOWN] = MatchCallListPageDown, + [POKENAV_MC_FUNC_PG_UP] = MatchCallListPageUp, + [POKENAV_MC_FUNC_SELECT] = SelectMatchCallEntry, + [POKENAV_MC_FUNC_MOVE_OPTIONS_CURSOR] = MoveMatchCallOptionsCursor, + [POKENAV_MC_FUNC_CANCEL] = CancelMatchCallSelection, + [POKENAV_MC_FUNC_CALL_MSG] = DoMatchCallMessage, + [POKENAV_MC_FUNC_NEARBY_MSG] = DoTrainerCloseByMessage, + [POKENAV_MC_FUNC_10] = sub_81CB888, + [POKENAV_MC_FUNC_SHOW_CHECK_PAGE] = ShowCheckPage, + [POKENAV_MC_FUNC_CHECK_PAGE_UP] = ShowCheckPageUp, + [POKENAV_MC_FUNC_CHECK_PAGE_DOWN] = ShowCheckPageDown, + [POKENAV_MC_FUNC_EXIT_CHECK_PAGE] = ExitCheckPage, + [POKENAV_MC_FUNC_EXIT] = ExitMatchCall +}; + +static const struct WindowTemplate sMatchCallLocationWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 0, + .tilemapTop = 5, + .width = 11, + .height = 2, + .paletteNum = 2, + .baseBlock = 16 +}; + +static const struct WindowTemplate sMatchCallInfoBoxWindowTemplate = +{ + .bg = 2, + .tilemapLeft = 0, + .tilemapTop = 9, + .width = 11, + .height = 8, + .paletteNum = 2, + .baseBlock = 38 +}; + +static const u8 *const sMatchCallOptionTexts[MATCH_CALL_OPTION_COUNT] = +{ + [MATCH_CALL_OPTION_CALL] = gText_Call, + [MATCH_CALL_OPTION_CHECK] = gText_Check, + [MATCH_CALL_OPTION_CANCEL] = gText_Cancel6 +}; + +// The series of 5 dots that appear when someone is called with Match Call +static const u8 sText_CallingDots[] = _("·{PAUSE 0x04}·{PAUSE 0x04}·{PAUSE 0x04}·{PAUSE 0x04}·\p"); + +static const struct WindowTemplate sCallMsgBoxWindowTemplate = +{ + .bg = 1, + .tilemapLeft = 1, + .tilemapTop = 12, + .width = 0x1C, + .height = 0x04, + .paletteNum = 1, + .baseBlock = 10 +}; + +const struct CompressedSpriteSheet gUnknown_08622810[1] = +{ + {gUnknown_086226B8, 0x40, 7} +}; + +const struct SpritePalette gUnknown_08622818[2] = +{ + {gUnknown_08622698, 12} +}; + +static const struct OamData sOptionsCursorOamData = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x16), + .x = 0, + .size = SPRITE_SIZE(8x16), + .tileNum = 0, + .priority = 1, + .paletteNum = 0, +}; + +static const struct SpriteTemplate sOptionsCursorSpriteTemplate = +{ + .tileTag = 7, + .paletteTag = 12, + .oam = &sOptionsCursorOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCB_OptionsCursor, +}; + +static const struct OamData sTrainerPicOamData = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0, + .priority = 1, + .paletteNum = 0, +}; + +static const struct SpriteTemplate sTrainerPicSpriteTemplate = +{ + .tileTag = 8, + .paletteTag = 13, + .oam = &sTrainerPicOamData, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +bool32 sub_81CB260(void) +{ + struct Pokenav4Struct *state = AllocSubstruct(6, sizeof(struct Pokenav4Struct)); + if (!state) + return FALSE; + + state->unk19 = 0; + state->unk4 = CreateLoopedTask(sub_81CB324, 1); + state->unk0 = sub_81CB310; + return TRUE; +} + +void CreateMatchCallLoopedTask(s32 index) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + state->unk4 = CreateLoopedTask(sMatchCallLoopTaskFuncs[index], 1); + state->unk0 = sub_81CB310; +} + +u32 sub_81CB2CC(void) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + return state->unk0(); +} + +void sub_81CB2E0(void) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + sub_81CC2B4(); + sub_81CBC1C(); + RemoveWindow(state->infoBoxWindowId); + RemoveWindow(state->locWindowId); + RemoveWindow(state->msgBoxWindowId); + FreePokenavSubstruct(6); +} + +static bool32 sub_81CB310(void) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + return IsLoopedTaskActive(state->unk4); +} + +static u32 sub_81CB324(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + InitBgTemplates(gUnknown_0862278C, ARRAY_COUNT(gUnknown_0862278C)); + ChangeBgX(2, 0, 0); + ChangeBgY(2, 0, 0); + decompress_and_copy_tile_data_to_vram(2, sMatchCallUI_Gfx, 0, 0, 0); + SetBgTilemapBuffer(2, state->unk1024); + CopyToBgTilemapBuffer(2, sMatchCallUI_Tilemap, 0, 0); + CopyBgTilemapBufferToVram(2); + CopyPaletteIntoBufferUnfaded(sMatchCallUI_Pal, 0x20, 0x20); + CopyBgTilemapBufferToVram(2); + return LT_INC_AND_PAUSE; + case 1: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + + sub_8199DF0(1, 0, 0, 1); + SetBgTilemapBuffer(1, state->unk24); + FillBgTilemapBufferRect_Palette0(1, 0x1000, 0, 0, 32, 20); + CopyPaletteIntoBufferUnfaded(gUnknown_086226E0, 0x10, 0x20); + CopyBgTilemapBufferToVram(1); + return LT_INC_AND_PAUSE; + case 2: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + + sub_81CC034(state); + decompress_and_copy_tile_data_to_vram(3, gUnknown_08622760, 0, 0, 0); + CopyPaletteIntoBufferUnfaded(gUnknown_08622700, 0x30, 0x20); + CopyPaletteIntoBufferUnfaded(gUnknown_08622720, 0x50, 0x20); + return LT_INC_AND_PAUSE; + case 3: + if (free_temp_tile_data_buffers_if_possible() || !sub_81CAE28()) + return LT_PAUSE; + + sub_81CBBB8(); + return LT_INC_AND_PAUSE; + case 4: + if (sub_81C8224()) + return LT_PAUSE; + + DrawMatchCallLeftColumnWindows(state); + return LT_INC_AND_PAUSE; + case 5: + UpdateMatchCallInfoBox(state); + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 6: + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ShowBg(2); + ShowBg(3); + ShowBg(1); + sub_81CC214(); + LoadLeftHeaderGfxForIndex(3); + sub_81C7FA0(3, 1, 0); + sub_81C7AC0(1); + return LT_INC_AND_PAUSE; + case 7: + if (IsPaletteFadeActive() || sub_81C8010()) + return LT_PAUSE; + + sub_81CBC38(1); + return LT_FINISH; + default: + return LT_FINISH; + } +} + +u32 MatchCallListCursorDown(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + switch (MatchCall_MoveCursorDown()) + { + case 0: + break; + case 1: + PlaySE(SE_SELECT); + return 7; + case 2: + PlaySE(SE_SELECT); + // fall through + default: + return LT_INC_AND_PAUSE; + } + break; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 2: + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +u32 MatchCallListCursorUp(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + switch (MatchCall_MoveCursorUp()) + { + case 0: + break; + case 1: + PlaySE(SE_SELECT); + return 7; + case 2: + PlaySE(SE_SELECT); + // fall through + default: + return LT_INC_AND_PAUSE; + } + break; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 2: + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +u32 MatchCallListPageDown(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + switch (MatchCall_PageDown()) + { + case 0: + break; + case 1: + PlaySE(SE_SELECT); + return 7; + case 2: + PlaySE(SE_SELECT); + // fall through + default: + return LT_INC_AND_PAUSE; + } + break; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 2: + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +u32 MatchCallListPageUp(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + switch (MatchCall_PageUp()) + { + case 0: + break; + case 1: + PlaySE(SE_SELECT); + return 7; + case 2: + PlaySE(SE_SELECT); + // fall through + default: + return LT_INC_AND_PAUSE; + } + break; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 2: + PrintMatchCallLocation(state, 0); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +u32 SelectMatchCallEntry(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + PrintMatchCallSelectionOptions(state); + PrintHelpBarText(HELPBAR_MC_CALL_MENU); + return LT_INC_AND_PAUSE; + case 1: + if (sub_81CBFC4(state)) + return LT_PAUSE; + break; + } + + return LT_FINISH; +} + +u32 MoveMatchCallOptionsCursor(s32 taskState) +{ + struct Pokenav4Struct *state; + u16 cursorPos; + + PlaySE(SE_SELECT); + state = GetSubstructPtr(6); + cursorPos = GetMatchCallOptionCursorPos(); + UpdateCursorGfxPos(state, cursorPos); + return LT_FINISH; +} + +u32 CancelMatchCallSelection(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + UpdateWindowsReturnToTrainerList(state); + PrintHelpBarText(HELPBAR_MC_TRAINER_LIST); + return LT_INC_AND_PAUSE; + case 1: + if (IsDma3ManagerBusyWithBgCopy1(state)) + return LT_PAUSE; + break; + } + + return LT_FINISH; +} + +u32 DoMatchCallMessage(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + ToggleMatchCallVerticalArrows(TRUE); + DrawMsgBoxForMatchCallMsg(state); + return LT_INC_AND_PAUSE; + case 1: + if (IsDma3ManagerBusyWithBgCopy2(state)) + return LT_PAUSE; + + PrintCallingDots(state); + PlaySE(SE_TOREEYE); + state->unkE = 0; + return LT_INC_AND_PAUSE; + case 2: + if (WaitForCallingDotsText(state)) + return LT_PAUSE; + + PrintMatchCallMessage(state); + return LT_INC_AND_PAUSE; + case 3: + if (WaitForMatchCallMessageText(state)) + return LT_PAUSE; + break; + } + + return LT_FINISH; +} + +u32 DoTrainerCloseByMessage(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + DrawMsgBoxForCloseByMsg(state); + ToggleMatchCallVerticalArrows(TRUE); + state->unkE = 1; + return LT_INC_AND_PAUSE; + case 1: + if (IsDma3ManagerBusyWithBgCopy2(state)) + return LT_PAUSE; + + PrintTrainerIsCloseBy(state); + return LT_INC_AND_PAUSE; + case 2: + if (WaitForTrainerIsCloseByText(state)) + return LT_PAUSE; + break; + } + + return LT_FINISH; +} + +u32 sub_81CB888(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + u32 result = LT_INC_AND_PAUSE; + + switch (taskState) + { + case 0: + if (!state->unkE) + PlaySE(SE_TOREOFF); + + PlaySE(SE_SELECT); + break; + case 1: + DrawSpinningPokenavForCall(state); + break; + case 2: + if (WaitForSpinningPokenav(state)) + result = LT_PAUSE; + break; + case 3: + UpdateWindowsReturnToTrainerList(state); + break; + case 4: + if (IsDma3ManagerBusyWithBgCopy1(state)) + result = LT_PAUSE; + + PrintHelpBarText(HELPBAR_MC_TRAINER_LIST); + break; + case 5: + if (WaitForHelpBar()) + { + result = LT_PAUSE; + } + else + { + if (state->unkF) + { + sub_81C8838(); + result = LT_INC_AND_CONTINUE; + } + else + { + ToggleMatchCallVerticalArrows(FALSE); + result = LT_FINISH; + } + } + break; + case 6: + if (IsDma3ManagerBusyWithBgCopy()) + { + result = LT_PAUSE; + } + else + { + ToggleMatchCallVerticalArrows(FALSE); + result = LT_FINISH; + } + break; + } + + return result; +} + +u32 ShowCheckPage(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + sub_81C877C(); + UpdateWindowsToShowCheckPage(state); + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8820() || IsDma3ManagerBusyWithBgCopy1(state)) + return LT_PAUSE; + + PrintHelpBarText(HELPBAR_MC_CHECK_PAGE); + return LT_INC_AND_PAUSE; + case 2: + PrintCheckPageInfo(0); + LoadCheckPageTrainerPic(state); + return LT_INC_AND_PAUSE; + case 3: + if (sub_81C8820() || WaitForTrainerPic(state) || WaitForHelpBar()) + return LT_PAUSE; + break; + } + + return LT_FINISH; +} + +u32 ShowCheckPageDown(s32 taskState) +{ + int topId; + int delta; + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + topId = GetMatchCallListTopIndex(); + delta = GetIndexDeltaOfNextCheckPageDown(topId); + if (delta) + { + PlaySE(SE_SELECT); + state->unk16 = delta; + TrainerPicSlideOffscreen(state); + return LT_INC_AND_PAUSE; + } + break; + case 1: + if (WaitForTrainerPic(state)) + return LT_PAUSE; + + PrintMatchCallLocation(state, state->unk16); + return LT_INC_AND_PAUSE; + case 2: + PrintCheckPageInfo(state->unk16); + return LT_INC_AND_PAUSE; + case 3: + LoadCheckPageTrainerPic(state); + return LT_INC_AND_PAUSE; + case 4: + if (sub_81C8820() || WaitForTrainerPic(state)) + return LT_PAUSE; + break; + } + + return LT_FINISH; +} + +u32 ExitCheckPage(s32 taskState) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + TrainerPicSlideOffscreen(state); + sub_81C87F0(); + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8820() || WaitForTrainerPic(state)) + return LT_PAUSE; + + PrintHelpBarText(HELPBAR_MC_TRAINER_LIST); + UpdateMatchCallInfoBox(state); + return LT_INC_AND_PAUSE; + case 2: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + + return LT_FINISH; +} + +u32 ShowCheckPageUp(s32 taskState) +{ + int topId; + int delta; + struct Pokenav4Struct *state = GetSubstructPtr(6); + switch (taskState) + { + case 0: + topId = GetMatchCallListTopIndex(); + delta = GetIndexDeltaOfNextCheckPageUp(topId); + if (delta) + { + PlaySE(SE_SELECT); + state->unk16 = delta; + TrainerPicSlideOffscreen(state); + return LT_INC_AND_PAUSE; + } + break; + case 1: + if (WaitForTrainerPic(state)) + return LT_PAUSE; + + PrintMatchCallLocation(state, state->unk16); + return LT_INC_AND_PAUSE; + case 2: + PrintCheckPageInfo(state->unk16); + return LT_INC_AND_PAUSE; + case 3: + LoadCheckPageTrainerPic(state); + return LT_INC_AND_PAUSE; + case 4: + if (sub_81C8820() || WaitForTrainerPic(state)) + return LT_PAUSE; + break; + } + + return LT_FINISH; +} + +u32 ExitMatchCall(s32 taskState) +{ + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + sub_81CBC38(0); + sub_81C7AC0(0); + sub_81C78A0(); + return LT_INC_AND_PAUSE; + case 1: + if (IsPaletteFadeActive() || MainMenuLoopedTaskIsBusy()) + return LT_PAUSE; + + sub_81C7FDC(); + break; + } + + return LT_FINISH; +} + +static void sub_81CBBB8(void) +{ + struct PokenavListTemplate template; + template.list.matchCallEntries = sub_81CAE94(); + template.unk4 = GetNumberRegistered(); + template.unk8 = 4; + template.unk6 = 0; + template.unk9 = 13; + template.unkA = 16; + template.unkB = 1; + template.unkC = 8; + template.unkD = 3; + template.unkE = 7; + template.listFunc.unk10_2 = BufferMatchCallNameAndDesc; + template.unk14 = TryDrawRematchPokeballIcon; + sub_81C81D4(&gUnknown_0862278C[2], &template, 2); + CreateTask(sub_81CBC64, 7); +} + +static void sub_81CBC1C(void) +{ + sub_81C8234(); + DestroyTask(FindTaskIdByFunc(sub_81CBC64)); +} + +static void sub_81CBC38(int arg0) +{ + u8 taskId = FindTaskIdByFunc(sub_81CBC64); + if (taskId != 0xFF) + gTasks[taskId].data[15] = arg0; +} + +static void sub_81CBC64(u8 taskId) +{ + s16 *taskData = gTasks[taskId].data; + if (taskData[15]) + { + taskData[0] += 4; + taskData[0] &= 0x7F; + taskData[1] = gSineTable[taskData[0]] >> 4; + sub_81C79BC(gUnknown_08622720, gUnknown_08622720 + 0x10, 0x10, 0x10, taskData[1], gPlttBufferUnfaded + 0x50); + if (!gPaletteFade.active) + CpuCopy32(gPlttBufferUnfaded + 0x50, gPlttBufferFaded + 0x50, 0x20); + } +} + +static void TryDrawRematchPokeballIcon(u16 windowId, u32 rematchId, u32 arg2) +{ + u8 bg = GetWindowAttribute(windowId, WINDOW_BG); + u16 *tilemap = GetBgTilemapBuffer(bg); + tilemap += arg2 * 0x40 + 0x1D; + if (ShouldDrawRematchPokeballIcon(rematchId)) + { + tilemap[0] = 0x5000; + tilemap[0x20] = 0x5001; + } + else + { + tilemap[0] = 0x5002; + tilemap[0x20] = 0x5002; + } +} + +void ClearRematchPokeballIcon(u16 windowId, u32 arg0) +{ + u8 bg = GetWindowAttribute(windowId, WINDOW_BG); + u16 *tilemap = GetBgTilemapBuffer(bg); + tilemap += arg0 * 0x40 + 0x1D; + tilemap[0] = 0x5002; + tilemap[0x20] = 0x5002; +} + +static void DrawMatchCallLeftColumnWindows(struct Pokenav4Struct *state) +{ + state->locWindowId = AddWindow(&sMatchCallLocationWindowTemplate); + state->infoBoxWindowId = AddWindow(&sMatchCallInfoBoxWindowTemplate); + FillWindowPixelBuffer(state->locWindowId, PIXEL_FILL(1)); + PutWindowTilemap(state->locWindowId); + FillWindowPixelBuffer(state->infoBoxWindowId, PIXEL_FILL(1)); + PutWindowTilemap(state->infoBoxWindowId); + CopyWindowToVram(state->locWindowId, 1); +} + +static void UpdateMatchCallInfoBox(struct Pokenav4Struct *state) +{ + FillWindowPixelBuffer(state->infoBoxWindowId, PIXEL_FILL(1)); + PrintNumberRegisteredLabel(state->infoBoxWindowId); + PrintNumberRegistered(state->infoBoxWindowId); + PrintNumberOfBattlesLabel(state->infoBoxWindowId); + PrintNumberOfBattles(state->infoBoxWindowId); + CopyWindowToVram(state->infoBoxWindowId, 2); +} + +static void PrintNumberRegisteredLabel(u16 windowId) +{ + PrintMatchCallInfoLabel(windowId, gText_NumberRegistered, 0); +} + +static void PrintNumberRegistered(u16 windowId) +{ + u8 str[3]; + ConvertIntToDecimalStringN(str, GetNumberRegistered(), STR_CONV_MODE_LEFT_ALIGN, 3); + PrintMatchCallInfoNumber(windowId, str, 1); +} + +static void PrintNumberOfBattlesLabel(u16 windowId) +{ + PrintMatchCallInfoLabel(windowId, gText_NumberOfBattles, 2); +} + +static void PrintNumberOfBattles(u16 windowId) +{ + u8 str[5]; + int numTrainerBattles = GetGameStat(GAME_STAT_TRAINER_BATTLES); + if (numTrainerBattles > 99999) + numTrainerBattles = 99999; + + ConvertIntToDecimalStringN(str, numTrainerBattles, STR_CONV_MODE_LEFT_ALIGN, 5); + PrintMatchCallInfoNumber(windowId, str, 3); +} + +static void PrintMatchCallInfoLabel(u16 windowId, const u8 *str, int top) +{ + int y = top * 16 + 1; + AddTextPrinterParameterized(windowId, 7, str, 2, y, TEXT_SPEED_FF, NULL); +} + +static void PrintMatchCallInfoNumber(u16 windowId, const u8 *str, int top) +{ + int x = GetStringRightAlignXOffset(7, str, 86); + int y = top * 16 + 1; + AddTextPrinterParameterized(windowId, 7, str, x, y, TEXT_SPEED_FF, NULL); +} + +static void PrintMatchCallLocation(struct Pokenav4Struct *state, int arg1) +{ + u8 mapName[32]; + int x; + int index = GetSelectedMatchCall() + arg1; + int mapSec = GetMatchCallMapSec(index); + if (mapSec != MAPSEC_NONE) + GetMapName(mapName, mapSec, 0); + else + StringCopy(mapName, gText_Unknown); + + x = GetStringCenterAlignXOffset(7, mapName, 88); + FillWindowPixelBuffer(state->locWindowId, PIXEL_FILL(1)); + AddTextPrinterParameterized(state->locWindowId, 7, mapName, x, 1, 0, NULL); +} + +static void PrintMatchCallSelectionOptions(struct Pokenav4Struct *state) +{ + u32 i; + + FillWindowPixelBuffer(state->infoBoxWindowId, PIXEL_FILL(1)); + for (i = 0; i < MATCH_CALL_OPTION_COUNT; i++) + { + int optionText = GetMatchCallOptionId(i); + if (optionText == MATCH_CALL_OPTION_COUNT) + break; + + AddTextPrinterParameterized(state->infoBoxWindowId, 7, sMatchCallOptionTexts[optionText], 16, i * 16 + 1, TEXT_SPEED_FF, NULL); + } + + CopyWindowToVram(state->infoBoxWindowId, 2); +} + +static bool32 sub_81CBFC4(struct Pokenav4Struct *state) +{ + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_81CC2F0(state, GetMatchCallOptionCursorPos()); + return FALSE; + } + + return TRUE; +} + +static void UpdateWindowsReturnToTrainerList(struct Pokenav4Struct *state) +{ + CloseMatchCallSelectOptionsWindow(state); + UpdateMatchCallInfoBox(state); +} + +static bool32 IsDma3ManagerBusyWithBgCopy1(struct Pokenav4Struct *state) +{ + return IsDma3ManagerBusyWithBgCopy(); +} + +static void UpdateWindowsToShowCheckPage(struct Pokenav4Struct *state) +{ + CloseMatchCallSelectOptionsWindow(state); + FillWindowPixelBuffer(state->infoBoxWindowId, PIXEL_FILL(1)); + CopyWindowToVram(state->infoBoxWindowId, 2); +} + +static void sub_81CC034(struct Pokenav4Struct *state) +{ + state->msgBoxWindowId = AddWindow(&sCallMsgBoxWindowTemplate); + sub_8197184(state->msgBoxWindowId, 1, 4); + sub_81C7B40(); +} + +static void DrawMsgBoxForMatchCallMsg(struct Pokenav4Struct *state) +{ + struct Sprite *sprite; + sub_8197184(state->msgBoxWindowId, 1, 4); + sub_81971C4(state->msgBoxWindowId, 1, 4); + FillWindowPixelBuffer(state->msgBoxWindowId, PIXEL_FILL(1)); + PutWindowTilemap(state->msgBoxWindowId); + CopyWindowToVram(state->msgBoxWindowId, 3); + sprite = PauseSpinningPokenavSprite(); + sprite->pos1.x = 24; + sprite->pos1.y = 112; + sprite->pos2.y = 0; +} + +static void DrawMsgBoxForCloseByMsg(struct Pokenav4Struct *state) +{ + LoadUserWindowBorderGfx(state->msgBoxWindowId, 1, 0x40); + DrawTextBorderOuter(state->msgBoxWindowId, 1, 4); + FillWindowPixelBuffer(state->msgBoxWindowId, PIXEL_FILL(1)); + PutWindowTilemap(state->msgBoxWindowId); + CopyWindowToVram(state->msgBoxWindowId, 3); +} + +static bool32 IsDma3ManagerBusyWithBgCopy2(struct Pokenav4Struct *state) +{ + return IsDma3ManagerBusyWithBgCopy(); +} + +static void PrintCallingDots(struct Pokenav4Struct *state) +{ + AddTextPrinterParameterized(state->msgBoxWindowId, 1, sText_CallingDots, 32, 1, 1, NULL); +} + +static bool32 WaitForCallingDotsText(struct Pokenav4Struct *state) +{ + RunTextPrinters(); + return IsTextPrinterActive(state->msgBoxWindowId); +} + +static void PrintTrainerIsCloseBy(struct Pokenav4Struct *state) +{ + AddTextPrinterParameterized(state->msgBoxWindowId, 1, gText_TrainerCloseBy, 0, 1, 1, NULL); +} + +static bool32 WaitForTrainerIsCloseByText(struct Pokenav4Struct *state) +{ + RunTextPrinters(); + return IsTextPrinterActive(state->msgBoxWindowId); +} + +static void PrintMatchCallMessage(struct Pokenav4Struct *state) +{ + int index = GetSelectedMatchCall(); + const u8 *str = GetMatchCallMessageText(index, &state->unkF); + u8 speed = GetPlayerTextSpeedDelay(); + AddTextPrinterParameterized(state->msgBoxWindowId, 1, str, 32, 1, speed, NULL); +} + +static bool32 WaitForMatchCallMessageText(struct Pokenav4Struct *state) +{ + if (gMain.heldKeys & A_BUTTON) + gTextFlags.canABSpeedUpPrint = 1; + else + gTextFlags.canABSpeedUpPrint = 0; + + RunTextPrinters(); + return IsTextPrinterActive(state->msgBoxWindowId); +} + +static void DrawSpinningPokenavForCall(struct Pokenav4Struct *state) +{ + ResumeSpinningPokenavSprite(); + FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 32, 20); + CopyBgTilemapBufferToVram(1); +} + +static bool32 WaitForSpinningPokenav(struct Pokenav4Struct *state) +{ + return IsDma3ManagerBusyWithBgCopy(); +} + +static void sub_81CC214(void) +{ + int i; + u8 paletteNum; + struct SpriteSheet spriteSheet; + struct Pokenav4Struct *state = GetSubstructPtr(6); + + for (i = 0; i < ARRAY_COUNT(gUnknown_08622810); i++) + LoadCompressedSpriteSheet(&gUnknown_08622810[i]); + + Pokenav_AllocAndLoadPalettes(gUnknown_08622818); + state->optionsCursorSprite = NULL; + spriteSheet.data = state->unk1828; + spriteSheet.size = 0x800; + spriteSheet.tag = 8; + state->unk1824 = (u8 *)OBJ_VRAM0 + LoadSpriteSheet(&spriteSheet) * 0x20; + paletteNum = AllocSpritePalette(13); + state->unk1A = 0x100 + paletteNum * 0x10; + state->trainerPicSprite = CreateTrainerPicSprite(); + state->trainerPicSprite->invisible = TRUE; +} + +static void sub_81CC2B4(void) +{ + struct Pokenav4Struct *state = GetSubstructPtr(6); + if (state->optionsCursorSprite) + DestroySprite(state->optionsCursorSprite); + if (state->trainerPicSprite) + DestroySprite(state->trainerPicSprite); + + FreeSpriteTilesByTag(8); + FreeSpriteTilesByTag(7); + FreeSpritePaletteByTag(12); + FreeSpritePaletteByTag(13); +} + +static void sub_81CC2F0(struct Pokenav4Struct *state, int top) +{ + if (!state->optionsCursorSprite) + { + u8 spriteId = CreateSprite(&sOptionsCursorSpriteTemplate, 4, 80, 5); + state->optionsCursorSprite = &gSprites[spriteId]; + UpdateCursorGfxPos(state, top); + } +} + +static void CloseMatchCallSelectOptionsWindow(struct Pokenav4Struct *state) +{ + DestroySprite(state->optionsCursorSprite); + state->optionsCursorSprite = NULL; +} + +static void UpdateCursorGfxPos(struct Pokenav4Struct *state, int top) +{ + state->optionsCursorSprite->pos2.y = top * 16; +} + +void SpriteCB_OptionsCursor(struct Sprite *sprite) +{ + if (++sprite->data[0] > 3) + { + sprite->data[0] = 0; + sprite->pos2.x = (sprite->pos2.x + 1) & 0x7; + } +} + +static struct Sprite *CreateTrainerPicSprite(void) +{ + u8 spriteId = CreateSprite(&sTrainerPicSpriteTemplate, 44, 104, 6); + return &gSprites[spriteId]; +} + +static void LoadCheckPageTrainerPic(struct Pokenav4Struct *state) +{ + u16 cursor; + int trainerPic = GetMatchCallTrainerPic(GetSelectedMatchCall()); + if (trainerPic >= 0) + { + DecompressPicFromTable(&gTrainerFrontPicTable[trainerPic], state->unk1828, SPECIES_NONE); + LZ77UnCompWram(gTrainerFrontPicPaletteTable[trainerPic].data, state->unk2028); + cursor = RequestDma3Copy(state->unk1828, state->unk1824, 0x800, 1); + LoadPalette(state->unk2028, state->unk1A, 0x20); + state->trainerPicSprite->data[0] = 0; + state->trainerPicSprite->data[7] = cursor; + state->trainerPicSprite->callback = SpriteCB_TrainerPicSlideOnscreen; + } +} + +static void TrainerPicSlideOffscreen(struct Pokenav4Struct *state) +{ + state->trainerPicSprite->callback = SpriteCB_TrainerPicSlideOffscreen; +} + +static bool32 WaitForTrainerPic(struct Pokenav4Struct *state) +{ + return state->trainerPicSprite->callback != SpriteCallbackDummy; +} + +static void SpriteCB_TrainerPicSlideOnscreen(struct Sprite *sprite) +{ + switch (sprite->data[0]) + { + case 0: + if (CheckForSpaceForDma3Request(sprite->data[7]) != -1) + { + sprite->pos2.x = -80; + sprite->invisible = FALSE; + sprite->data[0]++; + } + break; + case 1: + sprite->pos2.x += 8; + if (sprite->pos2.x >= 0) + { + sprite->pos2.x = 0; + sprite->callback = SpriteCallbackDummy; + } + break; + } +} + +static void SpriteCB_TrainerPicSlideOffscreen(struct Sprite *sprite) +{ + sprite->pos2.x -= 8; + if (sprite->pos2.x <= -80) + { + sprite->invisible = TRUE; + sprite->callback = SpriteCallbackDummy; + } +} diff --git a/src/pokenav_menu_handler_1.c b/src/pokenav_menu_handler_1.c new file mode 100644 index 000000000..44176176d --- /dev/null +++ b/src/pokenav_menu_handler_1.c @@ -0,0 +1,513 @@ +#include "global.h" +#include "pokenav.h" +#include "event_data.h" +#include "main.h" +#include "sound.h" +#include "constants/songs.h" + +struct Pokenav1Struct +{ + u16 menuType; + s16 cursorPos; + u16 currMenuItem; + u16 helpBarIndex; + u32 unk8; + u32 (*callback)(struct Pokenav1Struct*); +}; + +static bool32 UpdateMenuCursorPos(struct Pokenav1Struct *state); +static void ReturnToConditionMenu(struct Pokenav1Struct *state); +static void ReturnToMainMenu(struct Pokenav1Struct *state); +static u32 sub_81C97BC(struct Pokenav1Struct *state); +static void sub_81C97B0(struct Pokenav1Struct *state, u32 a1); +static u32 CB2_ReturnToConditionMenu(struct Pokenav1Struct *state); +static u32 CB2_ReturnToMainMenu(struct Pokenav1Struct *state); +static u32 HandleConditionSearchMenuInput(struct Pokenav1Struct *state); +static u32 HandleConditionMenuInput(struct Pokenav1Struct *state); +static u32 HandleCantOpenRibbonsInput(struct Pokenav1Struct *state); +static u32 HandleMainMenuInputEndTutorial(struct Pokenav1Struct *state); +static u32 HandleMainMenuInputTutorial(struct Pokenav1Struct *state); +static u32 HandleMainMenuInput(struct Pokenav1Struct *state); +static u32 (*GetMainMenuInputHandler(void))(struct Pokenav1Struct*); +static void SetMenuInputHandler(struct Pokenav1Struct *state); + +// Number of entries - 1 for that menu type +static const u8 sLastCursorPositions[] = +{ + [POKENAV_MENU_TYPE_DEFAULT] = 2, + [POKENAV_MENU_TYPE_UNLOCK_MC] = 3, + [POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS] = 4, + [POKENAV_MENU_TYPE_CONDITION] = 2, + [POKENAV_MENU_TYPE_CONDITION_SEARCH] = 5 +}; + +static const u8 sMenuItems[][6] = +{ + [POKENAV_MENU_TYPE_DEFAULT] = + { + POKENAV_MENUITEM_MAP, + POKENAV_MENUITEM_CONDITION, + [2 ... 5] = POKENAV_MENUITEM_SWITCH_OFF + }, + [POKENAV_MENU_TYPE_UNLOCK_MC] = + { + POKENAV_MENUITEM_MAP, + POKENAV_MENUITEM_CONDITION, + POKENAV_MENUITEM_MATCH_CALL, + [3 ... 5] = POKENAV_MENUITEM_SWITCH_OFF + }, + [POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS] = + { + POKENAV_MENUITEM_MAP, + POKENAV_MENUITEM_CONDITION, + POKENAV_MENUITEM_MATCH_CALL, + POKENAV_MENUITEM_RIBBONS, + [4 ... 5] = POKENAV_MENUITEM_SWITCH_OFF + }, + [POKENAV_MENU_TYPE_CONDITION] = + { + POKENAV_MENUITEM_CONDITION_PARTY, + POKENAV_MENUITEM_CONDITION_SEARCH, + POKENAV_MENUITEM_CONDITION_CANCEL, + [3 ... 5] = POKENAV_MENUITEM_SWITCH_OFF + }, + [POKENAV_MENU_TYPE_CONDITION_SEARCH] = + { + POKENAV_MENUITEM_CONDITION_SEARCH_COOL, + POKENAV_MENUITEM_CONDITION_SEARCH_BEAUTY, + POKENAV_MENUITEM_CONDITION_SEARCH_CUTE, + POKENAV_MENUITEM_CONDITION_SEARCH_SMART, + POKENAV_MENUITEM_CONDITION_SEARCH_TOUGH, + POKENAV_MENUITEM_CONDITION_SEARCH_CANCEL + }, +}; + +static u8 GetPokenavMainMenuType(void) +{ + u8 menuType = POKENAV_MENU_TYPE_DEFAULT; + + if (FlagGet(FLAG_ADDED_MATCH_CALL_TO_POKENAV)) + { + menuType = POKENAV_MENU_TYPE_UNLOCK_MC; + + if (FlagGet(FLAG_SYS_RIBBON_GET)) + menuType = POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS; + } + + return menuType; +} + +bool32 PokenavCallback_Init_0(void) +{ + struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); + if (!state) + return FALSE; + + state->menuType = GetPokenavMainMenuType(); + state->cursorPos = 0; + state->currMenuItem = POKENAV_MENUITEM_MAP; + state->helpBarIndex = HELPBAR_NONE; + SetMenuInputHandler(state); + return TRUE; +} + +bool32 PokenavCallback_Init_4(void) +{ + struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); + if (!state) + return FALSE; + + state->menuType = GetPokenavMainMenuType(); + state->cursorPos = 2; + state->currMenuItem = POKENAV_MENUITEM_MATCH_CALL; + state->helpBarIndex = HELPBAR_NONE; + SetMenuInputHandler(state); + return TRUE; +} + +bool32 PokenavCallback_Init_5(void) +{ + struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); + if (!state) + return FALSE; + + state->menuType = GetPokenavMainMenuType(); + state->cursorPos = 3; + state->currMenuItem = POKENAV_MENUITEM_RIBBONS; + SetMenuInputHandler(state); + return TRUE; +} + +bool32 PokenavCallback_Init_2(void) +{ + struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); + if (!state) + return FALSE; + + state->menuType = POKENAV_MENU_TYPE_CONDITION; + state->cursorPos = 0; + state->currMenuItem = POKENAV_MENUITEM_CONDITION_PARTY; + state->helpBarIndex = HELPBAR_NONE; + SetMenuInputHandler(state); + return TRUE; +} + +bool32 PokenavCallback_Init_3(void) +{ + struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); + if (!state) + return FALSE; + + state->menuType = POKENAV_MENU_TYPE_CONDITION_SEARCH; + state->cursorPos = GetSelectedConditionSearch(); + state->currMenuItem = state->cursorPos + POKENAV_MENUITEM_CONDITION_SEARCH_COOL; + state->helpBarIndex = HELPBAR_NONE; + SetMenuInputHandler(state); + return TRUE; +} + +static void SetMenuInputHandler(struct Pokenav1Struct *state) +{ + switch (state->menuType) + { + case POKENAV_MENU_TYPE_DEFAULT: + SetPokenavMode(POKENAV_MODE_NORMAL); + // fallthrough + case POKENAV_MENU_TYPE_UNLOCK_MC: + case POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS: + state->callback = GetMainMenuInputHandler(); + break; + case POKENAV_MENU_TYPE_CONDITION: + state->callback = HandleConditionMenuInput; + break; + case POKENAV_MENU_TYPE_CONDITION_SEARCH: + state->callback = HandleConditionSearchMenuInput; + break; + } +} + +static u32 (*GetMainMenuInputHandler(void))(struct Pokenav1Struct*) +{ + switch (GetPokenavMode()) + { + default: + case POKENAV_MODE_NORMAL: + return HandleMainMenuInput; + case POKENAV_MODE_FORCE_CALL_READY: + return HandleMainMenuInputTutorial; + case POKENAV_MODE_FORCE_CALL_EXIT: + return HandleMainMenuInputEndTutorial; + } +} + +u32 sub_81C941C(void) +{ + struct Pokenav1Struct *state = GetSubstructPtr(1); + return state->callback(state); +} + +void sub_81C9430(void) +{ + FreePokenavSubstruct(1); +} + +static u32 HandleMainMenuInput(struct Pokenav1Struct *state) +{ + if (UpdateMenuCursorPos(state)) + return POKENAV_MENU_FUNC_MOVE_CURSOR; + + if (gMain.newKeys & A_BUTTON) + { + switch (sMenuItems[state->menuType][state->cursorPos]) + { + case POKENAV_MENUITEM_MAP: + state->helpBarIndex = gSaveBlock2Ptr->regionMapZoom ? HELPBAR_MAP_ZOOMED_IN : HELPBAR_MAP_ZOOMED_OUT; + sub_81C97B0(state, POKENAV_MENU_6); + return POKENAV_MENU_FUNC_OPEN_FEATURE; + case POKENAV_MENUITEM_CONDITION: + state->menuType = POKENAV_MENU_TYPE_CONDITION; + state->cursorPos = 0; + state->currMenuItem = sMenuItems[POKENAV_MENU_TYPE_CONDITION][0]; + state->callback = HandleConditionMenuInput; + return POKENAV_MENU_FUNC_OPEN_CONDITION; + case POKENAV_MENUITEM_MATCH_CALL: + state->helpBarIndex = HELPBAR_MC_TRAINER_LIST; + sub_81C97B0(state, POKENAV_MENU_B); + return POKENAV_MENU_FUNC_OPEN_FEATURE; + case POKENAV_MENUITEM_RIBBONS: + if (CanViewRibbonsMenu()) + { + state->helpBarIndex = HELPBAR_RIBBONS_MON_LIST; + sub_81C97B0(state, POKENAV_MENU_C); + return POKENAV_MENU_FUNC_OPEN_FEATURE; + } + else + { + state->callback = HandleCantOpenRibbonsInput; + return POKENAV_MENU_FUNC_NO_RIBBON_WINNERS; + } + case POKENAV_MENUITEM_SWITCH_OFF: + return -1; + } + } + + if (gMain.newKeys & B_BUTTON) + return -1; + + return POKENAV_MENU_FUNC_NONE; +} + +// Force the player to select Match Call during the call Mr. Stone pokenav tutorial +static u32 HandleMainMenuInputTutorial(struct Pokenav1Struct *state) +{ + if (UpdateMenuCursorPos(state)) + return POKENAV_MENU_FUNC_MOVE_CURSOR; + + if (gMain.newKeys & A_BUTTON) + { + if (sMenuItems[state->menuType][state->cursorPos] == POKENAV_MENUITEM_MATCH_CALL) + { + state->helpBarIndex = HELPBAR_MC_TRAINER_LIST; + sub_81C97B0(state, POKENAV_MENU_B); + return POKENAV_MENU_FUNC_OPEN_FEATURE; + } + else + { + PlaySE(SE_HAZURE); + return POKENAV_MENU_FUNC_NONE; + } + } + + if (gMain.newKeys & B_BUTTON) + { + PlaySE(SE_HAZURE); + return POKENAV_MENU_FUNC_NONE; + } + + return POKENAV_MENU_FUNC_NONE; +} + +// After calling Mr. Stone during the pokenav tutorial, force player to exit or use Match Call again +static u32 HandleMainMenuInputEndTutorial(struct Pokenav1Struct *state) +{ + if (UpdateMenuCursorPos(state)) + return POKENAV_MENU_FUNC_MOVE_CURSOR; + + if (gMain.newKeys & A_BUTTON) + { + u32 menuItem = sMenuItems[state->menuType][state->cursorPos]; + if (menuItem != POKENAV_MENUITEM_MATCH_CALL && menuItem != POKENAV_MENUITEM_SWITCH_OFF) + { + PlaySE(SE_HAZURE); + return POKENAV_MENU_FUNC_NONE; + } + else if (menuItem == POKENAV_MENUITEM_MATCH_CALL) + { + state->helpBarIndex = HELPBAR_MC_TRAINER_LIST; + sub_81C97B0(state, POKENAV_MENU_B); + return POKENAV_MENU_FUNC_OPEN_FEATURE; + } + else + { + return -1; + } + } + else if (gMain.newKeys & B_BUTTON) + { + return -1; + } + return POKENAV_MENU_FUNC_NONE; +} + +// Handles input after selecting Ribbons when there are no ribbon winners left +// Selecting it again just reprints the Ribbon description to replace the "No Ribbon winners" message +static u32 HandleCantOpenRibbonsInput(struct Pokenav1Struct *state) +{ + if (UpdateMenuCursorPos(state)) + { + state->callback = GetMainMenuInputHandler(); + return POKENAV_MENU_FUNC_MOVE_CURSOR; + } + + if (gMain.newKeys & (A_BUTTON | B_BUTTON)) + { + state->callback = GetMainMenuInputHandler(); + return POKENAV_MENU_FUNC_RESHOW_DESCRIPTION; + } + + return POKENAV_MENU_FUNC_NONE; +} + +static u32 HandleConditionMenuInput(struct Pokenav1Struct *state) +{ + if (UpdateMenuCursorPos(state)) + return POKENAV_MENU_FUNC_MOVE_CURSOR; + + if (gMain.newKeys & A_BUTTON) + { + switch (sMenuItems[state->menuType][state->cursorPos]) + { + case POKENAV_MENUITEM_CONDITION_SEARCH: + state->menuType = POKENAV_MENU_TYPE_CONDITION_SEARCH; + state->cursorPos = 0; + state->currMenuItem = sMenuItems[POKENAV_MENU_TYPE_CONDITION_SEARCH][0]; + state->callback = HandleConditionSearchMenuInput; + return POKENAV_MENU_FUNC_OPEN_CONDITION_SEARCH; + case POKENAV_MENUITEM_CONDITION_PARTY: + state->helpBarIndex = 0; + sub_81C97B0(state, POKENAV_MENU_7); + return POKENAV_MENU_FUNC_OPEN_FEATURE; + case POKENAV_MENUITEM_CONDITION_CANCEL: + PlaySE(SE_SELECT); + ReturnToMainMenu(state); + return POKENAV_MENU_FUNC_RETURN_TO_MAIN; + } + } + if (gMain.newKeys & B_BUTTON) + { + if (state->cursorPos != sLastCursorPositions[state->menuType]) + { + state->cursorPos = sLastCursorPositions[state->menuType]; + state->callback = CB2_ReturnToMainMenu; + return POKENAV_MENU_FUNC_MOVE_CURSOR; + } + else + { + PlaySE(SE_SELECT); + ReturnToMainMenu(state); + return POKENAV_MENU_FUNC_RETURN_TO_MAIN; + } + } + + return POKENAV_MENU_FUNC_NONE; +} + +static u32 HandleConditionSearchMenuInput(struct Pokenav1Struct *state) +{ + if (UpdateMenuCursorPos(state)) + return POKENAV_MENU_FUNC_MOVE_CURSOR; + + if (gMain.newKeys & A_BUTTON) + { + u8 menuItem = sMenuItems[state->menuType][state->cursorPos]; + if (menuItem != POKENAV_MENUITEM_CONDITION_SEARCH_CANCEL) + { + SetSelectedConditionSearch(menuItem - POKENAV_MENUITEM_CONDITION_SEARCH_COOL); + sub_81C97B0(state, POKENAV_MENU_8); + state->helpBarIndex = HELPBAR_CONDITION_MON_LIST; + return POKENAV_MENU_FUNC_OPEN_FEATURE; + } + else + { + PlaySE(SE_SELECT); + ReturnToConditionMenu(state); + return POKENAV_MENU_FUNC_RETURN_TO_CONDITION; + } + } + if (gMain.newKeys & B_BUTTON) + { + if (state->cursorPos != sLastCursorPositions[state->menuType]) + { + state->cursorPos = sLastCursorPositions[state->menuType]; + state->callback = CB2_ReturnToConditionMenu; + return POKENAV_MENU_FUNC_MOVE_CURSOR; + } + else + { + PlaySE(SE_SELECT); + ReturnToConditionMenu(state); + return POKENAV_MENU_FUNC_RETURN_TO_CONDITION; + } + } + return POKENAV_MENU_FUNC_NONE; +} + +static u32 CB2_ReturnToMainMenu(struct Pokenav1Struct *state) +{ + ReturnToMainMenu(state); + return POKENAV_MENU_FUNC_RETURN_TO_MAIN; +} + +static u32 CB2_ReturnToConditionMenu(struct Pokenav1Struct *state) +{ + ReturnToConditionMenu(state); + return POKENAV_MENU_FUNC_RETURN_TO_CONDITION; +} + +static void sub_81C97B0(struct Pokenav1Struct *state, u32 a1) +{ + state->unk8 = a1; + state->callback = sub_81C97BC; +} + +static u32 sub_81C97BC(struct Pokenav1Struct *state) +{ + return state->unk8; +} + +static void ReturnToMainMenu(struct Pokenav1Struct *state) +{ + state->menuType = GetPokenavMainMenuType(); + state->cursorPos = 1; + state->currMenuItem = sMenuItems[state->menuType][state->cursorPos]; + state->callback = HandleMainMenuInput; +} + +static void ReturnToConditionMenu(struct Pokenav1Struct *state) +{ + state->menuType = POKENAV_MENU_TYPE_CONDITION; + state->cursorPos = 1; + state->currMenuItem = sMenuItems[POKENAV_MENU_TYPE_CONDITION][1]; + state->callback = HandleConditionMenuInput; +} + +static bool32 UpdateMenuCursorPos(struct Pokenav1Struct *state) +{ + if (gMain.newKeys & DPAD_UP) + { + if (--state->cursorPos < 0) + state->cursorPos = sLastCursorPositions[state->menuType]; + + state->currMenuItem = sMenuItems[state->menuType][state->cursorPos]; + return TRUE; + } + else if (gMain.newKeys & DPAD_DOWN) + { + state->cursorPos++; + if (state->cursorPos > sLastCursorPositions[state->menuType]) + state->cursorPos = 0; + + state->currMenuItem = sMenuItems[state->menuType][state->cursorPos]; + return TRUE; + } + else + { + return FALSE; + } +} + +int GetPokenavMenuType(void) +{ + struct Pokenav1Struct *state = GetSubstructPtr(1); + return state->menuType; +} + +// Position of cursor relative to number of current menu options +int GetPokenavCursorPos(void) +{ + struct Pokenav1Struct *state = GetSubstructPtr(1); + return state->cursorPos; +} + +// ID of menu item the cursor is currently on +int GetCurrentMenuItemId(void) +{ + struct Pokenav1Struct *state = GetSubstructPtr(1); + return state->currMenuItem; +} + +u16 GetHelpBarTextId(void) +{ + struct Pokenav1Struct *state = GetSubstructPtr(1); + return state->helpBarIndex; +} diff --git a/src/pokenav_menu_handler_2.c b/src/pokenav_menu_handler_2.c new file mode 100644 index 000000000..94b816b6d --- /dev/null +++ b/src/pokenav_menu_handler_2.c @@ -0,0 +1,1284 @@ +#include "global.h" +#include "malloc.h" +#include "decompress.h" +#include "bg.h" +#include "palette.h" +#include "trig.h" +#include "gpu_regs.h" +#include "menu.h" +#include "window.h" +#include "pokenav.h" +#include "graphics.h" +#include "sound.h" +#include "gym_leader_rematch.h" +#include "window.h" +#include "strings.h" +#include "scanline_effect.h" +#include "constants/songs.h" +#include "constants/rgb.h" + +// Top Menu + +struct Pokenav2Struct +{ + bool32 (*callback)(void); + u32 loopedTaskId; + u16 optionDescWindowId; + u8 bg3ScrollTaskId; + u8 cursorPos; + bool8 otherIconsInMotion; + u8 field_00d; + bool32 iconVisible[MAX_POKENAV_MENUITEMS]; + struct Sprite * field_028; + struct Sprite * iconSprites[MAX_POKENAV_MENUITEMS][4]; + u16 bg1TilemapBuffer[0x400]; +}; + +static struct Pokenav2Struct * sub_81C9958(void); +static bool32 sub_81C99FC(void); +static u32 sub_81C9A10(s32 state); +static u32 LoopedTask_MoveMenuCursor(s32 state); +static u32 LoopedTask_OpenConditionMenu(s32 state); +static u32 LoopedTask_ReturnToMainMenu(s32 state); +static u32 LoopedTask_OpenConditionSearchMenu(s32 state); +static u32 LoopedTask_ReturnToConditionMenu(s32 state); +static u32 LoopedTask_SelectRibbonsNoWinners(s32 state); +static u32 LoopedTask_ReShowDescription(s32 state); +static u32 LoopedTask_OpenPokenavFeature(s32 state); +static void sub_81C9FC4(void); +static void sub_81C9FEC(void); +static void CreateMenuOptionSprites(void); +static void sub_81CA094(void); +static void sub_81CA0C8(void); +static void sub_81CA0EC(const u16 *const * a0, s32 a1, s32 a2); +static void sub_81CA20C(void); +static void sub_81CA278(void); +static void sub_81CA35C(struct Sprite ** sprites, s32 a1, s32 a2, s32 a3); +static void sub_81CA3B4(struct Sprite ** sprites); +static void sub_81CA2DC(void); +static bool32 AreMenuOptionSpritesMoving(void); +static void sub_81CA448(struct Sprite ** sprites, bool32 a1); +static void sub_81CA474(struct Sprite * sprite); +static void sub_81CA4AC(struct Sprite * sprite); +static void sub_81CA580(u8 taskId); +static void sub_81CA640(void); +static void sub_81CA6AC(struct Sprite * sprite); +static void sub_81CA698(void); +static void AddOptionDescriptionWindow(void); +static void PrintCurrentOptionDescription(void); +static void PrintNoRibbonWinners(void); +static bool32 sub_81CA7C4(void); +static void sub_81CA7D4(void); +static void sub_81CA7F4(void); +static void sub_81CA808(u8 taskId); +static void sub_81CA818(void); +static void sub_81CA850(void); +static void sub_81CA864(void); +static bool32 sub_81CA89C(void); +static void sub_81CA8B0(u8 taskId); +static void sub_81CA92C(void); +static void sub_81CA994(void); +static void sub_81CA9C8(void); +static void sub_81CA9D8(void); +static void sub_81CA9EC(u8 taskId); +static void sub_81CAA3C(void); + +static const u16 gUnknown_0861FC78[] = INCBIN_U16("graphics/pokenav/bg.gbapal"); +static const u32 gUnknown_0861FC98[] = INCBIN_U32("graphics/pokenav/bg.4bpp.lz"); +static const u32 gUnknown_0861FCAC[] = INCBIN_U32("graphics/pokenav/bg.bin.lz"); +static const u16 gUnknown_0861FD4C[] = INCBIN_U16("graphics/pokenav/outline.gbapal"); +static const u32 gUnknown_0861FD6C[] = INCBIN_U32("graphics/pokenav/outline.4bpp.lz"); +static const u32 gUnknown_0861FFF4[] = INCBIN_U32("graphics/pokenav/outline_map.bin.lz"); +static const u16 gUnknown_08620104[] = INCBIN_U16("graphics/pokenav/blue_light.gbapal"); +static const u32 gUnknown_08620124[] = INCBIN_U32("graphics/pokenav/blue_light.4bpp.lz"); + +static const struct BgTemplate gUnknown_08620194[] = { + { + .bg = 1, + .charBaseIndex = 1, + .mapBaseIndex = 15, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0x000 + }, { + .bg = 2, + .charBaseIndex = 2, + .mapBaseIndex = 23, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0x000 + }, { + .bg = 3, + .charBaseIndex = 3, + .mapBaseIndex = 31, + .screenSize = 0, + .paletteMode = 0, + .priority = 3, + .baseTile = 0x000 + } +}; + +static const LoopedTask sMenuHandlerLoopTaskFuncs[] = { + [POKENAV_MENU_FUNC_NONE] = NULL, + [POKENAV_MENU_FUNC_MOVE_CURSOR] = LoopedTask_MoveMenuCursor, + [POKENAV_MENU_FUNC_OPEN_CONDITION] = LoopedTask_OpenConditionMenu, + [POKENAV_MENU_FUNC_RETURN_TO_MAIN] = LoopedTask_ReturnToMainMenu, + [POKENAV_MENU_FUNC_OPEN_CONDITION_SEARCH] = LoopedTask_OpenConditionSearchMenu, + [POKENAV_MENU_FUNC_RETURN_TO_CONDITION] = LoopedTask_ReturnToConditionMenu, + [POKENAV_MENU_FUNC_NO_RIBBON_WINNERS] = LoopedTask_SelectRibbonsNoWinners, + [POKENAV_MENU_FUNC_RESHOW_DESCRIPTION] = LoopedTask_ReShowDescription, + [POKENAV_MENU_FUNC_OPEN_FEATURE] = LoopedTask_OpenPokenavFeature +}; + +static const struct CompressedSpriteSheet gUnknown_086201C4[] = +{ + { + .data = gPokenavOptions_Gfx, + .size = 0x3400, + .tag = 0x0003 + }, + { + .data = gUnknown_08620124, + .size = 0x0100, + .tag = 0x0001 + } +}; + +static const struct SpritePalette gUnknown_086201D4[] = +{ + {gPokenavOptions_Pal + 0x00, 4}, + {gPokenavOptions_Pal + 0x10, 5}, + {gPokenavOptions_Pal + 0x20, 6}, + {gPokenavOptions_Pal + 0x30, 7}, + {gPokenavOptions_Pal + 0x40, 8}, + {gUnknown_08620104, 3}, + {} +}; + +static const u16 gUnknown_0862020C[] = {0, 0}; +static const u16 gUnknown_08620210[] = {0x20, 1}; +static const u16 gUnknown_08620214[] = {0x40, 4}; +static const u16 gUnknown_08620218[] = {0x60, 2}; +static const u16 gUnknown_0862021C[] = {0x80, 3}; +static const u16 gUnknown_08620220[] = {0xA0, 1}; +static const u16 gUnknown_08620224[] = {0xC0, 1}; +static const u16 gUnknown_08620228[] = {0xE0, 4}; +static const u16 gUnknown_0862022C[] = {0x100, 1}; +static const u16 gUnknown_08620230[] = {0x120, 2}; +static const u16 gUnknown_08620234[] = {0x140, 0}; +static const u16 gUnknown_08620238[] = {0x160, 0}; +static const u16 gUnknown_0862023C[] = {0x180, 3}; + +struct UnkStruct_08620240 +{ + u16 unk0; + u16 unk2; + const u16 *unk4[MAX_POKENAV_MENUITEMS]; +}; + +// TODO +static const struct UnkStruct_08620240 gUnknown_08620240[POKENAV_MENU_TYPE_COUNT] = +{ + [POKENAV_MENU_TYPE_DEFAULT] = + { + 0x2A, + 0x14, + {gUnknown_0862020C, gUnknown_08620210, gUnknown_0862021C} + }, + [POKENAV_MENU_TYPE_UNLOCK_MC] = + { + 0x2A, + 0x14, + {gUnknown_0862020C, gUnknown_08620210, gUnknown_08620214, gUnknown_0862021C} + }, + [POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS] = + { + 0x2A, + 0x14, + {gUnknown_0862020C, gUnknown_08620210, gUnknown_08620214, gUnknown_08620218, gUnknown_0862021C} + }, + [POKENAV_MENU_TYPE_CONDITION] = + { + 0x38, + 0x14, + {gUnknown_08620220, gUnknown_08620224, gUnknown_0862023C} + }, + [POKENAV_MENU_TYPE_CONDITION_SEARCH] = + { + 0x28, + 0x10, + {gUnknown_08620228, gUnknown_0862022C, gUnknown_08620230, gUnknown_08620234, gUnknown_08620238, gUnknown_0862023C} + }, +}; + +static const struct WindowTemplate sOptionDescWindowTemplate = +{ + .bg = 1, + .tilemapLeft = 3, + .tilemapTop = 17, + .width = 0x18, + .height = 0x2, + .paletteNum = 1, + .baseBlock = 8 +}; + +static const u8 *const sPageDescriptions[] = +{ + [POKENAV_MENUITEM_MAP] = gText_CheckMapOfHoenn, + [POKENAV_MENUITEM_CONDITION] = gText_CheckPokemonInDetail, + [POKENAV_MENUITEM_MATCH_CALL] = gText_CallRegisteredTrainer, + [POKENAV_MENUITEM_RIBBONS] = gText_CheckObtainedRibbons, + [POKENAV_MENUITEM_SWITCH_OFF] = gText_PutAwayPokenav, + [POKENAV_MENUITEM_CONDITION_PARTY] = gText_CheckPartyPokemonInDetail, + [POKENAV_MENUITEM_CONDITION_SEARCH] = gText_CheckAllPokemonInDetail, + [POKENAV_MENUITEM_CONDITION_CANCEL] = gText_ReturnToPokenavMenu, + [POKENAV_MENUITEM_CONDITION_SEARCH_COOL] = gText_FindCoolPokemon, + [POKENAV_MENUITEM_CONDITION_SEARCH_BEAUTY] = gText_FindBeautifulPokemon, + [POKENAV_MENUITEM_CONDITION_SEARCH_CUTE] = gText_FindCutePokemon, + [POKENAV_MENUITEM_CONDITION_SEARCH_SMART] = gText_FindSmartPokemon, + [POKENAV_MENUITEM_CONDITION_SEARCH_TOUGH] = gText_FindToughPokemon, + [POKENAV_MENUITEM_CONDITION_SEARCH_CANCEL] = gText_ReturnToConditionMenu +}; + +static const u8 sOptionDescTextColors[] = {TEXT_COLOR_GREEN, TEXT_COLOR_BLUE, TEXT_COLOR_LIGHT_GREEN}; +static const u8 sOptionDescTextColors2[] = {TEXT_COLOR_GREEN, TEXT_COLOR_BLUE, TEXT_COLOR_LIGHT_GREEN}; + +static const struct OamData sOamData_MenuOption = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +static const union AffineAnimCmd gUnknown_0862031C[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_END, +}; + +static const union AffineAnimCmd gUnknown_0862032C[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0x12), + AFFINEANIMCMD_END, +}; + +static const union AffineAnimCmd *const sSpriteAnims_MenuOption[] = +{ + gUnknown_0862031C, + gUnknown_0862032C +}; + +static const struct SpriteTemplate sMenuOptionSpriteTemplate = +{ + .tileTag = 3, + .paletteTag = 4, + .oam = &sOamData_MenuOption, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = sSpriteAnims_MenuOption, + .callback = SpriteCallbackDummy, +}; + +static const struct OamData gUnknown_08620364 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0, + .priority = 2, + .paletteNum = 0, +}; + +static const struct SpriteTemplate gUnknown_0862036C = +{ + .tileTag = 1, + .paletteTag = 3, + .oam = &gUnknown_08620364, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +static const struct ScanlineEffectParams gUnknown_08620384 = +{ + (void *)REG_ADDR_WIN0H, + ((DMA_ENABLE | DMA_START_HBLANK | DMA_REPEAT | DMA_DEST_RELOAD) << 16) | 1, + 1, + 0 +}; + +static bool32 sub_81C98D4(void) +{ + s32 i; + + for (i = 0; i < REMATCH_TABLE_ENTRIES; i++) + { + if (sub_81CB0C8(i) == gMapHeader.regionMapSectionId + && IsRematchEntryRegistered(i) + && gSaveBlock1Ptr->trainerRematches[i]) + return TRUE; + } + + return FALSE; +} + +bool32 sub_81C9924(void) +{ + struct Pokenav2Struct * unk = sub_81C9958(); + + if (unk == NULL) + return FALSE; + + unk->field_00d = 0; + return TRUE; +} + +bool32 sub_81C9940(void) +{ + struct Pokenav2Struct * unk = sub_81C9958(); + + if (unk == NULL) + return FALSE; + + unk->field_00d = 1; + return TRUE; +} + +static struct Pokenav2Struct * sub_81C9958(void) +{ + struct Pokenav2Struct * unk = AllocSubstruct(2, sizeof(struct Pokenav2Struct)); + + if (unk != NULL) + { + unk->otherIconsInMotion = FALSE; + unk->loopedTaskId = CreateLoopedTask(sub_81C9A10, 1); + unk->callback = sub_81C99FC; + } + + return unk; +} + + +void CreateMenuHandlerLoopedTask(s32 ltIdx) +{ + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + unk->loopedTaskId = CreateLoopedTask(sMenuHandlerLoopTaskFuncs[ltIdx], 1); + unk->callback = sub_81C99FC; +} + +bool32 sub_81C99C0(void) +{ + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + return unk->callback(); +} + +void sub_81C99D4(void) +{ + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + sub_81CA7F4(); + RemoveWindow(unk->optionDescWindowId); + sub_81C9FEC(); + sub_81CA994(); + FreePokenavSubstruct(2); +} + +static bool32 sub_81C99FC(void) +{ + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + return IsLoopedTaskActive(unk->loopedTaskId); +} + +static u32 sub_81C9A10(s32 state) +{ + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + switch (state) + { + case 0: + InitBgTemplates(gUnknown_08620194, ARRAY_COUNT(gUnknown_08620194)); + decompress_and_copy_tile_data_to_vram(1, gPokenavMessageBox_Gfx, 0, 0, 0); + SetBgTilemapBuffer(1, unk->bg1TilemapBuffer); + CopyToBgTilemapBuffer(1, gPokenavMessageBox_Tilemap, 0, 0); + CopyBgTilemapBufferToVram(1); + CopyPaletteIntoBufferUnfaded(gPokenavMessageBox_Pal, 0x10, 0x20); + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ChangeBgX(2, 0, 0); + ChangeBgY(2, 0, 0); + ChangeBgX(3, 0, 0); + ChangeBgY(3, 0, 0); + return LT_INC_AND_PAUSE; + case 1: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + decompress_and_copy_tile_data_to_vram(2, gUnknown_0861FD6C, 0, 0, 0); + decompress_and_copy_tile_data_to_vram(2, gUnknown_0861FFF4, 0, 0, 1); + CopyPaletteIntoBufferUnfaded(gUnknown_0861FD4C, 0x20, 0x20); + return LT_INC_AND_PAUSE; + case 2: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + decompress_and_copy_tile_data_to_vram(3, gUnknown_0861FC98, 0, 0, 0); + decompress_and_copy_tile_data_to_vram(3, gUnknown_0861FCAC, 0, 0, 1); + CopyPaletteIntoBufferUnfaded(gUnknown_0861FC78, 0x30, 0x20); + if (GetPokenavMenuType() == POKENAV_MENU_TYPE_CONDITION || GetPokenavMenuType() == POKENAV_MENU_TYPE_CONDITION_SEARCH) + sub_81CA850(); + return LT_INC_AND_PAUSE; + case 3: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + AddOptionDescriptionWindow(); + sub_81CA7D4(); + return LT_INC_AND_CONTINUE; + case 4: + sub_81C9FC4(); + return LT_INC_AND_CONTINUE; + case 5: + PrintCurrentOptionDescription(); + CreateMenuOptionSprites(); + sub_81CA640(); + sub_81CA0C8(); + return LT_INC_AND_PAUSE; + case 6: + if (sub_81CA7C4()) + return LT_PAUSE; + return LT_INC_AND_CONTINUE; + case 7: + ShowBg(1); + ShowBg(2); + ShowBg(3); + if (unk->field_00d) + sub_81C7AC0(1); + else + { + PlaySE(SE_PN_ON); + sub_81C7AC0(3); + } + switch (GetPokenavMenuType()) + { + case POKENAV_MENU_TYPE_CONDITION_SEARCH: + LoadLeftHeaderGfxForIndex(7); + // fallthrough + case POKENAV_MENU_TYPE_CONDITION: + LoadLeftHeaderGfxForIndex(1); + break; + default: + LoadLeftHeaderGfxForIndex(0); + break; + } + return LT_INC_AND_PAUSE; + case 8: + if (IsPaletteFadeActive()) + return LT_PAUSE; + switch (GetPokenavMenuType()) + { + case POKENAV_MENU_TYPE_CONDITION_SEARCH: + sub_81C7FA0(7, FALSE, FALSE); + // fallthrough + case POKENAV_MENU_TYPE_CONDITION: + sub_81C7FA0(1, FALSE, FALSE); + break; + default: + sub_81C7FA0(0, FALSE, FALSE); + break; + } + sub_81CA20C(); + sub_81CA92C(); + return LT_INC_AND_CONTINUE; + case 9: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 LoopedTask_MoveMenuCursor(s32 state) +{ + switch (state) + { + case 0: + sub_81CAA3C(); + sub_81CA278(); + PrintCurrentOptionDescription(); + PlaySE(SE_SELECT); + return LT_INC_AND_PAUSE; + case 1: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81CA7C4()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 LoopedTask_OpenConditionMenu(s32 state) +{ + switch (state) + { + case 0: + sub_81CA9C8(); + sub_81CA2DC(); + sub_81C7FC4(0, 0); + PlaySE(SE_SELECT); + return LT_INC_AND_PAUSE; + case 1: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + sub_81CA0C8(); + LoadLeftHeaderGfxForIndex(1); + return LT_INC_AND_PAUSE; + case 2: + sub_81CA20C(); + sub_81C7FA0(1, FALSE, FALSE); + sub_81CA818(); + PrintCurrentOptionDescription(); + return LT_INC_AND_PAUSE; + case 3: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + if (sub_81CA89C()) + return LT_PAUSE; + if (sub_81CA7C4()) + return LT_PAUSE; + sub_81CA9D8(); + break; + } + return LT_FINISH; +} + +static u32 LoopedTask_ReturnToMainMenu(s32 state) +{ + switch (state) + { + case 0: + sub_81CA9C8(); + sub_81CA2DC(); + sub_81C7FC4(1, 0); + return LT_INC_AND_PAUSE; + case 1: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + sub_81CA0C8(); + LoadLeftHeaderGfxForIndex(0); + return LT_INC_AND_PAUSE; + case 2: + sub_81CA20C(); + sub_81C7FA0(0, FALSE, FALSE); + sub_81CA864(); + PrintCurrentOptionDescription(); + return LT_INC_AND_PAUSE; + case 3: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + if (sub_81CA89C()) + return LT_PAUSE; + if (sub_81CA7C4()) + return LT_PAUSE; + sub_81CA9D8(); + break; + } + return LT_FINISH; +} + +static u32 LoopedTask_OpenConditionSearchMenu(s32 state) +{ + switch (state) + { + case 0: + sub_81CA9C8(); + sub_81CA2DC(); + PlaySE(SE_SELECT); + return LT_INC_AND_PAUSE; + case 1: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + LoadLeftHeaderGfxForIndex(7); + sub_81CA0C8(); + return LT_INC_AND_PAUSE; + case 2: + sub_81CA20C(); + sub_81C7FA0(7, FALSE, FALSE); + PrintCurrentOptionDescription(); + return LT_INC_AND_PAUSE; + case 3: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + if (sub_81CA89C()) + return LT_PAUSE; + sub_81CA9D8(); + break; + } + return LT_FINISH; +} + +static u32 LoopedTask_ReturnToConditionMenu(s32 state) +{ + switch (state) + { + case 0: + sub_81CA9C8(); + sub_81CA2DC(); + sub_81C7FC4(7, 0); + return LT_INC_AND_PAUSE; + case 1: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + sub_81CA0C8(); + return LT_INC_AND_PAUSE; + case 2: + sub_81CA20C(); + PrintCurrentOptionDescription(); + return LT_INC_AND_PAUSE; + case 3: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81CA89C()) + return LT_PAUSE; + sub_81CA9D8(); + break; + } + return LT_FINISH; +} + +static u32 LoopedTask_SelectRibbonsNoWinners(s32 state) +{ + switch (state) + { + case 0: + PlaySE(SE_HAZURE); + PrintNoRibbonWinners(); + return LT_INC_AND_PAUSE; + case 1: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +// For redisplaying the Ribbons description to replace the No Ribbon Winners message +static u32 LoopedTask_ReShowDescription(s32 state) +{ + switch (state) + { + case 0: + PlaySE(SE_SELECT); + PrintCurrentOptionDescription(); + return LT_INC_AND_PAUSE; + case 1: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +// For selecting a feature option from a menu, e.g. the Map, Match Call, Beauty search, etc. +static u32 LoopedTask_OpenPokenavFeature(s32 state) +{ + switch (state) + { + case 0: + PrintHelpBarText(GetHelpBarTextId()); + return LT_INC_AND_PAUSE; + case 1: + if (WaitForHelpBar()) + return LT_PAUSE; + sub_81C7880(); + sub_81CA9C8(); + sub_81CA2DC(); + switch (GetPokenavMenuType()) + { + case POKENAV_MENU_TYPE_CONDITION_SEARCH: + sub_81C7FC4(7, FALSE); + // fallthrough + case POKENAV_MENU_TYPE_CONDITION: + sub_81C7FC4(1, FALSE); + break; + default: + sub_81C7FC4(0, FALSE); + break; + } + PlaySE(SE_SELECT); + return LT_INC_AND_PAUSE; + case 2: + if (AreMenuOptionSpritesMoving()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + sub_81C7AC0(0); + return LT_INC_AND_PAUSE; + case 3: + if (IsPaletteFadeActive()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static void sub_81C9FC4(void) +{ + s32 i; + + for (i = 0; i < NELEMS(gUnknown_086201C4); i++) + LoadCompressedSpriteSheet(&gUnknown_086201C4[i]); + Pokenav_AllocAndLoadPalettes(gUnknown_086201D4); +} + +static void sub_81C9FEC(void) +{ + FreeSpriteTilesByTag(3); + FreeSpriteTilesByTag(1); + FreeSpritePaletteByTag(4); + FreeSpritePaletteByTag(5); + FreeSpritePaletteByTag(6); + FreeSpritePaletteByTag(7); + FreeSpritePaletteByTag(8); + FreeSpritePaletteByTag(3); + sub_81CA094(); + sub_81CA698(); +} + +static void CreateMenuOptionSprites(void) +{ + s32 i, j; + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) + { + // Each menu option is 4 subsprites + for (j = 0; j < 4; j++) + { + u8 spriteId = CreateSprite(&sMenuOptionSpriteTemplate, 0x8c, 20 * i + 40, 3); + unk->iconSprites[i][j] = &gSprites[spriteId]; + gSprites[spriteId].pos2.x = 32 * j; + } + } +} + +static void sub_81CA094(void) +{ + s32 i, j; + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) + { + for (j = 0; j < 4; j++) + { + FreeSpriteOamMatrix(unk->iconSprites[i][j]); + DestroySprite(unk->iconSprites[i][j]); + } + } +} + +static void sub_81CA0C8(void) +{ + s32 menuType = GetPokenavMenuType(); + sub_81CA0EC(gUnknown_08620240[menuType].unk4, gUnknown_08620240[menuType].unk0, gUnknown_08620240[menuType].unk2); +} + +static void sub_81CA0EC(const u16 *const *a0, s32 a1, s32 a2) +{ + s32 i, j; + struct Pokenav2Struct * unk = GetSubstructPtr(2); + s32 sp04 = GetSpriteTileStartByTag(3); + + for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) + { + if (*a0 != NULL) + { + for (j = 0; j < 4; j++) + { + unk->iconSprites[i][j]->oam.tileNum = (*a0)[0] + sp04 + 8 * j; + unk->iconSprites[i][j]->oam.paletteNum = IndexOfSpritePaletteTag((*a0)[1] + 4); + unk->iconSprites[i][j]->invisible = TRUE; + unk->iconSprites[i][j]->pos1.y = a1; + unk->iconSprites[i][j]->pos1.x = 0x8c; + unk->iconSprites[i][j]->pos2.x = 32 * j; + } + unk->iconVisible[i] = TRUE; + } + else + { + for (j = 0; j < 4; j++) + { + unk->iconSprites[i][j]->invisible = TRUE; + } + unk->iconVisible[i] = FALSE; + } + a0++; + a1 += a2; + } +} + +static void sub_81CA20C(void) +{ + s32 i; + struct Pokenav2Struct * unk = GetSubstructPtr(2); + s32 r8 = GetPokenavCursorPos(); + s32 r7 = 0; + s32 r2; + + for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) + { + if (unk->iconVisible[i]) + { + if (r7++ == r8) + { + r2 = 0x82; + unk->cursorPos = i; + } + else + r2 = 0x8c; + sub_81CA35C(unk->iconSprites[i], 0x100, r2, 0xC); + sub_81CA448(unk->iconSprites[i], FALSE); + } + else + sub_81CA448(unk->iconSprites[i], TRUE); + } +} + +static void sub_81CA278(void) +{ + s32 i; + struct Pokenav2Struct * unk = GetSubstructPtr(2); + s32 r3 = GetPokenavCursorPos(); + s32 r5; + + for (i = 0, r5 = 0; i < MAX_POKENAV_MENUITEMS; i++) + { + if (unk->iconVisible[i]) + { + if (r5 == r3) + { + r5 = i; + break; + } + r5++; + } + } + + sub_81CA35C(unk->iconSprites[unk->cursorPos], 0x82, 0x8c, 0x4); + sub_81CA35C(unk->iconSprites[r5], 0x8c, 0x82, 0x4); + unk->cursorPos = r5; +} + +static void sub_81CA2DC(void) +{ + s32 i; + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) + { + if (unk->iconVisible[i]) + { + if (unk->cursorPos != i) + sub_81CA35C(unk->iconSprites[i], 0x8C, 0x100, 0x8); + else + sub_81CA3B4(unk->iconSprites[i]); + } + } +} + +static bool32 AreMenuOptionSpritesMoving(void) +{ + s32 i; + struct Pokenav2Struct * unk = GetSubstructPtr(2); + + for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) + { + if (unk->iconSprites[i][0]->callback != SpriteCallbackDummy) + return TRUE; + } + + if (unk->otherIconsInMotion) + return TRUE; + + return FALSE; +} + +static void sub_81CA35C(struct Sprite ** sprites, s32 a1, s32 a2, s32 a3) +{ + s32 i; + + for (i = 0; i < 4; i++) + { + (*sprites)->pos1.x = a1; + (*sprites)->data[0] = a3; + (*sprites)->data[1] = 16 * (a2 - a1) / a3; + (*sprites)->data[2] = 16 * a1; + (*sprites)->data[7] = a2; + (*sprites)->callback = sub_81CA474; + sprites++; + } +} + +static void sub_81CA3B4(struct Sprite ** sprites) +{ + s32 i; + struct Pokenav2Struct * unk = GetSubstructPtr(2); + u8 taskId; + + for (i = 0; i < 4; i++) + { + (*sprites)->oam.objMode = ST_OAM_OBJ_BLEND; + (*sprites)->oam.affineMode = ST_OAM_AFFINE_DOUBLE; + (*sprites)->callback = sub_81CA4AC; + (*sprites)->data[0] = 8; + (*sprites)->data[1] = 0; + (*sprites)->data[7] = i; + InitSpriteAffineAnim(sprites[0]); + StartSpriteAffineAnim(sprites[0], 0); + sprites++; + } + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x10, 0x00)); + taskId = CreateTask(sub_81CA580, 3); + gTasks[taskId].data[0] = 8; + unk->otherIconsInMotion++; +} + +static void sub_81CA448(struct Sprite ** sprites, bool32 a1) +{ + s32 i; + + for (i = 0; i < 4; i++) + { + (*sprites)->invisible = a1; + sprites++; + } +} + +static void sub_81CA474(struct Sprite * sprite) +{ + sprite->data[0]--; + if (sprite->data[0] != -1) + { + sprite->data[2] += sprite->data[1]; + sprite->pos1.x = sprite->data[2] >> 4; + } + else + { + sprite->pos1.x = sprite->data[7]; + sprite->callback = SpriteCallbackDummy; + } +} + +static void sub_81CA4AC(struct Sprite * sprite) +{ + s32 r0; + s32 r1; + if (sprite->data[0] == 0) + { + if (sprite->data[1] == 0) + { + StartSpriteAffineAnim(sprite, 1); + sprite->data[1]++; + sprite->data[2] = 0x100; + sprite->pos1.x += sprite->pos2.x; + sprite->pos2.x = 0; + } + else + { + sprite->data[2] += 16; + r0 = sprite->data[2]; + r1 = r0 >> 3; + r1 = (r1 - 32) / 2; + switch (sprite->data[7]) + { + case 0: + sprite->pos2.x = -r1 * 3; + break; + case 1: + sprite->pos2.x = -r1; + break; + case 2: + sprite->pos2.x = r1; + break; + case 3: + sprite->pos2.x = r1 * 3; + break; + } + if (sprite->affineAnimEnded) + { + sprite->invisible = TRUE; + FreeOamMatrix(sprite->oam.matrixNum); + CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, ST_OAM_AFFINE_OFF); + sprite->oam.affineMode = ST_OAM_AFFINE_OFF; + sprite->oam.objMode = ST_OAM_OBJ_NORMAL; + sprite->callback = SpriteCallbackDummy; + } + } + } + else + { + sprite->data[0]--; + } +} + +static void sub_81CA580(u8 taskId) +{ + s16 * data = gTasks[taskId].data; + + if (data[0] == 0) + { + switch (data[1]) + { + case 0: + data[2] = 16; + data[3] = 0; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_NONE | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x10, 0x00)); + data[1]++; + break; + case 1: + if (data[4] & 1) + { + data[2] -= 3; + if (data[2] < 0) + data[2] = 0; + } + else + { + data[3] += 3; + if (data[3] > 16) + data[3] = 16; + } + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(data[2], data[3])); + data[4]++; + if (data[4] == 12) + { + ((struct Pokenav2Struct *)GetSubstructPtr(2))->otherIconsInMotion--; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x00, 0x10)); + DestroyTask(taskId); + } + break; + } + } + else + data[0]--; +} + +static void sub_81CA640(void) +{ + struct Pokenav2Struct * ptr = GetSubstructPtr(2); + u8 spriteId = CreateSprite(&gUnknown_0862036C, 0x10, 0x60, 4); + ptr->field_028 = &gSprites[spriteId]; + if (sub_81C98D4()) + ptr->field_028->callback = sub_81CA6AC; + else + ptr->field_028->invisible = TRUE; +} + +static void sub_81CA698(void) +{ + struct Pokenav2Struct * ptr = GetSubstructPtr(2); + DestroySprite(ptr->field_028); +} + +static void sub_81CA6AC(struct Sprite * sprite) +{ + sprite->data[0]++; + if (sprite->data[0] > 8) + { + sprite->data[0] = 0; + sprite->invisible ^= 1; + } +} + +static void AddOptionDescriptionWindow(void) +{ + struct Pokenav2Struct * ptr = GetSubstructPtr(2); + + ptr->optionDescWindowId = AddWindow(&sOptionDescWindowTemplate); + PutWindowTilemap(ptr->optionDescWindowId); + FillWindowPixelBuffer(ptr->optionDescWindowId, PIXEL_FILL(6)); + CopyWindowToVram(ptr->optionDescWindowId, 3); +} + +static void PrintCurrentOptionDescription(void) +{ + struct Pokenav2Struct * ptr = GetSubstructPtr(2); + int menuItem = GetCurrentMenuItemId(); + const u8 * s = sPageDescriptions[menuItem]; + u32 width = GetStringWidth(1, s, -1); + FillWindowPixelBuffer(ptr->optionDescWindowId, PIXEL_FILL(6)); + AddTextPrinterParameterized3(ptr->optionDescWindowId, 1, (192 - width) / 2, 1, sOptionDescTextColors, 0, s); +} + +// Printed when Ribbons is selected if no PC/party mons have ribbons +// Can occur by obtaining a mon with a ribbon and then releasing all ribbon winners +static void PrintNoRibbonWinners(void) +{ + struct Pokenav2Struct * ptr = GetSubstructPtr(2); + const u8 * s = gText_NoRibbonWinners; + u32 width = GetStringWidth(1, s, -1); + FillWindowPixelBuffer(ptr->optionDescWindowId, PIXEL_FILL(6)); + AddTextPrinterParameterized3(ptr->optionDescWindowId, 1, (192 - width) / 2, 1, sOptionDescTextColors2, 0, s); +} + +static bool32 sub_81CA7C4(void) +{ + return IsDma3ManagerBusyWithBgCopy(); +} + +static void sub_81CA7D4(void) +{ + struct Pokenav2Struct * ptr = GetSubstructPtr(2); + ptr->bg3ScrollTaskId = CreateTask(sub_81CA808, 2); +} + +static void sub_81CA7F4(void) +{ + struct Pokenav2Struct * ptr = GetSubstructPtr(2); + DestroyTask(ptr->bg3ScrollTaskId); +} + +static void sub_81CA808(u8 taskId) +{ + ChangeBgX(3, 0x80, 1); +} + +static void sub_81CA818(void) +{ + u8 taskId = CreateTask(sub_81CA8B0, 3); + SetWordTaskArg(taskId, 1, (uintptr_t)(gUnknown_0861FC78 + 1)); + SetWordTaskArg(taskId, 3, (uintptr_t)(gUnknown_0861FC78 + 7)); +} + +static void sub_81CA850(void) +{ + CopyPaletteIntoBufferUnfaded(gUnknown_0861FC78 + 7, 0x31, 4); +} + +static void sub_81CA864(void) +{ + u8 taskId = CreateTask(sub_81CA8B0, 3); + SetWordTaskArg(taskId, 1, (uintptr_t)(gUnknown_0861FC78 + 7)); + SetWordTaskArg(taskId, 3, (uintptr_t)(gUnknown_0861FC78 + 1)); +} + +static bool32 sub_81CA89C(void) +{ + return FuncIsActiveTask(sub_81CA8B0); +} + +static void sub_81CA8B0(u8 taskId) +{ + u16 sp8[2]; + s16 * data = gTasks[taskId].data; + const u16 * pal1 = (const u16 *)GetWordTaskArg(taskId, 1); + const u16 * pal2 = (const u16 *)GetWordTaskArg(taskId, 3); + + sub_81C79BC(pal1, pal2, 2, 12, ++data[0], sp8); + LoadPalette(sp8, 0x31, 4); + if (data[0] == 12) + DestroyTask(taskId); +} + +static void sub_81CA914(void) +{ + TransferPlttBuffer(); + LoadOam(); + ProcessSpriteCopyRequests(); + ScanlineEffect_InitHBlankDmaTransfer(); +} + +static void sub_81CA92C(void) +{ + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_OBJ | BLDCNT_EFFECT_LIGHTEN); + SetGpuReg(REG_OFFSET_BLDY, 0); + SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); + SetGpuRegBits(REG_OFFSET_WININ, 0x3F); + SetGpuRegBits(REG_OFFSET_WINOUT, 0x1F); + SetGpuRegBits(REG_OFFSET_WIN0V, 0xA0); + ScanlineEffect_Stop(); + sub_81CAA3C(); + ScanlineEffect_SetParams(gUnknown_08620384); + SetVBlankCallback_(sub_81CA914); + CreateTask(sub_81CA9EC, 3); +} + +static void sub_81CA994(void) +{ + SetGpuReg(REG_OFFSET_BLDCNT, 0); + ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); + ScanlineEffect_Stop(); + DestroyTask(FindTaskIdByFunc(sub_81CA9EC)); + SetPokenavVBlankCallback(); +} + +static void sub_81CA9C8(void) +{ + SetGpuReg(REG_OFFSET_BLDCNT, 0); +} + +static void sub_81CA9D8(void) +{ + sub_81CAA3C(); + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_OBJ | BLDCNT_EFFECT_LIGHTEN); +} + +static void sub_81CA9EC(u8 taskId) +{ + s16 * data = gTasks[taskId].data; + data[0]++; + if (data[0] > 0) + { + data[0] = 0; + data[1] += 3; + data[1] &= 0x7F; + SetGpuReg(REG_OFFSET_BLDY, gSineTable[data[1]] >> 5); + } +} + +static void sub_81CAA3C(void) +{ + int menuType = GetPokenavMenuType(); + int cursorPos = GetPokenavCursorPos(); + int r4 = gUnknown_08620240[menuType].unk2 * cursorPos + gUnknown_08620240[menuType].unk0 - 8; + CpuFill16(0, gScanlineEffectRegBuffers[0], 0x140); + CpuFill16(0, gScanlineEffectRegBuffers[1], 0x140); + CpuFill16(RGB(16, 23, 28), &gScanlineEffectRegBuffers[0][r4], 0x20); + CpuFill16(RGB(16, 23, 28), &gScanlineEffectRegBuffers[1][r4], 0x20); +} + +void sub_81CAADC(void) +{ + sub_81CA9C8(); +} diff --git a/src/pokenav_region_map.c b/src/pokenav_region_map.c new file mode 100755 index 000000000..be30ca94d --- /dev/null +++ b/src/pokenav_region_map.c @@ -0,0 +1,729 @@ +#include "global.h" +#include "bg.h" +#include "decompress.h" +#include "landmark.h" +#include "main.h" +#include "menu.h" +#include "palette.h" +#include "pokenav.h" +#include "region_map.h" +#include "sound.h" +#include "sprite.h" +#include "string_util.h" +#include "task.h" +#include "text_window.h" +#include "window.h" +#include "constants/songs.h" + +struct Pokenav5Struct +{ + u8 filler0[0xC]; + bool32 unkC; + u32 (*unk10)(struct Pokenav5Struct *); +}; + +struct Pokenav5Struct_2 +{ + bool32 (*unk0)(void); + u32 unk4; + u16 unk8; + struct Sprite *cityFeatureTextSprites[3]; + u8 unk18[0x800]; + u8 cityZoomPics[22][0xC8]; +}; + +struct CityMapEntry +{ + u16 mapSecId; + u16 index; + const u32 *tilemap; +}; + +static u32 sub_81CC568(struct Pokenav5Struct *); +static u32 sub_81CC5B4(struct Pokenav5Struct *); +static u32 sub_81CC5DC(struct Pokenav5Struct *); +static u32 sub_81CC6F4(s32); +static u32 sub_81CCD34(s32); +static bool32 sub_81CC6BC(void); +static void sub_81CC9EC(void); +static void sub_81CC9C0(void); +static void sub_81CCD10(void); +static bool32 sub_81CCD24(void); +static void sub_81CCA1C(struct Pokenav5Struct_2 *); +static bool32 sub_81CCAFC(void); +static void sub_81CCB0C(struct Pokenav5Struct_2 *); +static bool32 sub_81CCC4C(struct Pokenav5Struct_2 *); +static void sub_81CCC5C(int); +static bool32 sub_81CCC88(void); +static void sub_81CCE58(void); +static void sub_81CCD70(struct Pokenav5Struct_2 *, int, int); +static void sub_81CCDE8(struct Pokenav5Struct_2 *, int, int); +static void sub_81CCFA4(int); +static void sub_81CCC9C(u8 taskId); +static void sub_81CCF78(void); +void sub_81CCEF4(struct Sprite *sprite); +u32 sub_81CC848(s32); +u32 sub_81CC878(s32); +u32 sub_81CC8D8(s32); +u32 sub_81CC95C(s32); + +extern const u16 gHoennMapZoomIcons_Pal[]; +extern const struct SpriteTemplate gUnknown_086231D0; +extern const u32 gHoennMapZoomIcons_Gfx[]; + +const u16 gUnknown_08622868[] = INCBIN_U16("graphics/pokenav/8622868.gbapal"); +const u32 gUnknown_08622888[] = INCBIN_U32("graphics/pokenav/zoom_tiles.4bpp.lz"); + +#include "data/region_map/city_map_tilemaps.h" + + +const struct BgTemplate gUnknown_086230D8[3] = +{ + { + .bg = 1, + .charBaseIndex = 1, + .mapBaseIndex = 0x1F, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0 + }, + { + .bg = 2, + .charBaseIndex = 2, + .mapBaseIndex = 0x06, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0 + }, + { + .bg = 2, + .charBaseIndex = 0, + .mapBaseIndex = 0x00, + .screenSize = 2, + .paletteMode = 0, + .priority = 3, + .baseTile = 0 + }, +}; + +const LoopedTask gUnknown_086230E4[] = +{ + NULL, + sub_81CC848, + sub_81CC878, + sub_81CC8D8, + sub_81CC95C +}; + +const struct CompressedSpriteSheet gUnknown_086230F8[1] = +{ + {gHoennMapZoomIcons_Gfx, 0x800, 6} +}; + +const struct SpritePalette gUnknown_08623100[] = +{ + {gHoennMapZoomIcons_Pal, 11}, + {} +}; + +const struct WindowTemplate gUnknown_08623110 = +{ + .bg = 1, + .tilemapLeft = 17, + .tilemapTop = 4, + .width = 12, + .height = 13, + .paletteNum = 1, + .baseBlock = 0x4C +}; + +#include "data/region_map/city_map_entries.h" + +const struct OamData gUnknown_086231C8 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x8), + .x = 0, + .size = SPRITE_SIZE(32x8), + .tileNum = 0, + .priority = 1, + .paletteNum = 0, +}; + +const struct SpriteTemplate gUnknown_086231D0 = +{ + .tileTag = 6, + .paletteTag = 11, + .oam = &gUnknown_086231C8, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_81CCEF4, +}; + +u32 PokenavCallback_Init_6(void) +{ + struct Pokenav5Struct *state = AllocSubstruct(3, sizeof(struct Pokenav5Struct)); + if (!state) + return FALSE; + + if (!AllocSubstruct(16, sizeof(struct RegionMap))) + return FALSE; + + state->unkC = sub_8124668(gMapHeader.regionMapSectionId); + if (!state->unkC) + state->unk10 = sub_81CC568; + else + state->unk10 = sub_81CC5B4; + + return TRUE; +} + +void sub_81CC524(void) +{ + gSaveBlock2Ptr->regionMapZoom = sub_8124658(); + FreePokenavSubstruct(16); + FreePokenavSubstruct(3); +} + +u32 sub_81CC554(void) +{ + struct Pokenav5Struct *state = GetSubstructPtr(3); + return state->unk10(state); +} + +static u32 sub_81CC568(struct Pokenav5Struct *state) +{ + switch (sub_81230AC()) + { + case 3: + return 1; + case 4: + if (!sub_8124658()) + return 3; + return 2; + case 5: + state->unk10 = sub_81CC5DC; + return 4; + } + + return 0; +} + +static u32 sub_81CC5B4(struct Pokenav5Struct *state) +{ + if (gMain.newKeys & B_BUTTON) + { + state->unk10 = sub_81CC5DC; + return 4; + } + + return 0; +} + +static u32 sub_81CC5DC(struct Pokenav5Struct *state) +{ + return POKENAV_MENU_1; +} + +bool32 sub_81CC5E4(void) +{ + struct Pokenav5Struct *state = GetSubstructPtr(3); + return state->unkC; +} + +bool32 sub_81CC5F4(void) +{ + struct Pokenav5Struct_2 *state = AllocSubstruct(4, sizeof(struct Pokenav5Struct_2)); + if (!state) + return FALSE; + + state->unk4 = CreateLoopedTask(sub_81CC6F4, 1); + state->unk0 = sub_81CC6BC; + return TRUE; +} + +void sub_81CC62C(s32 index) +{ + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + state->unk4 = CreateLoopedTask(gUnknown_086230E4[index], 1); + state->unk0 = sub_81CC6BC; +} + +u32 sub_81CC65C(void) +{ + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + return state->unk0(); +} + +void sub_81CC670(void) +{ + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + FreeRegionMapIconResources(); + sub_81CC9EC(); + RemoveWindow(state->unk8); + FreePokenavSubstruct(16); + FreePokenavSubstruct(4); + SetPokenavVBlankCallback(); + SetBgMode(0); +} + +static void sub_81CC6A4(void) +{ + TransferPlttBuffer(); + LoadOam(); + ProcessSpriteCopyRequests(); + UpdateRegionMapVideoRegs(); +} + +static bool32 sub_81CC6BC(void) +{ + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + return IsLoopedTaskActive(state->unk4); +} + +static bool8 sub_81CC6D0(void) +{ + if (sub_81CC5E4()) + return FALSE; + + return gSaveBlock2Ptr->regionMapZoom == 1; +} + +static u32 sub_81CC6F4(s32 taskState) +{ + int var0; + struct RegionMap *regionMap; + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + switch (taskState) + { + case 0: + SetVBlankCallback_(NULL); + HideBg(1); + HideBg(2); + HideBg(3); + SetBgMode(1); + InitBgTemplates(gUnknown_086230D8, ARRAY_COUNT(gUnknown_086230D8) - 1); + regionMap = GetSubstructPtr(16); + sub_8122CF8(regionMap, &gUnknown_086230D8[1], sub_81CC6D0()); + sub_81CC9C0(); + return 0; + case 1: + if (sub_8122DB0()) + return 2; + + if (!sub_81CC5E4()) + { + CreateRegionMapPlayerIcon(4, 9); + CreateRegionMapCursor(5, 10); + sub_812454C(); + } + else + { + sub_8123030(0, 6); + } + return 0; + case 2: + sub_81CCD10(); + return 1; + case 3: + if (sub_81CCD24()) + return 2; + + sub_81CCA1C(state); + return 1; + case 4: + if (sub_81CCAFC()) + return 2; + + sub_81CCB0C(state); + sub_81C7B40(); + return 0; + case 5: + if (sub_81CCC4C(state)) + return 2; + + ShowBg(1); + ShowBg(2); + SetVBlankCallback_(sub_81CC6A4); + return 0; + case 6: + if (!sub_81CC6D0()) + var0 = 4; + else + var0 = 5; + + LoadLeftHeaderGfxForIndex(var0); + sub_81C7FA0(var0, 1, 1); + sub_81C7AC0(1); + return 0; + case 7: + if (IsPaletteFadeActive() || sub_81C8010()) + return 2; + return 1; + default: + return 4; + } +} + +u32 sub_81CC848(s32 taskState) +{ + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + switch (taskState) + { + case 0: + sub_81CCB0C(state); + return 0; + case 1: + if (sub_81CCC4C(state)) + return 2; + break; + } + + return 4; +} + +u32 sub_81CC878(s32 taskState) +{ + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + sub_81CCC5C(0); + sub_8123418(); + return 0; + case 1: + if (sub_8123514() || sub_81CCC88()) + return 2; + + PrintHelpBarText(HELPBAR_MAP_ZOOMED_OUT); + return 0; + case 2: + if (WaitForHelpBar()) + return 2; + + sub_81C7E14(4); + break; + } + + return 4; +} + +u32 sub_81CC8D8(s32 taskState) +{ + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + sub_81CCB0C(state); + return 0; + case 1: + if (sub_81CCC4C(state)) + return 2; + + sub_81CCC5C(1); + sub_8123418(); + return 0; + case 2: + if (sub_8123514() || sub_81CCC88()) + return 2; + + PrintHelpBarText(HELPBAR_MAP_ZOOMED_IN); + return 0; + case 3: + if (WaitForHelpBar()) + return 2; + + sub_81C7E14(5); + break; + } + + return 4; +} + +u32 sub_81CC95C(s32 taskState) +{ + switch (taskState) + { + case 0: + PlaySE(SE_SELECT); + sub_81C7AC0(0); + return 0; + case 1: + if (IsPaletteFadeActive()) + return 2; + + sub_81C7FDC(); + sub_81C78A0(); + return 0; + case 2: + if (MainMenuLoopedTaskIsBusy()) + return 2; + + HideBg(1); + HideBg(2); + HideBg(3); + return 0; + } + + return 4; +} + +static void sub_81CC9C0(void) +{ + int i; + for (i = 0; i < ARRAY_COUNT(gUnknown_086230F8); i++) + LoadCompressedSpriteSheet(&gUnknown_086230F8[i]); + + Pokenav_AllocAndLoadPalettes(gUnknown_08623100); + sub_81CCE58(); +} + +static void sub_81CC9EC(void) +{ + int i; + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + FreeSpriteTilesByTag(6); + FreeSpritePaletteByTag(11); + for (i = 0; i < 3; i++) + DestroySprite(state->cityFeatureTextSprites[i]); +} + +static void sub_81CCA1C(struct Pokenav5Struct_2 *state) +{ + sub_8199DF0(1, PIXEL_FILL(0), 0x40, 1); + sub_8199DF0(1, PIXEL_FILL(1), 0x41, 1); + CpuFill16(0x1040, state->unk18, 0x800); + SetBgTilemapBuffer(1, state->unk18); + state->unk8 = AddWindow(&gUnknown_08623110); + LoadUserWindowBorderGfx_(state->unk8, 0x42, 0x40); + DrawTextBorderOuter(state->unk8, 0x42, 4); + decompress_and_copy_tile_data_to_vram(1, gUnknown_08622888, 0, 0, 0); + FillWindowPixelBuffer(state->unk8, PIXEL_FILL(1)); + PutWindowTilemap(state->unk8); + CopyWindowToVram(state->unk8, 3); + CopyPaletteIntoBufferUnfaded(gUnknown_08622868, 0x10, 0x20); + CopyPaletteIntoBufferUnfaded(gHoennMapZoomIcons_Pal, 0x30, 0x20); + if (!sub_8124658()) + ChangeBgY(1, -0x6000, 0); + else + ChangeBgY(1, 0, 0); + + ChangeBgX(1, 0, 0); +} + +static bool32 sub_81CCAFC(void) +{ + return free_temp_tile_data_buffers_if_possible(); +} + +static void sub_81CCB0C(struct Pokenav5Struct_2 *state) +{ + struct RegionMap *regionMap = GetSubstructPtr(16); + switch (regionMap->iconDrawType) + { + case MAPSECTYPE_CITY_CANFLY: + FillWindowPixelBuffer(state->unk8, PIXEL_FILL(1)); + PutWindowRectTilemap(state->unk8, 0, 0, 12, 2); + AddTextPrinterParameterized(state->unk8, 7, regionMap->mapSecName, 0, 1, TEXT_SPEED_FF, NULL); + sub_81CCD70(state, regionMap->mapSecId, regionMap->posWithinMapSec); + CopyWindowToVram(state->unk8, 3); + sub_81CCFA4(0); + break; + case MAPSECTYPE_CITY_CANTFLY: + FillWindowPixelBuffer(state->unk8, PIXEL_FILL(1)); + PutWindowRectTilemap(state->unk8, 0, 0, 12, 2); + AddTextPrinterParameterized(state->unk8, 7, regionMap->mapSecName, 0, 1, TEXT_SPEED_FF, NULL); + FillBgTilemapBufferRect(1, 0x1041, 17, 6, 12, 11, 17); + CopyWindowToVram(state->unk8, 3); + sub_81CCFA4(1); + break; + case MAPSECTYPE_PLAIN: + case MAPSECTYPE_BATTLE_FRONTIER: + FillWindowPixelBuffer(state->unk8, PIXEL_FILL(1)); + PutWindowTilemap(state->unk8); + AddTextPrinterParameterized(state->unk8, 7, regionMap->mapSecName, 0, 1, TEXT_SPEED_FF, NULL); + sub_81CCDE8(state, regionMap->mapSecId, regionMap->posWithinMapSec); + CopyWindowToVram(state->unk8, 3); + sub_81CCFA4(1); + break; + case MAPSECTYPE_NONE: + FillBgTilemapBufferRect(1, 0x1041, 17, 4, 12, 13, 17); + CopyBgTilemapBufferToVram(1); + sub_81CCFA4(1); + break; + } +} + +static bool32 sub_81CCC4C(struct Pokenav5Struct_2 *state) +{ + return IsDma3ManagerBusyWithBgCopy(); +} + +static void sub_81CCC5C(int arg0) +{ + u8 taskId = CreateTask(sub_81CCC9C, 3); + gTasks[taskId].data[0] = arg0; +} + +static bool32 sub_81CCC88(void) +{ + return FuncIsActiveTask(sub_81CCC9C); +} + +static void sub_81CCC9C(u8 taskId) +{ + if (gTasks[taskId].data[0]) + { + if (ChangeBgY(1, 0x480, 1) >= 0) + { + ChangeBgY(1, 0, 0); + DestroyTask(taskId); + } + + sub_81CCF78(); + } + else + { + if (ChangeBgY(1, 0x480, 2) <= -0x6000) + { + ChangeBgY(1, -0x6000, 0); + DestroyTask(taskId); + } + + sub_81CCF78(); + } +} + +static void sub_81CCD10(void) +{ + CreateLoopedTask(sub_81CCD34, 1); +} + +static bool32 sub_81CCD24(void) +{ + return FuncIsActiveLoopedTask(sub_81CCD34); +} + +static u32 sub_81CCD34(s32 taskState) +{ + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + if (taskState < (int)ARRAY_COUNT(gPokenavCityMaps)) + { + LZ77UnCompWram(gPokenavCityMaps[taskState].tilemap, state->cityZoomPics[taskState]); + return 1; + } + + return 4; +} + +static void sub_81CCD70(struct Pokenav5Struct_2 *state, int mapSecId, int pos) +{ + int i; + for (i = 0; i < (int)ARRAY_COUNT(gPokenavCityMaps) && (gPokenavCityMaps[i].mapSecId != mapSecId || gPokenavCityMaps[i].index != pos); i++) + ; + + if (i == ARRAY_COUNT(gPokenavCityMaps)) + return; + + FillBgTilemapBufferRect_Palette0(1, 0x1041, 17, 6, 12, 11); + CopyToBgTilemapBufferRect(1, state->cityZoomPics[i], 18, 6, 10, 10); +} + +static void sub_81CCDE8(struct Pokenav5Struct_2 *state, int mapSecId, int pos) +{ + int i = 0; + while (1) + { + const u8 *landmarkName = GetLandmarkName(mapSecId, pos, i); + if (!landmarkName) + break; + + StringCopyPadded(gStringVar1, landmarkName, CHAR_SPACE, 12); + AddTextPrinterParameterized(state->unk8, 7, gStringVar1, 0, i * 16 + 17, TEXT_SPEED_FF, NULL); + i++; + } +} + +static void sub_81CCE58(void) +{ + int i; + int y; + struct Sprite *sprite; + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + + if (!sub_8124658()) + y = 228; + else + y = 132; + + for (i = 0; i < 3; i++) + { + u8 spriteId = CreateSprite(&gUnknown_086231D0, 152 + i * 32, y, 8); + sprite = &gSprites[spriteId]; + sprite->data[0] = 0; + sprite->data[1] = i * 4; + sprite->data[2] = sprite->oam.tileNum; + sprite->data[3] = 150; + sprite->data[4] = i * 4; + sprite->oam.tileNum += i * 4; + state->cityFeatureTextSprites[i] = sprite; + } +} + +void sub_81CCEF4(struct Sprite *sprite) +{ + if (sprite->data[3]) + { + sprite->data[3]--; + return; + } + + if (++sprite->data[0] > 11) + sprite->data[0] = 0; + + if (++sprite->data[1] > 60) + sprite->data[1] = 0; + + sprite->oam.tileNum = sprite->data[2] + sprite->data[1]; + if (sprite->data[5] < 4) + { + if (sprite->data[0] == 0) + { + sprite->data[5]++; + sprite->data[3] = 120; + } + } + else + { + if (sprite->data[1] == sprite->data[4]) + { + sprite->data[5] = 0; + sprite->data[0] = 0; + sprite->data[3] = 120; + } + } +} + +static void sub_81CCF78(void) +{ + int i; + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + int y = 132 - (GetBgY(1) >> 8); + for (i = 0; i < 3; i++) + state->cityFeatureTextSprites[i]->pos1.y = y; +} + +static void sub_81CCFA4(int invisible) +{ + int i; + struct Pokenav5Struct_2 *state = GetSubstructPtr(4); + for (i = 0; i < 3; i++) + state->cityFeatureTextSprites[i]->invisible = invisible; +} diff --git a/src/pokenav_ribbons_1.c b/src/pokenav_ribbons_1.c new file mode 100644 index 000000000..63b4adb30 --- /dev/null +++ b/src/pokenav_ribbons_1.c @@ -0,0 +1,732 @@ +#include "global.h" +#include "pokenav.h" +#include "bg.h" +#include "menu.h" +#include "window.h" +#include "sound.h" +#include "string_util.h" +#include "international_string_util.h" +#include "constants/songs.h" + +struct PokenavSub9 +{ + u32 (*unk0)(struct PokenavSub9*); + u32 loopedTaskId; + u16 winid; + s32 unkC; + s32 unk10; + u32 unk14; + u32 unk18; + struct PokenavSub18 *unk1C; +}; + +struct PokenavSub10 +{ + bool32 (*callback)(void); + u32 ltid; + u16 winid; + bool32 unkC; + u8 buff[BG_SCREEN_SIZE]; +}; + +static u32 sub_81CFA68(struct PokenavSub9 *structPtr); +static u32 sub_81CFA88(struct PokenavSub9 *structPtr); +static u32 sub_81CFB08(struct PokenavSub9 *structPtr); +static u32 sub_81CFB10(struct PokenavSub9 *structPtr); +static u32 sub_81CFB8C(s32 state); +static u32 sub_81CFC2C(s32 state); +static u32 sub_81CFC40(s32 state); +static u32 sub_81CFB74(s32 state); +static void sub_81CFCEC(struct PokenavSub9 *structPtr, struct PokenavMonList *item); +static u32 sub_81CFEB8(s32 state); +static bool32 sub_81CFE84(void); +static u32 sub_81CFFFC(s32 state); +static u32 sub_81D0074(s32 state); +static u32 sub_81D00EC(s32 state); +static u32 sub_81D0164(s32 state); +static u32 sub_81D01DC(s32 state); +static u32 sub_81D021C(s32 state); +static void sub_81D02B0(s32 windowId, s32 val1, s32 val2); +static void sub_81D024C(struct PokenavSub10 *ptr); +static void sub_81D0288(struct PokenavSub10 *ptr); +static void sub_81D0304(void); +static void BufferRibbonMonInfoText(struct PokenavMonList *, u8 *); + +static const LoopedTask gUnknown_086235D8[] = +{ + sub_81CFB8C, + sub_81CFC2C, + sub_81CFC40 +}; + +static const u16 gUnknown_086235E4[] = INCBIN_U16("graphics/pokenav/ui_ribbons.gbapal"); +static const u32 gUnknown_08623604[] = INCBIN_U32("graphics/pokenav/ui_ribbons.4bpp.lz"); +static const u32 gUnknown_086236CC[] = INCBIN_U32("graphics/pokenav/ui_ribbons.bin.lz"); +static const u16 gUnknown_08623790[] = INCBIN_U16("graphics/pokenav/8623790.gbapal"); + +static const struct BgTemplate gUnknown_086237B0[] = +{ + { + .bg = 1, + .charBaseIndex = 1, + .mapBaseIndex = 0x06, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0 + }, { + .bg = 2, + .charBaseIndex = 2, + .mapBaseIndex = 0x07, + .screenSize = 0, + .paletteMode = 0, + .priority = 3, + .baseTile = 0 + } +}; + +static const LoopedTask gUnknown_086237B8[] = +{ + NULL, + sub_81CFFFC, + sub_81D0074, + sub_81D00EC, + sub_81D0164, + sub_81D01DC, + sub_81D021C +}; + +static const struct WindowTemplate gUnknown_086237D4 = +{ + .bg = 1, + .tilemapLeft = 1, + .tilemapTop = 6, + .width = 7, + .height = 2, + .paletteNum = 1, + .baseBlock = 20 +}; + +static const u8 sText_MaleSymbol[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_RED}{WHITE}{GREEN}♂{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); +static const u8 sText_FemaleSymbol[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_GREEN}{WHITE}{BLUE}♀{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); +static const u8 sText_NoGenderSymbol[] = _("{UNK_SPACER}"); + +bool32 PokenavCallback_Init_12(void) +{ + struct PokenavSub9 *structPtr = AllocSubstruct(9, sizeof(struct PokenavSub9)); + if (structPtr == NULL) + return FALSE; + + structPtr->unk1C = AllocSubstruct(18, sizeof(struct PokenavSub18)); + if (structPtr->unk1C == NULL) + return FALSE; + + structPtr->unk0 = sub_81CFA68; + structPtr->loopedTaskId = CreateLoopedTask(sub_81CFB74, 1); + structPtr->unk14 = 0; + return TRUE; +} + +bool32 PokenavCallback_Init_14(void) +{ + struct PokenavSub9 *structPtr = AllocSubstruct(9, sizeof(struct PokenavSub9)); + if (structPtr == NULL) + return FALSE; + + structPtr->unk1C = GetSubstructPtr(18); + structPtr->unk0 = sub_81CFA88; + structPtr->unk14 = 1; + return TRUE; +} + +u32 sub_81CFA34(void) +{ + struct PokenavSub9 *structPtr = GetSubstructPtr(9); + return structPtr->unk0(structPtr); +} + +void sub_81CFA48(void) +{ + struct PokenavSub9 *structPtr = GetSubstructPtr(9); + if (!structPtr->unk18) + FreePokenavSubstruct(18); + FreePokenavSubstruct(9); +} + +static u32 sub_81CFA68(struct PokenavSub9 *structPtr) +{ + if (!IsLoopedTaskActive(structPtr->loopedTaskId)) + structPtr->unk0 = sub_81CFA88; + return 0; +} + +static u32 sub_81CFA88(struct PokenavSub9 *structPtr) +{ + if (gMain.newAndRepeatedKeys & DPAD_UP) + return 1; + if (gMain.newAndRepeatedKeys & DPAD_DOWN) + return 2; + if (gMain.newKeys & DPAD_LEFT) + return 3; + if (gMain.newKeys & DPAD_RIGHT) + return 4; + if (gMain.newKeys & B_BUTTON) + { + structPtr->unk18 = 0; + structPtr->unk0 = sub_81CFB08; + return 5; + } + if (gMain.newKeys & A_BUTTON) + { + structPtr->unk1C->unk2 = GetSelectedMatchCall(); + structPtr->unk18 = 1; + structPtr->unk0 = sub_81CFB10; + return 6; + } + return 0; +} + +static u32 sub_81CFB08(struct PokenavSub9 *structPtr) +{ + return POKENAV_MENU_5; +} + +static u32 sub_81CFB10(struct PokenavSub9 *structPtr) +{ + return POKENAV_MENU_D; +} + +static u32 sub_81CFB18(void) +{ + struct PokenavSub9 *structPtr = GetSubstructPtr(9); + return structPtr->unk14; +} + +static struct PokenavMonList * sub_81CFB28(void) +{ + struct PokenavSub9 * ptr = GetSubstructPtr(9); + return ptr->unk1C->unk4; +} + +static s32 sub_81CFB38(void) +{ + struct PokenavSub9 * ptr = GetSubstructPtr(9); + return ptr->unk1C->unk0; +} + +static s32 sub_81CFB48(void) +{ + struct PokenavSub9 * ptr = GetSubstructPtr(9); + s32 idx = GetSelectedMatchCall(); + return ptr->unk1C->unk4[idx].data; +} + +static s32 sub_81CFB64(void) +{ + struct PokenavSub9 * ptr = GetSubstructPtr(9); + return ptr->unk1C->unk2; +} + +static u32 sub_81CFB74(s32 state) +{ + return gUnknown_086235D8[state](state); +} + +static u32 sub_81CFB8C(s32 state) +{ + s32 i; + struct PokenavMonList item; + struct PokenavSub9 * ptr = GetSubstructPtr(9); + + ptr->unk1C->unk0 = 0; + ptr->unk1C->unk2 = 0; + item.boxId = TOTAL_BOXES_COUNT; + for (i = 0; i < PARTY_SIZE; i++) + { + struct Pokemon * pokemon = &gPlayerParty[i]; + if (!GetMonData(pokemon, MON_DATA_SANITY_HAS_SPECIES)) + return LT_INC_AND_CONTINUE; + if (!GetMonData(pokemon, MON_DATA_SANITY_IS_EGG) && !GetMonData(pokemon, MON_DATA_SANITY_IS_BAD_EGG)) + { + u32 ribbonCount = GetMonData(pokemon, MON_DATA_RIBBON_COUNT); + if (ribbonCount != 0) + { + item.monId = i; + item.data = ribbonCount; + sub_81CFCEC(ptr, &item); + } + } + } + + return LT_INC_AND_CONTINUE; +} + +static u32 sub_81CFC2C(s32 state) +{ + struct PokenavSub9 * ptr = GetSubstructPtr(9); + ptr->unk10 = 0; + ptr->unkC = 0; + return LT_INC_AND_CONTINUE; +} + +static u32 sub_81CFC40(s32 state) +{ + struct PokenavSub9 * ptr = GetSubstructPtr(9); + s32 boxId = ptr->unkC; + s32 monId = ptr->unk10; + s32 boxCount = 0; + struct PokenavMonList item; + + while (boxId < TOTAL_BOXES_COUNT) + { + while (monId < IN_BOX_COUNT) + { + if (CheckBoxMonSanityAt(boxId, monId)) + { + u32 ribbonCount = GetBoxMonDataAt(boxId, monId, MON_DATA_RIBBON_COUNT); + if (ribbonCount != 0) + { + item.boxId = boxId; + item.monId = monId; + item.data = ribbonCount; + sub_81CFCEC(ptr, &item); + } + } + boxCount++; + monId++; + if (boxCount > TOTAL_BOXES_COUNT) + { + ptr->unkC = boxId; + ptr->unk10 = monId; + return LT_CONTINUE; + } + } + monId = 0; + boxId++; + } + + ptr->unk14 = 1; + return LT_FINISH; +} + +static void sub_81CFCEC(struct PokenavSub9 *structPtr, struct PokenavMonList *item) +{ + u32 left = 0; + u32 right = structPtr->unk1C->unk0; + u32 insertionIdx = left + (right - left) / 2; + + while (right != insertionIdx) + { + if (item->data > structPtr->unk1C->unk4[insertionIdx].data) + right = insertionIdx; + else + left = insertionIdx + 1; + insertionIdx = left + (right - left) / 2; + } + for (right = structPtr->unk1C->unk0; right > insertionIdx; right--) + structPtr->unk1C->unk4[right] = structPtr->unk1C->unk4[right - 1]; + structPtr->unk1C->unk4[insertionIdx] = *item; + structPtr->unk1C->unk0++; +} + +static bool32 sub_81CFD58(void) +{ + s32 i, j; + + for (i = 0; i < PARTY_SIZE; i++) + { + struct Pokemon * mon = &gPlayerParty[i]; + if (!GetMonData(mon, MON_DATA_SANITY_HAS_SPECIES)) + continue; + if (GetMonData(mon, MON_DATA_SANITY_IS_EGG)) + continue; + if (GetMonData(mon, MON_DATA_RIBBONS)) + return TRUE; + } + + for (i = 0; i < TOTAL_BOXES_COUNT; i++) + { + for (j = 0; j < IN_BOX_COUNT; j++) + { + if (!CheckBoxMonSanityAt(i, j)) + continue; + if (GetBoxMonDataAt(i, j, MON_DATA_RIBBONS)) + return TRUE; + } + } + + return FALSE; +} + +bool32 sub_81CFDD0(void) +{ + struct PokenavSub10 * ptr = AllocSubstruct(10, sizeof(struct PokenavSub10)); + if (ptr == NULL) + return FALSE; + ptr->ltid = CreateLoopedTask(sub_81CFEB8, 1); + ptr->callback = sub_81CFE84; + ptr->unkC = FALSE; + return TRUE; +} + +bool32 sub_81CFE08(void) +{ + struct PokenavSub10 * ptr = AllocSubstruct(10, sizeof(struct PokenavSub10)); + if (ptr == NULL) + return FALSE; + ptr->ltid = CreateLoopedTask(sub_81CFEB8, 1); + ptr->callback = sub_81CFE84; + ptr->unkC = TRUE; + return TRUE; +} + +void sub_81CFE40(s32 idx) +{ + struct PokenavSub10 * ptr = GetSubstructPtr(10); + ptr->ltid = CreateLoopedTask(gUnknown_086237B8[idx], 1); + ptr->callback = sub_81CFE84; +} + +bool32 sub_81CFE70(void) +{ + struct PokenavSub10 * ptr = GetSubstructPtr(10); + return ptr->callback(); +} + +bool32 sub_81CFE84(void) +{ + struct PokenavSub10 * ptr = GetSubstructPtr(10); + return IsLoopedTaskActive(ptr->ltid); +} + +void sub_81CFE98(void) +{ + struct PokenavSub10 * ptr = GetSubstructPtr(10); + sub_81C8234(); + RemoveWindow(ptr->winid); + FreePokenavSubstruct(10); +} + +static u32 sub_81CFEB8(s32 state) +{ + struct PokenavSub10 * unk = GetSubstructPtr(10); + switch (state) + { + case 0: + InitBgTemplates(gUnknown_086237B0, NELEMS(gUnknown_086237B0)); + decompress_and_copy_tile_data_to_vram(1, gUnknown_08623604, 0, 0, 0); + SetBgTilemapBuffer(1, unk->buff); + CopyToBgTilemapBuffer(1, gUnknown_086236CC, 0, 0); + CopyPaletteIntoBufferUnfaded(gUnknown_086235E4, 0x10, 0x20); + CopyBgTilemapBufferToVram(1); + return LT_INC_AND_PAUSE; + case 1: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + if (!sub_81CFB18()) + return LT_PAUSE; + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ShowBg(1); + return LT_INC_AND_PAUSE; + case 2: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + CopyPaletteIntoBufferUnfaded(gUnknown_08623790, 0x20, 0x20); + sub_81D0304(); + return LT_INC_AND_PAUSE; + case 3: + if (sub_81C8224()) + return LT_PAUSE; + sub_81D024C(unk); + return LT_INC_AND_PAUSE; + case 4: + if (free_temp_tile_data_buffers_if_possible()) + return LT_PAUSE; + ShowBg(2); + HideBg(3); + PrintHelpBarText(HELPBAR_RIBBONS_MON_LIST); + sub_81C7AC0(1); + if (!unk->unkC) + { + LoadLeftHeaderGfxForIndex(2); + sub_81C7FA0(2, 1, 0); + } + return LT_INC_AND_PAUSE; + case 5: + if (IsPaletteFadeActive()) + return LT_PAUSE; + if (sub_81C8010()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81CFFFC(s32 state) +{ + struct PokenavSub10 * unk = GetSubstructPtr(10); + switch (state) + { + case 0: + switch (MatchCall_MoveCursorUp()) + { + case 0: + return LT_FINISH; + case 1: + PlaySE(SE_SELECT); + return LT_SET_STATE(2); + case 2: + PlaySE(SE_SELECT); + break; + } + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + // fallthrough + case 2: + sub_81D0288(unk); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81D0074(s32 state) +{ + struct PokenavSub10 * unk = GetSubstructPtr(10); + switch (state) + { + case 0: + switch (MatchCall_MoveCursorDown()) + { + case 0: + return LT_FINISH; + case 1: + PlaySE(SE_SELECT); + return LT_SET_STATE(2); + case 2: + PlaySE(SE_SELECT); + break; + } + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + // fallthrough + case 2: + sub_81D0288(unk); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81D00EC(s32 state) +{ + struct PokenavSub10 * unk = GetSubstructPtr(10); + switch (state) + { + case 0: + switch (MatchCall_PageUp()) + { + case 0: + return LT_FINISH; + case 1: + PlaySE(SE_SELECT); + return LT_SET_STATE(2); + case 2: + PlaySE(SE_SELECT); + break; + } + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + // fallthrough + case 2: + sub_81D0288(unk); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81D0164(s32 state) +{ + struct PokenavSub10 * unk = GetSubstructPtr(10); + switch (state) + { + case 0: + switch (MatchCall_PageDown()) + { + case 0: + return LT_FINISH; + case 1: + PlaySE(SE_SELECT); + return LT_SET_STATE(2); + case 2: + PlaySE(SE_SELECT); + break; + } + return LT_INC_AND_PAUSE; + case 1: + if (sub_81C8630()) + return LT_PAUSE; + // fallthrough + case 2: + sub_81D0288(unk); + return LT_INC_AND_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static u32 sub_81D01DC(s32 state) +{ + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81C7AC0(0); + sub_81C78A0(); + return LT_INC_AND_PAUSE; + case 1: + if (IsPaletteFadeActive()) + return LT_PAUSE; + if (MainMenuLoopedTaskIsBusy()) + return LT_PAUSE; + sub_81C7FDC(); + break; + } + return LT_FINISH; +} + +static u32 sub_81D021C(s32 state) +{ + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81C7AC0(0); + return LT_INC_AND_PAUSE; + case 1: + if (IsPaletteFadeActive()) + return LT_PAUSE; + break; + } + return LT_FINISH; +} + +static void sub_81D024C(struct PokenavSub10 * ptr) +{ + s32 r2; + ptr->winid = AddWindow(&gUnknown_086237D4); + PutWindowTilemap(ptr->winid); + r2 = sub_81CFB38(); + sub_81D02B0(ptr->winid, 0, r2); + CopyWindowToVram(ptr->winid, 1); + sub_81D0288(ptr); +} + +static void sub_81D0288(struct PokenavSub10 * ptr) +{ + s32 r4 = GetSelectedMatchCall(); + s32 r2 = sub_81CFB38(); + sub_81D02B0(ptr->winid, r4 + 1, r2); + CopyWindowToVram(ptr->winid, 2); +} + +static void sub_81D02B0(s32 windowId, s32 val1, s32 val2) +{ + u8 strbuf[16]; + u32 x; + + u8 * ptr = strbuf; + ptr = ConvertIntToDecimalStringN(ptr, val1, STR_CONV_MODE_RIGHT_ALIGN, 3); + *ptr++ = CHAR_SLASH; + ConvertIntToDecimalStringN(ptr, val2, STR_CONV_MODE_RIGHT_ALIGN, 3); + x = GetStringCenterAlignXOffset(1, strbuf, 56); + AddTextPrinterParameterized(windowId, 1, strbuf, x, 1, 0xFF, NULL); +} + +static void sub_81D0304(void) +{ + struct PokenavListTemplate template; + template.list.monList = sub_81CFB28(); + template.unk4 = sub_81CFB38(); + template.unk8 = 4; + template.unk6 = sub_81CFB64(); + template.unk9 = 13; + template.unkA = 17; + template.unkB = 1; + template.unkC = 8; + template.unkD = 2; + template.unkE = 1; + template.listFunc.unk10_1 = BufferRibbonMonInfoText; + template.unk14 = NULL; + sub_81C81D4(&gUnknown_086237B0[1], &template, 0); +} + +// Buffers the "Nickname gender/level" text for the ribbon mon list +static void BufferRibbonMonInfoText(struct PokenavMonList * item0, u8 * dest) +{ + u8 gender; + u8 level; + u8 * s; + const u8 * genderStr; + struct PokenavMonList * item = item0; + + // Mon is in party + if (item->boxId == TOTAL_BOXES_COUNT) + { + struct Pokemon * mon = &gPlayerParty[item->monId]; + gender = GetMonGender(mon); + level = GetLevelFromMonExp(mon); + GetMonData(mon, MON_DATA_NICKNAME, gStringVar3); + } + // Mon is in PC + else + { + struct BoxPokemon * mon = GetBoxedMonPtr(item->boxId, item->monId); + gender = GetBoxMonGender(mon); + level = GetLevelFromBoxMonExp(mon); + GetBoxMonData(mon, MON_DATA_NICKNAME, gStringVar3); + } + + StringGetEnd10(gStringVar3); + dest = sub_81DB494(dest, 1, gStringVar3, 60); + switch (gender) + { + default: + genderStr = sText_NoGenderSymbol; + break; + case MON_MALE: + genderStr = sText_MaleSymbol; + break; + case MON_FEMALE: + genderStr = sText_FemaleSymbol; + break; + } + + s = StringCopy(gStringVar1, genderStr); + *s++ = CHAR_SLASH; + *s++ = CHAR_SPECIAL_F9; + *s++ = CHAR_LV_2; + ConvertIntToDecimalStringN(s, level, STR_CONV_MODE_LEFT_ALIGN, 3); + dest = sub_81DB494(dest, 1, gStringVar1, 54); + ConvertIntToDecimalStringN(dest, item->data, STR_CONV_MODE_RIGHT_ALIGN, 2); +} diff --git a/src/pokenav_ribbons_2.c b/src/pokenav_ribbons_2.c new file mode 100644 index 000000000..2789b1244 --- /dev/null +++ b/src/pokenav_ribbons_2.c @@ -0,0 +1,1163 @@ +#include "global.h" +#include "decompress.h" +#include "dynamic_placeholder_text_util.h" +#include "graphics.h" +#include "international_string_util.h" +#include "pokenav.h" +#include "sound.h" +#include "sprite.h" +#include "string_util.h" +#include "strings.h" +#include "text.h" +#include "trainer_pokemon_sprites.h" +#include "window.h" +#include "constants/songs.h" + +struct PokenavSub13 +{ + u8 filler0[0x8]; + struct PokenavSub18 *field_8; + u16 field_C; + u16 field_E; + u16 field_10; + u16 field_12; + u32 field_14[25]; + u32 field_78[8]; + u32 (*field_98)(struct PokenavSub13 *structPtr); +}; + +struct PokenavSub14 +{ + u32 (*field_0)(void); + u32 loopedTaskId; + u16 field_8; + u16 field_A; + u16 field_C; + u16 field_E; + u16 field_10; + struct Sprite *field_14; + u32 filler; + u8 tilemapBuffers[2][BG_SCREEN_SIZE]; +}; + +static u32 gUnknown_030012C0; +static u32 gUnknown_030012C4; + +void sub_81D0E84(struct PokenavSub14 *structPtr); +void sub_81D0FF0(struct PokenavSub14 *structPtr); +void sub_81D10D0(struct PokenavSub14 *structPtr); +void sub_81D1500(struct PokenavSub14 *structPtr); +void sub_81D0EFC(struct PokenavSub14 *structPtr); +void sub_81D1148(struct PokenavSub14 *structPtr); +void sub_81D10A4(struct PokenavSub14 *structPtr); +void sub_81D1178(struct PokenavSub14 *structPtr); +void sub_81D11D8(struct PokenavSub14 *structPtr); +void sub_81D11FC(struct PokenavSub14 *structPtr); +void sub_81D0E60(struct PokenavSub14 *structPtr); +void sub_81D1448(struct PokenavSub14 *structPtr); +void sub_81D13FC(struct PokenavSub14 *structPtr); +void sub_81D0FCC(struct PokenavSub14 *structPtr); +void sub_81D12D8(struct PokenavSub14 *structPtr); +bool32 sub_81D1524(struct PokenavSub14 *structPtr); +bool32 sub_81D1234(struct PokenavSub14 *structPtr); +void sub_81D0814(struct PokenavSub13 *structPtr); +u32 sub_81D0548(struct PokenavSub13 *structPtr); +u32 sub_81D04C4(struct PokenavSub13 *structPtr); +u32 sub_81D05D4(struct PokenavSub13 *structPtr); +bool32 sub_81D05DC(struct PokenavSub13 *structPtr); +bool32 sub_81D0688(struct PokenavSub13 *structPtr); +bool32 sub_81D0664(struct PokenavSub13 *structPtr); +bool32 sub_81D061C(struct PokenavSub13 *structPtr); +bool32 sub_81D0688(struct PokenavSub13 *structPtr); +bool32 sub_81D0A58(void); +u32 sub_81D06C4(void); +u32 sub_81D06D4(void); +u16 sub_81D1184(s32 unused0, s32 unused1); +void sub_81D1258(struct Sprite *sprite, s32 arg1, s32 arg2, s32 arg3); +void sub_81D1284(struct Sprite *sprite); +void sub_81D1350(void); +void sub_81D13BC(u16 *dst, u32 id); +void sub_81D1370(u32 arg0, u32 id); +void sub_81D1538(struct Sprite *sprite); +u32 sub_81D0A6C(s32 state); +u32 sub_81D0C84(s32 state); +u32 sub_81D0D2C(s32 state); +u32 sub_81D0D8C(s32 state); +u32 sub_81D0E00(s32 state); +u32 sub_81D0C54(s32 state); + +struct +{ + u8 unk0; + u8 unk1; + u8 unk2; + u8 unk3; +} static const gUnknown_086237F8[] = +{ + {1, 1, 0, 0}, + {3, 4, 1, 0}, + {3, 4, 5, 0}, + {3, 4, 9, 0}, + {3, 4, 13, 0}, + {3, 4, 17, 0}, + {1, 1, 21, 0}, + {1, 1, 22, 0}, + {1, 1, 23, 0}, + {1, 1, 24, 0}, + {1, 1, 25, 1}, + {1, 1, 26, 1}, + {1, 1, 27, 1}, + {1, 1, 28, 1}, + {1, 1, 29, 1}, + {1, 1, 30, 1}, + {1, 1, 31, 1} +}; + +#include "data/text/ribbon_descriptions.h" +#include "data/text/gift_ribbon_descriptions.h" + +static const u16 gUnknown_08623FF8[] = INCBIN_U16("graphics/pokenav/ribbons_icon1.gbapal"); +static const u16 gUnknown_08624018[] = INCBIN_U16("graphics/pokenav/ribbons_icon2.gbapal"); +static const u16 gUnknown_08624038[] = INCBIN_U16("graphics/pokenav/ribbons_icon3.gbapal"); +static const u16 gUnknown_08624058[] = INCBIN_U16("graphics/pokenav/ribbons_icon4.gbapal"); +static const u16 gUnknown_08624078[] = INCBIN_U16("graphics/pokenav/ribbons_icon5.gbapal"); +static const u16 gUnknown_08624098[] = INCBIN_U16("graphics/pokenav/8624098.gbapal"); +static const u32 sRibbonIconsSmall_Gfx[] = INCBIN_U32("graphics/pokenav/ribbons_icon.4bpp.lz"); +static const u32 sRibbonIconsBig_Gfx[] = INCBIN_U32("graphics/pokenav/ribbons_icon_big.4bpp.lz"); + +static const struct BgTemplate gUnknown_08624B98[] = +{ + { + .bg = 1, + .charBaseIndex = 3, + .mapBaseIndex = 0x07, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0 + }, + { + .bg = 2, + .charBaseIndex = 1, + .mapBaseIndex = 0x06, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0 + } +}; + +static const LoopedTask gUnknown_08624BA0[] = +{ + NULL, + sub_81D0C84, + sub_81D0D2C, + sub_81D0D8C, + sub_81D0E00, + sub_81D0C54 +}; + +// code +bool32 PokenavCallback_Init_13(void) +{ + struct PokenavSub13 *structPtr = AllocSubstruct(13, sizeof(struct PokenavSub13)); + if (structPtr == NULL) + return FALSE; + + structPtr->field_8 = GetSubstructPtr(18); + if (structPtr->field_8 == NULL) + return FALSE; + + sub_81D0814(structPtr); + structPtr->field_98 = sub_81D04C4; + gKeyRepeatContinueDelay = 3; + gKeyRepeatStartDelay = 10; + return TRUE; +} + +u32 sub_81D04A0(void) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + return structPtr->field_98(structPtr); +} + +void sub_81D04B8(void) +{ + FreePokenavSubstruct(13); +} + +u32 sub_81D04C4(struct PokenavSub13 *structPtr) +{ + if (gMain.newAndRepeatedKeys & DPAD_UP && structPtr->field_8->unk2 != 0) + { + structPtr->field_8->unk2--; + structPtr->field_C = 0; + sub_81D0814(structPtr); + return 1; + } + else if (gMain.newAndRepeatedKeys & DPAD_DOWN && structPtr->field_8->unk2 < structPtr->field_8->unk0 - 1) + { + structPtr->field_8->unk2++; + structPtr->field_C = 0; + sub_81D0814(structPtr); + return 1; + } + else if (gMain.newKeys & A_BUTTON) + { + structPtr->field_98 = sub_81D0548; + return 2; + } + else if (gMain.newKeys & B_BUTTON) + { + structPtr->field_98 = sub_81D05D4; + return 5; + } + return 0; +} + +u32 sub_81D0548(struct PokenavSub13 *structPtr) +{ + if (gMain.newAndRepeatedKeys & DPAD_UP && sub_81D05DC(structPtr)) + return 3; + else if (gMain.newAndRepeatedKeys & DPAD_DOWN && sub_81D061C(structPtr)) + return 3; + else if (gMain.newAndRepeatedKeys & DPAD_LEFT && sub_81D0664(structPtr)) + return 3; + else if (gMain.newAndRepeatedKeys & DPAD_RIGHT && sub_81D0688(structPtr)) + return 3; + else if (gMain.newKeys & B_BUTTON) + { + structPtr->field_98 = sub_81D04C4; + return 4; + } + return 0; +} + +u32 sub_81D05D4(struct PokenavSub13 *structPtr) +{ + return POKENAV_MENU_E; +} + +bool32 sub_81D05DC(struct PokenavSub13 *structPtr) +{ + if (structPtr->field_C < 25) + { + if (structPtr->field_C <= 8) + return FALSE; + + structPtr->field_C -= 9; + return TRUE; + } + if (structPtr->field_10 != 0) + { + u32 var = structPtr->field_C - 27; + structPtr->field_C = var + structPtr->field_E; + if (structPtr->field_C >= structPtr->field_10) + structPtr->field_C = structPtr->field_10 - 1; + return TRUE; + } + return FALSE; +} + +bool32 sub_81D061C(struct PokenavSub13 *structPtr) +{ + if (structPtr->field_C >= 25) + return FALSE; + if (structPtr->field_C < structPtr->field_E) + { + structPtr->field_C += 9; + if (structPtr->field_C >= structPtr->field_10) + structPtr->field_C = structPtr->field_10 - 1; + return TRUE; + } + if (structPtr->field_12 != 0) + { + int var = structPtr->field_C - structPtr->field_E; + if (var >= structPtr->field_12) + var = structPtr->field_12 - 1; + + structPtr->field_C = var + 27; + return TRUE; + } + return FALSE; +} + +bool32 sub_81D0664(struct PokenavSub13 *structPtr) +{ + u16 var = structPtr->field_C % 9; + if (var != 0) + { + structPtr->field_C--; + return TRUE; + } + + return FALSE; +} + +bool32 sub_81D0688(struct PokenavSub13 *structPtr) +{ + int r1 = structPtr->field_C % 9; + + if (r1 >= 8) + return FALSE; + + if (structPtr->field_C <= 26) + { + if (structPtr->field_C < structPtr->field_10 - 1) + { + structPtr->field_C++; + return TRUE; + } + } + else + { + if (r1 < structPtr->field_12 - 1) + { + structPtr->field_C++; + return TRUE; + } + } + return FALSE; +} + +u32 sub_81D06C4(void) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + return structPtr->field_8->unk2; +} + +u32 sub_81D06D4(void) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + return structPtr->field_8->unk0; +} + +static void GetCurrMonInfo1(u8 *nick, u8 *level, u8 *gender) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + struct PokenavSub18 *mons = structPtr->field_8; + struct PokenavMonList *monInfo = &mons->unk4[mons->unk2]; + + if (monInfo->boxId == TOTAL_BOXES_COUNT) + { + struct Pokemon *mon = &gPlayerParty[monInfo->monId]; + GetMonData(mon, MON_DATA_NICKNAME, nick); + *level = GetLevelFromMonExp(mon); + *gender = GetMonGender(mon); + } + else + { + struct BoxPokemon *boxMon = GetBoxedMonPtr(monInfo->boxId, monInfo->monId); + *gender = GetBoxMonGender(boxMon); + *level = GetLevelFromBoxMonExp(boxMon); + GetBoxMonData(boxMon, MON_DATA_NICKNAME, nick); + } + StringGetEnd10(nick); +} + +static void GetCurrMonInfo2(u16 *species, u32 *personality, u32 *otId) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + struct PokenavSub18 *mons = structPtr->field_8; + struct PokenavMonList *monInfo = &mons->unk4[mons->unk2]; + + if (monInfo->boxId == TOTAL_BOXES_COUNT) + { + struct Pokemon *mon = &gPlayerParty[monInfo->monId]; + *species = GetMonData(mon, MON_DATA_SPECIES); + *personality = GetMonData(mon, MON_DATA_PERSONALITY); + *otId = GetMonData(mon, MON_DATA_OT_ID); + } + else + { + struct BoxPokemon *boxMon = GetBoxedMonPtr(monInfo->boxId, monInfo->monId); + *species = GetBoxMonData(boxMon, MON_DATA_SPECIES); + *personality = GetBoxMonData(boxMon, MON_DATA_PERSONALITY); + *otId = GetBoxMonData(boxMon, MON_DATA_OT_ID); + } +} + +static u32 GetCurrMonRibbonCount(void) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + struct PokenavSub18 *mons = structPtr->field_8; + struct PokenavMonList *monInfo = &mons->unk4[mons->unk2]; + + if (monInfo->boxId == TOTAL_BOXES_COUNT) + return GetMonData(&gPlayerParty[monInfo->monId], MON_DATA_RIBBON_COUNT); + else + return GetBoxMonDataAt(monInfo->boxId, monInfo->monId, MON_DATA_RIBBON_COUNT); +} + +void sub_81D0814(struct PokenavSub13 *structPtr) +{ + u32 ribbons; + s32 i, j; + struct PokenavSub18 *mons = structPtr->field_8; + struct PokenavMonList *monInfo = &mons->unk4[mons->unk2]; + + if (monInfo->boxId == TOTAL_BOXES_COUNT) + ribbons = GetMonData(&gPlayerParty[monInfo->monId], MON_DATA_RIBBONS); + else + ribbons = GetBoxMonDataAt(monInfo->boxId, monInfo->monId, MON_DATA_RIBBONS); + + structPtr->field_10 = 0; + structPtr->field_12 = 0; + for (i = 0; i < ARRAY_COUNT(gUnknown_086237F8); i++) + { + s32 r4 = ((1 << gUnknown_086237F8[i].unk0) - 1) & ribbons; + if (gUnknown_086237F8[i].unk3 == 0) + { + for (j = 0; j < r4; j++) + structPtr->field_14[structPtr->field_10++] = gUnknown_086237F8[i].unk2 + j; + } + else + { + for (j = 0; j < r4; j++) + structPtr->field_78[structPtr->field_12++] = gUnknown_086237F8[i].unk2 + j; + } + ribbons >>= gUnknown_086237F8[i].unk0; + } + + if (structPtr->field_10 != 0) + { + structPtr->field_E = ((structPtr->field_10 - 1) / 9) * 9; + structPtr->field_C = 0; + } + else + { + structPtr->field_E = 0; + structPtr->field_C = 27; + } +} + +u32 *sub_81D0914(u32 *arg0) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + *arg0 = structPtr->field_10; + return structPtr->field_14; +} + +u32 *sub_81D092C(u32 *arg0) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + *arg0 = structPtr->field_12; + return structPtr->field_78; +} + +u16 sub_81D0944(void) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + return structPtr->field_C; +} + +u32 sub_81D0954(void) +{ + struct PokenavSub13 *structPtr = GetSubstructPtr(13); + int var = structPtr->field_C; + if (var <= 24) + return structPtr->field_14[var]; + else + return structPtr->field_78[var - 27]; +} + +bool32 sub_81D0978(void) +{ + struct PokenavSub14 *structPtr = AllocSubstruct(14, sizeof(struct PokenavSub14)); + if (structPtr == NULL) + return FALSE; + + structPtr->loopedTaskId = CreateLoopedTask(sub_81D0A6C, 1); + structPtr->field_0 = sub_81D0A58; + return TRUE; +} + +void sub_81D09B0(s32 id) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + structPtr->loopedTaskId = CreateLoopedTask(gUnknown_08624BA0[id], 1); + structPtr->field_0 = sub_81D0A58; +} + +u32 sub_81D09E0(void) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + return structPtr->field_0(); +} + +void sub_81D09F4(void) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + RemoveWindow(structPtr->field_A); + RemoveWindow(structPtr->field_8); + RemoveWindow(structPtr->field_C); + RemoveWindow(structPtr->field_E); + sub_81D1178(structPtr); + FreeSpriteTilesByTag(9); + FreeSpritePaletteByTag(0xF); + FreeSpritePaletteByTag(0x10); + FreeSpritePaletteByTag(0x11); + FreeSpritePaletteByTag(0x12); + FreeSpritePaletteByTag(0x13); + FreeSpriteOamMatrix(structPtr->field_14); + DestroySprite(structPtr->field_14); + FreePokenavSubstruct(14); +} + +bool32 sub_81D0A58(void) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + return IsLoopedTaskActive(structPtr->loopedTaskId); +} + +u32 sub_81D0A6C(s32 state) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + switch (state) + { + case 0: + InitBgTemplates(gUnknown_08624B98, ARRAY_COUNT(gUnknown_08624B98)); + decompress_and_copy_tile_data_to_vram(2, gUnknown_08DDE030, 0, 0, 0); + SetBgTilemapBuffer(2, structPtr->tilemapBuffers[0]); + CopyToBgTilemapBuffer(2, gUnknown_08DDE12C, 0, 0); + CopyPaletteIntoBufferUnfaded(gUnknown_08DDE010, 0x10, 0x20); + CopyBgTilemapBufferToVram(2); + return LT_INC_AND_PAUSE; + case 1: + if (!free_temp_tile_data_buffers_if_possible()) + { + sub_8199DF0(1, 0, 0, 1); + decompress_and_copy_tile_data_to_vram(1, sRibbonIconsSmall_Gfx, 0, 1, 0); + SetBgTilemapBuffer(1, structPtr->tilemapBuffers[1]); + FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 32, 20); + CopyPaletteIntoBufferUnfaded(gUnknown_08623FF8, 0x20, 0xA0); + CopyPaletteIntoBufferUnfaded(gUnknown_08624098, 0xA0, 0x20); + CopyBgTilemapBufferToVram(1); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 2: + if (!free_temp_tile_data_buffers_if_possible()) + { + sub_81D0E60(structPtr); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 3: + if (!free_temp_tile_data_buffers_if_possible()) + { + sub_81D0FCC(structPtr); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 4: + if (!free_temp_tile_data_buffers_if_possible()) + { + sub_81D10A4(structPtr); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 5: + if (!IsDma3ManagerBusyWithBgCopy()) + { + CopyBgTilemapBufferToVram(2); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 6: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_81D1148(structPtr); + return LT_INC_AND_CONTINUE; + } + return LT_PAUSE; + case 7: + sub_81D12D8(structPtr); + PrintHelpBarText(HELPBAR_RIBBONS_LIST); + return LT_INC_AND_PAUSE; + case 8: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_81D13FC(structPtr); + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ChangeBgX(2, 0, 0); + ChangeBgY(2, 0, 0); + ShowBg(1); + ShowBg(2); + HideBg(3); + sub_81C7AC0(1); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 9: + if (IsPaletteFadeActive()) + return LT_PAUSE; + return LT_FINISH; + } + return LT_FINISH; +} + +u32 sub_81D0C54(s32 state) +{ + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81C7AC0(0); + return LT_INC_AND_PAUSE; + case 1: + if (IsPaletteFadeActive()) + return LT_PAUSE; + return LT_FINISH; + } + return LT_FINISH; +} + +u32 sub_81D0C84(s32 state) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81D11D8(structPtr); + return LT_INC_AND_PAUSE; + case 1: + if (!sub_81D1234(structPtr)) + { + sub_81D0FF0(structPtr); + return LT_INC_AND_CONTINUE; + } + return LT_PAUSE; + case 2: + sub_81D12D8(structPtr); + return LT_INC_AND_CONTINUE; + case 3: + sub_81D10D0(structPtr); + return LT_INC_AND_CONTINUE; + case 4: + sub_81D0E84(structPtr); + return LT_INC_AND_CONTINUE; + case 5: + if (!IsDma3ManagerBusyWithBgCopy()) + { + sub_81D11FC(structPtr); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 6: + if (sub_81D1234(structPtr)) + return LT_PAUSE; + return LT_FINISH; + } + return LT_FINISH; +} + +u32 sub_81D0D2C(s32 state) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81D1448(structPtr); + return LT_INC_AND_PAUSE; + case 1: + if (!sub_81D1524(structPtr)) + { + sub_81D0EFC(structPtr); + PrintHelpBarText(HELPBAR_RIBBONS_CHECK); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 2: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + } + return LT_FINISH; +} + +u32 sub_81D0D8C(s32 state) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81D1500(structPtr); + return LT_INC_AND_PAUSE; + case 1: + if (!sub_81D1524(structPtr)) + { + sub_81D1448(structPtr); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 2: + if (!sub_81D1524(structPtr)) + { + sub_81D0EFC(structPtr); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 3: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + } + return LT_FINISH; +} + +u32 sub_81D0E00(s32 state) +{ + struct PokenavSub14 *structPtr = GetSubstructPtr(14); + switch (state) + { + case 0: + PlaySE(SE_SELECT); + sub_81D1500(structPtr); + return LT_INC_AND_PAUSE; + case 1: + if (!sub_81D1524(structPtr)) + { + sub_81D0E84(structPtr); + PrintHelpBarText(HELPBAR_RIBBONS_LIST); + return LT_INC_AND_PAUSE; + } + return LT_PAUSE; + case 2: + if (IsDma3ManagerBusyWithBgCopy()) + return LT_PAUSE; + } + return LT_FINISH; +} + +static const struct WindowTemplate gUnknown_08624BB8 = +{ + .bg = 2, + .tilemapLeft = 12, + .tilemapTop = 13, + .width = 16, + .height = 4, + .paletteNum = 1, + .baseBlock = 0x14, +}; + +void sub_81D0E60(struct PokenavSub14 *structPtr) +{ + structPtr->field_A = AddWindow(&gUnknown_08624BB8); + PutWindowTilemap(structPtr->field_A); + sub_81D0E84(structPtr); +} + +void sub_81D0E84(struct PokenavSub14 *structPtr) +{ + u8 color[] = {TEXT_COLOR_RED, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY}; + + ConvertIntToDecimalStringN(gStringVar1, GetCurrMonRibbonCount(), STR_CONV_MODE_LEFT_ALIGN, 2); + DynamicPlaceholderTextUtil_Reset(); + DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1); + DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_RibbonsF700); + FillWindowPixelBuffer(structPtr->field_A, PIXEL_FILL(4)); + AddTextPrinterParameterized3(structPtr->field_A, 1, 0, 1, color, -1, gStringVar4); + CopyWindowToVram(structPtr->field_A, 2); +} + +void sub_81D0EFC(struct PokenavSub14 *structPtr) +{ + s32 i; + u32 ribbonId = sub_81D0954(); + u8 color[] = {TEXT_COLOR_RED, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY}; + + FillWindowPixelBuffer(structPtr->field_A, PIXEL_FILL(4)); + if (ribbonId < 25) + { + for (i = 0; i < 2; i++) + AddTextPrinterParameterized3(structPtr->field_A, 1, 0, (i * 16) + 1, color, -1, gRibbonDescriptionPointers[ribbonId][i]); + } + else + { + ribbonId = gSaveBlock1Ptr->giftRibbons[ribbonId - 25]; + if (ribbonId == 0) + return; + + ribbonId--; + for (i = 0; i < 2; i++) + AddTextPrinterParameterized3(structPtr->field_A, 1, 0, (i * 16) + 1, color, -1, gGiftRibbonDescriptionPointers[ribbonId][i]); + } + + CopyWindowToVram(structPtr->field_A, 2); +} + +static const struct WindowTemplate gUnknown_08624BC4 = +{ + .bg = 2, + .tilemapLeft = 14, + .tilemapTop = 1, + .width = 13, + .height = 2, + .paletteNum = 10, + .baseBlock = 0x54, +}; + +void sub_81D0FCC(struct PokenavSub14 *structPtr) +{ + structPtr->field_8 = AddWindow(&gUnknown_08624BC4); + PutWindowTilemap(structPtr->field_8); + sub_81D0FF0(structPtr); +} + +static const u8 sMaleIconString[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_RED}{WHITE}{GREEN}♂{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); +static const u8 sFemaleIconString[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_GREEN}{WHITE}{BLUE}♀{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); +static const u8 sGenderlessIconString[] = _("{UNK_SPACER}"); + +void sub_81D0FF0(struct PokenavSub14 *structPtr) +{ + const u8 *genderTxt; + u8 *txtPtr; + u8 level, gender; + u16 windowId = structPtr->field_8; + + FillWindowPixelBuffer(windowId, PIXEL_FILL(1)); + GetCurrMonInfo1(gStringVar3, &level, &gender); + AddTextPrinterParameterized(windowId, 1, gStringVar3, 0, 1, TEXT_SPEED_FF, NULL); + switch (gender) + { + case MON_MALE: + genderTxt = sMaleIconString; + break; + case MON_FEMALE: + genderTxt = sFemaleIconString; + break; + default: + genderTxt = sGenderlessIconString; + break; + } + + txtPtr = StringCopy(gStringVar1, genderTxt); + *(txtPtr++) = CHAR_SLASH; + *(txtPtr++) = CHAR_SPECIAL_F9; + *(txtPtr++) = CHAR_LV_2; + ConvertIntToDecimalStringN(txtPtr, level, STR_CONV_MODE_LEFT_ALIGN, 3); + AddTextPrinterParameterized(windowId, 1, gStringVar1, 60, 1, TEXT_SPEED_FF, NULL); + CopyWindowToVram(windowId, 2); +} + +static const struct WindowTemplate gUnknown_08624BE8[] = +{ + { + .bg = 2, + .tilemapLeft = 1, + .tilemapTop = 5, + .width = 7, + .height = 2, + .paletteNum = 1, + .baseBlock = 0x6E, + }, + {}, +}; + +void sub_81D10A4(struct PokenavSub14 *structPtr) +{ + structPtr->field_C = AddWindow(gUnknown_08624BE8); + FillWindowPixelBuffer(structPtr->field_C, PIXEL_FILL(1)); + PutWindowTilemap(structPtr->field_C); + sub_81D10D0(structPtr); +} + +void sub_81D10D0(struct PokenavSub14 *structPtr) +{ + s32 x; + u8 *txtPtr; + u32 id = sub_81D06C4() + 1; + u32 count = sub_81D06D4(); + + txtPtr = ConvertIntToDecimalStringN(gStringVar1, id, STR_CONV_MODE_RIGHT_ALIGN, 3); + *(txtPtr++) = CHAR_SLASH; + ConvertIntToDecimalStringN(txtPtr, count, STR_CONV_MODE_RIGHT_ALIGN, 3); + x = GetStringCenterAlignXOffset(1, gStringVar1, 56); + AddTextPrinterParameterized(structPtr->field_C, 1, gStringVar1, x, 1, TEXT_SPEED_FF, NULL); + CopyWindowToVram(structPtr->field_C, 2); +} + +void sub_81D1148(struct PokenavSub14 *structPtr) +{ + u16 species; + u32 personality, otId; + + GetCurrMonInfo2(&species, &personality, &otId); + ResetAllPicSprites(); + structPtr->field_10 = sub_81D1184(40, 104); + sub_81C7990(15, 0); +} + +void sub_81D1178(struct PokenavSub14 *structPtr) +{ + FreeAndDestroyMonPicSprite(structPtr->field_10); +} + +u16 sub_81D1184(s32 unused0, s32 unused1) +{ + u16 species, spriteId; + u32 personality, otId; + + GetCurrMonInfo2(&species, &personality, &otId); + spriteId = CreateMonPicSprite_HandleDeoxys(species, otId, personality, TRUE, 40, 104, 15, 0xFFFF); + gSprites[spriteId].oam.priority = 0; + return spriteId; +} + +void sub_81D11D8(struct PokenavSub14 *structPtr) +{ + sub_81D1258(&gSprites[structPtr->field_10], 40, -32, 6); +} + +void sub_81D11FC(struct PokenavSub14 *structPtr) +{ + FreeAndDestroyMonPicSprite(structPtr->field_10); + structPtr->field_10 = sub_81D1184(-32, 104); + sub_81D1258(&gSprites[structPtr->field_10], -32, 40, 6); +} + +bool32 sub_81D1234(struct PokenavSub14 *structPtr) +{ + return (gSprites[structPtr->field_10].callback != SpriteCallbackDummy); +} + +void sub_81D1258(struct Sprite *sprite, s32 arg1, s32 arg2, s32 arg3) +{ + u32 var = arg2 - arg1; + + sprite->pos1.x = arg1; + sprite->data[0] = arg1 << 4; + sprite->data[1] = (var << 4) / arg3; + sprite->data[2] = arg3; + sprite->data[3] = arg2; + + sprite->callback = sub_81D1284; +} + +void sub_81D1284(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 <= -32) + sprite->invisible = TRUE; + else + sprite->invisible = FALSE; + } + else + { + sprite->pos1.x = sprite->data[3]; + sprite->callback = SpriteCallbackDummy; + } +} + +void sub_81D12D8(struct PokenavSub14 *structPtr) +{ + u32 *ptr; + + sub_81D1350(); + + ptr = sub_81D0914(&gUnknown_030012C0); + for (gUnknown_030012C4 = 0; gUnknown_030012C4 < gUnknown_030012C0; gUnknown_030012C4++) + sub_81D1370(gUnknown_030012C4, *(ptr++)); + + ptr = sub_81D092C(&gUnknown_030012C0); + for (gUnknown_030012C4 = 0; gUnknown_030012C4 < gUnknown_030012C0; gUnknown_030012C4++) + sub_81D1370(gUnknown_030012C4 + 27, *(ptr++)); + + CopyBgTilemapBufferToVram(1); +} + +void sub_81D1350(void) +{ + FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 32, 20); +} + +void sub_81D1370(u32 arg0, u32 id) +{ + u16 bgData[4]; + u32 destX = (arg0 % 9) * 2 + 11; + u32 destY = (arg0 / 9) * 2 + 4; + + sub_81D13BC(bgData, id); + CopyToBgTilemapBufferRect(1, bgData, destX, destY, 2, 2); +} + +struct +{ + u16 var0; + u16 var2; +} static const gUnknown_08624BF8[] = +{ + {0, 0}, + {1, 0}, + {2, 0}, + {3, 0}, + {4, 0}, + {1, 1}, + {2, 1}, + {3, 1}, + {4, 1}, + {1, 2}, + {2, 2}, + {3, 2}, + {4, 2}, + {1, 3}, + {2, 3}, + {3, 3}, + {4, 3}, + {1, 4}, + {2, 4}, + {3, 4}, + {4, 4}, + {5, 0}, + {6, 0}, + {7, 1}, + {8, 2}, + {9, 1}, + {9, 3}, + {9, 4}, + {10, 3}, + {10, 4}, + {11, 0}, + {11, 1}, +}; + +void sub_81D13BC(u16 *dst, u32 id) +{ + u16 r3 = gUnknown_08624BF8[id].var2 + 2; + u16 r1 = (gUnknown_08624BF8[id].var0 * 2) + 1; + + dst[0] = r1 | (r3 << 12); + dst[1] = r1 | (r3 << 12) |0x400; + dst[2] = (r1 + 1) | (r3 << 12); + dst[3] = (r1 + 1) | (r3 << 12) | 0x400; +} + +static const struct CompressedSpriteSheet gUnknown_08624C78 = +{ + sRibbonIconsBig_Gfx, 0x1800, 9 +}; + +static const struct SpritePalette gUnknown_08624C80[] = +{ + {gUnknown_08623FF8, 15}, + {gUnknown_08624018, 16}, + {gUnknown_08624038, 17}, + {gUnknown_08624058, 18}, + {gUnknown_08624078, 19}, + {}, +}; + +static const struct OamData sOamData_8624CB0 = +{ + .y = 0, + .affineMode = ST_OAM_AFFINE_NORMAL, + .objMode = ST_OAM_OBJ_NORMAL, + .mosaic = 0, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x32), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(32x32), + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0 +}; + +static const union AffineAnimCmd sSpriteAffineAnim_8624CB8[] = +{ + AFFINEANIMCMD_FRAME(128, 128, 0, 0), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd sSpriteAffineAnim_8624CC8[] = +{ + AFFINEANIMCMD_FRAME(128, 128, 0, 0), + AFFINEANIMCMD_FRAME(32, 32, 0, 4), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd sSpriteAffineAnim_8624CE0[] = +{ + AFFINEANIMCMD_FRAME(256, 256, 0, 0), + AFFINEANIMCMD_FRAME(-32, -32, 0, 4), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd *const sSpriteAffineAnimTable_8624CF8[] = +{ + sSpriteAffineAnim_8624CB8, + sSpriteAffineAnim_8624CC8, + sSpriteAffineAnim_8624CE0 +}; + +static const struct SpriteTemplate gUnknown_08624D04 = +{ + .tileTag = 9, + .paletteTag = 15, + .oam = &sOamData_8624CB0, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = sSpriteAffineAnimTable_8624CF8, + .callback = SpriteCallbackDummy, +}; + +void sub_81D13FC(struct PokenavSub14 *structPtr) +{ + u8 spriteId; + + LoadCompressedSpriteSheet(&gUnknown_08624C78); + Pokenav_AllocAndLoadPalettes(gUnknown_08624C80); + + spriteId = CreateSprite(&gUnknown_08624D04, 0, 0, 0); + structPtr->field_14 = &gSprites[spriteId]; + structPtr->field_14->invisible = TRUE; +} + +void sub_81D1448(struct PokenavSub14 *structPtr) +{ + u32 ribbonId; + s32 r4 = sub_81D0944(); + s32 r5 = (r4 % 9) * 16 + 96; + s32 r0 = (r4 / 9) * 16 + 40; + + structPtr->field_14->pos1.x = r5; + structPtr->field_14->pos1.y = r0; + + ribbonId = sub_81D0954(); + structPtr->field_14->oam.tileNum = (gUnknown_08624BF8[ribbonId].var0 * 16) + GetSpriteTileStartByTag(9); + structPtr->field_14->oam.paletteNum = IndexOfSpritePaletteTag(gUnknown_08624BF8[ribbonId].var2 + 15); + + StartSpriteAffineAnim(structPtr->field_14, 1); + structPtr->field_14->invisible = FALSE; + structPtr->field_14->data[0] = 0; + structPtr->field_14->callback = sub_81D1538; +} + +void sub_81D1500(struct PokenavSub14 *structPtr) +{ + structPtr->field_14->data[0] = 1; + StartSpriteAffineAnim(structPtr->field_14, 2); + structPtr->field_14->callback = sub_81D1538; +} + +bool32 sub_81D1524(struct PokenavSub14 *structPtr) +{ + return (structPtr->field_14->callback != SpriteCallbackDummy); +} + +void sub_81D1538(struct Sprite *sprite) +{ + if (sprite->affineAnimEnded) + { + sprite->invisible = sprite->data[0]; + sprite->callback = SpriteCallbackDummy; + } +} diff --git a/src/pokenav_unk_1.c b/src/pokenav_unk_1.c deleted file mode 100644 index 44176176d..000000000 --- a/src/pokenav_unk_1.c +++ /dev/null @@ -1,513 +0,0 @@ -#include "global.h" -#include "pokenav.h" -#include "event_data.h" -#include "main.h" -#include "sound.h" -#include "constants/songs.h" - -struct Pokenav1Struct -{ - u16 menuType; - s16 cursorPos; - u16 currMenuItem; - u16 helpBarIndex; - u32 unk8; - u32 (*callback)(struct Pokenav1Struct*); -}; - -static bool32 UpdateMenuCursorPos(struct Pokenav1Struct *state); -static void ReturnToConditionMenu(struct Pokenav1Struct *state); -static void ReturnToMainMenu(struct Pokenav1Struct *state); -static u32 sub_81C97BC(struct Pokenav1Struct *state); -static void sub_81C97B0(struct Pokenav1Struct *state, u32 a1); -static u32 CB2_ReturnToConditionMenu(struct Pokenav1Struct *state); -static u32 CB2_ReturnToMainMenu(struct Pokenav1Struct *state); -static u32 HandleConditionSearchMenuInput(struct Pokenav1Struct *state); -static u32 HandleConditionMenuInput(struct Pokenav1Struct *state); -static u32 HandleCantOpenRibbonsInput(struct Pokenav1Struct *state); -static u32 HandleMainMenuInputEndTutorial(struct Pokenav1Struct *state); -static u32 HandleMainMenuInputTutorial(struct Pokenav1Struct *state); -static u32 HandleMainMenuInput(struct Pokenav1Struct *state); -static u32 (*GetMainMenuInputHandler(void))(struct Pokenav1Struct*); -static void SetMenuInputHandler(struct Pokenav1Struct *state); - -// Number of entries - 1 for that menu type -static const u8 sLastCursorPositions[] = -{ - [POKENAV_MENU_TYPE_DEFAULT] = 2, - [POKENAV_MENU_TYPE_UNLOCK_MC] = 3, - [POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS] = 4, - [POKENAV_MENU_TYPE_CONDITION] = 2, - [POKENAV_MENU_TYPE_CONDITION_SEARCH] = 5 -}; - -static const u8 sMenuItems[][6] = -{ - [POKENAV_MENU_TYPE_DEFAULT] = - { - POKENAV_MENUITEM_MAP, - POKENAV_MENUITEM_CONDITION, - [2 ... 5] = POKENAV_MENUITEM_SWITCH_OFF - }, - [POKENAV_MENU_TYPE_UNLOCK_MC] = - { - POKENAV_MENUITEM_MAP, - POKENAV_MENUITEM_CONDITION, - POKENAV_MENUITEM_MATCH_CALL, - [3 ... 5] = POKENAV_MENUITEM_SWITCH_OFF - }, - [POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS] = - { - POKENAV_MENUITEM_MAP, - POKENAV_MENUITEM_CONDITION, - POKENAV_MENUITEM_MATCH_CALL, - POKENAV_MENUITEM_RIBBONS, - [4 ... 5] = POKENAV_MENUITEM_SWITCH_OFF - }, - [POKENAV_MENU_TYPE_CONDITION] = - { - POKENAV_MENUITEM_CONDITION_PARTY, - POKENAV_MENUITEM_CONDITION_SEARCH, - POKENAV_MENUITEM_CONDITION_CANCEL, - [3 ... 5] = POKENAV_MENUITEM_SWITCH_OFF - }, - [POKENAV_MENU_TYPE_CONDITION_SEARCH] = - { - POKENAV_MENUITEM_CONDITION_SEARCH_COOL, - POKENAV_MENUITEM_CONDITION_SEARCH_BEAUTY, - POKENAV_MENUITEM_CONDITION_SEARCH_CUTE, - POKENAV_MENUITEM_CONDITION_SEARCH_SMART, - POKENAV_MENUITEM_CONDITION_SEARCH_TOUGH, - POKENAV_MENUITEM_CONDITION_SEARCH_CANCEL - }, -}; - -static u8 GetPokenavMainMenuType(void) -{ - u8 menuType = POKENAV_MENU_TYPE_DEFAULT; - - if (FlagGet(FLAG_ADDED_MATCH_CALL_TO_POKENAV)) - { - menuType = POKENAV_MENU_TYPE_UNLOCK_MC; - - if (FlagGet(FLAG_SYS_RIBBON_GET)) - menuType = POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS; - } - - return menuType; -} - -bool32 PokenavCallback_Init_0(void) -{ - struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); - if (!state) - return FALSE; - - state->menuType = GetPokenavMainMenuType(); - state->cursorPos = 0; - state->currMenuItem = POKENAV_MENUITEM_MAP; - state->helpBarIndex = HELPBAR_NONE; - SetMenuInputHandler(state); - return TRUE; -} - -bool32 PokenavCallback_Init_4(void) -{ - struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); - if (!state) - return FALSE; - - state->menuType = GetPokenavMainMenuType(); - state->cursorPos = 2; - state->currMenuItem = POKENAV_MENUITEM_MATCH_CALL; - state->helpBarIndex = HELPBAR_NONE; - SetMenuInputHandler(state); - return TRUE; -} - -bool32 PokenavCallback_Init_5(void) -{ - struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); - if (!state) - return FALSE; - - state->menuType = GetPokenavMainMenuType(); - state->cursorPos = 3; - state->currMenuItem = POKENAV_MENUITEM_RIBBONS; - SetMenuInputHandler(state); - return TRUE; -} - -bool32 PokenavCallback_Init_2(void) -{ - struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); - if (!state) - return FALSE; - - state->menuType = POKENAV_MENU_TYPE_CONDITION; - state->cursorPos = 0; - state->currMenuItem = POKENAV_MENUITEM_CONDITION_PARTY; - state->helpBarIndex = HELPBAR_NONE; - SetMenuInputHandler(state); - return TRUE; -} - -bool32 PokenavCallback_Init_3(void) -{ - struct Pokenav1Struct *state = AllocSubstruct(1, sizeof(struct Pokenav1Struct)); - if (!state) - return FALSE; - - state->menuType = POKENAV_MENU_TYPE_CONDITION_SEARCH; - state->cursorPos = GetSelectedConditionSearch(); - state->currMenuItem = state->cursorPos + POKENAV_MENUITEM_CONDITION_SEARCH_COOL; - state->helpBarIndex = HELPBAR_NONE; - SetMenuInputHandler(state); - return TRUE; -} - -static void SetMenuInputHandler(struct Pokenav1Struct *state) -{ - switch (state->menuType) - { - case POKENAV_MENU_TYPE_DEFAULT: - SetPokenavMode(POKENAV_MODE_NORMAL); - // fallthrough - case POKENAV_MENU_TYPE_UNLOCK_MC: - case POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS: - state->callback = GetMainMenuInputHandler(); - break; - case POKENAV_MENU_TYPE_CONDITION: - state->callback = HandleConditionMenuInput; - break; - case POKENAV_MENU_TYPE_CONDITION_SEARCH: - state->callback = HandleConditionSearchMenuInput; - break; - } -} - -static u32 (*GetMainMenuInputHandler(void))(struct Pokenav1Struct*) -{ - switch (GetPokenavMode()) - { - default: - case POKENAV_MODE_NORMAL: - return HandleMainMenuInput; - case POKENAV_MODE_FORCE_CALL_READY: - return HandleMainMenuInputTutorial; - case POKENAV_MODE_FORCE_CALL_EXIT: - return HandleMainMenuInputEndTutorial; - } -} - -u32 sub_81C941C(void) -{ - struct Pokenav1Struct *state = GetSubstructPtr(1); - return state->callback(state); -} - -void sub_81C9430(void) -{ - FreePokenavSubstruct(1); -} - -static u32 HandleMainMenuInput(struct Pokenav1Struct *state) -{ - if (UpdateMenuCursorPos(state)) - return POKENAV_MENU_FUNC_MOVE_CURSOR; - - if (gMain.newKeys & A_BUTTON) - { - switch (sMenuItems[state->menuType][state->cursorPos]) - { - case POKENAV_MENUITEM_MAP: - state->helpBarIndex = gSaveBlock2Ptr->regionMapZoom ? HELPBAR_MAP_ZOOMED_IN : HELPBAR_MAP_ZOOMED_OUT; - sub_81C97B0(state, POKENAV_MENU_6); - return POKENAV_MENU_FUNC_OPEN_FEATURE; - case POKENAV_MENUITEM_CONDITION: - state->menuType = POKENAV_MENU_TYPE_CONDITION; - state->cursorPos = 0; - state->currMenuItem = sMenuItems[POKENAV_MENU_TYPE_CONDITION][0]; - state->callback = HandleConditionMenuInput; - return POKENAV_MENU_FUNC_OPEN_CONDITION; - case POKENAV_MENUITEM_MATCH_CALL: - state->helpBarIndex = HELPBAR_MC_TRAINER_LIST; - sub_81C97B0(state, POKENAV_MENU_B); - return POKENAV_MENU_FUNC_OPEN_FEATURE; - case POKENAV_MENUITEM_RIBBONS: - if (CanViewRibbonsMenu()) - { - state->helpBarIndex = HELPBAR_RIBBONS_MON_LIST; - sub_81C97B0(state, POKENAV_MENU_C); - return POKENAV_MENU_FUNC_OPEN_FEATURE; - } - else - { - state->callback = HandleCantOpenRibbonsInput; - return POKENAV_MENU_FUNC_NO_RIBBON_WINNERS; - } - case POKENAV_MENUITEM_SWITCH_OFF: - return -1; - } - } - - if (gMain.newKeys & B_BUTTON) - return -1; - - return POKENAV_MENU_FUNC_NONE; -} - -// Force the player to select Match Call during the call Mr. Stone pokenav tutorial -static u32 HandleMainMenuInputTutorial(struct Pokenav1Struct *state) -{ - if (UpdateMenuCursorPos(state)) - return POKENAV_MENU_FUNC_MOVE_CURSOR; - - if (gMain.newKeys & A_BUTTON) - { - if (sMenuItems[state->menuType][state->cursorPos] == POKENAV_MENUITEM_MATCH_CALL) - { - state->helpBarIndex = HELPBAR_MC_TRAINER_LIST; - sub_81C97B0(state, POKENAV_MENU_B); - return POKENAV_MENU_FUNC_OPEN_FEATURE; - } - else - { - PlaySE(SE_HAZURE); - return POKENAV_MENU_FUNC_NONE; - } - } - - if (gMain.newKeys & B_BUTTON) - { - PlaySE(SE_HAZURE); - return POKENAV_MENU_FUNC_NONE; - } - - return POKENAV_MENU_FUNC_NONE; -} - -// After calling Mr. Stone during the pokenav tutorial, force player to exit or use Match Call again -static u32 HandleMainMenuInputEndTutorial(struct Pokenav1Struct *state) -{ - if (UpdateMenuCursorPos(state)) - return POKENAV_MENU_FUNC_MOVE_CURSOR; - - if (gMain.newKeys & A_BUTTON) - { - u32 menuItem = sMenuItems[state->menuType][state->cursorPos]; - if (menuItem != POKENAV_MENUITEM_MATCH_CALL && menuItem != POKENAV_MENUITEM_SWITCH_OFF) - { - PlaySE(SE_HAZURE); - return POKENAV_MENU_FUNC_NONE; - } - else if (menuItem == POKENAV_MENUITEM_MATCH_CALL) - { - state->helpBarIndex = HELPBAR_MC_TRAINER_LIST; - sub_81C97B0(state, POKENAV_MENU_B); - return POKENAV_MENU_FUNC_OPEN_FEATURE; - } - else - { - return -1; - } - } - else if (gMain.newKeys & B_BUTTON) - { - return -1; - } - return POKENAV_MENU_FUNC_NONE; -} - -// Handles input after selecting Ribbons when there are no ribbon winners left -// Selecting it again just reprints the Ribbon description to replace the "No Ribbon winners" message -static u32 HandleCantOpenRibbonsInput(struct Pokenav1Struct *state) -{ - if (UpdateMenuCursorPos(state)) - { - state->callback = GetMainMenuInputHandler(); - return POKENAV_MENU_FUNC_MOVE_CURSOR; - } - - if (gMain.newKeys & (A_BUTTON | B_BUTTON)) - { - state->callback = GetMainMenuInputHandler(); - return POKENAV_MENU_FUNC_RESHOW_DESCRIPTION; - } - - return POKENAV_MENU_FUNC_NONE; -} - -static u32 HandleConditionMenuInput(struct Pokenav1Struct *state) -{ - if (UpdateMenuCursorPos(state)) - return POKENAV_MENU_FUNC_MOVE_CURSOR; - - if (gMain.newKeys & A_BUTTON) - { - switch (sMenuItems[state->menuType][state->cursorPos]) - { - case POKENAV_MENUITEM_CONDITION_SEARCH: - state->menuType = POKENAV_MENU_TYPE_CONDITION_SEARCH; - state->cursorPos = 0; - state->currMenuItem = sMenuItems[POKENAV_MENU_TYPE_CONDITION_SEARCH][0]; - state->callback = HandleConditionSearchMenuInput; - return POKENAV_MENU_FUNC_OPEN_CONDITION_SEARCH; - case POKENAV_MENUITEM_CONDITION_PARTY: - state->helpBarIndex = 0; - sub_81C97B0(state, POKENAV_MENU_7); - return POKENAV_MENU_FUNC_OPEN_FEATURE; - case POKENAV_MENUITEM_CONDITION_CANCEL: - PlaySE(SE_SELECT); - ReturnToMainMenu(state); - return POKENAV_MENU_FUNC_RETURN_TO_MAIN; - } - } - if (gMain.newKeys & B_BUTTON) - { - if (state->cursorPos != sLastCursorPositions[state->menuType]) - { - state->cursorPos = sLastCursorPositions[state->menuType]; - state->callback = CB2_ReturnToMainMenu; - return POKENAV_MENU_FUNC_MOVE_CURSOR; - } - else - { - PlaySE(SE_SELECT); - ReturnToMainMenu(state); - return POKENAV_MENU_FUNC_RETURN_TO_MAIN; - } - } - - return POKENAV_MENU_FUNC_NONE; -} - -static u32 HandleConditionSearchMenuInput(struct Pokenav1Struct *state) -{ - if (UpdateMenuCursorPos(state)) - return POKENAV_MENU_FUNC_MOVE_CURSOR; - - if (gMain.newKeys & A_BUTTON) - { - u8 menuItem = sMenuItems[state->menuType][state->cursorPos]; - if (menuItem != POKENAV_MENUITEM_CONDITION_SEARCH_CANCEL) - { - SetSelectedConditionSearch(menuItem - POKENAV_MENUITEM_CONDITION_SEARCH_COOL); - sub_81C97B0(state, POKENAV_MENU_8); - state->helpBarIndex = HELPBAR_CONDITION_MON_LIST; - return POKENAV_MENU_FUNC_OPEN_FEATURE; - } - else - { - PlaySE(SE_SELECT); - ReturnToConditionMenu(state); - return POKENAV_MENU_FUNC_RETURN_TO_CONDITION; - } - } - if (gMain.newKeys & B_BUTTON) - { - if (state->cursorPos != sLastCursorPositions[state->menuType]) - { - state->cursorPos = sLastCursorPositions[state->menuType]; - state->callback = CB2_ReturnToConditionMenu; - return POKENAV_MENU_FUNC_MOVE_CURSOR; - } - else - { - PlaySE(SE_SELECT); - ReturnToConditionMenu(state); - return POKENAV_MENU_FUNC_RETURN_TO_CONDITION; - } - } - return POKENAV_MENU_FUNC_NONE; -} - -static u32 CB2_ReturnToMainMenu(struct Pokenav1Struct *state) -{ - ReturnToMainMenu(state); - return POKENAV_MENU_FUNC_RETURN_TO_MAIN; -} - -static u32 CB2_ReturnToConditionMenu(struct Pokenav1Struct *state) -{ - ReturnToConditionMenu(state); - return POKENAV_MENU_FUNC_RETURN_TO_CONDITION; -} - -static void sub_81C97B0(struct Pokenav1Struct *state, u32 a1) -{ - state->unk8 = a1; - state->callback = sub_81C97BC; -} - -static u32 sub_81C97BC(struct Pokenav1Struct *state) -{ - return state->unk8; -} - -static void ReturnToMainMenu(struct Pokenav1Struct *state) -{ - state->menuType = GetPokenavMainMenuType(); - state->cursorPos = 1; - state->currMenuItem = sMenuItems[state->menuType][state->cursorPos]; - state->callback = HandleMainMenuInput; -} - -static void ReturnToConditionMenu(struct Pokenav1Struct *state) -{ - state->menuType = POKENAV_MENU_TYPE_CONDITION; - state->cursorPos = 1; - state->currMenuItem = sMenuItems[POKENAV_MENU_TYPE_CONDITION][1]; - state->callback = HandleConditionMenuInput; -} - -static bool32 UpdateMenuCursorPos(struct Pokenav1Struct *state) -{ - if (gMain.newKeys & DPAD_UP) - { - if (--state->cursorPos < 0) - state->cursorPos = sLastCursorPositions[state->menuType]; - - state->currMenuItem = sMenuItems[state->menuType][state->cursorPos]; - return TRUE; - } - else if (gMain.newKeys & DPAD_DOWN) - { - state->cursorPos++; - if (state->cursorPos > sLastCursorPositions[state->menuType]) - state->cursorPos = 0; - - state->currMenuItem = sMenuItems[state->menuType][state->cursorPos]; - return TRUE; - } - else - { - return FALSE; - } -} - -int GetPokenavMenuType(void) -{ - struct Pokenav1Struct *state = GetSubstructPtr(1); - return state->menuType; -} - -// Position of cursor relative to number of current menu options -int GetPokenavCursorPos(void) -{ - struct Pokenav1Struct *state = GetSubstructPtr(1); - return state->cursorPos; -} - -// ID of menu item the cursor is currently on -int GetCurrentMenuItemId(void) -{ - struct Pokenav1Struct *state = GetSubstructPtr(1); - return state->currMenuItem; -} - -u16 GetHelpBarTextId(void) -{ - struct Pokenav1Struct *state = GetSubstructPtr(1); - return state->helpBarIndex; -} diff --git a/src/pokenav_unk_10.c b/src/pokenav_unk_10.c deleted file mode 100644 index 2789b1244..000000000 --- a/src/pokenav_unk_10.c +++ /dev/null @@ -1,1163 +0,0 @@ -#include "global.h" -#include "decompress.h" -#include "dynamic_placeholder_text_util.h" -#include "graphics.h" -#include "international_string_util.h" -#include "pokenav.h" -#include "sound.h" -#include "sprite.h" -#include "string_util.h" -#include "strings.h" -#include "text.h" -#include "trainer_pokemon_sprites.h" -#include "window.h" -#include "constants/songs.h" - -struct PokenavSub13 -{ - u8 filler0[0x8]; - struct PokenavSub18 *field_8; - u16 field_C; - u16 field_E; - u16 field_10; - u16 field_12; - u32 field_14[25]; - u32 field_78[8]; - u32 (*field_98)(struct PokenavSub13 *structPtr); -}; - -struct PokenavSub14 -{ - u32 (*field_0)(void); - u32 loopedTaskId; - u16 field_8; - u16 field_A; - u16 field_C; - u16 field_E; - u16 field_10; - struct Sprite *field_14; - u32 filler; - u8 tilemapBuffers[2][BG_SCREEN_SIZE]; -}; - -static u32 gUnknown_030012C0; -static u32 gUnknown_030012C4; - -void sub_81D0E84(struct PokenavSub14 *structPtr); -void sub_81D0FF0(struct PokenavSub14 *structPtr); -void sub_81D10D0(struct PokenavSub14 *structPtr); -void sub_81D1500(struct PokenavSub14 *structPtr); -void sub_81D0EFC(struct PokenavSub14 *structPtr); -void sub_81D1148(struct PokenavSub14 *structPtr); -void sub_81D10A4(struct PokenavSub14 *structPtr); -void sub_81D1178(struct PokenavSub14 *structPtr); -void sub_81D11D8(struct PokenavSub14 *structPtr); -void sub_81D11FC(struct PokenavSub14 *structPtr); -void sub_81D0E60(struct PokenavSub14 *structPtr); -void sub_81D1448(struct PokenavSub14 *structPtr); -void sub_81D13FC(struct PokenavSub14 *structPtr); -void sub_81D0FCC(struct PokenavSub14 *structPtr); -void sub_81D12D8(struct PokenavSub14 *structPtr); -bool32 sub_81D1524(struct PokenavSub14 *structPtr); -bool32 sub_81D1234(struct PokenavSub14 *structPtr); -void sub_81D0814(struct PokenavSub13 *structPtr); -u32 sub_81D0548(struct PokenavSub13 *structPtr); -u32 sub_81D04C4(struct PokenavSub13 *structPtr); -u32 sub_81D05D4(struct PokenavSub13 *structPtr); -bool32 sub_81D05DC(struct PokenavSub13 *structPtr); -bool32 sub_81D0688(struct PokenavSub13 *structPtr); -bool32 sub_81D0664(struct PokenavSub13 *structPtr); -bool32 sub_81D061C(struct PokenavSub13 *structPtr); -bool32 sub_81D0688(struct PokenavSub13 *structPtr); -bool32 sub_81D0A58(void); -u32 sub_81D06C4(void); -u32 sub_81D06D4(void); -u16 sub_81D1184(s32 unused0, s32 unused1); -void sub_81D1258(struct Sprite *sprite, s32 arg1, s32 arg2, s32 arg3); -void sub_81D1284(struct Sprite *sprite); -void sub_81D1350(void); -void sub_81D13BC(u16 *dst, u32 id); -void sub_81D1370(u32 arg0, u32 id); -void sub_81D1538(struct Sprite *sprite); -u32 sub_81D0A6C(s32 state); -u32 sub_81D0C84(s32 state); -u32 sub_81D0D2C(s32 state); -u32 sub_81D0D8C(s32 state); -u32 sub_81D0E00(s32 state); -u32 sub_81D0C54(s32 state); - -struct -{ - u8 unk0; - u8 unk1; - u8 unk2; - u8 unk3; -} static const gUnknown_086237F8[] = -{ - {1, 1, 0, 0}, - {3, 4, 1, 0}, - {3, 4, 5, 0}, - {3, 4, 9, 0}, - {3, 4, 13, 0}, - {3, 4, 17, 0}, - {1, 1, 21, 0}, - {1, 1, 22, 0}, - {1, 1, 23, 0}, - {1, 1, 24, 0}, - {1, 1, 25, 1}, - {1, 1, 26, 1}, - {1, 1, 27, 1}, - {1, 1, 28, 1}, - {1, 1, 29, 1}, - {1, 1, 30, 1}, - {1, 1, 31, 1} -}; - -#include "data/text/ribbon_descriptions.h" -#include "data/text/gift_ribbon_descriptions.h" - -static const u16 gUnknown_08623FF8[] = INCBIN_U16("graphics/pokenav/ribbons_icon1.gbapal"); -static const u16 gUnknown_08624018[] = INCBIN_U16("graphics/pokenav/ribbons_icon2.gbapal"); -static const u16 gUnknown_08624038[] = INCBIN_U16("graphics/pokenav/ribbons_icon3.gbapal"); -static const u16 gUnknown_08624058[] = INCBIN_U16("graphics/pokenav/ribbons_icon4.gbapal"); -static const u16 gUnknown_08624078[] = INCBIN_U16("graphics/pokenav/ribbons_icon5.gbapal"); -static const u16 gUnknown_08624098[] = INCBIN_U16("graphics/pokenav/8624098.gbapal"); -static const u32 sRibbonIconsSmall_Gfx[] = INCBIN_U32("graphics/pokenav/ribbons_icon.4bpp.lz"); -static const u32 sRibbonIconsBig_Gfx[] = INCBIN_U32("graphics/pokenav/ribbons_icon_big.4bpp.lz"); - -static const struct BgTemplate gUnknown_08624B98[] = -{ - { - .bg = 1, - .charBaseIndex = 3, - .mapBaseIndex = 0x07, - .screenSize = 0, - .paletteMode = 0, - .priority = 1, - .baseTile = 0 - }, - { - .bg = 2, - .charBaseIndex = 1, - .mapBaseIndex = 0x06, - .screenSize = 0, - .paletteMode = 0, - .priority = 2, - .baseTile = 0 - } -}; - -static const LoopedTask gUnknown_08624BA0[] = -{ - NULL, - sub_81D0C84, - sub_81D0D2C, - sub_81D0D8C, - sub_81D0E00, - sub_81D0C54 -}; - -// code -bool32 PokenavCallback_Init_13(void) -{ - struct PokenavSub13 *structPtr = AllocSubstruct(13, sizeof(struct PokenavSub13)); - if (structPtr == NULL) - return FALSE; - - structPtr->field_8 = GetSubstructPtr(18); - if (structPtr->field_8 == NULL) - return FALSE; - - sub_81D0814(structPtr); - structPtr->field_98 = sub_81D04C4; - gKeyRepeatContinueDelay = 3; - gKeyRepeatStartDelay = 10; - return TRUE; -} - -u32 sub_81D04A0(void) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - return structPtr->field_98(structPtr); -} - -void sub_81D04B8(void) -{ - FreePokenavSubstruct(13); -} - -u32 sub_81D04C4(struct PokenavSub13 *structPtr) -{ - if (gMain.newAndRepeatedKeys & DPAD_UP && structPtr->field_8->unk2 != 0) - { - structPtr->field_8->unk2--; - structPtr->field_C = 0; - sub_81D0814(structPtr); - return 1; - } - else if (gMain.newAndRepeatedKeys & DPAD_DOWN && structPtr->field_8->unk2 < structPtr->field_8->unk0 - 1) - { - structPtr->field_8->unk2++; - structPtr->field_C = 0; - sub_81D0814(structPtr); - return 1; - } - else if (gMain.newKeys & A_BUTTON) - { - structPtr->field_98 = sub_81D0548; - return 2; - } - else if (gMain.newKeys & B_BUTTON) - { - structPtr->field_98 = sub_81D05D4; - return 5; - } - return 0; -} - -u32 sub_81D0548(struct PokenavSub13 *structPtr) -{ - if (gMain.newAndRepeatedKeys & DPAD_UP && sub_81D05DC(structPtr)) - return 3; - else if (gMain.newAndRepeatedKeys & DPAD_DOWN && sub_81D061C(structPtr)) - return 3; - else if (gMain.newAndRepeatedKeys & DPAD_LEFT && sub_81D0664(structPtr)) - return 3; - else if (gMain.newAndRepeatedKeys & DPAD_RIGHT && sub_81D0688(structPtr)) - return 3; - else if (gMain.newKeys & B_BUTTON) - { - structPtr->field_98 = sub_81D04C4; - return 4; - } - return 0; -} - -u32 sub_81D05D4(struct PokenavSub13 *structPtr) -{ - return POKENAV_MENU_E; -} - -bool32 sub_81D05DC(struct PokenavSub13 *structPtr) -{ - if (structPtr->field_C < 25) - { - if (structPtr->field_C <= 8) - return FALSE; - - structPtr->field_C -= 9; - return TRUE; - } - if (structPtr->field_10 != 0) - { - u32 var = structPtr->field_C - 27; - structPtr->field_C = var + structPtr->field_E; - if (structPtr->field_C >= structPtr->field_10) - structPtr->field_C = structPtr->field_10 - 1; - return TRUE; - } - return FALSE; -} - -bool32 sub_81D061C(struct PokenavSub13 *structPtr) -{ - if (structPtr->field_C >= 25) - return FALSE; - if (structPtr->field_C < structPtr->field_E) - { - structPtr->field_C += 9; - if (structPtr->field_C >= structPtr->field_10) - structPtr->field_C = structPtr->field_10 - 1; - return TRUE; - } - if (structPtr->field_12 != 0) - { - int var = structPtr->field_C - structPtr->field_E; - if (var >= structPtr->field_12) - var = structPtr->field_12 - 1; - - structPtr->field_C = var + 27; - return TRUE; - } - return FALSE; -} - -bool32 sub_81D0664(struct PokenavSub13 *structPtr) -{ - u16 var = structPtr->field_C % 9; - if (var != 0) - { - structPtr->field_C--; - return TRUE; - } - - return FALSE; -} - -bool32 sub_81D0688(struct PokenavSub13 *structPtr) -{ - int r1 = structPtr->field_C % 9; - - if (r1 >= 8) - return FALSE; - - if (structPtr->field_C <= 26) - { - if (structPtr->field_C < structPtr->field_10 - 1) - { - structPtr->field_C++; - return TRUE; - } - } - else - { - if (r1 < structPtr->field_12 - 1) - { - structPtr->field_C++; - return TRUE; - } - } - return FALSE; -} - -u32 sub_81D06C4(void) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - return structPtr->field_8->unk2; -} - -u32 sub_81D06D4(void) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - return structPtr->field_8->unk0; -} - -static void GetCurrMonInfo1(u8 *nick, u8 *level, u8 *gender) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - struct PokenavSub18 *mons = structPtr->field_8; - struct PokenavMonList *monInfo = &mons->unk4[mons->unk2]; - - if (monInfo->boxId == TOTAL_BOXES_COUNT) - { - struct Pokemon *mon = &gPlayerParty[monInfo->monId]; - GetMonData(mon, MON_DATA_NICKNAME, nick); - *level = GetLevelFromMonExp(mon); - *gender = GetMonGender(mon); - } - else - { - struct BoxPokemon *boxMon = GetBoxedMonPtr(monInfo->boxId, monInfo->monId); - *gender = GetBoxMonGender(boxMon); - *level = GetLevelFromBoxMonExp(boxMon); - GetBoxMonData(boxMon, MON_DATA_NICKNAME, nick); - } - StringGetEnd10(nick); -} - -static void GetCurrMonInfo2(u16 *species, u32 *personality, u32 *otId) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - struct PokenavSub18 *mons = structPtr->field_8; - struct PokenavMonList *monInfo = &mons->unk4[mons->unk2]; - - if (monInfo->boxId == TOTAL_BOXES_COUNT) - { - struct Pokemon *mon = &gPlayerParty[monInfo->monId]; - *species = GetMonData(mon, MON_DATA_SPECIES); - *personality = GetMonData(mon, MON_DATA_PERSONALITY); - *otId = GetMonData(mon, MON_DATA_OT_ID); - } - else - { - struct BoxPokemon *boxMon = GetBoxedMonPtr(monInfo->boxId, monInfo->monId); - *species = GetBoxMonData(boxMon, MON_DATA_SPECIES); - *personality = GetBoxMonData(boxMon, MON_DATA_PERSONALITY); - *otId = GetBoxMonData(boxMon, MON_DATA_OT_ID); - } -} - -static u32 GetCurrMonRibbonCount(void) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - struct PokenavSub18 *mons = structPtr->field_8; - struct PokenavMonList *monInfo = &mons->unk4[mons->unk2]; - - if (monInfo->boxId == TOTAL_BOXES_COUNT) - return GetMonData(&gPlayerParty[monInfo->monId], MON_DATA_RIBBON_COUNT); - else - return GetBoxMonDataAt(monInfo->boxId, monInfo->monId, MON_DATA_RIBBON_COUNT); -} - -void sub_81D0814(struct PokenavSub13 *structPtr) -{ - u32 ribbons; - s32 i, j; - struct PokenavSub18 *mons = structPtr->field_8; - struct PokenavMonList *monInfo = &mons->unk4[mons->unk2]; - - if (monInfo->boxId == TOTAL_BOXES_COUNT) - ribbons = GetMonData(&gPlayerParty[monInfo->monId], MON_DATA_RIBBONS); - else - ribbons = GetBoxMonDataAt(monInfo->boxId, monInfo->monId, MON_DATA_RIBBONS); - - structPtr->field_10 = 0; - structPtr->field_12 = 0; - for (i = 0; i < ARRAY_COUNT(gUnknown_086237F8); i++) - { - s32 r4 = ((1 << gUnknown_086237F8[i].unk0) - 1) & ribbons; - if (gUnknown_086237F8[i].unk3 == 0) - { - for (j = 0; j < r4; j++) - structPtr->field_14[structPtr->field_10++] = gUnknown_086237F8[i].unk2 + j; - } - else - { - for (j = 0; j < r4; j++) - structPtr->field_78[structPtr->field_12++] = gUnknown_086237F8[i].unk2 + j; - } - ribbons >>= gUnknown_086237F8[i].unk0; - } - - if (structPtr->field_10 != 0) - { - structPtr->field_E = ((structPtr->field_10 - 1) / 9) * 9; - structPtr->field_C = 0; - } - else - { - structPtr->field_E = 0; - structPtr->field_C = 27; - } -} - -u32 *sub_81D0914(u32 *arg0) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - *arg0 = structPtr->field_10; - return structPtr->field_14; -} - -u32 *sub_81D092C(u32 *arg0) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - *arg0 = structPtr->field_12; - return structPtr->field_78; -} - -u16 sub_81D0944(void) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - return structPtr->field_C; -} - -u32 sub_81D0954(void) -{ - struct PokenavSub13 *structPtr = GetSubstructPtr(13); - int var = structPtr->field_C; - if (var <= 24) - return structPtr->field_14[var]; - else - return structPtr->field_78[var - 27]; -} - -bool32 sub_81D0978(void) -{ - struct PokenavSub14 *structPtr = AllocSubstruct(14, sizeof(struct PokenavSub14)); - if (structPtr == NULL) - return FALSE; - - structPtr->loopedTaskId = CreateLoopedTask(sub_81D0A6C, 1); - structPtr->field_0 = sub_81D0A58; - return TRUE; -} - -void sub_81D09B0(s32 id) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - structPtr->loopedTaskId = CreateLoopedTask(gUnknown_08624BA0[id], 1); - structPtr->field_0 = sub_81D0A58; -} - -u32 sub_81D09E0(void) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - return structPtr->field_0(); -} - -void sub_81D09F4(void) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - RemoveWindow(structPtr->field_A); - RemoveWindow(structPtr->field_8); - RemoveWindow(structPtr->field_C); - RemoveWindow(structPtr->field_E); - sub_81D1178(structPtr); - FreeSpriteTilesByTag(9); - FreeSpritePaletteByTag(0xF); - FreeSpritePaletteByTag(0x10); - FreeSpritePaletteByTag(0x11); - FreeSpritePaletteByTag(0x12); - FreeSpritePaletteByTag(0x13); - FreeSpriteOamMatrix(structPtr->field_14); - DestroySprite(structPtr->field_14); - FreePokenavSubstruct(14); -} - -bool32 sub_81D0A58(void) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - return IsLoopedTaskActive(structPtr->loopedTaskId); -} - -u32 sub_81D0A6C(s32 state) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - switch (state) - { - case 0: - InitBgTemplates(gUnknown_08624B98, ARRAY_COUNT(gUnknown_08624B98)); - decompress_and_copy_tile_data_to_vram(2, gUnknown_08DDE030, 0, 0, 0); - SetBgTilemapBuffer(2, structPtr->tilemapBuffers[0]); - CopyToBgTilemapBuffer(2, gUnknown_08DDE12C, 0, 0); - CopyPaletteIntoBufferUnfaded(gUnknown_08DDE010, 0x10, 0x20); - CopyBgTilemapBufferToVram(2); - return LT_INC_AND_PAUSE; - case 1: - if (!free_temp_tile_data_buffers_if_possible()) - { - sub_8199DF0(1, 0, 0, 1); - decompress_and_copy_tile_data_to_vram(1, sRibbonIconsSmall_Gfx, 0, 1, 0); - SetBgTilemapBuffer(1, structPtr->tilemapBuffers[1]); - FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 32, 20); - CopyPaletteIntoBufferUnfaded(gUnknown_08623FF8, 0x20, 0xA0); - CopyPaletteIntoBufferUnfaded(gUnknown_08624098, 0xA0, 0x20); - CopyBgTilemapBufferToVram(1); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 2: - if (!free_temp_tile_data_buffers_if_possible()) - { - sub_81D0E60(structPtr); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 3: - if (!free_temp_tile_data_buffers_if_possible()) - { - sub_81D0FCC(structPtr); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 4: - if (!free_temp_tile_data_buffers_if_possible()) - { - sub_81D10A4(structPtr); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 5: - if (!IsDma3ManagerBusyWithBgCopy()) - { - CopyBgTilemapBufferToVram(2); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 6: - if (!IsDma3ManagerBusyWithBgCopy()) - { - sub_81D1148(structPtr); - return LT_INC_AND_CONTINUE; - } - return LT_PAUSE; - case 7: - sub_81D12D8(structPtr); - PrintHelpBarText(HELPBAR_RIBBONS_LIST); - return LT_INC_AND_PAUSE; - case 8: - if (!IsDma3ManagerBusyWithBgCopy()) - { - sub_81D13FC(structPtr); - ChangeBgX(1, 0, 0); - ChangeBgY(1, 0, 0); - ChangeBgX(2, 0, 0); - ChangeBgY(2, 0, 0); - ShowBg(1); - ShowBg(2); - HideBg(3); - sub_81C7AC0(1); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 9: - if (IsPaletteFadeActive()) - return LT_PAUSE; - return LT_FINISH; - } - return LT_FINISH; -} - -u32 sub_81D0C54(s32 state) -{ - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81C7AC0(0); - return LT_INC_AND_PAUSE; - case 1: - if (IsPaletteFadeActive()) - return LT_PAUSE; - return LT_FINISH; - } - return LT_FINISH; -} - -u32 sub_81D0C84(s32 state) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81D11D8(structPtr); - return LT_INC_AND_PAUSE; - case 1: - if (!sub_81D1234(structPtr)) - { - sub_81D0FF0(structPtr); - return LT_INC_AND_CONTINUE; - } - return LT_PAUSE; - case 2: - sub_81D12D8(structPtr); - return LT_INC_AND_CONTINUE; - case 3: - sub_81D10D0(structPtr); - return LT_INC_AND_CONTINUE; - case 4: - sub_81D0E84(structPtr); - return LT_INC_AND_CONTINUE; - case 5: - if (!IsDma3ManagerBusyWithBgCopy()) - { - sub_81D11FC(structPtr); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 6: - if (sub_81D1234(structPtr)) - return LT_PAUSE; - return LT_FINISH; - } - return LT_FINISH; -} - -u32 sub_81D0D2C(s32 state) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81D1448(structPtr); - return LT_INC_AND_PAUSE; - case 1: - if (!sub_81D1524(structPtr)) - { - sub_81D0EFC(structPtr); - PrintHelpBarText(HELPBAR_RIBBONS_CHECK); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 2: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - } - return LT_FINISH; -} - -u32 sub_81D0D8C(s32 state) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81D1500(structPtr); - return LT_INC_AND_PAUSE; - case 1: - if (!sub_81D1524(structPtr)) - { - sub_81D1448(structPtr); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 2: - if (!sub_81D1524(structPtr)) - { - sub_81D0EFC(structPtr); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - } - return LT_FINISH; -} - -u32 sub_81D0E00(s32 state) -{ - struct PokenavSub14 *structPtr = GetSubstructPtr(14); - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81D1500(structPtr); - return LT_INC_AND_PAUSE; - case 1: - if (!sub_81D1524(structPtr)) - { - sub_81D0E84(structPtr); - PrintHelpBarText(HELPBAR_RIBBONS_LIST); - return LT_INC_AND_PAUSE; - } - return LT_PAUSE; - case 2: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - } - return LT_FINISH; -} - -static const struct WindowTemplate gUnknown_08624BB8 = -{ - .bg = 2, - .tilemapLeft = 12, - .tilemapTop = 13, - .width = 16, - .height = 4, - .paletteNum = 1, - .baseBlock = 0x14, -}; - -void sub_81D0E60(struct PokenavSub14 *structPtr) -{ - structPtr->field_A = AddWindow(&gUnknown_08624BB8); - PutWindowTilemap(structPtr->field_A); - sub_81D0E84(structPtr); -} - -void sub_81D0E84(struct PokenavSub14 *structPtr) -{ - u8 color[] = {TEXT_COLOR_RED, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY}; - - ConvertIntToDecimalStringN(gStringVar1, GetCurrMonRibbonCount(), STR_CONV_MODE_LEFT_ALIGN, 2); - DynamicPlaceholderTextUtil_Reset(); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1); - DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gText_RibbonsF700); - FillWindowPixelBuffer(structPtr->field_A, PIXEL_FILL(4)); - AddTextPrinterParameterized3(structPtr->field_A, 1, 0, 1, color, -1, gStringVar4); - CopyWindowToVram(structPtr->field_A, 2); -} - -void sub_81D0EFC(struct PokenavSub14 *structPtr) -{ - s32 i; - u32 ribbonId = sub_81D0954(); - u8 color[] = {TEXT_COLOR_RED, TEXT_COLOR_DARK_GREY, TEXT_COLOR_LIGHT_GREY}; - - FillWindowPixelBuffer(structPtr->field_A, PIXEL_FILL(4)); - if (ribbonId < 25) - { - for (i = 0; i < 2; i++) - AddTextPrinterParameterized3(structPtr->field_A, 1, 0, (i * 16) + 1, color, -1, gRibbonDescriptionPointers[ribbonId][i]); - } - else - { - ribbonId = gSaveBlock1Ptr->giftRibbons[ribbonId - 25]; - if (ribbonId == 0) - return; - - ribbonId--; - for (i = 0; i < 2; i++) - AddTextPrinterParameterized3(structPtr->field_A, 1, 0, (i * 16) + 1, color, -1, gGiftRibbonDescriptionPointers[ribbonId][i]); - } - - CopyWindowToVram(structPtr->field_A, 2); -} - -static const struct WindowTemplate gUnknown_08624BC4 = -{ - .bg = 2, - .tilemapLeft = 14, - .tilemapTop = 1, - .width = 13, - .height = 2, - .paletteNum = 10, - .baseBlock = 0x54, -}; - -void sub_81D0FCC(struct PokenavSub14 *structPtr) -{ - structPtr->field_8 = AddWindow(&gUnknown_08624BC4); - PutWindowTilemap(structPtr->field_8); - sub_81D0FF0(structPtr); -} - -static const u8 sMaleIconString[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_RED}{WHITE}{GREEN}♂{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); -static const u8 sFemaleIconString[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_GREEN}{WHITE}{BLUE}♀{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); -static const u8 sGenderlessIconString[] = _("{UNK_SPACER}"); - -void sub_81D0FF0(struct PokenavSub14 *structPtr) -{ - const u8 *genderTxt; - u8 *txtPtr; - u8 level, gender; - u16 windowId = structPtr->field_8; - - FillWindowPixelBuffer(windowId, PIXEL_FILL(1)); - GetCurrMonInfo1(gStringVar3, &level, &gender); - AddTextPrinterParameterized(windowId, 1, gStringVar3, 0, 1, TEXT_SPEED_FF, NULL); - switch (gender) - { - case MON_MALE: - genderTxt = sMaleIconString; - break; - case MON_FEMALE: - genderTxt = sFemaleIconString; - break; - default: - genderTxt = sGenderlessIconString; - break; - } - - txtPtr = StringCopy(gStringVar1, genderTxt); - *(txtPtr++) = CHAR_SLASH; - *(txtPtr++) = CHAR_SPECIAL_F9; - *(txtPtr++) = CHAR_LV_2; - ConvertIntToDecimalStringN(txtPtr, level, STR_CONV_MODE_LEFT_ALIGN, 3); - AddTextPrinterParameterized(windowId, 1, gStringVar1, 60, 1, TEXT_SPEED_FF, NULL); - CopyWindowToVram(windowId, 2); -} - -static const struct WindowTemplate gUnknown_08624BE8[] = -{ - { - .bg = 2, - .tilemapLeft = 1, - .tilemapTop = 5, - .width = 7, - .height = 2, - .paletteNum = 1, - .baseBlock = 0x6E, - }, - {}, -}; - -void sub_81D10A4(struct PokenavSub14 *structPtr) -{ - structPtr->field_C = AddWindow(gUnknown_08624BE8); - FillWindowPixelBuffer(structPtr->field_C, PIXEL_FILL(1)); - PutWindowTilemap(structPtr->field_C); - sub_81D10D0(structPtr); -} - -void sub_81D10D0(struct PokenavSub14 *structPtr) -{ - s32 x; - u8 *txtPtr; - u32 id = sub_81D06C4() + 1; - u32 count = sub_81D06D4(); - - txtPtr = ConvertIntToDecimalStringN(gStringVar1, id, STR_CONV_MODE_RIGHT_ALIGN, 3); - *(txtPtr++) = CHAR_SLASH; - ConvertIntToDecimalStringN(txtPtr, count, STR_CONV_MODE_RIGHT_ALIGN, 3); - x = GetStringCenterAlignXOffset(1, gStringVar1, 56); - AddTextPrinterParameterized(structPtr->field_C, 1, gStringVar1, x, 1, TEXT_SPEED_FF, NULL); - CopyWindowToVram(structPtr->field_C, 2); -} - -void sub_81D1148(struct PokenavSub14 *structPtr) -{ - u16 species; - u32 personality, otId; - - GetCurrMonInfo2(&species, &personality, &otId); - ResetAllPicSprites(); - structPtr->field_10 = sub_81D1184(40, 104); - sub_81C7990(15, 0); -} - -void sub_81D1178(struct PokenavSub14 *structPtr) -{ - FreeAndDestroyMonPicSprite(structPtr->field_10); -} - -u16 sub_81D1184(s32 unused0, s32 unused1) -{ - u16 species, spriteId; - u32 personality, otId; - - GetCurrMonInfo2(&species, &personality, &otId); - spriteId = CreateMonPicSprite_HandleDeoxys(species, otId, personality, TRUE, 40, 104, 15, 0xFFFF); - gSprites[spriteId].oam.priority = 0; - return spriteId; -} - -void sub_81D11D8(struct PokenavSub14 *structPtr) -{ - sub_81D1258(&gSprites[structPtr->field_10], 40, -32, 6); -} - -void sub_81D11FC(struct PokenavSub14 *structPtr) -{ - FreeAndDestroyMonPicSprite(structPtr->field_10); - structPtr->field_10 = sub_81D1184(-32, 104); - sub_81D1258(&gSprites[structPtr->field_10], -32, 40, 6); -} - -bool32 sub_81D1234(struct PokenavSub14 *structPtr) -{ - return (gSprites[structPtr->field_10].callback != SpriteCallbackDummy); -} - -void sub_81D1258(struct Sprite *sprite, s32 arg1, s32 arg2, s32 arg3) -{ - u32 var = arg2 - arg1; - - sprite->pos1.x = arg1; - sprite->data[0] = arg1 << 4; - sprite->data[1] = (var << 4) / arg3; - sprite->data[2] = arg3; - sprite->data[3] = arg2; - - sprite->callback = sub_81D1284; -} - -void sub_81D1284(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 <= -32) - sprite->invisible = TRUE; - else - sprite->invisible = FALSE; - } - else - { - sprite->pos1.x = sprite->data[3]; - sprite->callback = SpriteCallbackDummy; - } -} - -void sub_81D12D8(struct PokenavSub14 *structPtr) -{ - u32 *ptr; - - sub_81D1350(); - - ptr = sub_81D0914(&gUnknown_030012C0); - for (gUnknown_030012C4 = 0; gUnknown_030012C4 < gUnknown_030012C0; gUnknown_030012C4++) - sub_81D1370(gUnknown_030012C4, *(ptr++)); - - ptr = sub_81D092C(&gUnknown_030012C0); - for (gUnknown_030012C4 = 0; gUnknown_030012C4 < gUnknown_030012C0; gUnknown_030012C4++) - sub_81D1370(gUnknown_030012C4 + 27, *(ptr++)); - - CopyBgTilemapBufferToVram(1); -} - -void sub_81D1350(void) -{ - FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 32, 20); -} - -void sub_81D1370(u32 arg0, u32 id) -{ - u16 bgData[4]; - u32 destX = (arg0 % 9) * 2 + 11; - u32 destY = (arg0 / 9) * 2 + 4; - - sub_81D13BC(bgData, id); - CopyToBgTilemapBufferRect(1, bgData, destX, destY, 2, 2); -} - -struct -{ - u16 var0; - u16 var2; -} static const gUnknown_08624BF8[] = -{ - {0, 0}, - {1, 0}, - {2, 0}, - {3, 0}, - {4, 0}, - {1, 1}, - {2, 1}, - {3, 1}, - {4, 1}, - {1, 2}, - {2, 2}, - {3, 2}, - {4, 2}, - {1, 3}, - {2, 3}, - {3, 3}, - {4, 3}, - {1, 4}, - {2, 4}, - {3, 4}, - {4, 4}, - {5, 0}, - {6, 0}, - {7, 1}, - {8, 2}, - {9, 1}, - {9, 3}, - {9, 4}, - {10, 3}, - {10, 4}, - {11, 0}, - {11, 1}, -}; - -void sub_81D13BC(u16 *dst, u32 id) -{ - u16 r3 = gUnknown_08624BF8[id].var2 + 2; - u16 r1 = (gUnknown_08624BF8[id].var0 * 2) + 1; - - dst[0] = r1 | (r3 << 12); - dst[1] = r1 | (r3 << 12) |0x400; - dst[2] = (r1 + 1) | (r3 << 12); - dst[3] = (r1 + 1) | (r3 << 12) | 0x400; -} - -static const struct CompressedSpriteSheet gUnknown_08624C78 = -{ - sRibbonIconsBig_Gfx, 0x1800, 9 -}; - -static const struct SpritePalette gUnknown_08624C80[] = -{ - {gUnknown_08623FF8, 15}, - {gUnknown_08624018, 16}, - {gUnknown_08624038, 17}, - {gUnknown_08624058, 18}, - {gUnknown_08624078, 19}, - {}, -}; - -static const struct OamData sOamData_8624CB0 = -{ - .y = 0, - .affineMode = ST_OAM_AFFINE_NORMAL, - .objMode = ST_OAM_OBJ_NORMAL, - .mosaic = 0, - .bpp = ST_OAM_4BPP, - .shape = SPRITE_SHAPE(32x32), - .x = 0, - .matrixNum = 0, - .size = SPRITE_SIZE(32x32), - .tileNum = 0, - .priority = 1, - .paletteNum = 0, - .affineParam = 0 -}; - -static const union AffineAnimCmd sSpriteAffineAnim_8624CB8[] = -{ - AFFINEANIMCMD_FRAME(128, 128, 0, 0), - AFFINEANIMCMD_END -}; - -static const union AffineAnimCmd sSpriteAffineAnim_8624CC8[] = -{ - AFFINEANIMCMD_FRAME(128, 128, 0, 0), - AFFINEANIMCMD_FRAME(32, 32, 0, 4), - AFFINEANIMCMD_END -}; - -static const union AffineAnimCmd sSpriteAffineAnim_8624CE0[] = -{ - AFFINEANIMCMD_FRAME(256, 256, 0, 0), - AFFINEANIMCMD_FRAME(-32, -32, 0, 4), - AFFINEANIMCMD_END -}; - -static const union AffineAnimCmd *const sSpriteAffineAnimTable_8624CF8[] = -{ - sSpriteAffineAnim_8624CB8, - sSpriteAffineAnim_8624CC8, - sSpriteAffineAnim_8624CE0 -}; - -static const struct SpriteTemplate gUnknown_08624D04 = -{ - .tileTag = 9, - .paletteTag = 15, - .oam = &sOamData_8624CB0, - .anims = gDummySpriteAnimTable, - .images = NULL, - .affineAnims = sSpriteAffineAnimTable_8624CF8, - .callback = SpriteCallbackDummy, -}; - -void sub_81D13FC(struct PokenavSub14 *structPtr) -{ - u8 spriteId; - - LoadCompressedSpriteSheet(&gUnknown_08624C78); - Pokenav_AllocAndLoadPalettes(gUnknown_08624C80); - - spriteId = CreateSprite(&gUnknown_08624D04, 0, 0, 0); - structPtr->field_14 = &gSprites[spriteId]; - structPtr->field_14->invisible = TRUE; -} - -void sub_81D1448(struct PokenavSub14 *structPtr) -{ - u32 ribbonId; - s32 r4 = sub_81D0944(); - s32 r5 = (r4 % 9) * 16 + 96; - s32 r0 = (r4 / 9) * 16 + 40; - - structPtr->field_14->pos1.x = r5; - structPtr->field_14->pos1.y = r0; - - ribbonId = sub_81D0954(); - structPtr->field_14->oam.tileNum = (gUnknown_08624BF8[ribbonId].var0 * 16) + GetSpriteTileStartByTag(9); - structPtr->field_14->oam.paletteNum = IndexOfSpritePaletteTag(gUnknown_08624BF8[ribbonId].var2 + 15); - - StartSpriteAffineAnim(structPtr->field_14, 1); - structPtr->field_14->invisible = FALSE; - structPtr->field_14->data[0] = 0; - structPtr->field_14->callback = sub_81D1538; -} - -void sub_81D1500(struct PokenavSub14 *structPtr) -{ - structPtr->field_14->data[0] = 1; - StartSpriteAffineAnim(structPtr->field_14, 2); - structPtr->field_14->callback = sub_81D1538; -} - -bool32 sub_81D1524(struct PokenavSub14 *structPtr) -{ - return (structPtr->field_14->callback != SpriteCallbackDummy); -} - -void sub_81D1538(struct Sprite *sprite) -{ - if (sprite->affineAnimEnded) - { - sprite->invisible = sprite->data[0]; - sprite->callback = SpriteCallbackDummy; - } -} diff --git a/src/pokenav_unk_2.c b/src/pokenav_unk_2.c deleted file mode 100644 index 94b816b6d..000000000 --- a/src/pokenav_unk_2.c +++ /dev/null @@ -1,1284 +0,0 @@ -#include "global.h" -#include "malloc.h" -#include "decompress.h" -#include "bg.h" -#include "palette.h" -#include "trig.h" -#include "gpu_regs.h" -#include "menu.h" -#include "window.h" -#include "pokenav.h" -#include "graphics.h" -#include "sound.h" -#include "gym_leader_rematch.h" -#include "window.h" -#include "strings.h" -#include "scanline_effect.h" -#include "constants/songs.h" -#include "constants/rgb.h" - -// Top Menu - -struct Pokenav2Struct -{ - bool32 (*callback)(void); - u32 loopedTaskId; - u16 optionDescWindowId; - u8 bg3ScrollTaskId; - u8 cursorPos; - bool8 otherIconsInMotion; - u8 field_00d; - bool32 iconVisible[MAX_POKENAV_MENUITEMS]; - struct Sprite * field_028; - struct Sprite * iconSprites[MAX_POKENAV_MENUITEMS][4]; - u16 bg1TilemapBuffer[0x400]; -}; - -static struct Pokenav2Struct * sub_81C9958(void); -static bool32 sub_81C99FC(void); -static u32 sub_81C9A10(s32 state); -static u32 LoopedTask_MoveMenuCursor(s32 state); -static u32 LoopedTask_OpenConditionMenu(s32 state); -static u32 LoopedTask_ReturnToMainMenu(s32 state); -static u32 LoopedTask_OpenConditionSearchMenu(s32 state); -static u32 LoopedTask_ReturnToConditionMenu(s32 state); -static u32 LoopedTask_SelectRibbonsNoWinners(s32 state); -static u32 LoopedTask_ReShowDescription(s32 state); -static u32 LoopedTask_OpenPokenavFeature(s32 state); -static void sub_81C9FC4(void); -static void sub_81C9FEC(void); -static void CreateMenuOptionSprites(void); -static void sub_81CA094(void); -static void sub_81CA0C8(void); -static void sub_81CA0EC(const u16 *const * a0, s32 a1, s32 a2); -static void sub_81CA20C(void); -static void sub_81CA278(void); -static void sub_81CA35C(struct Sprite ** sprites, s32 a1, s32 a2, s32 a3); -static void sub_81CA3B4(struct Sprite ** sprites); -static void sub_81CA2DC(void); -static bool32 AreMenuOptionSpritesMoving(void); -static void sub_81CA448(struct Sprite ** sprites, bool32 a1); -static void sub_81CA474(struct Sprite * sprite); -static void sub_81CA4AC(struct Sprite * sprite); -static void sub_81CA580(u8 taskId); -static void sub_81CA640(void); -static void sub_81CA6AC(struct Sprite * sprite); -static void sub_81CA698(void); -static void AddOptionDescriptionWindow(void); -static void PrintCurrentOptionDescription(void); -static void PrintNoRibbonWinners(void); -static bool32 sub_81CA7C4(void); -static void sub_81CA7D4(void); -static void sub_81CA7F4(void); -static void sub_81CA808(u8 taskId); -static void sub_81CA818(void); -static void sub_81CA850(void); -static void sub_81CA864(void); -static bool32 sub_81CA89C(void); -static void sub_81CA8B0(u8 taskId); -static void sub_81CA92C(void); -static void sub_81CA994(void); -static void sub_81CA9C8(void); -static void sub_81CA9D8(void); -static void sub_81CA9EC(u8 taskId); -static void sub_81CAA3C(void); - -static const u16 gUnknown_0861FC78[] = INCBIN_U16("graphics/pokenav/bg.gbapal"); -static const u32 gUnknown_0861FC98[] = INCBIN_U32("graphics/pokenav/bg.4bpp.lz"); -static const u32 gUnknown_0861FCAC[] = INCBIN_U32("graphics/pokenav/bg.bin.lz"); -static const u16 gUnknown_0861FD4C[] = INCBIN_U16("graphics/pokenav/outline.gbapal"); -static const u32 gUnknown_0861FD6C[] = INCBIN_U32("graphics/pokenav/outline.4bpp.lz"); -static const u32 gUnknown_0861FFF4[] = INCBIN_U32("graphics/pokenav/outline_map.bin.lz"); -static const u16 gUnknown_08620104[] = INCBIN_U16("graphics/pokenav/blue_light.gbapal"); -static const u32 gUnknown_08620124[] = INCBIN_U32("graphics/pokenav/blue_light.4bpp.lz"); - -static const struct BgTemplate gUnknown_08620194[] = { - { - .bg = 1, - .charBaseIndex = 1, - .mapBaseIndex = 15, - .screenSize = 0, - .paletteMode = 0, - .priority = 1, - .baseTile = 0x000 - }, { - .bg = 2, - .charBaseIndex = 2, - .mapBaseIndex = 23, - .screenSize = 0, - .paletteMode = 0, - .priority = 2, - .baseTile = 0x000 - }, { - .bg = 3, - .charBaseIndex = 3, - .mapBaseIndex = 31, - .screenSize = 0, - .paletteMode = 0, - .priority = 3, - .baseTile = 0x000 - } -}; - -static const LoopedTask sMenuHandlerLoopTaskFuncs[] = { - [POKENAV_MENU_FUNC_NONE] = NULL, - [POKENAV_MENU_FUNC_MOVE_CURSOR] = LoopedTask_MoveMenuCursor, - [POKENAV_MENU_FUNC_OPEN_CONDITION] = LoopedTask_OpenConditionMenu, - [POKENAV_MENU_FUNC_RETURN_TO_MAIN] = LoopedTask_ReturnToMainMenu, - [POKENAV_MENU_FUNC_OPEN_CONDITION_SEARCH] = LoopedTask_OpenConditionSearchMenu, - [POKENAV_MENU_FUNC_RETURN_TO_CONDITION] = LoopedTask_ReturnToConditionMenu, - [POKENAV_MENU_FUNC_NO_RIBBON_WINNERS] = LoopedTask_SelectRibbonsNoWinners, - [POKENAV_MENU_FUNC_RESHOW_DESCRIPTION] = LoopedTask_ReShowDescription, - [POKENAV_MENU_FUNC_OPEN_FEATURE] = LoopedTask_OpenPokenavFeature -}; - -static const struct CompressedSpriteSheet gUnknown_086201C4[] = -{ - { - .data = gPokenavOptions_Gfx, - .size = 0x3400, - .tag = 0x0003 - }, - { - .data = gUnknown_08620124, - .size = 0x0100, - .tag = 0x0001 - } -}; - -static const struct SpritePalette gUnknown_086201D4[] = -{ - {gPokenavOptions_Pal + 0x00, 4}, - {gPokenavOptions_Pal + 0x10, 5}, - {gPokenavOptions_Pal + 0x20, 6}, - {gPokenavOptions_Pal + 0x30, 7}, - {gPokenavOptions_Pal + 0x40, 8}, - {gUnknown_08620104, 3}, - {} -}; - -static const u16 gUnknown_0862020C[] = {0, 0}; -static const u16 gUnknown_08620210[] = {0x20, 1}; -static const u16 gUnknown_08620214[] = {0x40, 4}; -static const u16 gUnknown_08620218[] = {0x60, 2}; -static const u16 gUnknown_0862021C[] = {0x80, 3}; -static const u16 gUnknown_08620220[] = {0xA0, 1}; -static const u16 gUnknown_08620224[] = {0xC0, 1}; -static const u16 gUnknown_08620228[] = {0xE0, 4}; -static const u16 gUnknown_0862022C[] = {0x100, 1}; -static const u16 gUnknown_08620230[] = {0x120, 2}; -static const u16 gUnknown_08620234[] = {0x140, 0}; -static const u16 gUnknown_08620238[] = {0x160, 0}; -static const u16 gUnknown_0862023C[] = {0x180, 3}; - -struct UnkStruct_08620240 -{ - u16 unk0; - u16 unk2; - const u16 *unk4[MAX_POKENAV_MENUITEMS]; -}; - -// TODO -static const struct UnkStruct_08620240 gUnknown_08620240[POKENAV_MENU_TYPE_COUNT] = -{ - [POKENAV_MENU_TYPE_DEFAULT] = - { - 0x2A, - 0x14, - {gUnknown_0862020C, gUnknown_08620210, gUnknown_0862021C} - }, - [POKENAV_MENU_TYPE_UNLOCK_MC] = - { - 0x2A, - 0x14, - {gUnknown_0862020C, gUnknown_08620210, gUnknown_08620214, gUnknown_0862021C} - }, - [POKENAV_MENU_TYPE_UNLOCK_MC_RIBBONS] = - { - 0x2A, - 0x14, - {gUnknown_0862020C, gUnknown_08620210, gUnknown_08620214, gUnknown_08620218, gUnknown_0862021C} - }, - [POKENAV_MENU_TYPE_CONDITION] = - { - 0x38, - 0x14, - {gUnknown_08620220, gUnknown_08620224, gUnknown_0862023C} - }, - [POKENAV_MENU_TYPE_CONDITION_SEARCH] = - { - 0x28, - 0x10, - {gUnknown_08620228, gUnknown_0862022C, gUnknown_08620230, gUnknown_08620234, gUnknown_08620238, gUnknown_0862023C} - }, -}; - -static const struct WindowTemplate sOptionDescWindowTemplate = -{ - .bg = 1, - .tilemapLeft = 3, - .tilemapTop = 17, - .width = 0x18, - .height = 0x2, - .paletteNum = 1, - .baseBlock = 8 -}; - -static const u8 *const sPageDescriptions[] = -{ - [POKENAV_MENUITEM_MAP] = gText_CheckMapOfHoenn, - [POKENAV_MENUITEM_CONDITION] = gText_CheckPokemonInDetail, - [POKENAV_MENUITEM_MATCH_CALL] = gText_CallRegisteredTrainer, - [POKENAV_MENUITEM_RIBBONS] = gText_CheckObtainedRibbons, - [POKENAV_MENUITEM_SWITCH_OFF] = gText_PutAwayPokenav, - [POKENAV_MENUITEM_CONDITION_PARTY] = gText_CheckPartyPokemonInDetail, - [POKENAV_MENUITEM_CONDITION_SEARCH] = gText_CheckAllPokemonInDetail, - [POKENAV_MENUITEM_CONDITION_CANCEL] = gText_ReturnToPokenavMenu, - [POKENAV_MENUITEM_CONDITION_SEARCH_COOL] = gText_FindCoolPokemon, - [POKENAV_MENUITEM_CONDITION_SEARCH_BEAUTY] = gText_FindBeautifulPokemon, - [POKENAV_MENUITEM_CONDITION_SEARCH_CUTE] = gText_FindCutePokemon, - [POKENAV_MENUITEM_CONDITION_SEARCH_SMART] = gText_FindSmartPokemon, - [POKENAV_MENUITEM_CONDITION_SEARCH_TOUGH] = gText_FindToughPokemon, - [POKENAV_MENUITEM_CONDITION_SEARCH_CANCEL] = gText_ReturnToConditionMenu -}; - -static const u8 sOptionDescTextColors[] = {TEXT_COLOR_GREEN, TEXT_COLOR_BLUE, TEXT_COLOR_LIGHT_GREEN}; -static const u8 sOptionDescTextColors2[] = {TEXT_COLOR_GREEN, TEXT_COLOR_BLUE, TEXT_COLOR_LIGHT_GREEN}; - -static const struct OamData sOamData_MenuOption = -{ - .y = 0, - .affineMode = ST_OAM_AFFINE_OFF, - .objMode = ST_OAM_OBJ_NORMAL, - .bpp = ST_OAM_4BPP, - .shape = SPRITE_SHAPE(32x16), - .x = 0, - .size = SPRITE_SIZE(32x16), - .tileNum = 0, - .priority = 2, - .paletteNum = 0, -}; - -static const union AffineAnimCmd gUnknown_0862031C[] = -{ - AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), - AFFINEANIMCMD_END, -}; - -static const union AffineAnimCmd gUnknown_0862032C[] = -{ - AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x10, 0x10, 0, 0x12), - AFFINEANIMCMD_END, -}; - -static const union AffineAnimCmd *const sSpriteAnims_MenuOption[] = -{ - gUnknown_0862031C, - gUnknown_0862032C -}; - -static const struct SpriteTemplate sMenuOptionSpriteTemplate = -{ - .tileTag = 3, - .paletteTag = 4, - .oam = &sOamData_MenuOption, - .anims = gDummySpriteAnimTable, - .images = NULL, - .affineAnims = sSpriteAnims_MenuOption, - .callback = SpriteCallbackDummy, -}; - -static const struct OamData gUnknown_08620364 = -{ - .y = 0, - .affineMode = ST_OAM_AFFINE_OFF, - .objMode = ST_OAM_OBJ_NORMAL, - .bpp = ST_OAM_4BPP, - .shape = SPRITE_SHAPE(32x16), - .x = 0, - .size = SPRITE_SIZE(32x16), - .tileNum = 0, - .priority = 2, - .paletteNum = 0, -}; - -static const struct SpriteTemplate gUnknown_0862036C = -{ - .tileTag = 1, - .paletteTag = 3, - .oam = &gUnknown_08620364, - .anims = gDummySpriteAnimTable, - .images = NULL, - .affineAnims = gDummySpriteAffineAnimTable, - .callback = SpriteCallbackDummy, -}; - -static const struct ScanlineEffectParams gUnknown_08620384 = -{ - (void *)REG_ADDR_WIN0H, - ((DMA_ENABLE | DMA_START_HBLANK | DMA_REPEAT | DMA_DEST_RELOAD) << 16) | 1, - 1, - 0 -}; - -static bool32 sub_81C98D4(void) -{ - s32 i; - - for (i = 0; i < REMATCH_TABLE_ENTRIES; i++) - { - if (sub_81CB0C8(i) == gMapHeader.regionMapSectionId - && IsRematchEntryRegistered(i) - && gSaveBlock1Ptr->trainerRematches[i]) - return TRUE; - } - - return FALSE; -} - -bool32 sub_81C9924(void) -{ - struct Pokenav2Struct * unk = sub_81C9958(); - - if (unk == NULL) - return FALSE; - - unk->field_00d = 0; - return TRUE; -} - -bool32 sub_81C9940(void) -{ - struct Pokenav2Struct * unk = sub_81C9958(); - - if (unk == NULL) - return FALSE; - - unk->field_00d = 1; - return TRUE; -} - -static struct Pokenav2Struct * sub_81C9958(void) -{ - struct Pokenav2Struct * unk = AllocSubstruct(2, sizeof(struct Pokenav2Struct)); - - if (unk != NULL) - { - unk->otherIconsInMotion = FALSE; - unk->loopedTaskId = CreateLoopedTask(sub_81C9A10, 1); - unk->callback = sub_81C99FC; - } - - return unk; -} - - -void CreateMenuHandlerLoopedTask(s32 ltIdx) -{ - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - unk->loopedTaskId = CreateLoopedTask(sMenuHandlerLoopTaskFuncs[ltIdx], 1); - unk->callback = sub_81C99FC; -} - -bool32 sub_81C99C0(void) -{ - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - return unk->callback(); -} - -void sub_81C99D4(void) -{ - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - sub_81CA7F4(); - RemoveWindow(unk->optionDescWindowId); - sub_81C9FEC(); - sub_81CA994(); - FreePokenavSubstruct(2); -} - -static bool32 sub_81C99FC(void) -{ - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - return IsLoopedTaskActive(unk->loopedTaskId); -} - -static u32 sub_81C9A10(s32 state) -{ - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - switch (state) - { - case 0: - InitBgTemplates(gUnknown_08620194, ARRAY_COUNT(gUnknown_08620194)); - decompress_and_copy_tile_data_to_vram(1, gPokenavMessageBox_Gfx, 0, 0, 0); - SetBgTilemapBuffer(1, unk->bg1TilemapBuffer); - CopyToBgTilemapBuffer(1, gPokenavMessageBox_Tilemap, 0, 0); - CopyBgTilemapBufferToVram(1); - CopyPaletteIntoBufferUnfaded(gPokenavMessageBox_Pal, 0x10, 0x20); - ChangeBgX(1, 0, 0); - ChangeBgY(1, 0, 0); - ChangeBgX(2, 0, 0); - ChangeBgY(2, 0, 0); - ChangeBgX(3, 0, 0); - ChangeBgY(3, 0, 0); - return LT_INC_AND_PAUSE; - case 1: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - decompress_and_copy_tile_data_to_vram(2, gUnknown_0861FD6C, 0, 0, 0); - decompress_and_copy_tile_data_to_vram(2, gUnknown_0861FFF4, 0, 0, 1); - CopyPaletteIntoBufferUnfaded(gUnknown_0861FD4C, 0x20, 0x20); - return LT_INC_AND_PAUSE; - case 2: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - decompress_and_copy_tile_data_to_vram(3, gUnknown_0861FC98, 0, 0, 0); - decompress_and_copy_tile_data_to_vram(3, gUnknown_0861FCAC, 0, 0, 1); - CopyPaletteIntoBufferUnfaded(gUnknown_0861FC78, 0x30, 0x20); - if (GetPokenavMenuType() == POKENAV_MENU_TYPE_CONDITION || GetPokenavMenuType() == POKENAV_MENU_TYPE_CONDITION_SEARCH) - sub_81CA850(); - return LT_INC_AND_PAUSE; - case 3: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - AddOptionDescriptionWindow(); - sub_81CA7D4(); - return LT_INC_AND_CONTINUE; - case 4: - sub_81C9FC4(); - return LT_INC_AND_CONTINUE; - case 5: - PrintCurrentOptionDescription(); - CreateMenuOptionSprites(); - sub_81CA640(); - sub_81CA0C8(); - return LT_INC_AND_PAUSE; - case 6: - if (sub_81CA7C4()) - return LT_PAUSE; - return LT_INC_AND_CONTINUE; - case 7: - ShowBg(1); - ShowBg(2); - ShowBg(3); - if (unk->field_00d) - sub_81C7AC0(1); - else - { - PlaySE(SE_PN_ON); - sub_81C7AC0(3); - } - switch (GetPokenavMenuType()) - { - case POKENAV_MENU_TYPE_CONDITION_SEARCH: - LoadLeftHeaderGfxForIndex(7); - // fallthrough - case POKENAV_MENU_TYPE_CONDITION: - LoadLeftHeaderGfxForIndex(1); - break; - default: - LoadLeftHeaderGfxForIndex(0); - break; - } - return LT_INC_AND_PAUSE; - case 8: - if (IsPaletteFadeActive()) - return LT_PAUSE; - switch (GetPokenavMenuType()) - { - case POKENAV_MENU_TYPE_CONDITION_SEARCH: - sub_81C7FA0(7, FALSE, FALSE); - // fallthrough - case POKENAV_MENU_TYPE_CONDITION: - sub_81C7FA0(1, FALSE, FALSE); - break; - default: - sub_81C7FA0(0, FALSE, FALSE); - break; - } - sub_81CA20C(); - sub_81CA92C(); - return LT_INC_AND_CONTINUE; - case 9: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 LoopedTask_MoveMenuCursor(s32 state) -{ - switch (state) - { - case 0: - sub_81CAA3C(); - sub_81CA278(); - PrintCurrentOptionDescription(); - PlaySE(SE_SELECT); - return LT_INC_AND_PAUSE; - case 1: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81CA7C4()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 LoopedTask_OpenConditionMenu(s32 state) -{ - switch (state) - { - case 0: - sub_81CA9C8(); - sub_81CA2DC(); - sub_81C7FC4(0, 0); - PlaySE(SE_SELECT); - return LT_INC_AND_PAUSE; - case 1: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - sub_81CA0C8(); - LoadLeftHeaderGfxForIndex(1); - return LT_INC_AND_PAUSE; - case 2: - sub_81CA20C(); - sub_81C7FA0(1, FALSE, FALSE); - sub_81CA818(); - PrintCurrentOptionDescription(); - return LT_INC_AND_PAUSE; - case 3: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - if (sub_81CA89C()) - return LT_PAUSE; - if (sub_81CA7C4()) - return LT_PAUSE; - sub_81CA9D8(); - break; - } - return LT_FINISH; -} - -static u32 LoopedTask_ReturnToMainMenu(s32 state) -{ - switch (state) - { - case 0: - sub_81CA9C8(); - sub_81CA2DC(); - sub_81C7FC4(1, 0); - return LT_INC_AND_PAUSE; - case 1: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - sub_81CA0C8(); - LoadLeftHeaderGfxForIndex(0); - return LT_INC_AND_PAUSE; - case 2: - sub_81CA20C(); - sub_81C7FA0(0, FALSE, FALSE); - sub_81CA864(); - PrintCurrentOptionDescription(); - return LT_INC_AND_PAUSE; - case 3: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - if (sub_81CA89C()) - return LT_PAUSE; - if (sub_81CA7C4()) - return LT_PAUSE; - sub_81CA9D8(); - break; - } - return LT_FINISH; -} - -static u32 LoopedTask_OpenConditionSearchMenu(s32 state) -{ - switch (state) - { - case 0: - sub_81CA9C8(); - sub_81CA2DC(); - PlaySE(SE_SELECT); - return LT_INC_AND_PAUSE; - case 1: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - LoadLeftHeaderGfxForIndex(7); - sub_81CA0C8(); - return LT_INC_AND_PAUSE; - case 2: - sub_81CA20C(); - sub_81C7FA0(7, FALSE, FALSE); - PrintCurrentOptionDescription(); - return LT_INC_AND_PAUSE; - case 3: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - if (sub_81CA89C()) - return LT_PAUSE; - sub_81CA9D8(); - break; - } - return LT_FINISH; -} - -static u32 LoopedTask_ReturnToConditionMenu(s32 state) -{ - switch (state) - { - case 0: - sub_81CA9C8(); - sub_81CA2DC(); - sub_81C7FC4(7, 0); - return LT_INC_AND_PAUSE; - case 1: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - sub_81CA0C8(); - return LT_INC_AND_PAUSE; - case 2: - sub_81CA20C(); - PrintCurrentOptionDescription(); - return LT_INC_AND_PAUSE; - case 3: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81CA89C()) - return LT_PAUSE; - sub_81CA9D8(); - break; - } - return LT_FINISH; -} - -static u32 LoopedTask_SelectRibbonsNoWinners(s32 state) -{ - switch (state) - { - case 0: - PlaySE(SE_HAZURE); - PrintNoRibbonWinners(); - return LT_INC_AND_PAUSE; - case 1: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -// For redisplaying the Ribbons description to replace the No Ribbon Winners message -static u32 LoopedTask_ReShowDescription(s32 state) -{ - switch (state) - { - case 0: - PlaySE(SE_SELECT); - PrintCurrentOptionDescription(); - return LT_INC_AND_PAUSE; - case 1: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -// For selecting a feature option from a menu, e.g. the Map, Match Call, Beauty search, etc. -static u32 LoopedTask_OpenPokenavFeature(s32 state) -{ - switch (state) - { - case 0: - PrintHelpBarText(GetHelpBarTextId()); - return LT_INC_AND_PAUSE; - case 1: - if (WaitForHelpBar()) - return LT_PAUSE; - sub_81C7880(); - sub_81CA9C8(); - sub_81CA2DC(); - switch (GetPokenavMenuType()) - { - case POKENAV_MENU_TYPE_CONDITION_SEARCH: - sub_81C7FC4(7, FALSE); - // fallthrough - case POKENAV_MENU_TYPE_CONDITION: - sub_81C7FC4(1, FALSE); - break; - default: - sub_81C7FC4(0, FALSE); - break; - } - PlaySE(SE_SELECT); - return LT_INC_AND_PAUSE; - case 2: - if (AreMenuOptionSpritesMoving()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - sub_81C7AC0(0); - return LT_INC_AND_PAUSE; - case 3: - if (IsPaletteFadeActive()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static void sub_81C9FC4(void) -{ - s32 i; - - for (i = 0; i < NELEMS(gUnknown_086201C4); i++) - LoadCompressedSpriteSheet(&gUnknown_086201C4[i]); - Pokenav_AllocAndLoadPalettes(gUnknown_086201D4); -} - -static void sub_81C9FEC(void) -{ - FreeSpriteTilesByTag(3); - FreeSpriteTilesByTag(1); - FreeSpritePaletteByTag(4); - FreeSpritePaletteByTag(5); - FreeSpritePaletteByTag(6); - FreeSpritePaletteByTag(7); - FreeSpritePaletteByTag(8); - FreeSpritePaletteByTag(3); - sub_81CA094(); - sub_81CA698(); -} - -static void CreateMenuOptionSprites(void) -{ - s32 i, j; - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) - { - // Each menu option is 4 subsprites - for (j = 0; j < 4; j++) - { - u8 spriteId = CreateSprite(&sMenuOptionSpriteTemplate, 0x8c, 20 * i + 40, 3); - unk->iconSprites[i][j] = &gSprites[spriteId]; - gSprites[spriteId].pos2.x = 32 * j; - } - } -} - -static void sub_81CA094(void) -{ - s32 i, j; - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) - { - for (j = 0; j < 4; j++) - { - FreeSpriteOamMatrix(unk->iconSprites[i][j]); - DestroySprite(unk->iconSprites[i][j]); - } - } -} - -static void sub_81CA0C8(void) -{ - s32 menuType = GetPokenavMenuType(); - sub_81CA0EC(gUnknown_08620240[menuType].unk4, gUnknown_08620240[menuType].unk0, gUnknown_08620240[menuType].unk2); -} - -static void sub_81CA0EC(const u16 *const *a0, s32 a1, s32 a2) -{ - s32 i, j; - struct Pokenav2Struct * unk = GetSubstructPtr(2); - s32 sp04 = GetSpriteTileStartByTag(3); - - for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) - { - if (*a0 != NULL) - { - for (j = 0; j < 4; j++) - { - unk->iconSprites[i][j]->oam.tileNum = (*a0)[0] + sp04 + 8 * j; - unk->iconSprites[i][j]->oam.paletteNum = IndexOfSpritePaletteTag((*a0)[1] + 4); - unk->iconSprites[i][j]->invisible = TRUE; - unk->iconSprites[i][j]->pos1.y = a1; - unk->iconSprites[i][j]->pos1.x = 0x8c; - unk->iconSprites[i][j]->pos2.x = 32 * j; - } - unk->iconVisible[i] = TRUE; - } - else - { - for (j = 0; j < 4; j++) - { - unk->iconSprites[i][j]->invisible = TRUE; - } - unk->iconVisible[i] = FALSE; - } - a0++; - a1 += a2; - } -} - -static void sub_81CA20C(void) -{ - s32 i; - struct Pokenav2Struct * unk = GetSubstructPtr(2); - s32 r8 = GetPokenavCursorPos(); - s32 r7 = 0; - s32 r2; - - for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) - { - if (unk->iconVisible[i]) - { - if (r7++ == r8) - { - r2 = 0x82; - unk->cursorPos = i; - } - else - r2 = 0x8c; - sub_81CA35C(unk->iconSprites[i], 0x100, r2, 0xC); - sub_81CA448(unk->iconSprites[i], FALSE); - } - else - sub_81CA448(unk->iconSprites[i], TRUE); - } -} - -static void sub_81CA278(void) -{ - s32 i; - struct Pokenav2Struct * unk = GetSubstructPtr(2); - s32 r3 = GetPokenavCursorPos(); - s32 r5; - - for (i = 0, r5 = 0; i < MAX_POKENAV_MENUITEMS; i++) - { - if (unk->iconVisible[i]) - { - if (r5 == r3) - { - r5 = i; - break; - } - r5++; - } - } - - sub_81CA35C(unk->iconSprites[unk->cursorPos], 0x82, 0x8c, 0x4); - sub_81CA35C(unk->iconSprites[r5], 0x8c, 0x82, 0x4); - unk->cursorPos = r5; -} - -static void sub_81CA2DC(void) -{ - s32 i; - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) - { - if (unk->iconVisible[i]) - { - if (unk->cursorPos != i) - sub_81CA35C(unk->iconSprites[i], 0x8C, 0x100, 0x8); - else - sub_81CA3B4(unk->iconSprites[i]); - } - } -} - -static bool32 AreMenuOptionSpritesMoving(void) -{ - s32 i; - struct Pokenav2Struct * unk = GetSubstructPtr(2); - - for (i = 0; i < MAX_POKENAV_MENUITEMS; i++) - { - if (unk->iconSprites[i][0]->callback != SpriteCallbackDummy) - return TRUE; - } - - if (unk->otherIconsInMotion) - return TRUE; - - return FALSE; -} - -static void sub_81CA35C(struct Sprite ** sprites, s32 a1, s32 a2, s32 a3) -{ - s32 i; - - for (i = 0; i < 4; i++) - { - (*sprites)->pos1.x = a1; - (*sprites)->data[0] = a3; - (*sprites)->data[1] = 16 * (a2 - a1) / a3; - (*sprites)->data[2] = 16 * a1; - (*sprites)->data[7] = a2; - (*sprites)->callback = sub_81CA474; - sprites++; - } -} - -static void sub_81CA3B4(struct Sprite ** sprites) -{ - s32 i; - struct Pokenav2Struct * unk = GetSubstructPtr(2); - u8 taskId; - - for (i = 0; i < 4; i++) - { - (*sprites)->oam.objMode = ST_OAM_OBJ_BLEND; - (*sprites)->oam.affineMode = ST_OAM_AFFINE_DOUBLE; - (*sprites)->callback = sub_81CA4AC; - (*sprites)->data[0] = 8; - (*sprites)->data[1] = 0; - (*sprites)->data[7] = i; - InitSpriteAffineAnim(sprites[0]); - StartSpriteAffineAnim(sprites[0], 0); - sprites++; - } - - SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x10, 0x00)); - taskId = CreateTask(sub_81CA580, 3); - gTasks[taskId].data[0] = 8; - unk->otherIconsInMotion++; -} - -static void sub_81CA448(struct Sprite ** sprites, bool32 a1) -{ - s32 i; - - for (i = 0; i < 4; i++) - { - (*sprites)->invisible = a1; - sprites++; - } -} - -static void sub_81CA474(struct Sprite * sprite) -{ - sprite->data[0]--; - if (sprite->data[0] != -1) - { - sprite->data[2] += sprite->data[1]; - sprite->pos1.x = sprite->data[2] >> 4; - } - else - { - sprite->pos1.x = sprite->data[7]; - sprite->callback = SpriteCallbackDummy; - } -} - -static void sub_81CA4AC(struct Sprite * sprite) -{ - s32 r0; - s32 r1; - if (sprite->data[0] == 0) - { - if (sprite->data[1] == 0) - { - StartSpriteAffineAnim(sprite, 1); - sprite->data[1]++; - sprite->data[2] = 0x100; - sprite->pos1.x += sprite->pos2.x; - sprite->pos2.x = 0; - } - else - { - sprite->data[2] += 16; - r0 = sprite->data[2]; - r1 = r0 >> 3; - r1 = (r1 - 32) / 2; - switch (sprite->data[7]) - { - case 0: - sprite->pos2.x = -r1 * 3; - break; - case 1: - sprite->pos2.x = -r1; - break; - case 2: - sprite->pos2.x = r1; - break; - case 3: - sprite->pos2.x = r1 * 3; - break; - } - if (sprite->affineAnimEnded) - { - sprite->invisible = TRUE; - FreeOamMatrix(sprite->oam.matrixNum); - CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, ST_OAM_AFFINE_OFF); - sprite->oam.affineMode = ST_OAM_AFFINE_OFF; - sprite->oam.objMode = ST_OAM_OBJ_NORMAL; - sprite->callback = SpriteCallbackDummy; - } - } - } - else - { - sprite->data[0]--; - } -} - -static void sub_81CA580(u8 taskId) -{ - s16 * data = gTasks[taskId].data; - - if (data[0] == 0) - { - switch (data[1]) - { - case 0: - data[2] = 16; - data[3] = 0; - SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_NONE | BLDCNT_TGT2_ALL); - SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x10, 0x00)); - data[1]++; - break; - case 1: - if (data[4] & 1) - { - data[2] -= 3; - if (data[2] < 0) - data[2] = 0; - } - else - { - data[3] += 3; - if (data[3] > 16) - data[3] = 16; - } - SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(data[2], data[3])); - data[4]++; - if (data[4] == 12) - { - ((struct Pokenav2Struct *)GetSubstructPtr(2))->otherIconsInMotion--; - SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0x00, 0x10)); - DestroyTask(taskId); - } - break; - } - } - else - data[0]--; -} - -static void sub_81CA640(void) -{ - struct Pokenav2Struct * ptr = GetSubstructPtr(2); - u8 spriteId = CreateSprite(&gUnknown_0862036C, 0x10, 0x60, 4); - ptr->field_028 = &gSprites[spriteId]; - if (sub_81C98D4()) - ptr->field_028->callback = sub_81CA6AC; - else - ptr->field_028->invisible = TRUE; -} - -static void sub_81CA698(void) -{ - struct Pokenav2Struct * ptr = GetSubstructPtr(2); - DestroySprite(ptr->field_028); -} - -static void sub_81CA6AC(struct Sprite * sprite) -{ - sprite->data[0]++; - if (sprite->data[0] > 8) - { - sprite->data[0] = 0; - sprite->invisible ^= 1; - } -} - -static void AddOptionDescriptionWindow(void) -{ - struct Pokenav2Struct * ptr = GetSubstructPtr(2); - - ptr->optionDescWindowId = AddWindow(&sOptionDescWindowTemplate); - PutWindowTilemap(ptr->optionDescWindowId); - FillWindowPixelBuffer(ptr->optionDescWindowId, PIXEL_FILL(6)); - CopyWindowToVram(ptr->optionDescWindowId, 3); -} - -static void PrintCurrentOptionDescription(void) -{ - struct Pokenav2Struct * ptr = GetSubstructPtr(2); - int menuItem = GetCurrentMenuItemId(); - const u8 * s = sPageDescriptions[menuItem]; - u32 width = GetStringWidth(1, s, -1); - FillWindowPixelBuffer(ptr->optionDescWindowId, PIXEL_FILL(6)); - AddTextPrinterParameterized3(ptr->optionDescWindowId, 1, (192 - width) / 2, 1, sOptionDescTextColors, 0, s); -} - -// Printed when Ribbons is selected if no PC/party mons have ribbons -// Can occur by obtaining a mon with a ribbon and then releasing all ribbon winners -static void PrintNoRibbonWinners(void) -{ - struct Pokenav2Struct * ptr = GetSubstructPtr(2); - const u8 * s = gText_NoRibbonWinners; - u32 width = GetStringWidth(1, s, -1); - FillWindowPixelBuffer(ptr->optionDescWindowId, PIXEL_FILL(6)); - AddTextPrinterParameterized3(ptr->optionDescWindowId, 1, (192 - width) / 2, 1, sOptionDescTextColors2, 0, s); -} - -static bool32 sub_81CA7C4(void) -{ - return IsDma3ManagerBusyWithBgCopy(); -} - -static void sub_81CA7D4(void) -{ - struct Pokenav2Struct * ptr = GetSubstructPtr(2); - ptr->bg3ScrollTaskId = CreateTask(sub_81CA808, 2); -} - -static void sub_81CA7F4(void) -{ - struct Pokenav2Struct * ptr = GetSubstructPtr(2); - DestroyTask(ptr->bg3ScrollTaskId); -} - -static void sub_81CA808(u8 taskId) -{ - ChangeBgX(3, 0x80, 1); -} - -static void sub_81CA818(void) -{ - u8 taskId = CreateTask(sub_81CA8B0, 3); - SetWordTaskArg(taskId, 1, (uintptr_t)(gUnknown_0861FC78 + 1)); - SetWordTaskArg(taskId, 3, (uintptr_t)(gUnknown_0861FC78 + 7)); -} - -static void sub_81CA850(void) -{ - CopyPaletteIntoBufferUnfaded(gUnknown_0861FC78 + 7, 0x31, 4); -} - -static void sub_81CA864(void) -{ - u8 taskId = CreateTask(sub_81CA8B0, 3); - SetWordTaskArg(taskId, 1, (uintptr_t)(gUnknown_0861FC78 + 7)); - SetWordTaskArg(taskId, 3, (uintptr_t)(gUnknown_0861FC78 + 1)); -} - -static bool32 sub_81CA89C(void) -{ - return FuncIsActiveTask(sub_81CA8B0); -} - -static void sub_81CA8B0(u8 taskId) -{ - u16 sp8[2]; - s16 * data = gTasks[taskId].data; - const u16 * pal1 = (const u16 *)GetWordTaskArg(taskId, 1); - const u16 * pal2 = (const u16 *)GetWordTaskArg(taskId, 3); - - sub_81C79BC(pal1, pal2, 2, 12, ++data[0], sp8); - LoadPalette(sp8, 0x31, 4); - if (data[0] == 12) - DestroyTask(taskId); -} - -static void sub_81CA914(void) -{ - TransferPlttBuffer(); - LoadOam(); - ProcessSpriteCopyRequests(); - ScanlineEffect_InitHBlankDmaTransfer(); -} - -static void sub_81CA92C(void) -{ - SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_OBJ | BLDCNT_EFFECT_LIGHTEN); - SetGpuReg(REG_OFFSET_BLDY, 0); - SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); - SetGpuRegBits(REG_OFFSET_WININ, 0x3F); - SetGpuRegBits(REG_OFFSET_WINOUT, 0x1F); - SetGpuRegBits(REG_OFFSET_WIN0V, 0xA0); - ScanlineEffect_Stop(); - sub_81CAA3C(); - ScanlineEffect_SetParams(gUnknown_08620384); - SetVBlankCallback_(sub_81CA914); - CreateTask(sub_81CA9EC, 3); -} - -static void sub_81CA994(void) -{ - SetGpuReg(REG_OFFSET_BLDCNT, 0); - ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON); - ScanlineEffect_Stop(); - DestroyTask(FindTaskIdByFunc(sub_81CA9EC)); - SetPokenavVBlankCallback(); -} - -static void sub_81CA9C8(void) -{ - SetGpuReg(REG_OFFSET_BLDCNT, 0); -} - -static void sub_81CA9D8(void) -{ - sub_81CAA3C(); - SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_OBJ | BLDCNT_EFFECT_LIGHTEN); -} - -static void sub_81CA9EC(u8 taskId) -{ - s16 * data = gTasks[taskId].data; - data[0]++; - if (data[0] > 0) - { - data[0] = 0; - data[1] += 3; - data[1] &= 0x7F; - SetGpuReg(REG_OFFSET_BLDY, gSineTable[data[1]] >> 5); - } -} - -static void sub_81CAA3C(void) -{ - int menuType = GetPokenavMenuType(); - int cursorPos = GetPokenavCursorPos(); - int r4 = gUnknown_08620240[menuType].unk2 * cursorPos + gUnknown_08620240[menuType].unk0 - 8; - CpuFill16(0, gScanlineEffectRegBuffers[0], 0x140); - CpuFill16(0, gScanlineEffectRegBuffers[1], 0x140); - CpuFill16(RGB(16, 23, 28), &gScanlineEffectRegBuffers[0][r4], 0x20); - CpuFill16(RGB(16, 23, 28), &gScanlineEffectRegBuffers[1][r4], 0x20); -} - -void sub_81CAADC(void) -{ - sub_81CA9C8(); -} diff --git a/src/pokenav_unk_3.c b/src/pokenav_unk_3.c deleted file mode 100755 index 28e84b50b..000000000 --- a/src/pokenav_unk_3.c +++ /dev/null @@ -1,516 +0,0 @@ -#include "global.h" -#include "battle_setup.h" -#include "data.h" -#include "event_data.h" -#include "gym_leader_rematch.h" -#include "international_string_util.h" -#include "main.h" -#include "match_call.h" -#include "overworld.h" -#include "pokemon.h" -#include "pokenav.h" -#include "sound.h" -#include "string_util.h" -#include "strings.h" -#include "constants/flags.h" -#include "constants/songs.h" - -struct Pokenav3Struct -{ - u16 optionCursorPos; - u16 maxOptionId; - const u8 *matchCallOptions; - u16 headerId; - u16 numRegistered; - u16 unkC; - u32 unk10; - u32 unk14; - u32 (*callback)(struct Pokenav3Struct*); - struct PokenavMatchCallEntries matchCallEntries[MAX_REMATCH_ENTRIES - 1]; -}; - -static u32 CB2_HandleMatchCallInput(struct Pokenav3Struct *); -static u32 sub_81CABFC(struct Pokenav3Struct *); -static u32 CB2_HandleMatchCallOptionsInput(struct Pokenav3Struct *); -static u32 CB2_HandleCheckPageInput(struct Pokenav3Struct *); -static u32 CB2_HandleCallInput(struct Pokenav3Struct *); -static u32 sub_81CAD20(s32); -static bool32 sub_81CB1D0(void); - -#include "data/text/match_call_messages.h" - -static const u8 sMatchCallOptionsNoCheckPage[] = -{ - MATCH_CALL_OPTION_CALL, - MATCH_CALL_OPTION_CANCEL -}; - -static const u8 sMatchCallOptionsHasCheckPage[] = -{ - MATCH_CALL_OPTION_CALL, - MATCH_CALL_OPTION_CHECK, - MATCH_CALL_OPTION_CANCEL -}; - -bool32 PokenavCallback_Init_11(void) -{ - struct Pokenav3Struct *state = AllocSubstruct(5, sizeof(struct Pokenav3Struct)); - if (!state) - return FALSE; - - state->callback = CB2_HandleMatchCallInput; - state->headerId = 0; - state->unk10 = 0; - state->unk14 = CreateLoopedTask(sub_81CAD20, 1); - return TRUE; -} - -u32 sub_81CAB24(void) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - return state->callback(state); -} - -void sub_81CAB38(void) -{ - FreePokenavSubstruct(5); -} - -static u32 CB2_HandleMatchCallInput(struct Pokenav3Struct *state) -{ - int selection; - - if (gMain.newAndRepeatedKeys & DPAD_UP) - return POKENAV_MC_FUNC_UP; - if (gMain.newAndRepeatedKeys & DPAD_DOWN) - return POKENAV_MC_FUNC_DOWN; - if (gMain.newAndRepeatedKeys & DPAD_LEFT) - return POKENAV_MC_FUNC_PG_UP; - if (gMain.newAndRepeatedKeys & DPAD_RIGHT) - return POKENAV_MC_FUNC_PG_DOWN; - - if (gMain.newKeys & A_BUTTON) - { - state->callback = CB2_HandleMatchCallOptionsInput; - state->optionCursorPos = 0; - selection = GetSelectedMatchCall(); - - if (!state->matchCallEntries[selection].isSpecialTrainer || MatchCall_HasCheckPage(state->matchCallEntries[selection].headerId)) - { - state->matchCallOptions = sMatchCallOptionsHasCheckPage; - state->maxOptionId = ARRAY_COUNT(sMatchCallOptionsHasCheckPage) - 1; - } - else - { - state->matchCallOptions = sMatchCallOptionsNoCheckPage; - state->maxOptionId = ARRAY_COUNT(sMatchCallOptionsNoCheckPage) - 1; - } - - return POKENAV_MC_FUNC_SELECT; - } - - if (gMain.newKeys & B_BUTTON) - { - if (GetPokenavMode() != POKENAV_MODE_FORCE_CALL_READY) - { - state->callback = sub_81CABFC; - return POKENAV_MC_FUNC_EXIT; - } - else - { - // Cant exit Match Call menu before calling Mr Stone during tutorial - PlaySE(SE_HAZURE); - } - } - - return POKENAV_MC_FUNC_NONE; -} - -static u32 sub_81CABFC(struct Pokenav3Struct *state) -{ - return POKENAV_MENU_4; -} - -static u32 CB2_HandleMatchCallOptionsInput(struct Pokenav3Struct *state) -{ - if ((gMain.newKeys & DPAD_UP) && state->optionCursorPos) - { - state->optionCursorPos--; - return POKENAV_MC_FUNC_MOVE_OPTIONS_CURSOR; - } - - if ((gMain.newKeys & DPAD_DOWN) && state->optionCursorPos < state->maxOptionId) - { - state->optionCursorPos++; - return POKENAV_MC_FUNC_MOVE_OPTIONS_CURSOR; - } - - if (gMain.newKeys & A_BUTTON) - { - switch (state->matchCallOptions[state->optionCursorPos]) - { - case MATCH_CALL_OPTION_CANCEL: - state->callback = CB2_HandleMatchCallInput; - return POKENAV_MC_FUNC_CANCEL; - case MATCH_CALL_OPTION_CALL: - if (GetPokenavMode() == POKENAV_MODE_FORCE_CALL_READY) - SetPokenavMode(POKENAV_MODE_FORCE_CALL_EXIT); - - state->callback = CB2_HandleCallInput; - if (sub_81CB1D0()) - return POKENAV_MC_FUNC_NEARBY_MSG; - - return POKENAV_MC_FUNC_CALL_MSG; - case MATCH_CALL_OPTION_CHECK: - state->callback = CB2_HandleCheckPageInput; - return POKENAV_MC_FUNC_SHOW_CHECK_PAGE; - } - } - - if (gMain.newKeys & B_BUTTON) - { - state->callback = CB2_HandleMatchCallInput; - return POKENAV_MC_FUNC_CANCEL; - } - - return POKENAV_MC_FUNC_NONE; -} - -static u32 CB2_HandleCheckPageInput(struct Pokenav3Struct *state) -{ - if (gMain.newAndRepeatedKeys & DPAD_UP) - return POKENAV_MC_FUNC_CHECK_PAGE_UP; - if (gMain.newAndRepeatedKeys & DPAD_DOWN) - return POKENAV_MC_FUNC_CHECK_PAGE_DOWN; - - if (gMain.newKeys & B_BUTTON) - { - state->callback = CB2_HandleMatchCallInput; - return POKENAV_MC_FUNC_EXIT_CHECK_PAGE; - } - - return POKENAV_MC_FUNC_NONE; -} - -static u32 CB2_HandleCallInput(struct Pokenav3Struct *state) -{ - if (gMain.newKeys & (A_BUTTON | B_BUTTON)) - { - state->callback = CB2_HandleMatchCallInput; - return POKENAV_MC_FUNC_10; - } - - return POKENAV_MC_FUNC_NONE; -} - -static u32 sub_81CAD20(s32 taskState) -{ - int i, j; - struct Pokenav3Struct *state = GetSubstructPtr(5); - switch (taskState) - { - case 0: - state->headerId = 0; - state->numRegistered = 0; - return LT_INC_AND_CONTINUE; - case 1: - for (i = 0, j = state->headerId; i < 30; i++, j++) - { - if (MatchCall_GetEnabled(j)) - { - state->matchCallEntries[state->numRegistered].headerId = j; - state->matchCallEntries[state->numRegistered].isSpecialTrainer = TRUE; - state->matchCallEntries[state->numRegistered].mapSec = MatchCall_GetMapSec(j); - state->numRegistered++; - } - - if (++state->headerId >= MC_HEADER_COUNT) - { - state->unkC = state->headerId; - state->headerId = 0; - return LT_INC_AND_CONTINUE; - } - } - - return LT_CONTINUE; - case 2: - for (i = 0, j = state->headerId; i < 30; i++, j++) - { - if (!MatchCall_HasRematchId(state->headerId) && IsRematchEntryRegistered(state->headerId)) - { - state->matchCallEntries[state->numRegistered].headerId = state->headerId; - state->matchCallEntries[state->numRegistered].isSpecialTrainer = FALSE; - state->matchCallEntries[state->numRegistered].mapSec = sub_81CB0C8(j); - state->numRegistered++; - } - - if (++state->headerId > REMATCH_TABLE_ENTRIES - 1) - return LT_INC_AND_CONTINUE; - } - - return LT_CONTINUE; - case 3: - state->unk10 = 1; - break; - } - - return LT_FINISH; -} - -bool32 IsRematchEntryRegistered(int rematchIndex) -{ - if (rematchIndex < REMATCH_TABLE_ENTRIES) - return FlagGet(FLAG_MATCH_CALL_REGISTERED + rematchIndex); - - return FALSE; -} - -int sub_81CAE28(void) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - return state->unk10; -} - -int GetNumberRegistered(void) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - return state->numRegistered; -} - -int sub_81CAE48(void) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - return state->unkC; -} - -int unref_sub_81CAE58(void) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - return state->numRegistered - state->unkC; -} - -int unref_sub_81CAE6C(int arg0) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - arg0 += state->unkC; - if (arg0 >= state->numRegistered) - return REMATCH_TABLE_ENTRIES; - - return state->matchCallEntries[arg0].headerId; -} - -struct PokenavMatchCallEntries *sub_81CAE94(void) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - return state->matchCallEntries; -} - -u16 GetMatchCallMapSec(int index) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - return state->matchCallEntries[index].mapSec; -} - -bool32 ShouldDrawRematchPokeballIcon(int index) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - if (!state->matchCallEntries[index].isSpecialTrainer) - index = state->matchCallEntries[index].headerId; - else - index = MatchCall_GetRematchTableIdx(state->matchCallEntries[index].headerId); - - if (index == REMATCH_TABLE_ENTRIES) - return FALSE; - - return gSaveBlock1Ptr->trainerRematches[index] != 0; -} - -int GetMatchCallTrainerPic(int index) -{ - int headerId; - struct Pokenav3Struct *state = GetSubstructPtr(5); - if (!state->matchCallEntries[index].isSpecialTrainer) - { - index = GetTrainerIdxByRematchIdx(state->matchCallEntries[index].headerId); - return gTrainers[index].trainerPic; - } - - headerId = state->matchCallEntries[index].headerId; - index = MatchCall_GetRematchTableIdx(headerId); - if (index != REMATCH_TABLE_ENTRIES) - { - index = GetTrainerIdxByRematchIdx(index); - return gTrainers[index].trainerPic; - } - - index = MatchCall_GetOverrideFacilityClass(headerId); - return gFacilityClassToPicIndex[index]; -} - -const u8 *GetMatchCallMessageText(int index, u8 *arg1) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - *arg1 = 0; - if (!Overworld_MapTypeAllowsTeleportAndFly(gMapHeader.mapType)) - return gText_CallCantBeMadeHere; - - if (!state->matchCallEntries[index].isSpecialTrainer) - *arg1 = SelectMatchCallMessage(GetTrainerIdxByRematchIdx(state->matchCallEntries[index].headerId), gStringVar4); - else - MatchCall_GetMessage(state->matchCallEntries[index].headerId, gStringVar4); - - return gStringVar4; -} - -const u8 *GetMatchCallFlavorText(int index, int checkPageEntry) -{ - int rematchId; - struct Pokenav3Struct *state = GetSubstructPtr(5); - if (state->matchCallEntries[index].isSpecialTrainer) - { - rematchId = MatchCall_GetRematchTableIdx(state->matchCallEntries[index].headerId); - if (rematchId == REMATCH_TABLE_ENTRIES) - return MatchCall_GetOverrideFlavorText(state->matchCallEntries[index].headerId, checkPageEntry); - } - else - { - rematchId = state->matchCallEntries[index].headerId; - } - - return gMatchCallFlavorTexts[rematchId][checkPageEntry]; -} - -u16 GetMatchCallOptionCursorPos(void) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - return state->optionCursorPos; -} - -u16 GetMatchCallOptionId(int optionId) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - if (state->maxOptionId < optionId) - return MATCH_CALL_OPTION_COUNT; - - return state->matchCallOptions[optionId]; -} - -void BufferMatchCallNameAndDesc(struct PokenavMatchCallEntries *matchCallEntry, u8 *str) -{ - const u8 *trainerName; - const u8 *className; - if (!matchCallEntry->isSpecialTrainer) - { - int index = GetTrainerIdxByRematchIdx(matchCallEntry->headerId); - const struct Trainer *trainer = &gTrainers[index]; - int class = trainer->trainerClass; - className = gTrainerClassNames[class]; - trainerName = trainer->trainerName; - } - else - { - MatchCall_GetNameAndDesc(matchCallEntry->headerId, &className, &trainerName); - } - - if (className && trainerName) - { - u8 *str2 = sub_81DB494(str, 7, className, 69); - sub_81DB494(str2, 7, trainerName, 51); - } - else - { - sub_81DB494(str, 7, NULL, 120); - } -} - -u8 sub_81CB0C8(int rematchIndex) -{ - int mapGroup = gRematchTable[rematchIndex].mapGroup; - int mapNum = gRematchTable[rematchIndex].mapNum; - return Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum)->regionMapSectionId; -} - -int GetIndexDeltaOfNextCheckPageDown(int index) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - int count = 1; - while (++index < state->numRegistered) - { - if (!state->matchCallEntries[index].isSpecialTrainer) - return count; - if (MatchCall_HasCheckPage(state->matchCallEntries[index].headerId)) - return count; - - count++; - } - - return 0; -} - -int GetIndexDeltaOfNextCheckPageUp(int index) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - int count = -1; - while (--index >= 0) - { - if (!state->matchCallEntries[index].isSpecialTrainer) - return count; - if (MatchCall_HasCheckPage(state->matchCallEntries[index].headerId)) - return count; - - count--; - } - - return 0; -} - -bool32 unref_sub_81CB16C(void) -{ - int i; - - for (i = 0; i < REMATCH_TABLE_ENTRIES; i++) - { - if (IsRematchEntryRegistered(i) && gSaveBlock1Ptr->trainerRematches[i]) - return TRUE; - } - - for (i = 0; i < MC_HEADER_COUNT; i++) - { - if (MatchCall_GetEnabled(i)) - { - int index = MatchCall_GetRematchTableIdx(i); - if (gSaveBlock1Ptr->trainerRematches[index]) - return TRUE; - } - } - - return FALSE; -} - -static bool32 sub_81CB1D0(void) -{ - struct Pokenav3Struct *state = GetSubstructPtr(5); - int selection = GetSelectedMatchCall(); - if (!state->matchCallEntries[selection].isSpecialTrainer) - { - if (GetMatchCallMapSec(selection) == gMapHeader.regionMapSectionId) - { - if (!gSaveBlock1Ptr->trainerRematches[state->matchCallEntries[selection].headerId]) - return TRUE; - } - } - else - { - if (state->matchCallEntries[selection].headerId == MC_HEADER_WATTSON) - { - if (GetMatchCallMapSec(selection) == gMapHeader.regionMapSectionId - && FlagGet(FLAG_BADGE05_GET) == TRUE) - { - if (!FlagGet(FLAG_WATTSON_REMATCH_AVAILABLE)) - return TRUE; - } - } - } - - return FALSE; -} diff --git a/src/pokenav_unk_4.c b/src/pokenav_unk_4.c deleted file mode 100755 index aaa1767aa..000000000 --- a/src/pokenav_unk_4.c +++ /dev/null @@ -1,1279 +0,0 @@ -#include "global.h" -#include "bg.h" -#include "data.h" -#include "decompress.h" -#include "dma3.h" -#include "international_string_util.h" -#include "main.h" -#include "match_call.h" -#include "menu.h" -#include "overworld.h" -#include "palette.h" -#include "pokenav.h" -#include "region_map.h" -#include "sound.h" -#include "sprite.h" -#include "string_util.h" -#include "strings.h" -#include "task.h" -#include "text.h" -#include "text_window.h" -#include "trig.h" -#include "window.h" -#include "constants/game_stat.h" -#include "constants/region_map_sections.h" -#include "constants/songs.h" -#include "constants/species.h" - -struct Pokenav4Struct -{ - bool32 (*unk0)(void); - u32 unk4; - u8 filler8[0x6]; - u8 unkE; - u8 unkF; - u16 locWindowId; - u16 infoBoxWindowId; - u16 msgBoxWindowId; - s16 unk16; - u8 unused18; - u8 unk19; - u16 unk1A; - struct Sprite *optionsCursorSprite; - struct Sprite *trainerPicSprite; - u8 unk24[0x800]; - u8 unk824[0x800]; - u8 unk1024[0x800]; - u8 *unk1824; - u8 unk1828[0x800]; - u8 unk2028[0x20]; -}; - -static bool32 sub_81CB310(void); -static u32 sub_81CB324(s32); -static void sub_81CBBB8(void); -static void sub_81CBC1C(void); -static void sub_81CC2B4(void); -static void sub_81CC034(struct Pokenav4Struct *); -static void DrawMatchCallLeftColumnWindows(struct Pokenav4Struct *); -static void UpdateMatchCallInfoBox(struct Pokenav4Struct *); -static void PrintMatchCallLocation(struct Pokenav4Struct *, int); -static void sub_81CC214(void); -static void sub_81CBC38(int); -static void PrintMatchCallSelectionOptions(struct Pokenav4Struct *); -static bool32 sub_81CBFC4(struct Pokenav4Struct *); -static void UpdateCursorGfxPos(struct Pokenav4Struct *, int); -static bool32 IsDma3ManagerBusyWithBgCopy1(struct Pokenav4Struct *); -static void UpdateWindowsReturnToTrainerList(struct Pokenav4Struct *); -static void DrawMsgBoxForMatchCallMsg(struct Pokenav4Struct *); -static bool32 IsDma3ManagerBusyWithBgCopy2(struct Pokenav4Struct *); -static void PrintCallingDots(struct Pokenav4Struct *); -static bool32 WaitForCallingDotsText(struct Pokenav4Struct *); -static void PrintMatchCallMessage(struct Pokenav4Struct *); -static bool32 WaitForMatchCallMessageText(struct Pokenav4Struct *); -static void DrawMsgBoxForCloseByMsg(struct Pokenav4Struct *); -static void PrintTrainerIsCloseBy(struct Pokenav4Struct *); -static bool32 WaitForTrainerIsCloseByText(struct Pokenav4Struct *); -static void DrawSpinningPokenavForCall(struct Pokenav4Struct *); -static bool32 WaitForSpinningPokenav(struct Pokenav4Struct *); -static void UpdateWindowsToShowCheckPage(struct Pokenav4Struct *); -static void LoadCheckPageTrainerPic(struct Pokenav4Struct *); -static bool32 WaitForTrainerPic(struct Pokenav4Struct *); -static void TrainerPicSlideOffscreen(struct Pokenav4Struct *); -static void sub_81CBC64(u8 taskId); -static void TryDrawRematchPokeballIcon(u16 windowId, u32, u32); -static void PrintNumberRegisteredLabel(u16 windowId); -static void PrintNumberRegistered(u16 windowId); -static void PrintNumberOfBattlesLabel(u16 windowId); -static void PrintNumberOfBattles(u16 windowId); -static void PrintMatchCallInfoLabel(u16 windowId, const u8 *str, int top); -static void PrintMatchCallInfoNumber(u16 windowId, const u8 *str, int top); -static void sub_81CC2F0(struct Pokenav4Struct *, int); -static void CloseMatchCallSelectOptionsWindow(struct Pokenav4Struct *); -static struct Sprite *CreateTrainerPicSprite(void); -static void SpriteCB_TrainerPicSlideOnscreen(struct Sprite *sprite); -static void SpriteCB_TrainerPicSlideOffscreen(struct Sprite *sprite); -void SpriteCB_OptionsCursor(struct Sprite *sprite); -u32 MatchCallListCursorDown(s32); -u32 MatchCallListCursorUp(s32); -u32 MatchCallListPageDown(s32); -u32 MatchCallListPageUp(s32); -u32 SelectMatchCallEntry(s32); -u32 MoveMatchCallOptionsCursor(s32); -static u32 CancelMatchCallSelection(s32); -u32 DoMatchCallMessage(s32); -u32 DoTrainerCloseByMessage(s32); -u32 sub_81CB888(s32); -u32 ShowCheckPage(s32); -u32 ShowCheckPageUp(s32); -u32 ShowCheckPageDown(s32); -u32 ExitCheckPage(s32); -u32 ExitMatchCall(s32); - -static const u16 sMatchCallUI_Pal[] = INCBIN_U16("graphics/pokenav/ui_matchcall.gbapal"); -static const u32 sMatchCallUI_Gfx[] = INCBIN_U32("graphics/pokenav/ui_matchcall.4bpp.lz"); -static const u32 sMatchCallUI_Tilemap[] = INCBIN_U32("graphics/pokenav/ui_matchcall.bin.lz"); -static const u16 gUnknown_08622698[] = INCBIN_U16("graphics/pokenav/arrow2.gbapal"); -static const u32 gUnknown_086226B8[] = INCBIN_U32("graphics/pokenav/arrow2.4bpp.lz"); -static const u16 gUnknown_086226E0[] = INCBIN_U16("graphics/pokenav/86226E0.gbapal"); -static const u16 gUnknown_08622700[] = INCBIN_U16("graphics/pokenav/8622700.gbapal"); -static const u16 gUnknown_08622720[] = INCBIN_U16("graphics/pokenav/pokeball_matchcall.gbapal"); -static const u32 gUnknown_08622760[] = INCBIN_U32("graphics/pokenav/pokeball_matchcall.4bpp.lz"); - -const struct BgTemplate gUnknown_0862278C[3] = -{ - { - .bg = 1, - .charBaseIndex = 3, - .mapBaseIndex = 0x1F, - .screenSize = 0, - .paletteMode = 0, - .priority = 1, - .baseTile = 0 - }, - { - .bg = 2, - .charBaseIndex = 2, - .mapBaseIndex = 0x06, - .screenSize = 0, - .paletteMode = 0, - .priority = 2, - .baseTile = 0x80 - }, - { - .bg = 3, - .charBaseIndex = 1, - .mapBaseIndex = 0x07, - .screenSize = 0, - .paletteMode = 0, - .priority = 3, - .baseTile = 0 - } -}; - -static const LoopedTask sMatchCallLoopTaskFuncs[] = -{ - [POKENAV_MC_FUNC_NONE] = NULL, - [POKENAV_MC_FUNC_DOWN] = MatchCallListCursorDown, - [POKENAV_MC_FUNC_UP] = MatchCallListCursorUp, - [POKENAV_MC_FUNC_PG_DOWN] = MatchCallListPageDown, - [POKENAV_MC_FUNC_PG_UP] = MatchCallListPageUp, - [POKENAV_MC_FUNC_SELECT] = SelectMatchCallEntry, - [POKENAV_MC_FUNC_MOVE_OPTIONS_CURSOR] = MoveMatchCallOptionsCursor, - [POKENAV_MC_FUNC_CANCEL] = CancelMatchCallSelection, - [POKENAV_MC_FUNC_CALL_MSG] = DoMatchCallMessage, - [POKENAV_MC_FUNC_NEARBY_MSG] = DoTrainerCloseByMessage, - [POKENAV_MC_FUNC_10] = sub_81CB888, - [POKENAV_MC_FUNC_SHOW_CHECK_PAGE] = ShowCheckPage, - [POKENAV_MC_FUNC_CHECK_PAGE_UP] = ShowCheckPageUp, - [POKENAV_MC_FUNC_CHECK_PAGE_DOWN] = ShowCheckPageDown, - [POKENAV_MC_FUNC_EXIT_CHECK_PAGE] = ExitCheckPage, - [POKENAV_MC_FUNC_EXIT] = ExitMatchCall -}; - -static const struct WindowTemplate sMatchCallLocationWindowTemplate = -{ - .bg = 2, - .tilemapLeft = 0, - .tilemapTop = 5, - .width = 11, - .height = 2, - .paletteNum = 2, - .baseBlock = 16 -}; - -static const struct WindowTemplate sMatchCallInfoBoxWindowTemplate = -{ - .bg = 2, - .tilemapLeft = 0, - .tilemapTop = 9, - .width = 11, - .height = 8, - .paletteNum = 2, - .baseBlock = 38 -}; - -static const u8 *const sMatchCallOptionTexts[MATCH_CALL_OPTION_COUNT] = -{ - [MATCH_CALL_OPTION_CALL] = gText_Call, - [MATCH_CALL_OPTION_CHECK] = gText_Check, - [MATCH_CALL_OPTION_CANCEL] = gText_Cancel6 -}; - -// The series of 5 dots that appear when someone is called with Match Call -static const u8 sText_CallingDots[] = _("·{PAUSE 0x04}·{PAUSE 0x04}·{PAUSE 0x04}·{PAUSE 0x04}·\p"); - -static const struct WindowTemplate sCallMsgBoxWindowTemplate = -{ - .bg = 1, - .tilemapLeft = 1, - .tilemapTop = 12, - .width = 0x1C, - .height = 0x04, - .paletteNum = 1, - .baseBlock = 10 -}; - -const struct CompressedSpriteSheet gUnknown_08622810[1] = -{ - {gUnknown_086226B8, 0x40, 7} -}; - -const struct SpritePalette gUnknown_08622818[2] = -{ - {gUnknown_08622698, 12} -}; - -static const struct OamData sOptionsCursorOamData = -{ - .y = 0, - .affineMode = ST_OAM_AFFINE_OFF, - .objMode = ST_OAM_OBJ_NORMAL, - .bpp = ST_OAM_4BPP, - .shape = SPRITE_SHAPE(8x16), - .x = 0, - .size = SPRITE_SIZE(8x16), - .tileNum = 0, - .priority = 1, - .paletteNum = 0, -}; - -static const struct SpriteTemplate sOptionsCursorSpriteTemplate = -{ - .tileTag = 7, - .paletteTag = 12, - .oam = &sOptionsCursorOamData, - .anims = gDummySpriteAnimTable, - .images = NULL, - .affineAnims = gDummySpriteAffineAnimTable, - .callback = SpriteCB_OptionsCursor, -}; - -static const struct OamData sTrainerPicOamData = -{ - .y = 0, - .affineMode = ST_OAM_AFFINE_OFF, - .objMode = ST_OAM_OBJ_NORMAL, - .bpp = ST_OAM_4BPP, - .shape = SPRITE_SHAPE(64x64), - .x = 0, - .size = SPRITE_SIZE(64x64), - .tileNum = 0, - .priority = 1, - .paletteNum = 0, -}; - -static const struct SpriteTemplate sTrainerPicSpriteTemplate = -{ - .tileTag = 8, - .paletteTag = 13, - .oam = &sTrainerPicOamData, - .anims = gDummySpriteAnimTable, - .images = NULL, - .affineAnims = gDummySpriteAffineAnimTable, - .callback = SpriteCallbackDummy, -}; - -bool32 sub_81CB260(void) -{ - struct Pokenav4Struct *state = AllocSubstruct(6, sizeof(struct Pokenav4Struct)); - if (!state) - return FALSE; - - state->unk19 = 0; - state->unk4 = CreateLoopedTask(sub_81CB324, 1); - state->unk0 = sub_81CB310; - return TRUE; -} - -void CreateMatchCallLoopedTask(s32 index) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - state->unk4 = CreateLoopedTask(sMatchCallLoopTaskFuncs[index], 1); - state->unk0 = sub_81CB310; -} - -u32 sub_81CB2CC(void) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - return state->unk0(); -} - -void sub_81CB2E0(void) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - sub_81CC2B4(); - sub_81CBC1C(); - RemoveWindow(state->infoBoxWindowId); - RemoveWindow(state->locWindowId); - RemoveWindow(state->msgBoxWindowId); - FreePokenavSubstruct(6); -} - -static bool32 sub_81CB310(void) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - return IsLoopedTaskActive(state->unk4); -} - -static u32 sub_81CB324(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - InitBgTemplates(gUnknown_0862278C, ARRAY_COUNT(gUnknown_0862278C)); - ChangeBgX(2, 0, 0); - ChangeBgY(2, 0, 0); - decompress_and_copy_tile_data_to_vram(2, sMatchCallUI_Gfx, 0, 0, 0); - SetBgTilemapBuffer(2, state->unk1024); - CopyToBgTilemapBuffer(2, sMatchCallUI_Tilemap, 0, 0); - CopyBgTilemapBufferToVram(2); - CopyPaletteIntoBufferUnfaded(sMatchCallUI_Pal, 0x20, 0x20); - CopyBgTilemapBufferToVram(2); - return LT_INC_AND_PAUSE; - case 1: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - - sub_8199DF0(1, 0, 0, 1); - SetBgTilemapBuffer(1, state->unk24); - FillBgTilemapBufferRect_Palette0(1, 0x1000, 0, 0, 32, 20); - CopyPaletteIntoBufferUnfaded(gUnknown_086226E0, 0x10, 0x20); - CopyBgTilemapBufferToVram(1); - return LT_INC_AND_PAUSE; - case 2: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - - sub_81CC034(state); - decompress_and_copy_tile_data_to_vram(3, gUnknown_08622760, 0, 0, 0); - CopyPaletteIntoBufferUnfaded(gUnknown_08622700, 0x30, 0x20); - CopyPaletteIntoBufferUnfaded(gUnknown_08622720, 0x50, 0x20); - return LT_INC_AND_PAUSE; - case 3: - if (free_temp_tile_data_buffers_if_possible() || !sub_81CAE28()) - return LT_PAUSE; - - sub_81CBBB8(); - return LT_INC_AND_PAUSE; - case 4: - if (sub_81C8224()) - return LT_PAUSE; - - DrawMatchCallLeftColumnWindows(state); - return LT_INC_AND_PAUSE; - case 5: - UpdateMatchCallInfoBox(state); - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 6: - ChangeBgX(1, 0, 0); - ChangeBgY(1, 0, 0); - ShowBg(2); - ShowBg(3); - ShowBg(1); - sub_81CC214(); - LoadLeftHeaderGfxForIndex(3); - sub_81C7FA0(3, 1, 0); - sub_81C7AC0(1); - return LT_INC_AND_PAUSE; - case 7: - if (IsPaletteFadeActive() || sub_81C8010()) - return LT_PAUSE; - - sub_81CBC38(1); - return LT_FINISH; - default: - return LT_FINISH; - } -} - -u32 MatchCallListCursorDown(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - switch (MatchCall_MoveCursorDown()) - { - case 0: - break; - case 1: - PlaySE(SE_SELECT); - return 7; - case 2: - PlaySE(SE_SELECT); - // fall through - default: - return LT_INC_AND_PAUSE; - } - break; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 2: - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -u32 MatchCallListCursorUp(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - switch (MatchCall_MoveCursorUp()) - { - case 0: - break; - case 1: - PlaySE(SE_SELECT); - return 7; - case 2: - PlaySE(SE_SELECT); - // fall through - default: - return LT_INC_AND_PAUSE; - } - break; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 2: - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -u32 MatchCallListPageDown(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - switch (MatchCall_PageDown()) - { - case 0: - break; - case 1: - PlaySE(SE_SELECT); - return 7; - case 2: - PlaySE(SE_SELECT); - // fall through - default: - return LT_INC_AND_PAUSE; - } - break; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 2: - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -u32 MatchCallListPageUp(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - switch (MatchCall_PageUp()) - { - case 0: - break; - case 1: - PlaySE(SE_SELECT); - return 7; - case 2: - PlaySE(SE_SELECT); - // fall through - default: - return LT_INC_AND_PAUSE; - } - break; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 2: - PrintMatchCallLocation(state, 0); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -u32 SelectMatchCallEntry(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - PrintMatchCallSelectionOptions(state); - PrintHelpBarText(HELPBAR_MC_CALL_MENU); - return LT_INC_AND_PAUSE; - case 1: - if (sub_81CBFC4(state)) - return LT_PAUSE; - break; - } - - return LT_FINISH; -} - -u32 MoveMatchCallOptionsCursor(s32 taskState) -{ - struct Pokenav4Struct *state; - u16 cursorPos; - - PlaySE(SE_SELECT); - state = GetSubstructPtr(6); - cursorPos = GetMatchCallOptionCursorPos(); - UpdateCursorGfxPos(state, cursorPos); - return LT_FINISH; -} - -u32 CancelMatchCallSelection(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - UpdateWindowsReturnToTrainerList(state); - PrintHelpBarText(HELPBAR_MC_TRAINER_LIST); - return LT_INC_AND_PAUSE; - case 1: - if (IsDma3ManagerBusyWithBgCopy1(state)) - return LT_PAUSE; - break; - } - - return LT_FINISH; -} - -u32 DoMatchCallMessage(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - ToggleMatchCallVerticalArrows(TRUE); - DrawMsgBoxForMatchCallMsg(state); - return LT_INC_AND_PAUSE; - case 1: - if (IsDma3ManagerBusyWithBgCopy2(state)) - return LT_PAUSE; - - PrintCallingDots(state); - PlaySE(SE_TOREEYE); - state->unkE = 0; - return LT_INC_AND_PAUSE; - case 2: - if (WaitForCallingDotsText(state)) - return LT_PAUSE; - - PrintMatchCallMessage(state); - return LT_INC_AND_PAUSE; - case 3: - if (WaitForMatchCallMessageText(state)) - return LT_PAUSE; - break; - } - - return LT_FINISH; -} - -u32 DoTrainerCloseByMessage(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - DrawMsgBoxForCloseByMsg(state); - ToggleMatchCallVerticalArrows(TRUE); - state->unkE = 1; - return LT_INC_AND_PAUSE; - case 1: - if (IsDma3ManagerBusyWithBgCopy2(state)) - return LT_PAUSE; - - PrintTrainerIsCloseBy(state); - return LT_INC_AND_PAUSE; - case 2: - if (WaitForTrainerIsCloseByText(state)) - return LT_PAUSE; - break; - } - - return LT_FINISH; -} - -u32 sub_81CB888(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - u32 result = LT_INC_AND_PAUSE; - - switch (taskState) - { - case 0: - if (!state->unkE) - PlaySE(SE_TOREOFF); - - PlaySE(SE_SELECT); - break; - case 1: - DrawSpinningPokenavForCall(state); - break; - case 2: - if (WaitForSpinningPokenav(state)) - result = LT_PAUSE; - break; - case 3: - UpdateWindowsReturnToTrainerList(state); - break; - case 4: - if (IsDma3ManagerBusyWithBgCopy1(state)) - result = LT_PAUSE; - - PrintHelpBarText(HELPBAR_MC_TRAINER_LIST); - break; - case 5: - if (WaitForHelpBar()) - { - result = LT_PAUSE; - } - else - { - if (state->unkF) - { - sub_81C8838(); - result = LT_INC_AND_CONTINUE; - } - else - { - ToggleMatchCallVerticalArrows(FALSE); - result = LT_FINISH; - } - } - break; - case 6: - if (IsDma3ManagerBusyWithBgCopy()) - { - result = LT_PAUSE; - } - else - { - ToggleMatchCallVerticalArrows(FALSE); - result = LT_FINISH; - } - break; - } - - return result; -} - -u32 ShowCheckPage(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - sub_81C877C(); - UpdateWindowsToShowCheckPage(state); - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8820() || IsDma3ManagerBusyWithBgCopy1(state)) - return LT_PAUSE; - - PrintHelpBarText(HELPBAR_MC_CHECK_PAGE); - return LT_INC_AND_PAUSE; - case 2: - PrintCheckPageInfo(0); - LoadCheckPageTrainerPic(state); - return LT_INC_AND_PAUSE; - case 3: - if (sub_81C8820() || WaitForTrainerPic(state) || WaitForHelpBar()) - return LT_PAUSE; - break; - } - - return LT_FINISH; -} - -u32 ShowCheckPageDown(s32 taskState) -{ - int topId; - int delta; - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - topId = GetMatchCallListTopIndex(); - delta = GetIndexDeltaOfNextCheckPageDown(topId); - if (delta) - { - PlaySE(SE_SELECT); - state->unk16 = delta; - TrainerPicSlideOffscreen(state); - return LT_INC_AND_PAUSE; - } - break; - case 1: - if (WaitForTrainerPic(state)) - return LT_PAUSE; - - PrintMatchCallLocation(state, state->unk16); - return LT_INC_AND_PAUSE; - case 2: - PrintCheckPageInfo(state->unk16); - return LT_INC_AND_PAUSE; - case 3: - LoadCheckPageTrainerPic(state); - return LT_INC_AND_PAUSE; - case 4: - if (sub_81C8820() || WaitForTrainerPic(state)) - return LT_PAUSE; - break; - } - - return LT_FINISH; -} - -u32 ExitCheckPage(s32 taskState) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - TrainerPicSlideOffscreen(state); - sub_81C87F0(); - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8820() || WaitForTrainerPic(state)) - return LT_PAUSE; - - PrintHelpBarText(HELPBAR_MC_TRAINER_LIST); - UpdateMatchCallInfoBox(state); - return LT_INC_AND_PAUSE; - case 2: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - - return LT_FINISH; -} - -u32 ShowCheckPageUp(s32 taskState) -{ - int topId; - int delta; - struct Pokenav4Struct *state = GetSubstructPtr(6); - switch (taskState) - { - case 0: - topId = GetMatchCallListTopIndex(); - delta = GetIndexDeltaOfNextCheckPageUp(topId); - if (delta) - { - PlaySE(SE_SELECT); - state->unk16 = delta; - TrainerPicSlideOffscreen(state); - return LT_INC_AND_PAUSE; - } - break; - case 1: - if (WaitForTrainerPic(state)) - return LT_PAUSE; - - PrintMatchCallLocation(state, state->unk16); - return LT_INC_AND_PAUSE; - case 2: - PrintCheckPageInfo(state->unk16); - return LT_INC_AND_PAUSE; - case 3: - LoadCheckPageTrainerPic(state); - return LT_INC_AND_PAUSE; - case 4: - if (sub_81C8820() || WaitForTrainerPic(state)) - return LT_PAUSE; - break; - } - - return LT_FINISH; -} - -u32 ExitMatchCall(s32 taskState) -{ - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - sub_81CBC38(0); - sub_81C7AC0(0); - sub_81C78A0(); - return LT_INC_AND_PAUSE; - case 1: - if (IsPaletteFadeActive() || MainMenuLoopedTaskIsBusy()) - return LT_PAUSE; - - sub_81C7FDC(); - break; - } - - return LT_FINISH; -} - -static void sub_81CBBB8(void) -{ - struct PokenavListTemplate template; - template.list.matchCallEntries = sub_81CAE94(); - template.unk4 = GetNumberRegistered(); - template.unk8 = 4; - template.unk6 = 0; - template.unk9 = 13; - template.unkA = 16; - template.unkB = 1; - template.unkC = 8; - template.unkD = 3; - template.unkE = 7; - template.listFunc.unk10_2 = BufferMatchCallNameAndDesc; - template.unk14 = TryDrawRematchPokeballIcon; - sub_81C81D4(&gUnknown_0862278C[2], &template, 2); - CreateTask(sub_81CBC64, 7); -} - -static void sub_81CBC1C(void) -{ - sub_81C8234(); - DestroyTask(FindTaskIdByFunc(sub_81CBC64)); -} - -static void sub_81CBC38(int arg0) -{ - u8 taskId = FindTaskIdByFunc(sub_81CBC64); - if (taskId != 0xFF) - gTasks[taskId].data[15] = arg0; -} - -static void sub_81CBC64(u8 taskId) -{ - s16 *taskData = gTasks[taskId].data; - if (taskData[15]) - { - taskData[0] += 4; - taskData[0] &= 0x7F; - taskData[1] = gSineTable[taskData[0]] >> 4; - sub_81C79BC(gUnknown_08622720, gUnknown_08622720 + 0x10, 0x10, 0x10, taskData[1], gPlttBufferUnfaded + 0x50); - if (!gPaletteFade.active) - CpuCopy32(gPlttBufferUnfaded + 0x50, gPlttBufferFaded + 0x50, 0x20); - } -} - -static void TryDrawRematchPokeballIcon(u16 windowId, u32 rematchId, u32 arg2) -{ - u8 bg = GetWindowAttribute(windowId, WINDOW_BG); - u16 *tilemap = GetBgTilemapBuffer(bg); - tilemap += arg2 * 0x40 + 0x1D; - if (ShouldDrawRematchPokeballIcon(rematchId)) - { - tilemap[0] = 0x5000; - tilemap[0x20] = 0x5001; - } - else - { - tilemap[0] = 0x5002; - tilemap[0x20] = 0x5002; - } -} - -void ClearRematchPokeballIcon(u16 windowId, u32 arg0) -{ - u8 bg = GetWindowAttribute(windowId, WINDOW_BG); - u16 *tilemap = GetBgTilemapBuffer(bg); - tilemap += arg0 * 0x40 + 0x1D; - tilemap[0] = 0x5002; - tilemap[0x20] = 0x5002; -} - -static void DrawMatchCallLeftColumnWindows(struct Pokenav4Struct *state) -{ - state->locWindowId = AddWindow(&sMatchCallLocationWindowTemplate); - state->infoBoxWindowId = AddWindow(&sMatchCallInfoBoxWindowTemplate); - FillWindowPixelBuffer(state->locWindowId, PIXEL_FILL(1)); - PutWindowTilemap(state->locWindowId); - FillWindowPixelBuffer(state->infoBoxWindowId, PIXEL_FILL(1)); - PutWindowTilemap(state->infoBoxWindowId); - CopyWindowToVram(state->locWindowId, 1); -} - -static void UpdateMatchCallInfoBox(struct Pokenav4Struct *state) -{ - FillWindowPixelBuffer(state->infoBoxWindowId, PIXEL_FILL(1)); - PrintNumberRegisteredLabel(state->infoBoxWindowId); - PrintNumberRegistered(state->infoBoxWindowId); - PrintNumberOfBattlesLabel(state->infoBoxWindowId); - PrintNumberOfBattles(state->infoBoxWindowId); - CopyWindowToVram(state->infoBoxWindowId, 2); -} - -static void PrintNumberRegisteredLabel(u16 windowId) -{ - PrintMatchCallInfoLabel(windowId, gText_NumberRegistered, 0); -} - -static void PrintNumberRegistered(u16 windowId) -{ - u8 str[3]; - ConvertIntToDecimalStringN(str, GetNumberRegistered(), STR_CONV_MODE_LEFT_ALIGN, 3); - PrintMatchCallInfoNumber(windowId, str, 1); -} - -static void PrintNumberOfBattlesLabel(u16 windowId) -{ - PrintMatchCallInfoLabel(windowId, gText_NumberOfBattles, 2); -} - -static void PrintNumberOfBattles(u16 windowId) -{ - u8 str[5]; - int numTrainerBattles = GetGameStat(GAME_STAT_TRAINER_BATTLES); - if (numTrainerBattles > 99999) - numTrainerBattles = 99999; - - ConvertIntToDecimalStringN(str, numTrainerBattles, STR_CONV_MODE_LEFT_ALIGN, 5); - PrintMatchCallInfoNumber(windowId, str, 3); -} - -static void PrintMatchCallInfoLabel(u16 windowId, const u8 *str, int top) -{ - int y = top * 16 + 1; - AddTextPrinterParameterized(windowId, 7, str, 2, y, TEXT_SPEED_FF, NULL); -} - -static void PrintMatchCallInfoNumber(u16 windowId, const u8 *str, int top) -{ - int x = GetStringRightAlignXOffset(7, str, 86); - int y = top * 16 + 1; - AddTextPrinterParameterized(windowId, 7, str, x, y, TEXT_SPEED_FF, NULL); -} - -static void PrintMatchCallLocation(struct Pokenav4Struct *state, int arg1) -{ - u8 mapName[32]; - int x; - int index = GetSelectedMatchCall() + arg1; - int mapSec = GetMatchCallMapSec(index); - if (mapSec != MAPSEC_NONE) - GetMapName(mapName, mapSec, 0); - else - StringCopy(mapName, gText_Unknown); - - x = GetStringCenterAlignXOffset(7, mapName, 88); - FillWindowPixelBuffer(state->locWindowId, PIXEL_FILL(1)); - AddTextPrinterParameterized(state->locWindowId, 7, mapName, x, 1, 0, NULL); -} - -static void PrintMatchCallSelectionOptions(struct Pokenav4Struct *state) -{ - u32 i; - - FillWindowPixelBuffer(state->infoBoxWindowId, PIXEL_FILL(1)); - for (i = 0; i < MATCH_CALL_OPTION_COUNT; i++) - { - int optionText = GetMatchCallOptionId(i); - if (optionText == MATCH_CALL_OPTION_COUNT) - break; - - AddTextPrinterParameterized(state->infoBoxWindowId, 7, sMatchCallOptionTexts[optionText], 16, i * 16 + 1, TEXT_SPEED_FF, NULL); - } - - CopyWindowToVram(state->infoBoxWindowId, 2); -} - -static bool32 sub_81CBFC4(struct Pokenav4Struct *state) -{ - if (!IsDma3ManagerBusyWithBgCopy()) - { - sub_81CC2F0(state, GetMatchCallOptionCursorPos()); - return FALSE; - } - - return TRUE; -} - -static void UpdateWindowsReturnToTrainerList(struct Pokenav4Struct *state) -{ - CloseMatchCallSelectOptionsWindow(state); - UpdateMatchCallInfoBox(state); -} - -static bool32 IsDma3ManagerBusyWithBgCopy1(struct Pokenav4Struct *state) -{ - return IsDma3ManagerBusyWithBgCopy(); -} - -static void UpdateWindowsToShowCheckPage(struct Pokenav4Struct *state) -{ - CloseMatchCallSelectOptionsWindow(state); - FillWindowPixelBuffer(state->infoBoxWindowId, PIXEL_FILL(1)); - CopyWindowToVram(state->infoBoxWindowId, 2); -} - -static void sub_81CC034(struct Pokenav4Struct *state) -{ - state->msgBoxWindowId = AddWindow(&sCallMsgBoxWindowTemplate); - sub_8197184(state->msgBoxWindowId, 1, 4); - sub_81C7B40(); -} - -static void DrawMsgBoxForMatchCallMsg(struct Pokenav4Struct *state) -{ - struct Sprite *sprite; - sub_8197184(state->msgBoxWindowId, 1, 4); - sub_81971C4(state->msgBoxWindowId, 1, 4); - FillWindowPixelBuffer(state->msgBoxWindowId, PIXEL_FILL(1)); - PutWindowTilemap(state->msgBoxWindowId); - CopyWindowToVram(state->msgBoxWindowId, 3); - sprite = PauseSpinningPokenavSprite(); - sprite->pos1.x = 24; - sprite->pos1.y = 112; - sprite->pos2.y = 0; -} - -static void DrawMsgBoxForCloseByMsg(struct Pokenav4Struct *state) -{ - LoadUserWindowBorderGfx(state->msgBoxWindowId, 1, 0x40); - DrawTextBorderOuter(state->msgBoxWindowId, 1, 4); - FillWindowPixelBuffer(state->msgBoxWindowId, PIXEL_FILL(1)); - PutWindowTilemap(state->msgBoxWindowId); - CopyWindowToVram(state->msgBoxWindowId, 3); -} - -static bool32 IsDma3ManagerBusyWithBgCopy2(struct Pokenav4Struct *state) -{ - return IsDma3ManagerBusyWithBgCopy(); -} - -static void PrintCallingDots(struct Pokenav4Struct *state) -{ - AddTextPrinterParameterized(state->msgBoxWindowId, 1, sText_CallingDots, 32, 1, 1, NULL); -} - -static bool32 WaitForCallingDotsText(struct Pokenav4Struct *state) -{ - RunTextPrinters(); - return IsTextPrinterActive(state->msgBoxWindowId); -} - -static void PrintTrainerIsCloseBy(struct Pokenav4Struct *state) -{ - AddTextPrinterParameterized(state->msgBoxWindowId, 1, gText_TrainerCloseBy, 0, 1, 1, NULL); -} - -static bool32 WaitForTrainerIsCloseByText(struct Pokenav4Struct *state) -{ - RunTextPrinters(); - return IsTextPrinterActive(state->msgBoxWindowId); -} - -static void PrintMatchCallMessage(struct Pokenav4Struct *state) -{ - int index = GetSelectedMatchCall(); - const u8 *str = GetMatchCallMessageText(index, &state->unkF); - u8 speed = GetPlayerTextSpeedDelay(); - AddTextPrinterParameterized(state->msgBoxWindowId, 1, str, 32, 1, speed, NULL); -} - -static bool32 WaitForMatchCallMessageText(struct Pokenav4Struct *state) -{ - if (gMain.heldKeys & A_BUTTON) - gTextFlags.canABSpeedUpPrint = 1; - else - gTextFlags.canABSpeedUpPrint = 0; - - RunTextPrinters(); - return IsTextPrinterActive(state->msgBoxWindowId); -} - -static void DrawSpinningPokenavForCall(struct Pokenav4Struct *state) -{ - ResumeSpinningPokenavSprite(); - FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 32, 20); - CopyBgTilemapBufferToVram(1); -} - -static bool32 WaitForSpinningPokenav(struct Pokenav4Struct *state) -{ - return IsDma3ManagerBusyWithBgCopy(); -} - -static void sub_81CC214(void) -{ - int i; - u8 paletteNum; - struct SpriteSheet spriteSheet; - struct Pokenav4Struct *state = GetSubstructPtr(6); - - for (i = 0; i < ARRAY_COUNT(gUnknown_08622810); i++) - LoadCompressedSpriteSheet(&gUnknown_08622810[i]); - - Pokenav_AllocAndLoadPalettes(gUnknown_08622818); - state->optionsCursorSprite = NULL; - spriteSheet.data = state->unk1828; - spriteSheet.size = 0x800; - spriteSheet.tag = 8; - state->unk1824 = (u8 *)OBJ_VRAM0 + LoadSpriteSheet(&spriteSheet) * 0x20; - paletteNum = AllocSpritePalette(13); - state->unk1A = 0x100 + paletteNum * 0x10; - state->trainerPicSprite = CreateTrainerPicSprite(); - state->trainerPicSprite->invisible = TRUE; -} - -static void sub_81CC2B4(void) -{ - struct Pokenav4Struct *state = GetSubstructPtr(6); - if (state->optionsCursorSprite) - DestroySprite(state->optionsCursorSprite); - if (state->trainerPicSprite) - DestroySprite(state->trainerPicSprite); - - FreeSpriteTilesByTag(8); - FreeSpriteTilesByTag(7); - FreeSpritePaletteByTag(12); - FreeSpritePaletteByTag(13); -} - -static void sub_81CC2F0(struct Pokenav4Struct *state, int top) -{ - if (!state->optionsCursorSprite) - { - u8 spriteId = CreateSprite(&sOptionsCursorSpriteTemplate, 4, 80, 5); - state->optionsCursorSprite = &gSprites[spriteId]; - UpdateCursorGfxPos(state, top); - } -} - -static void CloseMatchCallSelectOptionsWindow(struct Pokenav4Struct *state) -{ - DestroySprite(state->optionsCursorSprite); - state->optionsCursorSprite = NULL; -} - -static void UpdateCursorGfxPos(struct Pokenav4Struct *state, int top) -{ - state->optionsCursorSprite->pos2.y = top * 16; -} - -void SpriteCB_OptionsCursor(struct Sprite *sprite) -{ - if (++sprite->data[0] > 3) - { - sprite->data[0] = 0; - sprite->pos2.x = (sprite->pos2.x + 1) & 0x7; - } -} - -static struct Sprite *CreateTrainerPicSprite(void) -{ - u8 spriteId = CreateSprite(&sTrainerPicSpriteTemplate, 44, 104, 6); - return &gSprites[spriteId]; -} - -static void LoadCheckPageTrainerPic(struct Pokenav4Struct *state) -{ - u16 cursor; - int trainerPic = GetMatchCallTrainerPic(GetSelectedMatchCall()); - if (trainerPic >= 0) - { - DecompressPicFromTable(&gTrainerFrontPicTable[trainerPic], state->unk1828, SPECIES_NONE); - LZ77UnCompWram(gTrainerFrontPicPaletteTable[trainerPic].data, state->unk2028); - cursor = RequestDma3Copy(state->unk1828, state->unk1824, 0x800, 1); - LoadPalette(state->unk2028, state->unk1A, 0x20); - state->trainerPicSprite->data[0] = 0; - state->trainerPicSprite->data[7] = cursor; - state->trainerPicSprite->callback = SpriteCB_TrainerPicSlideOnscreen; - } -} - -static void TrainerPicSlideOffscreen(struct Pokenav4Struct *state) -{ - state->trainerPicSprite->callback = SpriteCB_TrainerPicSlideOffscreen; -} - -static bool32 WaitForTrainerPic(struct Pokenav4Struct *state) -{ - return state->trainerPicSprite->callback != SpriteCallbackDummy; -} - -static void SpriteCB_TrainerPicSlideOnscreen(struct Sprite *sprite) -{ - switch (sprite->data[0]) - { - case 0: - if (CheckForSpaceForDma3Request(sprite->data[7]) != -1) - { - sprite->pos2.x = -80; - sprite->invisible = FALSE; - sprite->data[0]++; - } - break; - case 1: - sprite->pos2.x += 8; - if (sprite->pos2.x >= 0) - { - sprite->pos2.x = 0; - sprite->callback = SpriteCallbackDummy; - } - break; - } -} - -static void SpriteCB_TrainerPicSlideOffscreen(struct Sprite *sprite) -{ - sprite->pos2.x -= 8; - if (sprite->pos2.x <= -80) - { - sprite->invisible = TRUE; - sprite->callback = SpriteCallbackDummy; - } -} diff --git a/src/pokenav_unk_5.c b/src/pokenav_unk_5.c deleted file mode 100755 index be30ca94d..000000000 --- a/src/pokenav_unk_5.c +++ /dev/null @@ -1,729 +0,0 @@ -#include "global.h" -#include "bg.h" -#include "decompress.h" -#include "landmark.h" -#include "main.h" -#include "menu.h" -#include "palette.h" -#include "pokenav.h" -#include "region_map.h" -#include "sound.h" -#include "sprite.h" -#include "string_util.h" -#include "task.h" -#include "text_window.h" -#include "window.h" -#include "constants/songs.h" - -struct Pokenav5Struct -{ - u8 filler0[0xC]; - bool32 unkC; - u32 (*unk10)(struct Pokenav5Struct *); -}; - -struct Pokenav5Struct_2 -{ - bool32 (*unk0)(void); - u32 unk4; - u16 unk8; - struct Sprite *cityFeatureTextSprites[3]; - u8 unk18[0x800]; - u8 cityZoomPics[22][0xC8]; -}; - -struct CityMapEntry -{ - u16 mapSecId; - u16 index; - const u32 *tilemap; -}; - -static u32 sub_81CC568(struct Pokenav5Struct *); -static u32 sub_81CC5B4(struct Pokenav5Struct *); -static u32 sub_81CC5DC(struct Pokenav5Struct *); -static u32 sub_81CC6F4(s32); -static u32 sub_81CCD34(s32); -static bool32 sub_81CC6BC(void); -static void sub_81CC9EC(void); -static void sub_81CC9C0(void); -static void sub_81CCD10(void); -static bool32 sub_81CCD24(void); -static void sub_81CCA1C(struct Pokenav5Struct_2 *); -static bool32 sub_81CCAFC(void); -static void sub_81CCB0C(struct Pokenav5Struct_2 *); -static bool32 sub_81CCC4C(struct Pokenav5Struct_2 *); -static void sub_81CCC5C(int); -static bool32 sub_81CCC88(void); -static void sub_81CCE58(void); -static void sub_81CCD70(struct Pokenav5Struct_2 *, int, int); -static void sub_81CCDE8(struct Pokenav5Struct_2 *, int, int); -static void sub_81CCFA4(int); -static void sub_81CCC9C(u8 taskId); -static void sub_81CCF78(void); -void sub_81CCEF4(struct Sprite *sprite); -u32 sub_81CC848(s32); -u32 sub_81CC878(s32); -u32 sub_81CC8D8(s32); -u32 sub_81CC95C(s32); - -extern const u16 gHoennMapZoomIcons_Pal[]; -extern const struct SpriteTemplate gUnknown_086231D0; -extern const u32 gHoennMapZoomIcons_Gfx[]; - -const u16 gUnknown_08622868[] = INCBIN_U16("graphics/pokenav/8622868.gbapal"); -const u32 gUnknown_08622888[] = INCBIN_U32("graphics/pokenav/zoom_tiles.4bpp.lz"); - -#include "data/region_map/city_map_tilemaps.h" - - -const struct BgTemplate gUnknown_086230D8[3] = -{ - { - .bg = 1, - .charBaseIndex = 1, - .mapBaseIndex = 0x1F, - .screenSize = 0, - .paletteMode = 0, - .priority = 1, - .baseTile = 0 - }, - { - .bg = 2, - .charBaseIndex = 2, - .mapBaseIndex = 0x06, - .screenSize = 0, - .paletteMode = 0, - .priority = 2, - .baseTile = 0 - }, - { - .bg = 2, - .charBaseIndex = 0, - .mapBaseIndex = 0x00, - .screenSize = 2, - .paletteMode = 0, - .priority = 3, - .baseTile = 0 - }, -}; - -const LoopedTask gUnknown_086230E4[] = -{ - NULL, - sub_81CC848, - sub_81CC878, - sub_81CC8D8, - sub_81CC95C -}; - -const struct CompressedSpriteSheet gUnknown_086230F8[1] = -{ - {gHoennMapZoomIcons_Gfx, 0x800, 6} -}; - -const struct SpritePalette gUnknown_08623100[] = -{ - {gHoennMapZoomIcons_Pal, 11}, - {} -}; - -const struct WindowTemplate gUnknown_08623110 = -{ - .bg = 1, - .tilemapLeft = 17, - .tilemapTop = 4, - .width = 12, - .height = 13, - .paletteNum = 1, - .baseBlock = 0x4C -}; - -#include "data/region_map/city_map_entries.h" - -const struct OamData gUnknown_086231C8 = -{ - .y = 0, - .affineMode = ST_OAM_AFFINE_OFF, - .objMode = ST_OAM_OBJ_NORMAL, - .bpp = ST_OAM_4BPP, - .shape = SPRITE_SHAPE(32x8), - .x = 0, - .size = SPRITE_SIZE(32x8), - .tileNum = 0, - .priority = 1, - .paletteNum = 0, -}; - -const struct SpriteTemplate gUnknown_086231D0 = -{ - .tileTag = 6, - .paletteTag = 11, - .oam = &gUnknown_086231C8, - .anims = gDummySpriteAnimTable, - .images = NULL, - .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_81CCEF4, -}; - -u32 PokenavCallback_Init_6(void) -{ - struct Pokenav5Struct *state = AllocSubstruct(3, sizeof(struct Pokenav5Struct)); - if (!state) - return FALSE; - - if (!AllocSubstruct(16, sizeof(struct RegionMap))) - return FALSE; - - state->unkC = sub_8124668(gMapHeader.regionMapSectionId); - if (!state->unkC) - state->unk10 = sub_81CC568; - else - state->unk10 = sub_81CC5B4; - - return TRUE; -} - -void sub_81CC524(void) -{ - gSaveBlock2Ptr->regionMapZoom = sub_8124658(); - FreePokenavSubstruct(16); - FreePokenavSubstruct(3); -} - -u32 sub_81CC554(void) -{ - struct Pokenav5Struct *state = GetSubstructPtr(3); - return state->unk10(state); -} - -static u32 sub_81CC568(struct Pokenav5Struct *state) -{ - switch (sub_81230AC()) - { - case 3: - return 1; - case 4: - if (!sub_8124658()) - return 3; - return 2; - case 5: - state->unk10 = sub_81CC5DC; - return 4; - } - - return 0; -} - -static u32 sub_81CC5B4(struct Pokenav5Struct *state) -{ - if (gMain.newKeys & B_BUTTON) - { - state->unk10 = sub_81CC5DC; - return 4; - } - - return 0; -} - -static u32 sub_81CC5DC(struct Pokenav5Struct *state) -{ - return POKENAV_MENU_1; -} - -bool32 sub_81CC5E4(void) -{ - struct Pokenav5Struct *state = GetSubstructPtr(3); - return state->unkC; -} - -bool32 sub_81CC5F4(void) -{ - struct Pokenav5Struct_2 *state = AllocSubstruct(4, sizeof(struct Pokenav5Struct_2)); - if (!state) - return FALSE; - - state->unk4 = CreateLoopedTask(sub_81CC6F4, 1); - state->unk0 = sub_81CC6BC; - return TRUE; -} - -void sub_81CC62C(s32 index) -{ - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - state->unk4 = CreateLoopedTask(gUnknown_086230E4[index], 1); - state->unk0 = sub_81CC6BC; -} - -u32 sub_81CC65C(void) -{ - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - return state->unk0(); -} - -void sub_81CC670(void) -{ - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - FreeRegionMapIconResources(); - sub_81CC9EC(); - RemoveWindow(state->unk8); - FreePokenavSubstruct(16); - FreePokenavSubstruct(4); - SetPokenavVBlankCallback(); - SetBgMode(0); -} - -static void sub_81CC6A4(void) -{ - TransferPlttBuffer(); - LoadOam(); - ProcessSpriteCopyRequests(); - UpdateRegionMapVideoRegs(); -} - -static bool32 sub_81CC6BC(void) -{ - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - return IsLoopedTaskActive(state->unk4); -} - -static bool8 sub_81CC6D0(void) -{ - if (sub_81CC5E4()) - return FALSE; - - return gSaveBlock2Ptr->regionMapZoom == 1; -} - -static u32 sub_81CC6F4(s32 taskState) -{ - int var0; - struct RegionMap *regionMap; - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - switch (taskState) - { - case 0: - SetVBlankCallback_(NULL); - HideBg(1); - HideBg(2); - HideBg(3); - SetBgMode(1); - InitBgTemplates(gUnknown_086230D8, ARRAY_COUNT(gUnknown_086230D8) - 1); - regionMap = GetSubstructPtr(16); - sub_8122CF8(regionMap, &gUnknown_086230D8[1], sub_81CC6D0()); - sub_81CC9C0(); - return 0; - case 1: - if (sub_8122DB0()) - return 2; - - if (!sub_81CC5E4()) - { - CreateRegionMapPlayerIcon(4, 9); - CreateRegionMapCursor(5, 10); - sub_812454C(); - } - else - { - sub_8123030(0, 6); - } - return 0; - case 2: - sub_81CCD10(); - return 1; - case 3: - if (sub_81CCD24()) - return 2; - - sub_81CCA1C(state); - return 1; - case 4: - if (sub_81CCAFC()) - return 2; - - sub_81CCB0C(state); - sub_81C7B40(); - return 0; - case 5: - if (sub_81CCC4C(state)) - return 2; - - ShowBg(1); - ShowBg(2); - SetVBlankCallback_(sub_81CC6A4); - return 0; - case 6: - if (!sub_81CC6D0()) - var0 = 4; - else - var0 = 5; - - LoadLeftHeaderGfxForIndex(var0); - sub_81C7FA0(var0, 1, 1); - sub_81C7AC0(1); - return 0; - case 7: - if (IsPaletteFadeActive() || sub_81C8010()) - return 2; - return 1; - default: - return 4; - } -} - -u32 sub_81CC848(s32 taskState) -{ - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - switch (taskState) - { - case 0: - sub_81CCB0C(state); - return 0; - case 1: - if (sub_81CCC4C(state)) - return 2; - break; - } - - return 4; -} - -u32 sub_81CC878(s32 taskState) -{ - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - sub_81CCC5C(0); - sub_8123418(); - return 0; - case 1: - if (sub_8123514() || sub_81CCC88()) - return 2; - - PrintHelpBarText(HELPBAR_MAP_ZOOMED_OUT); - return 0; - case 2: - if (WaitForHelpBar()) - return 2; - - sub_81C7E14(4); - break; - } - - return 4; -} - -u32 sub_81CC8D8(s32 taskState) -{ - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - sub_81CCB0C(state); - return 0; - case 1: - if (sub_81CCC4C(state)) - return 2; - - sub_81CCC5C(1); - sub_8123418(); - return 0; - case 2: - if (sub_8123514() || sub_81CCC88()) - return 2; - - PrintHelpBarText(HELPBAR_MAP_ZOOMED_IN); - return 0; - case 3: - if (WaitForHelpBar()) - return 2; - - sub_81C7E14(5); - break; - } - - return 4; -} - -u32 sub_81CC95C(s32 taskState) -{ - switch (taskState) - { - case 0: - PlaySE(SE_SELECT); - sub_81C7AC0(0); - return 0; - case 1: - if (IsPaletteFadeActive()) - return 2; - - sub_81C7FDC(); - sub_81C78A0(); - return 0; - case 2: - if (MainMenuLoopedTaskIsBusy()) - return 2; - - HideBg(1); - HideBg(2); - HideBg(3); - return 0; - } - - return 4; -} - -static void sub_81CC9C0(void) -{ - int i; - for (i = 0; i < ARRAY_COUNT(gUnknown_086230F8); i++) - LoadCompressedSpriteSheet(&gUnknown_086230F8[i]); - - Pokenav_AllocAndLoadPalettes(gUnknown_08623100); - sub_81CCE58(); -} - -static void sub_81CC9EC(void) -{ - int i; - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - FreeSpriteTilesByTag(6); - FreeSpritePaletteByTag(11); - for (i = 0; i < 3; i++) - DestroySprite(state->cityFeatureTextSprites[i]); -} - -static void sub_81CCA1C(struct Pokenav5Struct_2 *state) -{ - sub_8199DF0(1, PIXEL_FILL(0), 0x40, 1); - sub_8199DF0(1, PIXEL_FILL(1), 0x41, 1); - CpuFill16(0x1040, state->unk18, 0x800); - SetBgTilemapBuffer(1, state->unk18); - state->unk8 = AddWindow(&gUnknown_08623110); - LoadUserWindowBorderGfx_(state->unk8, 0x42, 0x40); - DrawTextBorderOuter(state->unk8, 0x42, 4); - decompress_and_copy_tile_data_to_vram(1, gUnknown_08622888, 0, 0, 0); - FillWindowPixelBuffer(state->unk8, PIXEL_FILL(1)); - PutWindowTilemap(state->unk8); - CopyWindowToVram(state->unk8, 3); - CopyPaletteIntoBufferUnfaded(gUnknown_08622868, 0x10, 0x20); - CopyPaletteIntoBufferUnfaded(gHoennMapZoomIcons_Pal, 0x30, 0x20); - if (!sub_8124658()) - ChangeBgY(1, -0x6000, 0); - else - ChangeBgY(1, 0, 0); - - ChangeBgX(1, 0, 0); -} - -static bool32 sub_81CCAFC(void) -{ - return free_temp_tile_data_buffers_if_possible(); -} - -static void sub_81CCB0C(struct Pokenav5Struct_2 *state) -{ - struct RegionMap *regionMap = GetSubstructPtr(16); - switch (regionMap->iconDrawType) - { - case MAPSECTYPE_CITY_CANFLY: - FillWindowPixelBuffer(state->unk8, PIXEL_FILL(1)); - PutWindowRectTilemap(state->unk8, 0, 0, 12, 2); - AddTextPrinterParameterized(state->unk8, 7, regionMap->mapSecName, 0, 1, TEXT_SPEED_FF, NULL); - sub_81CCD70(state, regionMap->mapSecId, regionMap->posWithinMapSec); - CopyWindowToVram(state->unk8, 3); - sub_81CCFA4(0); - break; - case MAPSECTYPE_CITY_CANTFLY: - FillWindowPixelBuffer(state->unk8, PIXEL_FILL(1)); - PutWindowRectTilemap(state->unk8, 0, 0, 12, 2); - AddTextPrinterParameterized(state->unk8, 7, regionMap->mapSecName, 0, 1, TEXT_SPEED_FF, NULL); - FillBgTilemapBufferRect(1, 0x1041, 17, 6, 12, 11, 17); - CopyWindowToVram(state->unk8, 3); - sub_81CCFA4(1); - break; - case MAPSECTYPE_PLAIN: - case MAPSECTYPE_BATTLE_FRONTIER: - FillWindowPixelBuffer(state->unk8, PIXEL_FILL(1)); - PutWindowTilemap(state->unk8); - AddTextPrinterParameterized(state->unk8, 7, regionMap->mapSecName, 0, 1, TEXT_SPEED_FF, NULL); - sub_81CCDE8(state, regionMap->mapSecId, regionMap->posWithinMapSec); - CopyWindowToVram(state->unk8, 3); - sub_81CCFA4(1); - break; - case MAPSECTYPE_NONE: - FillBgTilemapBufferRect(1, 0x1041, 17, 4, 12, 13, 17); - CopyBgTilemapBufferToVram(1); - sub_81CCFA4(1); - break; - } -} - -static bool32 sub_81CCC4C(struct Pokenav5Struct_2 *state) -{ - return IsDma3ManagerBusyWithBgCopy(); -} - -static void sub_81CCC5C(int arg0) -{ - u8 taskId = CreateTask(sub_81CCC9C, 3); - gTasks[taskId].data[0] = arg0; -} - -static bool32 sub_81CCC88(void) -{ - return FuncIsActiveTask(sub_81CCC9C); -} - -static void sub_81CCC9C(u8 taskId) -{ - if (gTasks[taskId].data[0]) - { - if (ChangeBgY(1, 0x480, 1) >= 0) - { - ChangeBgY(1, 0, 0); - DestroyTask(taskId); - } - - sub_81CCF78(); - } - else - { - if (ChangeBgY(1, 0x480, 2) <= -0x6000) - { - ChangeBgY(1, -0x6000, 0); - DestroyTask(taskId); - } - - sub_81CCF78(); - } -} - -static void sub_81CCD10(void) -{ - CreateLoopedTask(sub_81CCD34, 1); -} - -static bool32 sub_81CCD24(void) -{ - return FuncIsActiveLoopedTask(sub_81CCD34); -} - -static u32 sub_81CCD34(s32 taskState) -{ - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - if (taskState < (int)ARRAY_COUNT(gPokenavCityMaps)) - { - LZ77UnCompWram(gPokenavCityMaps[taskState].tilemap, state->cityZoomPics[taskState]); - return 1; - } - - return 4; -} - -static void sub_81CCD70(struct Pokenav5Struct_2 *state, int mapSecId, int pos) -{ - int i; - for (i = 0; i < (int)ARRAY_COUNT(gPokenavCityMaps) && (gPokenavCityMaps[i].mapSecId != mapSecId || gPokenavCityMaps[i].index != pos); i++) - ; - - if (i == ARRAY_COUNT(gPokenavCityMaps)) - return; - - FillBgTilemapBufferRect_Palette0(1, 0x1041, 17, 6, 12, 11); - CopyToBgTilemapBufferRect(1, state->cityZoomPics[i], 18, 6, 10, 10); -} - -static void sub_81CCDE8(struct Pokenav5Struct_2 *state, int mapSecId, int pos) -{ - int i = 0; - while (1) - { - const u8 *landmarkName = GetLandmarkName(mapSecId, pos, i); - if (!landmarkName) - break; - - StringCopyPadded(gStringVar1, landmarkName, CHAR_SPACE, 12); - AddTextPrinterParameterized(state->unk8, 7, gStringVar1, 0, i * 16 + 17, TEXT_SPEED_FF, NULL); - i++; - } -} - -static void sub_81CCE58(void) -{ - int i; - int y; - struct Sprite *sprite; - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - - if (!sub_8124658()) - y = 228; - else - y = 132; - - for (i = 0; i < 3; i++) - { - u8 spriteId = CreateSprite(&gUnknown_086231D0, 152 + i * 32, y, 8); - sprite = &gSprites[spriteId]; - sprite->data[0] = 0; - sprite->data[1] = i * 4; - sprite->data[2] = sprite->oam.tileNum; - sprite->data[3] = 150; - sprite->data[4] = i * 4; - sprite->oam.tileNum += i * 4; - state->cityFeatureTextSprites[i] = sprite; - } -} - -void sub_81CCEF4(struct Sprite *sprite) -{ - if (sprite->data[3]) - { - sprite->data[3]--; - return; - } - - if (++sprite->data[0] > 11) - sprite->data[0] = 0; - - if (++sprite->data[1] > 60) - sprite->data[1] = 0; - - sprite->oam.tileNum = sprite->data[2] + sprite->data[1]; - if (sprite->data[5] < 4) - { - if (sprite->data[0] == 0) - { - sprite->data[5]++; - sprite->data[3] = 120; - } - } - else - { - if (sprite->data[1] == sprite->data[4]) - { - sprite->data[5] = 0; - sprite->data[0] = 0; - sprite->data[3] = 120; - } - } -} - -static void sub_81CCF78(void) -{ - int i; - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - int y = 132 - (GetBgY(1) >> 8); - for (i = 0; i < 3; i++) - state->cityFeatureTextSprites[i]->pos1.y = y; -} - -static void sub_81CCFA4(int invisible) -{ - int i; - struct Pokenav5Struct_2 *state = GetSubstructPtr(4); - for (i = 0; i < 3; i++) - state->cityFeatureTextSprites[i]->invisible = invisible; -} diff --git a/src/pokenav_unk_6.c b/src/pokenav_unk_6.c deleted file mode 100644 index b16aec16e..000000000 --- a/src/pokenav_unk_6.c +++ /dev/null @@ -1,625 +0,0 @@ -#include "global.h" -#include "data.h" -#include "decompress.h" -#include "main.h" -#include "menu_specialized.h" -#include "mon_markings.h" -#include "pokenav.h" -#include "pokemon.h" -#include "pokemon_storage_system.h" -#include "sound.h" -#include "string_util.h" -#include "strings.h" -#include "text.h" -#include "constants/songs.h" -#include "constants/species.h" - -struct PokenavSub11 -{ - u32 monPal[3][0x20]; - u8 fill[0x180]; - u32 monPicGfx[3][0x800]; - u8 unk6300; - s16 unk6302; - u32 (*unk6304)(struct PokenavSub11 *); - u8 fill2[0x6320 - 0x6308]; - u8 unk6320[3][24]; - u8 unk6368[3][64]; - struct UnknownStruct_81D1ED4 unk6428; - u8 unk6780[3]; - u8 unk6783[3]; - s8 unk6786; - s8 unk6787; - s8 unk6788; - s8 unk6789; - u8 unk678A; -}; - -void sub_81CD970(void); -void sub_81CD9F8(void); -u32 sub_81CD08C(struct PokenavSub11 *structPtr); -u32 sub_81CD19C(struct PokenavSub11 *structPtr); -u32 sub_81CD110(struct PokenavSub11 *structPtr); -u8 sub_81CD1E4(struct PokenavSub11 *structPtr); -u8 sub_81CD258(u8 arg0); -void sub_81CD824(s16 arg0, u8 arg1); -void sub_81CDA1C(s16 arg0, u8 arg1); -void sub_81CDB98(s16 arg0, u8 arg1); - -// code -bool32 PokenavCallback_Init_7(void) -{ - struct PokenavSub11 *structPtr = AllocSubstruct(11, sizeof(struct PokenavSub11)); - - if (structPtr == NULL) - return FALSE; - - sub_81D1ED4(&structPtr->unk6428); - sub_81CD970(); - gKeyRepeatStartDelay = 20; - structPtr->unk6304 = sub_81CD08C; - return TRUE; -} - -bool32 PokenavCallback_Init_9(void) -{ - struct PokenavSub11 *structPtr = AllocSubstruct(11, sizeof(struct PokenavSub11)); - - if (structPtr == NULL) - return FALSE; - - sub_81D1ED4(&structPtr->unk6428); - sub_81CD9F8(); - gKeyRepeatStartDelay = 20; - structPtr->unk6304 = sub_81CD08C; - return TRUE; -} - -u32 sub_81CD070(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - - return structPtr->unk6304(structPtr); -} - -u32 sub_81CD08C(struct PokenavSub11 *structPtr) -{ - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - u32 ret = sub_81CD1E4(structPtr); - - if (ret == 0) - { - if (gMain.newKeys & B_BUTTON) - { - PlaySE(SE_SELECT); - structPtr->unk6304 = sub_81CD19C; - ret = 2; - } - else if (gMain.newKeys & A_BUTTON) - { - if (structPtr->unk6300 == 0) - { - if (unkPtr->unk2 == unkPtr->unk0 - 1) - { - PlaySE(SE_SELECT); - structPtr->unk6304 = sub_81CD19C; - ret = 2; - } - } - else - { - PlaySE(SE_SELECT); - ret = 5; - structPtr->unk6304 = sub_81CD110; - } - } - } - - return ret; -} - -u32 sub_81CD110(struct PokenavSub11 *structPtr) -{ - struct PokenavSub18 *unkPtr; - u8 markings; - u32 ret = 0, boxId, monId; - - if (!sub_811FBA4()) - { - structPtr->unk6783[structPtr->unk6786] = sub_81CEF14(); - unkPtr = GetSubstructPtr(18); - boxId = unkPtr->unk4[unkPtr->unk2].boxId; - monId = unkPtr->unk4[unkPtr->unk2].monId; - markings = structPtr->unk6783[structPtr->unk6786]; - - if (boxId == TOTAL_BOXES_COUNT) - SetMonData(&gPlayerParty[monId], MON_DATA_MARKINGS, &markings); - else - SetBoxMonDataAt(boxId, monId, MON_DATA_MARKINGS, &markings); - - structPtr->unk6304 = sub_81CD08C; - ret = 6; - } - - return ret; -} - -u32 sub_81CD19C(struct PokenavSub11 *structPtr) -{ - if (structPtr->unk6300 == 0) - return 100002; - else - return 100010; -} - -void sub_81CD1C0(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - if (structPtr->unk6300 == 0) - FreePokenavSubstruct(18); - - FreePokenavSubstruct(11); -} - -u8 sub_81CD1E4(struct PokenavSub11 *structPtr) -{ - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - u8 ret = 0; - - if (gMain.heldKeys & DPAD_UP) - { - if (structPtr->unk6300 == 0 || unkPtr->unk2 != 0) - { - PlaySE(SE_SELECT); - ret = sub_81CD258(1); - } - } - else if (gMain.heldKeys & DPAD_DOWN) - { - if (structPtr->unk6300 == 0 || unkPtr->unk2 < unkPtr->unk0 - 1) - { - PlaySE(SE_SELECT); - ret = sub_81CD258(0); - } - } - - return ret; -} - -u8 sub_81CD258(u8 arg0) -{ - u16 r7; - bool8 r6, r0; - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - - r7 = (arg0) ? structPtr->unk6788 : structPtr->unk6787; - sub_81D1F84(&structPtr->unk6428, structPtr->unk6428.unk14[structPtr->unk6786], structPtr->unk6428.unk14[r7]); - r6 = (unkPtr->unk2 != ((sub_81CDD5C() != 0) ? unkPtr->unk0 : unkPtr->unk0 - 1)); - if (arg0) - { - structPtr->unk6788 = structPtr->unk6787; - structPtr->unk6787 = structPtr->unk6786; - structPtr->unk6786 = r7; - structPtr->unk6789 = structPtr->unk6788; - - unkPtr->unk2 = (unkPtr->unk2 == 0) ? unkPtr->unk0 - 1 : unkPtr->unk2 - 1; - structPtr->unk6302 = (unkPtr->unk2 != 0) ? unkPtr->unk2 - 1 : unkPtr->unk0 - 1; - } - else - { - structPtr->unk6787 = structPtr->unk6788; - structPtr->unk6788 = structPtr->unk6786; - structPtr->unk6786 = r7; - structPtr->unk6789 = structPtr->unk6787; - - unkPtr->unk2 = (unkPtr->unk2 < unkPtr->unk0 - 1) ? unkPtr->unk2 + 1 : 0; - structPtr->unk6302 = (unkPtr->unk2 < unkPtr->unk0 - 1) ? unkPtr->unk2 + 1 : 0; - } - - r0 = (unkPtr->unk2 != ((sub_81CDD5C() != 0) ? unkPtr->unk0 : unkPtr->unk0 - 1)); - - if (!r6) - return 3; - else if (!r0) - return 4; - else - return 1; -} - -bool32 sub_81CD3C4(void) -{ - s32 var; - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - - switch (structPtr->unk678A) - { - case 0: - sub_81CD824(unkPtr->unk2, 0); - break; - case 1: - sub_81CDA1C(unkPtr->unk2, 0); - break; - case 2: - sub_81CDB98(unkPtr->unk2, 0); - break; - case 3: - if (unkPtr->unk0 == 1) - { - structPtr->unk6786 = 0; - structPtr->unk6787 = 0; - structPtr->unk6788 = 0; - structPtr->unk678A = 0; - return TRUE; - } - else - { - structPtr->unk6786 = 0; - structPtr->unk6787 = 1; - structPtr->unk6788 = 2; - } - break; - // These were probably ternaries just like cases 7-9, but couldn't match it any other way. - case 4: - var = unkPtr->unk2 + 1; - if (var >= unkPtr->unk0) - var = 0; - sub_81CD824(var, 1); - break; - case 5: - var = unkPtr->unk2 + 1; - if (var >= unkPtr->unk0) - var = 0; - sub_81CDA1C(var, 1); - break; - case 6: - var = unkPtr->unk2 + 1; - if (var >= unkPtr->unk0) - var = 0; - sub_81CDB98(var, 1); - break; - case 7: - sub_81CD824((unkPtr->unk2 - 1 >= 0) ? unkPtr->unk2 - 1 : unkPtr->unk0 - 1, 2); - break; - case 8: - sub_81CDA1C((unkPtr->unk2 - 1 >= 0) ? unkPtr->unk2 - 1 : unkPtr->unk0 - 1, 2); - break; - case 9: - sub_81CDB98((unkPtr->unk2 - 1 >= 0) ? unkPtr->unk2 - 1 : unkPtr->unk0 - 1, 2); - structPtr->unk678A = 0; - return TRUE; - } - - structPtr->unk678A++; - return FALSE; -} - -bool32 sub_81CD548(u8 arg0) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - - switch (arg0) - { - case 0: - sub_81CD824(structPtr->unk6302, structPtr->unk6789); - break; - case 1: - sub_81CDA1C(structPtr->unk6302, structPtr->unk6789); - break; - case 2: - sub_81CDB98(structPtr->unk6302, structPtr->unk6789); - return TRUE; - } - - return FALSE; -} - -u8 *sub_81CD5CC(u8 *dst, const u8 *src, s16 n) -{ - while (*src != EOS) - *dst++ = *src++, n--; - - while (n-- > 0) - *dst++ = CHAR_SPACE; - - *dst = EOS; - return dst; -} - -u8 *sub_81CD624(u8 *str, u16 id, bool8 arg3) -{ - u16 boxId, monId, gender, species, level, lvlDigits; - struct BoxPokemon *boxMon; - u8 *txtPtr, *str_; - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - - boxId = unkPtr->unk4[id].boxId; - monId = unkPtr->unk4[id].monId; - *(str++) = EXT_CTRL_CODE_BEGIN; - *(str++) = 4; - *(str++) = 8; - *(str++) = 0; - *(str++) = 9; - - if (GetBoxOrPartyMonData(boxId, monId, MON_DATA_IS_EGG, NULL)) - return StringCopyPadded(str, gText_EggNickname, CHAR_SPACE, 12); - - GetBoxOrPartyMonData(boxId, monId, MON_DATA_NICKNAME, str); - StringGetEnd10(str); - species = GetBoxOrPartyMonData(boxId, monId, MON_DATA_SPECIES, NULL); - if (boxId == TOTAL_BOXES_COUNT) - { - level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); - gender = GetMonGender(&gPlayerParty[monId]); - } - else - { - boxMon = GetBoxedMonPtr(boxId, monId); - gender = GetBoxMonGender(boxMon); - level = GetLevelFromBoxMonExp(boxMon); - } - - if ((species == SPECIES_NIDORAN_F || species == SPECIES_NIDORAN_M) && !StringCompare(str, gSpeciesNames[species])) - gender = MON_GENDERLESS; - - str_ = str; // For some reason, a variable is needed to match. - while (*str_ != EOS) - (str_++); - - *(str_++) = EXT_CTRL_CODE_BEGIN; - *(str_++) = 0x12; - *(str_++) = 0x3C; - switch (gender) - { - default: - *(str_++) = 0x77; - break; - case MON_MALE: - *(str_++) = EXT_CTRL_CODE_BEGIN; - *(str_++) = EXT_CTRL_CODE_COLOR; - *(str_++) = 4; - *(str_++) = EXT_CTRL_CODE_BEGIN; - *(str_++) = 3; - *(str_++) = 5; - *(str_++) = CHAR_MALE; - break; - case MON_FEMALE: - *(str_++) = EXT_CTRL_CODE_BEGIN; - *(str_++) = EXT_CTRL_CODE_COLOR; - *(str_++) = 6; - *(str_++) = EXT_CTRL_CODE_BEGIN; - *(str_++) = 3; - *(str_++) = 7; - *(str_++) = CHAR_FEMALE; - break; - } - - *(str_++) = EXT_CTRL_CODE_BEGIN; - *(str_++) = 4; - *(str_++) = 8; - *(str_++) = 0; - *(str_++) = 9; - *(str_++) = CHAR_SLASH; - *(str_++) = CHAR_SPECIAL_F9; - *(str_++) = CHAR_LV_2; - txtPtr = str_; - str_ = ConvertIntToDecimalStringN(str_, level, STR_CONV_MODE_LEFT_ALIGN, 3); - lvlDigits = str_ - txtPtr; - *(str_++) = CHAR_SPACE; - if (!arg3) - { - lvlDigits = 3 - lvlDigits; - while (lvlDigits-- != 0) - *(str_++) = CHAR_SPACE; - } - - *str_ = EOS; - return str_; -} - -void sub_81CD824(s16 arg0, u8 arg1) -{ - u16 boxId, i; - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - - if (arg0 != (sub_81CDD5C() != 0 ? unkPtr->unk0 : unkPtr->unk0 - 1)) - { - sub_81CD624(structPtr->unk6368[arg1], arg0, FALSE); - boxId = unkPtr->unk4[arg0].boxId; - structPtr->unk6320[arg1][0] = EXT_CTRL_CODE_BEGIN; - structPtr->unk6320[arg1][1] = 4; - structPtr->unk6320[arg1][2] = 8; - structPtr->unk6320[arg1][3] = 0; - structPtr->unk6320[arg1][4] = 9; - if (boxId == TOTAL_BOXES_COUNT) - sub_81CD5CC(&structPtr->unk6320[arg1][5], gText_InParty, 8); - else - sub_81CD5CC(&structPtr->unk6320[arg1][5], GetBoxNamePtr(boxId), 8); - } - else - { - for (i = 0; i < 12; i++) - structPtr->unk6368[arg1][i] = CHAR_SPACE; - structPtr->unk6368[arg1][i] = EOS; - - for (i = 0; i < 8; i++) - structPtr->unk6320[arg1][i] = CHAR_SPACE; - structPtr->unk6320[arg1][i] = EOS; - } -} - -void sub_81CD970(void) -{ - u16 i, count; - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - struct PokenavSub18 *unkPtr = AllocSubstruct(18, sizeof(struct PokenavSub18)); - - structPtr->unk6300 = 0; - for (i = 0, count = 0; i < CalculatePlayerPartyCount(); i++) - { - if (!GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG)) - { - unkPtr->unk4[count].boxId = TOTAL_BOXES_COUNT; - unkPtr->unk4[count].monId = i; - unkPtr->unk4[count].data = 0; - count++; - } - } - - unkPtr->unk4[count].boxId = 0; - unkPtr->unk4[count].monId = 0; - unkPtr->unk4[count].data = 0; - unkPtr->unk2 = 0; - unkPtr->unk0 = count + 1; - structPtr->unk678A = 0; -} - -void sub_81CD9F8(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - structPtr->unk6300 = 1; - structPtr->unk678A = 0; -} - -void sub_81CDA1C(s16 arg0, u8 arg1) -{ - u16 boxId, monId, i; - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - - if (arg0 != (sub_81CDD5C() != 0 ? unkPtr->unk0 : unkPtr->unk0 - 1)) - { - boxId = unkPtr->unk4[arg0].boxId; - monId = unkPtr->unk4[arg0].monId; - structPtr->unk6428.unk0[arg1][0] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_COOL, NULL); - structPtr->unk6428.unk0[arg1][1] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_TOUGH, NULL); - structPtr->unk6428.unk0[arg1][2] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_SMART, NULL); - structPtr->unk6428.unk0[arg1][3] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_CUTE, NULL); - structPtr->unk6428.unk0[arg1][4] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_BEAUTY, NULL); - structPtr->unk6780[arg1] = (GetBoxOrPartyMonData(boxId, monId, MON_DATA_SHEEN, NULL) != 255) - ? GetBoxOrPartyMonData(boxId, monId, MON_DATA_SHEEN, NULL) / 29u - : 9; - structPtr->unk6783[arg1] = GetBoxOrPartyMonData(boxId, monId, MON_DATA_MARKINGS, NULL); - sub_81D2754(structPtr->unk6428.unk0[arg1], structPtr->unk6428.unk14[arg1]); - } - else - { - for (i = 0; i < 5; i++) - { - structPtr->unk6428.unk0[arg1][i] = 0; - structPtr->unk6428.unk14[arg1][i].unk0 = 155; - structPtr->unk6428.unk14[arg1][i].unk2 = 91; - } - } -} - -void sub_81CDB98(s16 arg0, u8 arg1) -{ - u16 boxId, monId, species; - u32 personality, tid; - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - - if (arg0 == (sub_81CDD5C() != 0 ? unkPtr->unk0 : unkPtr->unk0 - 1)) - return; - - boxId = unkPtr->unk4[arg0].boxId; - monId = unkPtr->unk4[arg0].monId; - species = GetBoxOrPartyMonData(boxId, monId, MON_DATA_SPECIES2, NULL); - tid = GetBoxOrPartyMonData(boxId, monId, MON_DATA_OT_ID, NULL); - personality = GetBoxOrPartyMonData(boxId, monId, MON_DATA_PERSONALITY, NULL); - LoadSpecialPokePic(&gMonFrontPicTable[species], structPtr->monPicGfx[arg1], species, personality, TRUE); - LZ77UnCompWram(GetMonSpritePalFromSpeciesAndPersonality(species, tid, personality), structPtr->monPal[arg1]); -} - -u16 sub_81CDC50(void) -{ - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - return unkPtr->unk0; -} - -u16 sub_81CDC60(void) -{ - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - return unkPtr->unk2; -} - -struct UnknownStruct_81D1ED4 *sub_81CDC70(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return &structPtr->unk6428; -} - -u8 sub_81CDC84(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return structPtr->unk6786; -} - -u8 sub_81CDC9C(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return structPtr->unk6302; -} - -void *sub_81CDCB4(u8 id) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return structPtr->monPicGfx[id]; -} - -void *sub_81CDCD4(u8 id) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return structPtr->monPal[id]; -} - -u8 sub_81CDCEC(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return structPtr->unk6789; -} - -u8 *sub_81CDD04(u8 id) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return structPtr->unk6368[id]; -} - -u8 *sub_81CDD24(u8 id) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return structPtr->unk6320[id]; -} - -u16 sub_81CDD48(void) -{ - struct PokenavSub18 *unkPtr = GetSubstructPtr(18); - return unkPtr->unk4[unkPtr->unk2].data; -} - -bool32 sub_81CDD5C(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - if (structPtr->unk6300 == 1) - return TRUE; - else - return FALSE; -} - -u8 sub_81CDD7C(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - if (structPtr->unk6300 == 1) - return structPtr->unk6783[structPtr->unk6786]; - else - return 0; -} - -u8 sub_81CDDB0(void) -{ - struct PokenavSub11 *structPtr = GetSubstructPtr(11); - return structPtr->unk6780[structPtr->unk6786]; -} diff --git a/src/pokenav_unk_7.c b/src/pokenav_unk_7.c deleted file mode 100644 index 11fdaa425..000000000 --- a/src/pokenav_unk_7.c +++ /dev/null @@ -1,884 +0,0 @@ -#include "global.h" -#include "bg.h" -#include "window.h" -#include "pokenav.h" -#include "decompress.h" -#include "gpu_regs.h" -#include "graphics.h" -#include "menu.h" -#include "menu_specialized.h" -#include "mon_markings.h" -#include "palette.h" -#include "pokenav.h" -#include "scanline_effect.h" -#include "string_util.h" -#include "strings.h" -#include "text.h" - -u32 sub_81CE37C(s32); -u32 sub_81CE2D0(s32); -u32 sub_81CE4D8(s32); -u32 sub_81CE5E4(s32); -u32 sub_81CE6BC(s32); -u32 sub_81CE700(s32); - -BSS_DATA u8 gUnknown_030012BC; - -const u16 gUnknown_086231E8[] = INCBIN_U16("graphics/pokenav/86231E8.gbapal"); -const u16 gUnknown_08623208[] = INCBIN_U16("graphics/pokenav/8623208.gbapal"); -const u32 gUnknown_08623228[] = INCBIN_U32("graphics/pokenav/8623228.4bpp.lz"); -const u32 gUnknown_0862323C[] = INCBIN_U32("graphics/pokenav/862323C.bin.lz"); -const u16 gUnknown_08623338[] = INCBIN_U16("graphics/pokenav/8623338.gbapal"); - -const struct BgTemplate gUnknown_08623358[3] = -{ - { - .bg = 1, - .charBaseIndex = 1, - .mapBaseIndex = 0x1F, - .screenSize = 0, - .paletteMode = 0, - .priority = 1, - .baseTile = 0 - }, - { - .bg = 2, - .charBaseIndex = 3, - .mapBaseIndex = 0x1D, - .screenSize = 0, - .paletteMode = 0, - .priority = 2, - .baseTile = 0 - }, - { - .bg = 3, - .charBaseIndex = 2, - .mapBaseIndex = 0x1E, - .screenSize = 0, - .paletteMode = 0, - .priority = 3, - .baseTile = 0 - } -}; - -const struct WindowTemplate gUnknown_08623364 = -{ - .bg = 1, - .tilemapLeft = 13, - .tilemapTop = 1, - .width = 13, - .height = 4, - .paletteNum = 15, - .baseBlock = 2 -}; - -const struct WindowTemplate gUnknown_0862336C = -{ - .bg = 1, - .tilemapLeft = 1, - .tilemapTop = 6, - .width = 7, - .height = 2, - .paletteNum = 15, - .baseBlock = 0x36 -}; - -const struct WindowTemplate gUnknown_08623374 = -{ - .bg = 1, - .tilemapLeft = 1, - .tilemapTop = 0x1C, - .width = 5, - .height = 2, - .paletteNum = 15, - .baseBlock = 0x44 -}; - -const struct WindowTemplate gUnknown_0862337C = -{ - .bg = 1, - .tilemapLeft = 13, - .tilemapTop = 0x1C, - .width = 3, - .height = 2, - .paletteNum = 15, - .baseBlock = 0x44 -}; - -const LoopedTask gUnknown_08623384[] = -{ - NULL, - sub_81CE37C, - sub_81CE2D0, - sub_81CE4D8, - sub_81CE5E4, - sub_81CE6BC, - sub_81CE700 -}; - -struct Pokenav7Struct -{ - u32 loopedTaskId; - u8 tilemapBuffers[3][BG_SCREEN_SIZE]; - u8 filler[2]; - u8 unk1806[10]; - u32 (*unk1810)(void); - s16 unk1814; - u8 unk1816; - u16 unk1818; - u16 unk181A; - void *unk181C; - u8 unk1820; - u8 unk1821; - u8 unk1822; - u8 unk1823; - struct PokemonMarkMenu monMarks; - struct Sprite *unk28dc; - struct Sprite *unk28e0[10]; - u8 unk2908; - u8 filler2[0x38ac - 0x2909]; -}; - -extern s8 sub_81CDC84(void); // This function's declaration here is different than its definition in pokenav_unk_6. u8/s8 - -u32 sub_81CDE94(s32 state); -u32 sub_81CDE80(void); -void sub_81CED30(u8 var); -void sub_81CE9E4(void); -void sub_81CE934(void); -bool32 sub_81CE754(u8 a0, u16 a1, bool8 a2); -void sub_81CEE44(void); -void sub_81CEE90(void); -void sub_81CEEC8(void); -void sub_81CEE68(void); -void sub_81CEE74(bool8 showBg); - -// code -bool32 sub_81CDDD4(void) -{ - struct Pokenav7Struct *structPtr = AllocSubstruct(0xC, sizeof(struct Pokenav7Struct)); - - if (structPtr == NULL) - return FALSE; - - structPtr->unk1816 = 0xFF; - structPtr->loopedTaskId = CreateLoopedTask(sub_81CDE94, 1); - structPtr->unk1810 = sub_81CDE80; - structPtr->unk2908 = 0; - return TRUE; -} - -void sub_81CDE2C(s32 id) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - structPtr->loopedTaskId = CreateLoopedTask(gUnknown_08623384[id], 1); - structPtr->unk1810 = sub_81CDE80; -} - -u32 sub_81CDE64(void) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - return structPtr->unk1810(); -} - -u32 sub_81CDE80(void) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - return IsLoopedTaskActive(structPtr->loopedTaskId); -} - -u32 sub_81CDE94(s32 state) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - switch (state) - { - case 0: - if (sub_81CD3C4() != TRUE) - return LT_PAUSE; - return LT_INC_AND_PAUSE; - case 1: - InitBgTemplates(gUnknown_08623358, ARRAY_COUNT(gUnknown_08623358)); - ChangeBgX(1, 0, 0); - ChangeBgY(1, 0, 0); - ChangeBgX(2, 0, 0); - ChangeBgY(2, 0, 0); - ChangeBgX(3, 0, 0); - ChangeBgY(3, 0, 0); - SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_WIN1_ON | DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON | DISPCNT_BG3_ON); - SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG3); - SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(11, 4)); - decompress_and_copy_tile_data_to_vram(3, gPokenavCondition_Gfx, 0, 0, 0); - return LT_INC_AND_PAUSE; - case 2: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - decompress_and_copy_tile_data_to_vram(2, gUnknown_08623228, 0, 0, 0); - return LT_INC_AND_PAUSE; - case 3: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - - LZ77UnCompVram(gPokenavCondition_Tilemap, structPtr->tilemapBuffers[0]); - SetBgTilemapBuffer(3, structPtr->tilemapBuffers[0]); - if (sub_81CDD5C() == TRUE) - CopyToBgTilemapBufferRect(3, gPokenavOptions_Tilemap, 0, 5, 9, 4); - - CopyBgTilemapBufferToVram(3); - CopyPaletteIntoBufferUnfaded(gPokenavCondition_Pal, 0x10, 0x20); - CopyPaletteIntoBufferUnfaded(gUnknown_08623208, 0xF0, 0x20); - structPtr->unk1814 = -80; - return LT_INC_AND_PAUSE; - case 4: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - - LZ77UnCompVram(gUnknown_0862323C, structPtr->tilemapBuffers[2]); - SetBgTilemapBuffer(2, structPtr->tilemapBuffers[2]); - CopyBgTilemapBufferToVram(2); - CopyPaletteIntoBufferUnfaded(gUnknown_086231E8, 0x30, 0x20); - sub_81D21DC(2); - return LT_INC_AND_PAUSE; - case 5: - sub_8199DF0(1, 0, 0, 1); - sub_8199DF0(1, 17, 1, 1); - CpuFill32(0, structPtr->tilemapBuffers[1], BG_SCREEN_SIZE); - SetBgTilemapBuffer(1, structPtr->tilemapBuffers[1]); - return LT_INC_AND_PAUSE; - case 6: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - - structPtr->unk1820 = AddWindow(&gUnknown_08623364); - if (sub_81CDD5C() == TRUE) - { - structPtr->unk1821 = AddWindow(&gUnknown_0862336C); - structPtr->unk1822 = AddWindow(&gUnknown_08623374); - structPtr->unk1823 = AddWindow(&gUnknown_0862337C); - } - DeactivateAllTextPrinters(); - return LT_INC_AND_PAUSE; - case 7: - sub_81CED30(0); - return LT_INC_AND_PAUSE; - case 8: - sub_81CE9E4(); - return LT_INC_AND_PAUSE; - case 9: - if (sub_81CDD5C() == TRUE) - sub_81CE934(); - return LT_INC_AND_PAUSE; - case 10: - sub_81CE754(0, sub_81CDC84(), TRUE); - return LT_INC_AND_PAUSE; - case 11: - sub_81CE754(1, sub_81CDC84(), TRUE); - return LT_INC_AND_PAUSE; - case 12: - sub_81CE754(2, sub_81CDC84(), TRUE); - return LT_INC_AND_PAUSE; - case 13: - if (sub_81CE754(3, sub_81CDC84(), TRUE) != TRUE) - return LT_PAUSE; - PutWindowTilemap(structPtr->unk1820); - if (sub_81CDD5C() == TRUE) - { - PutWindowTilemap(structPtr->unk1821); - PutWindowTilemap(structPtr->unk1822); - PutWindowTilemap(structPtr->unk1823); - } - return LT_INC_AND_PAUSE; - case 14: - ShowBg(1); - HideBg(2); - ShowBg(3); - if (sub_81CDD5C() == TRUE) - PrintHelpBarText(HELPBAR_CONDITION_MON_STATUS); - return LT_INC_AND_PAUSE; - case 15: - sub_81C7AC0(1); - if (!sub_81CDD5C()) - { - LoadLeftHeaderGfxForIndex(6); - sub_81C7FA0(1, TRUE, 0); - sub_81C7FA0(6, TRUE, 0); - } - return LT_INC_AND_PAUSE; - case 16: - if (IsPaletteFadeActive()) - return LT_PAUSE; - if (!sub_81CDD5C() && sub_81C8010()) - return LT_PAUSE; - SetVBlankCallback_(sub_81CEE44); - return LT_INC_AND_PAUSE; - case 17: - sub_81CEE90(); - sub_81D20AC(sub_81CDC70()); - return LT_INC_AND_PAUSE; - case 18: - if (sub_81D20BC(sub_81CDC70())) - return LT_PAUSE; - return LT_INC_AND_PAUSE; - case 19: - sub_81CEE74(TRUE); - return LT_INC_AND_PAUSE; - case 20: - if (!sub_81D3178(sub_81CDC70(), &structPtr->unk1814)) - { - sub_81D3464(structPtr->unk28e0); - if (sub_81CDD5C() == TRUE || sub_81CDC60() != sub_81CDC50()) - sub_81D3480(structPtr->unk28e0, structPtr->unk1816, sub_81CDDB0()); - - return LT_FINISH; - } - return LT_PAUSE; - } - - return LT_FINISH; -} - -u32 sub_81CE2D0(s32 state) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - switch (state) - { - case 0: - sub_81CEEC8(); - sub_81D3520(structPtr->unk28e0); - return 1; - case 1: - if (sub_81D31A4(sub_81CDC70(), &structPtr->unk1814)) - return 2; - sub_81CEE74(FALSE); - return 1; - case 2: - sub_81C7AC0(0); - if (!sub_81CDD5C()) - sub_81C78A0(); - return 0; - case 3: - if (IsPaletteFadeActive() || MainMenuLoopedTaskIsBusy()) - return 2; - sub_81D354C(structPtr->unk28e0); - HideBg(1); - HideBg(2); - HideBg(3); - return 1; - } - - return LT_FINISH; -} - -u32 sub_81CE37C(s32 state) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - struct UnknownStruct_81D1ED4 *unkPtr = sub_81CDC70(); - - switch (state) - { - case 0: - sub_81CD548(0); - return 1; - case 1: - sub_81CD548(1); - return 1; - case 2: - sub_81CD548(2); - sub_81D3520(structPtr->unk28e0); - return 1; - case 3: - sub_81D2074(unkPtr); - return 1; - case 4: - if (!sub_81D3150(&structPtr->unk1814)) - { - sub_81CED30(sub_81CDC84()); - return 1; - } - return 2; - case 5: - sub_81CE754(0, sub_81CDC84(), FALSE); - return 1; - case 6: - sub_81CE754(1, sub_81CDC84(), FALSE); - return 1; - case 7: - sub_81CE754(2, sub_81CDC84(), FALSE); - return 1; - case 8: - if (sub_81CE754(3, sub_81CDC84(), FALSE) == TRUE) - return 1; - return 2; - case 9: - unkPtr = sub_81CDC70(); - if (!sub_81D3178(unkPtr, &structPtr->unk1814)) - { - sub_81D3464(structPtr->unk28e0); - if (sub_81CDD5C() != TRUE && sub_81CDC60() == sub_81CDC50()) - return 1; - - sub_81D3480(structPtr->unk28e0, structPtr->unk1816, sub_81CDDB0()); - return 1; - } - return 2; - } - - return LT_FINISH; -} - -u32 sub_81CE4D8(s32 state) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - switch (state) - { - case 0: - sub_81CD548(0); - return 1; - case 1: - sub_81CD548(1); - return 1; - case 2: - sub_81CD548(2); - return 1; - case 3: - sub_81CED30(sub_81CDC84()); - return 1; - case 4: - sub_81CE754(0, sub_81CDC84(), FALSE); - return 1; - case 5: - sub_81CE754(1, sub_81CDC84(), FALSE); - return 1; - case 6: - sub_81CE754(2, sub_81CDC84(), FALSE); - return 1; - case 7: - if (sub_81CE754(3, sub_81CDC84(), FALSE) == TRUE) - return 1; - return 2; - case 8: - if (!sub_81D3178(sub_81CDC70(), &structPtr->unk1814)) - { - sub_81D3464(structPtr->unk28e0); - sub_81D3480(structPtr->unk28e0, structPtr->unk1816, sub_81CDDB0()); - return 1; - } - return 2; - } - - return LT_FINISH; -} - -u32 sub_81CE5E4(s32 state) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - switch (state) - { - case 0: - sub_81CD548(0); - return 1; - case 1: - sub_81CD548(1); - return 1; - case 2: - sub_81CD548(2); - sub_81D3520(structPtr->unk28e0); - return 1; - case 3: - if (!sub_81D31A4(sub_81CDC70(), &structPtr->unk1814)) - return 1; - return 2; - case 4: - sub_81CE754(0, sub_81CDC84(), FALSE); - return 1; - case 5: - sub_81CE754(1, sub_81CDC84(), FALSE); - return 1; - case 6: - sub_81CE754(2, sub_81CDC84(), FALSE); - return 1; - case 7: - if (sub_81CE754(3, sub_81CDC84(), FALSE) == TRUE) - return 1; - return 2; - } - - return LT_FINISH; -} - -u32 sub_81CE6BC(s32 state) -{ - switch (state) - { - case 0: - sub_811FAA4(sub_81CDD7C(), 176, 32); - return 1; - case 1: - PrintHelpBarText(HELPBAR_CONDITION_MARKINGS); - return 1; - case 2: - if (WaitForHelpBar() == TRUE) - return 2; - return 1; - } - - return LT_FINISH; -} - -u32 sub_81CE700(s32 state) -{ - switch (state) - { - case 0: - sub_811FAF8(); - return 1; - case 1: - PrintHelpBarText(HELPBAR_CONDITION_MON_STATUS); - return 1; - case 2: - if (WaitForHelpBar() == TRUE) - return 2; - return 1; - } - - return LT_FINISH; -} - -static u8 *UnusedPrintNumberString(u8 *dst, u16 num) -{ - u8 *txtPtr = ConvertIntToDecimalStringN(dst, num, STR_CONV_MODE_RIGHT_ALIGN, 4); - txtPtr = StringCopy(txtPtr, gText_Number2); - - return txtPtr; -} - -bool32 sub_81CE754(u8 a0, u16 a1, bool8 a2) -{ - u8 text[32]; - const u8 *str; - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - switch (a0) - { - case 0: - FillWindowPixelBuffer(structPtr->unk1820, 0); - if (sub_81CDD5C() == TRUE) - FillWindowPixelBuffer(structPtr->unk1821, 0); - break; - case 1: - if (sub_81CDC60() != sub_81CDC50() - 1 || sub_81CDD5C() == TRUE) - { - str = sub_81CDD04(a1); - AddTextPrinterParameterized(structPtr->unk1820, 1, str, 0, 1, 0, NULL); - } - break; - case 2: - if (sub_81CDD5C() == TRUE) - { - str = sub_81CDD24(a1); - AddTextPrinterParameterized(structPtr->unk1820, 1, str, 0, 17, 0, NULL); - text[0] = EXT_CTRL_CODE_BEGIN; - text[1] = 4; - text[2] = 8; - text[3] = 0; - text[4] = 9; - StringCopy(text + 5, gText_Number2); - AddTextPrinterParameterized(structPtr->unk1821, 1, text, 4, 1, 0, NULL); - ConvertIntToDecimalStringN(text + 5, sub_81CDD48(), STR_CONV_MODE_RIGHT_ALIGN, 4); - AddTextPrinterParameterized(structPtr->unk1821, 1, text, 28, 1, 0, NULL); - } - break; - case 3: - switch (structPtr->unk2908) - { - case 0: - if (a2) - CopyWindowToVram(structPtr->unk1820, 3); - else - CopyWindowToVram(structPtr->unk1820, 2); - - if (sub_81CDD5C() == TRUE) - { - structPtr->unk2908++; - return FALSE; - } - else - { - structPtr->unk2908 = 0; - return TRUE; - } - case 1: - if (a2) - CopyWindowToVram(structPtr->unk1821, 3); - else - CopyWindowToVram(structPtr->unk1821, 2); - - structPtr->unk2908 = 0; - return TRUE; - } - } - - return FALSE; -} - -void sub_81CE934(void) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - CopyWindowToVram(structPtr->unk1822, 3); - CopyWindowToVram(structPtr->unk1823, 3); -} - -void sub_81CE964(struct Sprite *sprite) -{ - if (sprite->data[0] == sub_81CDC60()) - StartSpriteAnim(sprite, 0); - else - StartSpriteAnim(sprite, 1); -} - -void sub_81CE990(struct Sprite *sprite) -{ - if (sub_81CDC60() == sub_81CDC50() - 1) - sprite->oam.paletteNum = IndexOfSpritePaletteTag(0x65); - else - sprite->oam.paletteNum = IndexOfSpritePaletteTag(0x66); -} - -void sub_81CE9C8(struct Sprite *sprite) -{ - StartSpriteAnim(sprite, sub_81CDD7C()); -} - -void sub_81CE9E4(void) -{ - struct SpriteSheet sprSheets[4]; - struct SpriteTemplate sprTemplate; - struct SpritePalette sprPals[3]; - struct SpriteSheet sprSheet; - struct Sprite *sprite; - u16 i, spriteId; - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - sub_81D321C(sprSheets, &sprTemplate, sprPals); - if (sub_81CDD5C() == TRUE) - { - structPtr->monMarks.baseTileTag = 0x6A; - structPtr->monMarks.basePaletteTag = 0x6A; - sub_811F90C(&structPtr->monMarks); - sub_811FA90(); - sprite = sub_811FF94(0x69, 0x69, gUnknown_08623338); - sprite->oam.priority = 3; - sprite->pos1.x = 192; - sprite->pos1.y = 32; - sprite->callback = sub_81CE9C8; - structPtr->unk28dc = sprite; - sub_81C7990(IndexOfSpritePaletteTag(0x69), 0); - } - else - { - LoadSpriteSheets(sprSheets); - Pokenav_AllocAndLoadPalettes(sprPals); - for (i = 0; i < sub_81CDC50() - 1; i++) - { - spriteId = CreateSprite(&sprTemplate, 226, (i * 20) + 8, 0); - if (spriteId != MAX_SPRITES) - { - structPtr->unk1806[i] = spriteId; - gSprites[spriteId].data[0] = i; - gSprites[spriteId].callback = sub_81CE964; - } - else - { - structPtr->unk1806[i] = 0xFF; - } - } - - sprTemplate.tileTag = 0x67; - sprTemplate.callback = SpriteCallbackDummy; - for (; i < 6; i++) - { - spriteId = CreateSprite(&sprTemplate, 230, (i * 20) + 8, 0); - if (spriteId != MAX_SPRITES) - { - structPtr->unk1806[i] = spriteId; - gSprites[spriteId].oam.size = 0; - } - else - { - structPtr->unk1806[i] = 0xFF; - } - } - - sprTemplate.tileTag = 0x66; - sprTemplate.callback = sub_81CE990; - spriteId = CreateSprite(&sprTemplate, 222, (i * 20) + 8, 0); - if (spriteId != MAX_SPRITES) - { - structPtr->unk1806[i] = spriteId; - gSprites[spriteId].oam.shape = SPRITE_SHAPE(32x16); - gSprites[spriteId].oam.size = SPRITE_SIZE(32x16); - } - else - { - structPtr->unk1806[i] = 0xFF; - } - } - - sub_81D32B0(&sprSheet, &sprPals[0]); - LoadSpriteSheet(&sprSheet); - sprPals[1].data = NULL; - Pokenav_AllocAndLoadPalettes(sprPals); -} - -void sub_81CEBF4(struct Pokenav7Struct *structPtr) -{ - u8 i; - - if (sub_81CDD5C() == TRUE) - { - DestroySprite(structPtr->unk28dc); - FreeSpriteTilesByTag(0x6A); - FreeSpriteTilesByTag(0x69); - FreeSpritePaletteByTag(0x6A); - FreeSpritePaletteByTag(0x69); - } - else - { - for (i = 0; i < 7; i++) - DestroySprite(&gSprites[structPtr->unk1806[i]]); - - FreeSpriteTilesByTag(0x65); - FreeSpriteTilesByTag(0x66); - FreeSpriteTilesByTag(0x67); - FreeSpritePaletteByTag(0x65); - FreeSpritePaletteByTag(0x66); - } - - if (structPtr->unk1816 != 0xFF) - { - DestroySprite(&gSprites[structPtr->unk1816]); - FreeSpriteTilesByTag(0x64); - FreeSpritePaletteByTag(0x64); - } -} - -void sub_81CECA0(void) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - RemoveWindow(structPtr->unk1820); - if (sub_81CDD5C() == TRUE) - { - RemoveWindow(structPtr->unk1821); - RemoveWindow(structPtr->unk1822); - RemoveWindow(structPtr->unk1823); - } - else - { - sub_81C7FDC(); - } - - SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_BG0_ON | DISPCNT_OBJ_1D_MAP); - sub_81CEBF4(structPtr); - sub_81CEE68(); - FreePokenavSubstruct(0xC); -} - -void sub_81CED10(struct Sprite *sprite) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - sprite->pos1.x = structPtr->unk1814 + 38; -} - -void sub_81CED30(u8 var) -{ - struct SpriteTemplate sprTemplate; - struct SpriteSheet sprSheet; - struct SpritePalette sprPal; - u8 spriteId; - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - if (structPtr->unk1816 == 0xFF) - { - sub_81D31D0(&sprSheet, &sprTemplate, &sprPal); - sprSheet.data = sub_81CDCB4(var); - sprPal.data = sub_81CDCD4(var); - structPtr->unk1818 = LoadSpritePalette(&sprPal); - structPtr->unk181A = LoadSpriteSheet(&sprSheet); - spriteId = CreateSprite(&sprTemplate, 38, 104, 0); - structPtr->unk1816 = spriteId; - if (spriteId == MAX_SPRITES) - { - FreeSpriteTilesByTag(0x64); - FreeSpritePaletteByTag(0x64); - structPtr->unk1816 = 0xFF; - } - else - { - structPtr->unk1816 = spriteId; - gSprites[structPtr->unk1816].callback = sub_81CED10; - structPtr->unk181C = (void*)(VRAM) + 0x10000 + (structPtr->unk181A * 32); - structPtr->unk1818 = (structPtr->unk1818 * 16) + 0x100; - } - } - else - { - DmaCopy16Defvars(3, sub_81CDCB4(var), structPtr->unk181C, 0x800); - LoadPalette(sub_81CDCD4(var), structPtr->unk1818, 0x20); - } -} - -void sub_81CEE44(void) -{ - struct UnknownStruct_81D1ED4 *unk = sub_81CDC70(); - LoadOam(); - ProcessSpriteCopyRequests(); - TransferPlttBuffer(); - sub_81D2108(unk); - ScanlineEffect_InitHBlankDmaTransfer(); -} - -void sub_81CEE68(void) -{ - SetPokenavVBlankCallback(); -} - -void sub_81CEE74(bool8 showBg) -{ - if (showBg) - ShowBg(2); - else - HideBg(2); -} - -void sub_81CEE90(void) -{ - struct UnknownStruct_81D1ED4 *unk = sub_81CDC70(); - u8 id = sub_81CDC84(); - - gUnknown_030012BC = id; - sub_81D1F84(unk, unk->unk14[3], unk->unk14[id]); - sub_81D2074(unk); -} - -void sub_81CEEC8(void) -{ - struct UnknownStruct_81D1ED4 *unk = sub_81CDC70(); - - if (sub_81CDD5C() || sub_81CDC60() != sub_81CDC50() - 1) - sub_81D1F84(unk, unk->unk14[sub_81CDC84()], unk->unk14[3]); -} - -u8 sub_81CEF14(void) -{ - struct Pokenav7Struct *structPtr = GetSubstructPtr(0xC); - - if (sub_81CDD5C() == 1) - return structPtr->monMarks.markings; - else - return 0; -} diff --git a/src/pokenav_unk_8.c b/src/pokenav_unk_8.c deleted file mode 100644 index 9b6ce432b..000000000 --- a/src/pokenav_unk_8.c +++ /dev/null @@ -1,714 +0,0 @@ -#include "global.h" -#include "pokenav.h" -#include "bg.h" -#include "menu.h" -#include "window.h" -#include "sound.h" -#include "dynamic_placeholder_text_util.h" -#include "strings.h" -#include "string_util.h" -#include "international_string_util.h" -#include "constants/songs.h" - -struct PokenavSub7 -{ - u32 (*unk0)(struct PokenavSub7 *); - u32 loopedTaskId; - u8 fill1[4]; - s32 unkC; - s32 unk10; - u32 unk14; - u32 unk18; - u32 unk1C; - struct PokenavSub18 *unkPtr; -}; - -struct PokenavSub8 -{ - bool32 (*callback)(void); - u32 ltid; - u16 winid; - bool32 unkC; - u8 buff[BG_SCREEN_SIZE]; -}; // size: 0x810 - -static u32 sub_81CF010(struct PokenavSub7 *structPtr); -static u32 sub_81CF030(struct PokenavSub7 *structPtr); -static u32 sub_81CF0B8(struct PokenavSub7 *structPtr); -static u32 sub_81CF0B0(struct PokenavSub7 *structPtr); -static u32 sub_81CF11C(s32 state); -static u32 sub_81CF134(s32 state); -static u32 sub_81CF1C4(s32 state); -static u32 sub_81CF1D8(s32 state); -static u32 sub_81CF278(s32 state); -static u32 sub_81CF578(s32 state); -static u32 sub_81CF5F0(s32 state); -static u32 sub_81CF668(s32 state); -static u32 sub_81CF6E0(s32 state); -static u32 sub_81CF758(s32 state); -static u32 sub_81CF798(s32 state); -static void sub_81CF2C4(struct PokenavSub7 *structPtr, struct PokenavMonList *item); -static bool32 sub_81CF3E4(void); -static u32 sub_81CF418(s32 state); -static void sub_81CF7C8(struct PokenavSub8 *); -static void sub_81CF7F4(struct PokenavSub8 *); -static void sub_81CF88C(void); -static void sub_81CF8E4(struct PokenavMonList *, u8 *); - -static const u32 gUnknown_086233A0[] = {0x16, 0x17, 0x18, 0x21, 0x2F}; - -static const LoopedTask gUnknown_086233B4[] = -{ - sub_81CF134, - sub_81CF1C4, - sub_81CF1D8, - sub_81CF278 -}; - -static const u16 gUnknown_086233C4[] = INCBIN_U16("graphics/pokenav/condition_search2.gbapal"); -static const u32 gUnknown_086233E4[] = INCBIN_U32("graphics/pokenav/condition_search2.4bpp.lz"); -static const u32 gUnknown_086234AC[] = INCBIN_U32("graphics/pokenav/condition_search2.bin.lz"); -static const u16 gUnknown_08623570[] = INCBIN_U16("graphics/pokenav/8623570.gbapal"); - -static const struct BgTemplate gUnknown_08623590[] = -{ - { - .bg = 1, - .charBaseIndex = 1, - .mapBaseIndex = 0x06, - .screenSize = 0, - .paletteMode = 0, - .priority = 2, - .baseTile = 0 - }, { - .bg = 2, - .charBaseIndex = 2, - .mapBaseIndex = 0x07, - .screenSize = 0, - .paletteMode = 0, - .priority = 3, - .baseTile = 0 - } -}; - -static const LoopedTask gUnknown_08623598[] = -{ - NULL, - sub_81CF578, - sub_81CF5F0, - sub_81CF668, - sub_81CF6E0, - sub_81CF758, - sub_81CF798 -}; - -static const struct WindowTemplate gUnknown_086235B4 = -{ - .bg = 1, - .tilemapLeft = 1, - .tilemapTop = 6, - .width = 7, - .height = 2, - .paletteNum = 1, - .baseBlock = 20 -}; - -static const u8 sText_MaleSymbol[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_RED}{WHITE}{GREEN}♂{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); -static const u8 sText_FemaleSymbol[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_GREEN}{WHITE}{BLUE}♀{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); -static const u8 sText_NoGenderSymbol[] = _("{UNK_SPACER}"); - -bool32 PokenavCallback_Init_8(void) -{ - struct PokenavSub7 *structPtr = AllocSubstruct(7, sizeof(struct PokenavSub7)); - if (structPtr == NULL) - return FALSE; - - structPtr->unkPtr = AllocSubstruct(18, sizeof(struct PokenavSub18)); - if (structPtr->unkPtr == NULL) - return FALSE; - - structPtr->unk0 = sub_81CF010; - structPtr->loopedTaskId = CreateLoopedTask(sub_81CF11C, 1); - structPtr->unk18 = 0; - structPtr->unk14 = gUnknown_086233A0[GetSelectedConditionSearch()]; - return TRUE; -} - -bool32 PokenavCallback_Init_10(void) -{ - struct PokenavSub7 *structPtr = AllocSubstruct(7, sizeof(struct PokenavSub7)); - if (structPtr == NULL) - return FALSE; - - structPtr->unkPtr = GetSubstructPtr(18); - structPtr->unk0 = sub_81CF030; - structPtr->unk18 = 1; - structPtr->unk14 = gUnknown_086233A0[GetSelectedConditionSearch()]; - return TRUE; -} - -u32 sub_81CEFDC(void) -{ - struct PokenavSub7 *structPtr = GetSubstructPtr(7); - return structPtr->unk0(structPtr); -} - -void sub_81CEFF0(void) -{ - struct PokenavSub7 *structPtr = GetSubstructPtr(7); - if (structPtr->unk1C == 0) - FreePokenavSubstruct(18); - FreePokenavSubstruct(7); -} - -static bool32 sub_81CF010(struct PokenavSub7 *structPtr) -{ - if (!IsLoopedTaskActive(structPtr->loopedTaskId)) - structPtr->unk0 = sub_81CF030; - return FALSE; -} - -static u32 sub_81CF030(struct PokenavSub7 *structPtr) -{ - if (gMain.newAndRepeatedKeys & DPAD_UP) - return 1; - else if (gMain.newAndRepeatedKeys & DPAD_DOWN) - return 2; - else if (gMain.newKeys & DPAD_LEFT) - return 3; - else if (gMain.newKeys & DPAD_RIGHT) - return 4; - else if (gMain.newKeys & B_BUTTON) - { - structPtr->unk1C = 0; - structPtr->unk0 = sub_81CF0B0; - return 5; - } - else if (gMain.newKeys & A_BUTTON) - { - structPtr->unkPtr->unk2 = GetSelectedMatchCall(); - structPtr->unk1C = 1; - structPtr->unk0 = sub_81CF0B8; - return 6; - } - else - return 0; -} - -static u32 sub_81CF0B0(struct PokenavSub7 *structPtr) -{ - return 100003; -} - -static u32 sub_81CF0B8(struct PokenavSub7 *structPtr) -{ - return 100009; -} - -static u32 sub_81CF0C0(void) -{ - struct PokenavSub7 *structPtr = GetSubstructPtr(7); - return structPtr->unk18; -} - -static struct PokenavMonList * sub_81CF0D0(void) -{ - struct PokenavSub7 * ptr = GetSubstructPtr(7); - return ptr->unkPtr->unk4; -} - -static u16 sub_81CF0E0(void) -{ - struct PokenavSub7 * ptr = GetSubstructPtr(7); - return ptr->unkPtr->unk0; -} - -static s32 sub_81CF0F0(void) -{ - struct PokenavSub7 * ptr = GetSubstructPtr(7); - s32 i = GetSelectedMatchCall(); - return ptr->unkPtr->unk4[i].data; -} - -static u16 sub_81CF10C(void) -{ - struct PokenavSub7 * ptr = GetSubstructPtr(7); - return ptr->unkPtr->unk2; -} - -static u32 sub_81CF11C(s32 state) -{ - return gUnknown_086233B4[state](state); -} - -static u32 sub_81CF134(s32 state) -{ - s32 i; - struct PokenavMonList item; - struct PokenavSub7 * ptr = GetSubstructPtr(7); - - ptr->unkPtr->unk0 = 0; - ptr->unkPtr->unk2 = 0; - item.boxId = 14; - for (i = 0; i < PARTY_SIZE; i++) - { - struct Pokemon * pokemon = &gPlayerParty[i]; - if (!GetMonData(pokemon, MON_DATA_SANITY_HAS_SPECIES)) - return LT_INC_AND_CONTINUE; - if (!GetMonData(pokemon, MON_DATA_SANITY_IS_EGG)) - { - item.monId = i; - item.data = GetMonData(pokemon, ptr->unk14); - sub_81CF2C4(ptr, &item); - } - } - - return LT_INC_AND_CONTINUE; -} - -static u32 sub_81CF1C4(s32 state) -{ - struct PokenavSub7 * ptr = GetSubstructPtr(7); - ptr->unk10 = 0; - ptr->unkC = 0; - return LT_INC_AND_CONTINUE; -} - -static u32 sub_81CF1D8(s32 state) -{ - struct PokenavSub7 * ptr = GetSubstructPtr(7); - s32 boxId = ptr->unkC; - s32 monId = ptr->unk10; - s32 boxCount = 0; - struct PokenavMonList item; - - while (boxId < TOTAL_BOXES_COUNT) - { - while (monId < IN_BOX_COUNT) - { - if (CheckBoxMonSanityAt(boxId, monId)) - { - item.boxId = boxId; - item.monId = monId; - item.data = GetBoxMonDataAt(boxId, monId, ptr->unk14); - sub_81CF2C4(ptr, &item); - } - boxCount++; - monId++; - if (boxCount > 14) - { - ptr->unkC = boxId; - ptr->unk10 = monId; - return LT_CONTINUE; - } - } - monId = 0; - boxId++; - } - - return LT_INC_AND_CONTINUE; -} - -static u32 sub_81CF278(s32 state) -{ - struct PokenavSub7 * ptr = GetSubstructPtr(7); - s32 r6 = ptr->unkPtr->unk0; - s32 r4 = ptr->unkPtr->unk4[0].data; - s32 i; - ptr->unkPtr->unk4[0].data = 1; - for (i = 1; i < r6; i++) - { - if (ptr->unkPtr->unk4[i].data == r4) - { - ptr->unkPtr->unk4[i].data = ptr->unkPtr->unk4[i - 1].data; - } - else - { - r4 = ptr->unkPtr->unk4[i].data; - ptr->unkPtr->unk4[i].data = i + 1; - } - } - ptr->unk18 = 1; - return LT_FINISH; -} - -static void sub_81CF2C4(struct PokenavSub7 *structPtr, struct PokenavMonList *item) -{ - u32 left = 0; - u32 right = structPtr->unkPtr->unk0; - u32 insertionIdx = left + (right - left) / 2; - - while (right != insertionIdx) - { - if (item->data > structPtr->unkPtr->unk4[insertionIdx].data) - right = insertionIdx; - else - left = insertionIdx + 1; - insertionIdx = left + (right - left) / 2; - } - for (right = structPtr->unkPtr->unk0; right > insertionIdx; right--) - structPtr->unkPtr->unk4[right] = structPtr->unkPtr->unk4[right - 1]; - structPtr->unkPtr->unk4[insertionIdx] = *item; - structPtr->unkPtr->unk0++; -} - -bool32 sub_81CF330(void) -{ - struct PokenavSub8 * unk = AllocSubstruct(8, sizeof(struct PokenavSub8)); - if (unk == NULL) - return FALSE; - unk->ltid = CreateLoopedTask(sub_81CF418, 1); - unk->callback = sub_81CF3E4; - unk->unkC = FALSE; - return TRUE; -} - -bool32 sub_81CF368(void) -{ - struct PokenavSub8 * unk = AllocSubstruct(8, sizeof(struct PokenavSub8)); - if (unk == NULL) - return FALSE; - unk->ltid = CreateLoopedTask(sub_81CF418, 1); - unk->callback = sub_81CF3E4; - unk->unkC = TRUE; - return TRUE; -} - -void sub_81CF3A0(s32 idx) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - unk->ltid = CreateLoopedTask(gUnknown_08623598[idx], 1); - unk->callback = sub_81CF3E4; -} - -bool32 sub_81CF3D0(void) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - return unk->callback(); -} - -bool32 sub_81CF3E4(void) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - return IsLoopedTaskActive(unk->ltid); -} - -void sub_81CF3F8(void) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - sub_81C8234(); - RemoveWindow(unk->winid); - FreePokenavSubstruct(8); -} - -static u32 sub_81CF418(s32 state) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - switch (state) - { - case 0: - InitBgTemplates(gUnknown_08623590, NELEMS(gUnknown_08623590)); - decompress_and_copy_tile_data_to_vram(1, gUnknown_086233E4, 0, 0, 0); - SetBgTilemapBuffer(1, unk->buff); - CopyToBgTilemapBuffer(1, gUnknown_086234AC, 0, 0); - CopyBgTilemapBufferToVram(1); - CopyPaletteIntoBufferUnfaded(gUnknown_086233C4, 0x10, 0x20); - CopyBgTilemapBufferToVram(1); - return LT_INC_AND_PAUSE; - case 1: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - if (!sub_81CF0C0()) - return LT_PAUSE; - return LT_INC_AND_PAUSE; - case 2: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - CopyPaletteIntoBufferUnfaded(gUnknown_08623570, 0x20, 0x20); - sub_81CF88C(); - return LT_INC_AND_PAUSE; - case 3: - if (sub_81C8224()) - return LT_PAUSE; - sub_81CF7C8(unk); - PrintHelpBarText(HELPBAR_CONDITION_MON_LIST); - return LT_INC_AND_PAUSE; - case 4: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - ChangeBgX(1, 0, 0); - ChangeBgY(1, 0, 0); - ShowBg(1); - ShowBg(2); - HideBg(3); - if (!unk->unkC) - { - u8 r4 = GetSelectedConditionSearch() + POKENAV_MENUITEM_CONDITION_SEARCH_COOL; - LoadLeftHeaderGfxForIndex(r4); - sub_81C7FA0(r4, 1, 0); - sub_81C7FA0(1, 1, 0); - } - sub_81C7AC0(1); - return LT_INC_AND_PAUSE; - case 5: - if (IsPaletteFadeActive()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81CF578(s32 state) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - switch (state) - { - case 0: - switch (MatchCall_MoveCursorUp()) - { - case 0: - return LT_FINISH; - case 1: - PlaySE(SE_SELECT); - return LT_SET_STATE(2); - case 2: - PlaySE(SE_SELECT); - break; - } - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - // fallthrough - case 2: - sub_81CF7F4(unk); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81CF5F0(s32 state) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - switch (state) - { - case 0: - switch (MatchCall_MoveCursorDown()) - { - case 0: - return LT_FINISH; - case 1: - PlaySE(SE_SELECT); - return LT_SET_STATE(2); - case 2: - PlaySE(SE_SELECT); - break; - } - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - // fallthrough - case 2: - sub_81CF7F4(unk); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81CF668(s32 state) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - switch (state) - { - case 0: - switch (MatchCall_PageUp()) - { - case 0: - return LT_FINISH; - case 1: - PlaySE(SE_SELECT); - return LT_SET_STATE(2); - case 2: - PlaySE(SE_SELECT); - break; - } - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - // fallthrough - case 2: - sub_81CF7F4(unk); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81CF6E0(s32 state) -{ - struct PokenavSub8 * unk = GetSubstructPtr(8); - switch (state) - { - case 0: - switch (MatchCall_PageDown()) - { - case 0: - return LT_FINISH; - case 1: - PlaySE(SE_SELECT); - return LT_SET_STATE(2); - case 2: - PlaySE(SE_SELECT); - break; - } - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - // fallthrough - case 2: - sub_81CF7F4(unk); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81CF758(s32 state) -{ - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81C7AC0(0); - sub_81C78A0(); - return LT_INC_AND_PAUSE; - case 1: - if (IsPaletteFadeActive()) - return LT_PAUSE; - if (MainMenuLoopedTaskIsBusy()) - return LT_PAUSE; - sub_81C7FDC(); - break; - } - return LT_FINISH; -} - -static u32 sub_81CF798(s32 state) -{ - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81C7AC0(0); - return LT_INC_AND_PAUSE; - case 1: - if (IsPaletteFadeActive()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static void sub_81CF7C8(struct PokenavSub8 * ptr) -{ - ptr->winid = AddWindow(&gUnknown_086235B4); - PutWindowTilemap(ptr->winid); - CopyWindowToVram(ptr->winid, 1); - sub_81CF7F4(ptr); -} - -static void sub_81CF7F4(struct PokenavSub8 * ptr) -{ - s32 r7 = sub_81CF0F0(); - DynamicPlaceholderTextUtil_Reset(); - DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, gStringVar1); - *gStringVar1 = EOS; - DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar2, gText_NumberF700); - AddTextPrinterParameterized(ptr->winid, 1, gStringVar2, 4, 1, 0xFF, NULL); - ConvertIntToDecimalStringN(gStringVar1, r7, STR_CONV_MODE_RIGHT_ALIGN, 3); - AddTextPrinterParameterized(ptr->winid, 1, gStringVar1, 34, 1, 0xFF, NULL); - CopyWindowToVram(ptr->winid, 2); -} - -static void sub_81CF88C(void) -{ - struct PokenavListTemplate template; - template.list.monList = sub_81CF0D0(); - template.unk4 = sub_81CF0E0(); - template.unk8 = 4; - template.unk6 = sub_81CF10C(); - template.unk9 = 13; - template.unkA = 17; - template.unkB = 1; - template.unkC = 8; - template.unkD = 2; - template.unkE = 1; - template.listFunc.unk10_1 = sub_81CF8E4; - template.unk14 = NULL; - sub_81C81D4(&gUnknown_08623590[1], &template, 0); -} - -static void sub_81CF8E4(struct PokenavMonList * item, u8 * dest) -{ - u8 gender; - u8 level; - u8 * s; - const u8 * genderStr; - - // Mon is in party - if (item->boxId == TOTAL_BOXES_COUNT) - { - struct Pokemon * mon = &gPlayerParty[item->monId]; - gender = GetMonGender(mon); - level = GetLevelFromMonExp(mon); - GetMonData(mon, MON_DATA_NICKNAME, gStringVar3); - } - // Mon is in PC - else - { - struct BoxPokemon * mon = GetBoxedMonPtr(item->boxId, item->monId); - gender = GetBoxMonGender(mon); - level = GetLevelFromBoxMonExp(mon); - GetBoxMonData(mon, MON_DATA_NICKNAME, gStringVar3); - } - - StringGetEnd10(gStringVar3); - dest = sub_81DB494(dest, 1, gStringVar3, 60); - switch (gender) - { - default: - genderStr = sText_NoGenderSymbol; - break; - case MON_MALE: - genderStr = sText_MaleSymbol; - break; - case MON_FEMALE: - genderStr = sText_FemaleSymbol; - break; - } - s = StringCopy(gStringVar1, genderStr); - *s++ = CHAR_SLASH; - *s++ = CHAR_SPECIAL_F9; - *s++ = CHAR_LV_2; - ConvertIntToDecimalStringN(s, level, STR_CONV_MODE_LEFT_ALIGN, 3); - sub_81DB494(dest, 1, gStringVar1, 40); -} diff --git a/src/pokenav_unk_9.c b/src/pokenav_unk_9.c deleted file mode 100644 index 63b4adb30..000000000 --- a/src/pokenav_unk_9.c +++ /dev/null @@ -1,732 +0,0 @@ -#include "global.h" -#include "pokenav.h" -#include "bg.h" -#include "menu.h" -#include "window.h" -#include "sound.h" -#include "string_util.h" -#include "international_string_util.h" -#include "constants/songs.h" - -struct PokenavSub9 -{ - u32 (*unk0)(struct PokenavSub9*); - u32 loopedTaskId; - u16 winid; - s32 unkC; - s32 unk10; - u32 unk14; - u32 unk18; - struct PokenavSub18 *unk1C; -}; - -struct PokenavSub10 -{ - bool32 (*callback)(void); - u32 ltid; - u16 winid; - bool32 unkC; - u8 buff[BG_SCREEN_SIZE]; -}; - -static u32 sub_81CFA68(struct PokenavSub9 *structPtr); -static u32 sub_81CFA88(struct PokenavSub9 *structPtr); -static u32 sub_81CFB08(struct PokenavSub9 *structPtr); -static u32 sub_81CFB10(struct PokenavSub9 *structPtr); -static u32 sub_81CFB8C(s32 state); -static u32 sub_81CFC2C(s32 state); -static u32 sub_81CFC40(s32 state); -static u32 sub_81CFB74(s32 state); -static void sub_81CFCEC(struct PokenavSub9 *structPtr, struct PokenavMonList *item); -static u32 sub_81CFEB8(s32 state); -static bool32 sub_81CFE84(void); -static u32 sub_81CFFFC(s32 state); -static u32 sub_81D0074(s32 state); -static u32 sub_81D00EC(s32 state); -static u32 sub_81D0164(s32 state); -static u32 sub_81D01DC(s32 state); -static u32 sub_81D021C(s32 state); -static void sub_81D02B0(s32 windowId, s32 val1, s32 val2); -static void sub_81D024C(struct PokenavSub10 *ptr); -static void sub_81D0288(struct PokenavSub10 *ptr); -static void sub_81D0304(void); -static void BufferRibbonMonInfoText(struct PokenavMonList *, u8 *); - -static const LoopedTask gUnknown_086235D8[] = -{ - sub_81CFB8C, - sub_81CFC2C, - sub_81CFC40 -}; - -static const u16 gUnknown_086235E4[] = INCBIN_U16("graphics/pokenav/ui_ribbons.gbapal"); -static const u32 gUnknown_08623604[] = INCBIN_U32("graphics/pokenav/ui_ribbons.4bpp.lz"); -static const u32 gUnknown_086236CC[] = INCBIN_U32("graphics/pokenav/ui_ribbons.bin.lz"); -static const u16 gUnknown_08623790[] = INCBIN_U16("graphics/pokenav/8623790.gbapal"); - -static const struct BgTemplate gUnknown_086237B0[] = -{ - { - .bg = 1, - .charBaseIndex = 1, - .mapBaseIndex = 0x06, - .screenSize = 0, - .paletteMode = 0, - .priority = 2, - .baseTile = 0 - }, { - .bg = 2, - .charBaseIndex = 2, - .mapBaseIndex = 0x07, - .screenSize = 0, - .paletteMode = 0, - .priority = 3, - .baseTile = 0 - } -}; - -static const LoopedTask gUnknown_086237B8[] = -{ - NULL, - sub_81CFFFC, - sub_81D0074, - sub_81D00EC, - sub_81D0164, - sub_81D01DC, - sub_81D021C -}; - -static const struct WindowTemplate gUnknown_086237D4 = -{ - .bg = 1, - .tilemapLeft = 1, - .tilemapTop = 6, - .width = 7, - .height = 2, - .paletteNum = 1, - .baseBlock = 20 -}; - -static const u8 sText_MaleSymbol[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_RED}{WHITE}{GREEN}♂{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); -static const u8 sText_FemaleSymbol[] = _("{COLOR_HIGHLIGHT_SHADOW}{LIGHT_GREEN}{WHITE}{BLUE}♀{COLOR_HIGHLIGHT_SHADOW}{DARK_GREY}{WHITE}{LIGHT_GREY}"); -static const u8 sText_NoGenderSymbol[] = _("{UNK_SPACER}"); - -bool32 PokenavCallback_Init_12(void) -{ - struct PokenavSub9 *structPtr = AllocSubstruct(9, sizeof(struct PokenavSub9)); - if (structPtr == NULL) - return FALSE; - - structPtr->unk1C = AllocSubstruct(18, sizeof(struct PokenavSub18)); - if (structPtr->unk1C == NULL) - return FALSE; - - structPtr->unk0 = sub_81CFA68; - structPtr->loopedTaskId = CreateLoopedTask(sub_81CFB74, 1); - structPtr->unk14 = 0; - return TRUE; -} - -bool32 PokenavCallback_Init_14(void) -{ - struct PokenavSub9 *structPtr = AllocSubstruct(9, sizeof(struct PokenavSub9)); - if (structPtr == NULL) - return FALSE; - - structPtr->unk1C = GetSubstructPtr(18); - structPtr->unk0 = sub_81CFA88; - structPtr->unk14 = 1; - return TRUE; -} - -u32 sub_81CFA34(void) -{ - struct PokenavSub9 *structPtr = GetSubstructPtr(9); - return structPtr->unk0(structPtr); -} - -void sub_81CFA48(void) -{ - struct PokenavSub9 *structPtr = GetSubstructPtr(9); - if (!structPtr->unk18) - FreePokenavSubstruct(18); - FreePokenavSubstruct(9); -} - -static u32 sub_81CFA68(struct PokenavSub9 *structPtr) -{ - if (!IsLoopedTaskActive(structPtr->loopedTaskId)) - structPtr->unk0 = sub_81CFA88; - return 0; -} - -static u32 sub_81CFA88(struct PokenavSub9 *structPtr) -{ - if (gMain.newAndRepeatedKeys & DPAD_UP) - return 1; - if (gMain.newAndRepeatedKeys & DPAD_DOWN) - return 2; - if (gMain.newKeys & DPAD_LEFT) - return 3; - if (gMain.newKeys & DPAD_RIGHT) - return 4; - if (gMain.newKeys & B_BUTTON) - { - structPtr->unk18 = 0; - structPtr->unk0 = sub_81CFB08; - return 5; - } - if (gMain.newKeys & A_BUTTON) - { - structPtr->unk1C->unk2 = GetSelectedMatchCall(); - structPtr->unk18 = 1; - structPtr->unk0 = sub_81CFB10; - return 6; - } - return 0; -} - -static u32 sub_81CFB08(struct PokenavSub9 *structPtr) -{ - return POKENAV_MENU_5; -} - -static u32 sub_81CFB10(struct PokenavSub9 *structPtr) -{ - return POKENAV_MENU_D; -} - -static u32 sub_81CFB18(void) -{ - struct PokenavSub9 *structPtr = GetSubstructPtr(9); - return structPtr->unk14; -} - -static struct PokenavMonList * sub_81CFB28(void) -{ - struct PokenavSub9 * ptr = GetSubstructPtr(9); - return ptr->unk1C->unk4; -} - -static s32 sub_81CFB38(void) -{ - struct PokenavSub9 * ptr = GetSubstructPtr(9); - return ptr->unk1C->unk0; -} - -static s32 sub_81CFB48(void) -{ - struct PokenavSub9 * ptr = GetSubstructPtr(9); - s32 idx = GetSelectedMatchCall(); - return ptr->unk1C->unk4[idx].data; -} - -static s32 sub_81CFB64(void) -{ - struct PokenavSub9 * ptr = GetSubstructPtr(9); - return ptr->unk1C->unk2; -} - -static u32 sub_81CFB74(s32 state) -{ - return gUnknown_086235D8[state](state); -} - -static u32 sub_81CFB8C(s32 state) -{ - s32 i; - struct PokenavMonList item; - struct PokenavSub9 * ptr = GetSubstructPtr(9); - - ptr->unk1C->unk0 = 0; - ptr->unk1C->unk2 = 0; - item.boxId = TOTAL_BOXES_COUNT; - for (i = 0; i < PARTY_SIZE; i++) - { - struct Pokemon * pokemon = &gPlayerParty[i]; - if (!GetMonData(pokemon, MON_DATA_SANITY_HAS_SPECIES)) - return LT_INC_AND_CONTINUE; - if (!GetMonData(pokemon, MON_DATA_SANITY_IS_EGG) && !GetMonData(pokemon, MON_DATA_SANITY_IS_BAD_EGG)) - { - u32 ribbonCount = GetMonData(pokemon, MON_DATA_RIBBON_COUNT); - if (ribbonCount != 0) - { - item.monId = i; - item.data = ribbonCount; - sub_81CFCEC(ptr, &item); - } - } - } - - return LT_INC_AND_CONTINUE; -} - -static u32 sub_81CFC2C(s32 state) -{ - struct PokenavSub9 * ptr = GetSubstructPtr(9); - ptr->unk10 = 0; - ptr->unkC = 0; - return LT_INC_AND_CONTINUE; -} - -static u32 sub_81CFC40(s32 state) -{ - struct PokenavSub9 * ptr = GetSubstructPtr(9); - s32 boxId = ptr->unkC; - s32 monId = ptr->unk10; - s32 boxCount = 0; - struct PokenavMonList item; - - while (boxId < TOTAL_BOXES_COUNT) - { - while (monId < IN_BOX_COUNT) - { - if (CheckBoxMonSanityAt(boxId, monId)) - { - u32 ribbonCount = GetBoxMonDataAt(boxId, monId, MON_DATA_RIBBON_COUNT); - if (ribbonCount != 0) - { - item.boxId = boxId; - item.monId = monId; - item.data = ribbonCount; - sub_81CFCEC(ptr, &item); - } - } - boxCount++; - monId++; - if (boxCount > TOTAL_BOXES_COUNT) - { - ptr->unkC = boxId; - ptr->unk10 = monId; - return LT_CONTINUE; - } - } - monId = 0; - boxId++; - } - - ptr->unk14 = 1; - return LT_FINISH; -} - -static void sub_81CFCEC(struct PokenavSub9 *structPtr, struct PokenavMonList *item) -{ - u32 left = 0; - u32 right = structPtr->unk1C->unk0; - u32 insertionIdx = left + (right - left) / 2; - - while (right != insertionIdx) - { - if (item->data > structPtr->unk1C->unk4[insertionIdx].data) - right = insertionIdx; - else - left = insertionIdx + 1; - insertionIdx = left + (right - left) / 2; - } - for (right = structPtr->unk1C->unk0; right > insertionIdx; right--) - structPtr->unk1C->unk4[right] = structPtr->unk1C->unk4[right - 1]; - structPtr->unk1C->unk4[insertionIdx] = *item; - structPtr->unk1C->unk0++; -} - -static bool32 sub_81CFD58(void) -{ - s32 i, j; - - for (i = 0; i < PARTY_SIZE; i++) - { - struct Pokemon * mon = &gPlayerParty[i]; - if (!GetMonData(mon, MON_DATA_SANITY_HAS_SPECIES)) - continue; - if (GetMonData(mon, MON_DATA_SANITY_IS_EGG)) - continue; - if (GetMonData(mon, MON_DATA_RIBBONS)) - return TRUE; - } - - for (i = 0; i < TOTAL_BOXES_COUNT; i++) - { - for (j = 0; j < IN_BOX_COUNT; j++) - { - if (!CheckBoxMonSanityAt(i, j)) - continue; - if (GetBoxMonDataAt(i, j, MON_DATA_RIBBONS)) - return TRUE; - } - } - - return FALSE; -} - -bool32 sub_81CFDD0(void) -{ - struct PokenavSub10 * ptr = AllocSubstruct(10, sizeof(struct PokenavSub10)); - if (ptr == NULL) - return FALSE; - ptr->ltid = CreateLoopedTask(sub_81CFEB8, 1); - ptr->callback = sub_81CFE84; - ptr->unkC = FALSE; - return TRUE; -} - -bool32 sub_81CFE08(void) -{ - struct PokenavSub10 * ptr = AllocSubstruct(10, sizeof(struct PokenavSub10)); - if (ptr == NULL) - return FALSE; - ptr->ltid = CreateLoopedTask(sub_81CFEB8, 1); - ptr->callback = sub_81CFE84; - ptr->unkC = TRUE; - return TRUE; -} - -void sub_81CFE40(s32 idx) -{ - struct PokenavSub10 * ptr = GetSubstructPtr(10); - ptr->ltid = CreateLoopedTask(gUnknown_086237B8[idx], 1); - ptr->callback = sub_81CFE84; -} - -bool32 sub_81CFE70(void) -{ - struct PokenavSub10 * ptr = GetSubstructPtr(10); - return ptr->callback(); -} - -bool32 sub_81CFE84(void) -{ - struct PokenavSub10 * ptr = GetSubstructPtr(10); - return IsLoopedTaskActive(ptr->ltid); -} - -void sub_81CFE98(void) -{ - struct PokenavSub10 * ptr = GetSubstructPtr(10); - sub_81C8234(); - RemoveWindow(ptr->winid); - FreePokenavSubstruct(10); -} - -static u32 sub_81CFEB8(s32 state) -{ - struct PokenavSub10 * unk = GetSubstructPtr(10); - switch (state) - { - case 0: - InitBgTemplates(gUnknown_086237B0, NELEMS(gUnknown_086237B0)); - decompress_and_copy_tile_data_to_vram(1, gUnknown_08623604, 0, 0, 0); - SetBgTilemapBuffer(1, unk->buff); - CopyToBgTilemapBuffer(1, gUnknown_086236CC, 0, 0); - CopyPaletteIntoBufferUnfaded(gUnknown_086235E4, 0x10, 0x20); - CopyBgTilemapBufferToVram(1); - return LT_INC_AND_PAUSE; - case 1: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - if (!sub_81CFB18()) - return LT_PAUSE; - ChangeBgX(1, 0, 0); - ChangeBgY(1, 0, 0); - ShowBg(1); - return LT_INC_AND_PAUSE; - case 2: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - CopyPaletteIntoBufferUnfaded(gUnknown_08623790, 0x20, 0x20); - sub_81D0304(); - return LT_INC_AND_PAUSE; - case 3: - if (sub_81C8224()) - return LT_PAUSE; - sub_81D024C(unk); - return LT_INC_AND_PAUSE; - case 4: - if (free_temp_tile_data_buffers_if_possible()) - return LT_PAUSE; - ShowBg(2); - HideBg(3); - PrintHelpBarText(HELPBAR_RIBBONS_MON_LIST); - sub_81C7AC0(1); - if (!unk->unkC) - { - LoadLeftHeaderGfxForIndex(2); - sub_81C7FA0(2, 1, 0); - } - return LT_INC_AND_PAUSE; - case 5: - if (IsPaletteFadeActive()) - return LT_PAUSE; - if (sub_81C8010()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81CFFFC(s32 state) -{ - struct PokenavSub10 * unk = GetSubstructPtr(10); - switch (state) - { - case 0: - switch (MatchCall_MoveCursorUp()) - { - case 0: - return LT_FINISH; - case 1: - PlaySE(SE_SELECT); - return LT_SET_STATE(2); - case 2: - PlaySE(SE_SELECT); - break; - } - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - // fallthrough - case 2: - sub_81D0288(unk); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81D0074(s32 state) -{ - struct PokenavSub10 * unk = GetSubstructPtr(10); - switch (state) - { - case 0: - switch (MatchCall_MoveCursorDown()) - { - case 0: - return LT_FINISH; - case 1: - PlaySE(SE_SELECT); - return LT_SET_STATE(2); - case 2: - PlaySE(SE_SELECT); - break; - } - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - // fallthrough - case 2: - sub_81D0288(unk); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81D00EC(s32 state) -{ - struct PokenavSub10 * unk = GetSubstructPtr(10); - switch (state) - { - case 0: - switch (MatchCall_PageUp()) - { - case 0: - return LT_FINISH; - case 1: - PlaySE(SE_SELECT); - return LT_SET_STATE(2); - case 2: - PlaySE(SE_SELECT); - break; - } - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - // fallthrough - case 2: - sub_81D0288(unk); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81D0164(s32 state) -{ - struct PokenavSub10 * unk = GetSubstructPtr(10); - switch (state) - { - case 0: - switch (MatchCall_PageDown()) - { - case 0: - return LT_FINISH; - case 1: - PlaySE(SE_SELECT); - return LT_SET_STATE(2); - case 2: - PlaySE(SE_SELECT); - break; - } - return LT_INC_AND_PAUSE; - case 1: - if (sub_81C8630()) - return LT_PAUSE; - // fallthrough - case 2: - sub_81D0288(unk); - return LT_INC_AND_PAUSE; - case 3: - if (IsDma3ManagerBusyWithBgCopy()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static u32 sub_81D01DC(s32 state) -{ - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81C7AC0(0); - sub_81C78A0(); - return LT_INC_AND_PAUSE; - case 1: - if (IsPaletteFadeActive()) - return LT_PAUSE; - if (MainMenuLoopedTaskIsBusy()) - return LT_PAUSE; - sub_81C7FDC(); - break; - } - return LT_FINISH; -} - -static u32 sub_81D021C(s32 state) -{ - switch (state) - { - case 0: - PlaySE(SE_SELECT); - sub_81C7AC0(0); - return LT_INC_AND_PAUSE; - case 1: - if (IsPaletteFadeActive()) - return LT_PAUSE; - break; - } - return LT_FINISH; -} - -static void sub_81D024C(struct PokenavSub10 * ptr) -{ - s32 r2; - ptr->winid = AddWindow(&gUnknown_086237D4); - PutWindowTilemap(ptr->winid); - r2 = sub_81CFB38(); - sub_81D02B0(ptr->winid, 0, r2); - CopyWindowToVram(ptr->winid, 1); - sub_81D0288(ptr); -} - -static void sub_81D0288(struct PokenavSub10 * ptr) -{ - s32 r4 = GetSelectedMatchCall(); - s32 r2 = sub_81CFB38(); - sub_81D02B0(ptr->winid, r4 + 1, r2); - CopyWindowToVram(ptr->winid, 2); -} - -static void sub_81D02B0(s32 windowId, s32 val1, s32 val2) -{ - u8 strbuf[16]; - u32 x; - - u8 * ptr = strbuf; - ptr = ConvertIntToDecimalStringN(ptr, val1, STR_CONV_MODE_RIGHT_ALIGN, 3); - *ptr++ = CHAR_SLASH; - ConvertIntToDecimalStringN(ptr, val2, STR_CONV_MODE_RIGHT_ALIGN, 3); - x = GetStringCenterAlignXOffset(1, strbuf, 56); - AddTextPrinterParameterized(windowId, 1, strbuf, x, 1, 0xFF, NULL); -} - -static void sub_81D0304(void) -{ - struct PokenavListTemplate template; - template.list.monList = sub_81CFB28(); - template.unk4 = sub_81CFB38(); - template.unk8 = 4; - template.unk6 = sub_81CFB64(); - template.unk9 = 13; - template.unkA = 17; - template.unkB = 1; - template.unkC = 8; - template.unkD = 2; - template.unkE = 1; - template.listFunc.unk10_1 = BufferRibbonMonInfoText; - template.unk14 = NULL; - sub_81C81D4(&gUnknown_086237B0[1], &template, 0); -} - -// Buffers the "Nickname gender/level" text for the ribbon mon list -static void BufferRibbonMonInfoText(struct PokenavMonList * item0, u8 * dest) -{ - u8 gender; - u8 level; - u8 * s; - const u8 * genderStr; - struct PokenavMonList * item = item0; - - // Mon is in party - if (item->boxId == TOTAL_BOXES_COUNT) - { - struct Pokemon * mon = &gPlayerParty[item->monId]; - gender = GetMonGender(mon); - level = GetLevelFromMonExp(mon); - GetMonData(mon, MON_DATA_NICKNAME, gStringVar3); - } - // Mon is in PC - else - { - struct BoxPokemon * mon = GetBoxedMonPtr(item->boxId, item->monId); - gender = GetBoxMonGender(mon); - level = GetLevelFromBoxMonExp(mon); - GetBoxMonData(mon, MON_DATA_NICKNAME, gStringVar3); - } - - StringGetEnd10(gStringVar3); - dest = sub_81DB494(dest, 1, gStringVar3, 60); - switch (gender) - { - default: - genderStr = sText_NoGenderSymbol; - break; - case MON_MALE: - genderStr = sText_MaleSymbol; - break; - case MON_FEMALE: - genderStr = sText_FemaleSymbol; - break; - } - - s = StringCopy(gStringVar1, genderStr); - *s++ = CHAR_SLASH; - *s++ = CHAR_SPECIAL_F9; - *s++ = CHAR_LV_2; - ConvertIntToDecimalStringN(s, level, STR_CONV_MODE_LEFT_ALIGN, 3); - dest = sub_81DB494(dest, 1, gStringVar1, 54); - ConvertIntToDecimalStringN(dest, item->data, STR_CONV_MODE_RIGHT_ALIGN, 2); -} diff --git a/sym_bss.txt b/sym_bss.txt index c2a60404e..b08b0d445 100644 --- a/sym_bss.txt +++ b/sym_bss.txt @@ -47,9 +47,9 @@ .include "src/multiboot.o" .include "src/mirage_tower.o" .include "src/berry_fix_program.o" - .include "src/pokenav_unk_7.o" - .include "src/pokenav_unk_10.o" - .include "src/ereader_helpers.o" + .include "src/pokenav_conditions_2.o" + .include "src/pokenav_ribbons_2.o" + .include "src/ereader_helpers.o" .include "src/faraway_island.o" .include "src/m4a_1.o" .include "src/agb_flash.o" -- cgit v1.2.3